diff --git a/LICENSE b/LICENSE new file mode 100644 --- /dev/null +++ b/LICENSE @@ -0,0 +1,30 @@ +Copyright Artem Chirkin (c) 2018 + +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + + * Neither the name of Artem Chirkin nor the names of other + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/Setup.hs b/Setup.hs new file mode 100644 --- /dev/null +++ b/Setup.hs @@ -0,0 +1,2 @@ +import Distribution.Simple +main = defaultMain diff --git a/include/vulkan/vulkan.h b/include/vulkan/vulkan.h new file mode 100644 --- /dev/null +++ b/include/vulkan/vulkan.h @@ -0,0 +1,7047 @@ +#ifndef VULKAN_H_ +#define VULKAN_H_ 1 + +#ifdef __cplusplus +extern "C" { +#endif + +/* +** Copyright (c) 2015-2018 The Khronos Group Inc. +** +** Licensed under the Apache License, Version 2.0 (the "License"); +** you may not use this file except in compliance with the License. +** You may obtain a copy of the License at +** +** http://www.apache.org/licenses/LICENSE-2.0 +** +** Unless required by applicable law or agreed to in writing, software +** distributed under the License is distributed on an "AS IS" BASIS, +** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +** See the License for the specific language governing permissions and +** limitations under the License. +*/ + +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + + +#define VK_VERSION_1_0 1 +#include "vulkan/vk_platform.h" + +#define VK_MAKE_VERSION(major, minor, patch) \ + (((major) << 22) | ((minor) << 12) | (patch)) + +// DEPRECATED: This define has been removed. Specific version defines (e.g. VK_API_VERSION_1_0), or the VK_MAKE_VERSION macro, should be used instead. +//#define VK_API_VERSION VK_MAKE_VERSION(1, 0, 0) // Patch version should always be set to 0 + +// Vulkan 1.0 version number +#define VK_API_VERSION_1_0 VK_MAKE_VERSION(1, 0, 0)// Patch version should always be set to 0 + +#define VK_VERSION_MAJOR(version) ((uint32_t)(version) >> 22) +#define VK_VERSION_MINOR(version) (((uint32_t)(version) >> 12) & 0x3ff) +#define VK_VERSION_PATCH(version) ((uint32_t)(version) & 0xfff) +// Version of this file +#define VK_HEADER_VERSION 69 + + +#define VK_NULL_HANDLE 0 + + + +#define VK_DEFINE_HANDLE(object) typedef struct object##_T* object; + + +#if !defined(VK_DEFINE_NON_DISPATCHABLE_HANDLE) +#if defined(__LP64__) || defined(_WIN64) || (defined(__x86_64__) && !defined(__ILP32__) ) || defined(_M_X64) || defined(__ia64) || defined (_M_IA64) || defined(__aarch64__) || defined(__powerpc64__) + #define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef struct object##_T *object; +#else + #define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef uint64_t object; +#endif +#endif + + + +typedef uint32_t VkFlags; +typedef uint32_t VkBool32; +typedef uint64_t VkDeviceSize; +typedef uint32_t VkSampleMask; + +VK_DEFINE_HANDLE(VkInstance) +VK_DEFINE_HANDLE(VkPhysicalDevice) +VK_DEFINE_HANDLE(VkDevice) +VK_DEFINE_HANDLE(VkQueue) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSemaphore) +VK_DEFINE_HANDLE(VkCommandBuffer) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkFence) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDeviceMemory) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkBuffer) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkImage) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkEvent) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkQueryPool) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkBufferView) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkImageView) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkShaderModule) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineCache) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineLayout) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkRenderPass) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipeline) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorSetLayout) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSampler) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorPool) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorSet) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkFramebuffer) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkCommandPool) + +#define VK_LOD_CLAMP_NONE 1000.0f +#define VK_REMAINING_MIP_LEVELS (~0U) +#define VK_REMAINING_ARRAY_LAYERS (~0U) +#define VK_WHOLE_SIZE (~0ULL) +#define VK_ATTACHMENT_UNUSED (~0U) +#define VK_TRUE 1 +#define VK_FALSE 0 +#define VK_QUEUE_FAMILY_IGNORED (~0U) +#define VK_SUBPASS_EXTERNAL (~0U) +#define VK_MAX_PHYSICAL_DEVICE_NAME_SIZE 256 +#define VK_UUID_SIZE 16 +#define VK_MAX_MEMORY_TYPES 32 +#define VK_MAX_MEMORY_HEAPS 16 +#define VK_MAX_EXTENSION_NAME_SIZE 256 +#define VK_MAX_DESCRIPTION_SIZE 256 + + +typedef enum VkPipelineCacheHeaderVersion { + VK_PIPELINE_CACHE_HEADER_VERSION_ONE = 1, + VK_PIPELINE_CACHE_HEADER_VERSION_BEGIN_RANGE = VK_PIPELINE_CACHE_HEADER_VERSION_ONE, + VK_PIPELINE_CACHE_HEADER_VERSION_END_RANGE = VK_PIPELINE_CACHE_HEADER_VERSION_ONE, + VK_PIPELINE_CACHE_HEADER_VERSION_RANGE_SIZE = (VK_PIPELINE_CACHE_HEADER_VERSION_ONE - VK_PIPELINE_CACHE_HEADER_VERSION_ONE + 1), + VK_PIPELINE_CACHE_HEADER_VERSION_MAX_ENUM = 0x7FFFFFFF +} VkPipelineCacheHeaderVersion; + +typedef enum VkResult { + VK_SUCCESS = 0, + VK_NOT_READY = 1, + VK_TIMEOUT = 2, + VK_EVENT_SET = 3, + VK_EVENT_RESET = 4, + VK_INCOMPLETE = 5, + VK_ERROR_OUT_OF_HOST_MEMORY = -1, + VK_ERROR_OUT_OF_DEVICE_MEMORY = -2, + VK_ERROR_INITIALIZATION_FAILED = -3, + VK_ERROR_DEVICE_LOST = -4, + VK_ERROR_MEMORY_MAP_FAILED = -5, + VK_ERROR_LAYER_NOT_PRESENT = -6, + VK_ERROR_EXTENSION_NOT_PRESENT = -7, + VK_ERROR_FEATURE_NOT_PRESENT = -8, + VK_ERROR_INCOMPATIBLE_DRIVER = -9, + VK_ERROR_TOO_MANY_OBJECTS = -10, + VK_ERROR_FORMAT_NOT_SUPPORTED = -11, + VK_ERROR_FRAGMENTED_POOL = -12, + VK_ERROR_SURFACE_LOST_KHR = -1000000000, + VK_ERROR_NATIVE_WINDOW_IN_USE_KHR = -1000000001, + VK_SUBOPTIMAL_KHR = 1000001003, + VK_ERROR_OUT_OF_DATE_KHR = -1000001004, + VK_ERROR_INCOMPATIBLE_DISPLAY_KHR = -1000003001, + VK_ERROR_VALIDATION_FAILED_EXT = -1000011001, + VK_ERROR_INVALID_SHADER_NV = -1000012000, + VK_ERROR_OUT_OF_POOL_MEMORY_KHR = -1000069000, + VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR = -1000072003, + VK_ERROR_NOT_PERMITTED_EXT = -1000174001, + VK_RESULT_BEGIN_RANGE = VK_ERROR_FRAGMENTED_POOL, + VK_RESULT_END_RANGE = VK_INCOMPLETE, + VK_RESULT_RANGE_SIZE = (VK_INCOMPLETE - VK_ERROR_FRAGMENTED_POOL + 1), + VK_RESULT_MAX_ENUM = 0x7FFFFFFF +} VkResult; + +typedef enum VkStructureType { + VK_STRUCTURE_TYPE_APPLICATION_INFO = 0, + VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO = 1, + VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO = 2, + VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO = 3, + VK_STRUCTURE_TYPE_SUBMIT_INFO = 4, + VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO = 5, + VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE = 6, + VK_STRUCTURE_TYPE_BIND_SPARSE_INFO = 7, + VK_STRUCTURE_TYPE_FENCE_CREATE_INFO = 8, + VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO = 9, + VK_STRUCTURE_TYPE_EVENT_CREATE_INFO = 10, + VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO = 11, + VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO = 12, + VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO = 13, + VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO = 14, + VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO = 15, + VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO = 16, + VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO = 17, + VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO = 18, + VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO = 19, + VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO = 20, + VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO = 21, + VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO = 22, + VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO = 23, + VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO = 24, + VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO = 25, + VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO = 26, + VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO = 27, + VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO = 28, + VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO = 29, + VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO = 30, + VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO = 31, + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO = 32, + VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO = 33, + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO = 34, + VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET = 35, + VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET = 36, + VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO = 37, + VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO = 38, + VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO = 39, + VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO = 40, + VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO = 41, + VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO = 42, + VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO = 43, + VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER = 44, + VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER = 45, + VK_STRUCTURE_TYPE_MEMORY_BARRIER = 46, + VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO = 47, + VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO = 48, + VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR = 1000001000, + VK_STRUCTURE_TYPE_PRESENT_INFO_KHR = 1000001001, + VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR = 1000002000, + VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR = 1000002001, + VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR = 1000003000, + VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR = 1000004000, + VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR = 1000005000, + VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR = 1000006000, + VK_STRUCTURE_TYPE_MIR_SURFACE_CREATE_INFO_KHR = 1000007000, + VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR = 1000008000, + VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR = 1000009000, + VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT = 1000011000, + VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD = 1000018000, + VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT = 1000022000, + VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT = 1000022001, + VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT = 1000022002, + VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV = 1000026000, + VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV = 1000026001, + VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV = 1000026002, + VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD = 1000041000, + VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO_KHX = 1000053000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHX = 1000053001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHX = 1000053002, + VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV = 1000056000, + VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV = 1000056001, + VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV = 1000057000, + VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV = 1000057001, + VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV = 1000058000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR = 1000059000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR = 1000059001, + VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR = 1000059002, + VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2_KHR = 1000059003, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHR = 1000059004, + VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2_KHR = 1000059005, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2_KHR = 1000059006, + VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2_KHR = 1000059007, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2_KHR = 1000059008, + VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO_KHX = 1000060000, + VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO_KHX = 1000060003, + VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO_KHX = 1000060004, + VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO_KHX = 1000060005, + VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO_KHX = 1000060006, + VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHX = 1000060010, + VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO_KHX = 1000060013, + VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO_KHX = 1000060014, + VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHX = 1000060007, + VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHX = 1000060008, + VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHX = 1000060009, + VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHX = 1000060011, + VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHX = 1000060012, + VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT = 1000061000, + VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN = 1000062000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES_KHX = 1000070000, + VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO_KHX = 1000070001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHR = 1000071000, + VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHR = 1000071001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHR = 1000071002, + VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES_KHR = 1000071003, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHR = 1000071004, + VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHR = 1000072000, + VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHR = 1000072001, + VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHR = 1000072002, + VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR = 1000073000, + VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR = 1000073001, + VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR = 1000073002, + VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR = 1000073003, + VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR = 1000074000, + VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR = 1000074001, + VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR = 1000074002, + VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR = 1000075000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHR = 1000076000, + VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES_KHR = 1000076001, + VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHR = 1000077000, + VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR = 1000078000, + VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR = 1000078001, + VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR = 1000078002, + VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR = 1000078003, + VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR = 1000079000, + VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR = 1000079001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR = 1000080000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR = 1000083000, + VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR = 1000084000, + VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR = 1000085000, + VK_STRUCTURE_TYPE_OBJECT_TABLE_CREATE_INFO_NVX = 1000086000, + VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NVX = 1000086001, + VK_STRUCTURE_TYPE_CMD_PROCESS_COMMANDS_INFO_NVX = 1000086002, + VK_STRUCTURE_TYPE_CMD_RESERVE_SPACE_FOR_COMMANDS_INFO_NVX = 1000086003, + VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_LIMITS_NVX = 1000086004, + VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_FEATURES_NVX = 1000086005, + VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV = 1000087000, + VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT = 1000090000, + VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT = 1000091000, + VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT = 1000091001, + VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT = 1000091002, + VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT = 1000091003, + VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE = 1000092000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX = 1000097000, + VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV = 1000098000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT = 1000099000, + VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT = 1000099001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT = 1000101000, + VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT = 1000101001, + VK_STRUCTURE_TYPE_HDR_METADATA_EXT = 1000105000, + VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR = 1000111000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO_KHR = 1000112000, + VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES_KHR = 1000112001, + VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO_KHR = 1000113000, + VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR = 1000114000, + VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR = 1000114001, + VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR = 1000114002, + VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR = 1000115000, + VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR = 1000115001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES_KHR = 1000117000, + VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO_KHR = 1000117001, + VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO_KHR = 1000117002, + VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO_KHR = 1000117003, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR = 1000119000, + VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR = 1000119001, + VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR = 1000119002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES_KHR = 1000120000, + VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK = 1000122000, + VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK = 1000123000, + VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR = 1000127000, + VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR = 1000127001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT = 1000130000, + VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT = 1000130001, + VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT = 1000143000, + VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT = 1000143001, + VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT = 1000143002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT = 1000143003, + VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT = 1000143004, + VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2_KHR = 1000146000, + VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2_KHR = 1000146001, + VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2_KHR = 1000146002, + VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR = 1000146003, + VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2_KHR = 1000146004, + VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO_KHR = 1000147000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT = 1000148000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT = 1000148001, + VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT = 1000148002, + VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV = 1000149000, + VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV = 1000152000, + VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO_KHR = 1000156000, + VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO_KHR = 1000156001, + VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO_KHR = 1000156002, + VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO_KHR = 1000156003, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES_KHR = 1000156004, + VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES_KHR = 1000156005, + VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO_KHR = 1000157000, + VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO_KHR = 1000157001, + VK_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT = 1000160000, + VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT = 1000160001, + VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT = 1000174000, + VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT = 1000178000, + VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT = 1000178001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT = 1000178002, + VK_STRUCTURE_TYPE_BEGIN_RANGE = VK_STRUCTURE_TYPE_APPLICATION_INFO, + VK_STRUCTURE_TYPE_END_RANGE = VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO, + VK_STRUCTURE_TYPE_RANGE_SIZE = (VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO - VK_STRUCTURE_TYPE_APPLICATION_INFO + 1), + VK_STRUCTURE_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkStructureType; + +typedef enum VkSystemAllocationScope { + VK_SYSTEM_ALLOCATION_SCOPE_COMMAND = 0, + VK_SYSTEM_ALLOCATION_SCOPE_OBJECT = 1, + VK_SYSTEM_ALLOCATION_SCOPE_CACHE = 2, + VK_SYSTEM_ALLOCATION_SCOPE_DEVICE = 3, + VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE = 4, + VK_SYSTEM_ALLOCATION_SCOPE_BEGIN_RANGE = VK_SYSTEM_ALLOCATION_SCOPE_COMMAND, + VK_SYSTEM_ALLOCATION_SCOPE_END_RANGE = VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE, + VK_SYSTEM_ALLOCATION_SCOPE_RANGE_SIZE = (VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE - VK_SYSTEM_ALLOCATION_SCOPE_COMMAND + 1), + VK_SYSTEM_ALLOCATION_SCOPE_MAX_ENUM = 0x7FFFFFFF +} VkSystemAllocationScope; + +typedef enum VkInternalAllocationType { + VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE = 0, + VK_INTERNAL_ALLOCATION_TYPE_BEGIN_RANGE = VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE, + VK_INTERNAL_ALLOCATION_TYPE_END_RANGE = VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE, + VK_INTERNAL_ALLOCATION_TYPE_RANGE_SIZE = (VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE - VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE + 1), + VK_INTERNAL_ALLOCATION_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkInternalAllocationType; + +typedef enum VkFormat { + VK_FORMAT_UNDEFINED = 0, + VK_FORMAT_R4G4_UNORM_PACK8 = 1, + VK_FORMAT_R4G4B4A4_UNORM_PACK16 = 2, + VK_FORMAT_B4G4R4A4_UNORM_PACK16 = 3, + VK_FORMAT_R5G6B5_UNORM_PACK16 = 4, + VK_FORMAT_B5G6R5_UNORM_PACK16 = 5, + VK_FORMAT_R5G5B5A1_UNORM_PACK16 = 6, + VK_FORMAT_B5G5R5A1_UNORM_PACK16 = 7, + VK_FORMAT_A1R5G5B5_UNORM_PACK16 = 8, + VK_FORMAT_R8_UNORM = 9, + VK_FORMAT_R8_SNORM = 10, + VK_FORMAT_R8_USCALED = 11, + VK_FORMAT_R8_SSCALED = 12, + VK_FORMAT_R8_UINT = 13, + VK_FORMAT_R8_SINT = 14, + VK_FORMAT_R8_SRGB = 15, + VK_FORMAT_R8G8_UNORM = 16, + VK_FORMAT_R8G8_SNORM = 17, + VK_FORMAT_R8G8_USCALED = 18, + VK_FORMAT_R8G8_SSCALED = 19, + VK_FORMAT_R8G8_UINT = 20, + VK_FORMAT_R8G8_SINT = 21, + VK_FORMAT_R8G8_SRGB = 22, + VK_FORMAT_R8G8B8_UNORM = 23, + VK_FORMAT_R8G8B8_SNORM = 24, + VK_FORMAT_R8G8B8_USCALED = 25, + VK_FORMAT_R8G8B8_SSCALED = 26, + VK_FORMAT_R8G8B8_UINT = 27, + VK_FORMAT_R8G8B8_SINT = 28, + VK_FORMAT_R8G8B8_SRGB = 29, + VK_FORMAT_B8G8R8_UNORM = 30, + VK_FORMAT_B8G8R8_SNORM = 31, + VK_FORMAT_B8G8R8_USCALED = 32, + VK_FORMAT_B8G8R8_SSCALED = 33, + VK_FORMAT_B8G8R8_UINT = 34, + VK_FORMAT_B8G8R8_SINT = 35, + VK_FORMAT_B8G8R8_SRGB = 36, + VK_FORMAT_R8G8B8A8_UNORM = 37, + VK_FORMAT_R8G8B8A8_SNORM = 38, + VK_FORMAT_R8G8B8A8_USCALED = 39, + VK_FORMAT_R8G8B8A8_SSCALED = 40, + VK_FORMAT_R8G8B8A8_UINT = 41, + VK_FORMAT_R8G8B8A8_SINT = 42, + VK_FORMAT_R8G8B8A8_SRGB = 43, + VK_FORMAT_B8G8R8A8_UNORM = 44, + VK_FORMAT_B8G8R8A8_SNORM = 45, + VK_FORMAT_B8G8R8A8_USCALED = 46, + VK_FORMAT_B8G8R8A8_SSCALED = 47, + VK_FORMAT_B8G8R8A8_UINT = 48, + VK_FORMAT_B8G8R8A8_SINT = 49, + VK_FORMAT_B8G8R8A8_SRGB = 50, + VK_FORMAT_A8B8G8R8_UNORM_PACK32 = 51, + VK_FORMAT_A8B8G8R8_SNORM_PACK32 = 52, + VK_FORMAT_A8B8G8R8_USCALED_PACK32 = 53, + VK_FORMAT_A8B8G8R8_SSCALED_PACK32 = 54, + VK_FORMAT_A8B8G8R8_UINT_PACK32 = 55, + VK_FORMAT_A8B8G8R8_SINT_PACK32 = 56, + VK_FORMAT_A8B8G8R8_SRGB_PACK32 = 57, + VK_FORMAT_A2R10G10B10_UNORM_PACK32 = 58, + VK_FORMAT_A2R10G10B10_SNORM_PACK32 = 59, + VK_FORMAT_A2R10G10B10_USCALED_PACK32 = 60, + VK_FORMAT_A2R10G10B10_SSCALED_PACK32 = 61, + VK_FORMAT_A2R10G10B10_UINT_PACK32 = 62, + VK_FORMAT_A2R10G10B10_SINT_PACK32 = 63, + VK_FORMAT_A2B10G10R10_UNORM_PACK32 = 64, + VK_FORMAT_A2B10G10R10_SNORM_PACK32 = 65, + VK_FORMAT_A2B10G10R10_USCALED_PACK32 = 66, + VK_FORMAT_A2B10G10R10_SSCALED_PACK32 = 67, + VK_FORMAT_A2B10G10R10_UINT_PACK32 = 68, + VK_FORMAT_A2B10G10R10_SINT_PACK32 = 69, + VK_FORMAT_R16_UNORM = 70, + VK_FORMAT_R16_SNORM = 71, + VK_FORMAT_R16_USCALED = 72, + VK_FORMAT_R16_SSCALED = 73, + VK_FORMAT_R16_UINT = 74, + VK_FORMAT_R16_SINT = 75, + VK_FORMAT_R16_SFLOAT = 76, + VK_FORMAT_R16G16_UNORM = 77, + VK_FORMAT_R16G16_SNORM = 78, + VK_FORMAT_R16G16_USCALED = 79, + VK_FORMAT_R16G16_SSCALED = 80, + VK_FORMAT_R16G16_UINT = 81, + VK_FORMAT_R16G16_SINT = 82, + VK_FORMAT_R16G16_SFLOAT = 83, + VK_FORMAT_R16G16B16_UNORM = 84, + VK_FORMAT_R16G16B16_SNORM = 85, + VK_FORMAT_R16G16B16_USCALED = 86, + VK_FORMAT_R16G16B16_SSCALED = 87, + VK_FORMAT_R16G16B16_UINT = 88, + VK_FORMAT_R16G16B16_SINT = 89, + VK_FORMAT_R16G16B16_SFLOAT = 90, + VK_FORMAT_R16G16B16A16_UNORM = 91, + VK_FORMAT_R16G16B16A16_SNORM = 92, + VK_FORMAT_R16G16B16A16_USCALED = 93, + VK_FORMAT_R16G16B16A16_SSCALED = 94, + VK_FORMAT_R16G16B16A16_UINT = 95, + VK_FORMAT_R16G16B16A16_SINT = 96, + VK_FORMAT_R16G16B16A16_SFLOAT = 97, + VK_FORMAT_R32_UINT = 98, + VK_FORMAT_R32_SINT = 99, + VK_FORMAT_R32_SFLOAT = 100, + VK_FORMAT_R32G32_UINT = 101, + VK_FORMAT_R32G32_SINT = 102, + VK_FORMAT_R32G32_SFLOAT = 103, + VK_FORMAT_R32G32B32_UINT = 104, + VK_FORMAT_R32G32B32_SINT = 105, + VK_FORMAT_R32G32B32_SFLOAT = 106, + VK_FORMAT_R32G32B32A32_UINT = 107, + VK_FORMAT_R32G32B32A32_SINT = 108, + VK_FORMAT_R32G32B32A32_SFLOAT = 109, + VK_FORMAT_R64_UINT = 110, + VK_FORMAT_R64_SINT = 111, + VK_FORMAT_R64_SFLOAT = 112, + VK_FORMAT_R64G64_UINT = 113, + VK_FORMAT_R64G64_SINT = 114, + VK_FORMAT_R64G64_SFLOAT = 115, + VK_FORMAT_R64G64B64_UINT = 116, + VK_FORMAT_R64G64B64_SINT = 117, + VK_FORMAT_R64G64B64_SFLOAT = 118, + VK_FORMAT_R64G64B64A64_UINT = 119, + VK_FORMAT_R64G64B64A64_SINT = 120, + VK_FORMAT_R64G64B64A64_SFLOAT = 121, + VK_FORMAT_B10G11R11_UFLOAT_PACK32 = 122, + VK_FORMAT_E5B9G9R9_UFLOAT_PACK32 = 123, + VK_FORMAT_D16_UNORM = 124, + VK_FORMAT_X8_D24_UNORM_PACK32 = 125, + VK_FORMAT_D32_SFLOAT = 126, + VK_FORMAT_S8_UINT = 127, + VK_FORMAT_D16_UNORM_S8_UINT = 128, + VK_FORMAT_D24_UNORM_S8_UINT = 129, + VK_FORMAT_D32_SFLOAT_S8_UINT = 130, + VK_FORMAT_BC1_RGB_UNORM_BLOCK = 131, + VK_FORMAT_BC1_RGB_SRGB_BLOCK = 132, + VK_FORMAT_BC1_RGBA_UNORM_BLOCK = 133, + VK_FORMAT_BC1_RGBA_SRGB_BLOCK = 134, + VK_FORMAT_BC2_UNORM_BLOCK = 135, + VK_FORMAT_BC2_SRGB_BLOCK = 136, + VK_FORMAT_BC3_UNORM_BLOCK = 137, + VK_FORMAT_BC3_SRGB_BLOCK = 138, + VK_FORMAT_BC4_UNORM_BLOCK = 139, + VK_FORMAT_BC4_SNORM_BLOCK = 140, + VK_FORMAT_BC5_UNORM_BLOCK = 141, + VK_FORMAT_BC5_SNORM_BLOCK = 142, + VK_FORMAT_BC6H_UFLOAT_BLOCK = 143, + VK_FORMAT_BC6H_SFLOAT_BLOCK = 144, + VK_FORMAT_BC7_UNORM_BLOCK = 145, + VK_FORMAT_BC7_SRGB_BLOCK = 146, + VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK = 147, + VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK = 148, + VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK = 149, + VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK = 150, + VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK = 151, + VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK = 152, + VK_FORMAT_EAC_R11_UNORM_BLOCK = 153, + VK_FORMAT_EAC_R11_SNORM_BLOCK = 154, + VK_FORMAT_EAC_R11G11_UNORM_BLOCK = 155, + VK_FORMAT_EAC_R11G11_SNORM_BLOCK = 156, + VK_FORMAT_ASTC_4x4_UNORM_BLOCK = 157, + VK_FORMAT_ASTC_4x4_SRGB_BLOCK = 158, + VK_FORMAT_ASTC_5x4_UNORM_BLOCK = 159, + VK_FORMAT_ASTC_5x4_SRGB_BLOCK = 160, + VK_FORMAT_ASTC_5x5_UNORM_BLOCK = 161, + VK_FORMAT_ASTC_5x5_SRGB_BLOCK = 162, + VK_FORMAT_ASTC_6x5_UNORM_BLOCK = 163, + VK_FORMAT_ASTC_6x5_SRGB_BLOCK = 164, + VK_FORMAT_ASTC_6x6_UNORM_BLOCK = 165, + VK_FORMAT_ASTC_6x6_SRGB_BLOCK = 166, + VK_FORMAT_ASTC_8x5_UNORM_BLOCK = 167, + VK_FORMAT_ASTC_8x5_SRGB_BLOCK = 168, + VK_FORMAT_ASTC_8x6_UNORM_BLOCK = 169, + VK_FORMAT_ASTC_8x6_SRGB_BLOCK = 170, + VK_FORMAT_ASTC_8x8_UNORM_BLOCK = 171, + VK_FORMAT_ASTC_8x8_SRGB_BLOCK = 172, + VK_FORMAT_ASTC_10x5_UNORM_BLOCK = 173, + VK_FORMAT_ASTC_10x5_SRGB_BLOCK = 174, + VK_FORMAT_ASTC_10x6_UNORM_BLOCK = 175, + VK_FORMAT_ASTC_10x6_SRGB_BLOCK = 176, + VK_FORMAT_ASTC_10x8_UNORM_BLOCK = 177, + VK_FORMAT_ASTC_10x8_SRGB_BLOCK = 178, + VK_FORMAT_ASTC_10x10_UNORM_BLOCK = 179, + VK_FORMAT_ASTC_10x10_SRGB_BLOCK = 180, + VK_FORMAT_ASTC_12x10_UNORM_BLOCK = 181, + VK_FORMAT_ASTC_12x10_SRGB_BLOCK = 182, + VK_FORMAT_ASTC_12x12_UNORM_BLOCK = 183, + VK_FORMAT_ASTC_12x12_SRGB_BLOCK = 184, + VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG = 1000054000, + VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG = 1000054001, + VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG = 1000054002, + VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG = 1000054003, + VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG = 1000054004, + VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG = 1000054005, + VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG = 1000054006, + VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG = 1000054007, + VK_FORMAT_G8B8G8R8_422_UNORM_KHR = 1000156000, + VK_FORMAT_B8G8R8G8_422_UNORM_KHR = 1000156001, + VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM_KHR = 1000156002, + VK_FORMAT_G8_B8R8_2PLANE_420_UNORM_KHR = 1000156003, + VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM_KHR = 1000156004, + VK_FORMAT_G8_B8R8_2PLANE_422_UNORM_KHR = 1000156005, + VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM_KHR = 1000156006, + VK_FORMAT_R10X6_UNORM_PACK16_KHR = 1000156007, + VK_FORMAT_R10X6G10X6_UNORM_2PACK16_KHR = 1000156008, + VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16_KHR = 1000156009, + VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16_KHR = 1000156010, + VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16_KHR = 1000156011, + VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16_KHR = 1000156012, + VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16_KHR = 1000156013, + VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16_KHR = 1000156014, + VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16_KHR = 1000156015, + VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16_KHR = 1000156016, + VK_FORMAT_R12X4_UNORM_PACK16_KHR = 1000156017, + VK_FORMAT_R12X4G12X4_UNORM_2PACK16_KHR = 1000156018, + VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16_KHR = 1000156019, + VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16_KHR = 1000156020, + VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16_KHR = 1000156021, + VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16_KHR = 1000156022, + VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16_KHR = 1000156023, + VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16_KHR = 1000156024, + VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16_KHR = 1000156025, + VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16_KHR = 1000156026, + VK_FORMAT_G16B16G16R16_422_UNORM_KHR = 1000156027, + VK_FORMAT_B16G16R16G16_422_UNORM_KHR = 1000156028, + VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM_KHR = 1000156029, + VK_FORMAT_G16_B16R16_2PLANE_420_UNORM_KHR = 1000156030, + VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM_KHR = 1000156031, + VK_FORMAT_G16_B16R16_2PLANE_422_UNORM_KHR = 1000156032, + VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM_KHR = 1000156033, + VK_FORMAT_BEGIN_RANGE = VK_FORMAT_UNDEFINED, + VK_FORMAT_END_RANGE = VK_FORMAT_ASTC_12x12_SRGB_BLOCK, + VK_FORMAT_RANGE_SIZE = (VK_FORMAT_ASTC_12x12_SRGB_BLOCK - VK_FORMAT_UNDEFINED + 1), + VK_FORMAT_MAX_ENUM = 0x7FFFFFFF +} VkFormat; + +typedef enum VkImageType { + VK_IMAGE_TYPE_1D = 0, + VK_IMAGE_TYPE_2D = 1, + VK_IMAGE_TYPE_3D = 2, + VK_IMAGE_TYPE_BEGIN_RANGE = VK_IMAGE_TYPE_1D, + VK_IMAGE_TYPE_END_RANGE = VK_IMAGE_TYPE_3D, + VK_IMAGE_TYPE_RANGE_SIZE = (VK_IMAGE_TYPE_3D - VK_IMAGE_TYPE_1D + 1), + VK_IMAGE_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkImageType; + +typedef enum VkImageTiling { + VK_IMAGE_TILING_OPTIMAL = 0, + VK_IMAGE_TILING_LINEAR = 1, + VK_IMAGE_TILING_BEGIN_RANGE = VK_IMAGE_TILING_OPTIMAL, + VK_IMAGE_TILING_END_RANGE = VK_IMAGE_TILING_LINEAR, + VK_IMAGE_TILING_RANGE_SIZE = (VK_IMAGE_TILING_LINEAR - VK_IMAGE_TILING_OPTIMAL + 1), + VK_IMAGE_TILING_MAX_ENUM = 0x7FFFFFFF +} VkImageTiling; + +typedef enum VkPhysicalDeviceType { + VK_PHYSICAL_DEVICE_TYPE_OTHER = 0, + VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU = 1, + VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU = 2, + VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU = 3, + VK_PHYSICAL_DEVICE_TYPE_CPU = 4, + VK_PHYSICAL_DEVICE_TYPE_BEGIN_RANGE = VK_PHYSICAL_DEVICE_TYPE_OTHER, + VK_PHYSICAL_DEVICE_TYPE_END_RANGE = VK_PHYSICAL_DEVICE_TYPE_CPU, + VK_PHYSICAL_DEVICE_TYPE_RANGE_SIZE = (VK_PHYSICAL_DEVICE_TYPE_CPU - VK_PHYSICAL_DEVICE_TYPE_OTHER + 1), + VK_PHYSICAL_DEVICE_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkPhysicalDeviceType; + +typedef enum VkQueryType { + VK_QUERY_TYPE_OCCLUSION = 0, + VK_QUERY_TYPE_PIPELINE_STATISTICS = 1, + VK_QUERY_TYPE_TIMESTAMP = 2, + VK_QUERY_TYPE_BEGIN_RANGE = VK_QUERY_TYPE_OCCLUSION, + VK_QUERY_TYPE_END_RANGE = VK_QUERY_TYPE_TIMESTAMP, + VK_QUERY_TYPE_RANGE_SIZE = (VK_QUERY_TYPE_TIMESTAMP - VK_QUERY_TYPE_OCCLUSION + 1), + VK_QUERY_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkQueryType; + +typedef enum VkSharingMode { + VK_SHARING_MODE_EXCLUSIVE = 0, + VK_SHARING_MODE_CONCURRENT = 1, + VK_SHARING_MODE_BEGIN_RANGE = VK_SHARING_MODE_EXCLUSIVE, + VK_SHARING_MODE_END_RANGE = VK_SHARING_MODE_CONCURRENT, + VK_SHARING_MODE_RANGE_SIZE = (VK_SHARING_MODE_CONCURRENT - VK_SHARING_MODE_EXCLUSIVE + 1), + VK_SHARING_MODE_MAX_ENUM = 0x7FFFFFFF +} VkSharingMode; + +typedef enum VkImageLayout { + VK_IMAGE_LAYOUT_UNDEFINED = 0, + VK_IMAGE_LAYOUT_GENERAL = 1, + VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL = 2, + VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL = 3, + VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL = 4, + VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL = 5, + VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL = 6, + VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL = 7, + VK_IMAGE_LAYOUT_PREINITIALIZED = 8, + VK_IMAGE_LAYOUT_PRESENT_SRC_KHR = 1000001002, + VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR = 1000111000, + VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR = 1000117000, + VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL_KHR = 1000117001, + VK_IMAGE_LAYOUT_BEGIN_RANGE = VK_IMAGE_LAYOUT_UNDEFINED, + VK_IMAGE_LAYOUT_END_RANGE = VK_IMAGE_LAYOUT_PREINITIALIZED, + VK_IMAGE_LAYOUT_RANGE_SIZE = (VK_IMAGE_LAYOUT_PREINITIALIZED - VK_IMAGE_LAYOUT_UNDEFINED + 1), + VK_IMAGE_LAYOUT_MAX_ENUM = 0x7FFFFFFF +} VkImageLayout; + +typedef enum VkImageViewType { + VK_IMAGE_VIEW_TYPE_1D = 0, + VK_IMAGE_VIEW_TYPE_2D = 1, + VK_IMAGE_VIEW_TYPE_3D = 2, + VK_IMAGE_VIEW_TYPE_CUBE = 3, + VK_IMAGE_VIEW_TYPE_1D_ARRAY = 4, + VK_IMAGE_VIEW_TYPE_2D_ARRAY = 5, + VK_IMAGE_VIEW_TYPE_CUBE_ARRAY = 6, + VK_IMAGE_VIEW_TYPE_BEGIN_RANGE = VK_IMAGE_VIEW_TYPE_1D, + VK_IMAGE_VIEW_TYPE_END_RANGE = VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, + VK_IMAGE_VIEW_TYPE_RANGE_SIZE = (VK_IMAGE_VIEW_TYPE_CUBE_ARRAY - VK_IMAGE_VIEW_TYPE_1D + 1), + VK_IMAGE_VIEW_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkImageViewType; + +typedef enum VkComponentSwizzle { + VK_COMPONENT_SWIZZLE_IDENTITY = 0, + VK_COMPONENT_SWIZZLE_ZERO = 1, + VK_COMPONENT_SWIZZLE_ONE = 2, + VK_COMPONENT_SWIZZLE_R = 3, + VK_COMPONENT_SWIZZLE_G = 4, + VK_COMPONENT_SWIZZLE_B = 5, + VK_COMPONENT_SWIZZLE_A = 6, + VK_COMPONENT_SWIZZLE_BEGIN_RANGE = VK_COMPONENT_SWIZZLE_IDENTITY, + VK_COMPONENT_SWIZZLE_END_RANGE = VK_COMPONENT_SWIZZLE_A, + VK_COMPONENT_SWIZZLE_RANGE_SIZE = (VK_COMPONENT_SWIZZLE_A - VK_COMPONENT_SWIZZLE_IDENTITY + 1), + VK_COMPONENT_SWIZZLE_MAX_ENUM = 0x7FFFFFFF +} VkComponentSwizzle; + +typedef enum VkVertexInputRate { + VK_VERTEX_INPUT_RATE_VERTEX = 0, + VK_VERTEX_INPUT_RATE_INSTANCE = 1, + VK_VERTEX_INPUT_RATE_BEGIN_RANGE = VK_VERTEX_INPUT_RATE_VERTEX, + VK_VERTEX_INPUT_RATE_END_RANGE = VK_VERTEX_INPUT_RATE_INSTANCE, + VK_VERTEX_INPUT_RATE_RANGE_SIZE = (VK_VERTEX_INPUT_RATE_INSTANCE - VK_VERTEX_INPUT_RATE_VERTEX + 1), + VK_VERTEX_INPUT_RATE_MAX_ENUM = 0x7FFFFFFF +} VkVertexInputRate; + +typedef enum VkPrimitiveTopology { + VK_PRIMITIVE_TOPOLOGY_POINT_LIST = 0, + VK_PRIMITIVE_TOPOLOGY_LINE_LIST = 1, + VK_PRIMITIVE_TOPOLOGY_LINE_STRIP = 2, + VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST = 3, + VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP = 4, + VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN = 5, + VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY = 6, + VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY = 7, + VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY = 8, + VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY = 9, + VK_PRIMITIVE_TOPOLOGY_PATCH_LIST = 10, + VK_PRIMITIVE_TOPOLOGY_BEGIN_RANGE = VK_PRIMITIVE_TOPOLOGY_POINT_LIST, + VK_PRIMITIVE_TOPOLOGY_END_RANGE = VK_PRIMITIVE_TOPOLOGY_PATCH_LIST, + VK_PRIMITIVE_TOPOLOGY_RANGE_SIZE = (VK_PRIMITIVE_TOPOLOGY_PATCH_LIST - VK_PRIMITIVE_TOPOLOGY_POINT_LIST + 1), + VK_PRIMITIVE_TOPOLOGY_MAX_ENUM = 0x7FFFFFFF +} VkPrimitiveTopology; + +typedef enum VkPolygonMode { + VK_POLYGON_MODE_FILL = 0, + VK_POLYGON_MODE_LINE = 1, + VK_POLYGON_MODE_POINT = 2, + VK_POLYGON_MODE_FILL_RECTANGLE_NV = 1000153000, + VK_POLYGON_MODE_BEGIN_RANGE = VK_POLYGON_MODE_FILL, + VK_POLYGON_MODE_END_RANGE = VK_POLYGON_MODE_POINT, + VK_POLYGON_MODE_RANGE_SIZE = (VK_POLYGON_MODE_POINT - VK_POLYGON_MODE_FILL + 1), + VK_POLYGON_MODE_MAX_ENUM = 0x7FFFFFFF +} VkPolygonMode; + +typedef enum VkFrontFace { + VK_FRONT_FACE_COUNTER_CLOCKWISE = 0, + VK_FRONT_FACE_CLOCKWISE = 1, + VK_FRONT_FACE_BEGIN_RANGE = VK_FRONT_FACE_COUNTER_CLOCKWISE, + VK_FRONT_FACE_END_RANGE = VK_FRONT_FACE_CLOCKWISE, + VK_FRONT_FACE_RANGE_SIZE = (VK_FRONT_FACE_CLOCKWISE - VK_FRONT_FACE_COUNTER_CLOCKWISE + 1), + VK_FRONT_FACE_MAX_ENUM = 0x7FFFFFFF +} VkFrontFace; + +typedef enum VkCompareOp { + VK_COMPARE_OP_NEVER = 0, + VK_COMPARE_OP_LESS = 1, + VK_COMPARE_OP_EQUAL = 2, + VK_COMPARE_OP_LESS_OR_EQUAL = 3, + VK_COMPARE_OP_GREATER = 4, + VK_COMPARE_OP_NOT_EQUAL = 5, + VK_COMPARE_OP_GREATER_OR_EQUAL = 6, + VK_COMPARE_OP_ALWAYS = 7, + VK_COMPARE_OP_BEGIN_RANGE = VK_COMPARE_OP_NEVER, + VK_COMPARE_OP_END_RANGE = VK_COMPARE_OP_ALWAYS, + VK_COMPARE_OP_RANGE_SIZE = (VK_COMPARE_OP_ALWAYS - VK_COMPARE_OP_NEVER + 1), + VK_COMPARE_OP_MAX_ENUM = 0x7FFFFFFF +} VkCompareOp; + +typedef enum VkStencilOp { + VK_STENCIL_OP_KEEP = 0, + VK_STENCIL_OP_ZERO = 1, + VK_STENCIL_OP_REPLACE = 2, + VK_STENCIL_OP_INCREMENT_AND_CLAMP = 3, + VK_STENCIL_OP_DECREMENT_AND_CLAMP = 4, + VK_STENCIL_OP_INVERT = 5, + VK_STENCIL_OP_INCREMENT_AND_WRAP = 6, + VK_STENCIL_OP_DECREMENT_AND_WRAP = 7, + VK_STENCIL_OP_BEGIN_RANGE = VK_STENCIL_OP_KEEP, + VK_STENCIL_OP_END_RANGE = VK_STENCIL_OP_DECREMENT_AND_WRAP, + VK_STENCIL_OP_RANGE_SIZE = (VK_STENCIL_OP_DECREMENT_AND_WRAP - VK_STENCIL_OP_KEEP + 1), + VK_STENCIL_OP_MAX_ENUM = 0x7FFFFFFF +} VkStencilOp; + +typedef enum VkLogicOp { + VK_LOGIC_OP_CLEAR = 0, + VK_LOGIC_OP_AND = 1, + VK_LOGIC_OP_AND_REVERSE = 2, + VK_LOGIC_OP_COPY = 3, + VK_LOGIC_OP_AND_INVERTED = 4, + VK_LOGIC_OP_NO_OP = 5, + VK_LOGIC_OP_XOR = 6, + VK_LOGIC_OP_OR = 7, + VK_LOGIC_OP_NOR = 8, + VK_LOGIC_OP_EQUIVALENT = 9, + VK_LOGIC_OP_INVERT = 10, + VK_LOGIC_OP_OR_REVERSE = 11, + VK_LOGIC_OP_COPY_INVERTED = 12, + VK_LOGIC_OP_OR_INVERTED = 13, + VK_LOGIC_OP_NAND = 14, + VK_LOGIC_OP_SET = 15, + VK_LOGIC_OP_BEGIN_RANGE = VK_LOGIC_OP_CLEAR, + VK_LOGIC_OP_END_RANGE = VK_LOGIC_OP_SET, + VK_LOGIC_OP_RANGE_SIZE = (VK_LOGIC_OP_SET - VK_LOGIC_OP_CLEAR + 1), + VK_LOGIC_OP_MAX_ENUM = 0x7FFFFFFF +} VkLogicOp; + +typedef enum VkBlendFactor { + VK_BLEND_FACTOR_ZERO = 0, + VK_BLEND_FACTOR_ONE = 1, + VK_BLEND_FACTOR_SRC_COLOR = 2, + VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR = 3, + VK_BLEND_FACTOR_DST_COLOR = 4, + VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR = 5, + VK_BLEND_FACTOR_SRC_ALPHA = 6, + VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA = 7, + VK_BLEND_FACTOR_DST_ALPHA = 8, + VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA = 9, + VK_BLEND_FACTOR_CONSTANT_COLOR = 10, + VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR = 11, + VK_BLEND_FACTOR_CONSTANT_ALPHA = 12, + VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA = 13, + VK_BLEND_FACTOR_SRC_ALPHA_SATURATE = 14, + VK_BLEND_FACTOR_SRC1_COLOR = 15, + VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR = 16, + VK_BLEND_FACTOR_SRC1_ALPHA = 17, + VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA = 18, + VK_BLEND_FACTOR_BEGIN_RANGE = VK_BLEND_FACTOR_ZERO, + VK_BLEND_FACTOR_END_RANGE = VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA, + VK_BLEND_FACTOR_RANGE_SIZE = (VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA - VK_BLEND_FACTOR_ZERO + 1), + VK_BLEND_FACTOR_MAX_ENUM = 0x7FFFFFFF +} VkBlendFactor; + +typedef enum VkBlendOp { + VK_BLEND_OP_ADD = 0, + VK_BLEND_OP_SUBTRACT = 1, + VK_BLEND_OP_REVERSE_SUBTRACT = 2, + VK_BLEND_OP_MIN = 3, + VK_BLEND_OP_MAX = 4, + VK_BLEND_OP_ZERO_EXT = 1000148000, + VK_BLEND_OP_SRC_EXT = 1000148001, + VK_BLEND_OP_DST_EXT = 1000148002, + VK_BLEND_OP_SRC_OVER_EXT = 1000148003, + VK_BLEND_OP_DST_OVER_EXT = 1000148004, + VK_BLEND_OP_SRC_IN_EXT = 1000148005, + VK_BLEND_OP_DST_IN_EXT = 1000148006, + VK_BLEND_OP_SRC_OUT_EXT = 1000148007, + VK_BLEND_OP_DST_OUT_EXT = 1000148008, + VK_BLEND_OP_SRC_ATOP_EXT = 1000148009, + VK_BLEND_OP_DST_ATOP_EXT = 1000148010, + VK_BLEND_OP_XOR_EXT = 1000148011, + VK_BLEND_OP_MULTIPLY_EXT = 1000148012, + VK_BLEND_OP_SCREEN_EXT = 1000148013, + VK_BLEND_OP_OVERLAY_EXT = 1000148014, + VK_BLEND_OP_DARKEN_EXT = 1000148015, + VK_BLEND_OP_LIGHTEN_EXT = 1000148016, + VK_BLEND_OP_COLORDODGE_EXT = 1000148017, + VK_BLEND_OP_COLORBURN_EXT = 1000148018, + VK_BLEND_OP_HARDLIGHT_EXT = 1000148019, + VK_BLEND_OP_SOFTLIGHT_EXT = 1000148020, + VK_BLEND_OP_DIFFERENCE_EXT = 1000148021, + VK_BLEND_OP_EXCLUSION_EXT = 1000148022, + VK_BLEND_OP_INVERT_EXT = 1000148023, + VK_BLEND_OP_INVERT_RGB_EXT = 1000148024, + VK_BLEND_OP_LINEARDODGE_EXT = 1000148025, + VK_BLEND_OP_LINEARBURN_EXT = 1000148026, + VK_BLEND_OP_VIVIDLIGHT_EXT = 1000148027, + VK_BLEND_OP_LINEARLIGHT_EXT = 1000148028, + VK_BLEND_OP_PINLIGHT_EXT = 1000148029, + VK_BLEND_OP_HARDMIX_EXT = 1000148030, + VK_BLEND_OP_HSL_HUE_EXT = 1000148031, + VK_BLEND_OP_HSL_SATURATION_EXT = 1000148032, + VK_BLEND_OP_HSL_COLOR_EXT = 1000148033, + VK_BLEND_OP_HSL_LUMINOSITY_EXT = 1000148034, + VK_BLEND_OP_PLUS_EXT = 1000148035, + VK_BLEND_OP_PLUS_CLAMPED_EXT = 1000148036, + VK_BLEND_OP_PLUS_CLAMPED_ALPHA_EXT = 1000148037, + VK_BLEND_OP_PLUS_DARKER_EXT = 1000148038, + VK_BLEND_OP_MINUS_EXT = 1000148039, + VK_BLEND_OP_MINUS_CLAMPED_EXT = 1000148040, + VK_BLEND_OP_CONTRAST_EXT = 1000148041, + VK_BLEND_OP_INVERT_OVG_EXT = 1000148042, + VK_BLEND_OP_RED_EXT = 1000148043, + VK_BLEND_OP_GREEN_EXT = 1000148044, + VK_BLEND_OP_BLUE_EXT = 1000148045, + VK_BLEND_OP_BEGIN_RANGE = VK_BLEND_OP_ADD, + VK_BLEND_OP_END_RANGE = VK_BLEND_OP_MAX, + VK_BLEND_OP_RANGE_SIZE = (VK_BLEND_OP_MAX - VK_BLEND_OP_ADD + 1), + VK_BLEND_OP_MAX_ENUM = 0x7FFFFFFF +} VkBlendOp; + +typedef enum VkDynamicState { + VK_DYNAMIC_STATE_VIEWPORT = 0, + VK_DYNAMIC_STATE_SCISSOR = 1, + VK_DYNAMIC_STATE_LINE_WIDTH = 2, + VK_DYNAMIC_STATE_DEPTH_BIAS = 3, + VK_DYNAMIC_STATE_BLEND_CONSTANTS = 4, + VK_DYNAMIC_STATE_DEPTH_BOUNDS = 5, + VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK = 6, + VK_DYNAMIC_STATE_STENCIL_WRITE_MASK = 7, + VK_DYNAMIC_STATE_STENCIL_REFERENCE = 8, + VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV = 1000087000, + VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT = 1000099000, + VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT = 1000143000, + VK_DYNAMIC_STATE_BEGIN_RANGE = VK_DYNAMIC_STATE_VIEWPORT, + VK_DYNAMIC_STATE_END_RANGE = VK_DYNAMIC_STATE_STENCIL_REFERENCE, + VK_DYNAMIC_STATE_RANGE_SIZE = (VK_DYNAMIC_STATE_STENCIL_REFERENCE - VK_DYNAMIC_STATE_VIEWPORT + 1), + VK_DYNAMIC_STATE_MAX_ENUM = 0x7FFFFFFF +} VkDynamicState; + +typedef enum VkFilter { + VK_FILTER_NEAREST = 0, + VK_FILTER_LINEAR = 1, + VK_FILTER_CUBIC_IMG = 1000015000, + VK_FILTER_BEGIN_RANGE = VK_FILTER_NEAREST, + VK_FILTER_END_RANGE = VK_FILTER_LINEAR, + VK_FILTER_RANGE_SIZE = (VK_FILTER_LINEAR - VK_FILTER_NEAREST + 1), + VK_FILTER_MAX_ENUM = 0x7FFFFFFF +} VkFilter; + +typedef enum VkSamplerMipmapMode { + VK_SAMPLER_MIPMAP_MODE_NEAREST = 0, + VK_SAMPLER_MIPMAP_MODE_LINEAR = 1, + VK_SAMPLER_MIPMAP_MODE_BEGIN_RANGE = VK_SAMPLER_MIPMAP_MODE_NEAREST, + VK_SAMPLER_MIPMAP_MODE_END_RANGE = VK_SAMPLER_MIPMAP_MODE_LINEAR, + VK_SAMPLER_MIPMAP_MODE_RANGE_SIZE = (VK_SAMPLER_MIPMAP_MODE_LINEAR - VK_SAMPLER_MIPMAP_MODE_NEAREST + 1), + VK_SAMPLER_MIPMAP_MODE_MAX_ENUM = 0x7FFFFFFF +} VkSamplerMipmapMode; + +typedef enum VkSamplerAddressMode { + VK_SAMPLER_ADDRESS_MODE_REPEAT = 0, + VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT = 1, + VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE = 2, + VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER = 3, + VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE = 4, + VK_SAMPLER_ADDRESS_MODE_BEGIN_RANGE = VK_SAMPLER_ADDRESS_MODE_REPEAT, + VK_SAMPLER_ADDRESS_MODE_END_RANGE = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER, + VK_SAMPLER_ADDRESS_MODE_RANGE_SIZE = (VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER - VK_SAMPLER_ADDRESS_MODE_REPEAT + 1), + VK_SAMPLER_ADDRESS_MODE_MAX_ENUM = 0x7FFFFFFF +} VkSamplerAddressMode; + +typedef enum VkBorderColor { + VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK = 0, + VK_BORDER_COLOR_INT_TRANSPARENT_BLACK = 1, + VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK = 2, + VK_BORDER_COLOR_INT_OPAQUE_BLACK = 3, + VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE = 4, + VK_BORDER_COLOR_INT_OPAQUE_WHITE = 5, + VK_BORDER_COLOR_BEGIN_RANGE = VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK, + VK_BORDER_COLOR_END_RANGE = VK_BORDER_COLOR_INT_OPAQUE_WHITE, + VK_BORDER_COLOR_RANGE_SIZE = (VK_BORDER_COLOR_INT_OPAQUE_WHITE - VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK + 1), + VK_BORDER_COLOR_MAX_ENUM = 0x7FFFFFFF +} VkBorderColor; + +typedef enum VkDescriptorType { + VK_DESCRIPTOR_TYPE_SAMPLER = 0, + VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER = 1, + VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE = 2, + VK_DESCRIPTOR_TYPE_STORAGE_IMAGE = 3, + VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER = 4, + VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER = 5, + VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER = 6, + VK_DESCRIPTOR_TYPE_STORAGE_BUFFER = 7, + VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC = 8, + VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC = 9, + VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT = 10, + VK_DESCRIPTOR_TYPE_BEGIN_RANGE = VK_DESCRIPTOR_TYPE_SAMPLER, + VK_DESCRIPTOR_TYPE_END_RANGE = VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, + VK_DESCRIPTOR_TYPE_RANGE_SIZE = (VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT - VK_DESCRIPTOR_TYPE_SAMPLER + 1), + VK_DESCRIPTOR_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkDescriptorType; + +typedef enum VkAttachmentLoadOp { + VK_ATTACHMENT_LOAD_OP_LOAD = 0, + VK_ATTACHMENT_LOAD_OP_CLEAR = 1, + VK_ATTACHMENT_LOAD_OP_DONT_CARE = 2, + VK_ATTACHMENT_LOAD_OP_BEGIN_RANGE = VK_ATTACHMENT_LOAD_OP_LOAD, + VK_ATTACHMENT_LOAD_OP_END_RANGE = VK_ATTACHMENT_LOAD_OP_DONT_CARE, + VK_ATTACHMENT_LOAD_OP_RANGE_SIZE = (VK_ATTACHMENT_LOAD_OP_DONT_CARE - VK_ATTACHMENT_LOAD_OP_LOAD + 1), + VK_ATTACHMENT_LOAD_OP_MAX_ENUM = 0x7FFFFFFF +} VkAttachmentLoadOp; + +typedef enum VkAttachmentStoreOp { + VK_ATTACHMENT_STORE_OP_STORE = 0, + VK_ATTACHMENT_STORE_OP_DONT_CARE = 1, + VK_ATTACHMENT_STORE_OP_BEGIN_RANGE = VK_ATTACHMENT_STORE_OP_STORE, + VK_ATTACHMENT_STORE_OP_END_RANGE = VK_ATTACHMENT_STORE_OP_DONT_CARE, + VK_ATTACHMENT_STORE_OP_RANGE_SIZE = (VK_ATTACHMENT_STORE_OP_DONT_CARE - VK_ATTACHMENT_STORE_OP_STORE + 1), + VK_ATTACHMENT_STORE_OP_MAX_ENUM = 0x7FFFFFFF +} VkAttachmentStoreOp; + +typedef enum VkPipelineBindPoint { + VK_PIPELINE_BIND_POINT_GRAPHICS = 0, + VK_PIPELINE_BIND_POINT_COMPUTE = 1, + VK_PIPELINE_BIND_POINT_BEGIN_RANGE = VK_PIPELINE_BIND_POINT_GRAPHICS, + VK_PIPELINE_BIND_POINT_END_RANGE = VK_PIPELINE_BIND_POINT_COMPUTE, + VK_PIPELINE_BIND_POINT_RANGE_SIZE = (VK_PIPELINE_BIND_POINT_COMPUTE - VK_PIPELINE_BIND_POINT_GRAPHICS + 1), + VK_PIPELINE_BIND_POINT_MAX_ENUM = 0x7FFFFFFF +} VkPipelineBindPoint; + +typedef enum VkCommandBufferLevel { + VK_COMMAND_BUFFER_LEVEL_PRIMARY = 0, + VK_COMMAND_BUFFER_LEVEL_SECONDARY = 1, + VK_COMMAND_BUFFER_LEVEL_BEGIN_RANGE = VK_COMMAND_BUFFER_LEVEL_PRIMARY, + VK_COMMAND_BUFFER_LEVEL_END_RANGE = VK_COMMAND_BUFFER_LEVEL_SECONDARY, + VK_COMMAND_BUFFER_LEVEL_RANGE_SIZE = (VK_COMMAND_BUFFER_LEVEL_SECONDARY - VK_COMMAND_BUFFER_LEVEL_PRIMARY + 1), + VK_COMMAND_BUFFER_LEVEL_MAX_ENUM = 0x7FFFFFFF +} VkCommandBufferLevel; + +typedef enum VkIndexType { + VK_INDEX_TYPE_UINT16 = 0, + VK_INDEX_TYPE_UINT32 = 1, + VK_INDEX_TYPE_BEGIN_RANGE = VK_INDEX_TYPE_UINT16, + VK_INDEX_TYPE_END_RANGE = VK_INDEX_TYPE_UINT32, + VK_INDEX_TYPE_RANGE_SIZE = (VK_INDEX_TYPE_UINT32 - VK_INDEX_TYPE_UINT16 + 1), + VK_INDEX_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkIndexType; + +typedef enum VkSubpassContents { + VK_SUBPASS_CONTENTS_INLINE = 0, + VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS = 1, + VK_SUBPASS_CONTENTS_BEGIN_RANGE = VK_SUBPASS_CONTENTS_INLINE, + VK_SUBPASS_CONTENTS_END_RANGE = VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS, + VK_SUBPASS_CONTENTS_RANGE_SIZE = (VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS - VK_SUBPASS_CONTENTS_INLINE + 1), + VK_SUBPASS_CONTENTS_MAX_ENUM = 0x7FFFFFFF +} VkSubpassContents; + +typedef enum VkObjectType { + VK_OBJECT_TYPE_UNKNOWN = 0, + VK_OBJECT_TYPE_INSTANCE = 1, + VK_OBJECT_TYPE_PHYSICAL_DEVICE = 2, + VK_OBJECT_TYPE_DEVICE = 3, + VK_OBJECT_TYPE_QUEUE = 4, + VK_OBJECT_TYPE_SEMAPHORE = 5, + VK_OBJECT_TYPE_COMMAND_BUFFER = 6, + VK_OBJECT_TYPE_FENCE = 7, + VK_OBJECT_TYPE_DEVICE_MEMORY = 8, + VK_OBJECT_TYPE_BUFFER = 9, + VK_OBJECT_TYPE_IMAGE = 10, + VK_OBJECT_TYPE_EVENT = 11, + VK_OBJECT_TYPE_QUERY_POOL = 12, + VK_OBJECT_TYPE_BUFFER_VIEW = 13, + VK_OBJECT_TYPE_IMAGE_VIEW = 14, + VK_OBJECT_TYPE_SHADER_MODULE = 15, + VK_OBJECT_TYPE_PIPELINE_CACHE = 16, + VK_OBJECT_TYPE_PIPELINE_LAYOUT = 17, + VK_OBJECT_TYPE_RENDER_PASS = 18, + VK_OBJECT_TYPE_PIPELINE = 19, + VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT = 20, + VK_OBJECT_TYPE_SAMPLER = 21, + VK_OBJECT_TYPE_DESCRIPTOR_POOL = 22, + VK_OBJECT_TYPE_DESCRIPTOR_SET = 23, + VK_OBJECT_TYPE_FRAMEBUFFER = 24, + VK_OBJECT_TYPE_COMMAND_POOL = 25, + VK_OBJECT_TYPE_SURFACE_KHR = 1000000000, + VK_OBJECT_TYPE_SWAPCHAIN_KHR = 1000001000, + VK_OBJECT_TYPE_DISPLAY_KHR = 1000002000, + VK_OBJECT_TYPE_DISPLAY_MODE_KHR = 1000002001, + VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT = 1000011000, + VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR = 1000085000, + VK_OBJECT_TYPE_OBJECT_TABLE_NVX = 1000086000, + VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX = 1000086001, + VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR = 1000156000, + VK_OBJECT_TYPE_VALIDATION_CACHE_EXT = 1000160000, + VK_OBJECT_TYPE_BEGIN_RANGE = VK_OBJECT_TYPE_UNKNOWN, + VK_OBJECT_TYPE_END_RANGE = VK_OBJECT_TYPE_COMMAND_POOL, + VK_OBJECT_TYPE_RANGE_SIZE = (VK_OBJECT_TYPE_COMMAND_POOL - VK_OBJECT_TYPE_UNKNOWN + 1), + VK_OBJECT_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkObjectType; + +typedef VkFlags VkInstanceCreateFlags; + +typedef enum VkFormatFeatureFlagBits { + VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT = 0x00000001, + VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT = 0x00000002, + VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT = 0x00000004, + VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000008, + VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT = 0x00000010, + VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT = 0x00000020, + VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT = 0x00000040, + VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT = 0x00000080, + VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT = 0x00000100, + VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000200, + VK_FORMAT_FEATURE_BLIT_SRC_BIT = 0x00000400, + VK_FORMAT_FEATURE_BLIT_DST_BIT = 0x00000800, + VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT = 0x00001000, + VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG = 0x00002000, + VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR = 0x00004000, + VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR = 0x00008000, + VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT_EXT = 0x00010000, + VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT_KHR = 0x00020000, + VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT_KHR = 0x00040000, + VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT_KHR = 0x00080000, + VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT_KHR = 0x00100000, + VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT_KHR = 0x00200000, + VK_FORMAT_FEATURE_DISJOINT_BIT_KHR = 0x00400000, + VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT_KHR = 0x00800000, + VK_FORMAT_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkFormatFeatureFlagBits; +typedef VkFlags VkFormatFeatureFlags; + +typedef enum VkImageUsageFlagBits { + VK_IMAGE_USAGE_TRANSFER_SRC_BIT = 0x00000001, + VK_IMAGE_USAGE_TRANSFER_DST_BIT = 0x00000002, + VK_IMAGE_USAGE_SAMPLED_BIT = 0x00000004, + VK_IMAGE_USAGE_STORAGE_BIT = 0x00000008, + VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT = 0x00000010, + VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000020, + VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT = 0x00000040, + VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT = 0x00000080, + VK_IMAGE_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkImageUsageFlagBits; +typedef VkFlags VkImageUsageFlags; + +typedef enum VkImageCreateFlagBits { + VK_IMAGE_CREATE_SPARSE_BINDING_BIT = 0x00000001, + VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002, + VK_IMAGE_CREATE_SPARSE_ALIASED_BIT = 0x00000004, + VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT = 0x00000008, + VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT = 0x00000010, + VK_IMAGE_CREATE_BIND_SFR_BIT_KHX = 0x00000040, + VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR = 0x00000020, + VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT_KHR = 0x00000080, + VK_IMAGE_CREATE_EXTENDED_USAGE_BIT_KHR = 0x00000100, + VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT = 0x00001000, + VK_IMAGE_CREATE_DISJOINT_BIT_KHR = 0x00000200, + VK_IMAGE_CREATE_ALIAS_BIT_KHR = 0x00000400, + VK_IMAGE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkImageCreateFlagBits; +typedef VkFlags VkImageCreateFlags; + +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, + VK_SAMPLE_COUNT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkSampleCountFlagBits; +typedef VkFlags VkSampleCountFlags; + +typedef enum VkQueueFlagBits { + VK_QUEUE_GRAPHICS_BIT = 0x00000001, + VK_QUEUE_COMPUTE_BIT = 0x00000002, + VK_QUEUE_TRANSFER_BIT = 0x00000004, + VK_QUEUE_SPARSE_BINDING_BIT = 0x00000008, + VK_QUEUE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkQueueFlagBits; +typedef VkFlags VkQueueFlags; + +typedef enum VkMemoryPropertyFlagBits { + VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT = 0x00000001, + VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT = 0x00000002, + VK_MEMORY_PROPERTY_HOST_COHERENT_BIT = 0x00000004, + VK_MEMORY_PROPERTY_HOST_CACHED_BIT = 0x00000008, + VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT = 0x00000010, + VK_MEMORY_PROPERTY_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkMemoryPropertyFlagBits; +typedef VkFlags VkMemoryPropertyFlags; + +typedef enum VkMemoryHeapFlagBits { + VK_MEMORY_HEAP_DEVICE_LOCAL_BIT = 0x00000001, + VK_MEMORY_HEAP_MULTI_INSTANCE_BIT_KHX = 0x00000002, + VK_MEMORY_HEAP_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkMemoryHeapFlagBits; +typedef VkFlags VkMemoryHeapFlags; +typedef VkFlags VkDeviceCreateFlags; +typedef VkFlags VkDeviceQueueCreateFlags; + +typedef enum VkPipelineStageFlagBits { + VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT = 0x00000001, + VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT = 0x00000002, + VK_PIPELINE_STAGE_VERTEX_INPUT_BIT = 0x00000004, + VK_PIPELINE_STAGE_VERTEX_SHADER_BIT = 0x00000008, + VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT = 0x00000010, + VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT = 0x00000020, + VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT = 0x00000040, + VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT = 0x00000080, + VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT = 0x00000100, + VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT = 0x00000200, + VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT = 0x00000400, + VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT = 0x00000800, + VK_PIPELINE_STAGE_TRANSFER_BIT = 0x00001000, + VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT = 0x00002000, + VK_PIPELINE_STAGE_HOST_BIT = 0x00004000, + VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT = 0x00008000, + VK_PIPELINE_STAGE_ALL_COMMANDS_BIT = 0x00010000, + VK_PIPELINE_STAGE_COMMAND_PROCESS_BIT_NVX = 0x00020000, + VK_PIPELINE_STAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkPipelineStageFlagBits; +typedef VkFlags VkPipelineStageFlags; +typedef VkFlags VkMemoryMapFlags; + +typedef enum VkImageAspectFlagBits { + VK_IMAGE_ASPECT_COLOR_BIT = 0x00000001, + VK_IMAGE_ASPECT_DEPTH_BIT = 0x00000002, + VK_IMAGE_ASPECT_STENCIL_BIT = 0x00000004, + VK_IMAGE_ASPECT_METADATA_BIT = 0x00000008, + VK_IMAGE_ASPECT_PLANE_0_BIT_KHR = 0x00000010, + VK_IMAGE_ASPECT_PLANE_1_BIT_KHR = 0x00000020, + VK_IMAGE_ASPECT_PLANE_2_BIT_KHR = 0x00000040, + VK_IMAGE_ASPECT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkImageAspectFlagBits; +typedef VkFlags VkImageAspectFlags; + +typedef enum VkSparseImageFormatFlagBits { + VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT = 0x00000001, + VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT = 0x00000002, + VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT = 0x00000004, + VK_SPARSE_IMAGE_FORMAT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkSparseImageFormatFlagBits; +typedef VkFlags VkSparseImageFormatFlags; + +typedef enum VkSparseMemoryBindFlagBits { + VK_SPARSE_MEMORY_BIND_METADATA_BIT = 0x00000001, + VK_SPARSE_MEMORY_BIND_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkSparseMemoryBindFlagBits; +typedef VkFlags VkSparseMemoryBindFlags; + +typedef enum VkFenceCreateFlagBits { + VK_FENCE_CREATE_SIGNALED_BIT = 0x00000001, + VK_FENCE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkFenceCreateFlagBits; +typedef VkFlags VkFenceCreateFlags; +typedef VkFlags VkSemaphoreCreateFlags; +typedef VkFlags VkEventCreateFlags; +typedef VkFlags VkQueryPoolCreateFlags; + +typedef enum VkQueryPipelineStatisticFlagBits { + VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT = 0x00000001, + VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT = 0x00000002, + VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT = 0x00000004, + VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT = 0x00000008, + VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT = 0x00000010, + VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT = 0x00000020, + VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT = 0x00000040, + VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT = 0x00000080, + VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT = 0x00000100, + VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT = 0x00000200, + VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT = 0x00000400, + VK_QUERY_PIPELINE_STATISTIC_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkQueryPipelineStatisticFlagBits; +typedef VkFlags VkQueryPipelineStatisticFlags; + +typedef enum VkQueryResultFlagBits { + VK_QUERY_RESULT_64_BIT = 0x00000001, + VK_QUERY_RESULT_WAIT_BIT = 0x00000002, + VK_QUERY_RESULT_WITH_AVAILABILITY_BIT = 0x00000004, + VK_QUERY_RESULT_PARTIAL_BIT = 0x00000008, + VK_QUERY_RESULT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkQueryResultFlagBits; +typedef VkFlags VkQueryResultFlags; + +typedef enum VkBufferCreateFlagBits { + VK_BUFFER_CREATE_SPARSE_BINDING_BIT = 0x00000001, + VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002, + VK_BUFFER_CREATE_SPARSE_ALIASED_BIT = 0x00000004, + VK_BUFFER_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkBufferCreateFlagBits; +typedef VkFlags VkBufferCreateFlags; + +typedef enum VkBufferUsageFlagBits { + VK_BUFFER_USAGE_TRANSFER_SRC_BIT = 0x00000001, + VK_BUFFER_USAGE_TRANSFER_DST_BIT = 0x00000002, + VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000004, + VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT = 0x00000008, + VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT = 0x00000010, + VK_BUFFER_USAGE_STORAGE_BUFFER_BIT = 0x00000020, + VK_BUFFER_USAGE_INDEX_BUFFER_BIT = 0x00000040, + VK_BUFFER_USAGE_VERTEX_BUFFER_BIT = 0x00000080, + VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT = 0x00000100, + VK_BUFFER_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkBufferUsageFlagBits; +typedef VkFlags VkBufferUsageFlags; +typedef VkFlags VkBufferViewCreateFlags; +typedef VkFlags VkImageViewCreateFlags; +typedef VkFlags VkShaderModuleCreateFlags; +typedef VkFlags VkPipelineCacheCreateFlags; + +typedef enum VkPipelineCreateFlagBits { + VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = 0x00000001, + VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = 0x00000002, + VK_PIPELINE_CREATE_DERIVATIVE_BIT = 0x00000004, + VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHX = 0x00000008, + VK_PIPELINE_CREATE_DISPATCH_BASE_KHX = 0x00000010, + VK_PIPELINE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkPipelineCreateFlagBits; +typedef VkFlags VkPipelineCreateFlags; +typedef VkFlags VkPipelineShaderStageCreateFlags; + +typedef enum VkShaderStageFlagBits { + VK_SHADER_STAGE_VERTEX_BIT = 0x00000001, + VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT = 0x00000002, + VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT = 0x00000004, + VK_SHADER_STAGE_GEOMETRY_BIT = 0x00000008, + VK_SHADER_STAGE_FRAGMENT_BIT = 0x00000010, + VK_SHADER_STAGE_COMPUTE_BIT = 0x00000020, + VK_SHADER_STAGE_ALL_GRAPHICS = 0x0000001F, + VK_SHADER_STAGE_ALL = 0x7FFFFFFF, + VK_SHADER_STAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkShaderStageFlagBits; +typedef VkFlags VkPipelineVertexInputStateCreateFlags; +typedef VkFlags VkPipelineInputAssemblyStateCreateFlags; +typedef VkFlags VkPipelineTessellationStateCreateFlags; +typedef VkFlags VkPipelineViewportStateCreateFlags; +typedef VkFlags VkPipelineRasterizationStateCreateFlags; + +typedef enum VkCullModeFlagBits { + VK_CULL_MODE_NONE = 0, + VK_CULL_MODE_FRONT_BIT = 0x00000001, + VK_CULL_MODE_BACK_BIT = 0x00000002, + VK_CULL_MODE_FRONT_AND_BACK = 0x00000003, + VK_CULL_MODE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkCullModeFlagBits; +typedef VkFlags VkCullModeFlags; +typedef VkFlags VkPipelineMultisampleStateCreateFlags; +typedef VkFlags VkPipelineDepthStencilStateCreateFlags; +typedef VkFlags VkPipelineColorBlendStateCreateFlags; + +typedef enum VkColorComponentFlagBits { + VK_COLOR_COMPONENT_R_BIT = 0x00000001, + VK_COLOR_COMPONENT_G_BIT = 0x00000002, + VK_COLOR_COMPONENT_B_BIT = 0x00000004, + VK_COLOR_COMPONENT_A_BIT = 0x00000008, + VK_COLOR_COMPONENT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkColorComponentFlagBits; +typedef VkFlags VkColorComponentFlags; +typedef VkFlags VkPipelineDynamicStateCreateFlags; +typedef VkFlags VkPipelineLayoutCreateFlags; +typedef VkFlags VkShaderStageFlags; +typedef VkFlags VkSamplerCreateFlags; + +typedef enum VkDescriptorSetLayoutCreateFlagBits { + VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR = 0x00000001, + VK_DESCRIPTOR_SET_LAYOUT_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkDescriptorSetLayoutCreateFlagBits; +typedef VkFlags VkDescriptorSetLayoutCreateFlags; + +typedef enum VkDescriptorPoolCreateFlagBits { + VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT = 0x00000001, + VK_DESCRIPTOR_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkDescriptorPoolCreateFlagBits; +typedef VkFlags VkDescriptorPoolCreateFlags; +typedef VkFlags VkDescriptorPoolResetFlags; +typedef VkFlags VkFramebufferCreateFlags; +typedef VkFlags VkRenderPassCreateFlags; + +typedef enum VkAttachmentDescriptionFlagBits { + VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT = 0x00000001, + VK_ATTACHMENT_DESCRIPTION_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkAttachmentDescriptionFlagBits; +typedef VkFlags VkAttachmentDescriptionFlags; + +typedef enum VkSubpassDescriptionFlagBits { + VK_SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX = 0x00000001, + VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX = 0x00000002, + VK_SUBPASS_DESCRIPTION_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkSubpassDescriptionFlagBits; +typedef VkFlags VkSubpassDescriptionFlags; + +typedef enum VkAccessFlagBits { + VK_ACCESS_INDIRECT_COMMAND_READ_BIT = 0x00000001, + VK_ACCESS_INDEX_READ_BIT = 0x00000002, + VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT = 0x00000004, + VK_ACCESS_UNIFORM_READ_BIT = 0x00000008, + VK_ACCESS_INPUT_ATTACHMENT_READ_BIT = 0x00000010, + VK_ACCESS_SHADER_READ_BIT = 0x00000020, + VK_ACCESS_SHADER_WRITE_BIT = 0x00000040, + VK_ACCESS_COLOR_ATTACHMENT_READ_BIT = 0x00000080, + VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT = 0x00000100, + VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT = 0x00000200, + VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT = 0x00000400, + VK_ACCESS_TRANSFER_READ_BIT = 0x00000800, + VK_ACCESS_TRANSFER_WRITE_BIT = 0x00001000, + VK_ACCESS_HOST_READ_BIT = 0x00002000, + VK_ACCESS_HOST_WRITE_BIT = 0x00004000, + VK_ACCESS_MEMORY_READ_BIT = 0x00008000, + VK_ACCESS_MEMORY_WRITE_BIT = 0x00010000, + VK_ACCESS_COMMAND_PROCESS_READ_BIT_NVX = 0x00020000, + VK_ACCESS_COMMAND_PROCESS_WRITE_BIT_NVX = 0x00040000, + VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT = 0x00080000, + VK_ACCESS_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkAccessFlagBits; +typedef VkFlags VkAccessFlags; + +typedef enum VkDependencyFlagBits { + VK_DEPENDENCY_BY_REGION_BIT = 0x00000001, + VK_DEPENDENCY_VIEW_LOCAL_BIT_KHX = 0x00000002, + VK_DEPENDENCY_DEVICE_GROUP_BIT_KHX = 0x00000004, + VK_DEPENDENCY_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkDependencyFlagBits; +typedef VkFlags VkDependencyFlags; + +typedef enum VkCommandPoolCreateFlagBits { + VK_COMMAND_POOL_CREATE_TRANSIENT_BIT = 0x00000001, + VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT = 0x00000002, + VK_COMMAND_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkCommandPoolCreateFlagBits; +typedef VkFlags VkCommandPoolCreateFlags; + +typedef enum VkCommandPoolResetFlagBits { + VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT = 0x00000001, + VK_COMMAND_POOL_RESET_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkCommandPoolResetFlagBits; +typedef VkFlags VkCommandPoolResetFlags; + +typedef enum VkCommandBufferUsageFlagBits { + VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT = 0x00000001, + VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT = 0x00000002, + VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT = 0x00000004, + VK_COMMAND_BUFFER_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkCommandBufferUsageFlagBits; +typedef VkFlags VkCommandBufferUsageFlags; + +typedef enum VkQueryControlFlagBits { + VK_QUERY_CONTROL_PRECISE_BIT = 0x00000001, + VK_QUERY_CONTROL_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkQueryControlFlagBits; +typedef VkFlags VkQueryControlFlags; + +typedef enum VkCommandBufferResetFlagBits { + VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT = 0x00000001, + VK_COMMAND_BUFFER_RESET_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkCommandBufferResetFlagBits; +typedef VkFlags VkCommandBufferResetFlags; + +typedef enum VkStencilFaceFlagBits { + VK_STENCIL_FACE_FRONT_BIT = 0x00000001, + VK_STENCIL_FACE_BACK_BIT = 0x00000002, + VK_STENCIL_FRONT_AND_BACK = 0x00000003, + VK_STENCIL_FACE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkStencilFaceFlagBits; +typedef VkFlags VkStencilFaceFlags; + +typedef struct VkApplicationInfo { + VkStructureType sType; + const void* pNext; + const char* pApplicationName; + uint32_t applicationVersion; + const char* pEngineName; + uint32_t engineVersion; + uint32_t apiVersion; +} VkApplicationInfo; + +typedef struct VkInstanceCreateInfo { + VkStructureType sType; + const void* pNext; + VkInstanceCreateFlags flags; + const VkApplicationInfo* pApplicationInfo; + uint32_t enabledLayerCount; + const char* const* ppEnabledLayerNames; + uint32_t enabledExtensionCount; + const char* const* ppEnabledExtensionNames; +} VkInstanceCreateInfo; + +typedef void* (VKAPI_PTR *PFN_vkAllocationFunction)( + void* pUserData, + size_t size, + size_t alignment, + VkSystemAllocationScope allocationScope); + +typedef void* (VKAPI_PTR *PFN_vkReallocationFunction)( + void* pUserData, + void* pOriginal, + size_t size, + size_t alignment, + VkSystemAllocationScope allocationScope); + +typedef void (VKAPI_PTR *PFN_vkFreeFunction)( + void* pUserData, + void* pMemory); + +typedef void (VKAPI_PTR *PFN_vkInternalAllocationNotification)( + void* pUserData, + size_t size, + VkInternalAllocationType allocationType, + VkSystemAllocationScope allocationScope); + +typedef void (VKAPI_PTR *PFN_vkInternalFreeNotification)( + void* pUserData, + size_t size, + VkInternalAllocationType allocationType, + VkSystemAllocationScope allocationScope); + +typedef struct VkAllocationCallbacks { + void* pUserData; + PFN_vkAllocationFunction pfnAllocation; + PFN_vkReallocationFunction pfnReallocation; + PFN_vkFreeFunction pfnFree; + PFN_vkInternalAllocationNotification pfnInternalAllocation; + PFN_vkInternalFreeNotification pfnInternalFree; +} VkAllocationCallbacks; + +typedef struct VkPhysicalDeviceFeatures { + VkBool32 robustBufferAccess; + VkBool32 fullDrawIndexUint32; + VkBool32 imageCubeArray; + VkBool32 independentBlend; + VkBool32 geometryShader; + VkBool32 tessellationShader; + VkBool32 sampleRateShading; + VkBool32 dualSrcBlend; + VkBool32 logicOp; + VkBool32 multiDrawIndirect; + VkBool32 drawIndirectFirstInstance; + VkBool32 depthClamp; + VkBool32 depthBiasClamp; + VkBool32 fillModeNonSolid; + VkBool32 depthBounds; + VkBool32 wideLines; + VkBool32 largePoints; + VkBool32 alphaToOne; + VkBool32 multiViewport; + VkBool32 samplerAnisotropy; + VkBool32 textureCompressionETC2; + VkBool32 textureCompressionASTC_LDR; + VkBool32 textureCompressionBC; + VkBool32 occlusionQueryPrecise; + VkBool32 pipelineStatisticsQuery; + VkBool32 vertexPipelineStoresAndAtomics; + VkBool32 fragmentStoresAndAtomics; + VkBool32 shaderTessellationAndGeometryPointSize; + VkBool32 shaderImageGatherExtended; + VkBool32 shaderStorageImageExtendedFormats; + VkBool32 shaderStorageImageMultisample; + VkBool32 shaderStorageImageReadWithoutFormat; + VkBool32 shaderStorageImageWriteWithoutFormat; + VkBool32 shaderUniformBufferArrayDynamicIndexing; + VkBool32 shaderSampledImageArrayDynamicIndexing; + VkBool32 shaderStorageBufferArrayDynamicIndexing; + VkBool32 shaderStorageImageArrayDynamicIndexing; + VkBool32 shaderClipDistance; + VkBool32 shaderCullDistance; + VkBool32 shaderFloat64; + VkBool32 shaderInt64; + VkBool32 shaderInt16; + VkBool32 shaderResourceResidency; + VkBool32 shaderResourceMinLod; + VkBool32 sparseBinding; + VkBool32 sparseResidencyBuffer; + VkBool32 sparseResidencyImage2D; + VkBool32 sparseResidencyImage3D; + VkBool32 sparseResidency2Samples; + VkBool32 sparseResidency4Samples; + VkBool32 sparseResidency8Samples; + VkBool32 sparseResidency16Samples; + VkBool32 sparseResidencyAliased; + VkBool32 variableMultisampleRate; + VkBool32 inheritedQueries; +} VkPhysicalDeviceFeatures; + +typedef struct VkFormatProperties { + VkFormatFeatureFlags linearTilingFeatures; + VkFormatFeatureFlags optimalTilingFeatures; + VkFormatFeatureFlags bufferFeatures; +} VkFormatProperties; + +typedef struct VkExtent3D { + uint32_t width; + uint32_t height; + uint32_t depth; +} VkExtent3D; + +typedef struct VkImageFormatProperties { + VkExtent3D maxExtent; + uint32_t maxMipLevels; + uint32_t maxArrayLayers; + VkSampleCountFlags sampleCounts; + VkDeviceSize maxResourceSize; +} VkImageFormatProperties; + +typedef 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; +} VkPhysicalDeviceLimits; + +typedef struct VkPhysicalDeviceSparseProperties { + VkBool32 residencyStandard2DBlockShape; + VkBool32 residencyStandard2DMultisampleBlockShape; + VkBool32 residencyStandard3DBlockShape; + VkBool32 residencyAlignedMipSize; + VkBool32 residencyNonResidentStrict; +} VkPhysicalDeviceSparseProperties; + +typedef struct VkPhysicalDeviceProperties { + uint32_t apiVersion; + uint32_t driverVersion; + uint32_t vendorID; + uint32_t deviceID; + VkPhysicalDeviceType deviceType; + char deviceName[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE]; + uint8_t pipelineCacheUUID[VK_UUID_SIZE]; + VkPhysicalDeviceLimits limits; + VkPhysicalDeviceSparseProperties sparseProperties; +} VkPhysicalDeviceProperties; + +typedef struct VkQueueFamilyProperties { + VkQueueFlags queueFlags; + uint32_t queueCount; + uint32_t timestampValidBits; + VkExtent3D minImageTransferGranularity; +} VkQueueFamilyProperties; + +typedef struct VkMemoryType { + VkMemoryPropertyFlags propertyFlags; + uint32_t heapIndex; +} VkMemoryType; + +typedef struct VkMemoryHeap { + VkDeviceSize size; + VkMemoryHeapFlags flags; +} VkMemoryHeap; + +typedef struct VkPhysicalDeviceMemoryProperties { + uint32_t memoryTypeCount; + VkMemoryType memoryTypes[VK_MAX_MEMORY_TYPES]; + uint32_t memoryHeapCount; + VkMemoryHeap memoryHeaps[VK_MAX_MEMORY_HEAPS]; +} VkPhysicalDeviceMemoryProperties; + +typedef void (VKAPI_PTR *PFN_vkVoidFunction)(void); +typedef struct VkDeviceQueueCreateInfo { + VkStructureType sType; + const void* pNext; + VkDeviceQueueCreateFlags flags; + uint32_t queueFamilyIndex; + uint32_t queueCount; + const float* pQueuePriorities; +} VkDeviceQueueCreateInfo; + +typedef struct VkDeviceCreateInfo { + VkStructureType sType; + const void* pNext; + VkDeviceCreateFlags flags; + uint32_t queueCreateInfoCount; + const VkDeviceQueueCreateInfo* pQueueCreateInfos; + uint32_t enabledLayerCount; + const char* const* ppEnabledLayerNames; + uint32_t enabledExtensionCount; + const char* const* ppEnabledExtensionNames; + const VkPhysicalDeviceFeatures* pEnabledFeatures; +} VkDeviceCreateInfo; + +typedef struct VkExtensionProperties { + char extensionName[VK_MAX_EXTENSION_NAME_SIZE]; + uint32_t specVersion; +} VkExtensionProperties; + +typedef struct VkLayerProperties { + char layerName[VK_MAX_EXTENSION_NAME_SIZE]; + uint32_t specVersion; + uint32_t implementationVersion; + char description[VK_MAX_DESCRIPTION_SIZE]; +} VkLayerProperties; + +typedef struct VkSubmitInfo { + VkStructureType sType; + const void* pNext; + uint32_t waitSemaphoreCount; + const VkSemaphore* pWaitSemaphores; + const VkPipelineStageFlags* pWaitDstStageMask; + uint32_t commandBufferCount; + const VkCommandBuffer* pCommandBuffers; + uint32_t signalSemaphoreCount; + const VkSemaphore* pSignalSemaphores; +} VkSubmitInfo; + +typedef struct VkMemoryAllocateInfo { + VkStructureType sType; + const void* pNext; + VkDeviceSize allocationSize; + uint32_t memoryTypeIndex; +} VkMemoryAllocateInfo; + +typedef struct VkMappedMemoryRange { + VkStructureType sType; + const void* pNext; + VkDeviceMemory memory; + VkDeviceSize offset; + VkDeviceSize size; +} VkMappedMemoryRange; + +typedef struct VkMemoryRequirements { + VkDeviceSize size; + VkDeviceSize alignment; + uint32_t memoryTypeBits; +} VkMemoryRequirements; + +typedef struct VkSparseImageFormatProperties { + VkImageAspectFlags aspectMask; + VkExtent3D imageGranularity; + VkSparseImageFormatFlags flags; +} VkSparseImageFormatProperties; + +typedef struct VkSparseImageMemoryRequirements { + VkSparseImageFormatProperties formatProperties; + uint32_t imageMipTailFirstLod; + VkDeviceSize imageMipTailSize; + VkDeviceSize imageMipTailOffset; + VkDeviceSize imageMipTailStride; +} VkSparseImageMemoryRequirements; + +typedef struct VkSparseMemoryBind { + VkDeviceSize resourceOffset; + VkDeviceSize size; + VkDeviceMemory memory; + VkDeviceSize memoryOffset; + VkSparseMemoryBindFlags flags; +} VkSparseMemoryBind; + +typedef struct VkSparseBufferMemoryBindInfo { + VkBuffer buffer; + uint32_t bindCount; + const VkSparseMemoryBind* pBinds; +} VkSparseBufferMemoryBindInfo; + +typedef struct VkSparseImageOpaqueMemoryBindInfo { + VkImage image; + uint32_t bindCount; + const VkSparseMemoryBind* pBinds; +} VkSparseImageOpaqueMemoryBindInfo; + +typedef struct VkImageSubresource { + VkImageAspectFlags aspectMask; + uint32_t mipLevel; + uint32_t arrayLayer; +} VkImageSubresource; + +typedef struct VkOffset3D { + int32_t x; + int32_t y; + int32_t z; +} VkOffset3D; + +typedef struct VkSparseImageMemoryBind { + VkImageSubresource subresource; + VkOffset3D offset; + VkExtent3D extent; + VkDeviceMemory memory; + VkDeviceSize memoryOffset; + VkSparseMemoryBindFlags flags; +} VkSparseImageMemoryBind; + +typedef struct VkSparseImageMemoryBindInfo { + VkImage image; + uint32_t bindCount; + const VkSparseImageMemoryBind* pBinds; +} VkSparseImageMemoryBindInfo; + +typedef struct VkBindSparseInfo { + VkStructureType sType; + const void* pNext; + uint32_t waitSemaphoreCount; + const VkSemaphore* pWaitSemaphores; + uint32_t bufferBindCount; + const VkSparseBufferMemoryBindInfo* pBufferBinds; + uint32_t imageOpaqueBindCount; + const VkSparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds; + uint32_t imageBindCount; + const VkSparseImageMemoryBindInfo* pImageBinds; + uint32_t signalSemaphoreCount; + const VkSemaphore* pSignalSemaphores; +} VkBindSparseInfo; + +typedef struct VkFenceCreateInfo { + VkStructureType sType; + const void* pNext; + VkFenceCreateFlags flags; +} VkFenceCreateInfo; + +typedef struct VkSemaphoreCreateInfo { + VkStructureType sType; + const void* pNext; + VkSemaphoreCreateFlags flags; +} VkSemaphoreCreateInfo; + +typedef struct VkEventCreateInfo { + VkStructureType sType; + const void* pNext; + VkEventCreateFlags flags; +} VkEventCreateInfo; + +typedef struct VkQueryPoolCreateInfo { + VkStructureType sType; + const void* pNext; + VkQueryPoolCreateFlags flags; + VkQueryType queryType; + uint32_t queryCount; + VkQueryPipelineStatisticFlags pipelineStatistics; +} VkQueryPoolCreateInfo; + +typedef struct VkBufferCreateInfo { + VkStructureType sType; + const void* pNext; + VkBufferCreateFlags flags; + VkDeviceSize size; + VkBufferUsageFlags usage; + VkSharingMode sharingMode; + uint32_t queueFamilyIndexCount; + const uint32_t* pQueueFamilyIndices; +} VkBufferCreateInfo; + +typedef struct VkBufferViewCreateInfo { + VkStructureType sType; + const void* pNext; + VkBufferViewCreateFlags flags; + VkBuffer buffer; + VkFormat format; + VkDeviceSize offset; + VkDeviceSize range; +} VkBufferViewCreateInfo; + +typedef struct VkImageCreateInfo { + VkStructureType sType; + const void* pNext; + VkImageCreateFlags flags; + VkImageType imageType; + VkFormat format; + VkExtent3D extent; + uint32_t mipLevels; + uint32_t arrayLayers; + VkSampleCountFlagBits samples; + VkImageTiling tiling; + VkImageUsageFlags usage; + VkSharingMode sharingMode; + uint32_t queueFamilyIndexCount; + const uint32_t* pQueueFamilyIndices; + VkImageLayout initialLayout; +} VkImageCreateInfo; + +typedef struct VkSubresourceLayout { + VkDeviceSize offset; + VkDeviceSize size; + VkDeviceSize rowPitch; + VkDeviceSize arrayPitch; + VkDeviceSize depthPitch; +} VkSubresourceLayout; + +typedef struct VkComponentMapping { + VkComponentSwizzle r; + VkComponentSwizzle g; + VkComponentSwizzle b; + VkComponentSwizzle a; +} VkComponentMapping; + +typedef struct VkImageSubresourceRange { + VkImageAspectFlags aspectMask; + uint32_t baseMipLevel; + uint32_t levelCount; + uint32_t baseArrayLayer; + uint32_t layerCount; +} VkImageSubresourceRange; + +typedef struct VkImageViewCreateInfo { + VkStructureType sType; + const void* pNext; + VkImageViewCreateFlags flags; + VkImage image; + VkImageViewType viewType; + VkFormat format; + VkComponentMapping components; + VkImageSubresourceRange subresourceRange; +} VkImageViewCreateInfo; + +typedef struct VkShaderModuleCreateInfo { + VkStructureType sType; + const void* pNext; + VkShaderModuleCreateFlags flags; + size_t codeSize; + const uint32_t* pCode; +} VkShaderModuleCreateInfo; + +typedef struct VkPipelineCacheCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineCacheCreateFlags flags; + size_t initialDataSize; + const void* pInitialData; +} VkPipelineCacheCreateInfo; + +typedef struct VkSpecializationMapEntry { + uint32_t constantID; + uint32_t offset; + size_t size; +} VkSpecializationMapEntry; + +typedef struct VkSpecializationInfo { + uint32_t mapEntryCount; + const VkSpecializationMapEntry* pMapEntries; + size_t dataSize; + const void* pData; +} VkSpecializationInfo; + +typedef struct VkPipelineShaderStageCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineShaderStageCreateFlags flags; + VkShaderStageFlagBits stage; + VkShaderModule module; + const char* pName; + const VkSpecializationInfo* pSpecializationInfo; +} VkPipelineShaderStageCreateInfo; + +typedef struct VkVertexInputBindingDescription { + uint32_t binding; + uint32_t stride; + VkVertexInputRate inputRate; +} VkVertexInputBindingDescription; + +typedef struct VkVertexInputAttributeDescription { + uint32_t location; + uint32_t binding; + VkFormat format; + uint32_t offset; +} VkVertexInputAttributeDescription; + +typedef struct VkPipelineVertexInputStateCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineVertexInputStateCreateFlags flags; + uint32_t vertexBindingDescriptionCount; + const VkVertexInputBindingDescription* pVertexBindingDescriptions; + uint32_t vertexAttributeDescriptionCount; + const VkVertexInputAttributeDescription* pVertexAttributeDescriptions; +} VkPipelineVertexInputStateCreateInfo; + +typedef struct VkPipelineInputAssemblyStateCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineInputAssemblyStateCreateFlags flags; + VkPrimitiveTopology topology; + VkBool32 primitiveRestartEnable; +} VkPipelineInputAssemblyStateCreateInfo; + +typedef struct VkPipelineTessellationStateCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineTessellationStateCreateFlags flags; + uint32_t patchControlPoints; +} VkPipelineTessellationStateCreateInfo; + +typedef struct VkViewport { + float x; + float y; + float width; + float height; + float minDepth; + float maxDepth; +} VkViewport; + +typedef struct VkOffset2D { + int32_t x; + int32_t y; +} VkOffset2D; + +typedef struct VkExtent2D { + uint32_t width; + uint32_t height; +} VkExtent2D; + +typedef struct VkRect2D { + VkOffset2D offset; + VkExtent2D extent; +} VkRect2D; + +typedef struct VkPipelineViewportStateCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineViewportStateCreateFlags flags; + uint32_t viewportCount; + const VkViewport* pViewports; + uint32_t scissorCount; + const VkRect2D* pScissors; +} VkPipelineViewportStateCreateInfo; + +typedef struct VkPipelineRasterizationStateCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineRasterizationStateCreateFlags flags; + VkBool32 depthClampEnable; + VkBool32 rasterizerDiscardEnable; + VkPolygonMode polygonMode; + VkCullModeFlags cullMode; + VkFrontFace frontFace; + VkBool32 depthBiasEnable; + float depthBiasConstantFactor; + float depthBiasClamp; + float depthBiasSlopeFactor; + float lineWidth; +} VkPipelineRasterizationStateCreateInfo; + +typedef struct VkPipelineMultisampleStateCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineMultisampleStateCreateFlags flags; + VkSampleCountFlagBits rasterizationSamples; + VkBool32 sampleShadingEnable; + float minSampleShading; + const VkSampleMask* pSampleMask; + VkBool32 alphaToCoverageEnable; + VkBool32 alphaToOneEnable; +} VkPipelineMultisampleStateCreateInfo; + +typedef struct VkStencilOpState { + VkStencilOp failOp; + VkStencilOp passOp; + VkStencilOp depthFailOp; + VkCompareOp compareOp; + uint32_t compareMask; + uint32_t writeMask; + uint32_t reference; +} VkStencilOpState; + +typedef struct VkPipelineDepthStencilStateCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineDepthStencilStateCreateFlags flags; + VkBool32 depthTestEnable; + VkBool32 depthWriteEnable; + VkCompareOp depthCompareOp; + VkBool32 depthBoundsTestEnable; + VkBool32 stencilTestEnable; + VkStencilOpState front; + VkStencilOpState back; + float minDepthBounds; + float maxDepthBounds; +} VkPipelineDepthStencilStateCreateInfo; + +typedef struct VkPipelineColorBlendAttachmentState { + VkBool32 blendEnable; + VkBlendFactor srcColorBlendFactor; + VkBlendFactor dstColorBlendFactor; + VkBlendOp colorBlendOp; + VkBlendFactor srcAlphaBlendFactor; + VkBlendFactor dstAlphaBlendFactor; + VkBlendOp alphaBlendOp; + VkColorComponentFlags colorWriteMask; +} VkPipelineColorBlendAttachmentState; + +typedef struct VkPipelineColorBlendStateCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineColorBlendStateCreateFlags flags; + VkBool32 logicOpEnable; + VkLogicOp logicOp; + uint32_t attachmentCount; + const VkPipelineColorBlendAttachmentState* pAttachments; + float blendConstants[4]; +} VkPipelineColorBlendStateCreateInfo; + +typedef struct VkPipelineDynamicStateCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineDynamicStateCreateFlags flags; + uint32_t dynamicStateCount; + const VkDynamicState* pDynamicStates; +} VkPipelineDynamicStateCreateInfo; + +typedef struct VkGraphicsPipelineCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineCreateFlags flags; + uint32_t stageCount; + const VkPipelineShaderStageCreateInfo* pStages; + const VkPipelineVertexInputStateCreateInfo* pVertexInputState; + const VkPipelineInputAssemblyStateCreateInfo* pInputAssemblyState; + const VkPipelineTessellationStateCreateInfo* pTessellationState; + const VkPipelineViewportStateCreateInfo* pViewportState; + const VkPipelineRasterizationStateCreateInfo* pRasterizationState; + const VkPipelineMultisampleStateCreateInfo* pMultisampleState; + const VkPipelineDepthStencilStateCreateInfo* pDepthStencilState; + const VkPipelineColorBlendStateCreateInfo* pColorBlendState; + const VkPipelineDynamicStateCreateInfo* pDynamicState; + VkPipelineLayout layout; + VkRenderPass renderPass; + uint32_t subpass; + VkPipeline basePipelineHandle; + int32_t basePipelineIndex; +} VkGraphicsPipelineCreateInfo; + +typedef struct VkComputePipelineCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineCreateFlags flags; + VkPipelineShaderStageCreateInfo stage; + VkPipelineLayout layout; + VkPipeline basePipelineHandle; + int32_t basePipelineIndex; +} VkComputePipelineCreateInfo; + +typedef struct VkPushConstantRange { + VkShaderStageFlags stageFlags; + uint32_t offset; + uint32_t size; +} VkPushConstantRange; + +typedef struct VkPipelineLayoutCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineLayoutCreateFlags flags; + uint32_t setLayoutCount; + const VkDescriptorSetLayout* pSetLayouts; + uint32_t pushConstantRangeCount; + const VkPushConstantRange* pPushConstantRanges; +} VkPipelineLayoutCreateInfo; + +typedef struct VkSamplerCreateInfo { + VkStructureType sType; + const void* pNext; + VkSamplerCreateFlags flags; + VkFilter magFilter; + VkFilter minFilter; + VkSamplerMipmapMode mipmapMode; + VkSamplerAddressMode addressModeU; + VkSamplerAddressMode addressModeV; + VkSamplerAddressMode addressModeW; + float mipLodBias; + VkBool32 anisotropyEnable; + float maxAnisotropy; + VkBool32 compareEnable; + VkCompareOp compareOp; + float minLod; + float maxLod; + VkBorderColor borderColor; + VkBool32 unnormalizedCoordinates; +} VkSamplerCreateInfo; + +typedef struct VkDescriptorSetLayoutBinding { + uint32_t binding; + VkDescriptorType descriptorType; + uint32_t descriptorCount; + VkShaderStageFlags stageFlags; + const VkSampler* pImmutableSamplers; +} VkDescriptorSetLayoutBinding; + +typedef struct VkDescriptorSetLayoutCreateInfo { + VkStructureType sType; + const void* pNext; + VkDescriptorSetLayoutCreateFlags flags; + uint32_t bindingCount; + const VkDescriptorSetLayoutBinding* pBindings; +} VkDescriptorSetLayoutCreateInfo; + +typedef struct VkDescriptorPoolSize { + VkDescriptorType type; + uint32_t descriptorCount; +} VkDescriptorPoolSize; + +typedef struct VkDescriptorPoolCreateInfo { + VkStructureType sType; + const void* pNext; + VkDescriptorPoolCreateFlags flags; + uint32_t maxSets; + uint32_t poolSizeCount; + const VkDescriptorPoolSize* pPoolSizes; +} VkDescriptorPoolCreateInfo; + +typedef struct VkDescriptorSetAllocateInfo { + VkStructureType sType; + const void* pNext; + VkDescriptorPool descriptorPool; + uint32_t descriptorSetCount; + const VkDescriptorSetLayout* pSetLayouts; +} VkDescriptorSetAllocateInfo; + +typedef struct VkDescriptorImageInfo { + VkSampler sampler; + VkImageView imageView; + VkImageLayout imageLayout; +} VkDescriptorImageInfo; + +typedef struct VkDescriptorBufferInfo { + VkBuffer buffer; + VkDeviceSize offset; + VkDeviceSize range; +} VkDescriptorBufferInfo; + +typedef struct VkWriteDescriptorSet { + VkStructureType sType; + const void* pNext; + VkDescriptorSet dstSet; + uint32_t dstBinding; + uint32_t dstArrayElement; + uint32_t descriptorCount; + VkDescriptorType descriptorType; + const VkDescriptorImageInfo* pImageInfo; + const VkDescriptorBufferInfo* pBufferInfo; + const VkBufferView* pTexelBufferView; +} VkWriteDescriptorSet; + +typedef struct VkCopyDescriptorSet { + VkStructureType sType; + const void* pNext; + VkDescriptorSet srcSet; + uint32_t srcBinding; + uint32_t srcArrayElement; + VkDescriptorSet dstSet; + uint32_t dstBinding; + uint32_t dstArrayElement; + uint32_t descriptorCount; +} VkCopyDescriptorSet; + +typedef struct VkFramebufferCreateInfo { + VkStructureType sType; + const void* pNext; + VkFramebufferCreateFlags flags; + VkRenderPass renderPass; + uint32_t attachmentCount; + const VkImageView* pAttachments; + uint32_t width; + uint32_t height; + uint32_t layers; +} VkFramebufferCreateInfo; + +typedef struct VkAttachmentDescription { + VkAttachmentDescriptionFlags flags; + VkFormat format; + VkSampleCountFlagBits samples; + VkAttachmentLoadOp loadOp; + VkAttachmentStoreOp storeOp; + VkAttachmentLoadOp stencilLoadOp; + VkAttachmentStoreOp stencilStoreOp; + VkImageLayout initialLayout; + VkImageLayout finalLayout; +} VkAttachmentDescription; + +typedef struct VkAttachmentReference { + uint32_t attachment; + VkImageLayout layout; +} VkAttachmentReference; + +typedef struct VkSubpassDescription { + VkSubpassDescriptionFlags flags; + VkPipelineBindPoint pipelineBindPoint; + uint32_t inputAttachmentCount; + const VkAttachmentReference* pInputAttachments; + uint32_t colorAttachmentCount; + const VkAttachmentReference* pColorAttachments; + const VkAttachmentReference* pResolveAttachments; + const VkAttachmentReference* pDepthStencilAttachment; + uint32_t preserveAttachmentCount; + const uint32_t* pPreserveAttachments; +} VkSubpassDescription; + +typedef struct VkSubpassDependency { + uint32_t srcSubpass; + uint32_t dstSubpass; + VkPipelineStageFlags srcStageMask; + VkPipelineStageFlags dstStageMask; + VkAccessFlags srcAccessMask; + VkAccessFlags dstAccessMask; + VkDependencyFlags dependencyFlags; +} VkSubpassDependency; + +typedef struct VkRenderPassCreateInfo { + VkStructureType sType; + const void* pNext; + VkRenderPassCreateFlags flags; + uint32_t attachmentCount; + const VkAttachmentDescription* pAttachments; + uint32_t subpassCount; + const VkSubpassDescription* pSubpasses; + uint32_t dependencyCount; + const VkSubpassDependency* pDependencies; +} VkRenderPassCreateInfo; + +typedef struct VkCommandPoolCreateInfo { + VkStructureType sType; + const void* pNext; + VkCommandPoolCreateFlags flags; + uint32_t queueFamilyIndex; +} VkCommandPoolCreateInfo; + +typedef struct VkCommandBufferAllocateInfo { + VkStructureType sType; + const void* pNext; + VkCommandPool commandPool; + VkCommandBufferLevel level; + uint32_t commandBufferCount; +} VkCommandBufferAllocateInfo; + +typedef struct VkCommandBufferInheritanceInfo { + VkStructureType sType; + const void* pNext; + VkRenderPass renderPass; + uint32_t subpass; + VkFramebuffer framebuffer; + VkBool32 occlusionQueryEnable; + VkQueryControlFlags queryFlags; + VkQueryPipelineStatisticFlags pipelineStatistics; +} VkCommandBufferInheritanceInfo; + +typedef struct VkCommandBufferBeginInfo { + VkStructureType sType; + const void* pNext; + VkCommandBufferUsageFlags flags; + const VkCommandBufferInheritanceInfo* pInheritanceInfo; +} VkCommandBufferBeginInfo; + +typedef struct VkBufferCopy { + VkDeviceSize srcOffset; + VkDeviceSize dstOffset; + VkDeviceSize size; +} VkBufferCopy; + +typedef struct VkImageSubresourceLayers { + VkImageAspectFlags aspectMask; + uint32_t mipLevel; + uint32_t baseArrayLayer; + uint32_t layerCount; +} VkImageSubresourceLayers; + +typedef struct VkImageCopy { + VkImageSubresourceLayers srcSubresource; + VkOffset3D srcOffset; + VkImageSubresourceLayers dstSubresource; + VkOffset3D dstOffset; + VkExtent3D extent; +} VkImageCopy; + +typedef struct VkImageBlit { + VkImageSubresourceLayers srcSubresource; + VkOffset3D srcOffsets[2]; + VkImageSubresourceLayers dstSubresource; + VkOffset3D dstOffsets[2]; +} VkImageBlit; + +typedef struct VkBufferImageCopy { + VkDeviceSize bufferOffset; + uint32_t bufferRowLength; + uint32_t bufferImageHeight; + VkImageSubresourceLayers imageSubresource; + VkOffset3D imageOffset; + VkExtent3D imageExtent; +} VkBufferImageCopy; + +typedef union VkClearColorValue { + float float32[4]; + int32_t int32[4]; + uint32_t uint32[4]; +} VkClearColorValue; + +typedef struct VkClearDepthStencilValue { + float depth; + uint32_t stencil; +} VkClearDepthStencilValue; + +typedef union VkClearValue { + VkClearColorValue color; + VkClearDepthStencilValue depthStencil; +} VkClearValue; + +typedef struct VkClearAttachment { + VkImageAspectFlags aspectMask; + uint32_t colorAttachment; + VkClearValue clearValue; +} VkClearAttachment; + +typedef struct VkClearRect { + VkRect2D rect; + uint32_t baseArrayLayer; + uint32_t layerCount; +} VkClearRect; + +typedef struct VkImageResolve { + VkImageSubresourceLayers srcSubresource; + VkOffset3D srcOffset; + VkImageSubresourceLayers dstSubresource; + VkOffset3D dstOffset; + VkExtent3D extent; +} VkImageResolve; + +typedef struct VkMemoryBarrier { + VkStructureType sType; + const void* pNext; + VkAccessFlags srcAccessMask; + VkAccessFlags dstAccessMask; +} VkMemoryBarrier; + +typedef struct VkBufferMemoryBarrier { + VkStructureType sType; + const void* pNext; + VkAccessFlags srcAccessMask; + VkAccessFlags dstAccessMask; + uint32_t srcQueueFamilyIndex; + uint32_t dstQueueFamilyIndex; + VkBuffer buffer; + VkDeviceSize offset; + VkDeviceSize size; +} VkBufferMemoryBarrier; + +typedef struct VkImageMemoryBarrier { + VkStructureType sType; + const void* pNext; + VkAccessFlags srcAccessMask; + VkAccessFlags dstAccessMask; + VkImageLayout oldLayout; + VkImageLayout newLayout; + uint32_t srcQueueFamilyIndex; + uint32_t dstQueueFamilyIndex; + VkImage image; + VkImageSubresourceRange subresourceRange; +} VkImageMemoryBarrier; + +typedef struct VkRenderPassBeginInfo { + VkStructureType sType; + const void* pNext; + VkRenderPass renderPass; + VkFramebuffer framebuffer; + VkRect2D renderArea; + uint32_t clearValueCount; + const VkClearValue* pClearValues; +} VkRenderPassBeginInfo; + +typedef struct VkDispatchIndirectCommand { + uint32_t x; + uint32_t y; + uint32_t z; +} VkDispatchIndirectCommand; + +typedef struct VkDrawIndexedIndirectCommand { + uint32_t indexCount; + uint32_t instanceCount; + uint32_t firstIndex; + int32_t vertexOffset; + uint32_t firstInstance; +} VkDrawIndexedIndirectCommand; + +typedef struct VkDrawIndirectCommand { + uint32_t vertexCount; + uint32_t instanceCount; + uint32_t firstVertex; + uint32_t firstInstance; +} VkDrawIndirectCommand; + + +typedef VkResult (VKAPI_PTR *PFN_vkCreateInstance)(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance); +typedef void (VKAPI_PTR *PFN_vkDestroyInstance)(VkInstance instance, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkEnumeratePhysicalDevices)(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFeatures)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties); +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyProperties)(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceMemoryProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties); +typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_vkGetInstanceProcAddr)(VkInstance instance, const char* pName); +typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_vkGetDeviceProcAddr)(VkDevice device, const char* pName); +typedef VkResult (VKAPI_PTR *PFN_vkCreateDevice)(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice); +typedef void (VKAPI_PTR *PFN_vkDestroyDevice)(VkDevice device, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkEnumerateInstanceExtensionProperties)(const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties); +typedef VkResult (VKAPI_PTR *PFN_vkEnumerateDeviceExtensionProperties)(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties); +typedef VkResult (VKAPI_PTR *PFN_vkEnumerateInstanceLayerProperties)(uint32_t* pPropertyCount, VkLayerProperties* pProperties); +typedef VkResult (VKAPI_PTR *PFN_vkEnumerateDeviceLayerProperties)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties); +typedef void (VKAPI_PTR *PFN_vkGetDeviceQueue)(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue); +typedef VkResult (VKAPI_PTR *PFN_vkQueueSubmit)(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence); +typedef VkResult (VKAPI_PTR *PFN_vkQueueWaitIdle)(VkQueue queue); +typedef VkResult (VKAPI_PTR *PFN_vkDeviceWaitIdle)(VkDevice device); +typedef VkResult (VKAPI_PTR *PFN_vkAllocateMemory)(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory); +typedef void (VKAPI_PTR *PFN_vkFreeMemory)(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkMapMemory)(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData); +typedef void (VKAPI_PTR *PFN_vkUnmapMemory)(VkDevice device, VkDeviceMemory memory); +typedef VkResult (VKAPI_PTR *PFN_vkFlushMappedMemoryRanges)(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges); +typedef VkResult (VKAPI_PTR *PFN_vkInvalidateMappedMemoryRanges)(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges); +typedef void (VKAPI_PTR *PFN_vkGetDeviceMemoryCommitment)(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes); +typedef VkResult (VKAPI_PTR *PFN_vkBindBufferMemory)(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset); +typedef VkResult (VKAPI_PTR *PFN_vkBindImageMemory)(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset); +typedef void (VKAPI_PTR *PFN_vkGetBufferMemoryRequirements)(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements); +typedef void (VKAPI_PTR *PFN_vkGetImageMemoryRequirements)(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements); +typedef void (VKAPI_PTR *PFN_vkGetImageSparseMemoryRequirements)(VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceSparseImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties); +typedef VkResult (VKAPI_PTR *PFN_vkQueueBindSparse)(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence); +typedef VkResult (VKAPI_PTR *PFN_vkCreateFence)(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence); +typedef void (VKAPI_PTR *PFN_vkDestroyFence)(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkResetFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences); +typedef VkResult (VKAPI_PTR *PFN_vkGetFenceStatus)(VkDevice device, VkFence fence); +typedef VkResult (VKAPI_PTR *PFN_vkWaitForFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout); +typedef VkResult (VKAPI_PTR *PFN_vkCreateSemaphore)(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore); +typedef void (VKAPI_PTR *PFN_vkDestroySemaphore)(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkCreateEvent)(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent); +typedef void (VKAPI_PTR *PFN_vkDestroyEvent)(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkGetEventStatus)(VkDevice device, VkEvent event); +typedef VkResult (VKAPI_PTR *PFN_vkSetEvent)(VkDevice device, VkEvent event); +typedef VkResult (VKAPI_PTR *PFN_vkResetEvent)(VkDevice device, VkEvent event); +typedef VkResult (VKAPI_PTR *PFN_vkCreateQueryPool)(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool); +typedef void (VKAPI_PTR *PFN_vkDestroyQueryPool)(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkGetQueryPoolResults)(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags); +typedef VkResult (VKAPI_PTR *PFN_vkCreateBuffer)(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer); +typedef void (VKAPI_PTR *PFN_vkDestroyBuffer)(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkCreateBufferView)(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView); +typedef void (VKAPI_PTR *PFN_vkDestroyBufferView)(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkCreateImage)(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage); +typedef void (VKAPI_PTR *PFN_vkDestroyImage)(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator); +typedef void (VKAPI_PTR *PFN_vkGetImageSubresourceLayout)(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout); +typedef VkResult (VKAPI_PTR *PFN_vkCreateImageView)(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView); +typedef void (VKAPI_PTR *PFN_vkDestroyImageView)(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkCreateShaderModule)(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule); +typedef void (VKAPI_PTR *PFN_vkDestroyShaderModule)(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkCreatePipelineCache)(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache); +typedef void (VKAPI_PTR *PFN_vkDestroyPipelineCache)(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkGetPipelineCacheData)(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData); +typedef VkResult (VKAPI_PTR *PFN_vkMergePipelineCaches)(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches); +typedef VkResult (VKAPI_PTR *PFN_vkCreateGraphicsPipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines); +typedef VkResult (VKAPI_PTR *PFN_vkCreateComputePipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines); +typedef void (VKAPI_PTR *PFN_vkDestroyPipeline)(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkCreatePipelineLayout)(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout); +typedef void (VKAPI_PTR *PFN_vkDestroyPipelineLayout)(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkCreateSampler)(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler); +typedef void (VKAPI_PTR *PFN_vkDestroySampler)(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorSetLayout)(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout); +typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorSetLayout)(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorPool)(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool); +typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkResetDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags); +typedef VkResult (VKAPI_PTR *PFN_vkAllocateDescriptorSets)(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets); +typedef VkResult (VKAPI_PTR *PFN_vkFreeDescriptorSets)(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets); +typedef void (VKAPI_PTR *PFN_vkUpdateDescriptorSets)(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies); +typedef VkResult (VKAPI_PTR *PFN_vkCreateFramebuffer)(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer); +typedef void (VKAPI_PTR *PFN_vkDestroyFramebuffer)(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkCreateRenderPass)(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass); +typedef void (VKAPI_PTR *PFN_vkDestroyRenderPass)(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator); +typedef void (VKAPI_PTR *PFN_vkGetRenderAreaGranularity)(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity); +typedef VkResult (VKAPI_PTR *PFN_vkCreateCommandPool)(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool); +typedef void (VKAPI_PTR *PFN_vkDestroyCommandPool)(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkResetCommandPool)(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags); +typedef VkResult (VKAPI_PTR *PFN_vkAllocateCommandBuffers)(VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers); +typedef void (VKAPI_PTR *PFN_vkFreeCommandBuffers)(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers); +typedef VkResult (VKAPI_PTR *PFN_vkBeginCommandBuffer)(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo); +typedef VkResult (VKAPI_PTR *PFN_vkEndCommandBuffer)(VkCommandBuffer commandBuffer); +typedef VkResult (VKAPI_PTR *PFN_vkResetCommandBuffer)(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags); +typedef void (VKAPI_PTR *PFN_vkCmdBindPipeline)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline); +typedef void (VKAPI_PTR *PFN_vkCmdSetViewport)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports); +typedef void (VKAPI_PTR *PFN_vkCmdSetScissor)(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors); +typedef void (VKAPI_PTR *PFN_vkCmdSetLineWidth)(VkCommandBuffer commandBuffer, float lineWidth); +typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBias)(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor); +typedef void (VKAPI_PTR *PFN_vkCmdSetBlendConstants)(VkCommandBuffer commandBuffer, const float blendConstants[4]); +typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBounds)(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds); +typedef void (VKAPI_PTR *PFN_vkCmdSetStencilCompareMask)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask); +typedef void (VKAPI_PTR *PFN_vkCmdSetStencilWriteMask)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask); +typedef void (VKAPI_PTR *PFN_vkCmdSetStencilReference)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference); +typedef void (VKAPI_PTR *PFN_vkCmdBindDescriptorSets)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets); +typedef void (VKAPI_PTR *PFN_vkCmdBindIndexBuffer)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType); +typedef void (VKAPI_PTR *PFN_vkCmdBindVertexBuffers)(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets); +typedef void (VKAPI_PTR *PFN_vkCmdDraw)(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance); +typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexed)(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance); +typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride); +typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexedIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride); +typedef void (VKAPI_PTR *PFN_vkCmdDispatch)(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ); +typedef void (VKAPI_PTR *PFN_vkCmdDispatchIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset); +typedef void (VKAPI_PTR *PFN_vkCmdCopyBuffer)(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions); +typedef void (VKAPI_PTR *PFN_vkCmdCopyImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions); +typedef void (VKAPI_PTR *PFN_vkCmdBlitImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter); +typedef void (VKAPI_PTR *PFN_vkCmdCopyBufferToImage)(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions); +typedef void (VKAPI_PTR *PFN_vkCmdCopyImageToBuffer)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions); +typedef void (VKAPI_PTR *PFN_vkCmdUpdateBuffer)(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData); +typedef void (VKAPI_PTR *PFN_vkCmdFillBuffer)(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data); +typedef void (VKAPI_PTR *PFN_vkCmdClearColorImage)(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges); +typedef void (VKAPI_PTR *PFN_vkCmdClearDepthStencilImage)(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges); +typedef void (VKAPI_PTR *PFN_vkCmdClearAttachments)(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects); +typedef void (VKAPI_PTR *PFN_vkCmdResolveImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions); +typedef void (VKAPI_PTR *PFN_vkCmdSetEvent)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask); +typedef void (VKAPI_PTR *PFN_vkCmdResetEvent)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask); +typedef void (VKAPI_PTR *PFN_vkCmdWaitEvents)(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers); +typedef void (VKAPI_PTR *PFN_vkCmdPipelineBarrier)(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers); +typedef void (VKAPI_PTR *PFN_vkCmdBeginQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags); +typedef void (VKAPI_PTR *PFN_vkCmdEndQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query); +typedef void (VKAPI_PTR *PFN_vkCmdResetQueryPool)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount); +typedef void (VKAPI_PTR *PFN_vkCmdWriteTimestamp)(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query); +typedef void (VKAPI_PTR *PFN_vkCmdCopyQueryPoolResults)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags); +typedef void (VKAPI_PTR *PFN_vkCmdPushConstants)(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues); +typedef void (VKAPI_PTR *PFN_vkCmdBeginRenderPass)(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents); +typedef void (VKAPI_PTR *PFN_vkCmdNextSubpass)(VkCommandBuffer commandBuffer, VkSubpassContents contents); +typedef void (VKAPI_PTR *PFN_vkCmdEndRenderPass)(VkCommandBuffer commandBuffer); +typedef void (VKAPI_PTR *PFN_vkCmdExecuteCommands)(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateInstance( + const VkInstanceCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkInstance* pInstance); + +VKAPI_ATTR void VKAPI_CALL vkDestroyInstance( + VkInstance instance, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDevices( + VkInstance instance, + uint32_t* pPhysicalDeviceCount, + VkPhysicalDevice* pPhysicalDevices); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceFeatures* pFeatures); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties( + VkPhysicalDevice physicalDevice, + VkFormat format, + VkFormatProperties* pFormatProperties); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties( + VkPhysicalDevice physicalDevice, + VkFormat format, + VkImageType type, + VkImageTiling tiling, + VkImageUsageFlags usage, + VkImageCreateFlags flags, + VkImageFormatProperties* pImageFormatProperties); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceProperties* pProperties); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties( + VkPhysicalDevice physicalDevice, + uint32_t* pQueueFamilyPropertyCount, + VkQueueFamilyProperties* pQueueFamilyProperties); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceMemoryProperties* pMemoryProperties); + +VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetInstanceProcAddr( + VkInstance instance, + const char* pName); + +VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetDeviceProcAddr( + VkDevice device, + const char* pName); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateDevice( + VkPhysicalDevice physicalDevice, + const VkDeviceCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDevice* pDevice); + +VKAPI_ATTR void VKAPI_CALL vkDestroyDevice( + VkDevice device, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceExtensionProperties( + const char* pLayerName, + uint32_t* pPropertyCount, + VkExtensionProperties* pProperties); + +VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceExtensionProperties( + VkPhysicalDevice physicalDevice, + const char* pLayerName, + uint32_t* pPropertyCount, + VkExtensionProperties* pProperties); + +VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceLayerProperties( + uint32_t* pPropertyCount, + VkLayerProperties* pProperties); + +VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceLayerProperties( + VkPhysicalDevice physicalDevice, + uint32_t* pPropertyCount, + VkLayerProperties* pProperties); + +VKAPI_ATTR void VKAPI_CALL vkGetDeviceQueue( + VkDevice device, + uint32_t queueFamilyIndex, + uint32_t queueIndex, + VkQueue* pQueue); + +VKAPI_ATTR VkResult VKAPI_CALL vkQueueSubmit( + VkQueue queue, + uint32_t submitCount, + const VkSubmitInfo* pSubmits, + VkFence fence); + +VKAPI_ATTR VkResult VKAPI_CALL vkQueueWaitIdle( + VkQueue queue); + +VKAPI_ATTR VkResult VKAPI_CALL vkDeviceWaitIdle( + VkDevice device); + +VKAPI_ATTR VkResult VKAPI_CALL vkAllocateMemory( + VkDevice device, + const VkMemoryAllocateInfo* pAllocateInfo, + const VkAllocationCallbacks* pAllocator, + VkDeviceMemory* pMemory); + +VKAPI_ATTR void VKAPI_CALL vkFreeMemory( + VkDevice device, + VkDeviceMemory memory, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkMapMemory( + VkDevice device, + VkDeviceMemory memory, + VkDeviceSize offset, + VkDeviceSize size, + VkMemoryMapFlags flags, + void** ppData); + +VKAPI_ATTR void VKAPI_CALL vkUnmapMemory( + VkDevice device, + VkDeviceMemory memory); + +VKAPI_ATTR VkResult VKAPI_CALL vkFlushMappedMemoryRanges( + VkDevice device, + uint32_t memoryRangeCount, + const VkMappedMemoryRange* pMemoryRanges); + +VKAPI_ATTR VkResult VKAPI_CALL vkInvalidateMappedMemoryRanges( + VkDevice device, + uint32_t memoryRangeCount, + const VkMappedMemoryRange* pMemoryRanges); + +VKAPI_ATTR void VKAPI_CALL vkGetDeviceMemoryCommitment( + VkDevice device, + VkDeviceMemory memory, + VkDeviceSize* pCommittedMemoryInBytes); + +VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory( + VkDevice device, + VkBuffer buffer, + VkDeviceMemory memory, + VkDeviceSize memoryOffset); + +VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory( + VkDevice device, + VkImage image, + VkDeviceMemory memory, + VkDeviceSize memoryOffset); + +VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements( + VkDevice device, + VkBuffer buffer, + VkMemoryRequirements* pMemoryRequirements); + +VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements( + VkDevice device, + VkImage image, + VkMemoryRequirements* pMemoryRequirements); + +VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements( + VkDevice device, + VkImage image, + uint32_t* pSparseMemoryRequirementCount, + VkSparseImageMemoryRequirements* pSparseMemoryRequirements); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties( + VkPhysicalDevice physicalDevice, + VkFormat format, + VkImageType type, + VkSampleCountFlagBits samples, + VkImageUsageFlags usage, + VkImageTiling tiling, + uint32_t* pPropertyCount, + VkSparseImageFormatProperties* pProperties); + +VKAPI_ATTR VkResult VKAPI_CALL vkQueueBindSparse( + VkQueue queue, + uint32_t bindInfoCount, + const VkBindSparseInfo* pBindInfo, + VkFence fence); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateFence( + VkDevice device, + const VkFenceCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkFence* pFence); + +VKAPI_ATTR void VKAPI_CALL vkDestroyFence( + VkDevice device, + VkFence fence, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkResetFences( + VkDevice device, + uint32_t fenceCount, + const VkFence* pFences); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceStatus( + VkDevice device, + VkFence fence); + +VKAPI_ATTR VkResult VKAPI_CALL vkWaitForFences( + VkDevice device, + uint32_t fenceCount, + const VkFence* pFences, + VkBool32 waitAll, + uint64_t timeout); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateSemaphore( + VkDevice device, + const VkSemaphoreCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSemaphore* pSemaphore); + +VKAPI_ATTR void VKAPI_CALL vkDestroySemaphore( + VkDevice device, + VkSemaphore semaphore, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateEvent( + VkDevice device, + const VkEventCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkEvent* pEvent); + +VKAPI_ATTR void VKAPI_CALL vkDestroyEvent( + VkDevice device, + VkEvent event, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetEventStatus( + VkDevice device, + VkEvent event); + +VKAPI_ATTR VkResult VKAPI_CALL vkSetEvent( + VkDevice device, + VkEvent event); + +VKAPI_ATTR VkResult VKAPI_CALL vkResetEvent( + VkDevice device, + VkEvent event); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateQueryPool( + VkDevice device, + const VkQueryPoolCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkQueryPool* pQueryPool); + +VKAPI_ATTR void VKAPI_CALL vkDestroyQueryPool( + VkDevice device, + VkQueryPool queryPool, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetQueryPoolResults( + VkDevice device, + VkQueryPool queryPool, + uint32_t firstQuery, + uint32_t queryCount, + size_t dataSize, + void* pData, + VkDeviceSize stride, + VkQueryResultFlags flags); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateBuffer( + VkDevice device, + const VkBufferCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkBuffer* pBuffer); + +VKAPI_ATTR void VKAPI_CALL vkDestroyBuffer( + VkDevice device, + VkBuffer buffer, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateBufferView( + VkDevice device, + const VkBufferViewCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkBufferView* pView); + +VKAPI_ATTR void VKAPI_CALL vkDestroyBufferView( + VkDevice device, + VkBufferView bufferView, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateImage( + VkDevice device, + const VkImageCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkImage* pImage); + +VKAPI_ATTR void VKAPI_CALL vkDestroyImage( + VkDevice device, + VkImage image, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR void VKAPI_CALL vkGetImageSubresourceLayout( + VkDevice device, + VkImage image, + const VkImageSubresource* pSubresource, + VkSubresourceLayout* pLayout); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateImageView( + VkDevice device, + const VkImageViewCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkImageView* pView); + +VKAPI_ATTR void VKAPI_CALL vkDestroyImageView( + VkDevice device, + VkImageView imageView, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateShaderModule( + VkDevice device, + const VkShaderModuleCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkShaderModule* pShaderModule); + +VKAPI_ATTR void VKAPI_CALL vkDestroyShaderModule( + VkDevice device, + VkShaderModule shaderModule, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineCache( + VkDevice device, + const VkPipelineCacheCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkPipelineCache* pPipelineCache); + +VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineCache( + VkDevice device, + VkPipelineCache pipelineCache, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineCacheData( + VkDevice device, + VkPipelineCache pipelineCache, + size_t* pDataSize, + void* pData); + +VKAPI_ATTR VkResult VKAPI_CALL vkMergePipelineCaches( + VkDevice device, + VkPipelineCache dstCache, + uint32_t srcCacheCount, + const VkPipelineCache* pSrcCaches); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateGraphicsPipelines( + VkDevice device, + VkPipelineCache pipelineCache, + uint32_t createInfoCount, + const VkGraphicsPipelineCreateInfo* pCreateInfos, + const VkAllocationCallbacks* pAllocator, + VkPipeline* pPipelines); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateComputePipelines( + VkDevice device, + VkPipelineCache pipelineCache, + uint32_t createInfoCount, + const VkComputePipelineCreateInfo* pCreateInfos, + const VkAllocationCallbacks* pAllocator, + VkPipeline* pPipelines); + +VKAPI_ATTR void VKAPI_CALL vkDestroyPipeline( + VkDevice device, + VkPipeline pipeline, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineLayout( + VkDevice device, + const VkPipelineLayoutCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkPipelineLayout* pPipelineLayout); + +VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineLayout( + VkDevice device, + VkPipelineLayout pipelineLayout, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateSampler( + VkDevice device, + const VkSamplerCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSampler* pSampler); + +VKAPI_ATTR void VKAPI_CALL vkDestroySampler( + VkDevice device, + VkSampler sampler, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorSetLayout( + VkDevice device, + const VkDescriptorSetLayoutCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDescriptorSetLayout* pSetLayout); + +VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorSetLayout( + VkDevice device, + VkDescriptorSetLayout descriptorSetLayout, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorPool( + VkDevice device, + const VkDescriptorPoolCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDescriptorPool* pDescriptorPool); + +VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorPool( + VkDevice device, + VkDescriptorPool descriptorPool, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkResetDescriptorPool( + VkDevice device, + VkDescriptorPool descriptorPool, + VkDescriptorPoolResetFlags flags); + +VKAPI_ATTR VkResult VKAPI_CALL vkAllocateDescriptorSets( + VkDevice device, + const VkDescriptorSetAllocateInfo* pAllocateInfo, + VkDescriptorSet* pDescriptorSets); + +VKAPI_ATTR VkResult VKAPI_CALL vkFreeDescriptorSets( + VkDevice device, + VkDescriptorPool descriptorPool, + uint32_t descriptorSetCount, + const VkDescriptorSet* pDescriptorSets); + +VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSets( + VkDevice device, + uint32_t descriptorWriteCount, + const VkWriteDescriptorSet* pDescriptorWrites, + uint32_t descriptorCopyCount, + const VkCopyDescriptorSet* pDescriptorCopies); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateFramebuffer( + VkDevice device, + const VkFramebufferCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkFramebuffer* pFramebuffer); + +VKAPI_ATTR void VKAPI_CALL vkDestroyFramebuffer( + VkDevice device, + VkFramebuffer framebuffer, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateRenderPass( + VkDevice device, + const VkRenderPassCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkRenderPass* pRenderPass); + +VKAPI_ATTR void VKAPI_CALL vkDestroyRenderPass( + VkDevice device, + VkRenderPass renderPass, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR void VKAPI_CALL vkGetRenderAreaGranularity( + VkDevice device, + VkRenderPass renderPass, + VkExtent2D* pGranularity); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateCommandPool( + VkDevice device, + const VkCommandPoolCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkCommandPool* pCommandPool); + +VKAPI_ATTR void VKAPI_CALL vkDestroyCommandPool( + VkDevice device, + VkCommandPool commandPool, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandPool( + VkDevice device, + VkCommandPool commandPool, + VkCommandPoolResetFlags flags); + +VKAPI_ATTR VkResult VKAPI_CALL vkAllocateCommandBuffers( + VkDevice device, + const VkCommandBufferAllocateInfo* pAllocateInfo, + VkCommandBuffer* pCommandBuffers); + +VKAPI_ATTR void VKAPI_CALL vkFreeCommandBuffers( + VkDevice device, + VkCommandPool commandPool, + uint32_t commandBufferCount, + const VkCommandBuffer* pCommandBuffers); + +VKAPI_ATTR VkResult VKAPI_CALL vkBeginCommandBuffer( + VkCommandBuffer commandBuffer, + const VkCommandBufferBeginInfo* pBeginInfo); + +VKAPI_ATTR VkResult VKAPI_CALL vkEndCommandBuffer( + VkCommandBuffer commandBuffer); + +VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandBuffer( + VkCommandBuffer commandBuffer, + VkCommandBufferResetFlags flags); + +VKAPI_ATTR void VKAPI_CALL vkCmdBindPipeline( + VkCommandBuffer commandBuffer, + VkPipelineBindPoint pipelineBindPoint, + VkPipeline pipeline); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetViewport( + VkCommandBuffer commandBuffer, + uint32_t firstViewport, + uint32_t viewportCount, + const VkViewport* pViewports); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetScissor( + VkCommandBuffer commandBuffer, + uint32_t firstScissor, + uint32_t scissorCount, + const VkRect2D* pScissors); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetLineWidth( + VkCommandBuffer commandBuffer, + float lineWidth); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBias( + VkCommandBuffer commandBuffer, + float depthBiasConstantFactor, + float depthBiasClamp, + float depthBiasSlopeFactor); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetBlendConstants( + VkCommandBuffer commandBuffer, + const float blendConstants[4]); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBounds( + VkCommandBuffer commandBuffer, + float minDepthBounds, + float maxDepthBounds); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilCompareMask( + VkCommandBuffer commandBuffer, + VkStencilFaceFlags faceMask, + uint32_t compareMask); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilWriteMask( + VkCommandBuffer commandBuffer, + VkStencilFaceFlags faceMask, + uint32_t writeMask); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilReference( + VkCommandBuffer commandBuffer, + VkStencilFaceFlags faceMask, + uint32_t reference); + +VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorSets( + VkCommandBuffer commandBuffer, + VkPipelineBindPoint pipelineBindPoint, + VkPipelineLayout layout, + uint32_t firstSet, + uint32_t descriptorSetCount, + const VkDescriptorSet* pDescriptorSets, + uint32_t dynamicOffsetCount, + const uint32_t* pDynamicOffsets); + +VKAPI_ATTR void VKAPI_CALL vkCmdBindIndexBuffer( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + VkIndexType indexType); + +VKAPI_ATTR void VKAPI_CALL vkCmdBindVertexBuffers( + VkCommandBuffer commandBuffer, + uint32_t firstBinding, + uint32_t bindingCount, + const VkBuffer* pBuffers, + const VkDeviceSize* pOffsets); + +VKAPI_ATTR void VKAPI_CALL vkCmdDraw( + VkCommandBuffer commandBuffer, + uint32_t vertexCount, + uint32_t instanceCount, + uint32_t firstVertex, + uint32_t firstInstance); + +VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexed( + VkCommandBuffer commandBuffer, + uint32_t indexCount, + uint32_t instanceCount, + uint32_t firstIndex, + int32_t vertexOffset, + uint32_t firstInstance); + +VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirect( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + uint32_t drawCount, + uint32_t stride); + +VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirect( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + uint32_t drawCount, + uint32_t stride); + +VKAPI_ATTR void VKAPI_CALL vkCmdDispatch( + VkCommandBuffer commandBuffer, + uint32_t groupCountX, + uint32_t groupCountY, + uint32_t groupCountZ); + +VKAPI_ATTR void VKAPI_CALL vkCmdDispatchIndirect( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset); + +VKAPI_ATTR void VKAPI_CALL vkCmdCopyBuffer( + VkCommandBuffer commandBuffer, + VkBuffer srcBuffer, + VkBuffer dstBuffer, + uint32_t regionCount, + const VkBufferCopy* pRegions); + +VKAPI_ATTR void VKAPI_CALL vkCmdCopyImage( + VkCommandBuffer commandBuffer, + VkImage srcImage, + VkImageLayout srcImageLayout, + VkImage dstImage, + VkImageLayout dstImageLayout, + uint32_t regionCount, + const VkImageCopy* pRegions); + +VKAPI_ATTR void VKAPI_CALL vkCmdBlitImage( + VkCommandBuffer commandBuffer, + VkImage srcImage, + VkImageLayout srcImageLayout, + VkImage dstImage, + VkImageLayout dstImageLayout, + uint32_t regionCount, + const VkImageBlit* pRegions, + VkFilter filter); + +VKAPI_ATTR void VKAPI_CALL vkCmdCopyBufferToImage( + VkCommandBuffer commandBuffer, + VkBuffer srcBuffer, + VkImage dstImage, + VkImageLayout dstImageLayout, + uint32_t regionCount, + const VkBufferImageCopy* pRegions); + +VKAPI_ATTR void VKAPI_CALL vkCmdCopyImageToBuffer( + VkCommandBuffer commandBuffer, + VkImage srcImage, + VkImageLayout srcImageLayout, + VkBuffer dstBuffer, + uint32_t regionCount, + const VkBufferImageCopy* pRegions); + +VKAPI_ATTR void VKAPI_CALL vkCmdUpdateBuffer( + VkCommandBuffer commandBuffer, + VkBuffer dstBuffer, + VkDeviceSize dstOffset, + VkDeviceSize dataSize, + const void* pData); + +VKAPI_ATTR void VKAPI_CALL vkCmdFillBuffer( + VkCommandBuffer commandBuffer, + VkBuffer dstBuffer, + VkDeviceSize dstOffset, + VkDeviceSize size, + uint32_t data); + +VKAPI_ATTR void VKAPI_CALL vkCmdClearColorImage( + VkCommandBuffer commandBuffer, + VkImage image, + VkImageLayout imageLayout, + const VkClearColorValue* pColor, + uint32_t rangeCount, + const VkImageSubresourceRange* pRanges); + +VKAPI_ATTR void VKAPI_CALL vkCmdClearDepthStencilImage( + VkCommandBuffer commandBuffer, + VkImage image, + VkImageLayout imageLayout, + const VkClearDepthStencilValue* pDepthStencil, + uint32_t rangeCount, + const VkImageSubresourceRange* pRanges); + +VKAPI_ATTR void VKAPI_CALL vkCmdClearAttachments( + VkCommandBuffer commandBuffer, + uint32_t attachmentCount, + const VkClearAttachment* pAttachments, + uint32_t rectCount, + const VkClearRect* pRects); + +VKAPI_ATTR void VKAPI_CALL vkCmdResolveImage( + VkCommandBuffer commandBuffer, + VkImage srcImage, + VkImageLayout srcImageLayout, + VkImage dstImage, + VkImageLayout dstImageLayout, + uint32_t regionCount, + const VkImageResolve* pRegions); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetEvent( + VkCommandBuffer commandBuffer, + VkEvent event, + VkPipelineStageFlags stageMask); + +VKAPI_ATTR void VKAPI_CALL vkCmdResetEvent( + VkCommandBuffer commandBuffer, + VkEvent event, + VkPipelineStageFlags stageMask); + +VKAPI_ATTR void VKAPI_CALL vkCmdWaitEvents( + VkCommandBuffer commandBuffer, + uint32_t eventCount, + const VkEvent* pEvents, + VkPipelineStageFlags srcStageMask, + VkPipelineStageFlags dstStageMask, + uint32_t memoryBarrierCount, + const VkMemoryBarrier* pMemoryBarriers, + uint32_t bufferMemoryBarrierCount, + const VkBufferMemoryBarrier* pBufferMemoryBarriers, + uint32_t imageMemoryBarrierCount, + const VkImageMemoryBarrier* pImageMemoryBarriers); + +VKAPI_ATTR void VKAPI_CALL vkCmdPipelineBarrier( + VkCommandBuffer commandBuffer, + VkPipelineStageFlags srcStageMask, + VkPipelineStageFlags dstStageMask, + VkDependencyFlags dependencyFlags, + uint32_t memoryBarrierCount, + const VkMemoryBarrier* pMemoryBarriers, + uint32_t bufferMemoryBarrierCount, + const VkBufferMemoryBarrier* pBufferMemoryBarriers, + uint32_t imageMemoryBarrierCount, + const VkImageMemoryBarrier* pImageMemoryBarriers); + +VKAPI_ATTR void VKAPI_CALL vkCmdBeginQuery( + VkCommandBuffer commandBuffer, + VkQueryPool queryPool, + uint32_t query, + VkQueryControlFlags flags); + +VKAPI_ATTR void VKAPI_CALL vkCmdEndQuery( + VkCommandBuffer commandBuffer, + VkQueryPool queryPool, + uint32_t query); + +VKAPI_ATTR void VKAPI_CALL vkCmdResetQueryPool( + VkCommandBuffer commandBuffer, + VkQueryPool queryPool, + uint32_t firstQuery, + uint32_t queryCount); + +VKAPI_ATTR void VKAPI_CALL vkCmdWriteTimestamp( + VkCommandBuffer commandBuffer, + VkPipelineStageFlagBits pipelineStage, + VkQueryPool queryPool, + uint32_t query); + +VKAPI_ATTR void VKAPI_CALL vkCmdCopyQueryPoolResults( + VkCommandBuffer commandBuffer, + VkQueryPool queryPool, + uint32_t firstQuery, + uint32_t queryCount, + VkBuffer dstBuffer, + VkDeviceSize dstOffset, + VkDeviceSize stride, + VkQueryResultFlags flags); + +VKAPI_ATTR void VKAPI_CALL vkCmdPushConstants( + VkCommandBuffer commandBuffer, + VkPipelineLayout layout, + VkShaderStageFlags stageFlags, + uint32_t offset, + uint32_t size, + const void* pValues); + +VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderPass( + VkCommandBuffer commandBuffer, + const VkRenderPassBeginInfo* pRenderPassBegin, + VkSubpassContents contents); + +VKAPI_ATTR void VKAPI_CALL vkCmdNextSubpass( + VkCommandBuffer commandBuffer, + VkSubpassContents contents); + +VKAPI_ATTR void VKAPI_CALL vkCmdEndRenderPass( + VkCommandBuffer commandBuffer); + +VKAPI_ATTR void VKAPI_CALL vkCmdExecuteCommands( + VkCommandBuffer commandBuffer, + uint32_t commandBufferCount, + const VkCommandBuffer* pCommandBuffers); +#endif + +#define VK_KHR_surface 1 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSurfaceKHR) + +#define VK_KHR_SURFACE_SPEC_VERSION 25 +#define VK_KHR_SURFACE_EXTENSION_NAME "VK_KHR_surface" +#define VK_COLORSPACE_SRGB_NONLINEAR_KHR VK_COLOR_SPACE_SRGB_NONLINEAR_KHR + + +typedef enum VkColorSpaceKHR { + VK_COLOR_SPACE_SRGB_NONLINEAR_KHR = 0, + VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT = 1000104001, + VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT = 1000104002, + VK_COLOR_SPACE_DCI_P3_LINEAR_EXT = 1000104003, + VK_COLOR_SPACE_DCI_P3_NONLINEAR_EXT = 1000104004, + VK_COLOR_SPACE_BT709_LINEAR_EXT = 1000104005, + VK_COLOR_SPACE_BT709_NONLINEAR_EXT = 1000104006, + VK_COLOR_SPACE_BT2020_LINEAR_EXT = 1000104007, + VK_COLOR_SPACE_HDR10_ST2084_EXT = 1000104008, + VK_COLOR_SPACE_DOLBYVISION_EXT = 1000104009, + VK_COLOR_SPACE_HDR10_HLG_EXT = 1000104010, + VK_COLOR_SPACE_ADOBERGB_LINEAR_EXT = 1000104011, + VK_COLOR_SPACE_ADOBERGB_NONLINEAR_EXT = 1000104012, + VK_COLOR_SPACE_PASS_THROUGH_EXT = 1000104013, + VK_COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT = 1000104014, + VK_COLOR_SPACE_BEGIN_RANGE_KHR = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR, + VK_COLOR_SPACE_END_RANGE_KHR = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR, + VK_COLOR_SPACE_RANGE_SIZE_KHR = (VK_COLOR_SPACE_SRGB_NONLINEAR_KHR - VK_COLOR_SPACE_SRGB_NONLINEAR_KHR + 1), + VK_COLOR_SPACE_MAX_ENUM_KHR = 0x7FFFFFFF +} VkColorSpaceKHR; + +typedef enum VkPresentModeKHR { + VK_PRESENT_MODE_IMMEDIATE_KHR = 0, + VK_PRESENT_MODE_MAILBOX_KHR = 1, + VK_PRESENT_MODE_FIFO_KHR = 2, + VK_PRESENT_MODE_FIFO_RELAXED_KHR = 3, + VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR = 1000111000, + VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR = 1000111001, + VK_PRESENT_MODE_BEGIN_RANGE_KHR = VK_PRESENT_MODE_IMMEDIATE_KHR, + VK_PRESENT_MODE_END_RANGE_KHR = VK_PRESENT_MODE_FIFO_RELAXED_KHR, + VK_PRESENT_MODE_RANGE_SIZE_KHR = (VK_PRESENT_MODE_FIFO_RELAXED_KHR - VK_PRESENT_MODE_IMMEDIATE_KHR + 1), + VK_PRESENT_MODE_MAX_ENUM_KHR = 0x7FFFFFFF +} VkPresentModeKHR; + + +typedef enum VkSurfaceTransformFlagBitsKHR { + VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR = 0x00000001, + VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR = 0x00000002, + VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR = 0x00000004, + VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR = 0x00000008, + VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR = 0x00000010, + VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR = 0x00000020, + VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR = 0x00000040, + VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR = 0x00000080, + VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR = 0x00000100, + VK_SURFACE_TRANSFORM_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkSurfaceTransformFlagBitsKHR; +typedef VkFlags VkSurfaceTransformFlagsKHR; + +typedef enum VkCompositeAlphaFlagBitsKHR { + VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR = 0x00000001, + VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR = 0x00000002, + VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR = 0x00000004, + VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR = 0x00000008, + VK_COMPOSITE_ALPHA_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkCompositeAlphaFlagBitsKHR; +typedef VkFlags VkCompositeAlphaFlagsKHR; + +typedef struct VkSurfaceCapabilitiesKHR { + uint32_t minImageCount; + uint32_t maxImageCount; + VkExtent2D currentExtent; + VkExtent2D minImageExtent; + VkExtent2D maxImageExtent; + uint32_t maxImageArrayLayers; + VkSurfaceTransformFlagsKHR supportedTransforms; + VkSurfaceTransformFlagBitsKHR currentTransform; + VkCompositeAlphaFlagsKHR supportedCompositeAlpha; + VkImageUsageFlags supportedUsageFlags; +} VkSurfaceCapabilitiesKHR; + +typedef struct VkSurfaceFormatKHR { + VkFormat format; + VkColorSpaceKHR colorSpace; +} VkSurfaceFormatKHR; + + +typedef void (VKAPI_PTR *PFN_vkDestroySurfaceKHR)(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported); +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities); +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceFormatsKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats); +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfacePresentModesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkDestroySurfaceKHR( + VkInstance instance, + VkSurfaceKHR surface, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceSupportKHR( + VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + VkSurfaceKHR surface, + VkBool32* pSupported); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilitiesKHR( + VkPhysicalDevice physicalDevice, + VkSurfaceKHR surface, + VkSurfaceCapabilitiesKHR* pSurfaceCapabilities); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceFormatsKHR( + VkPhysicalDevice physicalDevice, + VkSurfaceKHR surface, + uint32_t* pSurfaceFormatCount, + VkSurfaceFormatKHR* pSurfaceFormats); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfacePresentModesKHR( + VkPhysicalDevice physicalDevice, + VkSurfaceKHR surface, + uint32_t* pPresentModeCount, + VkPresentModeKHR* pPresentModes); +#endif + +#define VK_KHR_swapchain 1 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSwapchainKHR) + +#define VK_KHR_SWAPCHAIN_SPEC_VERSION 68 +#define VK_KHR_SWAPCHAIN_EXTENSION_NAME "VK_KHR_swapchain" + + +typedef enum VkSwapchainCreateFlagBitsKHR { + VK_SWAPCHAIN_CREATE_BIND_SFR_BIT_KHX = 0x00000001, + VK_SWAPCHAIN_CREATE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkSwapchainCreateFlagBitsKHR; +typedef VkFlags VkSwapchainCreateFlagsKHR; + +typedef struct VkSwapchainCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkSwapchainCreateFlagsKHR flags; + VkSurfaceKHR surface; + uint32_t minImageCount; + VkFormat imageFormat; + VkColorSpaceKHR imageColorSpace; + VkExtent2D imageExtent; + uint32_t imageArrayLayers; + VkImageUsageFlags imageUsage; + VkSharingMode imageSharingMode; + uint32_t queueFamilyIndexCount; + const uint32_t* pQueueFamilyIndices; + VkSurfaceTransformFlagBitsKHR preTransform; + VkCompositeAlphaFlagBitsKHR compositeAlpha; + VkPresentModeKHR presentMode; + VkBool32 clipped; + VkSwapchainKHR oldSwapchain; +} VkSwapchainCreateInfoKHR; + +typedef struct VkPresentInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t waitSemaphoreCount; + const VkSemaphore* pWaitSemaphores; + uint32_t swapchainCount; + const VkSwapchainKHR* pSwapchains; + const uint32_t* pImageIndices; + VkResult* pResults; +} VkPresentInfoKHR; + + +typedef VkResult (VKAPI_PTR *PFN_vkCreateSwapchainKHR)(VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain); +typedef void (VKAPI_PTR *PFN_vkDestroySwapchainKHR)(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainImagesKHR)(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages); +typedef VkResult (VKAPI_PTR *PFN_vkAcquireNextImageKHR)(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex); +typedef VkResult (VKAPI_PTR *PFN_vkQueuePresentKHR)(VkQueue queue, const VkPresentInfoKHR* pPresentInfo); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateSwapchainKHR( + VkDevice device, + const VkSwapchainCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSwapchainKHR* pSwapchain); + +VKAPI_ATTR void VKAPI_CALL vkDestroySwapchainKHR( + VkDevice device, + VkSwapchainKHR swapchain, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainImagesKHR( + VkDevice device, + VkSwapchainKHR swapchain, + uint32_t* pSwapchainImageCount, + VkImage* pSwapchainImages); + +VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImageKHR( + VkDevice device, + VkSwapchainKHR swapchain, + uint64_t timeout, + VkSemaphore semaphore, + VkFence fence, + uint32_t* pImageIndex); + +VKAPI_ATTR VkResult VKAPI_CALL vkQueuePresentKHR( + VkQueue queue, + const VkPresentInfoKHR* pPresentInfo); +#endif + +#define VK_KHR_display 1 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayKHR) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayModeKHR) + +#define VK_KHR_DISPLAY_SPEC_VERSION 21 +#define VK_KHR_DISPLAY_EXTENSION_NAME "VK_KHR_display" + + +typedef enum VkDisplayPlaneAlphaFlagBitsKHR { + VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR = 0x00000001, + VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR = 0x00000002, + VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR = 0x00000004, + VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR = 0x00000008, + VK_DISPLAY_PLANE_ALPHA_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkDisplayPlaneAlphaFlagBitsKHR; +typedef VkFlags VkDisplayPlaneAlphaFlagsKHR; +typedef VkFlags VkDisplayModeCreateFlagsKHR; +typedef VkFlags VkDisplaySurfaceCreateFlagsKHR; + +typedef struct VkDisplayPropertiesKHR { + VkDisplayKHR display; + const char* displayName; + VkExtent2D physicalDimensions; + VkExtent2D physicalResolution; + VkSurfaceTransformFlagsKHR supportedTransforms; + VkBool32 planeReorderPossible; + VkBool32 persistentContent; +} VkDisplayPropertiesKHR; + +typedef struct VkDisplayModeParametersKHR { + VkExtent2D visibleRegion; + uint32_t refreshRate; +} VkDisplayModeParametersKHR; + +typedef struct VkDisplayModePropertiesKHR { + VkDisplayModeKHR displayMode; + VkDisplayModeParametersKHR parameters; +} VkDisplayModePropertiesKHR; + +typedef struct VkDisplayModeCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkDisplayModeCreateFlagsKHR flags; + VkDisplayModeParametersKHR parameters; +} VkDisplayModeCreateInfoKHR; + +typedef struct VkDisplayPlaneCapabilitiesKHR { + VkDisplayPlaneAlphaFlagsKHR supportedAlpha; + VkOffset2D minSrcPosition; + VkOffset2D maxSrcPosition; + VkExtent2D minSrcExtent; + VkExtent2D maxSrcExtent; + VkOffset2D minDstPosition; + VkOffset2D maxDstPosition; + VkExtent2D minDstExtent; + VkExtent2D maxDstExtent; +} VkDisplayPlaneCapabilitiesKHR; + +typedef struct VkDisplayPlanePropertiesKHR { + VkDisplayKHR currentDisplay; + uint32_t currentStackIndex; +} VkDisplayPlanePropertiesKHR; + +typedef struct VkDisplaySurfaceCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkDisplaySurfaceCreateFlagsKHR flags; + VkDisplayModeKHR displayMode; + uint32_t planeIndex; + uint32_t planeStackIndex; + VkSurfaceTransformFlagBitsKHR transform; + float globalAlpha; + VkDisplayPlaneAlphaFlagBitsKHR alphaMode; + VkExtent2D imageExtent; +} VkDisplaySurfaceCreateInfoKHR; + + +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayPropertiesKHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPropertiesKHR* pProperties); +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlanePropertiesKHR* pProperties); +typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayPlaneSupportedDisplaysKHR)(VkPhysicalDevice physicalDevice, uint32_t planeIndex, uint32_t* pDisplayCount, VkDisplayKHR* pDisplays); +typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayModePropertiesKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModePropertiesKHR* pProperties); +typedef VkResult (VKAPI_PTR *PFN_vkCreateDisplayModeKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, const VkDisplayModeCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDisplayModeKHR* pMode); +typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayPlaneCapabilitiesKHR)(VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR* pCapabilities); +typedef VkResult (VKAPI_PTR *PFN_vkCreateDisplayPlaneSurfaceKHR)(VkInstance instance, const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPropertiesKHR( + VkPhysicalDevice physicalDevice, + uint32_t* pPropertyCount, + VkDisplayPropertiesKHR* pProperties); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPlanePropertiesKHR( + VkPhysicalDevice physicalDevice, + uint32_t* pPropertyCount, + VkDisplayPlanePropertiesKHR* pProperties); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneSupportedDisplaysKHR( + VkPhysicalDevice physicalDevice, + uint32_t planeIndex, + uint32_t* pDisplayCount, + VkDisplayKHR* pDisplays); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayModePropertiesKHR( + VkPhysicalDevice physicalDevice, + VkDisplayKHR display, + uint32_t* pPropertyCount, + VkDisplayModePropertiesKHR* pProperties); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateDisplayModeKHR( + VkPhysicalDevice physicalDevice, + VkDisplayKHR display, + const VkDisplayModeCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDisplayModeKHR* pMode); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneCapabilitiesKHR( + VkPhysicalDevice physicalDevice, + VkDisplayModeKHR mode, + uint32_t planeIndex, + VkDisplayPlaneCapabilitiesKHR* pCapabilities); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateDisplayPlaneSurfaceKHR( + VkInstance instance, + const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); +#endif + +#define VK_KHR_display_swapchain 1 +#define VK_KHR_DISPLAY_SWAPCHAIN_SPEC_VERSION 9 +#define VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME "VK_KHR_display_swapchain" + +typedef struct VkDisplayPresentInfoKHR { + VkStructureType sType; + const void* pNext; + VkRect2D srcRect; + VkRect2D dstRect; + VkBool32 persistent; +} VkDisplayPresentInfoKHR; + + +typedef VkResult (VKAPI_PTR *PFN_vkCreateSharedSwapchainsKHR)(VkDevice device, uint32_t swapchainCount, const VkSwapchainCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchains); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateSharedSwapchainsKHR( + VkDevice device, + uint32_t swapchainCount, + const VkSwapchainCreateInfoKHR* pCreateInfos, + const VkAllocationCallbacks* pAllocator, + VkSwapchainKHR* pSwapchains); +#endif + +#ifdef VK_USE_PLATFORM_XLIB_KHR +#define VK_KHR_xlib_surface 1 +#include + +#define VK_KHR_XLIB_SURFACE_SPEC_VERSION 6 +#define VK_KHR_XLIB_SURFACE_EXTENSION_NAME "VK_KHR_xlib_surface" + +typedef VkFlags VkXlibSurfaceCreateFlagsKHR; + +typedef struct VkXlibSurfaceCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkXlibSurfaceCreateFlagsKHR flags; + Display* dpy; + Window window; +} VkXlibSurfaceCreateInfoKHR; + + +typedef VkResult (VKAPI_PTR *PFN_vkCreateXlibSurfaceKHR)(VkInstance instance, const VkXlibSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); +typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, Display* dpy, VisualID visualID); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateXlibSurfaceKHR( + VkInstance instance, + const VkXlibSurfaceCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); + +VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceXlibPresentationSupportKHR( + VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + Display* dpy, + VisualID visualID); +#endif +#endif /* VK_USE_PLATFORM_XLIB_KHR */ + +#ifdef VK_USE_PLATFORM_XCB_KHR +#define VK_KHR_xcb_surface 1 +#include + +#define VK_KHR_XCB_SURFACE_SPEC_VERSION 6 +#define VK_KHR_XCB_SURFACE_EXTENSION_NAME "VK_KHR_xcb_surface" + +typedef VkFlags VkXcbSurfaceCreateFlagsKHR; + +typedef struct VkXcbSurfaceCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkXcbSurfaceCreateFlagsKHR flags; + xcb_connection_t* connection; + xcb_window_t window; +} VkXcbSurfaceCreateInfoKHR; + + +typedef VkResult (VKAPI_PTR *PFN_vkCreateXcbSurfaceKHR)(VkInstance instance, const VkXcbSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); +typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, xcb_connection_t* connection, xcb_visualid_t visual_id); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateXcbSurfaceKHR( + VkInstance instance, + const VkXcbSurfaceCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); + +VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceXcbPresentationSupportKHR( + VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + xcb_connection_t* connection, + xcb_visualid_t visual_id); +#endif +#endif /* VK_USE_PLATFORM_XCB_KHR */ + +#ifdef VK_USE_PLATFORM_WAYLAND_KHR +#define VK_KHR_wayland_surface 1 +#include + +#define VK_KHR_WAYLAND_SURFACE_SPEC_VERSION 6 +#define VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME "VK_KHR_wayland_surface" + +typedef VkFlags VkWaylandSurfaceCreateFlagsKHR; + +typedef struct VkWaylandSurfaceCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkWaylandSurfaceCreateFlagsKHR flags; + struct wl_display* display; + struct wl_surface* surface; +} VkWaylandSurfaceCreateInfoKHR; + + +typedef VkResult (VKAPI_PTR *PFN_vkCreateWaylandSurfaceKHR)(VkInstance instance, const VkWaylandSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); +typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, struct wl_display* display); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateWaylandSurfaceKHR( + VkInstance instance, + const VkWaylandSurfaceCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); + +VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceWaylandPresentationSupportKHR( + VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + struct wl_display* display); +#endif +#endif /* VK_USE_PLATFORM_WAYLAND_KHR */ + +#ifdef VK_USE_PLATFORM_MIR_KHR +#define VK_KHR_mir_surface 1 +#include + +#define VK_KHR_MIR_SURFACE_SPEC_VERSION 4 +#define VK_KHR_MIR_SURFACE_EXTENSION_NAME "VK_KHR_mir_surface" + +typedef VkFlags VkMirSurfaceCreateFlagsKHR; + +typedef struct VkMirSurfaceCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkMirSurfaceCreateFlagsKHR flags; + MirConnection* connection; + MirSurface* mirSurface; +} VkMirSurfaceCreateInfoKHR; + + +typedef VkResult (VKAPI_PTR *PFN_vkCreateMirSurfaceKHR)(VkInstance instance, const VkMirSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); +typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceMirPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, MirConnection* connection); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateMirSurfaceKHR( + VkInstance instance, + const VkMirSurfaceCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); + +VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceMirPresentationSupportKHR( + VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + MirConnection* connection); +#endif +#endif /* VK_USE_PLATFORM_MIR_KHR */ + +#ifdef VK_USE_PLATFORM_ANDROID_KHR +#define VK_KHR_android_surface 1 +#include + +#define VK_KHR_ANDROID_SURFACE_SPEC_VERSION 6 +#define VK_KHR_ANDROID_SURFACE_EXTENSION_NAME "VK_KHR_android_surface" + +typedef VkFlags VkAndroidSurfaceCreateFlagsKHR; + +typedef struct VkAndroidSurfaceCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkAndroidSurfaceCreateFlagsKHR flags; + ANativeWindow* window; +} VkAndroidSurfaceCreateInfoKHR; + + +typedef VkResult (VKAPI_PTR *PFN_vkCreateAndroidSurfaceKHR)(VkInstance instance, const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateAndroidSurfaceKHR( + VkInstance instance, + const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); +#endif +#endif /* VK_USE_PLATFORM_ANDROID_KHR */ + +#ifdef VK_USE_PLATFORM_WIN32_KHR +#define VK_KHR_win32_surface 1 +#include + +#define VK_KHR_WIN32_SURFACE_SPEC_VERSION 6 +#define VK_KHR_WIN32_SURFACE_EXTENSION_NAME "VK_KHR_win32_surface" + +typedef VkFlags VkWin32SurfaceCreateFlagsKHR; + +typedef struct VkWin32SurfaceCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkWin32SurfaceCreateFlagsKHR flags; + HINSTANCE hinstance; + HWND hwnd; +} VkWin32SurfaceCreateInfoKHR; + + +typedef VkResult (VKAPI_PTR *PFN_vkCreateWin32SurfaceKHR)(VkInstance instance, const VkWin32SurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); +typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateWin32SurfaceKHR( + VkInstance instance, + const VkWin32SurfaceCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); + +VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceWin32PresentationSupportKHR( + VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex); +#endif +#endif /* VK_USE_PLATFORM_WIN32_KHR */ + +#define VK_KHR_sampler_mirror_clamp_to_edge 1 +#define VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_SPEC_VERSION 1 +#define VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_EXTENSION_NAME "VK_KHR_sampler_mirror_clamp_to_edge" + + +#define VK_KHR_get_physical_device_properties2 1 +#define VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_SPEC_VERSION 1 +#define VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME "VK_KHR_get_physical_device_properties2" + +typedef struct VkPhysicalDeviceFeatures2KHR { + VkStructureType sType; + void* pNext; + VkPhysicalDeviceFeatures features; +} VkPhysicalDeviceFeatures2KHR; + +typedef struct VkPhysicalDeviceProperties2KHR { + VkStructureType sType; + void* pNext; + VkPhysicalDeviceProperties properties; +} VkPhysicalDeviceProperties2KHR; + +typedef struct VkFormatProperties2KHR { + VkStructureType sType; + void* pNext; + VkFormatProperties formatProperties; +} VkFormatProperties2KHR; + +typedef struct VkImageFormatProperties2KHR { + VkStructureType sType; + void* pNext; + VkImageFormatProperties imageFormatProperties; +} VkImageFormatProperties2KHR; + +typedef struct VkPhysicalDeviceImageFormatInfo2KHR { + VkStructureType sType; + const void* pNext; + VkFormat format; + VkImageType type; + VkImageTiling tiling; + VkImageUsageFlags usage; + VkImageCreateFlags flags; +} VkPhysicalDeviceImageFormatInfo2KHR; + +typedef struct VkQueueFamilyProperties2KHR { + VkStructureType sType; + void* pNext; + VkQueueFamilyProperties queueFamilyProperties; +} VkQueueFamilyProperties2KHR; + +typedef struct VkPhysicalDeviceMemoryProperties2KHR { + VkStructureType sType; + void* pNext; + VkPhysicalDeviceMemoryProperties memoryProperties; +} VkPhysicalDeviceMemoryProperties2KHR; + +typedef struct VkSparseImageFormatProperties2KHR { + VkStructureType sType; + void* pNext; + VkSparseImageFormatProperties properties; +} VkSparseImageFormatProperties2KHR; + +typedef struct VkPhysicalDeviceSparseImageFormatInfo2KHR { + VkStructureType sType; + const void* pNext; + VkFormat format; + VkImageType type; + VkSampleCountFlagBits samples; + VkImageUsageFlags usage; + VkImageTiling tiling; +} VkPhysicalDeviceSparseImageFormatInfo2KHR; + + +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFeatures2KHR)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2KHR* pFeatures); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceProperties2KHR)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2KHR* pProperties); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFormatProperties2KHR)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2KHR* pFormatProperties); +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceImageFormatProperties2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2KHR* pImageFormatInfo, VkImageFormatProperties2KHR* pImageFormatProperties); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR)(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2KHR* pQueueFamilyProperties); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceMemoryProperties2KHR)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2KHR* pMemoryProperties); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2KHR* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2KHR* pProperties); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures2KHR( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceFeatures2KHR* pFeatures); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties2KHR( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceProperties2KHR* pProperties); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties2KHR( + VkPhysicalDevice physicalDevice, + VkFormat format, + VkFormatProperties2KHR* pFormatProperties); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties2KHR( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceImageFormatInfo2KHR* pImageFormatInfo, + VkImageFormatProperties2KHR* pImageFormatProperties); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties2KHR( + VkPhysicalDevice physicalDevice, + uint32_t* pQueueFamilyPropertyCount, + VkQueueFamilyProperties2KHR* pQueueFamilyProperties); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties2KHR( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceMemoryProperties2KHR* pMemoryProperties); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties2KHR( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceSparseImageFormatInfo2KHR* pFormatInfo, + uint32_t* pPropertyCount, + VkSparseImageFormatProperties2KHR* pProperties); +#endif + +#define VK_KHR_shader_draw_parameters 1 +#define VK_KHR_SHADER_DRAW_PARAMETERS_SPEC_VERSION 1 +#define VK_KHR_SHADER_DRAW_PARAMETERS_EXTENSION_NAME "VK_KHR_shader_draw_parameters" + + +#define VK_KHR_maintenance1 1 +#define VK_KHR_MAINTENANCE1_SPEC_VERSION 1 +#define VK_KHR_MAINTENANCE1_EXTENSION_NAME "VK_KHR_maintenance1" + +typedef VkFlags VkCommandPoolTrimFlagsKHR; + +typedef void (VKAPI_PTR *PFN_vkTrimCommandPoolKHR)(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlagsKHR flags); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkTrimCommandPoolKHR( + VkDevice device, + VkCommandPool commandPool, + VkCommandPoolTrimFlagsKHR flags); +#endif + +#define VK_KHR_external_memory_capabilities 1 +#define VK_LUID_SIZE_KHR 8 +#define VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION 1 +#define VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME "VK_KHR_external_memory_capabilities" + + +typedef enum VkExternalMemoryHandleTypeFlagBitsKHR { + VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR = 0x00000001, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR = 0x00000002, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR = 0x00000004, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT_KHR = 0x00000008, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT_KHR = 0x00000010, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT_KHR = 0x00000020, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT_KHR = 0x00000040, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT = 0x00000200, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT = 0x00000080, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT = 0x00000100, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkExternalMemoryHandleTypeFlagBitsKHR; +typedef VkFlags VkExternalMemoryHandleTypeFlagsKHR; + +typedef enum VkExternalMemoryFeatureFlagBitsKHR { + VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHR = 0x00000001, + VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHR = 0x00000002, + VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHR = 0x00000004, + VK_EXTERNAL_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkExternalMemoryFeatureFlagBitsKHR; +typedef VkFlags VkExternalMemoryFeatureFlagsKHR; + +typedef struct VkExternalMemoryPropertiesKHR { + VkExternalMemoryFeatureFlagsKHR externalMemoryFeatures; + VkExternalMemoryHandleTypeFlagsKHR exportFromImportedHandleTypes; + VkExternalMemoryHandleTypeFlagsKHR compatibleHandleTypes; +} VkExternalMemoryPropertiesKHR; + +typedef struct VkPhysicalDeviceExternalImageFormatInfoKHR { + VkStructureType sType; + const void* pNext; + VkExternalMemoryHandleTypeFlagBitsKHR handleType; +} VkPhysicalDeviceExternalImageFormatInfoKHR; + +typedef struct VkExternalImageFormatPropertiesKHR { + VkStructureType sType; + void* pNext; + VkExternalMemoryPropertiesKHR externalMemoryProperties; +} VkExternalImageFormatPropertiesKHR; + +typedef struct VkPhysicalDeviceExternalBufferInfoKHR { + VkStructureType sType; + const void* pNext; + VkBufferCreateFlags flags; + VkBufferUsageFlags usage; + VkExternalMemoryHandleTypeFlagBitsKHR handleType; +} VkPhysicalDeviceExternalBufferInfoKHR; + +typedef struct VkExternalBufferPropertiesKHR { + VkStructureType sType; + void* pNext; + VkExternalMemoryPropertiesKHR externalMemoryProperties; +} VkExternalBufferPropertiesKHR; + +typedef struct VkPhysicalDeviceIDPropertiesKHR { + VkStructureType sType; + void* pNext; + uint8_t deviceUUID[VK_UUID_SIZE]; + uint8_t driverUUID[VK_UUID_SIZE]; + uint8_t deviceLUID[VK_LUID_SIZE_KHR]; + uint32_t deviceNodeMask; + VkBool32 deviceLUIDValid; +} VkPhysicalDeviceIDPropertiesKHR; + + +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfoKHR* pExternalBufferInfo, VkExternalBufferPropertiesKHR* pExternalBufferProperties); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalBufferPropertiesKHR( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceExternalBufferInfoKHR* pExternalBufferInfo, + VkExternalBufferPropertiesKHR* pExternalBufferProperties); +#endif + +#define VK_KHR_external_memory 1 +#define VK_KHR_EXTERNAL_MEMORY_SPEC_VERSION 1 +#define VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME "VK_KHR_external_memory" +#define VK_QUEUE_FAMILY_EXTERNAL_KHR (~0U-1) + +typedef struct VkExternalMemoryImageCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkExternalMemoryHandleTypeFlagsKHR handleTypes; +} VkExternalMemoryImageCreateInfoKHR; + +typedef struct VkExternalMemoryBufferCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkExternalMemoryHandleTypeFlagsKHR handleTypes; +} VkExternalMemoryBufferCreateInfoKHR; + +typedef struct VkExportMemoryAllocateInfoKHR { + VkStructureType sType; + const void* pNext; + VkExternalMemoryHandleTypeFlagsKHR handleTypes; +} VkExportMemoryAllocateInfoKHR; + + + +#ifdef VK_USE_PLATFORM_WIN32_KHR +#define VK_KHR_external_memory_win32 1 +#define VK_KHR_EXTERNAL_MEMORY_WIN32_SPEC_VERSION 1 +#define VK_KHR_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME "VK_KHR_external_memory_win32" + +typedef struct VkImportMemoryWin32HandleInfoKHR { + VkStructureType sType; + const void* pNext; + VkExternalMemoryHandleTypeFlagBitsKHR handleType; + HANDLE handle; + LPCWSTR name; +} VkImportMemoryWin32HandleInfoKHR; + +typedef struct VkExportMemoryWin32HandleInfoKHR { + VkStructureType sType; + const void* pNext; + const SECURITY_ATTRIBUTES* pAttributes; + DWORD dwAccess; + LPCWSTR name; +} VkExportMemoryWin32HandleInfoKHR; + +typedef struct VkMemoryWin32HandlePropertiesKHR { + VkStructureType sType; + void* pNext; + uint32_t memoryTypeBits; +} VkMemoryWin32HandlePropertiesKHR; + +typedef struct VkMemoryGetWin32HandleInfoKHR { + VkStructureType sType; + const void* pNext; + VkDeviceMemory memory; + VkExternalMemoryHandleTypeFlagBitsKHR handleType; +} VkMemoryGetWin32HandleInfoKHR; + + +typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandleKHR)(VkDevice device, const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle); +typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandlePropertiesKHR)(VkDevice device, VkExternalMemoryHandleTypeFlagBitsKHR handleType, HANDLE handle, VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandleKHR( + VkDevice device, + const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, + HANDLE* pHandle); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandlePropertiesKHR( + VkDevice device, + VkExternalMemoryHandleTypeFlagBitsKHR handleType, + HANDLE handle, + VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties); +#endif +#endif /* VK_USE_PLATFORM_WIN32_KHR */ + +#define VK_KHR_external_memory_fd 1 +#define VK_KHR_EXTERNAL_MEMORY_FD_SPEC_VERSION 1 +#define VK_KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME "VK_KHR_external_memory_fd" + +typedef struct VkImportMemoryFdInfoKHR { + VkStructureType sType; + const void* pNext; + VkExternalMemoryHandleTypeFlagBitsKHR handleType; + int fd; +} VkImportMemoryFdInfoKHR; + +typedef struct VkMemoryFdPropertiesKHR { + VkStructureType sType; + void* pNext; + uint32_t memoryTypeBits; +} VkMemoryFdPropertiesKHR; + +typedef struct VkMemoryGetFdInfoKHR { + VkStructureType sType; + const void* pNext; + VkDeviceMemory memory; + VkExternalMemoryHandleTypeFlagBitsKHR handleType; +} VkMemoryGetFdInfoKHR; + + +typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryFdKHR)(VkDevice device, const VkMemoryGetFdInfoKHR* pGetFdInfo, int* pFd); +typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryFdPropertiesKHR)(VkDevice device, VkExternalMemoryHandleTypeFlagBitsKHR handleType, int fd, VkMemoryFdPropertiesKHR* pMemoryFdProperties); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryFdKHR( + VkDevice device, + const VkMemoryGetFdInfoKHR* pGetFdInfo, + int* pFd); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryFdPropertiesKHR( + VkDevice device, + VkExternalMemoryHandleTypeFlagBitsKHR handleType, + int fd, + VkMemoryFdPropertiesKHR* pMemoryFdProperties); +#endif + +#ifdef VK_USE_PLATFORM_WIN32_KHR +#define VK_KHR_win32_keyed_mutex 1 +#define VK_KHR_WIN32_KEYED_MUTEX_SPEC_VERSION 1 +#define VK_KHR_WIN32_KEYED_MUTEX_EXTENSION_NAME "VK_KHR_win32_keyed_mutex" + +typedef struct VkWin32KeyedMutexAcquireReleaseInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t acquireCount; + const VkDeviceMemory* pAcquireSyncs; + const uint64_t* pAcquireKeys; + const uint32_t* pAcquireTimeouts; + uint32_t releaseCount; + const VkDeviceMemory* pReleaseSyncs; + const uint64_t* pReleaseKeys; +} VkWin32KeyedMutexAcquireReleaseInfoKHR; + + +#endif /* VK_USE_PLATFORM_WIN32_KHR */ + +#define VK_KHR_external_semaphore_capabilities 1 +#define VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_SPEC_VERSION 1 +#define VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME "VK_KHR_external_semaphore_capabilities" + + +typedef enum VkExternalSemaphoreHandleTypeFlagBitsKHR { + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR = 0x00000001, + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR = 0x00000002, + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR = 0x00000004, + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT_KHR = 0x00000008, + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT_KHR = 0x00000010, + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkExternalSemaphoreHandleTypeFlagBitsKHR; +typedef VkFlags VkExternalSemaphoreHandleTypeFlagsKHR; + +typedef enum VkExternalSemaphoreFeatureFlagBitsKHR { + VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT_KHR = 0x00000001, + VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT_KHR = 0x00000002, + VK_EXTERNAL_SEMAPHORE_FEATURE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkExternalSemaphoreFeatureFlagBitsKHR; +typedef VkFlags VkExternalSemaphoreFeatureFlagsKHR; + +typedef struct VkPhysicalDeviceExternalSemaphoreInfoKHR { + VkStructureType sType; + const void* pNext; + VkExternalSemaphoreHandleTypeFlagBitsKHR handleType; +} VkPhysicalDeviceExternalSemaphoreInfoKHR; + +typedef struct VkExternalSemaphorePropertiesKHR { + VkStructureType sType; + void* pNext; + VkExternalSemaphoreHandleTypeFlagsKHR exportFromImportedHandleTypes; + VkExternalSemaphoreHandleTypeFlagsKHR compatibleHandleTypes; + VkExternalSemaphoreFeatureFlagsKHR externalSemaphoreFeatures; +} VkExternalSemaphorePropertiesKHR; + + +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfoKHR* pExternalSemaphoreInfo, VkExternalSemaphorePropertiesKHR* pExternalSemaphoreProperties); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceExternalSemaphoreInfoKHR* pExternalSemaphoreInfo, + VkExternalSemaphorePropertiesKHR* pExternalSemaphoreProperties); +#endif + +#define VK_KHR_external_semaphore 1 +#define VK_KHR_EXTERNAL_SEMAPHORE_SPEC_VERSION 1 +#define VK_KHR_EXTERNAL_SEMAPHORE_EXTENSION_NAME "VK_KHR_external_semaphore" + + +typedef enum VkSemaphoreImportFlagBitsKHR { + VK_SEMAPHORE_IMPORT_TEMPORARY_BIT_KHR = 0x00000001, + VK_SEMAPHORE_IMPORT_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkSemaphoreImportFlagBitsKHR; +typedef VkFlags VkSemaphoreImportFlagsKHR; + +typedef struct VkExportSemaphoreCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkExternalSemaphoreHandleTypeFlagsKHR handleTypes; +} VkExportSemaphoreCreateInfoKHR; + + + +#ifdef VK_USE_PLATFORM_WIN32_KHR +#define VK_KHR_external_semaphore_win32 1 +#define VK_KHR_EXTERNAL_SEMAPHORE_WIN32_SPEC_VERSION 1 +#define VK_KHR_EXTERNAL_SEMAPHORE_WIN32_EXTENSION_NAME "VK_KHR_external_semaphore_win32" + +typedef struct VkImportSemaphoreWin32HandleInfoKHR { + VkStructureType sType; + const void* pNext; + VkSemaphore semaphore; + VkSemaphoreImportFlagsKHR flags; + VkExternalSemaphoreHandleTypeFlagBitsKHR handleType; + HANDLE handle; + LPCWSTR name; +} VkImportSemaphoreWin32HandleInfoKHR; + +typedef struct VkExportSemaphoreWin32HandleInfoKHR { + VkStructureType sType; + const void* pNext; + const SECURITY_ATTRIBUTES* pAttributes; + DWORD dwAccess; + LPCWSTR name; +} VkExportSemaphoreWin32HandleInfoKHR; + +typedef struct VkD3D12FenceSubmitInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t waitSemaphoreValuesCount; + const uint64_t* pWaitSemaphoreValues; + uint32_t signalSemaphoreValuesCount; + const uint64_t* pSignalSemaphoreValues; +} VkD3D12FenceSubmitInfoKHR; + +typedef struct VkSemaphoreGetWin32HandleInfoKHR { + VkStructureType sType; + const void* pNext; + VkSemaphore semaphore; + VkExternalSemaphoreHandleTypeFlagBitsKHR handleType; +} VkSemaphoreGetWin32HandleInfoKHR; + + +typedef VkResult (VKAPI_PTR *PFN_vkImportSemaphoreWin32HandleKHR)(VkDevice device, const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo); +typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreWin32HandleKHR)(VkDevice device, const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkImportSemaphoreWin32HandleKHR( + VkDevice device, + const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreWin32HandleKHR( + VkDevice device, + const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, + HANDLE* pHandle); +#endif +#endif /* VK_USE_PLATFORM_WIN32_KHR */ + +#define VK_KHR_external_semaphore_fd 1 +#define VK_KHR_EXTERNAL_SEMAPHORE_FD_SPEC_VERSION 1 +#define VK_KHR_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME "VK_KHR_external_semaphore_fd" + +typedef struct VkImportSemaphoreFdInfoKHR { + VkStructureType sType; + const void* pNext; + VkSemaphore semaphore; + VkSemaphoreImportFlagsKHR flags; + VkExternalSemaphoreHandleTypeFlagBitsKHR handleType; + int fd; +} VkImportSemaphoreFdInfoKHR; + +typedef struct VkSemaphoreGetFdInfoKHR { + VkStructureType sType; + const void* pNext; + VkSemaphore semaphore; + VkExternalSemaphoreHandleTypeFlagBitsKHR handleType; +} VkSemaphoreGetFdInfoKHR; + + +typedef VkResult (VKAPI_PTR *PFN_vkImportSemaphoreFdKHR)(VkDevice device, const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo); +typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreFdKHR)(VkDevice device, const VkSemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkImportSemaphoreFdKHR( + VkDevice device, + const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreFdKHR( + VkDevice device, + const VkSemaphoreGetFdInfoKHR* pGetFdInfo, + int* pFd); +#endif + +#define VK_KHR_push_descriptor 1 +#define VK_KHR_PUSH_DESCRIPTOR_SPEC_VERSION 1 +#define VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME "VK_KHR_push_descriptor" + +typedef struct VkPhysicalDevicePushDescriptorPropertiesKHR { + VkStructureType sType; + void* pNext; + uint32_t maxPushDescriptors; +} VkPhysicalDevicePushDescriptorPropertiesKHR; + + +typedef void (VKAPI_PTR *PFN_vkCmdPushDescriptorSetKHR)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSetKHR( + VkCommandBuffer commandBuffer, + VkPipelineBindPoint pipelineBindPoint, + VkPipelineLayout layout, + uint32_t set, + uint32_t descriptorWriteCount, + const VkWriteDescriptorSet* pDescriptorWrites); +#endif + +#define VK_KHR_16bit_storage 1 +#define VK_KHR_16BIT_STORAGE_SPEC_VERSION 1 +#define VK_KHR_16BIT_STORAGE_EXTENSION_NAME "VK_KHR_16bit_storage" + +typedef struct VkPhysicalDevice16BitStorageFeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 storageBuffer16BitAccess; + VkBool32 uniformAndStorageBuffer16BitAccess; + VkBool32 storagePushConstant16; + VkBool32 storageInputOutput16; +} VkPhysicalDevice16BitStorageFeaturesKHR; + + + +#define VK_KHR_incremental_present 1 +#define VK_KHR_INCREMENTAL_PRESENT_SPEC_VERSION 1 +#define VK_KHR_INCREMENTAL_PRESENT_EXTENSION_NAME "VK_KHR_incremental_present" + +typedef struct VkRectLayerKHR { + VkOffset2D offset; + VkExtent2D extent; + uint32_t layer; +} VkRectLayerKHR; + +typedef struct VkPresentRegionKHR { + uint32_t rectangleCount; + const VkRectLayerKHR* pRectangles; +} VkPresentRegionKHR; + +typedef struct VkPresentRegionsKHR { + VkStructureType sType; + const void* pNext; + uint32_t swapchainCount; + const VkPresentRegionKHR* pRegions; +} VkPresentRegionsKHR; + + + +#define VK_KHR_descriptor_update_template 1 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorUpdateTemplateKHR) + +#define VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_SPEC_VERSION 1 +#define VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_EXTENSION_NAME "VK_KHR_descriptor_update_template" + + +typedef enum VkDescriptorUpdateTemplateTypeKHR { + VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET_KHR = 0, + VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR = 1, + VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_BEGIN_RANGE_KHR = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET_KHR, + VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_END_RANGE_KHR = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR, + VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_RANGE_SIZE_KHR = (VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR - VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET_KHR + 1), + VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_MAX_ENUM_KHR = 0x7FFFFFFF +} VkDescriptorUpdateTemplateTypeKHR; + +typedef VkFlags VkDescriptorUpdateTemplateCreateFlagsKHR; + +typedef struct VkDescriptorUpdateTemplateEntryKHR { + uint32_t dstBinding; + uint32_t dstArrayElement; + uint32_t descriptorCount; + VkDescriptorType descriptorType; + size_t offset; + size_t stride; +} VkDescriptorUpdateTemplateEntryKHR; + +typedef struct VkDescriptorUpdateTemplateCreateInfoKHR { + VkStructureType sType; + void* pNext; + VkDescriptorUpdateTemplateCreateFlagsKHR flags; + uint32_t descriptorUpdateEntryCount; + const VkDescriptorUpdateTemplateEntryKHR* pDescriptorUpdateEntries; + VkDescriptorUpdateTemplateTypeKHR templateType; + VkDescriptorSetLayout descriptorSetLayout; + VkPipelineBindPoint pipelineBindPoint; + VkPipelineLayout pipelineLayout; + uint32_t set; +} VkDescriptorUpdateTemplateCreateInfoKHR; + + +typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorUpdateTemplateKHR)(VkDevice device, const VkDescriptorUpdateTemplateCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplateKHR* pDescriptorUpdateTemplate); +typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorUpdateTemplateKHR)(VkDevice device, VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator); +typedef void (VKAPI_PTR *PFN_vkUpdateDescriptorSetWithTemplateKHR)(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, const void* pData); +typedef void (VKAPI_PTR *PFN_vkCmdPushDescriptorSetWithTemplateKHR)(VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void* pData); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorUpdateTemplateKHR( + VkDevice device, + const VkDescriptorUpdateTemplateCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDescriptorUpdateTemplateKHR* pDescriptorUpdateTemplate); + +VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorUpdateTemplateKHR( + VkDevice device, + VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSetWithTemplateKHR( + VkDevice device, + VkDescriptorSet descriptorSet, + VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, + const void* pData); + +VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSetWithTemplateKHR( + VkCommandBuffer commandBuffer, + VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, + VkPipelineLayout layout, + uint32_t set, + const void* pData); +#endif + +#define VK_KHR_shared_presentable_image 1 +#define VK_KHR_SHARED_PRESENTABLE_IMAGE_SPEC_VERSION 1 +#define VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME "VK_KHR_shared_presentable_image" + +typedef struct VkSharedPresentSurfaceCapabilitiesKHR { + VkStructureType sType; + void* pNext; + VkImageUsageFlags sharedPresentSupportedUsageFlags; +} VkSharedPresentSurfaceCapabilitiesKHR; + + +typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainStatusKHR)(VkDevice device, VkSwapchainKHR swapchain); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainStatusKHR( + VkDevice device, + VkSwapchainKHR swapchain); +#endif + +#define VK_KHR_external_fence_capabilities 1 +#define VK_KHR_EXTERNAL_FENCE_CAPABILITIES_SPEC_VERSION 1 +#define VK_KHR_EXTERNAL_FENCE_CAPABILITIES_EXTENSION_NAME "VK_KHR_external_fence_capabilities" + + +typedef enum VkExternalFenceHandleTypeFlagBitsKHR { + VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR = 0x00000001, + VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR = 0x00000002, + VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR = 0x00000004, + VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT_KHR = 0x00000008, + VK_EXTERNAL_FENCE_HANDLE_TYPE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkExternalFenceHandleTypeFlagBitsKHR; +typedef VkFlags VkExternalFenceHandleTypeFlagsKHR; + +typedef enum VkExternalFenceFeatureFlagBitsKHR { + VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT_KHR = 0x00000001, + VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT_KHR = 0x00000002, + VK_EXTERNAL_FENCE_FEATURE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkExternalFenceFeatureFlagBitsKHR; +typedef VkFlags VkExternalFenceFeatureFlagsKHR; + +typedef struct VkPhysicalDeviceExternalFenceInfoKHR { + VkStructureType sType; + const void* pNext; + VkExternalFenceHandleTypeFlagBitsKHR handleType; +} VkPhysicalDeviceExternalFenceInfoKHR; + +typedef struct VkExternalFencePropertiesKHR { + VkStructureType sType; + void* pNext; + VkExternalFenceHandleTypeFlagsKHR exportFromImportedHandleTypes; + VkExternalFenceHandleTypeFlagsKHR compatibleHandleTypes; + VkExternalFenceFeatureFlagsKHR externalFenceFeatures; +} VkExternalFencePropertiesKHR; + + +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfoKHR* pExternalFenceInfo, VkExternalFencePropertiesKHR* pExternalFenceProperties); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalFencePropertiesKHR( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceExternalFenceInfoKHR* pExternalFenceInfo, + VkExternalFencePropertiesKHR* pExternalFenceProperties); +#endif + +#define VK_KHR_external_fence 1 +#define VK_KHR_EXTERNAL_FENCE_SPEC_VERSION 1 +#define VK_KHR_EXTERNAL_FENCE_EXTENSION_NAME "VK_KHR_external_fence" + + +typedef enum VkFenceImportFlagBitsKHR { + VK_FENCE_IMPORT_TEMPORARY_BIT_KHR = 0x00000001, + VK_FENCE_IMPORT_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkFenceImportFlagBitsKHR; +typedef VkFlags VkFenceImportFlagsKHR; + +typedef struct VkExportFenceCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkExternalFenceHandleTypeFlagsKHR handleTypes; +} VkExportFenceCreateInfoKHR; + + + +#ifdef VK_USE_PLATFORM_WIN32_KHR +#define VK_KHR_external_fence_win32 1 +#define VK_KHR_EXTERNAL_FENCE_WIN32_SPEC_VERSION 1 +#define VK_KHR_EXTERNAL_FENCE_WIN32_EXTENSION_NAME "VK_KHR_external_fence_win32" + +typedef struct VkImportFenceWin32HandleInfoKHR { + VkStructureType sType; + const void* pNext; + VkFence fence; + VkFenceImportFlagsKHR flags; + VkExternalFenceHandleTypeFlagBitsKHR handleType; + HANDLE handle; + LPCWSTR name; +} VkImportFenceWin32HandleInfoKHR; + +typedef struct VkExportFenceWin32HandleInfoKHR { + VkStructureType sType; + const void* pNext; + const SECURITY_ATTRIBUTES* pAttributes; + DWORD dwAccess; + LPCWSTR name; +} VkExportFenceWin32HandleInfoKHR; + +typedef struct VkFenceGetWin32HandleInfoKHR { + VkStructureType sType; + const void* pNext; + VkFence fence; + VkExternalFenceHandleTypeFlagBitsKHR handleType; +} VkFenceGetWin32HandleInfoKHR; + + +typedef VkResult (VKAPI_PTR *PFN_vkImportFenceWin32HandleKHR)(VkDevice device, const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo); +typedef VkResult (VKAPI_PTR *PFN_vkGetFenceWin32HandleKHR)(VkDevice device, const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkImportFenceWin32HandleKHR( + VkDevice device, + const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceWin32HandleKHR( + VkDevice device, + const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, + HANDLE* pHandle); +#endif +#endif /* VK_USE_PLATFORM_WIN32_KHR */ + +#define VK_KHR_external_fence_fd 1 +#define VK_KHR_EXTERNAL_FENCE_FD_SPEC_VERSION 1 +#define VK_KHR_EXTERNAL_FENCE_FD_EXTENSION_NAME "VK_KHR_external_fence_fd" + +typedef struct VkImportFenceFdInfoKHR { + VkStructureType sType; + const void* pNext; + VkFence fence; + VkFenceImportFlagsKHR flags; + VkExternalFenceHandleTypeFlagBitsKHR handleType; + int fd; +} VkImportFenceFdInfoKHR; + +typedef struct VkFenceGetFdInfoKHR { + VkStructureType sType; + const void* pNext; + VkFence fence; + VkExternalFenceHandleTypeFlagBitsKHR handleType; +} VkFenceGetFdInfoKHR; + + +typedef VkResult (VKAPI_PTR *PFN_vkImportFenceFdKHR)(VkDevice device, const VkImportFenceFdInfoKHR* pImportFenceFdInfo); +typedef VkResult (VKAPI_PTR *PFN_vkGetFenceFdKHR)(VkDevice device, const VkFenceGetFdInfoKHR* pGetFdInfo, int* pFd); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkImportFenceFdKHR( + VkDevice device, + const VkImportFenceFdInfoKHR* pImportFenceFdInfo); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceFdKHR( + VkDevice device, + const VkFenceGetFdInfoKHR* pGetFdInfo, + int* pFd); +#endif + +#define VK_KHR_maintenance2 1 +#define VK_KHR_MAINTENANCE2_SPEC_VERSION 1 +#define VK_KHR_MAINTENANCE2_EXTENSION_NAME "VK_KHR_maintenance2" + + +typedef enum VkPointClippingBehaviorKHR { + VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES_KHR = 0, + VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY_KHR = 1, + VK_POINT_CLIPPING_BEHAVIOR_BEGIN_RANGE_KHR = VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES_KHR, + VK_POINT_CLIPPING_BEHAVIOR_END_RANGE_KHR = VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY_KHR, + VK_POINT_CLIPPING_BEHAVIOR_RANGE_SIZE_KHR = (VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY_KHR - VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES_KHR + 1), + VK_POINT_CLIPPING_BEHAVIOR_MAX_ENUM_KHR = 0x7FFFFFFF +} VkPointClippingBehaviorKHR; + +typedef enum VkTessellationDomainOriginKHR { + VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT_KHR = 0, + VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT_KHR = 1, + VK_TESSELLATION_DOMAIN_ORIGIN_BEGIN_RANGE_KHR = VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT_KHR, + VK_TESSELLATION_DOMAIN_ORIGIN_END_RANGE_KHR = VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT_KHR, + VK_TESSELLATION_DOMAIN_ORIGIN_RANGE_SIZE_KHR = (VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT_KHR - VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT_KHR + 1), + VK_TESSELLATION_DOMAIN_ORIGIN_MAX_ENUM_KHR = 0x7FFFFFFF +} VkTessellationDomainOriginKHR; + +typedef struct VkPhysicalDevicePointClippingPropertiesKHR { + VkStructureType sType; + void* pNext; + VkPointClippingBehaviorKHR pointClippingBehavior; +} VkPhysicalDevicePointClippingPropertiesKHR; + +typedef struct VkInputAttachmentAspectReferenceKHR { + uint32_t subpass; + uint32_t inputAttachmentIndex; + VkImageAspectFlags aspectMask; +} VkInputAttachmentAspectReferenceKHR; + +typedef struct VkRenderPassInputAttachmentAspectCreateInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t aspectReferenceCount; + const VkInputAttachmentAspectReferenceKHR* pAspectReferences; +} VkRenderPassInputAttachmentAspectCreateInfoKHR; + +typedef struct VkImageViewUsageCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkImageUsageFlags usage; +} VkImageViewUsageCreateInfoKHR; + +typedef struct VkPipelineTessellationDomainOriginStateCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkTessellationDomainOriginKHR domainOrigin; +} VkPipelineTessellationDomainOriginStateCreateInfoKHR; + + + +#define VK_KHR_get_surface_capabilities2 1 +#define VK_KHR_GET_SURFACE_CAPABILITIES_2_SPEC_VERSION 1 +#define VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME "VK_KHR_get_surface_capabilities2" + +typedef struct VkPhysicalDeviceSurfaceInfo2KHR { + VkStructureType sType; + const void* pNext; + VkSurfaceKHR surface; +} VkPhysicalDeviceSurfaceInfo2KHR; + +typedef struct VkSurfaceCapabilities2KHR { + VkStructureType sType; + void* pNext; + VkSurfaceCapabilitiesKHR surfaceCapabilities; +} VkSurfaceCapabilities2KHR; + +typedef struct VkSurfaceFormat2KHR { + VkStructureType sType; + void* pNext; + VkSurfaceFormatKHR surfaceFormat; +} VkSurfaceFormat2KHR; + + +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkSurfaceCapabilities2KHR* pSurfaceCapabilities); +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceFormats2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pSurfaceFormatCount, VkSurfaceFormat2KHR* pSurfaceFormats); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilities2KHR( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, + VkSurfaceCapabilities2KHR* pSurfaceCapabilities); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceFormats2KHR( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, + uint32_t* pSurfaceFormatCount, + VkSurfaceFormat2KHR* pSurfaceFormats); +#endif + +#define VK_KHR_variable_pointers 1 +#define VK_KHR_VARIABLE_POINTERS_SPEC_VERSION 1 +#define VK_KHR_VARIABLE_POINTERS_EXTENSION_NAME "VK_KHR_variable_pointers" + +typedef struct VkPhysicalDeviceVariablePointerFeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 variablePointersStorageBuffer; + VkBool32 variablePointers; +} VkPhysicalDeviceVariablePointerFeaturesKHR; + + + +#define VK_KHR_dedicated_allocation 1 +#define VK_KHR_DEDICATED_ALLOCATION_SPEC_VERSION 3 +#define VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME "VK_KHR_dedicated_allocation" + +typedef struct VkMemoryDedicatedRequirementsKHR { + VkStructureType sType; + void* pNext; + VkBool32 prefersDedicatedAllocation; + VkBool32 requiresDedicatedAllocation; +} VkMemoryDedicatedRequirementsKHR; + +typedef struct VkMemoryDedicatedAllocateInfoKHR { + VkStructureType sType; + const void* pNext; + VkImage image; + VkBuffer buffer; +} VkMemoryDedicatedAllocateInfoKHR; + + + +#define VK_KHR_storage_buffer_storage_class 1 +#define VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_SPEC_VERSION 1 +#define VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_EXTENSION_NAME "VK_KHR_storage_buffer_storage_class" + + +#define VK_KHR_relaxed_block_layout 1 +#define VK_KHR_RELAXED_BLOCK_LAYOUT_SPEC_VERSION 1 +#define VK_KHR_RELAXED_BLOCK_LAYOUT_EXTENSION_NAME "VK_KHR_relaxed_block_layout" + + +#define VK_KHR_get_memory_requirements2 1 +#define VK_KHR_GET_MEMORY_REQUIREMENTS_2_SPEC_VERSION 1 +#define VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME "VK_KHR_get_memory_requirements2" + +typedef struct VkBufferMemoryRequirementsInfo2KHR { + VkStructureType sType; + const void* pNext; + VkBuffer buffer; +} VkBufferMemoryRequirementsInfo2KHR; + +typedef struct VkImageMemoryRequirementsInfo2KHR { + VkStructureType sType; + const void* pNext; + VkImage image; +} VkImageMemoryRequirementsInfo2KHR; + +typedef struct VkImageSparseMemoryRequirementsInfo2KHR { + VkStructureType sType; + const void* pNext; + VkImage image; +} VkImageSparseMemoryRequirementsInfo2KHR; + +typedef struct VkMemoryRequirements2KHR { + VkStructureType sType; + void* pNext; + VkMemoryRequirements memoryRequirements; +} VkMemoryRequirements2KHR; + +typedef struct VkSparseImageMemoryRequirements2KHR { + VkStructureType sType; + void* pNext; + VkSparseImageMemoryRequirements memoryRequirements; +} VkSparseImageMemoryRequirements2KHR; + + +typedef void (VKAPI_PTR *PFN_vkGetImageMemoryRequirements2KHR)(VkDevice device, const VkImageMemoryRequirementsInfo2KHR* pInfo, VkMemoryRequirements2KHR* pMemoryRequirements); +typedef void (VKAPI_PTR *PFN_vkGetBufferMemoryRequirements2KHR)(VkDevice device, const VkBufferMemoryRequirementsInfo2KHR* pInfo, VkMemoryRequirements2KHR* pMemoryRequirements); +typedef void (VKAPI_PTR *PFN_vkGetImageSparseMemoryRequirements2KHR)(VkDevice device, const VkImageSparseMemoryRequirementsInfo2KHR* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2KHR* pSparseMemoryRequirements); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements2KHR( + VkDevice device, + const VkImageMemoryRequirementsInfo2KHR* pInfo, + VkMemoryRequirements2KHR* pMemoryRequirements); + +VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements2KHR( + VkDevice device, + const VkBufferMemoryRequirementsInfo2KHR* pInfo, + VkMemoryRequirements2KHR* pMemoryRequirements); + +VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements2KHR( + VkDevice device, + const VkImageSparseMemoryRequirementsInfo2KHR* pInfo, + uint32_t* pSparseMemoryRequirementCount, + VkSparseImageMemoryRequirements2KHR* pSparseMemoryRequirements); +#endif + +#define VK_KHR_image_format_list 1 +#define VK_KHR_IMAGE_FORMAT_LIST_SPEC_VERSION 1 +#define VK_KHR_IMAGE_FORMAT_LIST_EXTENSION_NAME "VK_KHR_image_format_list" + +typedef struct VkImageFormatListCreateInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t viewFormatCount; + const VkFormat* pViewFormats; +} VkImageFormatListCreateInfoKHR; + + + +#define VK_KHR_sampler_ycbcr_conversion 1 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSamplerYcbcrConversionKHR) + +#define VK_KHR_SAMPLER_YCBCR_CONVERSION_SPEC_VERSION 1 +#define VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME "VK_KHR_sampler_ycbcr_conversion" + + +typedef enum VkSamplerYcbcrModelConversionKHR { + VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY_KHR = 0, + VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY_KHR = 1, + VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709_KHR = 2, + VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601_KHR = 3, + VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020_KHR = 4, + VK_SAMPLER_YCBCR_MODEL_CONVERSION_BEGIN_RANGE_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY_KHR, + VK_SAMPLER_YCBCR_MODEL_CONVERSION_END_RANGE_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020_KHR, + VK_SAMPLER_YCBCR_MODEL_CONVERSION_RANGE_SIZE_KHR = (VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020_KHR - VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY_KHR + 1), + VK_SAMPLER_YCBCR_MODEL_CONVERSION_MAX_ENUM_KHR = 0x7FFFFFFF +} VkSamplerYcbcrModelConversionKHR; + +typedef enum VkSamplerYcbcrRangeKHR { + VK_SAMPLER_YCBCR_RANGE_ITU_FULL_KHR = 0, + VK_SAMPLER_YCBCR_RANGE_ITU_NARROW_KHR = 1, + VK_SAMPLER_YCBCR_RANGE_BEGIN_RANGE_KHR = VK_SAMPLER_YCBCR_RANGE_ITU_FULL_KHR, + VK_SAMPLER_YCBCR_RANGE_END_RANGE_KHR = VK_SAMPLER_YCBCR_RANGE_ITU_NARROW_KHR, + VK_SAMPLER_YCBCR_RANGE_RANGE_SIZE_KHR = (VK_SAMPLER_YCBCR_RANGE_ITU_NARROW_KHR - VK_SAMPLER_YCBCR_RANGE_ITU_FULL_KHR + 1), + VK_SAMPLER_YCBCR_RANGE_MAX_ENUM_KHR = 0x7FFFFFFF +} VkSamplerYcbcrRangeKHR; + +typedef enum VkChromaLocationKHR { + VK_CHROMA_LOCATION_COSITED_EVEN_KHR = 0, + VK_CHROMA_LOCATION_MIDPOINT_KHR = 1, + VK_CHROMA_LOCATION_BEGIN_RANGE_KHR = VK_CHROMA_LOCATION_COSITED_EVEN_KHR, + VK_CHROMA_LOCATION_END_RANGE_KHR = VK_CHROMA_LOCATION_MIDPOINT_KHR, + VK_CHROMA_LOCATION_RANGE_SIZE_KHR = (VK_CHROMA_LOCATION_MIDPOINT_KHR - VK_CHROMA_LOCATION_COSITED_EVEN_KHR + 1), + VK_CHROMA_LOCATION_MAX_ENUM_KHR = 0x7FFFFFFF +} VkChromaLocationKHR; + +typedef struct VkSamplerYcbcrConversionCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkFormat format; + VkSamplerYcbcrModelConversionKHR ycbcrModel; + VkSamplerYcbcrRangeKHR ycbcrRange; + VkComponentMapping components; + VkChromaLocationKHR xChromaOffset; + VkChromaLocationKHR yChromaOffset; + VkFilter chromaFilter; + VkBool32 forceExplicitReconstruction; +} VkSamplerYcbcrConversionCreateInfoKHR; + +typedef struct VkSamplerYcbcrConversionInfoKHR { + VkStructureType sType; + const void* pNext; + VkSamplerYcbcrConversionKHR conversion; +} VkSamplerYcbcrConversionInfoKHR; + +typedef struct VkBindImagePlaneMemoryInfoKHR { + VkStructureType sType; + const void* pNext; + VkImageAspectFlagBits planeAspect; +} VkBindImagePlaneMemoryInfoKHR; + +typedef struct VkImagePlaneMemoryRequirementsInfoKHR { + VkStructureType sType; + const void* pNext; + VkImageAspectFlagBits planeAspect; +} VkImagePlaneMemoryRequirementsInfoKHR; + +typedef struct VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 samplerYcbcrConversion; +} VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR; + +typedef struct VkSamplerYcbcrConversionImageFormatPropertiesKHR { + VkStructureType sType; + void* pNext; + uint32_t combinedImageSamplerDescriptorCount; +} VkSamplerYcbcrConversionImageFormatPropertiesKHR; + + +typedef VkResult (VKAPI_PTR *PFN_vkCreateSamplerYcbcrConversionKHR)(VkDevice device, const VkSamplerYcbcrConversionCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversionKHR* pYcbcrConversion); +typedef void (VKAPI_PTR *PFN_vkDestroySamplerYcbcrConversionKHR)(VkDevice device, VkSamplerYcbcrConversionKHR ycbcrConversion, const VkAllocationCallbacks* pAllocator); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateSamplerYcbcrConversionKHR( + VkDevice device, + const VkSamplerYcbcrConversionCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSamplerYcbcrConversionKHR* pYcbcrConversion); + +VKAPI_ATTR void VKAPI_CALL vkDestroySamplerYcbcrConversionKHR( + VkDevice device, + VkSamplerYcbcrConversionKHR ycbcrConversion, + const VkAllocationCallbacks* pAllocator); +#endif + +#define VK_KHR_bind_memory2 1 +#define VK_KHR_BIND_MEMORY_2_SPEC_VERSION 1 +#define VK_KHR_BIND_MEMORY_2_EXTENSION_NAME "VK_KHR_bind_memory2" + +typedef struct VkBindBufferMemoryInfoKHR { + VkStructureType sType; + const void* pNext; + VkBuffer buffer; + VkDeviceMemory memory; + VkDeviceSize memoryOffset; +} VkBindBufferMemoryInfoKHR; + +typedef struct VkBindImageMemoryInfoKHR { + VkStructureType sType; + const void* pNext; + VkImage image; + VkDeviceMemory memory; + VkDeviceSize memoryOffset; +} VkBindImageMemoryInfoKHR; + + +typedef VkResult (VKAPI_PTR *PFN_vkBindBufferMemory2KHR)(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfoKHR* pBindInfos); +typedef VkResult (VKAPI_PTR *PFN_vkBindImageMemory2KHR)(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfoKHR* pBindInfos); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory2KHR( + VkDevice device, + uint32_t bindInfoCount, + const VkBindBufferMemoryInfoKHR* pBindInfos); + +VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory2KHR( + VkDevice device, + uint32_t bindInfoCount, + const VkBindImageMemoryInfoKHR* pBindInfos); +#endif + +#define VK_EXT_debug_report 1 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDebugReportCallbackEXT) + +#define VK_EXT_DEBUG_REPORT_SPEC_VERSION 9 +#define VK_EXT_DEBUG_REPORT_EXTENSION_NAME "VK_EXT_debug_report" +#define VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT +#define VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT + + +typedef enum VkDebugReportObjectTypeEXT { + VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT = 0, + VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT = 1, + VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT = 2, + VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT = 3, + VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT = 4, + VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT = 5, + VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT = 6, + VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT = 7, + VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT = 8, + VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT = 9, + VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT = 10, + VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT = 11, + VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT = 12, + VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT = 13, + VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT = 14, + VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT = 15, + VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT = 16, + VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT = 17, + VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT = 18, + VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT = 19, + VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT = 20, + VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT = 21, + VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT = 22, + VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT = 23, + VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT = 24, + VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT = 25, + VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT = 26, + VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT = 27, + VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT = 28, + VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT = 29, + VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT = 30, + VK_DEBUG_REPORT_OBJECT_TYPE_OBJECT_TABLE_NVX_EXT = 31, + VK_DEBUG_REPORT_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX_EXT = 32, + VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT = 33, + VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR_EXT = 1000085000, + VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR_EXT = 1000156000, + VK_DEBUG_REPORT_OBJECT_TYPE_BEGIN_RANGE_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, + VK_DEBUG_REPORT_OBJECT_TYPE_END_RANGE_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT, + VK_DEBUG_REPORT_OBJECT_TYPE_RANGE_SIZE_EXT = (VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT - VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT + 1), + VK_DEBUG_REPORT_OBJECT_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkDebugReportObjectTypeEXT; + + +typedef enum VkDebugReportFlagBitsEXT { + VK_DEBUG_REPORT_INFORMATION_BIT_EXT = 0x00000001, + VK_DEBUG_REPORT_WARNING_BIT_EXT = 0x00000002, + VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT = 0x00000004, + VK_DEBUG_REPORT_ERROR_BIT_EXT = 0x00000008, + VK_DEBUG_REPORT_DEBUG_BIT_EXT = 0x00000010, + VK_DEBUG_REPORT_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF +} VkDebugReportFlagBitsEXT; +typedef VkFlags VkDebugReportFlagsEXT; + +typedef VkBool32 (VKAPI_PTR *PFN_vkDebugReportCallbackEXT)( + VkDebugReportFlagsEXT flags, + VkDebugReportObjectTypeEXT objectType, + uint64_t object, + size_t location, + int32_t messageCode, + const char* pLayerPrefix, + const char* pMessage, + void* pUserData); + +typedef struct VkDebugReportCallbackCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkDebugReportFlagsEXT flags; + PFN_vkDebugReportCallbackEXT pfnCallback; + void* pUserData; +} VkDebugReportCallbackCreateInfoEXT; + + +typedef VkResult (VKAPI_PTR *PFN_vkCreateDebugReportCallbackEXT)(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugReportCallbackEXT* pCallback); +typedef void (VKAPI_PTR *PFN_vkDestroyDebugReportCallbackEXT)(VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks* pAllocator); +typedef void (VKAPI_PTR *PFN_vkDebugReportMessageEXT)(VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char* pLayerPrefix, const char* pMessage); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateDebugReportCallbackEXT( + VkInstance instance, + const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDebugReportCallbackEXT* pCallback); + +VKAPI_ATTR void VKAPI_CALL vkDestroyDebugReportCallbackEXT( + VkInstance instance, + VkDebugReportCallbackEXT callback, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR void VKAPI_CALL vkDebugReportMessageEXT( + VkInstance instance, + VkDebugReportFlagsEXT flags, + VkDebugReportObjectTypeEXT objectType, + uint64_t object, + size_t location, + int32_t messageCode, + const char* pLayerPrefix, + const char* pMessage); +#endif + +#define VK_NV_glsl_shader 1 +#define VK_NV_GLSL_SHADER_SPEC_VERSION 1 +#define VK_NV_GLSL_SHADER_EXTENSION_NAME "VK_NV_glsl_shader" + + +#define VK_EXT_depth_range_unrestricted 1 +#define VK_EXT_DEPTH_RANGE_UNRESTRICTED_SPEC_VERSION 1 +#define VK_EXT_DEPTH_RANGE_UNRESTRICTED_EXTENSION_NAME "VK_EXT_depth_range_unrestricted" + + +#define VK_IMG_filter_cubic 1 +#define VK_IMG_FILTER_CUBIC_SPEC_VERSION 1 +#define VK_IMG_FILTER_CUBIC_EXTENSION_NAME "VK_IMG_filter_cubic" + + +#define VK_AMD_rasterization_order 1 +#define VK_AMD_RASTERIZATION_ORDER_SPEC_VERSION 1 +#define VK_AMD_RASTERIZATION_ORDER_EXTENSION_NAME "VK_AMD_rasterization_order" + + +typedef enum VkRasterizationOrderAMD { + VK_RASTERIZATION_ORDER_STRICT_AMD = 0, + VK_RASTERIZATION_ORDER_RELAXED_AMD = 1, + VK_RASTERIZATION_ORDER_BEGIN_RANGE_AMD = VK_RASTERIZATION_ORDER_STRICT_AMD, + VK_RASTERIZATION_ORDER_END_RANGE_AMD = VK_RASTERIZATION_ORDER_RELAXED_AMD, + VK_RASTERIZATION_ORDER_RANGE_SIZE_AMD = (VK_RASTERIZATION_ORDER_RELAXED_AMD - VK_RASTERIZATION_ORDER_STRICT_AMD + 1), + VK_RASTERIZATION_ORDER_MAX_ENUM_AMD = 0x7FFFFFFF +} VkRasterizationOrderAMD; + +typedef struct VkPipelineRasterizationStateRasterizationOrderAMD { + VkStructureType sType; + const void* pNext; + VkRasterizationOrderAMD rasterizationOrder; +} VkPipelineRasterizationStateRasterizationOrderAMD; + + + +#define VK_AMD_shader_trinary_minmax 1 +#define VK_AMD_SHADER_TRINARY_MINMAX_SPEC_VERSION 1 +#define VK_AMD_SHADER_TRINARY_MINMAX_EXTENSION_NAME "VK_AMD_shader_trinary_minmax" + + +#define VK_AMD_shader_explicit_vertex_parameter 1 +#define VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_SPEC_VERSION 1 +#define VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_EXTENSION_NAME "VK_AMD_shader_explicit_vertex_parameter" + + +#define VK_EXT_debug_marker 1 +#define VK_EXT_DEBUG_MARKER_SPEC_VERSION 4 +#define VK_EXT_DEBUG_MARKER_EXTENSION_NAME "VK_EXT_debug_marker" + +typedef struct VkDebugMarkerObjectNameInfoEXT { + VkStructureType sType; + const void* pNext; + VkDebugReportObjectTypeEXT objectType; + uint64_t object; + const char* pObjectName; +} VkDebugMarkerObjectNameInfoEXT; + +typedef struct VkDebugMarkerObjectTagInfoEXT { + VkStructureType sType; + const void* pNext; + VkDebugReportObjectTypeEXT objectType; + uint64_t object; + uint64_t tagName; + size_t tagSize; + const void* pTag; +} VkDebugMarkerObjectTagInfoEXT; + +typedef struct VkDebugMarkerMarkerInfoEXT { + VkStructureType sType; + const void* pNext; + const char* pMarkerName; + float color[4]; +} VkDebugMarkerMarkerInfoEXT; + + +typedef VkResult (VKAPI_PTR *PFN_vkDebugMarkerSetObjectTagEXT)(VkDevice device, const VkDebugMarkerObjectTagInfoEXT* pTagInfo); +typedef VkResult (VKAPI_PTR *PFN_vkDebugMarkerSetObjectNameEXT)(VkDevice device, const VkDebugMarkerObjectNameInfoEXT* pNameInfo); +typedef void (VKAPI_PTR *PFN_vkCmdDebugMarkerBeginEXT)(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo); +typedef void (VKAPI_PTR *PFN_vkCmdDebugMarkerEndEXT)(VkCommandBuffer commandBuffer); +typedef void (VKAPI_PTR *PFN_vkCmdDebugMarkerInsertEXT)(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkDebugMarkerSetObjectTagEXT( + VkDevice device, + const VkDebugMarkerObjectTagInfoEXT* pTagInfo); + +VKAPI_ATTR VkResult VKAPI_CALL vkDebugMarkerSetObjectNameEXT( + VkDevice device, + const VkDebugMarkerObjectNameInfoEXT* pNameInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerBeginEXT( + VkCommandBuffer commandBuffer, + const VkDebugMarkerMarkerInfoEXT* pMarkerInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerEndEXT( + VkCommandBuffer commandBuffer); + +VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerInsertEXT( + VkCommandBuffer commandBuffer, + const VkDebugMarkerMarkerInfoEXT* pMarkerInfo); +#endif + +#define VK_AMD_gcn_shader 1 +#define VK_AMD_GCN_SHADER_SPEC_VERSION 1 +#define VK_AMD_GCN_SHADER_EXTENSION_NAME "VK_AMD_gcn_shader" + + +#define VK_NV_dedicated_allocation 1 +#define VK_NV_DEDICATED_ALLOCATION_SPEC_VERSION 1 +#define VK_NV_DEDICATED_ALLOCATION_EXTENSION_NAME "VK_NV_dedicated_allocation" + +typedef struct VkDedicatedAllocationImageCreateInfoNV { + VkStructureType sType; + const void* pNext; + VkBool32 dedicatedAllocation; +} VkDedicatedAllocationImageCreateInfoNV; + +typedef struct VkDedicatedAllocationBufferCreateInfoNV { + VkStructureType sType; + const void* pNext; + VkBool32 dedicatedAllocation; +} VkDedicatedAllocationBufferCreateInfoNV; + +typedef struct VkDedicatedAllocationMemoryAllocateInfoNV { + VkStructureType sType; + const void* pNext; + VkImage image; + VkBuffer buffer; +} VkDedicatedAllocationMemoryAllocateInfoNV; + + + +#define VK_AMD_draw_indirect_count 1 +#define VK_AMD_DRAW_INDIRECT_COUNT_SPEC_VERSION 1 +#define VK_AMD_DRAW_INDIRECT_COUNT_EXTENSION_NAME "VK_AMD_draw_indirect_count" + +typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirectCountAMD)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride); +typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexedIndirectCountAMD)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirectCountAMD( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + VkBuffer countBuffer, + VkDeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride); + +VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirectCountAMD( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + VkBuffer countBuffer, + VkDeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride); +#endif + +#define VK_AMD_negative_viewport_height 1 +#define VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_SPEC_VERSION 1 +#define VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_EXTENSION_NAME "VK_AMD_negative_viewport_height" + + +#define VK_AMD_gpu_shader_half_float 1 +#define VK_AMD_GPU_SHADER_HALF_FLOAT_SPEC_VERSION 1 +#define VK_AMD_GPU_SHADER_HALF_FLOAT_EXTENSION_NAME "VK_AMD_gpu_shader_half_float" + + +#define VK_AMD_shader_ballot 1 +#define VK_AMD_SHADER_BALLOT_SPEC_VERSION 1 +#define VK_AMD_SHADER_BALLOT_EXTENSION_NAME "VK_AMD_shader_ballot" + + +#define VK_AMD_texture_gather_bias_lod 1 +#define VK_AMD_TEXTURE_GATHER_BIAS_LOD_SPEC_VERSION 1 +#define VK_AMD_TEXTURE_GATHER_BIAS_LOD_EXTENSION_NAME "VK_AMD_texture_gather_bias_lod" + +typedef struct VkTextureLODGatherFormatPropertiesAMD { + VkStructureType sType; + void* pNext; + VkBool32 supportsTextureGatherLODBiasAMD; +} VkTextureLODGatherFormatPropertiesAMD; + + + +#define VK_AMD_shader_info 1 +#define VK_AMD_SHADER_INFO_SPEC_VERSION 1 +#define VK_AMD_SHADER_INFO_EXTENSION_NAME "VK_AMD_shader_info" + + +typedef enum VkShaderInfoTypeAMD { + VK_SHADER_INFO_TYPE_STATISTICS_AMD = 0, + VK_SHADER_INFO_TYPE_BINARY_AMD = 1, + VK_SHADER_INFO_TYPE_DISASSEMBLY_AMD = 2, + VK_SHADER_INFO_TYPE_BEGIN_RANGE_AMD = VK_SHADER_INFO_TYPE_STATISTICS_AMD, + VK_SHADER_INFO_TYPE_END_RANGE_AMD = VK_SHADER_INFO_TYPE_DISASSEMBLY_AMD, + VK_SHADER_INFO_TYPE_RANGE_SIZE_AMD = (VK_SHADER_INFO_TYPE_DISASSEMBLY_AMD - VK_SHADER_INFO_TYPE_STATISTICS_AMD + 1), + VK_SHADER_INFO_TYPE_MAX_ENUM_AMD = 0x7FFFFFFF +} VkShaderInfoTypeAMD; + +typedef struct VkShaderResourceUsageAMD { + uint32_t numUsedVgprs; + uint32_t numUsedSgprs; + uint32_t ldsSizePerLocalWorkGroup; + size_t ldsUsageSizeInBytes; + size_t scratchMemUsageInBytes; +} VkShaderResourceUsageAMD; + +typedef struct VkShaderStatisticsInfoAMD { + VkShaderStageFlags shaderStageMask; + VkShaderResourceUsageAMD resourceUsage; + uint32_t numPhysicalVgprs; + uint32_t numPhysicalSgprs; + uint32_t numAvailableVgprs; + uint32_t numAvailableSgprs; + uint32_t computeWorkGroupSize[3]; +} VkShaderStatisticsInfoAMD; + + +typedef VkResult (VKAPI_PTR *PFN_vkGetShaderInfoAMD)(VkDevice device, VkPipeline pipeline, VkShaderStageFlagBits shaderStage, VkShaderInfoTypeAMD infoType, size_t* pInfoSize, void* pInfo); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetShaderInfoAMD( + VkDevice device, + VkPipeline pipeline, + VkShaderStageFlagBits shaderStage, + VkShaderInfoTypeAMD infoType, + size_t* pInfoSize, + void* pInfo); +#endif + +#define VK_AMD_shader_image_load_store_lod 1 +#define VK_AMD_SHADER_IMAGE_LOAD_STORE_LOD_SPEC_VERSION 1 +#define VK_AMD_SHADER_IMAGE_LOAD_STORE_LOD_EXTENSION_NAME "VK_AMD_shader_image_load_store_lod" + + +#define VK_KHX_multiview 1 +#define VK_KHX_MULTIVIEW_SPEC_VERSION 1 +#define VK_KHX_MULTIVIEW_EXTENSION_NAME "VK_KHX_multiview" + +typedef struct VkRenderPassMultiviewCreateInfoKHX { + VkStructureType sType; + const void* pNext; + uint32_t subpassCount; + const uint32_t* pViewMasks; + uint32_t dependencyCount; + const int32_t* pViewOffsets; + uint32_t correlationMaskCount; + const uint32_t* pCorrelationMasks; +} VkRenderPassMultiviewCreateInfoKHX; + +typedef struct VkPhysicalDeviceMultiviewFeaturesKHX { + VkStructureType sType; + void* pNext; + VkBool32 multiview; + VkBool32 multiviewGeometryShader; + VkBool32 multiviewTessellationShader; +} VkPhysicalDeviceMultiviewFeaturesKHX; + +typedef struct VkPhysicalDeviceMultiviewPropertiesKHX { + VkStructureType sType; + void* pNext; + uint32_t maxMultiviewViewCount; + uint32_t maxMultiviewInstanceIndex; +} VkPhysicalDeviceMultiviewPropertiesKHX; + + + +#define VK_IMG_format_pvrtc 1 +#define VK_IMG_FORMAT_PVRTC_SPEC_VERSION 1 +#define VK_IMG_FORMAT_PVRTC_EXTENSION_NAME "VK_IMG_format_pvrtc" + + +#define VK_NV_external_memory_capabilities 1 +#define VK_NV_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION 1 +#define VK_NV_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME "VK_NV_external_memory_capabilities" + + +typedef enum VkExternalMemoryHandleTypeFlagBitsNV { + VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV = 0x00000001, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_NV = 0x00000002, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_BIT_NV = 0x00000004, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_BIT_NV = 0x00000008, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF +} VkExternalMemoryHandleTypeFlagBitsNV; +typedef VkFlags VkExternalMemoryHandleTypeFlagsNV; + +typedef enum VkExternalMemoryFeatureFlagBitsNV { + VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_NV = 0x00000001, + VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_NV = 0x00000002, + VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_NV = 0x00000004, + VK_EXTERNAL_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF +} VkExternalMemoryFeatureFlagBitsNV; +typedef VkFlags VkExternalMemoryFeatureFlagsNV; + +typedef struct VkExternalImageFormatPropertiesNV { + VkImageFormatProperties imageFormatProperties; + VkExternalMemoryFeatureFlagsNV externalMemoryFeatures; + VkExternalMemoryHandleTypeFlagsNV exportFromImportedHandleTypes; + VkExternalMemoryHandleTypeFlagsNV compatibleHandleTypes; +} VkExternalImageFormatPropertiesNV; + + +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkExternalMemoryHandleTypeFlagsNV externalHandleType, VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceExternalImageFormatPropertiesNV( + VkPhysicalDevice physicalDevice, + VkFormat format, + VkImageType type, + VkImageTiling tiling, + VkImageUsageFlags usage, + VkImageCreateFlags flags, + VkExternalMemoryHandleTypeFlagsNV externalHandleType, + VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties); +#endif + +#define VK_NV_external_memory 1 +#define VK_NV_EXTERNAL_MEMORY_SPEC_VERSION 1 +#define VK_NV_EXTERNAL_MEMORY_EXTENSION_NAME "VK_NV_external_memory" + +typedef struct VkExternalMemoryImageCreateInfoNV { + VkStructureType sType; + const void* pNext; + VkExternalMemoryHandleTypeFlagsNV handleTypes; +} VkExternalMemoryImageCreateInfoNV; + +typedef struct VkExportMemoryAllocateInfoNV { + VkStructureType sType; + const void* pNext; + VkExternalMemoryHandleTypeFlagsNV handleTypes; +} VkExportMemoryAllocateInfoNV; + + + +#ifdef VK_USE_PLATFORM_WIN32_KHR +#define VK_NV_external_memory_win32 1 +#define VK_NV_EXTERNAL_MEMORY_WIN32_SPEC_VERSION 1 +#define VK_NV_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME "VK_NV_external_memory_win32" + +typedef struct VkImportMemoryWin32HandleInfoNV { + VkStructureType sType; + const void* pNext; + VkExternalMemoryHandleTypeFlagsNV handleType; + HANDLE handle; +} VkImportMemoryWin32HandleInfoNV; + +typedef struct VkExportMemoryWin32HandleInfoNV { + VkStructureType sType; + const void* pNext; + const SECURITY_ATTRIBUTES* pAttributes; + DWORD dwAccess; +} VkExportMemoryWin32HandleInfoNV; + + +typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandleNV)(VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagsNV handleType, HANDLE* pHandle); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandleNV( + VkDevice device, + VkDeviceMemory memory, + VkExternalMemoryHandleTypeFlagsNV handleType, + HANDLE* pHandle); +#endif +#endif /* VK_USE_PLATFORM_WIN32_KHR */ + +#ifdef VK_USE_PLATFORM_WIN32_KHR +#define VK_NV_win32_keyed_mutex 1 +#define VK_NV_WIN32_KEYED_MUTEX_SPEC_VERSION 1 +#define VK_NV_WIN32_KEYED_MUTEX_EXTENSION_NAME "VK_NV_win32_keyed_mutex" + +typedef struct VkWin32KeyedMutexAcquireReleaseInfoNV { + VkStructureType sType; + const void* pNext; + uint32_t acquireCount; + const VkDeviceMemory* pAcquireSyncs; + const uint64_t* pAcquireKeys; + const uint32_t* pAcquireTimeoutMilliseconds; + uint32_t releaseCount; + const VkDeviceMemory* pReleaseSyncs; + const uint64_t* pReleaseKeys; +} VkWin32KeyedMutexAcquireReleaseInfoNV; + + +#endif /* VK_USE_PLATFORM_WIN32_KHR */ + +#define VK_KHX_device_group 1 +#define VK_KHX_DEVICE_GROUP_SPEC_VERSION 2 +#define VK_KHX_DEVICE_GROUP_EXTENSION_NAME "VK_KHX_device_group" +#define VK_MAX_DEVICE_GROUP_SIZE_KHX 32 + + +typedef enum VkPeerMemoryFeatureFlagBitsKHX { + VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT_KHX = 0x00000001, + VK_PEER_MEMORY_FEATURE_COPY_DST_BIT_KHX = 0x00000002, + VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT_KHX = 0x00000004, + VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT_KHX = 0x00000008, + VK_PEER_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM_KHX = 0x7FFFFFFF +} VkPeerMemoryFeatureFlagBitsKHX; +typedef VkFlags VkPeerMemoryFeatureFlagsKHX; + +typedef enum VkMemoryAllocateFlagBitsKHX { + VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT_KHX = 0x00000001, + VK_MEMORY_ALLOCATE_FLAG_BITS_MAX_ENUM_KHX = 0x7FFFFFFF +} VkMemoryAllocateFlagBitsKHX; +typedef VkFlags VkMemoryAllocateFlagsKHX; + +typedef enum VkDeviceGroupPresentModeFlagBitsKHX { + VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHX = 0x00000001, + VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHX = 0x00000002, + VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHX = 0x00000004, + VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHX = 0x00000008, + VK_DEVICE_GROUP_PRESENT_MODE_FLAG_BITS_MAX_ENUM_KHX = 0x7FFFFFFF +} VkDeviceGroupPresentModeFlagBitsKHX; +typedef VkFlags VkDeviceGroupPresentModeFlagsKHX; + +typedef struct VkMemoryAllocateFlagsInfoKHX { + VkStructureType sType; + const void* pNext; + VkMemoryAllocateFlagsKHX flags; + uint32_t deviceMask; +} VkMemoryAllocateFlagsInfoKHX; + +typedef struct VkDeviceGroupRenderPassBeginInfoKHX { + VkStructureType sType; + const void* pNext; + uint32_t deviceMask; + uint32_t deviceRenderAreaCount; + const VkRect2D* pDeviceRenderAreas; +} VkDeviceGroupRenderPassBeginInfoKHX; + +typedef struct VkDeviceGroupCommandBufferBeginInfoKHX { + VkStructureType sType; + const void* pNext; + uint32_t deviceMask; +} VkDeviceGroupCommandBufferBeginInfoKHX; + +typedef struct VkDeviceGroupSubmitInfoKHX { + VkStructureType sType; + const void* pNext; + uint32_t waitSemaphoreCount; + const uint32_t* pWaitSemaphoreDeviceIndices; + uint32_t commandBufferCount; + const uint32_t* pCommandBufferDeviceMasks; + uint32_t signalSemaphoreCount; + const uint32_t* pSignalSemaphoreDeviceIndices; +} VkDeviceGroupSubmitInfoKHX; + +typedef struct VkDeviceGroupBindSparseInfoKHX { + VkStructureType sType; + const void* pNext; + uint32_t resourceDeviceIndex; + uint32_t memoryDeviceIndex; +} VkDeviceGroupBindSparseInfoKHX; + +typedef struct VkBindBufferMemoryDeviceGroupInfoKHX { + VkStructureType sType; + const void* pNext; + uint32_t deviceIndexCount; + const uint32_t* pDeviceIndices; +} VkBindBufferMemoryDeviceGroupInfoKHX; + +typedef struct VkBindImageMemoryDeviceGroupInfoKHX { + VkStructureType sType; + const void* pNext; + uint32_t deviceIndexCount; + const uint32_t* pDeviceIndices; + uint32_t SFRRectCount; + const VkRect2D* pSFRRects; +} VkBindImageMemoryDeviceGroupInfoKHX; + +typedef struct VkDeviceGroupPresentCapabilitiesKHX { + VkStructureType sType; + const void* pNext; + uint32_t presentMask[VK_MAX_DEVICE_GROUP_SIZE_KHX]; + VkDeviceGroupPresentModeFlagsKHX modes; +} VkDeviceGroupPresentCapabilitiesKHX; + +typedef struct VkImageSwapchainCreateInfoKHX { + VkStructureType sType; + const void* pNext; + VkSwapchainKHR swapchain; +} VkImageSwapchainCreateInfoKHX; + +typedef struct VkBindImageMemorySwapchainInfoKHX { + VkStructureType sType; + const void* pNext; + VkSwapchainKHR swapchain; + uint32_t imageIndex; +} VkBindImageMemorySwapchainInfoKHX; + +typedef struct VkAcquireNextImageInfoKHX { + VkStructureType sType; + const void* pNext; + VkSwapchainKHR swapchain; + uint64_t timeout; + VkSemaphore semaphore; + VkFence fence; + uint32_t deviceMask; +} VkAcquireNextImageInfoKHX; + +typedef struct VkDeviceGroupPresentInfoKHX { + VkStructureType sType; + const void* pNext; + uint32_t swapchainCount; + const uint32_t* pDeviceMasks; + VkDeviceGroupPresentModeFlagBitsKHX mode; +} VkDeviceGroupPresentInfoKHX; + +typedef struct VkDeviceGroupSwapchainCreateInfoKHX { + VkStructureType sType; + const void* pNext; + VkDeviceGroupPresentModeFlagsKHX modes; +} VkDeviceGroupSwapchainCreateInfoKHX; + + +typedef void (VKAPI_PTR *PFN_vkGetDeviceGroupPeerMemoryFeaturesKHX)(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlagsKHX* pPeerMemoryFeatures); +typedef void (VKAPI_PTR *PFN_vkCmdSetDeviceMaskKHX)(VkCommandBuffer commandBuffer, uint32_t deviceMask); +typedef void (VKAPI_PTR *PFN_vkCmdDispatchBaseKHX)(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ); +typedef VkResult (VKAPI_PTR *PFN_vkGetDeviceGroupPresentCapabilitiesKHX)(VkDevice device, VkDeviceGroupPresentCapabilitiesKHX* pDeviceGroupPresentCapabilities); +typedef VkResult (VKAPI_PTR *PFN_vkGetDeviceGroupSurfacePresentModesKHX)(VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHX* pModes); +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDevicePresentRectanglesKHX)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pRectCount, VkRect2D* pRects); +typedef VkResult (VKAPI_PTR *PFN_vkAcquireNextImage2KHX)(VkDevice device, const VkAcquireNextImageInfoKHX* pAcquireInfo, uint32_t* pImageIndex); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkGetDeviceGroupPeerMemoryFeaturesKHX( + VkDevice device, + uint32_t heapIndex, + uint32_t localDeviceIndex, + uint32_t remoteDeviceIndex, + VkPeerMemoryFeatureFlagsKHX* pPeerMemoryFeatures); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetDeviceMaskKHX( + VkCommandBuffer commandBuffer, + uint32_t deviceMask); + +VKAPI_ATTR void VKAPI_CALL vkCmdDispatchBaseKHX( + VkCommandBuffer commandBuffer, + uint32_t baseGroupX, + uint32_t baseGroupY, + uint32_t baseGroupZ, + uint32_t groupCountX, + uint32_t groupCountY, + uint32_t groupCountZ); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceGroupPresentCapabilitiesKHX( + VkDevice device, + VkDeviceGroupPresentCapabilitiesKHX* pDeviceGroupPresentCapabilities); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceGroupSurfacePresentModesKHX( + VkDevice device, + VkSurfaceKHR surface, + VkDeviceGroupPresentModeFlagsKHX* pModes); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDevicePresentRectanglesKHX( + VkPhysicalDevice physicalDevice, + VkSurfaceKHR surface, + uint32_t* pRectCount, + VkRect2D* pRects); + +VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImage2KHX( + VkDevice device, + const VkAcquireNextImageInfoKHX* pAcquireInfo, + uint32_t* pImageIndex); +#endif + +#define VK_EXT_validation_flags 1 +#define VK_EXT_VALIDATION_FLAGS_SPEC_VERSION 1 +#define VK_EXT_VALIDATION_FLAGS_EXTENSION_NAME "VK_EXT_validation_flags" + + +typedef enum VkValidationCheckEXT { + VK_VALIDATION_CHECK_ALL_EXT = 0, + VK_VALIDATION_CHECK_SHADERS_EXT = 1, + VK_VALIDATION_CHECK_BEGIN_RANGE_EXT = VK_VALIDATION_CHECK_ALL_EXT, + VK_VALIDATION_CHECK_END_RANGE_EXT = VK_VALIDATION_CHECK_SHADERS_EXT, + VK_VALIDATION_CHECK_RANGE_SIZE_EXT = (VK_VALIDATION_CHECK_SHADERS_EXT - VK_VALIDATION_CHECK_ALL_EXT + 1), + VK_VALIDATION_CHECK_MAX_ENUM_EXT = 0x7FFFFFFF +} VkValidationCheckEXT; + +typedef struct VkValidationFlagsEXT { + VkStructureType sType; + const void* pNext; + uint32_t disabledValidationCheckCount; + VkValidationCheckEXT* pDisabledValidationChecks; +} VkValidationFlagsEXT; + + + +#ifdef VK_USE_PLATFORM_VI_NN +#define VK_NN_vi_surface 1 +#define VK_NN_VI_SURFACE_SPEC_VERSION 1 +#define VK_NN_VI_SURFACE_EXTENSION_NAME "VK_NN_vi_surface" + +typedef VkFlags VkViSurfaceCreateFlagsNN; + +typedef struct VkViSurfaceCreateInfoNN { + VkStructureType sType; + const void* pNext; + VkViSurfaceCreateFlagsNN flags; + void* window; +} VkViSurfaceCreateInfoNN; + + +typedef VkResult (VKAPI_PTR *PFN_vkCreateViSurfaceNN)(VkInstance instance, const VkViSurfaceCreateInfoNN* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateViSurfaceNN( + VkInstance instance, + const VkViSurfaceCreateInfoNN* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); +#endif +#endif /* VK_USE_PLATFORM_VI_NN */ + +#define VK_EXT_shader_subgroup_ballot 1 +#define VK_EXT_SHADER_SUBGROUP_BALLOT_SPEC_VERSION 1 +#define VK_EXT_SHADER_SUBGROUP_BALLOT_EXTENSION_NAME "VK_EXT_shader_subgroup_ballot" + + +#define VK_EXT_shader_subgroup_vote 1 +#define VK_EXT_SHADER_SUBGROUP_VOTE_SPEC_VERSION 1 +#define VK_EXT_SHADER_SUBGROUP_VOTE_EXTENSION_NAME "VK_EXT_shader_subgroup_vote" + + +#define VK_KHX_device_group_creation 1 +#define VK_KHX_DEVICE_GROUP_CREATION_SPEC_VERSION 1 +#define VK_KHX_DEVICE_GROUP_CREATION_EXTENSION_NAME "VK_KHX_device_group_creation" + +typedef struct VkPhysicalDeviceGroupPropertiesKHX { + VkStructureType sType; + void* pNext; + uint32_t physicalDeviceCount; + VkPhysicalDevice physicalDevices[VK_MAX_DEVICE_GROUP_SIZE_KHX]; + VkBool32 subsetAllocation; +} VkPhysicalDeviceGroupPropertiesKHX; + +typedef struct VkDeviceGroupDeviceCreateInfoKHX { + VkStructureType sType; + const void* pNext; + uint32_t physicalDeviceCount; + const VkPhysicalDevice* pPhysicalDevices; +} VkDeviceGroupDeviceCreateInfoKHX; + + +typedef VkResult (VKAPI_PTR *PFN_vkEnumeratePhysicalDeviceGroupsKHX)(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupPropertiesKHX* pPhysicalDeviceGroupProperties); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDeviceGroupsKHX( + VkInstance instance, + uint32_t* pPhysicalDeviceGroupCount, + VkPhysicalDeviceGroupPropertiesKHX* pPhysicalDeviceGroupProperties); +#endif + +#define VK_NVX_device_generated_commands 1 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkObjectTableNVX) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkIndirectCommandsLayoutNVX) + +#define VK_NVX_DEVICE_GENERATED_COMMANDS_SPEC_VERSION 3 +#define VK_NVX_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME "VK_NVX_device_generated_commands" + + +typedef enum VkIndirectCommandsTokenTypeNVX { + VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NVX = 0, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_DESCRIPTOR_SET_NVX = 1, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_NVX = 2, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_NVX = 3, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NVX = 4, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NVX = 5, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NVX = 6, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NVX = 7, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_BEGIN_RANGE_NVX = VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NVX, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_END_RANGE_NVX = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NVX, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_RANGE_SIZE_NVX = (VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NVX - VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NVX + 1), + VK_INDIRECT_COMMANDS_TOKEN_TYPE_MAX_ENUM_NVX = 0x7FFFFFFF +} VkIndirectCommandsTokenTypeNVX; + +typedef enum VkObjectEntryTypeNVX { + VK_OBJECT_ENTRY_TYPE_DESCRIPTOR_SET_NVX = 0, + VK_OBJECT_ENTRY_TYPE_PIPELINE_NVX = 1, + VK_OBJECT_ENTRY_TYPE_INDEX_BUFFER_NVX = 2, + VK_OBJECT_ENTRY_TYPE_VERTEX_BUFFER_NVX = 3, + VK_OBJECT_ENTRY_TYPE_PUSH_CONSTANT_NVX = 4, + VK_OBJECT_ENTRY_TYPE_BEGIN_RANGE_NVX = VK_OBJECT_ENTRY_TYPE_DESCRIPTOR_SET_NVX, + VK_OBJECT_ENTRY_TYPE_END_RANGE_NVX = VK_OBJECT_ENTRY_TYPE_PUSH_CONSTANT_NVX, + VK_OBJECT_ENTRY_TYPE_RANGE_SIZE_NVX = (VK_OBJECT_ENTRY_TYPE_PUSH_CONSTANT_NVX - VK_OBJECT_ENTRY_TYPE_DESCRIPTOR_SET_NVX + 1), + VK_OBJECT_ENTRY_TYPE_MAX_ENUM_NVX = 0x7FFFFFFF +} VkObjectEntryTypeNVX; + + +typedef enum VkIndirectCommandsLayoutUsageFlagBitsNVX { + VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NVX = 0x00000001, + VK_INDIRECT_COMMANDS_LAYOUT_USAGE_SPARSE_SEQUENCES_BIT_NVX = 0x00000002, + VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EMPTY_EXECUTIONS_BIT_NVX = 0x00000004, + VK_INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NVX = 0x00000008, + VK_INDIRECT_COMMANDS_LAYOUT_USAGE_FLAG_BITS_MAX_ENUM_NVX = 0x7FFFFFFF +} VkIndirectCommandsLayoutUsageFlagBitsNVX; +typedef VkFlags VkIndirectCommandsLayoutUsageFlagsNVX; + +typedef enum VkObjectEntryUsageFlagBitsNVX { + VK_OBJECT_ENTRY_USAGE_GRAPHICS_BIT_NVX = 0x00000001, + VK_OBJECT_ENTRY_USAGE_COMPUTE_BIT_NVX = 0x00000002, + VK_OBJECT_ENTRY_USAGE_FLAG_BITS_MAX_ENUM_NVX = 0x7FFFFFFF +} VkObjectEntryUsageFlagBitsNVX; +typedef VkFlags VkObjectEntryUsageFlagsNVX; + +typedef struct VkDeviceGeneratedCommandsFeaturesNVX { + VkStructureType sType; + const void* pNext; + VkBool32 computeBindingPointSupport; +} VkDeviceGeneratedCommandsFeaturesNVX; + +typedef struct VkDeviceGeneratedCommandsLimitsNVX { + VkStructureType sType; + const void* pNext; + uint32_t maxIndirectCommandsLayoutTokenCount; + uint32_t maxObjectEntryCounts; + uint32_t minSequenceCountBufferOffsetAlignment; + uint32_t minSequenceIndexBufferOffsetAlignment; + uint32_t minCommandsTokenBufferOffsetAlignment; +} VkDeviceGeneratedCommandsLimitsNVX; + +typedef struct VkIndirectCommandsTokenNVX { + VkIndirectCommandsTokenTypeNVX tokenType; + VkBuffer buffer; + VkDeviceSize offset; +} VkIndirectCommandsTokenNVX; + +typedef struct VkIndirectCommandsLayoutTokenNVX { + VkIndirectCommandsTokenTypeNVX tokenType; + uint32_t bindingUnit; + uint32_t dynamicCount; + uint32_t divisor; +} VkIndirectCommandsLayoutTokenNVX; + +typedef struct VkIndirectCommandsLayoutCreateInfoNVX { + VkStructureType sType; + const void* pNext; + VkPipelineBindPoint pipelineBindPoint; + VkIndirectCommandsLayoutUsageFlagsNVX flags; + uint32_t tokenCount; + const VkIndirectCommandsLayoutTokenNVX* pTokens; +} VkIndirectCommandsLayoutCreateInfoNVX; + +typedef struct VkCmdProcessCommandsInfoNVX { + VkStructureType sType; + const void* pNext; + VkObjectTableNVX objectTable; + VkIndirectCommandsLayoutNVX indirectCommandsLayout; + uint32_t indirectCommandsTokenCount; + const VkIndirectCommandsTokenNVX* pIndirectCommandsTokens; + uint32_t maxSequencesCount; + VkCommandBuffer targetCommandBuffer; + VkBuffer sequencesCountBuffer; + VkDeviceSize sequencesCountOffset; + VkBuffer sequencesIndexBuffer; + VkDeviceSize sequencesIndexOffset; +} VkCmdProcessCommandsInfoNVX; + +typedef struct VkCmdReserveSpaceForCommandsInfoNVX { + VkStructureType sType; + const void* pNext; + VkObjectTableNVX objectTable; + VkIndirectCommandsLayoutNVX indirectCommandsLayout; + uint32_t maxSequencesCount; +} VkCmdReserveSpaceForCommandsInfoNVX; + +typedef struct VkObjectTableCreateInfoNVX { + VkStructureType sType; + const void* pNext; + uint32_t objectCount; + const VkObjectEntryTypeNVX* pObjectEntryTypes; + const uint32_t* pObjectEntryCounts; + const VkObjectEntryUsageFlagsNVX* pObjectEntryUsageFlags; + uint32_t maxUniformBuffersPerDescriptor; + uint32_t maxStorageBuffersPerDescriptor; + uint32_t maxStorageImagesPerDescriptor; + uint32_t maxSampledImagesPerDescriptor; + uint32_t maxPipelineLayouts; +} VkObjectTableCreateInfoNVX; + +typedef struct VkObjectTableEntryNVX { + VkObjectEntryTypeNVX type; + VkObjectEntryUsageFlagsNVX flags; +} VkObjectTableEntryNVX; + +typedef struct VkObjectTablePipelineEntryNVX { + VkObjectEntryTypeNVX type; + VkObjectEntryUsageFlagsNVX flags; + VkPipeline pipeline; +} VkObjectTablePipelineEntryNVX; + +typedef struct VkObjectTableDescriptorSetEntryNVX { + VkObjectEntryTypeNVX type; + VkObjectEntryUsageFlagsNVX flags; + VkPipelineLayout pipelineLayout; + VkDescriptorSet descriptorSet; +} VkObjectTableDescriptorSetEntryNVX; + +typedef struct VkObjectTableVertexBufferEntryNVX { + VkObjectEntryTypeNVX type; + VkObjectEntryUsageFlagsNVX flags; + VkBuffer buffer; +} VkObjectTableVertexBufferEntryNVX; + +typedef struct VkObjectTableIndexBufferEntryNVX { + VkObjectEntryTypeNVX type; + VkObjectEntryUsageFlagsNVX flags; + VkBuffer buffer; + VkIndexType indexType; +} VkObjectTableIndexBufferEntryNVX; + +typedef struct VkObjectTablePushConstantEntryNVX { + VkObjectEntryTypeNVX type; + VkObjectEntryUsageFlagsNVX flags; + VkPipelineLayout pipelineLayout; + VkShaderStageFlags stageFlags; +} VkObjectTablePushConstantEntryNVX; + + +typedef void (VKAPI_PTR *PFN_vkCmdProcessCommandsNVX)(VkCommandBuffer commandBuffer, const VkCmdProcessCommandsInfoNVX* pProcessCommandsInfo); +typedef void (VKAPI_PTR *PFN_vkCmdReserveSpaceForCommandsNVX)(VkCommandBuffer commandBuffer, const VkCmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo); +typedef VkResult (VKAPI_PTR *PFN_vkCreateIndirectCommandsLayoutNVX)(VkDevice device, const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkIndirectCommandsLayoutNVX* pIndirectCommandsLayout); +typedef void (VKAPI_PTR *PFN_vkDestroyIndirectCommandsLayoutNVX)(VkDevice device, VkIndirectCommandsLayoutNVX indirectCommandsLayout, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkCreateObjectTableNVX)(VkDevice device, const VkObjectTableCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkObjectTableNVX* pObjectTable); +typedef void (VKAPI_PTR *PFN_vkDestroyObjectTableNVX)(VkDevice device, VkObjectTableNVX objectTable, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkRegisterObjectsNVX)(VkDevice device, VkObjectTableNVX objectTable, uint32_t objectCount, const VkObjectTableEntryNVX* const* ppObjectTableEntries, const uint32_t* pObjectIndices); +typedef VkResult (VKAPI_PTR *PFN_vkUnregisterObjectsNVX)(VkDevice device, VkObjectTableNVX objectTable, uint32_t objectCount, const VkObjectEntryTypeNVX* pObjectEntryTypes, const uint32_t* pObjectIndices); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX)(VkPhysicalDevice physicalDevice, VkDeviceGeneratedCommandsFeaturesNVX* pFeatures, VkDeviceGeneratedCommandsLimitsNVX* pLimits); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdProcessCommandsNVX( + VkCommandBuffer commandBuffer, + const VkCmdProcessCommandsInfoNVX* pProcessCommandsInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdReserveSpaceForCommandsNVX( + VkCommandBuffer commandBuffer, + const VkCmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateIndirectCommandsLayoutNVX( + VkDevice device, + const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkIndirectCommandsLayoutNVX* pIndirectCommandsLayout); + +VKAPI_ATTR void VKAPI_CALL vkDestroyIndirectCommandsLayoutNVX( + VkDevice device, + VkIndirectCommandsLayoutNVX indirectCommandsLayout, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateObjectTableNVX( + VkDevice device, + const VkObjectTableCreateInfoNVX* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkObjectTableNVX* pObjectTable); + +VKAPI_ATTR void VKAPI_CALL vkDestroyObjectTableNVX( + VkDevice device, + VkObjectTableNVX objectTable, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkRegisterObjectsNVX( + VkDevice device, + VkObjectTableNVX objectTable, + uint32_t objectCount, + const VkObjectTableEntryNVX* const* ppObjectTableEntries, + const uint32_t* pObjectIndices); + +VKAPI_ATTR VkResult VKAPI_CALL vkUnregisterObjectsNVX( + VkDevice device, + VkObjectTableNVX objectTable, + uint32_t objectCount, + const VkObjectEntryTypeNVX* pObjectEntryTypes, + const uint32_t* pObjectIndices); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX( + VkPhysicalDevice physicalDevice, + VkDeviceGeneratedCommandsFeaturesNVX* pFeatures, + VkDeviceGeneratedCommandsLimitsNVX* pLimits); +#endif + +#define VK_NV_clip_space_w_scaling 1 +#define VK_NV_CLIP_SPACE_W_SCALING_SPEC_VERSION 1 +#define VK_NV_CLIP_SPACE_W_SCALING_EXTENSION_NAME "VK_NV_clip_space_w_scaling" + +typedef struct VkViewportWScalingNV { + float xcoeff; + float ycoeff; +} VkViewportWScalingNV; + +typedef struct VkPipelineViewportWScalingStateCreateInfoNV { + VkStructureType sType; + const void* pNext; + VkBool32 viewportWScalingEnable; + uint32_t viewportCount; + const VkViewportWScalingNV* pViewportWScalings; +} VkPipelineViewportWScalingStateCreateInfoNV; + + +typedef void (VKAPI_PTR *PFN_vkCmdSetViewportWScalingNV)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportWScalingNV* pViewportWScalings); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetViewportWScalingNV( + VkCommandBuffer commandBuffer, + uint32_t firstViewport, + uint32_t viewportCount, + const VkViewportWScalingNV* pViewportWScalings); +#endif + +#define VK_EXT_direct_mode_display 1 +#define VK_EXT_DIRECT_MODE_DISPLAY_SPEC_VERSION 1 +#define VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME "VK_EXT_direct_mode_display" + +typedef VkResult (VKAPI_PTR *PFN_vkReleaseDisplayEXT)(VkPhysicalDevice physicalDevice, VkDisplayKHR display); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkReleaseDisplayEXT( + VkPhysicalDevice physicalDevice, + VkDisplayKHR display); +#endif + +#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT +#define VK_EXT_acquire_xlib_display 1 +#include + +#define VK_EXT_ACQUIRE_XLIB_DISPLAY_SPEC_VERSION 1 +#define VK_EXT_ACQUIRE_XLIB_DISPLAY_EXTENSION_NAME "VK_EXT_acquire_xlib_display" + +typedef VkResult (VKAPI_PTR *PFN_vkAcquireXlibDisplayEXT)(VkPhysicalDevice physicalDevice, Display* dpy, VkDisplayKHR display); +typedef VkResult (VKAPI_PTR *PFN_vkGetRandROutputDisplayEXT)(VkPhysicalDevice physicalDevice, Display* dpy, RROutput rrOutput, VkDisplayKHR* pDisplay); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkAcquireXlibDisplayEXT( + VkPhysicalDevice physicalDevice, + Display* dpy, + VkDisplayKHR display); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetRandROutputDisplayEXT( + VkPhysicalDevice physicalDevice, + Display* dpy, + RROutput rrOutput, + VkDisplayKHR* pDisplay); +#endif +#endif /* VK_USE_PLATFORM_XLIB_XRANDR_EXT */ + +#define VK_EXT_display_surface_counter 1 +#define VK_EXT_DISPLAY_SURFACE_COUNTER_SPEC_VERSION 1 +#define VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME "VK_EXT_display_surface_counter" +#define VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES2_EXT VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT + + +typedef enum VkSurfaceCounterFlagBitsEXT { + VK_SURFACE_COUNTER_VBLANK_EXT = 0x00000001, + VK_SURFACE_COUNTER_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF +} VkSurfaceCounterFlagBitsEXT; +typedef VkFlags VkSurfaceCounterFlagsEXT; + +typedef struct VkSurfaceCapabilities2EXT { + VkStructureType sType; + void* pNext; + uint32_t minImageCount; + uint32_t maxImageCount; + VkExtent2D currentExtent; + VkExtent2D minImageExtent; + VkExtent2D maxImageExtent; + uint32_t maxImageArrayLayers; + VkSurfaceTransformFlagsKHR supportedTransforms; + VkSurfaceTransformFlagBitsKHR currentTransform; + VkCompositeAlphaFlagsKHR supportedCompositeAlpha; + VkImageUsageFlags supportedUsageFlags; + VkSurfaceCounterFlagsEXT supportedSurfaceCounters; +} VkSurfaceCapabilities2EXT; + + +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilities2EXT* pSurfaceCapabilities); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilities2EXT( + VkPhysicalDevice physicalDevice, + VkSurfaceKHR surface, + VkSurfaceCapabilities2EXT* pSurfaceCapabilities); +#endif + +#define VK_EXT_display_control 1 +#define VK_EXT_DISPLAY_CONTROL_SPEC_VERSION 1 +#define VK_EXT_DISPLAY_CONTROL_EXTENSION_NAME "VK_EXT_display_control" + + +typedef enum VkDisplayPowerStateEXT { + VK_DISPLAY_POWER_STATE_OFF_EXT = 0, + VK_DISPLAY_POWER_STATE_SUSPEND_EXT = 1, + VK_DISPLAY_POWER_STATE_ON_EXT = 2, + VK_DISPLAY_POWER_STATE_BEGIN_RANGE_EXT = VK_DISPLAY_POWER_STATE_OFF_EXT, + VK_DISPLAY_POWER_STATE_END_RANGE_EXT = VK_DISPLAY_POWER_STATE_ON_EXT, + VK_DISPLAY_POWER_STATE_RANGE_SIZE_EXT = (VK_DISPLAY_POWER_STATE_ON_EXT - VK_DISPLAY_POWER_STATE_OFF_EXT + 1), + VK_DISPLAY_POWER_STATE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkDisplayPowerStateEXT; + +typedef enum VkDeviceEventTypeEXT { + VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT = 0, + VK_DEVICE_EVENT_TYPE_BEGIN_RANGE_EXT = VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT, + VK_DEVICE_EVENT_TYPE_END_RANGE_EXT = VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT, + VK_DEVICE_EVENT_TYPE_RANGE_SIZE_EXT = (VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT - VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT + 1), + VK_DEVICE_EVENT_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkDeviceEventTypeEXT; + +typedef enum VkDisplayEventTypeEXT { + VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT = 0, + VK_DISPLAY_EVENT_TYPE_BEGIN_RANGE_EXT = VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT, + VK_DISPLAY_EVENT_TYPE_END_RANGE_EXT = VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT, + VK_DISPLAY_EVENT_TYPE_RANGE_SIZE_EXT = (VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT - VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT + 1), + VK_DISPLAY_EVENT_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkDisplayEventTypeEXT; + +typedef struct VkDisplayPowerInfoEXT { + VkStructureType sType; + const void* pNext; + VkDisplayPowerStateEXT powerState; +} VkDisplayPowerInfoEXT; + +typedef struct VkDeviceEventInfoEXT { + VkStructureType sType; + const void* pNext; + VkDeviceEventTypeEXT deviceEvent; +} VkDeviceEventInfoEXT; + +typedef struct VkDisplayEventInfoEXT { + VkStructureType sType; + const void* pNext; + VkDisplayEventTypeEXT displayEvent; +} VkDisplayEventInfoEXT; + +typedef struct VkSwapchainCounterCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkSurfaceCounterFlagsEXT surfaceCounters; +} VkSwapchainCounterCreateInfoEXT; + + +typedef VkResult (VKAPI_PTR *PFN_vkDisplayPowerControlEXT)(VkDevice device, VkDisplayKHR display, const VkDisplayPowerInfoEXT* pDisplayPowerInfo); +typedef VkResult (VKAPI_PTR *PFN_vkRegisterDeviceEventEXT)(VkDevice device, const VkDeviceEventInfoEXT* pDeviceEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence); +typedef VkResult (VKAPI_PTR *PFN_vkRegisterDisplayEventEXT)(VkDevice device, VkDisplayKHR display, const VkDisplayEventInfoEXT* pDisplayEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence); +typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainCounterEXT)(VkDevice device, VkSwapchainKHR swapchain, VkSurfaceCounterFlagBitsEXT counter, uint64_t* pCounterValue); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkDisplayPowerControlEXT( + VkDevice device, + VkDisplayKHR display, + const VkDisplayPowerInfoEXT* pDisplayPowerInfo); + +VKAPI_ATTR VkResult VKAPI_CALL vkRegisterDeviceEventEXT( + VkDevice device, + const VkDeviceEventInfoEXT* pDeviceEventInfo, + const VkAllocationCallbacks* pAllocator, + VkFence* pFence); + +VKAPI_ATTR VkResult VKAPI_CALL vkRegisterDisplayEventEXT( + VkDevice device, + VkDisplayKHR display, + const VkDisplayEventInfoEXT* pDisplayEventInfo, + const VkAllocationCallbacks* pAllocator, + VkFence* pFence); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainCounterEXT( + VkDevice device, + VkSwapchainKHR swapchain, + VkSurfaceCounterFlagBitsEXT counter, + uint64_t* pCounterValue); +#endif + +#define VK_GOOGLE_display_timing 1 +#define VK_GOOGLE_DISPLAY_TIMING_SPEC_VERSION 1 +#define VK_GOOGLE_DISPLAY_TIMING_EXTENSION_NAME "VK_GOOGLE_display_timing" + +typedef struct VkRefreshCycleDurationGOOGLE { + uint64_t refreshDuration; +} VkRefreshCycleDurationGOOGLE; + +typedef struct VkPastPresentationTimingGOOGLE { + uint32_t presentID; + uint64_t desiredPresentTime; + uint64_t actualPresentTime; + uint64_t earliestPresentTime; + uint64_t presentMargin; +} VkPastPresentationTimingGOOGLE; + +typedef struct VkPresentTimeGOOGLE { + uint32_t presentID; + uint64_t desiredPresentTime; +} VkPresentTimeGOOGLE; + +typedef struct VkPresentTimesInfoGOOGLE { + VkStructureType sType; + const void* pNext; + uint32_t swapchainCount; + const VkPresentTimeGOOGLE* pTimes; +} VkPresentTimesInfoGOOGLE; + + +typedef VkResult (VKAPI_PTR *PFN_vkGetRefreshCycleDurationGOOGLE)(VkDevice device, VkSwapchainKHR swapchain, VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties); +typedef VkResult (VKAPI_PTR *PFN_vkGetPastPresentationTimingGOOGLE)(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pPresentationTimingCount, VkPastPresentationTimingGOOGLE* pPresentationTimings); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetRefreshCycleDurationGOOGLE( + VkDevice device, + VkSwapchainKHR swapchain, + VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetPastPresentationTimingGOOGLE( + VkDevice device, + VkSwapchainKHR swapchain, + uint32_t* pPresentationTimingCount, + VkPastPresentationTimingGOOGLE* pPresentationTimings); +#endif + +#define VK_NV_sample_mask_override_coverage 1 +#define VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_SPEC_VERSION 1 +#define VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_EXTENSION_NAME "VK_NV_sample_mask_override_coverage" + + +#define VK_NV_geometry_shader_passthrough 1 +#define VK_NV_GEOMETRY_SHADER_PASSTHROUGH_SPEC_VERSION 1 +#define VK_NV_GEOMETRY_SHADER_PASSTHROUGH_EXTENSION_NAME "VK_NV_geometry_shader_passthrough" + + +#define VK_NV_viewport_array2 1 +#define VK_NV_VIEWPORT_ARRAY2_SPEC_VERSION 1 +#define VK_NV_VIEWPORT_ARRAY2_EXTENSION_NAME "VK_NV_viewport_array2" + + +#define VK_NVX_multiview_per_view_attributes 1 +#define VK_NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_SPEC_VERSION 1 +#define VK_NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_EXTENSION_NAME "VK_NVX_multiview_per_view_attributes" + +typedef struct VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX { + VkStructureType sType; + void* pNext; + VkBool32 perViewPositionAllComponents; +} VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX; + + + +#define VK_NV_viewport_swizzle 1 +#define VK_NV_VIEWPORT_SWIZZLE_SPEC_VERSION 1 +#define VK_NV_VIEWPORT_SWIZZLE_EXTENSION_NAME "VK_NV_viewport_swizzle" + + +typedef enum VkViewportCoordinateSwizzleNV { + VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV = 0, + VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_X_NV = 1, + VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Y_NV = 2, + VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Y_NV = 3, + VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Z_NV = 4, + VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Z_NV = 5, + VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_W_NV = 6, + VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV = 7, + VK_VIEWPORT_COORDINATE_SWIZZLE_BEGIN_RANGE_NV = VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV, + VK_VIEWPORT_COORDINATE_SWIZZLE_END_RANGE_NV = VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV, + VK_VIEWPORT_COORDINATE_SWIZZLE_RANGE_SIZE_NV = (VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV - VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV + 1), + VK_VIEWPORT_COORDINATE_SWIZZLE_MAX_ENUM_NV = 0x7FFFFFFF +} VkViewportCoordinateSwizzleNV; + +typedef VkFlags VkPipelineViewportSwizzleStateCreateFlagsNV; + +typedef struct VkViewportSwizzleNV { + VkViewportCoordinateSwizzleNV x; + VkViewportCoordinateSwizzleNV y; + VkViewportCoordinateSwizzleNV z; + VkViewportCoordinateSwizzleNV w; +} VkViewportSwizzleNV; + +typedef struct VkPipelineViewportSwizzleStateCreateInfoNV { + VkStructureType sType; + const void* pNext; + VkPipelineViewportSwizzleStateCreateFlagsNV flags; + uint32_t viewportCount; + const VkViewportSwizzleNV* pViewportSwizzles; +} VkPipelineViewportSwizzleStateCreateInfoNV; + + + +#define VK_EXT_discard_rectangles 1 +#define VK_EXT_DISCARD_RECTANGLES_SPEC_VERSION 1 +#define VK_EXT_DISCARD_RECTANGLES_EXTENSION_NAME "VK_EXT_discard_rectangles" + + +typedef enum VkDiscardRectangleModeEXT { + VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT = 0, + VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT = 1, + VK_DISCARD_RECTANGLE_MODE_BEGIN_RANGE_EXT = VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT, + VK_DISCARD_RECTANGLE_MODE_END_RANGE_EXT = VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT, + VK_DISCARD_RECTANGLE_MODE_RANGE_SIZE_EXT = (VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT - VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT + 1), + VK_DISCARD_RECTANGLE_MODE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkDiscardRectangleModeEXT; + +typedef VkFlags VkPipelineDiscardRectangleStateCreateFlagsEXT; + +typedef struct VkPhysicalDeviceDiscardRectanglePropertiesEXT { + VkStructureType sType; + void* pNext; + uint32_t maxDiscardRectangles; +} VkPhysicalDeviceDiscardRectanglePropertiesEXT; + +typedef struct VkPipelineDiscardRectangleStateCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkPipelineDiscardRectangleStateCreateFlagsEXT flags; + VkDiscardRectangleModeEXT discardRectangleMode; + uint32_t discardRectangleCount; + const VkRect2D* pDiscardRectangles; +} VkPipelineDiscardRectangleStateCreateInfoEXT; + + +typedef void (VKAPI_PTR *PFN_vkCmdSetDiscardRectangleEXT)(VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VkRect2D* pDiscardRectangles); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetDiscardRectangleEXT( + VkCommandBuffer commandBuffer, + uint32_t firstDiscardRectangle, + uint32_t discardRectangleCount, + const VkRect2D* pDiscardRectangles); +#endif + +#define VK_EXT_conservative_rasterization 1 +#define VK_EXT_CONSERVATIVE_RASTERIZATION_SPEC_VERSION 1 +#define VK_EXT_CONSERVATIVE_RASTERIZATION_EXTENSION_NAME "VK_EXT_conservative_rasterization" + + +typedef enum VkConservativeRasterizationModeEXT { + VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT = 0, + VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT = 1, + VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT = 2, + VK_CONSERVATIVE_RASTERIZATION_MODE_BEGIN_RANGE_EXT = VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT, + VK_CONSERVATIVE_RASTERIZATION_MODE_END_RANGE_EXT = VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT, + VK_CONSERVATIVE_RASTERIZATION_MODE_RANGE_SIZE_EXT = (VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT - VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT + 1), + VK_CONSERVATIVE_RASTERIZATION_MODE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkConservativeRasterizationModeEXT; + +typedef VkFlags VkPipelineRasterizationConservativeStateCreateFlagsEXT; + +typedef struct VkPhysicalDeviceConservativeRasterizationPropertiesEXT { + VkStructureType sType; + void* pNext; + float primitiveOverestimationSize; + float maxExtraPrimitiveOverestimationSize; + float extraPrimitiveOverestimationSizeGranularity; + VkBool32 primitiveUnderestimation; + VkBool32 conservativePointAndLineRasterization; + VkBool32 degenerateTrianglesRasterized; + VkBool32 degenerateLinesRasterized; + VkBool32 fullyCoveredFragmentShaderInputVariable; + VkBool32 conservativeRasterizationPostDepthCoverage; +} VkPhysicalDeviceConservativeRasterizationPropertiesEXT; + +typedef struct VkPipelineRasterizationConservativeStateCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkPipelineRasterizationConservativeStateCreateFlagsEXT flags; + VkConservativeRasterizationModeEXT conservativeRasterizationMode; + float extraPrimitiveOverestimationSize; +} VkPipelineRasterizationConservativeStateCreateInfoEXT; + + + +#define VK_EXT_swapchain_colorspace 1 +#define VK_EXT_SWAPCHAIN_COLOR_SPACE_SPEC_VERSION 3 +#define VK_EXT_SWAPCHAIN_COLOR_SPACE_EXTENSION_NAME "VK_EXT_swapchain_colorspace" + + +#define VK_EXT_hdr_metadata 1 +#define VK_EXT_HDR_METADATA_SPEC_VERSION 1 +#define VK_EXT_HDR_METADATA_EXTENSION_NAME "VK_EXT_hdr_metadata" + +typedef struct VkXYColorEXT { + float x; + float y; +} VkXYColorEXT; + +typedef struct VkHdrMetadataEXT { + VkStructureType sType; + const void* pNext; + VkXYColorEXT displayPrimaryRed; + VkXYColorEXT displayPrimaryGreen; + VkXYColorEXT displayPrimaryBlue; + VkXYColorEXT whitePoint; + float maxLuminance; + float minLuminance; + float maxContentLightLevel; + float maxFrameAverageLightLevel; +} VkHdrMetadataEXT; + + +typedef void (VKAPI_PTR *PFN_vkSetHdrMetadataEXT)(VkDevice device, uint32_t swapchainCount, const VkSwapchainKHR* pSwapchains, const VkHdrMetadataEXT* pMetadata); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkSetHdrMetadataEXT( + VkDevice device, + uint32_t swapchainCount, + const VkSwapchainKHR* pSwapchains, + const VkHdrMetadataEXT* pMetadata); +#endif + +#ifdef VK_USE_PLATFORM_IOS_MVK +#define VK_MVK_ios_surface 1 +#define VK_MVK_IOS_SURFACE_SPEC_VERSION 2 +#define VK_MVK_IOS_SURFACE_EXTENSION_NAME "VK_MVK_ios_surface" + +typedef VkFlags VkIOSSurfaceCreateFlagsMVK; + +typedef struct VkIOSSurfaceCreateInfoMVK { + VkStructureType sType; + const void* pNext; + VkIOSSurfaceCreateFlagsMVK flags; + const void* pView; +} VkIOSSurfaceCreateInfoMVK; + + +typedef VkResult (VKAPI_PTR *PFN_vkCreateIOSSurfaceMVK)(VkInstance instance, const VkIOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateIOSSurfaceMVK( + VkInstance instance, + const VkIOSSurfaceCreateInfoMVK* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); +#endif +#endif /* VK_USE_PLATFORM_IOS_MVK */ + +#ifdef VK_USE_PLATFORM_MACOS_MVK +#define VK_MVK_macos_surface 1 +#define VK_MVK_MACOS_SURFACE_SPEC_VERSION 2 +#define VK_MVK_MACOS_SURFACE_EXTENSION_NAME "VK_MVK_macos_surface" + +typedef VkFlags VkMacOSSurfaceCreateFlagsMVK; + +typedef struct VkMacOSSurfaceCreateInfoMVK { + VkStructureType sType; + const void* pNext; + VkMacOSSurfaceCreateFlagsMVK flags; + const void* pView; +} VkMacOSSurfaceCreateInfoMVK; + + +typedef VkResult (VKAPI_PTR *PFN_vkCreateMacOSSurfaceMVK)(VkInstance instance, const VkMacOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateMacOSSurfaceMVK( + VkInstance instance, + const VkMacOSSurfaceCreateInfoMVK* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); +#endif +#endif /* VK_USE_PLATFORM_MACOS_MVK */ + +#define VK_EXT_external_memory_dma_buf 1 +#define VK_EXT_EXTERNAL_MEMORY_DMA_BUF_SPEC_VERSION 1 +#define VK_EXT_EXTERNAL_MEMORY_DMA_BUF_EXTENSION_NAME "VK_EXT_external_memory_dma_buf" + + +#define VK_EXT_queue_family_foreign 1 +#define VK_EXT_QUEUE_FAMILY_FOREIGN_SPEC_VERSION 1 +#define VK_EXT_QUEUE_FAMILY_FOREIGN_EXTENSION_NAME "VK_EXT_queue_family_foreign" +#define VK_QUEUE_FAMILY_FOREIGN_EXT (~0U-2) + + +#define VK_EXT_sampler_filter_minmax 1 +#define VK_EXT_SAMPLER_FILTER_MINMAX_SPEC_VERSION 1 +#define VK_EXT_SAMPLER_FILTER_MINMAX_EXTENSION_NAME "VK_EXT_sampler_filter_minmax" + + +typedef enum VkSamplerReductionModeEXT { + VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT = 0, + VK_SAMPLER_REDUCTION_MODE_MIN_EXT = 1, + VK_SAMPLER_REDUCTION_MODE_MAX_EXT = 2, + VK_SAMPLER_REDUCTION_MODE_BEGIN_RANGE_EXT = VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT, + VK_SAMPLER_REDUCTION_MODE_END_RANGE_EXT = VK_SAMPLER_REDUCTION_MODE_MAX_EXT, + VK_SAMPLER_REDUCTION_MODE_RANGE_SIZE_EXT = (VK_SAMPLER_REDUCTION_MODE_MAX_EXT - VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT + 1), + VK_SAMPLER_REDUCTION_MODE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkSamplerReductionModeEXT; + +typedef struct VkSamplerReductionModeCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkSamplerReductionModeEXT reductionMode; +} VkSamplerReductionModeCreateInfoEXT; + +typedef struct VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT { + VkStructureType sType; + void* pNext; + VkBool32 filterMinmaxSingleComponentFormats; + VkBool32 filterMinmaxImageComponentMapping; +} VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT; + + + +#define VK_AMD_gpu_shader_int16 1 +#define VK_AMD_GPU_SHADER_INT16_SPEC_VERSION 1 +#define VK_AMD_GPU_SHADER_INT16_EXTENSION_NAME "VK_AMD_gpu_shader_int16" + + +#define VK_AMD_mixed_attachment_samples 1 +#define VK_AMD_MIXED_ATTACHMENT_SAMPLES_SPEC_VERSION 1 +#define VK_AMD_MIXED_ATTACHMENT_SAMPLES_EXTENSION_NAME "VK_AMD_mixed_attachment_samples" + + +#define VK_AMD_shader_fragment_mask 1 +#define VK_AMD_SHADER_FRAGMENT_MASK_SPEC_VERSION 1 +#define VK_AMD_SHADER_FRAGMENT_MASK_EXTENSION_NAME "VK_AMD_shader_fragment_mask" + + +#define VK_EXT_shader_stencil_export 1 +#define VK_EXT_SHADER_STENCIL_EXPORT_SPEC_VERSION 1 +#define VK_EXT_SHADER_STENCIL_EXPORT_EXTENSION_NAME "VK_EXT_shader_stencil_export" + + +#define VK_EXT_sample_locations 1 +#define VK_EXT_SAMPLE_LOCATIONS_SPEC_VERSION 1 +#define VK_EXT_SAMPLE_LOCATIONS_EXTENSION_NAME "VK_EXT_sample_locations" + +typedef struct VkSampleLocationEXT { + float x; + float y; +} VkSampleLocationEXT; + +typedef struct VkSampleLocationsInfoEXT { + VkStructureType sType; + const void* pNext; + VkSampleCountFlagBits sampleLocationsPerPixel; + VkExtent2D sampleLocationGridSize; + uint32_t sampleLocationsCount; + const VkSampleLocationEXT* pSampleLocations; +} VkSampleLocationsInfoEXT; + +typedef struct VkAttachmentSampleLocationsEXT { + uint32_t attachmentIndex; + VkSampleLocationsInfoEXT sampleLocationsInfo; +} VkAttachmentSampleLocationsEXT; + +typedef struct VkSubpassSampleLocationsEXT { + uint32_t subpassIndex; + VkSampleLocationsInfoEXT sampleLocationsInfo; +} VkSubpassSampleLocationsEXT; + +typedef struct VkRenderPassSampleLocationsBeginInfoEXT { + VkStructureType sType; + const void* pNext; + uint32_t attachmentInitialSampleLocationsCount; + const VkAttachmentSampleLocationsEXT* pAttachmentInitialSampleLocations; + uint32_t postSubpassSampleLocationsCount; + const VkSubpassSampleLocationsEXT* pPostSubpassSampleLocations; +} VkRenderPassSampleLocationsBeginInfoEXT; + +typedef struct VkPipelineSampleLocationsStateCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkBool32 sampleLocationsEnable; + VkSampleLocationsInfoEXT sampleLocationsInfo; +} VkPipelineSampleLocationsStateCreateInfoEXT; + +typedef struct VkPhysicalDeviceSampleLocationsPropertiesEXT { + VkStructureType sType; + void* pNext; + VkSampleCountFlags sampleLocationSampleCounts; + VkExtent2D maxSampleLocationGridSize; + float sampleLocationCoordinateRange[2]; + uint32_t sampleLocationSubPixelBits; + VkBool32 variableSampleLocations; +} VkPhysicalDeviceSampleLocationsPropertiesEXT; + +typedef struct VkMultisamplePropertiesEXT { + VkStructureType sType; + void* pNext; + VkExtent2D maxSampleLocationGridSize; +} VkMultisamplePropertiesEXT; + + +typedef void (VKAPI_PTR *PFN_vkCmdSetSampleLocationsEXT)(VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT* pSampleLocationsInfo); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT)(VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples, VkMultisamplePropertiesEXT* pMultisampleProperties); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetSampleLocationsEXT( + VkCommandBuffer commandBuffer, + const VkSampleLocationsInfoEXT* pSampleLocationsInfo); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMultisamplePropertiesEXT( + VkPhysicalDevice physicalDevice, + VkSampleCountFlagBits samples, + VkMultisamplePropertiesEXT* pMultisampleProperties); +#endif + +#define VK_EXT_blend_operation_advanced 1 +#define VK_EXT_BLEND_OPERATION_ADVANCED_SPEC_VERSION 2 +#define VK_EXT_BLEND_OPERATION_ADVANCED_EXTENSION_NAME "VK_EXT_blend_operation_advanced" + + +typedef enum VkBlendOverlapEXT { + VK_BLEND_OVERLAP_UNCORRELATED_EXT = 0, + VK_BLEND_OVERLAP_DISJOINT_EXT = 1, + VK_BLEND_OVERLAP_CONJOINT_EXT = 2, + VK_BLEND_OVERLAP_BEGIN_RANGE_EXT = VK_BLEND_OVERLAP_UNCORRELATED_EXT, + VK_BLEND_OVERLAP_END_RANGE_EXT = VK_BLEND_OVERLAP_CONJOINT_EXT, + VK_BLEND_OVERLAP_RANGE_SIZE_EXT = (VK_BLEND_OVERLAP_CONJOINT_EXT - VK_BLEND_OVERLAP_UNCORRELATED_EXT + 1), + VK_BLEND_OVERLAP_MAX_ENUM_EXT = 0x7FFFFFFF +} VkBlendOverlapEXT; + +typedef struct VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 advancedBlendCoherentOperations; +} VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT; + +typedef struct VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT { + VkStructureType sType; + void* pNext; + uint32_t advancedBlendMaxColorAttachments; + VkBool32 advancedBlendIndependentBlend; + VkBool32 advancedBlendNonPremultipliedSrcColor; + VkBool32 advancedBlendNonPremultipliedDstColor; + VkBool32 advancedBlendCorrelatedOverlap; + VkBool32 advancedBlendAllOperations; +} VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT; + +typedef struct VkPipelineColorBlendAdvancedStateCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkBool32 srcPremultiplied; + VkBool32 dstPremultiplied; + VkBlendOverlapEXT blendOverlap; +} VkPipelineColorBlendAdvancedStateCreateInfoEXT; + + + +#define VK_NV_fragment_coverage_to_color 1 +#define VK_NV_FRAGMENT_COVERAGE_TO_COLOR_SPEC_VERSION 1 +#define VK_NV_FRAGMENT_COVERAGE_TO_COLOR_EXTENSION_NAME "VK_NV_fragment_coverage_to_color" + +typedef VkFlags VkPipelineCoverageToColorStateCreateFlagsNV; + +typedef struct VkPipelineCoverageToColorStateCreateInfoNV { + VkStructureType sType; + const void* pNext; + VkPipelineCoverageToColorStateCreateFlagsNV flags; + VkBool32 coverageToColorEnable; + uint32_t coverageToColorLocation; +} VkPipelineCoverageToColorStateCreateInfoNV; + + + +#define VK_NV_framebuffer_mixed_samples 1 +#define VK_NV_FRAMEBUFFER_MIXED_SAMPLES_SPEC_VERSION 1 +#define VK_NV_FRAMEBUFFER_MIXED_SAMPLES_EXTENSION_NAME "VK_NV_framebuffer_mixed_samples" + + +typedef enum VkCoverageModulationModeNV { + VK_COVERAGE_MODULATION_MODE_NONE_NV = 0, + VK_COVERAGE_MODULATION_MODE_RGB_NV = 1, + VK_COVERAGE_MODULATION_MODE_ALPHA_NV = 2, + VK_COVERAGE_MODULATION_MODE_RGBA_NV = 3, + VK_COVERAGE_MODULATION_MODE_BEGIN_RANGE_NV = VK_COVERAGE_MODULATION_MODE_NONE_NV, + VK_COVERAGE_MODULATION_MODE_END_RANGE_NV = VK_COVERAGE_MODULATION_MODE_RGBA_NV, + VK_COVERAGE_MODULATION_MODE_RANGE_SIZE_NV = (VK_COVERAGE_MODULATION_MODE_RGBA_NV - VK_COVERAGE_MODULATION_MODE_NONE_NV + 1), + VK_COVERAGE_MODULATION_MODE_MAX_ENUM_NV = 0x7FFFFFFF +} VkCoverageModulationModeNV; + +typedef VkFlags VkPipelineCoverageModulationStateCreateFlagsNV; + +typedef struct VkPipelineCoverageModulationStateCreateInfoNV { + VkStructureType sType; + const void* pNext; + VkPipelineCoverageModulationStateCreateFlagsNV flags; + VkCoverageModulationModeNV coverageModulationMode; + VkBool32 coverageModulationTableEnable; + uint32_t coverageModulationTableCount; + const float* pCoverageModulationTable; +} VkPipelineCoverageModulationStateCreateInfoNV; + + + +#define VK_NV_fill_rectangle 1 +#define VK_NV_FILL_RECTANGLE_SPEC_VERSION 1 +#define VK_NV_FILL_RECTANGLE_EXTENSION_NAME "VK_NV_fill_rectangle" + + +#define VK_EXT_post_depth_coverage 1 +#define VK_EXT_POST_DEPTH_COVERAGE_SPEC_VERSION 1 +#define VK_EXT_POST_DEPTH_COVERAGE_EXTENSION_NAME "VK_EXT_post_depth_coverage" + + +#define VK_EXT_validation_cache 1 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkValidationCacheEXT) + +#define VK_EXT_VALIDATION_CACHE_SPEC_VERSION 1 +#define VK_EXT_VALIDATION_CACHE_EXTENSION_NAME "VK_EXT_validation_cache" +#define VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT + + +typedef enum VkValidationCacheHeaderVersionEXT { + VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT = 1, + VK_VALIDATION_CACHE_HEADER_VERSION_BEGIN_RANGE_EXT = VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT, + VK_VALIDATION_CACHE_HEADER_VERSION_END_RANGE_EXT = VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT, + VK_VALIDATION_CACHE_HEADER_VERSION_RANGE_SIZE_EXT = (VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT - VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT + 1), + VK_VALIDATION_CACHE_HEADER_VERSION_MAX_ENUM_EXT = 0x7FFFFFFF +} VkValidationCacheHeaderVersionEXT; + +typedef VkFlags VkValidationCacheCreateFlagsEXT; + +typedef struct VkValidationCacheCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkValidationCacheCreateFlagsEXT flags; + size_t initialDataSize; + const void* pInitialData; +} VkValidationCacheCreateInfoEXT; + +typedef struct VkShaderModuleValidationCacheCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkValidationCacheEXT validationCache; +} VkShaderModuleValidationCacheCreateInfoEXT; + + +typedef VkResult (VKAPI_PTR *PFN_vkCreateValidationCacheEXT)(VkDevice device, const VkValidationCacheCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkValidationCacheEXT* pValidationCache); +typedef void (VKAPI_PTR *PFN_vkDestroyValidationCacheEXT)(VkDevice device, VkValidationCacheEXT validationCache, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkMergeValidationCachesEXT)(VkDevice device, VkValidationCacheEXT dstCache, uint32_t srcCacheCount, const VkValidationCacheEXT* pSrcCaches); +typedef VkResult (VKAPI_PTR *PFN_vkGetValidationCacheDataEXT)(VkDevice device, VkValidationCacheEXT validationCache, size_t* pDataSize, void* pData); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateValidationCacheEXT( + VkDevice device, + const VkValidationCacheCreateInfoEXT* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkValidationCacheEXT* pValidationCache); + +VKAPI_ATTR void VKAPI_CALL vkDestroyValidationCacheEXT( + VkDevice device, + VkValidationCacheEXT validationCache, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkMergeValidationCachesEXT( + VkDevice device, + VkValidationCacheEXT dstCache, + uint32_t srcCacheCount, + const VkValidationCacheEXT* pSrcCaches); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetValidationCacheDataEXT( + VkDevice device, + VkValidationCacheEXT validationCache, + size_t* pDataSize, + void* pData); +#endif + +#define VK_EXT_shader_viewport_index_layer 1 +#define VK_EXT_SHADER_VIEWPORT_INDEX_LAYER_SPEC_VERSION 1 +#define VK_EXT_SHADER_VIEWPORT_INDEX_LAYER_EXTENSION_NAME "VK_EXT_shader_viewport_index_layer" + + +#define VK_EXT_global_priority 1 +#define VK_EXT_GLOBAL_PRIORITY_SPEC_VERSION 2 +#define VK_EXT_GLOBAL_PRIORITY_EXTENSION_NAME "VK_EXT_global_priority" + + +typedef enum VkQueueGlobalPriorityEXT { + VK_QUEUE_GLOBAL_PRIORITY_LOW_EXT = 128, + VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_EXT = 256, + VK_QUEUE_GLOBAL_PRIORITY_HIGH_EXT = 512, + VK_QUEUE_GLOBAL_PRIORITY_REALTIME_EXT = 1024, + VK_QUEUE_GLOBAL_PRIORITY_BEGIN_RANGE_EXT = VK_QUEUE_GLOBAL_PRIORITY_LOW_EXT, + VK_QUEUE_GLOBAL_PRIORITY_END_RANGE_EXT = VK_QUEUE_GLOBAL_PRIORITY_REALTIME_EXT, + VK_QUEUE_GLOBAL_PRIORITY_RANGE_SIZE_EXT = (VK_QUEUE_GLOBAL_PRIORITY_REALTIME_EXT - VK_QUEUE_GLOBAL_PRIORITY_LOW_EXT + 1), + VK_QUEUE_GLOBAL_PRIORITY_MAX_ENUM_EXT = 0x7FFFFFFF +} VkQueueGlobalPriorityEXT; + +typedef struct VkDeviceQueueGlobalPriorityCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkQueueGlobalPriorityEXT globalPriority; +} VkDeviceQueueGlobalPriorityCreateInfoEXT; + + + +#define VK_EXT_external_memory_host 1 +#define VK_EXT_EXTERNAL_MEMORY_HOST_SPEC_VERSION 1 +#define VK_EXT_EXTERNAL_MEMORY_HOST_EXTENSION_NAME "VK_EXT_external_memory_host" + +typedef struct VkImportMemoryHostPointerInfoEXT { + VkStructureType sType; + const void* pNext; + VkExternalMemoryHandleTypeFlagBitsKHR handleType; + void* pHostPointer; +} VkImportMemoryHostPointerInfoEXT; + +typedef struct VkMemoryHostPointerPropertiesEXT { + VkStructureType sType; + void* pNext; + uint32_t memoryTypeBits; +} VkMemoryHostPointerPropertiesEXT; + +typedef struct VkPhysicalDeviceExternalMemoryHostPropertiesEXT { + VkStructureType sType; + void* pNext; + VkDeviceSize minImportedHostPointerAlignment; +} VkPhysicalDeviceExternalMemoryHostPropertiesEXT; + + +typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryHostPointerPropertiesEXT)(VkDevice device, VkExternalMemoryHandleTypeFlagBitsKHR handleType, const void* pHostPointer, VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryHostPointerPropertiesEXT( + VkDevice device, + VkExternalMemoryHandleTypeFlagBitsKHR handleType, + const void* pHostPointer, + VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties); +#endif + +#define VK_AMD_buffer_marker 1 +#define VK_AMD_BUFFER_MARKER_SPEC_VERSION 1 +#define VK_AMD_BUFFER_MARKER_EXTENSION_NAME "VK_AMD_buffer_marker" + +typedef void (VKAPI_PTR *PFN_vkCmdWriteBufferMarkerAMD)(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdWriteBufferMarkerAMD( + VkCommandBuffer commandBuffer, + VkPipelineStageFlagBits pipelineStage, + VkBuffer dstBuffer, + VkDeviceSize dstOffset, + uint32_t marker); +#endif + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/src-gen/Graphics/Vulkan/Constants.hs b/src-gen/Graphics/Vulkan/Constants.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Constants.hs @@ -0,0 +1,137 @@ +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +module Graphics.Vulkan.Constants + (VK_MAX_PHYSICAL_DEVICE_NAME_SIZE, + pattern VK_MAX_PHYSICAL_DEVICE_NAME_SIZE, VK_UUID_SIZE, + pattern VK_UUID_SIZE, VK_LUID_SIZE_KHR, pattern VK_LUID_SIZE_KHR, + VK_MAX_EXTENSION_NAME_SIZE, pattern VK_MAX_EXTENSION_NAME_SIZE, + VK_MAX_DESCRIPTION_SIZE, pattern VK_MAX_DESCRIPTION_SIZE, + VK_MAX_MEMORY_TYPES, pattern VK_MAX_MEMORY_TYPES, + VK_MAX_MEMORY_HEAPS, pattern VK_MAX_MEMORY_HEAPS, + pattern VK_LOD_CLAMP_NONE, VK_REMAINING_MIP_LEVELS, + pattern VK_REMAINING_MIP_LEVELS, VK_REMAINING_ARRAY_LAYERS, + pattern VK_REMAINING_ARRAY_LAYERS, VK_WHOLE_SIZE, + pattern VK_WHOLE_SIZE, VK_ATTACHMENT_UNUSED, + pattern VK_ATTACHMENT_UNUSED, VK_TRUE, pattern VK_TRUE, VK_FALSE, + pattern VK_FALSE, VK_QUEUE_FAMILY_IGNORED, + pattern VK_QUEUE_FAMILY_IGNORED, VK_QUEUE_FAMILY_EXTERNAL_KHR, + pattern VK_QUEUE_FAMILY_EXTERNAL_KHR, VK_QUEUE_FAMILY_FOREIGN_EXT, + pattern VK_QUEUE_FAMILY_FOREIGN_EXT, VK_SUBPASS_EXTERNAL, + pattern VK_SUBPASS_EXTERNAL, VK_MAX_DEVICE_GROUP_SIZE_KHX, + pattern VK_MAX_DEVICE_GROUP_SIZE_KHX) + where +import Graphics.Vulkan.Marshal + +pattern VK_MAX_PHYSICAL_DEVICE_NAME_SIZE :: (Num a, Eq a) => a + +pattern VK_MAX_PHYSICAL_DEVICE_NAME_SIZE = 256 + +type VK_MAX_PHYSICAL_DEVICE_NAME_SIZE = 256 + +pattern VK_UUID_SIZE :: (Num a, Eq a) => a + +pattern VK_UUID_SIZE = 16 + +type VK_UUID_SIZE = 16 + +pattern VK_LUID_SIZE_KHR :: (Num a, Eq a) => a + +pattern VK_LUID_SIZE_KHR = 8 + +type VK_LUID_SIZE_KHR = 8 + +pattern VK_MAX_EXTENSION_NAME_SIZE :: (Num a, Eq a) => a + +pattern VK_MAX_EXTENSION_NAME_SIZE = 256 + +type VK_MAX_EXTENSION_NAME_SIZE = 256 + +pattern VK_MAX_DESCRIPTION_SIZE :: (Num a, Eq a) => a + +pattern VK_MAX_DESCRIPTION_SIZE = 256 + +type VK_MAX_DESCRIPTION_SIZE = 256 + +pattern VK_MAX_MEMORY_TYPES :: (Num a, Eq a) => a + +pattern VK_MAX_MEMORY_TYPES = 32 + +type VK_MAX_MEMORY_TYPES = 32 + +-- | The maximum number of unique memory heaps, each of which supporting 1 or more memory types +pattern VK_MAX_MEMORY_HEAPS :: (Num a, Eq a) => a + +pattern VK_MAX_MEMORY_HEAPS = 16 + +type VK_MAX_MEMORY_HEAPS = 16 + +pattern VK_LOD_CLAMP_NONE :: (Fractional a, Eq a) => a + +pattern VK_LOD_CLAMP_NONE = 1000.0 + +pattern VK_REMAINING_MIP_LEVELS :: Word32 + +pattern VK_REMAINING_MIP_LEVELS = 4294967295 + +type VK_REMAINING_MIP_LEVELS = 4294967295 + +pattern VK_REMAINING_ARRAY_LAYERS :: Word32 + +pattern VK_REMAINING_ARRAY_LAYERS = 4294967295 + +type VK_REMAINING_ARRAY_LAYERS = 4294967295 + +pattern VK_WHOLE_SIZE :: Word64 + +pattern VK_WHOLE_SIZE = 18446744073709551615 + +type VK_WHOLE_SIZE = 18446744073709551615 + +pattern VK_ATTACHMENT_UNUSED :: Word32 + +pattern VK_ATTACHMENT_UNUSED = 4294967295 + +type VK_ATTACHMENT_UNUSED = 4294967295 + +pattern VK_TRUE :: (Num a, Eq a) => a + +pattern VK_TRUE = 1 + +type VK_TRUE = 1 + +pattern VK_FALSE :: (Num a, Eq a) => a + +pattern VK_FALSE = 0 + +type VK_FALSE = 0 + +pattern VK_QUEUE_FAMILY_IGNORED :: Word32 + +pattern VK_QUEUE_FAMILY_IGNORED = 4294967295 + +type VK_QUEUE_FAMILY_IGNORED = 4294967295 + +pattern VK_QUEUE_FAMILY_EXTERNAL_KHR :: Word32 + +pattern VK_QUEUE_FAMILY_EXTERNAL_KHR = 4294967294 + +type VK_QUEUE_FAMILY_EXTERNAL_KHR = 4294967294 + +pattern VK_QUEUE_FAMILY_FOREIGN_EXT :: Word32 + +pattern VK_QUEUE_FAMILY_FOREIGN_EXT = 4294967293 + +type VK_QUEUE_FAMILY_FOREIGN_EXT = 4294967293 + +pattern VK_SUBPASS_EXTERNAL :: Word32 + +pattern VK_SUBPASS_EXTERNAL = 4294967295 + +type VK_SUBPASS_EXTERNAL = 4294967295 + +pattern VK_MAX_DEVICE_GROUP_SIZE_KHX :: (Num a, Eq a) => a + +pattern VK_MAX_DEVICE_GROUP_SIZE_KHX = 32 + +type VK_MAX_DEVICE_GROUP_SIZE_KHX = 32 diff --git a/src-gen/Graphics/Vulkan/Core.hsc b/src-gen/Graphics/Vulkan/Core.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Core.hsc @@ -0,0 +1,3186 @@ +#include "vulkan/vulkan.h" + +{-# OPTIONS_GHC -fno-warn-unused-imports#-} +{-# OPTIONS_HADDOCK not-home#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE ForeignFunctionInterface #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +module Graphics.Vulkan.Core + (-- * Vulkan core API interface definitions + -- | + -- + -- @api = vulkan@ + -- + -- @name = VK_VERSION_1_0@ + -- + -- @number = 1.0@ + -- + + -- ** Header boilerplate + -- + -- | + -- > ##include "vk_platform.h" + -- + + -- ** API version + -- + + -- ** API constants + module Graphics.Vulkan.Types.Enum.VkPipelineCacheHeaderVersion, + pattern VK_LOD_CLAMP_NONE, pattern VK_REMAINING_MIP_LEVELS, + VK_REMAINING_MIP_LEVELS, pattern VK_REMAINING_ARRAY_LAYERS, + VK_REMAINING_ARRAY_LAYERS, pattern VK_WHOLE_SIZE, VK_WHOLE_SIZE, + pattern VK_ATTACHMENT_UNUSED, VK_ATTACHMENT_UNUSED, + pattern VK_TRUE, VK_TRUE, pattern VK_FALSE, VK_FALSE, + pattern VK_QUEUE_FAMILY_IGNORED, VK_QUEUE_FAMILY_IGNORED, + pattern VK_SUBPASS_EXTERNAL, VK_SUBPASS_EXTERNAL, -- ** Device initialization + vkCreateInstance, + vkDestroyInstance, vkEnumeratePhysicalDevices, + vkGetPhysicalDeviceFeatures, vkGetPhysicalDeviceFormatProperties, + vkGetPhysicalDeviceImageFormatProperties, + vkGetPhysicalDeviceProperties, + vkGetPhysicalDeviceQueueFamilyProperties, + vkGetPhysicalDeviceMemoryProperties, vkGetInstanceProcAddr, + vkGetDeviceProcAddr, module Graphics.Vulkan.Marshal, + module Graphics.Vulkan.Types.BaseTypes, + module Graphics.Vulkan.Types.Bitmasks, + module Graphics.Vulkan.Types.Enum.VkFormat, + module Graphics.Vulkan.Types.Enum.VkFormatFeatureFlags, + module Graphics.Vulkan.Types.Enum.VkImageCreateFlags, + module Graphics.Vulkan.Types.Enum.VkImageTiling, + module Graphics.Vulkan.Types.Enum.VkImageType, + module Graphics.Vulkan.Types.Enum.VkImageUsageFlags, + module Graphics.Vulkan.Types.Enum.VkInternalAllocationType, + module Graphics.Vulkan.Types.Enum.VkMemoryHeapFlags, + module Graphics.Vulkan.Types.Enum.VkMemoryPropertyFlags, + module Graphics.Vulkan.Types.Enum.VkPhysicalDeviceType, + module Graphics.Vulkan.Types.Enum.VkQueueFlags, + module Graphics.Vulkan.Types.Enum.VkResult, + module Graphics.Vulkan.Types.Enum.VkSampleCountFlags, + module Graphics.Vulkan.Types.Enum.VkStructureType, + module Graphics.Vulkan.Types.Enum.VkSystemAllocationScope, + module Graphics.Vulkan.Types.Funcpointers, + module Graphics.Vulkan.Types.Handles, + module Graphics.Vulkan.Types.Struct.VkAllocationCallbacks, + module Graphics.Vulkan.Types.Struct.VkApplicationInfo, + module Graphics.Vulkan.Types.Struct.VkExtent3D, + module Graphics.Vulkan.Types.Struct.VkFormatProperties, + module Graphics.Vulkan.Types.Struct.VkImageFormatProperties, + module Graphics.Vulkan.Types.Struct.VkInstanceCreateInfo, + module Graphics.Vulkan.Types.Struct.VkMemoryHeap, + module Graphics.Vulkan.Types.Struct.VkMemoryType, + module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceFeatures, + module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceLimits, + module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceMemoryProperties, + module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceProperties, + module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceSparseProperties, + module Graphics.Vulkan.Types.Struct.VkQueueFamilyProperties, + -- ** Device commands + vkCreateDevice, vkDestroyDevice, + module Graphics.Vulkan.Types.Struct.VkDeviceCreateInfo, + module Graphics.Vulkan.Types.Struct.VkDeviceQueueCreateInfo, + -- ** Extension discovery commands + vkEnumerateInstanceExtensionProperties, + vkEnumerateDeviceExtensionProperties, + module Graphics.Vulkan.Types.Struct.VkExtensionProperties, + -- ** Layer discovery commands + vkEnumerateInstanceLayerProperties, + vkEnumerateDeviceLayerProperties, + module Graphics.Vulkan.Types.Struct.VkLayerProperties, + -- ** queue commands + vkGetDeviceQueue, vkQueueSubmit, vkQueueWaitIdle, vkDeviceWaitIdle, + module Graphics.Vulkan.Types.Enum.VkPipelineStageFlags, + module Graphics.Vulkan.Types.Struct.VkSubmitInfo, -- ** Memory commands + vkAllocateMemory, + vkFreeMemory, vkMapMemory, vkUnmapMemory, + vkFlushMappedMemoryRanges, vkInvalidateMappedMemoryRanges, + vkGetDeviceMemoryCommitment, + module Graphics.Vulkan.Types.Struct.VkMappedMemoryRange, + module Graphics.Vulkan.Types.Struct.VkMemoryAllocateInfo, + -- ** Memory management API commands + vkBindBufferMemory, vkBindImageMemory, + vkGetBufferMemoryRequirements, vkGetImageMemoryRequirements, + module Graphics.Vulkan.Types.Struct.VkMemoryRequirements, + -- ** Sparse resource memory management API commands + vkGetImageSparseMemoryRequirements, + vkGetPhysicalDeviceSparseImageFormatProperties, vkQueueBindSparse, + module Graphics.Vulkan.Types.Enum.VkImageAspectFlags, + module Graphics.Vulkan.Types.Enum.VkSparseImageFormatFlags, + module Graphics.Vulkan.Types.Enum.VkSparseMemoryBindFlags, + module Graphics.Vulkan.Types.Struct.VkBindSparseInfo, + module Graphics.Vulkan.Types.Struct.VkImageSubresource, + module Graphics.Vulkan.Types.Struct.VkOffset3D, + module Graphics.Vulkan.Types.Struct.VkSparseBufferMemoryBindInfo, + module Graphics.Vulkan.Types.Struct.VkSparseImageFormatProperties, + module Graphics.Vulkan.Types.Struct.VkSparseImageMemoryBind, + module Graphics.Vulkan.Types.Struct.VkSparseImageMemoryBindInfo, + module Graphics.Vulkan.Types.Struct.VkSparseImageMemoryRequirements, + module Graphics.Vulkan.Types.Struct.VkSparseImageOpaqueMemoryBindInfo, + module Graphics.Vulkan.Types.Struct.VkSparseMemoryBind, + -- ** Fence commands + vkCreateFence, vkDestroyFence, vkResetFences, vkGetFenceStatus, + vkWaitForFences, + module Graphics.Vulkan.Types.Enum.VkFenceCreateFlags, + module Graphics.Vulkan.Types.Struct.VkFenceCreateInfo, + -- ** Queue semaphore commands + vkCreateSemaphore, vkDestroySemaphore, + module Graphics.Vulkan.Types.Struct.VkSemaphoreCreateInfo, + -- ** Event commands + vkCreateEvent, vkDestroyEvent, vkGetEventStatus, vkSetEvent, + vkResetEvent, + module Graphics.Vulkan.Types.Struct.VkEventCreateInfo, + -- ** Query commands + vkCreateQueryPool, vkDestroyQueryPool, vkGetQueryPoolResults, + module Graphics.Vulkan.Types.Enum.VkQueryPipelineStatisticFlags, + module Graphics.Vulkan.Types.Enum.VkQueryResultFlags, + module Graphics.Vulkan.Types.Enum.VkQueryType, + module Graphics.Vulkan.Types.Struct.VkQueryPoolCreateInfo, + -- ** Buffer commands + vkCreateBuffer, vkDestroyBuffer, + module Graphics.Vulkan.Types.Enum.VkBufferCreateFlags, + module Graphics.Vulkan.Types.Enum.VkBufferUsageFlags, + module Graphics.Vulkan.Types.Enum.VkSharingMode, + module Graphics.Vulkan.Types.Struct.VkBufferCreateInfo, + -- ** Buffer view commands + vkCreateBufferView, vkDestroyBufferView, + module Graphics.Vulkan.Types.Struct.VkBufferViewCreateInfo, + -- ** Image commands + vkCreateImage, vkDestroyImage, vkGetImageSubresourceLayout, + module Graphics.Vulkan.Types.Enum.VkImageLayout, + module Graphics.Vulkan.Types.Struct.VkImageCreateInfo, + module Graphics.Vulkan.Types.Struct.VkSubresourceLayout, + -- ** Image view commands + vkCreateImageView, vkDestroyImageView, + module Graphics.Vulkan.Types.Enum.VkComponentSwizzle, + module Graphics.Vulkan.Types.Enum.VkImageViewType, + module Graphics.Vulkan.Types.Struct.VkComponentMapping, + module Graphics.Vulkan.Types.Struct.VkImageSubresourceRange, + module Graphics.Vulkan.Types.Struct.VkImageViewCreateInfo, + -- ** Shader commands + vkCreateShaderModule, vkDestroyShaderModule, + module Graphics.Vulkan.Types.Struct.VkShaderModuleCreateInfo, + -- ** Pipeline Cache commands + vkCreatePipelineCache, vkDestroyPipelineCache, + vkGetPipelineCacheData, vkMergePipelineCaches, + module Graphics.Vulkan.Types.Struct.VkPipelineCacheCreateInfo, + -- ** Pipeline commands + vkCreateGraphicsPipelines, vkCreateComputePipelines, + vkDestroyPipeline, module Graphics.Vulkan.Types.Enum.VkBlendFactor, + module Graphics.Vulkan.Types.Enum.VkBlendOp, + module Graphics.Vulkan.Types.Enum.VkColorComponentFlags, + module Graphics.Vulkan.Types.Enum.VkCompareOp, + module Graphics.Vulkan.Types.Enum.VkCullModeFlags, + module Graphics.Vulkan.Types.Enum.VkDynamicState, + module Graphics.Vulkan.Types.Enum.VkFrontFace, + module Graphics.Vulkan.Types.Enum.VkLogicOp, + module Graphics.Vulkan.Types.Enum.VkPipelineCreateFlags, + module Graphics.Vulkan.Types.Enum.VkPolygonMode, + module Graphics.Vulkan.Types.Enum.VkPrimitiveTopology, + module Graphics.Vulkan.Types.Enum.VkShaderStageFlags, + module Graphics.Vulkan.Types.Enum.VkStencilOp, + module Graphics.Vulkan.Types.Enum.VkVertexInputRate, + module Graphics.Vulkan.Types.Struct.VkComputePipelineCreateInfo, + module Graphics.Vulkan.Types.Struct.VkExtent2D, + module Graphics.Vulkan.Types.Struct.VkGraphicsPipelineCreateInfo, + module Graphics.Vulkan.Types.Struct.VkOffset2D, + module Graphics.Vulkan.Types.Struct.VkPipelineColorBlendAttachmentState, + module Graphics.Vulkan.Types.Struct.VkPipelineColorBlendStateCreateInfo, + module Graphics.Vulkan.Types.Struct.VkPipelineDepthStencilStateCreateInfo, + module Graphics.Vulkan.Types.Struct.VkPipelineDynamicStateCreateInfo, + module Graphics.Vulkan.Types.Struct.VkPipelineInputAssemblyStateCreateInfo, + module Graphics.Vulkan.Types.Struct.VkPipelineMultisampleStateCreateInfo, + module Graphics.Vulkan.Types.Struct.VkPipelineRasterizationStateCreateInfo, + module Graphics.Vulkan.Types.Struct.VkPipelineShaderStageCreateInfo, + module Graphics.Vulkan.Types.Struct.VkPipelineTessellationStateCreateInfo, + module Graphics.Vulkan.Types.Struct.VkPipelineVertexInputStateCreateInfo, + module Graphics.Vulkan.Types.Struct.VkPipelineViewportStateCreateInfo, + module Graphics.Vulkan.Types.Struct.VkRect2D, + module Graphics.Vulkan.Types.Struct.VkSpecializationInfo, + module Graphics.Vulkan.Types.Struct.VkSpecializationMapEntry, + module Graphics.Vulkan.Types.Struct.VkStencilOpState, + module Graphics.Vulkan.Types.Struct.VkVertexInputAttributeDescription, + module Graphics.Vulkan.Types.Struct.VkVertexInputBindingDescription, + module Graphics.Vulkan.Types.Struct.VkViewport, + -- ** Pipeline layout commands + vkCreatePipelineLayout, vkDestroyPipelineLayout, + module Graphics.Vulkan.Types.Struct.VkPipelineLayoutCreateInfo, + module Graphics.Vulkan.Types.Struct.VkPushConstantRange, + -- ** Sampler commands + vkCreateSampler, vkDestroySampler, + module Graphics.Vulkan.Types.Enum.VkBorderColor, + module Graphics.Vulkan.Types.Enum.VkFilter, + module Graphics.Vulkan.Types.Enum.VkSamplerAddressMode, + module Graphics.Vulkan.Types.Enum.VkSamplerMipmapMode, + module Graphics.Vulkan.Types.Struct.VkSamplerCreateInfo, + -- ** Descriptor set commands + vkCreateDescriptorSetLayout, vkDestroyDescriptorSetLayout, + vkCreateDescriptorPool, vkDestroyDescriptorPool, + vkResetDescriptorPool, vkAllocateDescriptorSets, + vkFreeDescriptorSets, vkUpdateDescriptorSets, + module Graphics.Vulkan.Types.Enum.VkDescriptorPoolCreateFlags, + module Graphics.Vulkan.Types.Enum.VkDescriptorSetLayoutCreateFlags, + module Graphics.Vulkan.Types.Enum.VkDescriptorType, + module Graphics.Vulkan.Types.Struct.VkCopyDescriptorSet, + module Graphics.Vulkan.Types.Struct.VkDescriptorBufferInfo, + module Graphics.Vulkan.Types.Struct.VkDescriptorImageInfo, + module Graphics.Vulkan.Types.Struct.VkDescriptorPoolCreateInfo, + module Graphics.Vulkan.Types.Struct.VkDescriptorPoolSize, + module Graphics.Vulkan.Types.Struct.VkDescriptorSetAllocateInfo, + module Graphics.Vulkan.Types.Struct.VkDescriptorSetLayoutBinding, + module Graphics.Vulkan.Types.Struct.VkDescriptorSetLayoutCreateInfo, + module Graphics.Vulkan.Types.Struct.VkWriteDescriptorSet, + -- ** Pass commands + vkCreateFramebuffer, vkDestroyFramebuffer, vkCreateRenderPass, + vkDestroyRenderPass, vkGetRenderAreaGranularity, + module Graphics.Vulkan.Types.Enum.VkAccessFlags, + module Graphics.Vulkan.Types.Enum.VkAttachmentDescriptionFlags, + module Graphics.Vulkan.Types.Enum.VkAttachmentLoadOp, + module Graphics.Vulkan.Types.Enum.VkAttachmentStoreOp, + module Graphics.Vulkan.Types.Enum.VkDependencyFlags, + module Graphics.Vulkan.Types.Enum.VkPipelineBindPoint, + module Graphics.Vulkan.Types.Enum.VkSubpassDescriptionFlags, + module Graphics.Vulkan.Types.Struct.VkAttachmentDescription, + module Graphics.Vulkan.Types.Struct.VkAttachmentReference, + module Graphics.Vulkan.Types.Struct.VkFramebufferCreateInfo, + module Graphics.Vulkan.Types.Struct.VkRenderPassCreateInfo, + module Graphics.Vulkan.Types.Struct.VkSubpassDependency, + module Graphics.Vulkan.Types.Struct.VkSubpassDescription, + -- ** Command pool commands + vkCreateCommandPool, vkDestroyCommandPool, vkResetCommandPool, + module Graphics.Vulkan.Types.Enum.VkCommandPoolCreateFlags, + module Graphics.Vulkan.Types.Enum.VkCommandPoolResetFlags, + module Graphics.Vulkan.Types.Struct.VkCommandPoolCreateInfo, + -- ** Command buffer commands + vkAllocateCommandBuffers, vkFreeCommandBuffers, + vkBeginCommandBuffer, vkEndCommandBuffer, vkResetCommandBuffer, + module Graphics.Vulkan.Types.Enum.VkCommandBufferLevel, + module Graphics.Vulkan.Types.Enum.VkCommandBufferResetFlags, + module Graphics.Vulkan.Types.Enum.VkCommandBufferUsageFlags, + module Graphics.Vulkan.Types.Enum.VkQueryControlFlags, + module Graphics.Vulkan.Types.Struct.VkCommandBufferAllocateInfo, + module Graphics.Vulkan.Types.Struct.VkCommandBufferBeginInfo, + module Graphics.Vulkan.Types.Struct.VkCommandBufferInheritanceInfo, + -- ** Command buffer building commands + vkCmdBindPipeline, vkCmdSetViewport, vkCmdSetScissor, + vkCmdSetLineWidth, vkCmdSetDepthBias, vkCmdSetBlendConstants, + vkCmdSetDepthBounds, vkCmdSetStencilCompareMask, + vkCmdSetStencilWriteMask, vkCmdSetStencilReference, + vkCmdBindDescriptorSets, vkCmdBindIndexBuffer, + vkCmdBindVertexBuffers, vkCmdDraw, vkCmdDrawIndexed, + vkCmdDrawIndirect, vkCmdDrawIndexedIndirect, vkCmdDispatch, + vkCmdDispatchIndirect, vkCmdCopyBuffer, vkCmdCopyImage, + vkCmdBlitImage, vkCmdCopyBufferToImage, vkCmdCopyImageToBuffer, + vkCmdUpdateBuffer, vkCmdFillBuffer, vkCmdClearColorImage, + vkCmdClearDepthStencilImage, vkCmdClearAttachments, + vkCmdResolveImage, vkCmdSetEvent, vkCmdResetEvent, vkCmdWaitEvents, + vkCmdPipelineBarrier, vkCmdBeginQuery, vkCmdEndQuery, + vkCmdResetQueryPool, vkCmdWriteTimestamp, + vkCmdCopyQueryPoolResults, vkCmdPushConstants, + vkCmdBeginRenderPass, vkCmdNextSubpass, vkCmdEndRenderPass, + vkCmdExecuteCommands, + module Graphics.Vulkan.Types.Enum.VkIndexType, + module Graphics.Vulkan.Types.Enum.VkStencilFaceFlags, + module Graphics.Vulkan.Types.Enum.VkSubpassContents, + module Graphics.Vulkan.Types.Struct.VkBufferCopy, + module Graphics.Vulkan.Types.Struct.VkBufferImageCopy, + module Graphics.Vulkan.Types.Struct.VkBufferMemoryBarrier, + module Graphics.Vulkan.Types.Struct.VkClearAttachment, + module Graphics.Vulkan.Types.Struct.VkClearColorValue, + module Graphics.Vulkan.Types.Struct.VkClearDepthStencilValue, + module Graphics.Vulkan.Types.Struct.VkClearRect, + module Graphics.Vulkan.Types.Struct.VkClearValue, + module Graphics.Vulkan.Types.Struct.VkImageBlit, + module Graphics.Vulkan.Types.Struct.VkImageCopy, + module Graphics.Vulkan.Types.Struct.VkImageMemoryBarrier, + module Graphics.Vulkan.Types.Struct.VkImageResolve, + module Graphics.Vulkan.Types.Struct.VkImageSubresourceLayers, + module Graphics.Vulkan.Types.Struct.VkMemoryBarrier, + module Graphics.Vulkan.Types.Struct.VkRenderPassBeginInfo, + -- ** Types not directly used by the API. Include e.g. structs that are not parameter types of commands, but still defined by the API. + module Graphics.Vulkan.Types.Struct.VkDispatchIndirectCommand, + module Graphics.Vulkan.Types.Struct.VkDrawIndexedIndirectCommand, + module Graphics.Vulkan.Types.Struct.VkDrawIndirectCommand, + module Graphics.Vulkan.Types.Enum.VkObjectType) + where +import Graphics.Vulkan.Constants + (VK_ATTACHMENT_UNUSED, + pattern VK_ATTACHMENT_UNUSED, + VK_FALSE, + pattern VK_FALSE, + pattern VK_LOD_CLAMP_NONE, + VK_QUEUE_FAMILY_IGNORED, + pattern VK_QUEUE_FAMILY_IGNORED, + VK_REMAINING_ARRAY_LAYERS, + pattern VK_REMAINING_ARRAY_LAYERS, + VK_REMAINING_MIP_LEVELS, + pattern VK_REMAINING_MIP_LEVELS, + VK_SUBPASS_EXTERNAL, + pattern VK_SUBPASS_EXTERNAL, + VK_TRUE, + pattern VK_TRUE, + VK_WHOLE_SIZE, + pattern VK_WHOLE_SIZE) +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Types.BaseTypes +import Graphics.Vulkan.Types.Bitmasks +import Graphics.Vulkan.Types.Enum.VkAccessFlags +import Graphics.Vulkan.Types.Enum.VkAttachmentDescriptionFlags +import Graphics.Vulkan.Types.Enum.VkAttachmentLoadOp +import Graphics.Vulkan.Types.Enum.VkAttachmentStoreOp +import Graphics.Vulkan.Types.Enum.VkBlendFactor +import Graphics.Vulkan.Types.Enum.VkBlendOp +import Graphics.Vulkan.Types.Enum.VkBorderColor +import Graphics.Vulkan.Types.Enum.VkBufferCreateFlags +import Graphics.Vulkan.Types.Enum.VkBufferUsageFlags +import Graphics.Vulkan.Types.Enum.VkColorComponentFlags +import Graphics.Vulkan.Types.Enum.VkCommandBufferLevel +import Graphics.Vulkan.Types.Enum.VkCommandBufferResetFlags +import Graphics.Vulkan.Types.Enum.VkCommandBufferUsageFlags +import Graphics.Vulkan.Types.Enum.VkCommandPoolCreateFlags +import Graphics.Vulkan.Types.Enum.VkCommandPoolResetFlags +import Graphics.Vulkan.Types.Enum.VkCompareOp +import Graphics.Vulkan.Types.Enum.VkComponentSwizzle +import Graphics.Vulkan.Types.Enum.VkCullModeFlags +import Graphics.Vulkan.Types.Enum.VkDependencyFlags +import Graphics.Vulkan.Types.Enum.VkDescriptorPoolCreateFlags +import Graphics.Vulkan.Types.Enum.VkDescriptorSetLayoutCreateFlags +import Graphics.Vulkan.Types.Enum.VkDescriptorType +import Graphics.Vulkan.Types.Enum.VkDynamicState +import Graphics.Vulkan.Types.Enum.VkFenceCreateFlags +import Graphics.Vulkan.Types.Enum.VkFilter +import Graphics.Vulkan.Types.Enum.VkFormat +import Graphics.Vulkan.Types.Enum.VkFormatFeatureFlags +import Graphics.Vulkan.Types.Enum.VkFrontFace +import Graphics.Vulkan.Types.Enum.VkImageAspectFlags +import Graphics.Vulkan.Types.Enum.VkImageCreateFlags +import Graphics.Vulkan.Types.Enum.VkImageLayout +import Graphics.Vulkan.Types.Enum.VkImageTiling +import Graphics.Vulkan.Types.Enum.VkImageType +import Graphics.Vulkan.Types.Enum.VkImageUsageFlags +import Graphics.Vulkan.Types.Enum.VkImageViewType +import Graphics.Vulkan.Types.Enum.VkIndexType +import Graphics.Vulkan.Types.Enum.VkInternalAllocationType +import Graphics.Vulkan.Types.Enum.VkLogicOp +import Graphics.Vulkan.Types.Enum.VkMemoryHeapFlags +import Graphics.Vulkan.Types.Enum.VkMemoryPropertyFlags +import Graphics.Vulkan.Types.Enum.VkObjectType +import Graphics.Vulkan.Types.Enum.VkPhysicalDeviceType +import Graphics.Vulkan.Types.Enum.VkPipelineBindPoint +import Graphics.Vulkan.Types.Enum.VkPipelineCacheHeaderVersion +import Graphics.Vulkan.Types.Enum.VkPipelineCreateFlags +import Graphics.Vulkan.Types.Enum.VkPipelineStageFlags +import Graphics.Vulkan.Types.Enum.VkPolygonMode +import Graphics.Vulkan.Types.Enum.VkPrimitiveTopology +import Graphics.Vulkan.Types.Enum.VkQueryControlFlags +import Graphics.Vulkan.Types.Enum.VkQueryPipelineStatisticFlags +import Graphics.Vulkan.Types.Enum.VkQueryResultFlags +import Graphics.Vulkan.Types.Enum.VkQueryType +import Graphics.Vulkan.Types.Enum.VkQueueFlags +import Graphics.Vulkan.Types.Enum.VkResult +import Graphics.Vulkan.Types.Enum.VkSampleCountFlags +import Graphics.Vulkan.Types.Enum.VkSamplerAddressMode +import Graphics.Vulkan.Types.Enum.VkSamplerMipmapMode +import Graphics.Vulkan.Types.Enum.VkShaderStageFlags +import Graphics.Vulkan.Types.Enum.VkSharingMode +import Graphics.Vulkan.Types.Enum.VkSparseImageFormatFlags +import Graphics.Vulkan.Types.Enum.VkSparseMemoryBindFlags +import Graphics.Vulkan.Types.Enum.VkStencilFaceFlags +import Graphics.Vulkan.Types.Enum.VkStencilOp +import Graphics.Vulkan.Types.Enum.VkStructureType +import Graphics.Vulkan.Types.Enum.VkSubpassContents +import Graphics.Vulkan.Types.Enum.VkSubpassDescriptionFlags +import Graphics.Vulkan.Types.Enum.VkSystemAllocationScope +import Graphics.Vulkan.Types.Enum.VkVertexInputRate +import Graphics.Vulkan.Types.Funcpointers +import Graphics.Vulkan.Types.Handles +import Graphics.Vulkan.Types.Struct.VkAllocationCallbacks +import Graphics.Vulkan.Types.Struct.VkApplicationInfo +import Graphics.Vulkan.Types.Struct.VkAttachmentDescription +import Graphics.Vulkan.Types.Struct.VkAttachmentReference +import Graphics.Vulkan.Types.Struct.VkBindSparseInfo +import Graphics.Vulkan.Types.Struct.VkBufferCopy +import Graphics.Vulkan.Types.Struct.VkBufferCreateInfo +import Graphics.Vulkan.Types.Struct.VkBufferImageCopy +import Graphics.Vulkan.Types.Struct.VkBufferMemoryBarrier +import Graphics.Vulkan.Types.Struct.VkBufferViewCreateInfo +import Graphics.Vulkan.Types.Struct.VkClearAttachment +import Graphics.Vulkan.Types.Struct.VkClearColorValue +import Graphics.Vulkan.Types.Struct.VkClearDepthStencilValue +import Graphics.Vulkan.Types.Struct.VkClearRect +import Graphics.Vulkan.Types.Struct.VkClearValue +import Graphics.Vulkan.Types.Struct.VkCommandBufferAllocateInfo +import Graphics.Vulkan.Types.Struct.VkCommandBufferBeginInfo +import Graphics.Vulkan.Types.Struct.VkCommandBufferInheritanceInfo +import Graphics.Vulkan.Types.Struct.VkCommandPoolCreateInfo +import Graphics.Vulkan.Types.Struct.VkComponentMapping +import Graphics.Vulkan.Types.Struct.VkComputePipelineCreateInfo +import Graphics.Vulkan.Types.Struct.VkCopyDescriptorSet +import Graphics.Vulkan.Types.Struct.VkDescriptorBufferInfo +import Graphics.Vulkan.Types.Struct.VkDescriptorImageInfo +import Graphics.Vulkan.Types.Struct.VkDescriptorPoolCreateInfo +import Graphics.Vulkan.Types.Struct.VkDescriptorPoolSize +import Graphics.Vulkan.Types.Struct.VkDescriptorSetAllocateInfo +import Graphics.Vulkan.Types.Struct.VkDescriptorSetLayoutBinding +import Graphics.Vulkan.Types.Struct.VkDescriptorSetLayoutCreateInfo +import Graphics.Vulkan.Types.Struct.VkDeviceCreateInfo +import Graphics.Vulkan.Types.Struct.VkDeviceQueueCreateInfo +import Graphics.Vulkan.Types.Struct.VkDispatchIndirectCommand +import Graphics.Vulkan.Types.Struct.VkDrawIndexedIndirectCommand +import Graphics.Vulkan.Types.Struct.VkDrawIndirectCommand +import Graphics.Vulkan.Types.Struct.VkEventCreateInfo +import Graphics.Vulkan.Types.Struct.VkExtensionProperties +import Graphics.Vulkan.Types.Struct.VkExtent2D +import Graphics.Vulkan.Types.Struct.VkExtent3D +import Graphics.Vulkan.Types.Struct.VkFenceCreateInfo +import Graphics.Vulkan.Types.Struct.VkFormatProperties +import Graphics.Vulkan.Types.Struct.VkFramebufferCreateInfo +import Graphics.Vulkan.Types.Struct.VkGraphicsPipelineCreateInfo +import Graphics.Vulkan.Types.Struct.VkImageBlit +import Graphics.Vulkan.Types.Struct.VkImageCopy +import Graphics.Vulkan.Types.Struct.VkImageCreateInfo +import Graphics.Vulkan.Types.Struct.VkImageFormatProperties +import Graphics.Vulkan.Types.Struct.VkImageMemoryBarrier +import Graphics.Vulkan.Types.Struct.VkImageResolve +import Graphics.Vulkan.Types.Struct.VkImageSubresource +import Graphics.Vulkan.Types.Struct.VkImageSubresourceLayers +import Graphics.Vulkan.Types.Struct.VkImageSubresourceRange +import Graphics.Vulkan.Types.Struct.VkImageViewCreateInfo +import Graphics.Vulkan.Types.Struct.VkInstanceCreateInfo +import Graphics.Vulkan.Types.Struct.VkLayerProperties +import Graphics.Vulkan.Types.Struct.VkMappedMemoryRange +import Graphics.Vulkan.Types.Struct.VkMemoryAllocateInfo +import Graphics.Vulkan.Types.Struct.VkMemoryBarrier +import Graphics.Vulkan.Types.Struct.VkMemoryHeap +import Graphics.Vulkan.Types.Struct.VkMemoryRequirements +import Graphics.Vulkan.Types.Struct.VkMemoryType +import Graphics.Vulkan.Types.Struct.VkOffset2D +import Graphics.Vulkan.Types.Struct.VkOffset3D +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceFeatures +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceLimits +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceMemoryProperties +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceProperties +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceSparseProperties +import Graphics.Vulkan.Types.Struct.VkPipelineCacheCreateInfo +import Graphics.Vulkan.Types.Struct.VkPipelineColorBlendAttachmentState +import Graphics.Vulkan.Types.Struct.VkPipelineColorBlendStateCreateInfo +import Graphics.Vulkan.Types.Struct.VkPipelineDepthStencilStateCreateInfo +import Graphics.Vulkan.Types.Struct.VkPipelineDynamicStateCreateInfo +import Graphics.Vulkan.Types.Struct.VkPipelineInputAssemblyStateCreateInfo +import Graphics.Vulkan.Types.Struct.VkPipelineLayoutCreateInfo +import Graphics.Vulkan.Types.Struct.VkPipelineMultisampleStateCreateInfo +import Graphics.Vulkan.Types.Struct.VkPipelineRasterizationStateCreateInfo +import Graphics.Vulkan.Types.Struct.VkPipelineShaderStageCreateInfo +import Graphics.Vulkan.Types.Struct.VkPipelineTessellationStateCreateInfo +import Graphics.Vulkan.Types.Struct.VkPipelineVertexInputStateCreateInfo +import Graphics.Vulkan.Types.Struct.VkPipelineViewportStateCreateInfo +import Graphics.Vulkan.Types.Struct.VkPushConstantRange +import Graphics.Vulkan.Types.Struct.VkQueryPoolCreateInfo +import Graphics.Vulkan.Types.Struct.VkQueueFamilyProperties +import Graphics.Vulkan.Types.Struct.VkRect2D +import Graphics.Vulkan.Types.Struct.VkRenderPassBeginInfo +import Graphics.Vulkan.Types.Struct.VkRenderPassCreateInfo +import Graphics.Vulkan.Types.Struct.VkSamplerCreateInfo +import Graphics.Vulkan.Types.Struct.VkSemaphoreCreateInfo +import Graphics.Vulkan.Types.Struct.VkShaderModuleCreateInfo +import Graphics.Vulkan.Types.Struct.VkSparseBufferMemoryBindInfo +import Graphics.Vulkan.Types.Struct.VkSparseImageFormatProperties +import Graphics.Vulkan.Types.Struct.VkSparseImageMemoryBind +import Graphics.Vulkan.Types.Struct.VkSparseImageMemoryBindInfo +import Graphics.Vulkan.Types.Struct.VkSparseImageMemoryRequirements +import Graphics.Vulkan.Types.Struct.VkSparseImageOpaqueMemoryBindInfo +import Graphics.Vulkan.Types.Struct.VkSparseMemoryBind +import Graphics.Vulkan.Types.Struct.VkSpecializationInfo +import Graphics.Vulkan.Types.Struct.VkSpecializationMapEntry +import Graphics.Vulkan.Types.Struct.VkStencilOpState +import Graphics.Vulkan.Types.Struct.VkSubmitInfo +import Graphics.Vulkan.Types.Struct.VkSubpassDependency +import Graphics.Vulkan.Types.Struct.VkSubpassDescription +import Graphics.Vulkan.Types.Struct.VkSubresourceLayout +import Graphics.Vulkan.Types.Struct.VkVertexInputAttributeDescription +import Graphics.Vulkan.Types.Struct.VkVertexInputBindingDescription +import Graphics.Vulkan.Types.Struct.VkViewport +import Graphics.Vulkan.Types.Struct.VkWriteDescriptorSet + +-- | Success codes: 'VK_SUCCESS'. +-- +-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_INITIALIZATION_FAILED', 'VK_ERROR_LAYER_NOT_PRESENT', 'VK_ERROR_EXTENSION_NOT_PRESENT', 'VK_ERROR_INCOMPATIBLE_DRIVER'. +-- +-- > VkResult vkCreateInstance +-- > ( const VkInstanceCreateInfo* pCreateInfo +-- > , const VkAllocationCallbacks* pAllocator +-- > , VkInstance* pInstance +-- > ) +-- +-- +foreign import ccall unsafe "vkCreateInstance" vkCreateInstance :: + Ptr VkInstanceCreateInfo -- ^ pCreateInfo + -> + Ptr VkAllocationCallbacks -- ^ pAllocator + -> Ptr VkInstance -- ^ pInstance + -> IO VkResult + +-- | > () vkDestroyInstance +-- > ( VkInstance instance +-- > , const VkAllocationCallbacks* pAllocator +-- > ) +-- +-- +foreign import ccall unsafe "vkDestroyInstance" vkDestroyInstance + :: VkInstance -- ^ instance + -> Ptr VkAllocationCallbacks -- ^ pAllocator + -> IO () + +-- | Success codes: 'VK_SUCCESS', 'VK_INCOMPLETE'. +-- +-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_INITIALIZATION_FAILED'. +-- +-- > VkResult vkEnumeratePhysicalDevices +-- > ( VkInstance instance +-- > , uint32_t* pPhysicalDeviceCount +-- > , VkPhysicalDevice* pPhysicalDevices +-- > ) +-- +-- +foreign import ccall unsafe "vkEnumeratePhysicalDevices" + vkEnumeratePhysicalDevices :: + VkInstance -- ^ instance + -> Ptr Word32 -- ^ pPhysicalDeviceCount + -> Ptr VkPhysicalDevice -- ^ pPhysicalDevices + -> IO VkResult + +-- | > () vkGetPhysicalDeviceFeatures +-- > ( VkPhysicalDevice physicalDevice +-- > , VkPhysicalDeviceFeatures* pFeatures +-- > ) +-- +-- +foreign import ccall unsafe "vkGetPhysicalDeviceFeatures" + vkGetPhysicalDeviceFeatures :: + VkPhysicalDevice -- ^ physicalDevice + -> Ptr VkPhysicalDeviceFeatures -- ^ pFeatures + -> IO () + +-- | > () vkGetPhysicalDeviceFormatProperties +-- > ( VkPhysicalDevice physicalDevice +-- > , VkFormat format +-- > , VkFormatProperties* pFormatProperties +-- > ) +-- +-- +foreign import ccall unsafe "vkGetPhysicalDeviceFormatProperties" + vkGetPhysicalDeviceFormatProperties :: + VkPhysicalDevice -- ^ physicalDevice + -> VkFormat -- ^ format + -> Ptr VkFormatProperties -- ^ pFormatProperties + -> IO () + +-- | Success codes: 'VK_SUCCESS'. +-- +-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_FORMAT_NOT_SUPPORTED'. +-- +-- > VkResult vkGetPhysicalDeviceImageFormatProperties +-- > ( VkPhysicalDevice physicalDevice +-- > , VkFormat format +-- > , VkImageType type +-- > , VkImageTiling tiling +-- > , VkImageUsageFlags usage +-- > , VkImageCreateFlags flags +-- > , VkImageFormatProperties* pImageFormatProperties +-- > ) +-- +-- +foreign import ccall unsafe + "vkGetPhysicalDeviceImageFormatProperties" + vkGetPhysicalDeviceImageFormatProperties :: + VkPhysicalDevice -- ^ physicalDevice + -> + VkFormat -- ^ format + -> + VkImageType -- ^ type + -> + VkImageTiling -- ^ tiling + -> + VkImageUsageFlags -- ^ usage + -> + VkImageCreateFlags -- ^ flags + -> Ptr VkImageFormatProperties -- ^ pImageFormatProperties + -> IO VkResult + +-- | > () vkGetPhysicalDeviceProperties +-- > ( VkPhysicalDevice physicalDevice +-- > , VkPhysicalDeviceProperties* pProperties +-- > ) +-- +-- +foreign import ccall unsafe "vkGetPhysicalDeviceProperties" + vkGetPhysicalDeviceProperties :: + VkPhysicalDevice -- ^ physicalDevice + -> Ptr VkPhysicalDeviceProperties -- ^ pProperties + -> IO () + +-- | > () vkGetPhysicalDeviceQueueFamilyProperties +-- > ( VkPhysicalDevice physicalDevice +-- > , uint32_t* pQueueFamilyPropertyCount +-- > , VkQueueFamilyProperties* pQueueFamilyProperties +-- > ) +-- +-- +foreign import ccall unsafe + "vkGetPhysicalDeviceQueueFamilyProperties" + vkGetPhysicalDeviceQueueFamilyProperties :: + VkPhysicalDevice -- ^ physicalDevice + -> + Ptr Word32 -- ^ pQueueFamilyPropertyCount + -> Ptr VkQueueFamilyProperties -- ^ pQueueFamilyProperties + -> IO () + +-- | > () vkGetPhysicalDeviceMemoryProperties +-- > ( VkPhysicalDevice physicalDevice +-- > , VkPhysicalDeviceMemoryProperties* pMemoryProperties +-- > ) +-- +-- +foreign import ccall unsafe "vkGetPhysicalDeviceMemoryProperties" + vkGetPhysicalDeviceMemoryProperties :: + VkPhysicalDevice -- ^ physicalDevice + -> Ptr VkPhysicalDeviceMemoryProperties -- ^ pMemoryProperties + -> IO () + +-- | > PFN_vkVoidFunction vkGetInstanceProcAddr +-- > ( VkInstance instance +-- > , const char* pName +-- > ) +-- +-- +foreign import ccall unsafe "vkGetInstanceProcAddr" + vkGetInstanceProcAddr :: + VkInstance -- ^ instance + -> CString -- ^ pName + -> IO PFN_vkVoidFunction + +-- | > PFN_vkVoidFunction vkGetDeviceProcAddr +-- > ( VkDevice device +-- > , const char* pName +-- > ) +-- +-- +foreign import ccall unsafe "vkGetDeviceProcAddr" + vkGetDeviceProcAddr :: VkDevice -- ^ device + -> CString -- ^ pName + -> IO PFN_vkVoidFunction + +-- | Success codes: 'VK_SUCCESS'. +-- +-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_INITIALIZATION_FAILED', 'VK_ERROR_EXTENSION_NOT_PRESENT', 'VK_ERROR_FEATURE_NOT_PRESENT', 'VK_ERROR_TOO_MANY_OBJECTS', 'VK_ERROR_DEVICE_LOST'. +-- +-- > VkResult vkCreateDevice +-- > ( VkPhysicalDevice physicalDevice +-- > , const VkDeviceCreateInfo* pCreateInfo +-- > , const VkAllocationCallbacks* pAllocator +-- > , VkDevice* pDevice +-- > ) +-- +-- +foreign import ccall unsafe "vkCreateDevice" vkCreateDevice :: + VkPhysicalDevice -- ^ physicalDevice + -> + Ptr VkDeviceCreateInfo -- ^ pCreateInfo + -> + Ptr VkAllocationCallbacks -- ^ pAllocator + -> Ptr VkDevice -- ^ pDevice + -> IO VkResult + +-- | > () vkDestroyDevice +-- > ( VkDevice device +-- > , const VkAllocationCallbacks* pAllocator +-- > ) +-- +-- +foreign import ccall unsafe "vkDestroyDevice" vkDestroyDevice :: + VkDevice -- ^ device + -> Ptr VkAllocationCallbacks -- ^ pAllocator + -> IO () + +-- | Success codes: 'VK_SUCCESS', 'VK_INCOMPLETE'. +-- +-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_LAYER_NOT_PRESENT'. +-- +-- > VkResult vkEnumerateInstanceExtensionProperties +-- > ( const char* pLayerName +-- > , uint32_t* pPropertyCount +-- > , VkExtensionProperties* pProperties +-- > ) +-- +-- +foreign import ccall unsafe + "vkEnumerateInstanceExtensionProperties" + vkEnumerateInstanceExtensionProperties :: + CString -- ^ pLayerName + -> Ptr Word32 -- ^ pPropertyCount + -> Ptr VkExtensionProperties -- ^ pProperties + -> IO VkResult + +-- | Success codes: 'VK_SUCCESS', 'VK_INCOMPLETE'. +-- +-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_LAYER_NOT_PRESENT'. +-- +-- > VkResult vkEnumerateDeviceExtensionProperties +-- > ( VkPhysicalDevice physicalDevice +-- > , const char* pLayerName +-- > , uint32_t* pPropertyCount +-- > , VkExtensionProperties* pProperties +-- > ) +-- +-- +foreign import ccall unsafe "vkEnumerateDeviceExtensionProperties" + vkEnumerateDeviceExtensionProperties :: + VkPhysicalDevice -- ^ physicalDevice + -> + CString -- ^ pLayerName + -> Ptr Word32 -- ^ pPropertyCount + -> Ptr VkExtensionProperties -- ^ pProperties + -> IO VkResult + +-- | Success codes: 'VK_SUCCESS', 'VK_INCOMPLETE'. +-- +-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. +-- +-- > VkResult vkEnumerateInstanceLayerProperties +-- > ( uint32_t* pPropertyCount +-- > , VkLayerProperties* pProperties +-- > ) +-- +-- +foreign import ccall unsafe "vkEnumerateInstanceLayerProperties" + vkEnumerateInstanceLayerProperties :: + Ptr Word32 -- ^ pPropertyCount + -> Ptr VkLayerProperties -- ^ pProperties + -> IO VkResult + +-- | Success codes: 'VK_SUCCESS', 'VK_INCOMPLETE'. +-- +-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. +-- +-- > VkResult vkEnumerateDeviceLayerProperties +-- > ( VkPhysicalDevice physicalDevice +-- > , uint32_t* pPropertyCount +-- > , VkLayerProperties* pProperties +-- > ) +-- +-- +foreign import ccall unsafe "vkEnumerateDeviceLayerProperties" + vkEnumerateDeviceLayerProperties :: + VkPhysicalDevice -- ^ physicalDevice + -> + Ptr Word32 -- ^ pPropertyCount + -> Ptr VkLayerProperties -- ^ pProperties + -> IO VkResult + +-- | > () vkGetDeviceQueue +-- > ( VkDevice device +-- > , uint32_t queueFamilyIndex +-- > , uint32_t queueIndex +-- > , VkQueue* pQueue +-- > ) +-- +-- +foreign import ccall unsafe "vkGetDeviceQueue" vkGetDeviceQueue :: + VkDevice -- ^ device + -> Word32 -- ^ queueFamilyIndex + -> Word32 -- ^ queueIndex + -> Ptr VkQueue -- ^ pQueue + -> IO () + +-- | Success codes: 'VK_SUCCESS'. +-- +-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_DEVICE_LOST'. +-- +-- > VkResult vkQueueSubmit +-- > ( VkQueue queue +-- > , uint32_t submitCount +-- > , const VkSubmitInfo* pSubmits +-- > , VkFence fence +-- > ) +-- +-- +foreign import ccall unsafe "vkQueueSubmit" vkQueueSubmit :: + VkQueue -- ^ queue + -> Word32 -- ^ submitCount + -> Ptr VkSubmitInfo -- ^ pSubmits + -> VkFence -- ^ fence + -> IO VkResult + +-- | Success codes: 'VK_SUCCESS'. +-- +-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_DEVICE_LOST'. +-- +-- > VkResult vkQueueWaitIdle +-- > ( VkQueue queue +-- > ) +-- +-- +foreign import ccall unsafe "vkQueueWaitIdle" vkQueueWaitIdle :: + VkQueue -- ^ queue + -> IO VkResult + +-- | Success codes: 'VK_SUCCESS'. +-- +-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_DEVICE_LOST'. +-- +-- > VkResult vkDeviceWaitIdle +-- > ( VkDevice device +-- > ) +-- +-- +foreign import ccall unsafe "vkDeviceWaitIdle" vkDeviceWaitIdle :: + VkDevice -- ^ device + -> IO VkResult + +-- | Success codes: 'VK_SUCCESS'. +-- +-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_TOO_MANY_OBJECTS', 'VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR'. +-- +-- > VkResult vkAllocateMemory +-- > ( VkDevice device +-- > , const VkMemoryAllocateInfo* pAllocateInfo +-- > , const VkAllocationCallbacks* pAllocator +-- > , VkDeviceMemory* pMemory +-- > ) +-- +-- +foreign import ccall unsafe "vkAllocateMemory" vkAllocateMemory :: + VkDevice -- ^ device + -> + Ptr VkMemoryAllocateInfo -- ^ pAllocateInfo + -> + Ptr VkAllocationCallbacks -- ^ pAllocator + -> Ptr VkDeviceMemory -- ^ pMemory + -> IO VkResult + +-- | > () vkFreeMemory +-- > ( VkDevice device +-- > , VkDeviceMemory memory +-- > , const VkAllocationCallbacks* pAllocator +-- > ) +-- +-- +foreign import ccall unsafe "vkFreeMemory" vkFreeMemory :: + VkDevice -- ^ device + -> VkDeviceMemory -- ^ memory + -> Ptr VkAllocationCallbacks -- ^ pAllocator + -> IO () + +-- | Success codes: 'VK_SUCCESS'. +-- +-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_MEMORY_MAP_FAILED'. +-- +-- > VkResult vkMapMemory +-- > ( VkDevice device +-- > , VkDeviceMemory memory +-- > , VkDeviceSize offset +-- > , VkDeviceSize size +-- > , VkMemoryMapFlags flags +-- > , void** ppData +-- > ) +-- +-- +foreign import ccall unsafe "vkMapMemory" vkMapMemory :: + VkDevice -- ^ device + -> + VkDeviceMemory -- ^ memory + -> + VkDeviceSize -- ^ offset + -> + VkDeviceSize -- ^ size + -> VkMemoryMapFlags -- ^ flags + -> Ptr (Ptr Void) -- ^ ppData + -> IO VkResult + +-- | > () vkUnmapMemory +-- > ( VkDevice device +-- > , VkDeviceMemory memory +-- > ) +-- +-- +foreign import ccall unsafe "vkUnmapMemory" vkUnmapMemory :: + VkDevice -- ^ device + -> VkDeviceMemory -- ^ memory + -> IO () + +-- | Success codes: 'VK_SUCCESS'. +-- +-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. +-- +-- > VkResult vkFlushMappedMemoryRanges +-- > ( VkDevice device +-- > , uint32_t memoryRangeCount +-- > , const VkMappedMemoryRange* pMemoryRanges +-- > ) +-- +-- +foreign import ccall unsafe "vkFlushMappedMemoryRanges" + vkFlushMappedMemoryRanges :: + VkDevice -- ^ device + -> Word32 -- ^ memoryRangeCount + -> Ptr VkMappedMemoryRange -- ^ pMemoryRanges + -> IO VkResult + +-- | Success codes: 'VK_SUCCESS'. +-- +-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. +-- +-- > VkResult vkInvalidateMappedMemoryRanges +-- > ( VkDevice device +-- > , uint32_t memoryRangeCount +-- > , const VkMappedMemoryRange* pMemoryRanges +-- > ) +-- +-- +foreign import ccall unsafe "vkInvalidateMappedMemoryRanges" + vkInvalidateMappedMemoryRanges :: + VkDevice -- ^ device + -> Word32 -- ^ memoryRangeCount + -> Ptr VkMappedMemoryRange -- ^ pMemoryRanges + -> IO VkResult + +-- | > () vkGetDeviceMemoryCommitment +-- > ( VkDevice device +-- > , VkDeviceMemory memory +-- > , VkDeviceSize* pCommittedMemoryInBytes +-- > ) +-- +-- +foreign import ccall unsafe "vkGetDeviceMemoryCommitment" + vkGetDeviceMemoryCommitment :: + VkDevice -- ^ device + -> VkDeviceMemory -- ^ memory + -> Ptr VkDeviceSize -- ^ pCommittedMemoryInBytes + -> IO () + +-- | Success codes: 'VK_SUCCESS'. +-- +-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. +-- +-- > VkResult vkBindBufferMemory +-- > ( VkDevice device +-- > , VkBuffer buffer +-- > , VkDeviceMemory memory +-- > , VkDeviceSize memoryOffset +-- > ) +-- +-- +foreign import ccall unsafe "vkBindBufferMemory" vkBindBufferMemory + :: + VkDevice -- ^ device + -> + VkBuffer -- ^ buffer + -> VkDeviceMemory -- ^ memory + -> VkDeviceSize -- ^ memoryOffset + -> IO VkResult + +-- | Success codes: 'VK_SUCCESS'. +-- +-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. +-- +-- > VkResult vkBindImageMemory +-- > ( VkDevice device +-- > , VkImage image +-- > , VkDeviceMemory memory +-- > , VkDeviceSize memoryOffset +-- > ) +-- +-- +foreign import ccall unsafe "vkBindImageMemory" vkBindImageMemory + :: + VkDevice -- ^ device + -> + VkImage -- ^ image + -> VkDeviceMemory -- ^ memory + -> VkDeviceSize -- ^ memoryOffset + -> IO VkResult + +-- | > () vkGetBufferMemoryRequirements +-- > ( VkDevice device +-- > , VkBuffer buffer +-- > , VkMemoryRequirements* pMemoryRequirements +-- > ) +-- +-- +foreign import ccall unsafe "vkGetBufferMemoryRequirements" + vkGetBufferMemoryRequirements :: + VkDevice -- ^ device + -> VkBuffer -- ^ buffer + -> Ptr VkMemoryRequirements -- ^ pMemoryRequirements + -> IO () + +-- | > () vkGetImageMemoryRequirements +-- > ( VkDevice device +-- > , VkImage image +-- > , VkMemoryRequirements* pMemoryRequirements +-- > ) +-- +-- +foreign import ccall unsafe "vkGetImageMemoryRequirements" + vkGetImageMemoryRequirements :: + VkDevice -- ^ device + -> VkImage -- ^ image + -> Ptr VkMemoryRequirements -- ^ pMemoryRequirements + -> IO () + +-- | > () vkGetImageSparseMemoryRequirements +-- > ( VkDevice device +-- > , VkImage image +-- > , uint32_t* pSparseMemoryRequirementCount +-- > , VkSparseImageMemoryRequirements* pSparseMemoryRequirements +-- > ) +-- +-- +foreign import ccall unsafe "vkGetImageSparseMemoryRequirements" + vkGetImageSparseMemoryRequirements :: + VkDevice -- ^ device + -> + VkImage -- ^ image + -> + Ptr Word32 -- ^ pSparseMemoryRequirementCount + -> Ptr VkSparseImageMemoryRequirements -- ^ pSparseMemoryRequirements + -> IO () + +-- | > () vkGetPhysicalDeviceSparseImageFormatProperties +-- > ( VkPhysicalDevice physicalDevice +-- > , VkFormat format +-- > , VkImageType type +-- > , VkSampleCountFlagBits samples +-- > , VkImageUsageFlags usage +-- > , VkImageTiling tiling +-- > , uint32_t* pPropertyCount +-- > , VkSparseImageFormatProperties* pProperties +-- > ) +-- +-- +foreign import ccall unsafe + "vkGetPhysicalDeviceSparseImageFormatProperties" + vkGetPhysicalDeviceSparseImageFormatProperties :: + VkPhysicalDevice -- ^ physicalDevice + -> + VkFormat -- ^ format + -> + VkImageType -- ^ type + -> + VkSampleCountFlagBits -- ^ samples + -> + VkImageUsageFlags -- ^ usage + -> + VkImageTiling -- ^ tiling + -> + Ptr Word32 -- ^ pPropertyCount + -> Ptr VkSparseImageFormatProperties -- ^ pProperties + -> IO () + +-- | Success codes: 'VK_SUCCESS'. +-- +-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_DEVICE_LOST'. +-- +-- queues: 'sparse_binding'. +-- +-- > VkResult vkQueueBindSparse +-- > ( VkQueue queue +-- > , uint32_t bindInfoCount +-- > , const VkBindSparseInfo* pBindInfo +-- > , VkFence fence +-- > ) +-- +-- +foreign import ccall unsafe "vkQueueBindSparse" vkQueueBindSparse + :: + VkQueue -- ^ queue + -> Word32 -- ^ bindInfoCount + -> Ptr VkBindSparseInfo -- ^ pBindInfo + -> VkFence -- ^ fence + -> IO VkResult + +-- | Success codes: 'VK_SUCCESS'. +-- +-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. +-- +-- > VkResult vkCreateFence +-- > ( VkDevice device +-- > , const VkFenceCreateInfo* pCreateInfo +-- > , const VkAllocationCallbacks* pAllocator +-- > , VkFence* pFence +-- > ) +-- +-- +foreign import ccall unsafe "vkCreateFence" vkCreateFence :: + VkDevice -- ^ device + -> + Ptr VkFenceCreateInfo -- ^ pCreateInfo + -> + Ptr VkAllocationCallbacks -- ^ pAllocator + -> Ptr VkFence -- ^ pFence + -> IO VkResult + +-- | > () vkDestroyFence +-- > ( VkDevice device +-- > , VkFence fence +-- > , const VkAllocationCallbacks* pAllocator +-- > ) +-- +-- +foreign import ccall unsafe "vkDestroyFence" vkDestroyFence :: + VkDevice -- ^ device + -> VkFence -- ^ fence + -> Ptr VkAllocationCallbacks -- ^ pAllocator + -> IO () + +-- | Success codes: 'VK_SUCCESS'. +-- +-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. +-- +-- > VkResult vkResetFences +-- > ( VkDevice device +-- > , uint32_t fenceCount +-- > , const VkFence* pFences +-- > ) +-- +-- +foreign import ccall unsafe "vkResetFences" vkResetFences :: + VkDevice -- ^ device + -> Word32 -- ^ fenceCount + -> Ptr VkFence -- ^ pFences + -> IO VkResult + +-- | Success codes: 'VK_SUCCESS', 'VK_NOT_READY'. +-- +-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_DEVICE_LOST'. +-- +-- > VkResult vkGetFenceStatus +-- > ( VkDevice device +-- > , VkFence fence +-- > ) +-- +-- +foreign import ccall unsafe "vkGetFenceStatus" vkGetFenceStatus :: + VkDevice -- ^ device + -> VkFence -- ^ fence + -> IO VkResult + +-- | Success codes: 'VK_SUCCESS', 'VK_TIMEOUT'. +-- +-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_DEVICE_LOST'. +-- +-- > VkResult vkWaitForFences +-- > ( VkDevice device +-- > , uint32_t fenceCount +-- > , const VkFence* pFences +-- > , VkBool32 waitAll +-- > , uint64_t timeout +-- > ) +-- +-- +foreign import ccall unsafe "vkWaitForFences" vkWaitForFences :: + VkDevice -- ^ device + -> + Word32 -- ^ fenceCount + -> Ptr VkFence -- ^ pFences + -> VkBool32 -- ^ waitAll + -> Word64 -- ^ timeout + -> IO VkResult + +-- | Success codes: 'VK_SUCCESS'. +-- +-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. +-- +-- > VkResult vkCreateSemaphore +-- > ( VkDevice device +-- > , const VkSemaphoreCreateInfo* pCreateInfo +-- > , const VkAllocationCallbacks* pAllocator +-- > , VkSemaphore* pSemaphore +-- > ) +-- +-- +foreign import ccall unsafe "vkCreateSemaphore" vkCreateSemaphore + :: + VkDevice -- ^ device + -> + Ptr VkSemaphoreCreateInfo -- ^ pCreateInfo + -> + Ptr VkAllocationCallbacks -- ^ pAllocator + -> Ptr VkSemaphore -- ^ pSemaphore + -> IO VkResult + +-- | > () vkDestroySemaphore +-- > ( VkDevice device +-- > , VkSemaphore semaphore +-- > , const VkAllocationCallbacks* pAllocator +-- > ) +-- +-- +foreign import ccall unsafe "vkDestroySemaphore" vkDestroySemaphore + :: VkDevice -- ^ device + -> VkSemaphore -- ^ semaphore + -> Ptr VkAllocationCallbacks -- ^ pAllocator + -> IO () + +-- | Success codes: 'VK_SUCCESS'. +-- +-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. +-- +-- > VkResult vkCreateEvent +-- > ( VkDevice device +-- > , const VkEventCreateInfo* pCreateInfo +-- > , const VkAllocationCallbacks* pAllocator +-- > , VkEvent* pEvent +-- > ) +-- +-- +foreign import ccall unsafe "vkCreateEvent" vkCreateEvent :: + VkDevice -- ^ device + -> + Ptr VkEventCreateInfo -- ^ pCreateInfo + -> + Ptr VkAllocationCallbacks -- ^ pAllocator + -> Ptr VkEvent -- ^ pEvent + -> IO VkResult + +-- | > () vkDestroyEvent +-- > ( VkDevice device +-- > , VkEvent event +-- > , const VkAllocationCallbacks* pAllocator +-- > ) +-- +-- +foreign import ccall unsafe "vkDestroyEvent" vkDestroyEvent :: + VkDevice -- ^ device + -> VkEvent -- ^ event + -> Ptr VkAllocationCallbacks -- ^ pAllocator + -> IO () + +-- | Success codes: 'VK_EVENT_SET', 'VK_EVENT_RESET'. +-- +-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_DEVICE_LOST'. +-- +-- > VkResult vkGetEventStatus +-- > ( VkDevice device +-- > , VkEvent event +-- > ) +-- +-- +foreign import ccall unsafe "vkGetEventStatus" vkGetEventStatus :: + VkDevice -- ^ device + -> VkEvent -- ^ event + -> IO VkResult + +-- | Success codes: 'VK_SUCCESS'. +-- +-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. +-- +-- > VkResult vkSetEvent +-- > ( VkDevice device +-- > , VkEvent event +-- > ) +-- +-- +foreign import ccall unsafe "vkSetEvent" vkSetEvent :: + VkDevice -- ^ device + -> VkEvent -- ^ event + -> IO VkResult + +-- | Success codes: 'VK_SUCCESS'. +-- +-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. +-- +-- > VkResult vkResetEvent +-- > ( VkDevice device +-- > , VkEvent event +-- > ) +-- +-- +foreign import ccall unsafe "vkResetEvent" vkResetEvent :: + VkDevice -- ^ device + -> VkEvent -- ^ event + -> IO VkResult + +-- | Success codes: 'VK_SUCCESS'. +-- +-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. +-- +-- > VkResult vkCreateQueryPool +-- > ( VkDevice device +-- > , const VkQueryPoolCreateInfo* pCreateInfo +-- > , const VkAllocationCallbacks* pAllocator +-- > , VkQueryPool* pQueryPool +-- > ) +-- +-- +foreign import ccall unsafe "vkCreateQueryPool" vkCreateQueryPool + :: + VkDevice -- ^ device + -> + Ptr VkQueryPoolCreateInfo -- ^ pCreateInfo + -> + Ptr VkAllocationCallbacks -- ^ pAllocator + -> Ptr VkQueryPool -- ^ pQueryPool + -> IO VkResult + +-- | > () vkDestroyQueryPool +-- > ( VkDevice device +-- > , VkQueryPool queryPool +-- > , const VkAllocationCallbacks* pAllocator +-- > ) +-- +-- +foreign import ccall unsafe "vkDestroyQueryPool" vkDestroyQueryPool + :: VkDevice -- ^ device + -> VkQueryPool -- ^ queryPool + -> Ptr VkAllocationCallbacks -- ^ pAllocator + -> IO () + +-- | Success codes: 'VK_SUCCESS', 'VK_NOT_READY'. +-- +-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_DEVICE_LOST'. +-- +-- > VkResult vkGetQueryPoolResults +-- > ( VkDevice device +-- > , VkQueryPool queryPool +-- > , uint32_t firstQuery +-- > , uint32_t queryCount +-- > , size_t dataSize +-- > , void* pData +-- > , VkDeviceSize stride +-- > , VkQueryResultFlags flags +-- > ) +-- +-- +foreign import ccall unsafe "vkGetQueryPoolResults" + vkGetQueryPoolResults :: + VkDevice -- ^ device + -> + VkQueryPool -- ^ queryPool + -> + Word32 -- ^ firstQuery + -> + Word32 -- ^ queryCount + -> + CSize -- ^ dataSize + -> + Ptr Void -- ^ pData + -> VkDeviceSize -- ^ stride + -> VkQueryResultFlags -- ^ flags + -> IO VkResult + +-- | Success codes: 'VK_SUCCESS'. +-- +-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. +-- +-- > VkResult vkCreateBuffer +-- > ( VkDevice device +-- > , const VkBufferCreateInfo* pCreateInfo +-- > , const VkAllocationCallbacks* pAllocator +-- > , VkBuffer* pBuffer +-- > ) +-- +-- +foreign import ccall unsafe "vkCreateBuffer" vkCreateBuffer :: + VkDevice -- ^ device + -> + Ptr VkBufferCreateInfo -- ^ pCreateInfo + -> + Ptr VkAllocationCallbacks -- ^ pAllocator + -> Ptr VkBuffer -- ^ pBuffer + -> IO VkResult + +-- | > () vkDestroyBuffer +-- > ( VkDevice device +-- > , VkBuffer buffer +-- > , const VkAllocationCallbacks* pAllocator +-- > ) +-- +-- +foreign import ccall unsafe "vkDestroyBuffer" vkDestroyBuffer :: + VkDevice -- ^ device + -> VkBuffer -- ^ buffer + -> Ptr VkAllocationCallbacks -- ^ pAllocator + -> IO () + +-- | Success codes: 'VK_SUCCESS'. +-- +-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. +-- +-- > VkResult vkCreateBufferView +-- > ( VkDevice device +-- > , const VkBufferViewCreateInfo* pCreateInfo +-- > , const VkAllocationCallbacks* pAllocator +-- > , VkBufferView* pView +-- > ) +-- +-- +foreign import ccall unsafe "vkCreateBufferView" vkCreateBufferView + :: + VkDevice -- ^ device + -> + Ptr VkBufferViewCreateInfo -- ^ pCreateInfo + -> + Ptr VkAllocationCallbacks -- ^ pAllocator + -> Ptr VkBufferView -- ^ pView + -> IO VkResult + +-- | > () vkDestroyBufferView +-- > ( VkDevice device +-- > , VkBufferView bufferView +-- > , const VkAllocationCallbacks* pAllocator +-- > ) +-- +-- +foreign import ccall unsafe "vkDestroyBufferView" + vkDestroyBufferView :: + VkDevice -- ^ device + -> VkBufferView -- ^ bufferView + -> Ptr VkAllocationCallbacks -- ^ pAllocator + -> IO () + +-- | Success codes: 'VK_SUCCESS'. +-- +-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. +-- +-- > VkResult vkCreateImage +-- > ( VkDevice device +-- > , const VkImageCreateInfo* pCreateInfo +-- > , const VkAllocationCallbacks* pAllocator +-- > , VkImage* pImage +-- > ) +-- +-- +foreign import ccall unsafe "vkCreateImage" vkCreateImage :: + VkDevice -- ^ device + -> + Ptr VkImageCreateInfo -- ^ pCreateInfo + -> + Ptr VkAllocationCallbacks -- ^ pAllocator + -> Ptr VkImage -- ^ pImage + -> IO VkResult + +-- | > () vkDestroyImage +-- > ( VkDevice device +-- > , VkImage image +-- > , const VkAllocationCallbacks* pAllocator +-- > ) +-- +-- +foreign import ccall unsafe "vkDestroyImage" vkDestroyImage :: + VkDevice -- ^ device + -> VkImage -- ^ image + -> Ptr VkAllocationCallbacks -- ^ pAllocator + -> IO () + +-- | > () vkGetImageSubresourceLayout +-- > ( VkDevice device +-- > , VkImage image +-- > , const VkImageSubresource* pSubresource +-- > , VkSubresourceLayout* pLayout +-- > ) +-- +-- +foreign import ccall unsafe "vkGetImageSubresourceLayout" + vkGetImageSubresourceLayout :: + VkDevice -- ^ device + -> + VkImage -- ^ image + -> + Ptr VkImageSubresource -- ^ pSubresource + -> Ptr VkSubresourceLayout -- ^ pLayout + -> IO () + +-- | Success codes: 'VK_SUCCESS'. +-- +-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. +-- +-- > VkResult vkCreateImageView +-- > ( VkDevice device +-- > , const VkImageViewCreateInfo* pCreateInfo +-- > , const VkAllocationCallbacks* pAllocator +-- > , VkImageView* pView +-- > ) +-- +-- +foreign import ccall unsafe "vkCreateImageView" vkCreateImageView + :: + VkDevice -- ^ device + -> + Ptr VkImageViewCreateInfo -- ^ pCreateInfo + -> + Ptr VkAllocationCallbacks -- ^ pAllocator + -> Ptr VkImageView -- ^ pView + -> IO VkResult + +-- | > () vkDestroyImageView +-- > ( VkDevice device +-- > , VkImageView imageView +-- > , const VkAllocationCallbacks* pAllocator +-- > ) +-- +-- +foreign import ccall unsafe "vkDestroyImageView" vkDestroyImageView + :: VkDevice -- ^ device + -> VkImageView -- ^ imageView + -> Ptr VkAllocationCallbacks -- ^ pAllocator + -> IO () + +-- | Success codes: 'VK_SUCCESS'. +-- +-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_INVALID_SHADER_NV'. +-- +-- > VkResult vkCreateShaderModule +-- > ( VkDevice device +-- > , const VkShaderModuleCreateInfo* pCreateInfo +-- > , const VkAllocationCallbacks* pAllocator +-- > , VkShaderModule* pShaderModule +-- > ) +-- +-- +foreign import ccall unsafe "vkCreateShaderModule" + vkCreateShaderModule :: + VkDevice -- ^ device + -> + Ptr VkShaderModuleCreateInfo -- ^ pCreateInfo + -> + Ptr VkAllocationCallbacks -- ^ pAllocator + -> Ptr VkShaderModule -- ^ pShaderModule + -> IO VkResult + +-- | > () vkDestroyShaderModule +-- > ( VkDevice device +-- > , VkShaderModule shaderModule +-- > , const VkAllocationCallbacks* pAllocator +-- > ) +-- +-- +foreign import ccall unsafe "vkDestroyShaderModule" + vkDestroyShaderModule :: + VkDevice -- ^ device + -> VkShaderModule -- ^ shaderModule + -> Ptr VkAllocationCallbacks -- ^ pAllocator + -> IO () + +-- | Success codes: 'VK_SUCCESS'. +-- +-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. +-- +-- > VkResult vkCreatePipelineCache +-- > ( VkDevice device +-- > , const VkPipelineCacheCreateInfo* pCreateInfo +-- > , const VkAllocationCallbacks* pAllocator +-- > , VkPipelineCache* pPipelineCache +-- > ) +-- +-- +foreign import ccall unsafe "vkCreatePipelineCache" + vkCreatePipelineCache :: + VkDevice -- ^ device + -> + Ptr VkPipelineCacheCreateInfo -- ^ pCreateInfo + -> + Ptr VkAllocationCallbacks -- ^ pAllocator + -> Ptr VkPipelineCache -- ^ pPipelineCache + -> IO VkResult + +-- | > () vkDestroyPipelineCache +-- > ( VkDevice device +-- > , VkPipelineCache pipelineCache +-- > , const VkAllocationCallbacks* pAllocator +-- > ) +-- +-- +foreign import ccall unsafe "vkDestroyPipelineCache" + vkDestroyPipelineCache :: + VkDevice -- ^ device + -> VkPipelineCache -- ^ pipelineCache + -> Ptr VkAllocationCallbacks -- ^ pAllocator + -> IO () + +-- | Success codes: 'VK_SUCCESS', 'VK_INCOMPLETE'. +-- +-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. +-- +-- > VkResult vkGetPipelineCacheData +-- > ( VkDevice device +-- > , VkPipelineCache pipelineCache +-- > , size_t* pDataSize +-- > , void* pData +-- > ) +-- +-- +foreign import ccall unsafe "vkGetPipelineCacheData" + vkGetPipelineCacheData :: + VkDevice -- ^ device + -> VkPipelineCache -- ^ pipelineCache + -> Ptr CSize -- ^ pDataSize + -> Ptr Void -- ^ pData + -> IO VkResult + +-- | Success codes: 'VK_SUCCESS'. +-- +-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. +-- +-- > VkResult vkMergePipelineCaches +-- > ( VkDevice device +-- > , VkPipelineCache dstCache +-- > , uint32_t srcCacheCount +-- > , const VkPipelineCache* pSrcCaches +-- > ) +-- +-- +foreign import ccall unsafe "vkMergePipelineCaches" + vkMergePipelineCaches :: + VkDevice -- ^ device + -> + VkPipelineCache -- ^ dstCache + -> Word32 -- ^ srcCacheCount + -> Ptr VkPipelineCache -- ^ pSrcCaches + -> IO VkResult + +-- | Success codes: 'VK_SUCCESS'. +-- +-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_INVALID_SHADER_NV'. +-- +-- > VkResult vkCreateGraphicsPipelines +-- > ( VkDevice device +-- > , VkPipelineCache pipelineCache +-- > , uint32_t createInfoCount +-- > , const VkGraphicsPipelineCreateInfo* pCreateInfos +-- > , const VkAllocationCallbacks* pAllocator +-- > , VkPipeline* pPipelines +-- > ) +-- +-- +foreign import ccall unsafe "vkCreateGraphicsPipelines" + vkCreateGraphicsPipelines :: + VkDevice -- ^ device + -> + VkPipelineCache -- ^ pipelineCache + -> + Word32 -- ^ createInfoCount + -> + Ptr VkGraphicsPipelineCreateInfo -- ^ pCreateInfos + -> + Ptr VkAllocationCallbacks -- ^ pAllocator + -> Ptr VkPipeline -- ^ pPipelines + -> IO VkResult + +-- | Success codes: 'VK_SUCCESS'. +-- +-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_INVALID_SHADER_NV'. +-- +-- > VkResult vkCreateComputePipelines +-- > ( VkDevice device +-- > , VkPipelineCache pipelineCache +-- > , uint32_t createInfoCount +-- > , const VkComputePipelineCreateInfo* pCreateInfos +-- > , const VkAllocationCallbacks* pAllocator +-- > , VkPipeline* pPipelines +-- > ) +-- +-- +foreign import ccall unsafe "vkCreateComputePipelines" + vkCreateComputePipelines :: + VkDevice -- ^ device + -> + VkPipelineCache -- ^ pipelineCache + -> + Word32 -- ^ createInfoCount + -> + Ptr VkComputePipelineCreateInfo -- ^ pCreateInfos + -> + Ptr VkAllocationCallbacks -- ^ pAllocator + -> Ptr VkPipeline -- ^ pPipelines + -> IO VkResult + +-- | > () vkDestroyPipeline +-- > ( VkDevice device +-- > , VkPipeline pipeline +-- > , const VkAllocationCallbacks* pAllocator +-- > ) +-- +-- +foreign import ccall unsafe "vkDestroyPipeline" vkDestroyPipeline + :: VkDevice -- ^ device + -> VkPipeline -- ^ pipeline + -> Ptr VkAllocationCallbacks -- ^ pAllocator + -> IO () + +-- | Success codes: 'VK_SUCCESS'. +-- +-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. +-- +-- > VkResult vkCreatePipelineLayout +-- > ( VkDevice device +-- > , const VkPipelineLayoutCreateInfo* pCreateInfo +-- > , const VkAllocationCallbacks* pAllocator +-- > , VkPipelineLayout* pPipelineLayout +-- > ) +-- +-- +foreign import ccall unsafe "vkCreatePipelineLayout" + vkCreatePipelineLayout :: + VkDevice -- ^ device + -> + Ptr VkPipelineLayoutCreateInfo -- ^ pCreateInfo + -> + Ptr VkAllocationCallbacks -- ^ pAllocator + -> Ptr VkPipelineLayout -- ^ pPipelineLayout + -> IO VkResult + +-- | > () vkDestroyPipelineLayout +-- > ( VkDevice device +-- > , VkPipelineLayout pipelineLayout +-- > , const VkAllocationCallbacks* pAllocator +-- > ) +-- +-- +foreign import ccall unsafe "vkDestroyPipelineLayout" + vkDestroyPipelineLayout :: + VkDevice -- ^ device + -> VkPipelineLayout -- ^ pipelineLayout + -> Ptr VkAllocationCallbacks -- ^ pAllocator + -> IO () + +-- | Success codes: 'VK_SUCCESS'. +-- +-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_TOO_MANY_OBJECTS'. +-- +-- > VkResult vkCreateSampler +-- > ( VkDevice device +-- > , const VkSamplerCreateInfo* pCreateInfo +-- > , const VkAllocationCallbacks* pAllocator +-- > , VkSampler* pSampler +-- > ) +-- +-- +foreign import ccall unsafe "vkCreateSampler" vkCreateSampler :: + VkDevice -- ^ device + -> + Ptr VkSamplerCreateInfo -- ^ pCreateInfo + -> + Ptr VkAllocationCallbacks -- ^ pAllocator + -> Ptr VkSampler -- ^ pSampler + -> IO VkResult + +-- | > () vkDestroySampler +-- > ( VkDevice device +-- > , VkSampler sampler +-- > , const VkAllocationCallbacks* pAllocator +-- > ) +-- +-- +foreign import ccall unsafe "vkDestroySampler" vkDestroySampler :: + VkDevice -- ^ device + -> VkSampler -- ^ sampler + -> Ptr VkAllocationCallbacks -- ^ pAllocator + -> IO () + +-- | Success codes: 'VK_SUCCESS'. +-- +-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. +-- +-- > VkResult vkCreateDescriptorSetLayout +-- > ( VkDevice device +-- > , const VkDescriptorSetLayoutCreateInfo* pCreateInfo +-- > , const VkAllocationCallbacks* pAllocator +-- > , VkDescriptorSetLayout* pSetLayout +-- > ) +-- +-- +foreign import ccall unsafe "vkCreateDescriptorSetLayout" + vkCreateDescriptorSetLayout :: + VkDevice -- ^ device + -> + Ptr VkDescriptorSetLayoutCreateInfo -- ^ pCreateInfo + -> + Ptr VkAllocationCallbacks -- ^ pAllocator + -> + Ptr VkDescriptorSetLayout -- ^ pSetLayout + -> IO VkResult + +-- | > () vkDestroyDescriptorSetLayout +-- > ( VkDevice device +-- > , VkDescriptorSetLayout descriptorSetLayout +-- > , const VkAllocationCallbacks* pAllocator +-- > ) +-- +-- +foreign import ccall unsafe "vkDestroyDescriptorSetLayout" + vkDestroyDescriptorSetLayout :: + VkDevice -- ^ device + -> + VkDescriptorSetLayout -- ^ descriptorSetLayout + -> Ptr VkAllocationCallbacks -- ^ pAllocator + -> IO () + +-- | Success codes: 'VK_SUCCESS'. +-- +-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. +-- +-- > VkResult vkCreateDescriptorPool +-- > ( VkDevice device +-- > , const VkDescriptorPoolCreateInfo* pCreateInfo +-- > , const VkAllocationCallbacks* pAllocator +-- > , VkDescriptorPool* pDescriptorPool +-- > ) +-- +-- +foreign import ccall unsafe "vkCreateDescriptorPool" + vkCreateDescriptorPool :: + VkDevice -- ^ device + -> + Ptr VkDescriptorPoolCreateInfo -- ^ pCreateInfo + -> + Ptr VkAllocationCallbacks -- ^ pAllocator + -> Ptr VkDescriptorPool -- ^ pDescriptorPool + -> IO VkResult + +-- | > () vkDestroyDescriptorPool +-- > ( VkDevice device +-- > , VkDescriptorPool descriptorPool +-- > , const VkAllocationCallbacks* pAllocator +-- > ) +-- +-- +foreign import ccall unsafe "vkDestroyDescriptorPool" + vkDestroyDescriptorPool :: + VkDevice -- ^ device + -> VkDescriptorPool -- ^ descriptorPool + -> Ptr VkAllocationCallbacks -- ^ pAllocator + -> IO () + +-- | Success codes: 'VK_SUCCESS'. +-- +-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. +-- +-- > VkResult vkResetDescriptorPool +-- > ( VkDevice device +-- > , VkDescriptorPool descriptorPool +-- > , VkDescriptorPoolResetFlags flags +-- > ) +-- +-- +foreign import ccall unsafe "vkResetDescriptorPool" + vkResetDescriptorPool :: + VkDevice -- ^ device + -> + VkDescriptorPool -- ^ descriptorPool + -> VkDescriptorPoolResetFlags -- ^ flags + -> IO VkResult + +-- | Success codes: 'VK_SUCCESS'. +-- +-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_FRAGMENTED_POOL', 'VK_ERROR_OUT_OF_POOL_MEMORY_KHR'. +-- +-- > VkResult vkAllocateDescriptorSets +-- > ( VkDevice device +-- > , const VkDescriptorSetAllocateInfo* pAllocateInfo +-- > , VkDescriptorSet* pDescriptorSets +-- > ) +-- +-- +foreign import ccall unsafe "vkAllocateDescriptorSets" + vkAllocateDescriptorSets :: + VkDevice -- ^ device + -> + Ptr VkDescriptorSetAllocateInfo -- ^ pAllocateInfo + -> + Ptr VkDescriptorSet -- ^ pDescriptorSets + -> IO VkResult + +-- | Success codes: 'VK_SUCCESS'. +-- +-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. +-- +-- > VkResult vkFreeDescriptorSets +-- > ( VkDevice device +-- > , VkDescriptorPool descriptorPool +-- > , uint32_t descriptorSetCount +-- > , const VkDescriptorSet* pDescriptorSets +-- > ) +-- +-- +foreign import ccall unsafe "vkFreeDescriptorSets" + vkFreeDescriptorSets :: + VkDevice -- ^ device + -> + VkDescriptorPool -- ^ descriptorPool + -> Word32 -- ^ descriptorSetCount + -> Ptr VkDescriptorSet -- ^ pDescriptorSets + -> IO VkResult + +-- | > () vkUpdateDescriptorSets +-- > ( VkDevice device +-- > , uint32_t descriptorWriteCount +-- > , const VkWriteDescriptorSet* pDescriptorWrites +-- > , uint32_t descriptorCopyCount +-- > , const VkCopyDescriptorSet* pDescriptorCopies +-- > ) +-- +-- +foreign import ccall unsafe "vkUpdateDescriptorSets" + vkUpdateDescriptorSets :: + VkDevice -- ^ device + -> + Word32 -- ^ descriptorWriteCount + -> + Ptr VkWriteDescriptorSet -- ^ pDescriptorWrites + -> + Word32 -- ^ descriptorCopyCount + -> Ptr VkCopyDescriptorSet -- ^ pDescriptorCopies + -> IO () + +-- | Success codes: 'VK_SUCCESS'. +-- +-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. +-- +-- > VkResult vkCreateFramebuffer +-- > ( VkDevice device +-- > , const VkFramebufferCreateInfo* pCreateInfo +-- > , const VkAllocationCallbacks* pAllocator +-- > , VkFramebuffer* pFramebuffer +-- > ) +-- +-- +foreign import ccall unsafe "vkCreateFramebuffer" + vkCreateFramebuffer :: + VkDevice -- ^ device + -> + Ptr VkFramebufferCreateInfo -- ^ pCreateInfo + -> + Ptr VkAllocationCallbacks -- ^ pAllocator + -> Ptr VkFramebuffer -- ^ pFramebuffer + -> IO VkResult + +-- | > () vkDestroyFramebuffer +-- > ( VkDevice device +-- > , VkFramebuffer framebuffer +-- > , const VkAllocationCallbacks* pAllocator +-- > ) +-- +-- +foreign import ccall unsafe "vkDestroyFramebuffer" + vkDestroyFramebuffer :: + VkDevice -- ^ device + -> VkFramebuffer -- ^ framebuffer + -> Ptr VkAllocationCallbacks -- ^ pAllocator + -> IO () + +-- | Success codes: 'VK_SUCCESS'. +-- +-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. +-- +-- > VkResult vkCreateRenderPass +-- > ( VkDevice device +-- > , const VkRenderPassCreateInfo* pCreateInfo +-- > , const VkAllocationCallbacks* pAllocator +-- > , VkRenderPass* pRenderPass +-- > ) +-- +-- +foreign import ccall unsafe "vkCreateRenderPass" vkCreateRenderPass + :: + VkDevice -- ^ device + -> + Ptr VkRenderPassCreateInfo -- ^ pCreateInfo + -> + Ptr VkAllocationCallbacks -- ^ pAllocator + -> Ptr VkRenderPass -- ^ pRenderPass + -> IO VkResult + +-- | > () vkDestroyRenderPass +-- > ( VkDevice device +-- > , VkRenderPass renderPass +-- > , const VkAllocationCallbacks* pAllocator +-- > ) +-- +-- +foreign import ccall unsafe "vkDestroyRenderPass" + vkDestroyRenderPass :: + VkDevice -- ^ device + -> VkRenderPass -- ^ renderPass + -> Ptr VkAllocationCallbacks -- ^ pAllocator + -> IO () + +-- | > () vkGetRenderAreaGranularity +-- > ( VkDevice device +-- > , VkRenderPass renderPass +-- > , VkExtent2D* pGranularity +-- > ) +-- +-- +foreign import ccall unsafe "vkGetRenderAreaGranularity" + vkGetRenderAreaGranularity :: + VkDevice -- ^ device + -> VkRenderPass -- ^ renderPass + -> Ptr VkExtent2D -- ^ pGranularity + -> IO () + +-- | Success codes: 'VK_SUCCESS'. +-- +-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. +-- +-- > VkResult vkCreateCommandPool +-- > ( VkDevice device +-- > , const VkCommandPoolCreateInfo* pCreateInfo +-- > , const VkAllocationCallbacks* pAllocator +-- > , VkCommandPool* pCommandPool +-- > ) +-- +-- +foreign import ccall unsafe "vkCreateCommandPool" + vkCreateCommandPool :: + VkDevice -- ^ device + -> + Ptr VkCommandPoolCreateInfo -- ^ pCreateInfo + -> + Ptr VkAllocationCallbacks -- ^ pAllocator + -> Ptr VkCommandPool -- ^ pCommandPool + -> IO VkResult + +-- | > () vkDestroyCommandPool +-- > ( VkDevice device +-- > , VkCommandPool commandPool +-- > , const VkAllocationCallbacks* pAllocator +-- > ) +-- +-- +foreign import ccall unsafe "vkDestroyCommandPool" + vkDestroyCommandPool :: + VkDevice -- ^ device + -> VkCommandPool -- ^ commandPool + -> Ptr VkAllocationCallbacks -- ^ pAllocator + -> IO () + +-- | Success codes: 'VK_SUCCESS'. +-- +-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. +-- +-- > VkResult vkResetCommandPool +-- > ( VkDevice device +-- > , VkCommandPool commandPool +-- > , VkCommandPoolResetFlags flags +-- > ) +-- +-- +foreign import ccall unsafe "vkResetCommandPool" vkResetCommandPool + :: + VkDevice -- ^ device + -> VkCommandPool -- ^ commandPool + -> VkCommandPoolResetFlags -- ^ flags + -> IO VkResult + +-- | Success codes: 'VK_SUCCESS'. +-- +-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. +-- +-- > VkResult vkAllocateCommandBuffers +-- > ( VkDevice device +-- > , const VkCommandBufferAllocateInfo* pAllocateInfo +-- > , VkCommandBuffer* pCommandBuffers +-- > ) +-- +-- +foreign import ccall unsafe "vkAllocateCommandBuffers" + vkAllocateCommandBuffers :: + VkDevice -- ^ device + -> + Ptr VkCommandBufferAllocateInfo -- ^ pAllocateInfo + -> + Ptr VkCommandBuffer -- ^ pCommandBuffers + -> IO VkResult + +-- | > () vkFreeCommandBuffers +-- > ( VkDevice device +-- > , VkCommandPool commandPool +-- > , uint32_t commandBufferCount +-- > , const VkCommandBuffer* pCommandBuffers +-- > ) +-- +-- +foreign import ccall unsafe "vkFreeCommandBuffers" + vkFreeCommandBuffers :: + VkDevice -- ^ device + -> VkCommandPool -- ^ commandPool + -> Word32 -- ^ commandBufferCount + -> Ptr VkCommandBuffer -- ^ pCommandBuffers + -> IO () + +-- | Success codes: 'VK_SUCCESS'. +-- +-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. +-- +-- > VkResult vkBeginCommandBuffer +-- > ( VkCommandBuffer commandBuffer +-- > , const VkCommandBufferBeginInfo* pBeginInfo +-- > ) +-- +-- +foreign import ccall unsafe "vkBeginCommandBuffer" + vkBeginCommandBuffer :: + VkCommandBuffer -- ^ commandBuffer + -> Ptr VkCommandBufferBeginInfo -- ^ pBeginInfo + -> IO VkResult + +-- | Success codes: 'VK_SUCCESS'. +-- +-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. +-- +-- > VkResult vkEndCommandBuffer +-- > ( VkCommandBuffer commandBuffer +-- > ) +-- +-- +foreign import ccall unsafe "vkEndCommandBuffer" vkEndCommandBuffer + :: VkCommandBuffer -- ^ commandBuffer + -> IO VkResult + +-- | Success codes: 'VK_SUCCESS'. +-- +-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. +-- +-- > VkResult vkResetCommandBuffer +-- > ( VkCommandBuffer commandBuffer +-- > , VkCommandBufferResetFlags flags +-- > ) +-- +-- +foreign import ccall unsafe "vkResetCommandBuffer" + vkResetCommandBuffer :: + VkCommandBuffer -- ^ commandBuffer + -> VkCommandBufferResetFlags -- ^ flags + -> IO VkResult + +-- | queues: 'graphics', 'compute'. +-- +-- renderpass: @both@ +-- +-- > () vkCmdBindPipeline +-- > ( VkCommandBuffer commandBuffer +-- > , VkPipelineBindPoint pipelineBindPoint +-- > , VkPipeline pipeline +-- > ) +-- +-- +foreign import ccall unsafe "vkCmdBindPipeline" vkCmdBindPipeline + :: VkCommandBuffer -- ^ commandBuffer + -> VkPipelineBindPoint -- ^ pipelineBindPoint + -> VkPipeline -- ^ pipeline + -> IO () + +-- | queues: 'graphics'. +-- +-- renderpass: @both@ +-- +-- > () vkCmdSetViewport +-- > ( VkCommandBuffer commandBuffer +-- > , uint32_t firstViewport +-- > , uint32_t viewportCount +-- > , const VkViewport* pViewports +-- > ) +-- +-- +foreign import ccall unsafe "vkCmdSetViewport" vkCmdSetViewport :: + VkCommandBuffer -- ^ commandBuffer + -> Word32 -- ^ firstViewport + -> Word32 -- ^ viewportCount + -> Ptr VkViewport -- ^ pViewports + -> IO () + +-- | queues: 'graphics'. +-- +-- renderpass: @both@ +-- +-- > () vkCmdSetScissor +-- > ( VkCommandBuffer commandBuffer +-- > , uint32_t firstScissor +-- > , uint32_t scissorCount +-- > , const VkRect2D* pScissors +-- > ) +-- +-- +foreign import ccall unsafe "vkCmdSetScissor" vkCmdSetScissor :: + VkCommandBuffer -- ^ commandBuffer + -> Word32 -- ^ firstScissor + -> Word32 -- ^ scissorCount + -> Ptr VkRect2D -- ^ pScissors + -> IO () + +-- | queues: 'graphics'. +-- +-- renderpass: @both@ +-- +-- > () vkCmdSetLineWidth +-- > ( VkCommandBuffer commandBuffer +-- > , float lineWidth +-- > ) +-- +-- +foreign import ccall unsafe "vkCmdSetLineWidth" vkCmdSetLineWidth + :: VkCommandBuffer -- ^ commandBuffer + -> #{type float} -> IO () + +-- | queues: 'graphics'. +-- +-- renderpass: @both@ +-- +-- > () vkCmdSetDepthBias +-- > ( VkCommandBuffer commandBuffer +-- > , float depthBiasConstantFactor +-- > , float depthBiasClamp +-- > , float depthBiasSlopeFactor +-- > ) +-- +-- +foreign import ccall unsafe "vkCmdSetDepthBias" vkCmdSetDepthBias + :: + VkCommandBuffer -- ^ commandBuffer + -> + #{type float} -> + #{type float} -> #{type float} -> IO () + +-- | queues: 'graphics'. +-- +-- renderpass: @both@ +-- +-- > () vkCmdSetBlendConstants +-- > ( VkCommandBuffer commandBuffer +-- > , const float blendConstants[4] +-- > ) +-- +-- +foreign import ccall unsafe "vkCmdSetBlendConstants" + vkCmdSetBlendConstants :: + VkCommandBuffer -- ^ commandBuffer + -> Ptr #{type float} -- ^ blendConstants + -> IO () + +-- | queues: 'graphics'. +-- +-- renderpass: @both@ +-- +-- > () vkCmdSetDepthBounds +-- > ( VkCommandBuffer commandBuffer +-- > , float minDepthBounds +-- > , float maxDepthBounds +-- > ) +-- +-- +foreign import ccall unsafe "vkCmdSetDepthBounds" + vkCmdSetDepthBounds :: + VkCommandBuffer -- ^ commandBuffer + -> + #{type float} -> #{type float} -> IO () + +-- | queues: 'graphics'. +-- +-- renderpass: @both@ +-- +-- > () vkCmdSetStencilCompareMask +-- > ( VkCommandBuffer commandBuffer +-- > , VkStencilFaceFlags faceMask +-- > , uint32_t compareMask +-- > ) +-- +-- +foreign import ccall unsafe "vkCmdSetStencilCompareMask" + vkCmdSetStencilCompareMask :: + VkCommandBuffer -- ^ commandBuffer + -> VkStencilFaceFlags -- ^ faceMask + -> Word32 -- ^ compareMask + -> IO () + +-- | queues: 'graphics'. +-- +-- renderpass: @both@ +-- +-- > () vkCmdSetStencilWriteMask +-- > ( VkCommandBuffer commandBuffer +-- > , VkStencilFaceFlags faceMask +-- > , uint32_t writeMask +-- > ) +-- +-- +foreign import ccall unsafe "vkCmdSetStencilWriteMask" + vkCmdSetStencilWriteMask :: + VkCommandBuffer -- ^ commandBuffer + -> VkStencilFaceFlags -- ^ faceMask + -> Word32 -- ^ writeMask + -> IO () + +-- | queues: 'graphics'. +-- +-- renderpass: @both@ +-- +-- > () vkCmdSetStencilReference +-- > ( VkCommandBuffer commandBuffer +-- > , VkStencilFaceFlags faceMask +-- > , uint32_t reference +-- > ) +-- +-- +foreign import ccall unsafe "vkCmdSetStencilReference" + vkCmdSetStencilReference :: + VkCommandBuffer -- ^ commandBuffer + -> VkStencilFaceFlags -- ^ faceMask + -> Word32 -- ^ reference + -> IO () + +-- | queues: 'graphics', 'compute'. +-- +-- renderpass: @both@ +-- +-- > () vkCmdBindDescriptorSets +-- > ( VkCommandBuffer commandBuffer +-- > , VkPipelineBindPoint pipelineBindPoint +-- > , VkPipelineLayout layout +-- > , uint32_t firstSet +-- > , uint32_t descriptorSetCount +-- > , const VkDescriptorSet* pDescriptorSets +-- > , uint32_t dynamicOffsetCount +-- > , const uint32_t* pDynamicOffsets +-- > ) +-- +-- +foreign import ccall unsafe "vkCmdBindDescriptorSets" + vkCmdBindDescriptorSets :: + VkCommandBuffer -- ^ commandBuffer + -> + VkPipelineBindPoint -- ^ pipelineBindPoint + -> + VkPipelineLayout -- ^ layout + -> + Word32 -- ^ firstSet + -> + Word32 -- ^ descriptorSetCount + -> Ptr VkDescriptorSet -- ^ pDescriptorSets + -> Word32 -- ^ dynamicOffsetCount + -> Ptr Word32 -- ^ pDynamicOffsets + -> IO () + +-- | queues: 'graphics'. +-- +-- renderpass: @both@ +-- +-- > () vkCmdBindIndexBuffer +-- > ( VkCommandBuffer commandBuffer +-- > , VkBuffer buffer +-- > , VkDeviceSize offset +-- > , VkIndexType indexType +-- > ) +-- +-- +foreign import ccall unsafe "vkCmdBindIndexBuffer" + vkCmdBindIndexBuffer :: + VkCommandBuffer -- ^ commandBuffer + -> VkBuffer -- ^ buffer + -> VkDeviceSize -- ^ offset + -> VkIndexType -- ^ indexType + -> IO () + +-- | queues: 'graphics'. +-- +-- renderpass: @both@ +-- +-- > () vkCmdBindVertexBuffers +-- > ( VkCommandBuffer commandBuffer +-- > , uint32_t firstBinding +-- > , uint32_t bindingCount +-- > , const VkBuffer* pBuffers +-- > , const VkDeviceSize* pOffsets +-- > ) +-- +-- +foreign import ccall unsafe "vkCmdBindVertexBuffers" + vkCmdBindVertexBuffers :: + VkCommandBuffer -- ^ commandBuffer + -> + Word32 -- ^ firstBinding + -> Word32 -- ^ bindingCount + -> Ptr VkBuffer -- ^ pBuffers + -> Ptr VkDeviceSize -- ^ pOffsets + -> IO () + +-- | queues: 'graphics'. +-- +-- renderpass: @inside@ +-- +-- pipeline: @graphics@ +-- +-- > () vkCmdDraw +-- > ( VkCommandBuffer commandBuffer +-- > , uint32_t vertexCount +-- > , uint32_t instanceCount +-- > , uint32_t firstVertex +-- > , uint32_t firstInstance +-- > ) +-- +-- +foreign import ccall unsafe "vkCmdDraw" vkCmdDraw :: + VkCommandBuffer -- ^ commandBuffer + -> Word32 -- ^ vertexCount + -> Word32 -- ^ instanceCount + -> Word32 -- ^ firstVertex + -> Word32 -- ^ firstInstance + -> IO () + +-- | queues: 'graphics'. +-- +-- renderpass: @inside@ +-- +-- pipeline: @graphics@ +-- +-- > () vkCmdDrawIndexed +-- > ( VkCommandBuffer commandBuffer +-- > , uint32_t indexCount +-- > , uint32_t instanceCount +-- > , uint32_t firstIndex +-- > , int32_t vertexOffset +-- > , uint32_t firstInstance +-- > ) +-- +-- +foreign import ccall unsafe "vkCmdDrawIndexed" vkCmdDrawIndexed :: + VkCommandBuffer -- ^ commandBuffer + -> + Word32 -- ^ indexCount + -> Word32 -- ^ instanceCount + -> Word32 -- ^ firstIndex + -> Int32 -- ^ vertexOffset + -> Word32 -- ^ firstInstance + -> IO () + +-- | queues: 'graphics'. +-- +-- renderpass: @inside@ +-- +-- pipeline: @graphics@ +-- +-- > () vkCmdDrawIndirect +-- > ( VkCommandBuffer commandBuffer +-- > , VkBuffer buffer +-- > , VkDeviceSize offset +-- > , uint32_t drawCount +-- > , uint32_t stride +-- > ) +-- +-- +foreign import ccall unsafe "vkCmdDrawIndirect" vkCmdDrawIndirect + :: + VkCommandBuffer -- ^ commandBuffer + -> + VkBuffer -- ^ buffer + -> VkDeviceSize -- ^ offset + -> Word32 -- ^ drawCount + -> Word32 -- ^ stride + -> IO () + +-- | queues: 'graphics'. +-- +-- renderpass: @inside@ +-- +-- pipeline: @graphics@ +-- +-- > () vkCmdDrawIndexedIndirect +-- > ( VkCommandBuffer commandBuffer +-- > , VkBuffer buffer +-- > , VkDeviceSize offset +-- > , uint32_t drawCount +-- > , uint32_t stride +-- > ) +-- +-- +foreign import ccall unsafe "vkCmdDrawIndexedIndirect" + vkCmdDrawIndexedIndirect :: + VkCommandBuffer -- ^ commandBuffer + -> + VkBuffer -- ^ buffer + -> VkDeviceSize -- ^ offset + -> Word32 -- ^ drawCount + -> Word32 -- ^ stride + -> IO () + +-- | queues: 'compute'. +-- +-- renderpass: @outside@ +-- +-- pipeline: @compute@ +-- +-- > () vkCmdDispatch +-- > ( VkCommandBuffer commandBuffer +-- > , uint32_t groupCountX +-- > , uint32_t groupCountY +-- > , uint32_t groupCountZ +-- > ) +-- +-- +foreign import ccall unsafe "vkCmdDispatch" vkCmdDispatch :: + VkCommandBuffer -- ^ commandBuffer + -> Word32 -- ^ groupCountX + -> Word32 -- ^ groupCountY + -> Word32 -- ^ groupCountZ + -> IO () + +-- | queues: 'compute'. +-- +-- renderpass: @outside@ +-- +-- pipeline: @compute@ +-- +-- > () vkCmdDispatchIndirect +-- > ( VkCommandBuffer commandBuffer +-- > , VkBuffer buffer +-- > , VkDeviceSize offset +-- > ) +-- +-- +foreign import ccall unsafe "vkCmdDispatchIndirect" + vkCmdDispatchIndirect :: + VkCommandBuffer -- ^ commandBuffer + -> VkBuffer -- ^ buffer + -> VkDeviceSize -- ^ offset + -> IO () + +-- | queues: 'transfer', 'graphics', 'compute'. +-- +-- renderpass: @outside@ +-- +-- pipeline: @transfer@ +-- +-- > () vkCmdCopyBuffer +-- > ( VkCommandBuffer commandBuffer +-- > , VkBuffer srcBuffer +-- > , VkBuffer dstBuffer +-- > , uint32_t regionCount +-- > , const VkBufferCopy* pRegions +-- > ) +-- +-- +foreign import ccall unsafe "vkCmdCopyBuffer" vkCmdCopyBuffer :: + VkCommandBuffer -- ^ commandBuffer + -> + VkBuffer -- ^ srcBuffer + -> VkBuffer -- ^ dstBuffer + -> Word32 -- ^ regionCount + -> Ptr VkBufferCopy -- ^ pRegions + -> IO () + +-- | queues: 'transfer', 'graphics', 'compute'. +-- +-- renderpass: @outside@ +-- +-- pipeline: @transfer@ +-- +-- > () vkCmdCopyImage +-- > ( VkCommandBuffer commandBuffer +-- > , VkImage srcImage +-- > , VkImageLayout srcImageLayout +-- > , VkImage dstImage +-- > , VkImageLayout dstImageLayout +-- > , uint32_t regionCount +-- > , const VkImageCopy* pRegions +-- > ) +-- +-- +foreign import ccall unsafe "vkCmdCopyImage" vkCmdCopyImage :: + VkCommandBuffer -- ^ commandBuffer + -> + VkImage -- ^ srcImage + -> + VkImageLayout -- ^ srcImageLayout + -> + VkImage -- ^ dstImage + -> VkImageLayout -- ^ dstImageLayout + -> Word32 -- ^ regionCount + -> Ptr VkImageCopy -- ^ pRegions + -> IO () + +-- | queues: 'graphics'. +-- +-- renderpass: @outside@ +-- +-- pipeline: @transfer@ +-- +-- > () vkCmdBlitImage +-- > ( VkCommandBuffer commandBuffer +-- > , VkImage srcImage +-- > , VkImageLayout srcImageLayout +-- > , VkImage dstImage +-- > , VkImageLayout dstImageLayout +-- > , uint32_t regionCount +-- > , const VkImageBlit* pRegions +-- > , VkFilter filter +-- > ) +-- +-- +foreign import ccall unsafe "vkCmdBlitImage" vkCmdBlitImage :: + VkCommandBuffer -- ^ commandBuffer + -> + VkImage -- ^ srcImage + -> + VkImageLayout -- ^ srcImageLayout + -> + VkImage -- ^ dstImage + -> + VkImageLayout -- ^ dstImageLayout + -> Word32 -- ^ regionCount + -> Ptr VkImageBlit -- ^ pRegions + -> VkFilter -- ^ filter + -> IO () + +-- | queues: 'transfer', 'graphics', 'compute'. +-- +-- renderpass: @outside@ +-- +-- pipeline: @transfer@ +-- +-- > () vkCmdCopyBufferToImage +-- > ( VkCommandBuffer commandBuffer +-- > , VkBuffer srcBuffer +-- > , VkImage dstImage +-- > , VkImageLayout dstImageLayout +-- > , uint32_t regionCount +-- > , const VkBufferImageCopy* pRegions +-- > ) +-- +-- +foreign import ccall unsafe "vkCmdCopyBufferToImage" + vkCmdCopyBufferToImage :: + VkCommandBuffer -- ^ commandBuffer + -> + VkBuffer -- ^ srcBuffer + -> + VkImage -- ^ dstImage + -> + VkImageLayout -- ^ dstImageLayout + -> Word32 -- ^ regionCount + -> Ptr VkBufferImageCopy -- ^ pRegions + -> IO () + +-- | queues: 'transfer', 'graphics', 'compute'. +-- +-- renderpass: @outside@ +-- +-- pipeline: @transfer@ +-- +-- > () vkCmdCopyImageToBuffer +-- > ( VkCommandBuffer commandBuffer +-- > , VkImage srcImage +-- > , VkImageLayout srcImageLayout +-- > , VkBuffer dstBuffer +-- > , uint32_t regionCount +-- > , const VkBufferImageCopy* pRegions +-- > ) +-- +-- +foreign import ccall unsafe "vkCmdCopyImageToBuffer" + vkCmdCopyImageToBuffer :: + VkCommandBuffer -- ^ commandBuffer + -> + VkImage -- ^ srcImage + -> + VkImageLayout -- ^ srcImageLayout + -> + VkBuffer -- ^ dstBuffer + -> Word32 -- ^ regionCount + -> Ptr VkBufferImageCopy -- ^ pRegions + -> IO () + +-- | queues: 'transfer', 'graphics', 'compute'. +-- +-- renderpass: @outside@ +-- +-- pipeline: @transfer@ +-- +-- > () vkCmdUpdateBuffer +-- > ( VkCommandBuffer commandBuffer +-- > , VkBuffer dstBuffer +-- > , VkDeviceSize dstOffset +-- > , VkDeviceSize dataSize +-- > , const void* pData +-- > ) +-- +-- +foreign import ccall unsafe "vkCmdUpdateBuffer" vkCmdUpdateBuffer + :: + VkCommandBuffer -- ^ commandBuffer + -> + VkBuffer -- ^ dstBuffer + -> VkDeviceSize -- ^ dstOffset + -> VkDeviceSize -- ^ dataSize + -> Ptr Void -- ^ pData + -> IO () + +-- | transfer support is only available when VK_KHR_maintenance1 is enabled, as documented in valid usage language in the specification +-- +-- queues: 'transfer', 'graphics', 'compute'. +-- +-- renderpass: @outside@ +-- +-- pipeline: @transfer@ +-- +-- > () vkCmdFillBuffer +-- > ( VkCommandBuffer commandBuffer +-- > , VkBuffer dstBuffer +-- > , VkDeviceSize dstOffset +-- > , VkDeviceSize size +-- > , uint32_t data +-- > ) +-- +-- +foreign import ccall unsafe "vkCmdFillBuffer" vkCmdFillBuffer :: + VkCommandBuffer -- ^ commandBuffer + -> + VkBuffer -- ^ dstBuffer + -> VkDeviceSize -- ^ dstOffset + -> VkDeviceSize -- ^ size + -> Word32 -- ^ data + -> IO () + +-- | queues: 'graphics', 'compute'. +-- +-- renderpass: @outside@ +-- +-- pipeline: @transfer@ +-- +-- > () vkCmdClearColorImage +-- > ( VkCommandBuffer commandBuffer +-- > , VkImage image +-- > , VkImageLayout imageLayout +-- > , const VkClearColorValue* pColor +-- > , uint32_t rangeCount +-- > , const VkImageSubresourceRange* pRanges +-- > ) +-- +-- +foreign import ccall unsafe "vkCmdClearColorImage" + vkCmdClearColorImage :: + VkCommandBuffer -- ^ commandBuffer + -> + VkImage -- ^ image + -> + VkImageLayout -- ^ imageLayout + -> + Ptr VkClearColorValue -- ^ pColor + -> + Word32 -- ^ rangeCount + -> Ptr VkImageSubresourceRange -- ^ pRanges + -> IO () + +-- | queues: 'graphics'. +-- +-- renderpass: @outside@ +-- +-- pipeline: @transfer@ +-- +-- > () vkCmdClearDepthStencilImage +-- > ( VkCommandBuffer commandBuffer +-- > , VkImage image +-- > , VkImageLayout imageLayout +-- > , const VkClearDepthStencilValue* pDepthStencil +-- > , uint32_t rangeCount +-- > , const VkImageSubresourceRange* pRanges +-- > ) +-- +-- +foreign import ccall unsafe "vkCmdClearDepthStencilImage" + vkCmdClearDepthStencilImage :: + VkCommandBuffer -- ^ commandBuffer + -> + VkImage -- ^ image + -> + VkImageLayout -- ^ imageLayout + -> + Ptr VkClearDepthStencilValue -- ^ pDepthStencil + -> + Word32 -- ^ rangeCount + -> Ptr VkImageSubresourceRange -- ^ pRanges + -> IO () + +-- | queues: 'graphics'. +-- +-- renderpass: @inside@ +-- +-- pipeline: @graphics@ +-- +-- > () vkCmdClearAttachments +-- > ( VkCommandBuffer commandBuffer +-- > , uint32_t attachmentCount +-- > , const VkClearAttachment* pAttachments +-- > , uint32_t rectCount +-- > , const VkClearRect* pRects +-- > ) +-- +-- +foreign import ccall unsafe "vkCmdClearAttachments" + vkCmdClearAttachments :: + VkCommandBuffer -- ^ commandBuffer + -> + Word32 -- ^ attachmentCount + -> + Ptr VkClearAttachment -- ^ pAttachments + -> Word32 -- ^ rectCount + -> Ptr VkClearRect -- ^ pRects + -> IO () + +-- | queues: 'graphics'. +-- +-- renderpass: @outside@ +-- +-- pipeline: @transfer@ +-- +-- > () vkCmdResolveImage +-- > ( VkCommandBuffer commandBuffer +-- > , VkImage srcImage +-- > , VkImageLayout srcImageLayout +-- > , VkImage dstImage +-- > , VkImageLayout dstImageLayout +-- > , uint32_t regionCount +-- > , const VkImageResolve* pRegions +-- > ) +-- +-- +foreign import ccall unsafe "vkCmdResolveImage" vkCmdResolveImage + :: + VkCommandBuffer -- ^ commandBuffer + -> + VkImage -- ^ srcImage + -> + VkImageLayout -- ^ srcImageLayout + -> + VkImage -- ^ dstImage + -> VkImageLayout -- ^ dstImageLayout + -> Word32 -- ^ regionCount + -> Ptr VkImageResolve -- ^ pRegions + -> IO () + +-- | queues: 'graphics', 'compute'. +-- +-- renderpass: @outside@ +-- +-- > () vkCmdSetEvent +-- > ( VkCommandBuffer commandBuffer +-- > , VkEvent event +-- > , VkPipelineStageFlags stageMask +-- > ) +-- +-- +foreign import ccall unsafe "vkCmdSetEvent" vkCmdSetEvent :: + VkCommandBuffer -- ^ commandBuffer + -> VkEvent -- ^ event + -> VkPipelineStageFlags -- ^ stageMask + -> IO () + +-- | queues: 'graphics', 'compute'. +-- +-- renderpass: @outside@ +-- +-- > () vkCmdResetEvent +-- > ( VkCommandBuffer commandBuffer +-- > , VkEvent event +-- > , VkPipelineStageFlags stageMask +-- > ) +-- +-- +foreign import ccall unsafe "vkCmdResetEvent" vkCmdResetEvent :: + VkCommandBuffer -- ^ commandBuffer + -> VkEvent -- ^ event + -> VkPipelineStageFlags -- ^ stageMask + -> IO () + +-- | queues: 'graphics', 'compute'. +-- +-- renderpass: @both@ +-- +-- > () vkCmdWaitEvents +-- > ( VkCommandBuffer commandBuffer +-- > , uint32_t eventCount +-- > , const VkEvent* pEvents +-- > , VkPipelineStageFlags srcStageMask +-- > , VkPipelineStageFlags dstStageMask +-- > , uint32_t memoryBarrierCount +-- > , const VkMemoryBarrier* pMemoryBarriers +-- > , uint32_t bufferMemoryBarrierCount +-- > , const VkBufferMemoryBarrier* pBufferMemoryBarriers +-- > , uint32_t imageMemoryBarrierCount +-- > , const VkImageMemoryBarrier* pImageMemoryBarriers +-- > ) +-- +-- +foreign import ccall unsafe "vkCmdWaitEvents" vkCmdWaitEvents :: + VkCommandBuffer -- ^ commandBuffer + -> + Word32 -- ^ eventCount + -> + Ptr VkEvent -- ^ pEvents + -> + VkPipelineStageFlags -- ^ srcStageMask + -> + VkPipelineStageFlags -- ^ dstStageMask + -> + Word32 -- ^ memoryBarrierCount + -> + Ptr VkMemoryBarrier -- ^ pMemoryBarriers + -> + Word32 -- ^ bufferMemoryBarrierCount + -> + Ptr VkBufferMemoryBarrier -- ^ pBufferMemoryBarriers + -> + Word32 -- ^ imageMemoryBarrierCount + -> Ptr VkImageMemoryBarrier -- ^ pImageMemoryBarriers + -> IO () + +-- | queues: 'transfer', 'graphics', 'compute'. +-- +-- renderpass: @both@ +-- +-- > () vkCmdPipelineBarrier +-- > ( VkCommandBuffer commandBuffer +-- > , VkPipelineStageFlags srcStageMask +-- > , VkPipelineStageFlags dstStageMask +-- > , VkDependencyFlags dependencyFlags +-- > , uint32_t memoryBarrierCount +-- > , const VkMemoryBarrier* pMemoryBarriers +-- > , uint32_t bufferMemoryBarrierCount +-- > , const VkBufferMemoryBarrier* pBufferMemoryBarriers +-- > , uint32_t imageMemoryBarrierCount +-- > , const VkImageMemoryBarrier* pImageMemoryBarriers +-- > ) +-- +-- +foreign import ccall unsafe "vkCmdPipelineBarrier" + vkCmdPipelineBarrier :: + VkCommandBuffer -- ^ commandBuffer + -> + VkPipelineStageFlags -- ^ srcStageMask + -> + VkPipelineStageFlags -- ^ dstStageMask + -> + VkDependencyFlags -- ^ dependencyFlags + -> + Word32 -- ^ memoryBarrierCount + -> + Ptr VkMemoryBarrier -- ^ pMemoryBarriers + -> + Word32 -- ^ bufferMemoryBarrierCount + -> + Ptr VkBufferMemoryBarrier -- ^ pBufferMemoryBarriers + -> + Word32 -- ^ imageMemoryBarrierCount + -> Ptr VkImageMemoryBarrier -- ^ pImageMemoryBarriers + -> IO () + +-- | queues: 'graphics', 'compute'. +-- +-- renderpass: @both@ +-- +-- > () vkCmdBeginQuery +-- > ( VkCommandBuffer commandBuffer +-- > , VkQueryPool queryPool +-- > , uint32_t query +-- > , VkQueryControlFlags flags +-- > ) +-- +-- +foreign import ccall unsafe "vkCmdBeginQuery" vkCmdBeginQuery :: + VkCommandBuffer -- ^ commandBuffer + -> + VkQueryPool -- ^ queryPool + -> Word32 -- ^ query + -> VkQueryControlFlags -- ^ flags + -> IO () + +-- | queues: 'graphics', 'compute'. +-- +-- renderpass: @both@ +-- +-- > () vkCmdEndQuery +-- > ( VkCommandBuffer commandBuffer +-- > , VkQueryPool queryPool +-- > , uint32_t query +-- > ) +-- +-- +foreign import ccall unsafe "vkCmdEndQuery" vkCmdEndQuery :: + VkCommandBuffer -- ^ commandBuffer + -> VkQueryPool -- ^ queryPool + -> Word32 -- ^ query + -> IO () + +-- | queues: 'graphics', 'compute'. +-- +-- renderpass: @outside@ +-- +-- > () vkCmdResetQueryPool +-- > ( VkCommandBuffer commandBuffer +-- > , VkQueryPool queryPool +-- > , uint32_t firstQuery +-- > , uint32_t queryCount +-- > ) +-- +-- +foreign import ccall unsafe "vkCmdResetQueryPool" + vkCmdResetQueryPool :: + VkCommandBuffer -- ^ commandBuffer + -> VkQueryPool -- ^ queryPool + -> Word32 -- ^ firstQuery + -> Word32 -- ^ queryCount + -> IO () + +-- | queues: 'transfer', 'graphics', 'compute'. +-- +-- renderpass: @both@ +-- +-- pipeline: @transfer@ +-- +-- > () vkCmdWriteTimestamp +-- > ( VkCommandBuffer commandBuffer +-- > , VkPipelineStageFlagBits pipelineStage +-- > , VkQueryPool queryPool +-- > , uint32_t query +-- > ) +-- +-- +foreign import ccall unsafe "vkCmdWriteTimestamp" + vkCmdWriteTimestamp :: + VkCommandBuffer -- ^ commandBuffer + -> + VkPipelineStageFlagBits -- ^ pipelineStage + -> VkQueryPool -- ^ queryPool + -> Word32 -- ^ query + -> IO () + +-- | queues: 'graphics', 'compute'. +-- +-- renderpass: @outside@ +-- +-- pipeline: @transfer@ +-- +-- > () vkCmdCopyQueryPoolResults +-- > ( VkCommandBuffer commandBuffer +-- > , VkQueryPool queryPool +-- > , uint32_t firstQuery +-- > , uint32_t queryCount +-- > , VkBuffer dstBuffer +-- > , VkDeviceSize dstOffset +-- > , VkDeviceSize stride +-- > , VkQueryResultFlags flags +-- > ) +-- +-- +foreign import ccall unsafe "vkCmdCopyQueryPoolResults" + vkCmdCopyQueryPoolResults :: + VkCommandBuffer -- ^ commandBuffer + -> + VkQueryPool -- ^ queryPool + -> + Word32 -- ^ firstQuery + -> + Word32 -- ^ queryCount + -> + VkBuffer -- ^ dstBuffer + -> + VkDeviceSize -- ^ dstOffset + -> VkDeviceSize -- ^ stride + -> VkQueryResultFlags -- ^ flags + -> IO () + +-- | queues: 'graphics', 'compute'. +-- +-- renderpass: @both@ +-- +-- > () vkCmdPushConstants +-- > ( VkCommandBuffer commandBuffer +-- > , VkPipelineLayout layout +-- > , VkShaderStageFlags stageFlags +-- > , uint32_t offset +-- > , uint32_t size +-- > , const void* pValues +-- > ) +-- +-- +foreign import ccall unsafe "vkCmdPushConstants" vkCmdPushConstants + :: + VkCommandBuffer -- ^ commandBuffer + -> + VkPipelineLayout -- ^ layout + -> + VkShaderStageFlags -- ^ stageFlags + -> Word32 -- ^ offset + -> Word32 -- ^ size + -> Ptr Void -- ^ pValues + -> IO () + +-- | queues: 'graphics'. +-- +-- renderpass: @outside@ +-- +-- pipeline: @graphics@ +-- +-- > () vkCmdBeginRenderPass +-- > ( VkCommandBuffer commandBuffer +-- > , const VkRenderPassBeginInfo* pRenderPassBegin +-- > , VkSubpassContents contents +-- > ) +-- +-- +foreign import ccall unsafe "vkCmdBeginRenderPass" + vkCmdBeginRenderPass :: + VkCommandBuffer -- ^ commandBuffer + -> + Ptr VkRenderPassBeginInfo -- ^ pRenderPassBegin + -> VkSubpassContents -- ^ contents + -> IO () + +-- | queues: 'graphics'. +-- +-- renderpass: @inside@ +-- +-- pipeline: @graphics@ +-- +-- > () vkCmdNextSubpass +-- > ( VkCommandBuffer commandBuffer +-- > , VkSubpassContents contents +-- > ) +-- +-- +foreign import ccall unsafe "vkCmdNextSubpass" vkCmdNextSubpass :: + VkCommandBuffer -- ^ commandBuffer + -> VkSubpassContents -- ^ contents + -> IO () + +-- | queues: 'graphics'. +-- +-- renderpass: @inside@ +-- +-- pipeline: @graphics@ +-- +-- > () vkCmdEndRenderPass +-- > ( VkCommandBuffer commandBuffer +-- > ) +-- +-- +foreign import ccall unsafe "vkCmdEndRenderPass" vkCmdEndRenderPass + :: VkCommandBuffer -- ^ commandBuffer + -> IO () + +-- | queues: 'transfer', 'graphics', 'compute'. +-- +-- renderpass: @both@ +-- +-- > () vkCmdExecuteCommands +-- > ( VkCommandBuffer commandBuffer +-- > , uint32_t commandBufferCount +-- > , const VkCommandBuffer* pCommandBuffers +-- > ) +-- +-- +foreign import ccall unsafe "vkCmdExecuteCommands" + vkCmdExecuteCommands :: + VkCommandBuffer -- ^ commandBuffer + -> Word32 -- ^ commandBufferCount + -> Ptr VkCommandBuffer -- ^ pCommandBuffers + -> IO () diff --git a/src-gen/Graphics/Vulkan/Ext.hs b/src-gen/Graphics/Vulkan/Ext.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Ext.hs @@ -0,0 +1,315 @@ +{-# LANGUAGE CPP #-} +module Graphics.Vulkan.Ext + ( + module Graphics.Vulkan.Ext.VK_KHR_surface + , module Graphics.Vulkan.Ext.VK_KHR_swapchain + , module Graphics.Vulkan.Ext.VK_KHR_display + , module Graphics.Vulkan.Ext.VK_KHR_display_swapchain +#ifdef VK_USE_PLATFORM_XLIB_KHR + , module Graphics.Vulkan.Ext.VK_KHR_xlib_surface +#endif + +#ifdef VK_USE_PLATFORM_XCB_KHR + , module Graphics.Vulkan.Ext.VK_KHR_xcb_surface +#endif + +#ifdef VK_USE_PLATFORM_WAYLAND_KHR + , module Graphics.Vulkan.Ext.VK_KHR_wayland_surface +#endif + +#ifdef VK_USE_PLATFORM_MIR_KHR + , module Graphics.Vulkan.Ext.VK_KHR_mir_surface +#endif + +#ifdef VK_USE_PLATFORM_ANDROID_KHR + , module Graphics.Vulkan.Ext.VK_KHR_android_surface +#endif + +#ifdef VK_USE_PLATFORM_WIN32_KHR + , module Graphics.Vulkan.Ext.VK_KHR_win32_surface +#endif + + , module Graphics.Vulkan.Ext.VK_EXT_debug_report + , module Graphics.Vulkan.Ext.VK_NV_glsl_shader + , module Graphics.Vulkan.Ext.VK_EXT_depth_range_unrestricted + , module Graphics.Vulkan.Ext.VK_KHR_sampler_mirror_clamp_to_edge + , module Graphics.Vulkan.Ext.VK_IMG_filter_cubic + , module Graphics.Vulkan.Ext.VK_AMD_rasterization_order + , module Graphics.Vulkan.Ext.VK_AMD_shader_trinary_minmax + , module Graphics.Vulkan.Ext.VK_AMD_shader_explicit_vertex_parameter + , module Graphics.Vulkan.Ext.VK_EXT_debug_marker + , module Graphics.Vulkan.Ext.VK_AMD_gcn_shader + , module Graphics.Vulkan.Ext.VK_NV_dedicated_allocation + , module Graphics.Vulkan.Ext.VK_AMD_draw_indirect_count + , module Graphics.Vulkan.Ext.VK_AMD_negative_viewport_height + , module Graphics.Vulkan.Ext.VK_AMD_gpu_shader_half_float + , module Graphics.Vulkan.Ext.VK_AMD_shader_ballot + , module Graphics.Vulkan.Ext.VK_AMD_texture_gather_bias_lod + , module Graphics.Vulkan.Ext.VK_AMD_shader_info + , module Graphics.Vulkan.Ext.VK_AMD_shader_image_load_store_lod + , module Graphics.Vulkan.Ext.VK_KHX_multiview + , module Graphics.Vulkan.Ext.VK_IMG_format_pvrtc + , module Graphics.Vulkan.Ext.VK_NV_external_memory_capabilities + , module Graphics.Vulkan.Ext.VK_NV_external_memory +#ifdef VK_USE_PLATFORM_WIN32_KHR + , module Graphics.Vulkan.Ext.VK_NV_external_memory_win32 +#endif + +#ifdef VK_USE_PLATFORM_WIN32_KHR + , module Graphics.Vulkan.Ext.VK_NV_win32_keyed_mutex +#endif + + , module Graphics.Vulkan.Ext.VK_KHR_get_physical_device_properties2 + , module Graphics.Vulkan.Ext.VK_KHX_device_group + , module Graphics.Vulkan.Ext.VK_EXT_validation_flags +#ifdef VK_USE_PLATFORM_VI_NN + , module Graphics.Vulkan.Ext.VK_NN_vi_surface +#endif + + , module Graphics.Vulkan.Ext.VK_KHR_shader_draw_parameters + , module Graphics.Vulkan.Ext.VK_EXT_shader_subgroup_ballot + , module Graphics.Vulkan.Ext.VK_EXT_shader_subgroup_vote + , module Graphics.Vulkan.Ext.VK_KHR_maintenance1 + , module Graphics.Vulkan.Ext.VK_KHX_device_group_creation + , module Graphics.Vulkan.Ext.VK_KHR_external_memory_capabilities + , module Graphics.Vulkan.Ext.VK_KHR_external_memory +#ifdef VK_USE_PLATFORM_WIN32_KHR + , module Graphics.Vulkan.Ext.VK_KHR_external_memory_win32 +#endif + + , module Graphics.Vulkan.Ext.VK_KHR_external_memory_fd +#ifdef VK_USE_PLATFORM_WIN32_KHR + , module Graphics.Vulkan.Ext.VK_KHR_win32_keyed_mutex +#endif + + , module Graphics.Vulkan.Ext.VK_KHR_external_semaphore_capabilities + , module Graphics.Vulkan.Ext.VK_KHR_external_semaphore +#ifdef VK_USE_PLATFORM_WIN32_KHR + , module Graphics.Vulkan.Ext.VK_KHR_external_semaphore_win32 +#endif + + , module Graphics.Vulkan.Ext.VK_KHR_external_semaphore_fd + , module Graphics.Vulkan.Ext.VK_KHR_push_descriptor + , module Graphics.Vulkan.Ext.VK_KHR_16bit_storage + , module Graphics.Vulkan.Ext.VK_KHR_incremental_present + , module Graphics.Vulkan.Ext.VK_KHR_descriptor_update_template + , module Graphics.Vulkan.Ext.VK_NVX_device_generated_commands + , module Graphics.Vulkan.Ext.VK_NV_clip_space_w_scaling + , module Graphics.Vulkan.Ext.VK_EXT_direct_mode_display +#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT + , module Graphics.Vulkan.Ext.VK_EXT_acquire_xlib_display +#endif + + , module Graphics.Vulkan.Ext.VK_EXT_display_surface_counter + , module Graphics.Vulkan.Ext.VK_EXT_display_control + , module Graphics.Vulkan.Ext.VK_GOOGLE_display_timing + , module Graphics.Vulkan.Ext.VK_NV_sample_mask_override_coverage + , module Graphics.Vulkan.Ext.VK_NV_geometry_shader_passthrough + , module Graphics.Vulkan.Ext.VK_NV_viewport_array2 + , module Graphics.Vulkan.Ext.VK_NVX_multiview_per_view_attributes + , module Graphics.Vulkan.Ext.VK_NV_viewport_swizzle + , module Graphics.Vulkan.Ext.VK_EXT_discard_rectangles + , module Graphics.Vulkan.Ext.VK_EXT_conservative_rasterization + , module Graphics.Vulkan.Ext.VK_EXT_swapchain_colorspace + , module Graphics.Vulkan.Ext.VK_EXT_hdr_metadata + , module Graphics.Vulkan.Ext.VK_KHR_shared_presentable_image + , module Graphics.Vulkan.Ext.VK_KHR_external_fence_capabilities + , module Graphics.Vulkan.Ext.VK_KHR_external_fence +#ifdef VK_USE_PLATFORM_WIN32_KHR + , module Graphics.Vulkan.Ext.VK_KHR_external_fence_win32 +#endif + + , module Graphics.Vulkan.Ext.VK_KHR_external_fence_fd + , module Graphics.Vulkan.Ext.VK_KHR_maintenance2 + , module Graphics.Vulkan.Ext.VK_KHR_get_surface_capabilities2 + , module Graphics.Vulkan.Ext.VK_KHR_variable_pointers +#ifdef VK_USE_PLATFORM_IOS_MVK + , module Graphics.Vulkan.Ext.VK_MVK_ios_surface +#endif + +#ifdef VK_USE_PLATFORM_MACOS_MVK + , module Graphics.Vulkan.Ext.VK_MVK_macos_surface +#endif + + , module Graphics.Vulkan.Ext.VK_EXT_external_memory_dma_buf + , module Graphics.Vulkan.Ext.VK_EXT_queue_family_foreign + , module Graphics.Vulkan.Ext.VK_KHR_dedicated_allocation + , module Graphics.Vulkan.Ext.VK_EXT_sampler_filter_minmax + , module Graphics.Vulkan.Ext.VK_KHR_storage_buffer_storage_class + , module Graphics.Vulkan.Ext.VK_AMD_gpu_shader_int16 + , module Graphics.Vulkan.Ext.VK_AMD_mixed_attachment_samples + , module Graphics.Vulkan.Ext.VK_AMD_shader_fragment_mask + , module Graphics.Vulkan.Ext.VK_EXT_shader_stencil_export + , module Graphics.Vulkan.Ext.VK_EXT_sample_locations + , module Graphics.Vulkan.Ext.VK_KHR_relaxed_block_layout + , module Graphics.Vulkan.Ext.VK_KHR_get_memory_requirements2 + , module Graphics.Vulkan.Ext.VK_KHR_image_format_list + , module Graphics.Vulkan.Ext.VK_EXT_blend_operation_advanced + , module Graphics.Vulkan.Ext.VK_NV_fragment_coverage_to_color + , module Graphics.Vulkan.Ext.VK_NV_framebuffer_mixed_samples + , module Graphics.Vulkan.Ext.VK_NV_fill_rectangle + , module Graphics.Vulkan.Ext.VK_EXT_post_depth_coverage + , module Graphics.Vulkan.Ext.VK_KHR_sampler_ycbcr_conversion + , module Graphics.Vulkan.Ext.VK_KHR_bind_memory2 + , module Graphics.Vulkan.Ext.VK_EXT_validation_cache + , module Graphics.Vulkan.Ext.VK_EXT_shader_viewport_index_layer + , module Graphics.Vulkan.Ext.VK_EXT_global_priority + , module Graphics.Vulkan.Ext.VK_EXT_external_memory_host + , module Graphics.Vulkan.Ext.VK_AMD_buffer_marker + ) where + +import Graphics.Vulkan.Ext.VK_KHR_surface +import Graphics.Vulkan.Ext.VK_KHR_swapchain +import Graphics.Vulkan.Ext.VK_KHR_display +import Graphics.Vulkan.Ext.VK_KHR_display_swapchain +#ifdef VK_USE_PLATFORM_XLIB_KHR +import Graphics.Vulkan.Ext.VK_KHR_xlib_surface +#endif + +#ifdef VK_USE_PLATFORM_XCB_KHR +import Graphics.Vulkan.Ext.VK_KHR_xcb_surface +#endif + +#ifdef VK_USE_PLATFORM_WAYLAND_KHR +import Graphics.Vulkan.Ext.VK_KHR_wayland_surface +#endif + +#ifdef VK_USE_PLATFORM_MIR_KHR +import Graphics.Vulkan.Ext.VK_KHR_mir_surface +#endif + +#ifdef VK_USE_PLATFORM_ANDROID_KHR +import Graphics.Vulkan.Ext.VK_KHR_android_surface +#endif + +#ifdef VK_USE_PLATFORM_WIN32_KHR +import Graphics.Vulkan.Ext.VK_KHR_win32_surface +#endif + +import Graphics.Vulkan.Ext.VK_EXT_debug_report +import Graphics.Vulkan.Ext.VK_NV_glsl_shader +import Graphics.Vulkan.Ext.VK_EXT_depth_range_unrestricted +import Graphics.Vulkan.Ext.VK_KHR_sampler_mirror_clamp_to_edge +import Graphics.Vulkan.Ext.VK_IMG_filter_cubic +import Graphics.Vulkan.Ext.VK_AMD_rasterization_order +import Graphics.Vulkan.Ext.VK_AMD_shader_trinary_minmax +import Graphics.Vulkan.Ext.VK_AMD_shader_explicit_vertex_parameter +import Graphics.Vulkan.Ext.VK_EXT_debug_marker +import Graphics.Vulkan.Ext.VK_AMD_gcn_shader +import Graphics.Vulkan.Ext.VK_NV_dedicated_allocation +import Graphics.Vulkan.Ext.VK_AMD_draw_indirect_count +import Graphics.Vulkan.Ext.VK_AMD_negative_viewport_height +import Graphics.Vulkan.Ext.VK_AMD_gpu_shader_half_float +import Graphics.Vulkan.Ext.VK_AMD_shader_ballot +import Graphics.Vulkan.Ext.VK_AMD_texture_gather_bias_lod +import Graphics.Vulkan.Ext.VK_AMD_shader_info +import Graphics.Vulkan.Ext.VK_AMD_shader_image_load_store_lod +import Graphics.Vulkan.Ext.VK_KHX_multiview +import Graphics.Vulkan.Ext.VK_IMG_format_pvrtc +import Graphics.Vulkan.Ext.VK_NV_external_memory_capabilities +import Graphics.Vulkan.Ext.VK_NV_external_memory +#ifdef VK_USE_PLATFORM_WIN32_KHR +import Graphics.Vulkan.Ext.VK_NV_external_memory_win32 +#endif + +#ifdef VK_USE_PLATFORM_WIN32_KHR +import Graphics.Vulkan.Ext.VK_NV_win32_keyed_mutex +#endif + +import Graphics.Vulkan.Ext.VK_KHR_get_physical_device_properties2 +import Graphics.Vulkan.Ext.VK_KHX_device_group +import Graphics.Vulkan.Ext.VK_EXT_validation_flags +#ifdef VK_USE_PLATFORM_VI_NN +import Graphics.Vulkan.Ext.VK_NN_vi_surface +#endif + +import Graphics.Vulkan.Ext.VK_KHR_shader_draw_parameters +import Graphics.Vulkan.Ext.VK_EXT_shader_subgroup_ballot +import Graphics.Vulkan.Ext.VK_EXT_shader_subgroup_vote +import Graphics.Vulkan.Ext.VK_KHR_maintenance1 +import Graphics.Vulkan.Ext.VK_KHX_device_group_creation +import Graphics.Vulkan.Ext.VK_KHR_external_memory_capabilities +import Graphics.Vulkan.Ext.VK_KHR_external_memory +#ifdef VK_USE_PLATFORM_WIN32_KHR +import Graphics.Vulkan.Ext.VK_KHR_external_memory_win32 +#endif + +import Graphics.Vulkan.Ext.VK_KHR_external_memory_fd +#ifdef VK_USE_PLATFORM_WIN32_KHR +import Graphics.Vulkan.Ext.VK_KHR_win32_keyed_mutex +#endif + +import Graphics.Vulkan.Ext.VK_KHR_external_semaphore_capabilities +import Graphics.Vulkan.Ext.VK_KHR_external_semaphore +#ifdef VK_USE_PLATFORM_WIN32_KHR +import Graphics.Vulkan.Ext.VK_KHR_external_semaphore_win32 +#endif + +import Graphics.Vulkan.Ext.VK_KHR_external_semaphore_fd +import Graphics.Vulkan.Ext.VK_KHR_push_descriptor +import Graphics.Vulkan.Ext.VK_KHR_16bit_storage +import Graphics.Vulkan.Ext.VK_KHR_incremental_present +import Graphics.Vulkan.Ext.VK_KHR_descriptor_update_template +import Graphics.Vulkan.Ext.VK_NVX_device_generated_commands +import Graphics.Vulkan.Ext.VK_NV_clip_space_w_scaling +import Graphics.Vulkan.Ext.VK_EXT_direct_mode_display +#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT +import Graphics.Vulkan.Ext.VK_EXT_acquire_xlib_display +#endif + +import Graphics.Vulkan.Ext.VK_EXT_display_surface_counter +import Graphics.Vulkan.Ext.VK_EXT_display_control +import Graphics.Vulkan.Ext.VK_GOOGLE_display_timing +import Graphics.Vulkan.Ext.VK_NV_sample_mask_override_coverage +import Graphics.Vulkan.Ext.VK_NV_geometry_shader_passthrough +import Graphics.Vulkan.Ext.VK_NV_viewport_array2 +import Graphics.Vulkan.Ext.VK_NVX_multiview_per_view_attributes +import Graphics.Vulkan.Ext.VK_NV_viewport_swizzle +import Graphics.Vulkan.Ext.VK_EXT_discard_rectangles +import Graphics.Vulkan.Ext.VK_EXT_conservative_rasterization +import Graphics.Vulkan.Ext.VK_EXT_swapchain_colorspace +import Graphics.Vulkan.Ext.VK_EXT_hdr_metadata +import Graphics.Vulkan.Ext.VK_KHR_shared_presentable_image +import Graphics.Vulkan.Ext.VK_KHR_external_fence_capabilities +import Graphics.Vulkan.Ext.VK_KHR_external_fence +#ifdef VK_USE_PLATFORM_WIN32_KHR +import Graphics.Vulkan.Ext.VK_KHR_external_fence_win32 +#endif + +import Graphics.Vulkan.Ext.VK_KHR_external_fence_fd +import Graphics.Vulkan.Ext.VK_KHR_maintenance2 +import Graphics.Vulkan.Ext.VK_KHR_get_surface_capabilities2 +import Graphics.Vulkan.Ext.VK_KHR_variable_pointers +#ifdef VK_USE_PLATFORM_IOS_MVK +import Graphics.Vulkan.Ext.VK_MVK_ios_surface +#endif + +#ifdef VK_USE_PLATFORM_MACOS_MVK +import Graphics.Vulkan.Ext.VK_MVK_macos_surface +#endif + +import Graphics.Vulkan.Ext.VK_EXT_external_memory_dma_buf +import Graphics.Vulkan.Ext.VK_EXT_queue_family_foreign +import Graphics.Vulkan.Ext.VK_KHR_dedicated_allocation +import Graphics.Vulkan.Ext.VK_EXT_sampler_filter_minmax +import Graphics.Vulkan.Ext.VK_KHR_storage_buffer_storage_class +import Graphics.Vulkan.Ext.VK_AMD_gpu_shader_int16 +import Graphics.Vulkan.Ext.VK_AMD_mixed_attachment_samples +import Graphics.Vulkan.Ext.VK_AMD_shader_fragment_mask +import Graphics.Vulkan.Ext.VK_EXT_shader_stencil_export +import Graphics.Vulkan.Ext.VK_EXT_sample_locations +import Graphics.Vulkan.Ext.VK_KHR_relaxed_block_layout +import Graphics.Vulkan.Ext.VK_KHR_get_memory_requirements2 +import Graphics.Vulkan.Ext.VK_KHR_image_format_list +import Graphics.Vulkan.Ext.VK_EXT_blend_operation_advanced +import Graphics.Vulkan.Ext.VK_NV_fragment_coverage_to_color +import Graphics.Vulkan.Ext.VK_NV_framebuffer_mixed_samples +import Graphics.Vulkan.Ext.VK_NV_fill_rectangle +import Graphics.Vulkan.Ext.VK_EXT_post_depth_coverage +import Graphics.Vulkan.Ext.VK_KHR_sampler_ycbcr_conversion +import Graphics.Vulkan.Ext.VK_KHR_bind_memory2 +import Graphics.Vulkan.Ext.VK_EXT_validation_cache +import Graphics.Vulkan.Ext.VK_EXT_shader_viewport_index_layer +import Graphics.Vulkan.Ext.VK_EXT_global_priority +import Graphics.Vulkan.Ext.VK_EXT_external_memory_host +import Graphics.Vulkan.Ext.VK_AMD_buffer_marker diff --git a/src-gen/Graphics/Vulkan/Ext/VK_AMD_buffer_marker.hs b/src-gen/Graphics/Vulkan/Ext/VK_AMD_buffer_marker.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Ext/VK_AMD_buffer_marker.hs @@ -0,0 +1,88 @@ +{-# OPTIONS_GHC -fno-warn-unused-imports#-} +{-# OPTIONS_HADDOCK not-home#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE ForeignFunctionInterface #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE ViewPatterns #-} +module Graphics.Vulkan.Ext.VK_AMD_buffer_marker + (-- * Vulkan extension: @VK_AMD_buffer_marker@ + -- | + -- + -- supported: @vulkan@ + -- + -- contact: @Daniel Rakos @aqnuep@ + -- + -- author: @AMD@ + -- + -- type: @device@ + -- + -- Extension number: @180@ + vkCmdWriteBufferMarkerAMD, module Graphics.Vulkan.Marshal, + module Graphics.Vulkan.Types.BaseTypes, + module Graphics.Vulkan.Types.Enum.VkPipelineStageFlags, + module Graphics.Vulkan.Types.Handles, + VK_AMD_BUFFER_MARKER_SPEC_VERSION, + pattern VK_AMD_BUFFER_MARKER_SPEC_VERSION, + VK_AMD_BUFFER_MARKER_EXTENSION_NAME, + pattern VK_AMD_BUFFER_MARKER_EXTENSION_NAME) + where +import GHC.Ptr (Ptr (..)) +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Types.BaseTypes +import Graphics.Vulkan.Types.Enum.VkPipelineStageFlags +import Graphics.Vulkan.Types.Handles + +-- | queues: 'transfer', 'graphics', 'compute'. +-- +-- renderpass: @both@ +-- +-- pipeline: @transfer@ +-- +-- > () vkCmdWriteBufferMarkerAMD +-- > ( VkCommandBuffer commandBuffer +-- > , VkPipelineStageFlagBits pipelineStage +-- > , VkBuffer dstBuffer +-- > , VkDeviceSize dstOffset +-- > , uint32_t marker +-- > ) +-- +-- +foreign import ccall unsafe "vkCmdWriteBufferMarkerAMD" + vkCmdWriteBufferMarkerAMD :: + VkCommandBuffer -- ^ commandBuffer + -> + VkPipelineStageFlagBits -- ^ pipelineStage + -> + VkBuffer -- ^ dstBuffer + -> VkDeviceSize -- ^ dstOffset + -> Word32 -- ^ marker + -> IO () + +pattern VK_AMD_BUFFER_MARKER_SPEC_VERSION :: (Num a, Eq a) => a + +pattern VK_AMD_BUFFER_MARKER_SPEC_VERSION = 1 + +type VK_AMD_BUFFER_MARKER_SPEC_VERSION = 1 + +pattern VK_AMD_BUFFER_MARKER_EXTENSION_NAME :: CString + +pattern VK_AMD_BUFFER_MARKER_EXTENSION_NAME <- + (is_VK_AMD_BUFFER_MARKER_EXTENSION_NAME -> True) + where VK_AMD_BUFFER_MARKER_EXTENSION_NAME + = _VK_AMD_BUFFER_MARKER_EXTENSION_NAME + +{-# INLINE _VK_AMD_BUFFER_MARKER_EXTENSION_NAME #-} + +_VK_AMD_BUFFER_MARKER_EXTENSION_NAME :: CString +_VK_AMD_BUFFER_MARKER_EXTENSION_NAME + = Ptr "VK_AMD_buffer_marker\NUL"# + +{-# INLINE is_VK_AMD_BUFFER_MARKER_EXTENSION_NAME #-} + +is_VK_AMD_BUFFER_MARKER_EXTENSION_NAME :: CString -> Bool +is_VK_AMD_BUFFER_MARKER_EXTENSION_NAME + = eqCStrings _VK_AMD_BUFFER_MARKER_EXTENSION_NAME + +type VK_AMD_BUFFER_MARKER_EXTENSION_NAME = "VK_AMD_buffer_marker" diff --git a/src-gen/Graphics/Vulkan/Ext/VK_AMD_draw_indirect_count.hs b/src-gen/Graphics/Vulkan/Ext/VK_AMD_draw_indirect_count.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Ext/VK_AMD_draw_indirect_count.hs @@ -0,0 +1,124 @@ +{-# OPTIONS_HADDOCK not-home#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE ForeignFunctionInterface #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE ViewPatterns #-} +module Graphics.Vulkan.Ext.VK_AMD_draw_indirect_count + (-- * Vulkan extension: @VK_AMD_draw_indirect_count@ + -- | + -- + -- supported: @vulkan@ + -- + -- contact: @Daniel Rakos @aqnuep@ + -- + -- author: @AMD@ + -- + -- type: @device@ + -- + -- Extension number: @34@ + vkCmdDrawIndirectCountAMD, vkCmdDrawIndexedIndirectCountAMD, + module Graphics.Vulkan.Marshal, + module Graphics.Vulkan.Types.BaseTypes, + module Graphics.Vulkan.Types.Handles, + VK_AMD_DRAW_INDIRECT_COUNT_SPEC_VERSION, + pattern VK_AMD_DRAW_INDIRECT_COUNT_SPEC_VERSION, + VK_AMD_DRAW_INDIRECT_COUNT_EXTENSION_NAME, + pattern VK_AMD_DRAW_INDIRECT_COUNT_EXTENSION_NAME) + where +import GHC.Ptr (Ptr (..)) +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Types.BaseTypes +import Graphics.Vulkan.Types.Handles + +-- | queues: 'graphics'. +-- +-- renderpass: @inside@ +-- +-- pipeline: @graphics@ +-- +-- > () vkCmdDrawIndirectCountAMD +-- > ( VkCommandBuffer commandBuffer +-- > , VkBuffer buffer +-- > , VkDeviceSize offset +-- > , VkBuffer countBuffer +-- > , VkDeviceSize countBufferOffset +-- > , uint32_t maxDrawCount +-- > , uint32_t stride +-- > ) +-- +-- +foreign import ccall unsafe "vkCmdDrawIndirectCountAMD" + vkCmdDrawIndirectCountAMD :: + VkCommandBuffer -- ^ commandBuffer + -> + VkBuffer -- ^ buffer + -> + VkDeviceSize -- ^ offset + -> + VkBuffer -- ^ countBuffer + -> VkDeviceSize -- ^ countBufferOffset + -> Word32 -- ^ maxDrawCount + -> Word32 -- ^ stride + -> IO () + +-- | queues: 'graphics'. +-- +-- renderpass: @inside@ +-- +-- pipeline: @graphics@ +-- +-- > () vkCmdDrawIndexedIndirectCountAMD +-- > ( VkCommandBuffer commandBuffer +-- > , VkBuffer buffer +-- > , VkDeviceSize offset +-- > , VkBuffer countBuffer +-- > , VkDeviceSize countBufferOffset +-- > , uint32_t maxDrawCount +-- > , uint32_t stride +-- > ) +-- +-- +foreign import ccall unsafe "vkCmdDrawIndexedIndirectCountAMD" + vkCmdDrawIndexedIndirectCountAMD :: + VkCommandBuffer -- ^ commandBuffer + -> + VkBuffer -- ^ buffer + -> + VkDeviceSize -- ^ offset + -> + VkBuffer -- ^ countBuffer + -> VkDeviceSize -- ^ countBufferOffset + -> Word32 -- ^ maxDrawCount + -> Word32 -- ^ stride + -> IO () + +pattern VK_AMD_DRAW_INDIRECT_COUNT_SPEC_VERSION :: (Num a, Eq a) => + a + +pattern VK_AMD_DRAW_INDIRECT_COUNT_SPEC_VERSION = 1 + +type VK_AMD_DRAW_INDIRECT_COUNT_SPEC_VERSION = 1 + +pattern VK_AMD_DRAW_INDIRECT_COUNT_EXTENSION_NAME :: CString + +pattern VK_AMD_DRAW_INDIRECT_COUNT_EXTENSION_NAME <- + (is_VK_AMD_DRAW_INDIRECT_COUNT_EXTENSION_NAME -> True) + where VK_AMD_DRAW_INDIRECT_COUNT_EXTENSION_NAME + = _VK_AMD_DRAW_INDIRECT_COUNT_EXTENSION_NAME + +{-# INLINE _VK_AMD_DRAW_INDIRECT_COUNT_EXTENSION_NAME #-} + +_VK_AMD_DRAW_INDIRECT_COUNT_EXTENSION_NAME :: CString +_VK_AMD_DRAW_INDIRECT_COUNT_EXTENSION_NAME + = Ptr "VK_AMD_draw_indirect_count\NUL"# + +{-# INLINE is_VK_AMD_DRAW_INDIRECT_COUNT_EXTENSION_NAME #-} + +is_VK_AMD_DRAW_INDIRECT_COUNT_EXTENSION_NAME :: CString -> Bool +is_VK_AMD_DRAW_INDIRECT_COUNT_EXTENSION_NAME + = eqCStrings _VK_AMD_DRAW_INDIRECT_COUNT_EXTENSION_NAME + +type VK_AMD_DRAW_INDIRECT_COUNT_EXTENSION_NAME = + "VK_AMD_draw_indirect_count" diff --git a/src-gen/Graphics/Vulkan/Ext/VK_AMD_gcn_shader.hs b/src-gen/Graphics/Vulkan/Ext/VK_AMD_gcn_shader.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Ext/VK_AMD_gcn_shader.hs @@ -0,0 +1,52 @@ +{-# OPTIONS_HADDOCK not-home#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE ViewPatterns #-} +module Graphics.Vulkan.Ext.VK_AMD_gcn_shader + (-- * Vulkan extension: @VK_AMD_gcn_shader@ + -- | + -- + -- supported: @vulkan@ + -- + -- contact: @dominik.witczak@amd.com@ + -- + -- author: @AMD@ + -- + -- type: @device@ + -- + -- Extension number: @26@ + VK_AMD_GCN_SHADER_SPEC_VERSION, + pattern VK_AMD_GCN_SHADER_SPEC_VERSION, + VK_AMD_GCN_SHADER_EXTENSION_NAME, + pattern VK_AMD_GCN_SHADER_EXTENSION_NAME) + where +import GHC.Ptr (Ptr (..)) +import Graphics.Vulkan.Marshal + +pattern VK_AMD_GCN_SHADER_SPEC_VERSION :: (Num a, Eq a) => a + +pattern VK_AMD_GCN_SHADER_SPEC_VERSION = 1 + +type VK_AMD_GCN_SHADER_SPEC_VERSION = 1 + +pattern VK_AMD_GCN_SHADER_EXTENSION_NAME :: CString + +pattern VK_AMD_GCN_SHADER_EXTENSION_NAME <- + (is_VK_AMD_GCN_SHADER_EXTENSION_NAME -> True) + where VK_AMD_GCN_SHADER_EXTENSION_NAME + = _VK_AMD_GCN_SHADER_EXTENSION_NAME + +{-# INLINE _VK_AMD_GCN_SHADER_EXTENSION_NAME #-} + +_VK_AMD_GCN_SHADER_EXTENSION_NAME :: CString +_VK_AMD_GCN_SHADER_EXTENSION_NAME = Ptr "VK_AMD_gcn_shader\NUL"# + +{-# INLINE is_VK_AMD_GCN_SHADER_EXTENSION_NAME #-} + +is_VK_AMD_GCN_SHADER_EXTENSION_NAME :: CString -> Bool +is_VK_AMD_GCN_SHADER_EXTENSION_NAME + = eqCStrings _VK_AMD_GCN_SHADER_EXTENSION_NAME + +type VK_AMD_GCN_SHADER_EXTENSION_NAME = "VK_AMD_gcn_shader" diff --git a/src-gen/Graphics/Vulkan/Ext/VK_AMD_gpu_shader_half_float.hs b/src-gen/Graphics/Vulkan/Ext/VK_AMD_gpu_shader_half_float.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Ext/VK_AMD_gpu_shader_half_float.hs @@ -0,0 +1,55 @@ +{-# OPTIONS_HADDOCK not-home#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE ViewPatterns #-} +module Graphics.Vulkan.Ext.VK_AMD_gpu_shader_half_float + (-- * Vulkan extension: @VK_AMD_gpu_shader_half_float@ + -- | + -- + -- supported: @vulkan@ + -- + -- contact: @Dominik Witczak @dominikwitczak_amd@ + -- + -- author: @AMD@ + -- + -- type: @device@ + -- + -- Extension number: @37@ + VK_AMD_GPU_SHADER_HALF_FLOAT_SPEC_VERSION, + pattern VK_AMD_GPU_SHADER_HALF_FLOAT_SPEC_VERSION, + VK_AMD_GPU_SHADER_HALF_FLOAT_EXTENSION_NAME, + pattern VK_AMD_GPU_SHADER_HALF_FLOAT_EXTENSION_NAME) + where +import GHC.Ptr (Ptr (..)) +import Graphics.Vulkan.Marshal + +pattern VK_AMD_GPU_SHADER_HALF_FLOAT_SPEC_VERSION :: + (Num a, Eq a) => a + +pattern VK_AMD_GPU_SHADER_HALF_FLOAT_SPEC_VERSION = 1 + +type VK_AMD_GPU_SHADER_HALF_FLOAT_SPEC_VERSION = 1 + +pattern VK_AMD_GPU_SHADER_HALF_FLOAT_EXTENSION_NAME :: CString + +pattern VK_AMD_GPU_SHADER_HALF_FLOAT_EXTENSION_NAME <- + (is_VK_AMD_GPU_SHADER_HALF_FLOAT_EXTENSION_NAME -> True) + where VK_AMD_GPU_SHADER_HALF_FLOAT_EXTENSION_NAME + = _VK_AMD_GPU_SHADER_HALF_FLOAT_EXTENSION_NAME + +{-# INLINE _VK_AMD_GPU_SHADER_HALF_FLOAT_EXTENSION_NAME #-} + +_VK_AMD_GPU_SHADER_HALF_FLOAT_EXTENSION_NAME :: CString +_VK_AMD_GPU_SHADER_HALF_FLOAT_EXTENSION_NAME + = Ptr "VK_AMD_gpu_shader_half_float\NUL"# + +{-# INLINE is_VK_AMD_GPU_SHADER_HALF_FLOAT_EXTENSION_NAME #-} + +is_VK_AMD_GPU_SHADER_HALF_FLOAT_EXTENSION_NAME :: CString -> Bool +is_VK_AMD_GPU_SHADER_HALF_FLOAT_EXTENSION_NAME + = eqCStrings _VK_AMD_GPU_SHADER_HALF_FLOAT_EXTENSION_NAME + +type VK_AMD_GPU_SHADER_HALF_FLOAT_EXTENSION_NAME = + "VK_AMD_gpu_shader_half_float" diff --git a/src-gen/Graphics/Vulkan/Ext/VK_AMD_gpu_shader_int16.hs b/src-gen/Graphics/Vulkan/Ext/VK_AMD_gpu_shader_int16.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Ext/VK_AMD_gpu_shader_int16.hs @@ -0,0 +1,54 @@ +{-# OPTIONS_HADDOCK not-home#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE ViewPatterns #-} +module Graphics.Vulkan.Ext.VK_AMD_gpu_shader_int16 + (-- * Vulkan extension: @VK_AMD_gpu_shader_int16@ + -- | + -- + -- supported: @vulkan@ + -- + -- contact: @quentin.lin@amd.com@ + -- + -- author: @AMD@ + -- + -- type: @device@ + -- + -- Extension number: @133@ + VK_AMD_GPU_SHADER_INT16_SPEC_VERSION, + pattern VK_AMD_GPU_SHADER_INT16_SPEC_VERSION, + VK_AMD_GPU_SHADER_INT16_EXTENSION_NAME, + pattern VK_AMD_GPU_SHADER_INT16_EXTENSION_NAME) + where +import GHC.Ptr (Ptr (..)) +import Graphics.Vulkan.Marshal + +pattern VK_AMD_GPU_SHADER_INT16_SPEC_VERSION :: (Num a, Eq a) => a + +pattern VK_AMD_GPU_SHADER_INT16_SPEC_VERSION = 1 + +type VK_AMD_GPU_SHADER_INT16_SPEC_VERSION = 1 + +pattern VK_AMD_GPU_SHADER_INT16_EXTENSION_NAME :: CString + +pattern VK_AMD_GPU_SHADER_INT16_EXTENSION_NAME <- + (is_VK_AMD_GPU_SHADER_INT16_EXTENSION_NAME -> True) + where VK_AMD_GPU_SHADER_INT16_EXTENSION_NAME + = _VK_AMD_GPU_SHADER_INT16_EXTENSION_NAME + +{-# INLINE _VK_AMD_GPU_SHADER_INT16_EXTENSION_NAME #-} + +_VK_AMD_GPU_SHADER_INT16_EXTENSION_NAME :: CString +_VK_AMD_GPU_SHADER_INT16_EXTENSION_NAME + = Ptr "VK_AMD_gpu_shader_int16\NUL"# + +{-# INLINE is_VK_AMD_GPU_SHADER_INT16_EXTENSION_NAME #-} + +is_VK_AMD_GPU_SHADER_INT16_EXTENSION_NAME :: CString -> Bool +is_VK_AMD_GPU_SHADER_INT16_EXTENSION_NAME + = eqCStrings _VK_AMD_GPU_SHADER_INT16_EXTENSION_NAME + +type VK_AMD_GPU_SHADER_INT16_EXTENSION_NAME = + "VK_AMD_gpu_shader_int16" diff --git a/src-gen/Graphics/Vulkan/Ext/VK_AMD_mixed_attachment_samples.hs b/src-gen/Graphics/Vulkan/Ext/VK_AMD_mixed_attachment_samples.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Ext/VK_AMD_mixed_attachment_samples.hs @@ -0,0 +1,56 @@ +{-# OPTIONS_HADDOCK not-home#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE ViewPatterns #-} +module Graphics.Vulkan.Ext.VK_AMD_mixed_attachment_samples + (-- * Vulkan extension: @VK_AMD_mixed_attachment_samples@ + -- | + -- + -- supported: @vulkan@ + -- + -- contact: @Matthaeus G. Chajdas @anteru@ + -- + -- author: @AMD@ + -- + -- type: @device@ + -- + -- Extension number: @137@ + VK_AMD_MIXED_ATTACHMENT_SAMPLES_SPEC_VERSION, + pattern VK_AMD_MIXED_ATTACHMENT_SAMPLES_SPEC_VERSION, + VK_AMD_MIXED_ATTACHMENT_SAMPLES_EXTENSION_NAME, + pattern VK_AMD_MIXED_ATTACHMENT_SAMPLES_EXTENSION_NAME) + where +import GHC.Ptr (Ptr (..)) +import Graphics.Vulkan.Marshal + +pattern VK_AMD_MIXED_ATTACHMENT_SAMPLES_SPEC_VERSION :: + (Num a, Eq a) => a + +pattern VK_AMD_MIXED_ATTACHMENT_SAMPLES_SPEC_VERSION = 1 + +type VK_AMD_MIXED_ATTACHMENT_SAMPLES_SPEC_VERSION = 1 + +pattern VK_AMD_MIXED_ATTACHMENT_SAMPLES_EXTENSION_NAME :: CString + +pattern VK_AMD_MIXED_ATTACHMENT_SAMPLES_EXTENSION_NAME <- + (is_VK_AMD_MIXED_ATTACHMENT_SAMPLES_EXTENSION_NAME -> True) + where VK_AMD_MIXED_ATTACHMENT_SAMPLES_EXTENSION_NAME + = _VK_AMD_MIXED_ATTACHMENT_SAMPLES_EXTENSION_NAME + +{-# INLINE _VK_AMD_MIXED_ATTACHMENT_SAMPLES_EXTENSION_NAME #-} + +_VK_AMD_MIXED_ATTACHMENT_SAMPLES_EXTENSION_NAME :: CString +_VK_AMD_MIXED_ATTACHMENT_SAMPLES_EXTENSION_NAME + = Ptr "VK_AMD_mixed_attachment_samples\NUL"# + +{-# INLINE is_VK_AMD_MIXED_ATTACHMENT_SAMPLES_EXTENSION_NAME #-} + +is_VK_AMD_MIXED_ATTACHMENT_SAMPLES_EXTENSION_NAME :: + CString -> Bool +is_VK_AMD_MIXED_ATTACHMENT_SAMPLES_EXTENSION_NAME + = eqCStrings _VK_AMD_MIXED_ATTACHMENT_SAMPLES_EXTENSION_NAME + +type VK_AMD_MIXED_ATTACHMENT_SAMPLES_EXTENSION_NAME = + "VK_AMD_mixed_attachment_samples" diff --git a/src-gen/Graphics/Vulkan/Ext/VK_AMD_negative_viewport_height.hs b/src-gen/Graphics/Vulkan/Ext/VK_AMD_negative_viewport_height.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Ext/VK_AMD_negative_viewport_height.hs @@ -0,0 +1,56 @@ +{-# OPTIONS_HADDOCK not-home#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE ViewPatterns #-} +module Graphics.Vulkan.Ext.VK_AMD_negative_viewport_height + (-- * Vulkan extension: @VK_AMD_negative_viewport_height@ + -- | + -- + -- supported: @vulkan@ + -- + -- contact: @Matthaeus G. Chajdas @anteru@ + -- + -- author: @AMD@ + -- + -- type: @device@ + -- + -- Extension number: @36@ + VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_SPEC_VERSION, + pattern VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_SPEC_VERSION, + VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_EXTENSION_NAME, + pattern VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_EXTENSION_NAME) + where +import GHC.Ptr (Ptr (..)) +import Graphics.Vulkan.Marshal + +pattern VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_SPEC_VERSION :: + (Num a, Eq a) => a + +pattern VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_SPEC_VERSION = 1 + +type VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_SPEC_VERSION = 1 + +pattern VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_EXTENSION_NAME :: CString + +pattern VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_EXTENSION_NAME <- + (is_VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_EXTENSION_NAME -> True) + where VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_EXTENSION_NAME + = _VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_EXTENSION_NAME + +{-# INLINE _VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_EXTENSION_NAME #-} + +_VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_EXTENSION_NAME :: CString +_VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_EXTENSION_NAME + = Ptr "VK_AMD_negative_viewport_height\NUL"# + +{-# INLINE is_VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_EXTENSION_NAME #-} + +is_VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_EXTENSION_NAME :: + CString -> Bool +is_VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_EXTENSION_NAME + = eqCStrings _VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_EXTENSION_NAME + +type VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_EXTENSION_NAME = + "VK_AMD_negative_viewport_height" diff --git a/src-gen/Graphics/Vulkan/Ext/VK_AMD_rasterization_order.hs b/src-gen/Graphics/Vulkan/Ext/VK_AMD_rasterization_order.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Ext/VK_AMD_rasterization_order.hs @@ -0,0 +1,82 @@ +{-# OPTIONS_HADDOCK not-home#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE ViewPatterns #-} +module Graphics.Vulkan.Ext.VK_AMD_rasterization_order + (-- * Vulkan extension: @VK_AMD_rasterization_order@ + -- | + -- + -- supported: @vulkan@ + -- + -- contact: @Daniel Rakos @aqnuep@ + -- + -- author: @AMD@ + -- + -- type: @device@ + -- + -- Extension number: @19@ + module Graphics.Vulkan.Types.BaseTypes, + module Graphics.Vulkan.Types.Enum.VkCullModeFlags, + module Graphics.Vulkan.Types.Enum.VkFrontFace, + module Graphics.Vulkan.Types.Bitmasks, + module Graphics.Vulkan.Types.Struct.VkPipelineRasterizationStateCreateInfo, + module Graphics.Vulkan.Types.Struct.VkPipelineRasterizationStateRasterizationOrderAMD, + module Graphics.Vulkan.Types.Enum.VkPolygonMode, + module Graphics.Vulkan.Types.Enum.VkRasterizationOrderAMD, + module Graphics.Vulkan.Types.Enum.VkStructureType, + -- > #include "vk_platform.h" + VK_AMD_RASTERIZATION_ORDER_SPEC_VERSION, + pattern VK_AMD_RASTERIZATION_ORDER_SPEC_VERSION, + VK_AMD_RASTERIZATION_ORDER_EXTENSION_NAME, + pattern VK_AMD_RASTERIZATION_ORDER_EXTENSION_NAME, + pattern VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD) + where +import GHC.Ptr + (Ptr (..)) +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Types.BaseTypes +import Graphics.Vulkan.Types.Bitmasks +import Graphics.Vulkan.Types.Enum.VkCullModeFlags +import Graphics.Vulkan.Types.Enum.VkFrontFace +import Graphics.Vulkan.Types.Enum.VkPolygonMode +import Graphics.Vulkan.Types.Enum.VkRasterizationOrderAMD +import Graphics.Vulkan.Types.Enum.VkStructureType +import Graphics.Vulkan.Types.Struct.VkPipelineRasterizationStateCreateInfo +import Graphics.Vulkan.Types.Struct.VkPipelineRasterizationStateRasterizationOrderAMD + +pattern VK_AMD_RASTERIZATION_ORDER_SPEC_VERSION :: (Num a, Eq a) => + a + +pattern VK_AMD_RASTERIZATION_ORDER_SPEC_VERSION = 1 + +type VK_AMD_RASTERIZATION_ORDER_SPEC_VERSION = 1 + +pattern VK_AMD_RASTERIZATION_ORDER_EXTENSION_NAME :: CString + +pattern VK_AMD_RASTERIZATION_ORDER_EXTENSION_NAME <- + (is_VK_AMD_RASTERIZATION_ORDER_EXTENSION_NAME -> True) + where VK_AMD_RASTERIZATION_ORDER_EXTENSION_NAME + = _VK_AMD_RASTERIZATION_ORDER_EXTENSION_NAME + +{-# INLINE _VK_AMD_RASTERIZATION_ORDER_EXTENSION_NAME #-} + +_VK_AMD_RASTERIZATION_ORDER_EXTENSION_NAME :: CString +_VK_AMD_RASTERIZATION_ORDER_EXTENSION_NAME + = Ptr "VK_AMD_rasterization_order\NUL"# + +{-# INLINE is_VK_AMD_RASTERIZATION_ORDER_EXTENSION_NAME #-} + +is_VK_AMD_RASTERIZATION_ORDER_EXTENSION_NAME :: CString -> Bool +is_VK_AMD_RASTERIZATION_ORDER_EXTENSION_NAME + = eqCStrings _VK_AMD_RASTERIZATION_ORDER_EXTENSION_NAME + +type VK_AMD_RASTERIZATION_ORDER_EXTENSION_NAME = + "VK_AMD_rasterization_order" + +pattern VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD + :: VkStructureType + +pattern VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD + = VkStructureType 1000018000 diff --git a/src-gen/Graphics/Vulkan/Ext/VK_AMD_shader_ballot.hs b/src-gen/Graphics/Vulkan/Ext/VK_AMD_shader_ballot.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Ext/VK_AMD_shader_ballot.hs @@ -0,0 +1,53 @@ +{-# OPTIONS_HADDOCK not-home#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE ViewPatterns #-} +module Graphics.Vulkan.Ext.VK_AMD_shader_ballot + (-- * Vulkan extension: @VK_AMD_shader_ballot@ + -- | + -- + -- supported: @vulkan@ + -- + -- contact: @Dominik Witczak @dominikwitczak_amd@ + -- + -- author: @AMD@ + -- + -- type: @device@ + -- + -- Extension number: @38@ + VK_AMD_SHADER_BALLOT_SPEC_VERSION, + pattern VK_AMD_SHADER_BALLOT_SPEC_VERSION, + VK_AMD_SHADER_BALLOT_EXTENSION_NAME, + pattern VK_AMD_SHADER_BALLOT_EXTENSION_NAME) + where +import GHC.Ptr (Ptr (..)) +import Graphics.Vulkan.Marshal + +pattern VK_AMD_SHADER_BALLOT_SPEC_VERSION :: (Num a, Eq a) => a + +pattern VK_AMD_SHADER_BALLOT_SPEC_VERSION = 1 + +type VK_AMD_SHADER_BALLOT_SPEC_VERSION = 1 + +pattern VK_AMD_SHADER_BALLOT_EXTENSION_NAME :: CString + +pattern VK_AMD_SHADER_BALLOT_EXTENSION_NAME <- + (is_VK_AMD_SHADER_BALLOT_EXTENSION_NAME -> True) + where VK_AMD_SHADER_BALLOT_EXTENSION_NAME + = _VK_AMD_SHADER_BALLOT_EXTENSION_NAME + +{-# INLINE _VK_AMD_SHADER_BALLOT_EXTENSION_NAME #-} + +_VK_AMD_SHADER_BALLOT_EXTENSION_NAME :: CString +_VK_AMD_SHADER_BALLOT_EXTENSION_NAME + = Ptr "VK_AMD_shader_ballot\NUL"# + +{-# INLINE is_VK_AMD_SHADER_BALLOT_EXTENSION_NAME #-} + +is_VK_AMD_SHADER_BALLOT_EXTENSION_NAME :: CString -> Bool +is_VK_AMD_SHADER_BALLOT_EXTENSION_NAME + = eqCStrings _VK_AMD_SHADER_BALLOT_EXTENSION_NAME + +type VK_AMD_SHADER_BALLOT_EXTENSION_NAME = "VK_AMD_shader_ballot" diff --git a/src-gen/Graphics/Vulkan/Ext/VK_AMD_shader_explicit_vertex_parameter.hs b/src-gen/Graphics/Vulkan/Ext/VK_AMD_shader_explicit_vertex_parameter.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Ext/VK_AMD_shader_explicit_vertex_parameter.hs @@ -0,0 +1,60 @@ +{-# OPTIONS_HADDOCK not-home#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE ViewPatterns #-} +module Graphics.Vulkan.Ext.VK_AMD_shader_explicit_vertex_parameter + (-- * Vulkan extension: @VK_AMD_shader_explicit_vertex_parameter@ + -- | + -- + -- supported: @vulkan@ + -- + -- contact: @quentin.lin@amd.com@ + -- + -- author: @AMD@ + -- + -- type: @device@ + -- + -- Extension number: @22@ + VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_SPEC_VERSION, + pattern VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_SPEC_VERSION, + VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_EXTENSION_NAME, + pattern VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_EXTENSION_NAME) + where +import GHC.Ptr (Ptr (..)) +import Graphics.Vulkan.Marshal + +pattern VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_SPEC_VERSION :: + (Num a, Eq a) => a + +pattern VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_SPEC_VERSION = 1 + +type VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_SPEC_VERSION = 1 + +pattern VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_EXTENSION_NAME :: + CString + +pattern VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_EXTENSION_NAME <- + (is_VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_EXTENSION_NAME -> True) + where VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_EXTENSION_NAME + = _VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_EXTENSION_NAME + +{-# INLINE _VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_EXTENSION_NAME + #-} + +_VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_EXTENSION_NAME :: CString +_VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_EXTENSION_NAME + = Ptr "VK_AMD_shader_explicit_vertex_parameter\NUL"# + +{-# INLINE is_VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_EXTENSION_NAME + #-} + +is_VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_EXTENSION_NAME :: + CString -> Bool +is_VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_EXTENSION_NAME + = eqCStrings + _VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_EXTENSION_NAME + +type VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_EXTENSION_NAME = + "VK_AMD_shader_explicit_vertex_parameter" diff --git a/src-gen/Graphics/Vulkan/Ext/VK_AMD_shader_fragment_mask.hs b/src-gen/Graphics/Vulkan/Ext/VK_AMD_shader_fragment_mask.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Ext/VK_AMD_shader_fragment_mask.hs @@ -0,0 +1,55 @@ +{-# OPTIONS_HADDOCK not-home#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE ViewPatterns #-} +module Graphics.Vulkan.Ext.VK_AMD_shader_fragment_mask + (-- * Vulkan extension: @VK_AMD_shader_fragment_mask@ + -- | + -- + -- supported: @vulkan@ + -- + -- contact: @Aaron Hagan @ahagan@ + -- + -- author: @AMD@ + -- + -- type: @device@ + -- + -- Extension number: @138@ + VK_AMD_SHADER_FRAGMENT_MASK_SPEC_VERSION, + pattern VK_AMD_SHADER_FRAGMENT_MASK_SPEC_VERSION, + VK_AMD_SHADER_FRAGMENT_MASK_EXTENSION_NAME, + pattern VK_AMD_SHADER_FRAGMENT_MASK_EXTENSION_NAME) + where +import GHC.Ptr (Ptr (..)) +import Graphics.Vulkan.Marshal + +pattern VK_AMD_SHADER_FRAGMENT_MASK_SPEC_VERSION :: + (Num a, Eq a) => a + +pattern VK_AMD_SHADER_FRAGMENT_MASK_SPEC_VERSION = 1 + +type VK_AMD_SHADER_FRAGMENT_MASK_SPEC_VERSION = 1 + +pattern VK_AMD_SHADER_FRAGMENT_MASK_EXTENSION_NAME :: CString + +pattern VK_AMD_SHADER_FRAGMENT_MASK_EXTENSION_NAME <- + (is_VK_AMD_SHADER_FRAGMENT_MASK_EXTENSION_NAME -> True) + where VK_AMD_SHADER_FRAGMENT_MASK_EXTENSION_NAME + = _VK_AMD_SHADER_FRAGMENT_MASK_EXTENSION_NAME + +{-# INLINE _VK_AMD_SHADER_FRAGMENT_MASK_EXTENSION_NAME #-} + +_VK_AMD_SHADER_FRAGMENT_MASK_EXTENSION_NAME :: CString +_VK_AMD_SHADER_FRAGMENT_MASK_EXTENSION_NAME + = Ptr "VK_AMD_shader_fragment_mask\NUL"# + +{-# INLINE is_VK_AMD_SHADER_FRAGMENT_MASK_EXTENSION_NAME #-} + +is_VK_AMD_SHADER_FRAGMENT_MASK_EXTENSION_NAME :: CString -> Bool +is_VK_AMD_SHADER_FRAGMENT_MASK_EXTENSION_NAME + = eqCStrings _VK_AMD_SHADER_FRAGMENT_MASK_EXTENSION_NAME + +type VK_AMD_SHADER_FRAGMENT_MASK_EXTENSION_NAME = + "VK_AMD_shader_fragment_mask" diff --git a/src-gen/Graphics/Vulkan/Ext/VK_AMD_shader_image_load_store_lod.hs b/src-gen/Graphics/Vulkan/Ext/VK_AMD_shader_image_load_store_lod.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Ext/VK_AMD_shader_image_load_store_lod.hs @@ -0,0 +1,57 @@ +{-# OPTIONS_HADDOCK not-home#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE ViewPatterns #-} +module Graphics.Vulkan.Ext.VK_AMD_shader_image_load_store_lod + (-- * Vulkan extension: @VK_AMD_shader_image_load_store_lod@ + -- | + -- + -- supported: @vulkan@ + -- + -- contact: @Dominik Witczak @dominikwitczak_amd@ + -- + -- author: @AMD@ + -- + -- type: @device@ + -- + -- Extension number: @47@ + VK_AMD_SHADER_IMAGE_LOAD_STORE_LOD_SPEC_VERSION, + pattern VK_AMD_SHADER_IMAGE_LOAD_STORE_LOD_SPEC_VERSION, + VK_AMD_SHADER_IMAGE_LOAD_STORE_LOD_EXTENSION_NAME, + pattern VK_AMD_SHADER_IMAGE_LOAD_STORE_LOD_EXTENSION_NAME) + where +import GHC.Ptr (Ptr (..)) +import Graphics.Vulkan.Marshal + +pattern VK_AMD_SHADER_IMAGE_LOAD_STORE_LOD_SPEC_VERSION :: + (Num a, Eq a) => a + +pattern VK_AMD_SHADER_IMAGE_LOAD_STORE_LOD_SPEC_VERSION = 1 + +type VK_AMD_SHADER_IMAGE_LOAD_STORE_LOD_SPEC_VERSION = 1 + +pattern VK_AMD_SHADER_IMAGE_LOAD_STORE_LOD_EXTENSION_NAME :: + CString + +pattern VK_AMD_SHADER_IMAGE_LOAD_STORE_LOD_EXTENSION_NAME <- + (is_VK_AMD_SHADER_IMAGE_LOAD_STORE_LOD_EXTENSION_NAME -> True) + where VK_AMD_SHADER_IMAGE_LOAD_STORE_LOD_EXTENSION_NAME + = _VK_AMD_SHADER_IMAGE_LOAD_STORE_LOD_EXTENSION_NAME + +{-# INLINE _VK_AMD_SHADER_IMAGE_LOAD_STORE_LOD_EXTENSION_NAME #-} + +_VK_AMD_SHADER_IMAGE_LOAD_STORE_LOD_EXTENSION_NAME :: CString +_VK_AMD_SHADER_IMAGE_LOAD_STORE_LOD_EXTENSION_NAME + = Ptr "VK_AMD_shader_image_load_store_lod\NUL"# + +{-# INLINE is_VK_AMD_SHADER_IMAGE_LOAD_STORE_LOD_EXTENSION_NAME #-} + +is_VK_AMD_SHADER_IMAGE_LOAD_STORE_LOD_EXTENSION_NAME :: + CString -> Bool +is_VK_AMD_SHADER_IMAGE_LOAD_STORE_LOD_EXTENSION_NAME + = eqCStrings _VK_AMD_SHADER_IMAGE_LOAD_STORE_LOD_EXTENSION_NAME + +type VK_AMD_SHADER_IMAGE_LOAD_STORE_LOD_EXTENSION_NAME = + "VK_AMD_shader_image_load_store_lod" diff --git a/src-gen/Graphics/Vulkan/Ext/VK_AMD_shader_info.hs b/src-gen/Graphics/Vulkan/Ext/VK_AMD_shader_info.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Ext/VK_AMD_shader_info.hs @@ -0,0 +1,97 @@ +{-# OPTIONS_GHC -fno-warn-unused-imports#-} +{-# OPTIONS_HADDOCK not-home#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE ForeignFunctionInterface #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE ViewPatterns #-} +module Graphics.Vulkan.Ext.VK_AMD_shader_info + (-- * Vulkan extension: @VK_AMD_shader_info@ + -- | + -- + -- supported: @vulkan@ + -- + -- contact: @Jaakko Konttinen @jaakko@ + -- + -- author: @AMD@ + -- + -- type: @device@ + -- + -- Extension number: @43@ + module Graphics.Vulkan.Marshal, + module Graphics.Vulkan.Types.BaseTypes, + module Graphics.Vulkan.Types.Enum.VkShaderInfoTypeAMD, + module Graphics.Vulkan.Types.Struct.VkShaderResourceUsageAMD, + module Graphics.Vulkan.Types.Enum.VkShaderStageFlags, + module Graphics.Vulkan.Types.Struct.VkShaderStatisticsInfoAMD, + -- > #include "vk_platform.h" + vkGetShaderInfoAMD, module Graphics.Vulkan.Types.Enum.VkResult, + module Graphics.Vulkan.Types.Handles, + VK_AMD_SHADER_INFO_SPEC_VERSION, + pattern VK_AMD_SHADER_INFO_SPEC_VERSION, + VK_AMD_SHADER_INFO_EXTENSION_NAME, + pattern VK_AMD_SHADER_INFO_EXTENSION_NAME) + where +import GHC.Ptr (Ptr (..)) +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Types.BaseTypes +import Graphics.Vulkan.Types.Enum.VkResult +import Graphics.Vulkan.Types.Enum.VkShaderInfoTypeAMD +import Graphics.Vulkan.Types.Enum.VkShaderStageFlags +import Graphics.Vulkan.Types.Handles +import Graphics.Vulkan.Types.Struct.VkShaderResourceUsageAMD +import Graphics.Vulkan.Types.Struct.VkShaderStatisticsInfoAMD + +-- | Success codes: 'VK_SUCCESS', 'VK_INCOMPLETE'. +-- +-- Error codes: 'VK_ERROR_FEATURE_NOT_PRESENT', 'VK_ERROR_OUT_OF_HOST_MEMORY'. +-- +-- > VkResult vkGetShaderInfoAMD +-- > ( VkDevice device +-- > , VkPipeline pipeline +-- > , VkShaderStageFlagBits shaderStage +-- > , VkShaderInfoTypeAMD infoType +-- > , size_t* pInfoSize +-- > , void* pInfo +-- > ) +-- +-- +foreign import ccall unsafe "vkGetShaderInfoAMD" vkGetShaderInfoAMD + :: + VkDevice -- ^ device + -> + VkPipeline -- ^ pipeline + -> + VkShaderStageFlagBits -- ^ shaderStage + -> + VkShaderInfoTypeAMD -- ^ infoType + -> Ptr CSize -- ^ pInfoSize + -> Ptr Void -- ^ pInfo + -> IO VkResult + +pattern VK_AMD_SHADER_INFO_SPEC_VERSION :: (Num a, Eq a) => a + +pattern VK_AMD_SHADER_INFO_SPEC_VERSION = 1 + +type VK_AMD_SHADER_INFO_SPEC_VERSION = 1 + +pattern VK_AMD_SHADER_INFO_EXTENSION_NAME :: CString + +pattern VK_AMD_SHADER_INFO_EXTENSION_NAME <- + (is_VK_AMD_SHADER_INFO_EXTENSION_NAME -> True) + where VK_AMD_SHADER_INFO_EXTENSION_NAME + = _VK_AMD_SHADER_INFO_EXTENSION_NAME + +{-# INLINE _VK_AMD_SHADER_INFO_EXTENSION_NAME #-} + +_VK_AMD_SHADER_INFO_EXTENSION_NAME :: CString +_VK_AMD_SHADER_INFO_EXTENSION_NAME = Ptr "VK_AMD_shader_info\NUL"# + +{-# INLINE is_VK_AMD_SHADER_INFO_EXTENSION_NAME #-} + +is_VK_AMD_SHADER_INFO_EXTENSION_NAME :: CString -> Bool +is_VK_AMD_SHADER_INFO_EXTENSION_NAME + = eqCStrings _VK_AMD_SHADER_INFO_EXTENSION_NAME + +type VK_AMD_SHADER_INFO_EXTENSION_NAME = "VK_AMD_shader_info" diff --git a/src-gen/Graphics/Vulkan/Ext/VK_AMD_shader_trinary_minmax.hs b/src-gen/Graphics/Vulkan/Ext/VK_AMD_shader_trinary_minmax.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Ext/VK_AMD_shader_trinary_minmax.hs @@ -0,0 +1,55 @@ +{-# OPTIONS_HADDOCK not-home#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE ViewPatterns #-} +module Graphics.Vulkan.Ext.VK_AMD_shader_trinary_minmax + (-- * Vulkan extension: @VK_AMD_shader_trinary_minmax@ + -- | + -- + -- supported: @vulkan@ + -- + -- contact: @quentin.lin@amd.com@ + -- + -- author: @AMD@ + -- + -- type: @device@ + -- + -- Extension number: @21@ + VK_AMD_SHADER_TRINARY_MINMAX_SPEC_VERSION, + pattern VK_AMD_SHADER_TRINARY_MINMAX_SPEC_VERSION, + VK_AMD_SHADER_TRINARY_MINMAX_EXTENSION_NAME, + pattern VK_AMD_SHADER_TRINARY_MINMAX_EXTENSION_NAME) + where +import GHC.Ptr (Ptr (..)) +import Graphics.Vulkan.Marshal + +pattern VK_AMD_SHADER_TRINARY_MINMAX_SPEC_VERSION :: + (Num a, Eq a) => a + +pattern VK_AMD_SHADER_TRINARY_MINMAX_SPEC_VERSION = 1 + +type VK_AMD_SHADER_TRINARY_MINMAX_SPEC_VERSION = 1 + +pattern VK_AMD_SHADER_TRINARY_MINMAX_EXTENSION_NAME :: CString + +pattern VK_AMD_SHADER_TRINARY_MINMAX_EXTENSION_NAME <- + (is_VK_AMD_SHADER_TRINARY_MINMAX_EXTENSION_NAME -> True) + where VK_AMD_SHADER_TRINARY_MINMAX_EXTENSION_NAME + = _VK_AMD_SHADER_TRINARY_MINMAX_EXTENSION_NAME + +{-# INLINE _VK_AMD_SHADER_TRINARY_MINMAX_EXTENSION_NAME #-} + +_VK_AMD_SHADER_TRINARY_MINMAX_EXTENSION_NAME :: CString +_VK_AMD_SHADER_TRINARY_MINMAX_EXTENSION_NAME + = Ptr "VK_AMD_shader_trinary_minmax\NUL"# + +{-# INLINE is_VK_AMD_SHADER_TRINARY_MINMAX_EXTENSION_NAME #-} + +is_VK_AMD_SHADER_TRINARY_MINMAX_EXTENSION_NAME :: CString -> Bool +is_VK_AMD_SHADER_TRINARY_MINMAX_EXTENSION_NAME + = eqCStrings _VK_AMD_SHADER_TRINARY_MINMAX_EXTENSION_NAME + +type VK_AMD_SHADER_TRINARY_MINMAX_EXTENSION_NAME = + "VK_AMD_shader_trinary_minmax" diff --git a/src-gen/Graphics/Vulkan/Ext/VK_AMD_texture_gather_bias_lod.hs b/src-gen/Graphics/Vulkan/Ext/VK_AMD_texture_gather_bias_lod.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Ext/VK_AMD_texture_gather_bias_lod.hs @@ -0,0 +1,83 @@ +{-# OPTIONS_HADDOCK not-home#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE ViewPatterns #-} +module Graphics.Vulkan.Ext.VK_AMD_texture_gather_bias_lod + (-- * Vulkan extension: @VK_AMD_texture_gather_bias_lod@ + -- | + -- + -- supported: @vulkan@ + -- + -- contact: @Rex Xu @amdrexu@ + -- + -- author: @AMD@ + -- + -- type: @device@ + -- + -- Extension number: @42@ + -- + -- Required extensions: 'VK_KHR_get_physical_device_properties2'. + -- + + -- ** Required extensions: 'VK_KHR_get_physical_device_properties2'. + module Graphics.Vulkan.Types.BaseTypes, + module Graphics.Vulkan.Types.Struct.VkExtent3D, + module Graphics.Vulkan.Types.Struct.VkImageFormatProperties, + module Graphics.Vulkan.Types.Struct.VkImageFormatProperties2KHR, + module Graphics.Vulkan.Types.Enum.VkSampleCountFlags, + module Graphics.Vulkan.Types.Enum.VkStructureType, + module Graphics.Vulkan.Types.Struct.VkTextureLODGatherFormatPropertiesAMD, + -- > #include "vk_platform.h" + VK_AMD_TEXTURE_GATHER_BIAS_LOD_SPEC_VERSION, + pattern VK_AMD_TEXTURE_GATHER_BIAS_LOD_SPEC_VERSION, + VK_AMD_TEXTURE_GATHER_BIAS_LOD_EXTENSION_NAME, + pattern VK_AMD_TEXTURE_GATHER_BIAS_LOD_EXTENSION_NAME, + pattern VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD) + where +import GHC.Ptr + (Ptr (..)) +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Types.BaseTypes +import Graphics.Vulkan.Types.Enum.VkSampleCountFlags +import Graphics.Vulkan.Types.Enum.VkStructureType +import Graphics.Vulkan.Types.Struct.VkExtent3D +import Graphics.Vulkan.Types.Struct.VkImageFormatProperties +import Graphics.Vulkan.Types.Struct.VkImageFormatProperties2KHR +import Graphics.Vulkan.Types.Struct.VkTextureLODGatherFormatPropertiesAMD + +pattern VK_AMD_TEXTURE_GATHER_BIAS_LOD_SPEC_VERSION :: + (Num a, Eq a) => a + +pattern VK_AMD_TEXTURE_GATHER_BIAS_LOD_SPEC_VERSION = 1 + +type VK_AMD_TEXTURE_GATHER_BIAS_LOD_SPEC_VERSION = 1 + +pattern VK_AMD_TEXTURE_GATHER_BIAS_LOD_EXTENSION_NAME :: CString + +pattern VK_AMD_TEXTURE_GATHER_BIAS_LOD_EXTENSION_NAME <- + (is_VK_AMD_TEXTURE_GATHER_BIAS_LOD_EXTENSION_NAME -> True) + where VK_AMD_TEXTURE_GATHER_BIAS_LOD_EXTENSION_NAME + = _VK_AMD_TEXTURE_GATHER_BIAS_LOD_EXTENSION_NAME + +{-# INLINE _VK_AMD_TEXTURE_GATHER_BIAS_LOD_EXTENSION_NAME #-} + +_VK_AMD_TEXTURE_GATHER_BIAS_LOD_EXTENSION_NAME :: CString +_VK_AMD_TEXTURE_GATHER_BIAS_LOD_EXTENSION_NAME + = Ptr "VK_AMD_texture_gather_bias_lod\NUL"# + +{-# INLINE is_VK_AMD_TEXTURE_GATHER_BIAS_LOD_EXTENSION_NAME #-} + +is_VK_AMD_TEXTURE_GATHER_BIAS_LOD_EXTENSION_NAME :: CString -> Bool +is_VK_AMD_TEXTURE_GATHER_BIAS_LOD_EXTENSION_NAME + = eqCStrings _VK_AMD_TEXTURE_GATHER_BIAS_LOD_EXTENSION_NAME + +type VK_AMD_TEXTURE_GATHER_BIAS_LOD_EXTENSION_NAME = + "VK_AMD_texture_gather_bias_lod" + +pattern VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD + :: VkStructureType + +pattern VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD + = VkStructureType 1000041000 diff --git a/src-gen/Graphics/Vulkan/Ext/VK_EXT_acquire_xlib_display.hs b/src-gen/Graphics/Vulkan/Ext/VK_EXT_acquire_xlib_display.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Ext/VK_EXT_acquire_xlib_display.hs @@ -0,0 +1,106 @@ +{-# OPTIONS_HADDOCK not-home#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE ForeignFunctionInterface #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE ViewPatterns #-} +module Graphics.Vulkan.Ext.VK_EXT_acquire_xlib_display + (-- * Vulkan extension: @VK_EXT_acquire_xlib_display@ + -- | + -- + -- supported: @vulkan@ + -- + -- contact: @James Jones @cubanismo@ + -- + -- author: @NV@ + -- + -- type: @instance@ + -- + -- Extension number: @90@ + -- + -- Required extensions: 'VK_EXT_direct_mode_display'. + -- + -- Protected by CPP ifdef: @VK_USE_PLATFORM_XLIB_XRANDR_EXT@ + -- + + -- ** Required extensions: 'VK_EXT_direct_mode_display'. + vkAcquireXlibDisplayEXT, vkGetRandROutputDisplayEXT, + module Graphics.Vulkan.Types.Enum.VkResult, + module Graphics.Vulkan.Types.Handles, + VK_EXT_ACQUIRE_XLIB_DISPLAY_SPEC_VERSION, + pattern VK_EXT_ACQUIRE_XLIB_DISPLAY_SPEC_VERSION, + VK_EXT_ACQUIRE_XLIB_DISPLAY_EXTENSION_NAME, + pattern VK_EXT_ACQUIRE_XLIB_DISPLAY_EXTENSION_NAME) + where +import GHC.Ptr (Ptr (..)) +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Types.Enum.VkResult +import Graphics.Vulkan.Types.Handles +import Graphics.Vulkan.Types.Include (Display, RROutput) + +-- | Success codes: 'VK_SUCCESS'. +-- +-- Error codes: 'VK_ERROR_INITIALIZATION_FAILED'. +-- +-- > VkResult vkAcquireXlibDisplayEXT +-- > ( VkPhysicalDevice physicalDevice +-- > , Display* dpy +-- > , VkDisplayKHR display +-- > ) +-- +-- +foreign import ccall unsafe "vkAcquireXlibDisplayEXT" + vkAcquireXlibDisplayEXT :: + VkPhysicalDevice -- ^ physicalDevice + -> Ptr Display -- ^ dpy + -> VkDisplayKHR -- ^ display + -> IO VkResult + +-- | Success codes: 'VK_SUCCESS'. +-- +-- > VkResult vkGetRandROutputDisplayEXT +-- > ( VkPhysicalDevice physicalDevice +-- > , Display* dpy +-- > , RROutput rrOutput +-- > , VkDisplayKHR* pDisplay +-- > ) +-- +-- +foreign import ccall unsafe "vkGetRandROutputDisplayEXT" + vkGetRandROutputDisplayEXT :: + VkPhysicalDevice -- ^ physicalDevice + -> + Ptr Display -- ^ dpy + -> RROutput -- ^ rrOutput + -> Ptr VkDisplayKHR -- ^ pDisplay + -> IO VkResult + +pattern VK_EXT_ACQUIRE_XLIB_DISPLAY_SPEC_VERSION :: + (Num a, Eq a) => a + +pattern VK_EXT_ACQUIRE_XLIB_DISPLAY_SPEC_VERSION = 1 + +type VK_EXT_ACQUIRE_XLIB_DISPLAY_SPEC_VERSION = 1 + +pattern VK_EXT_ACQUIRE_XLIB_DISPLAY_EXTENSION_NAME :: CString + +pattern VK_EXT_ACQUIRE_XLIB_DISPLAY_EXTENSION_NAME <- + (is_VK_EXT_ACQUIRE_XLIB_DISPLAY_EXTENSION_NAME -> True) + where VK_EXT_ACQUIRE_XLIB_DISPLAY_EXTENSION_NAME + = _VK_EXT_ACQUIRE_XLIB_DISPLAY_EXTENSION_NAME + +{-# INLINE _VK_EXT_ACQUIRE_XLIB_DISPLAY_EXTENSION_NAME #-} + +_VK_EXT_ACQUIRE_XLIB_DISPLAY_EXTENSION_NAME :: CString +_VK_EXT_ACQUIRE_XLIB_DISPLAY_EXTENSION_NAME + = Ptr "VK_EXT_acquire_xlib_display\NUL"# + +{-# INLINE is_VK_EXT_ACQUIRE_XLIB_DISPLAY_EXTENSION_NAME #-} + +is_VK_EXT_ACQUIRE_XLIB_DISPLAY_EXTENSION_NAME :: CString -> Bool +is_VK_EXT_ACQUIRE_XLIB_DISPLAY_EXTENSION_NAME + = eqCStrings _VK_EXT_ACQUIRE_XLIB_DISPLAY_EXTENSION_NAME + +type VK_EXT_ACQUIRE_XLIB_DISPLAY_EXTENSION_NAME = + "VK_EXT_acquire_xlib_display" diff --git a/src-gen/Graphics/Vulkan/Ext/VK_EXT_blend_operation_advanced.hs b/src-gen/Graphics/Vulkan/Ext/VK_EXT_blend_operation_advanced.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Ext/VK_EXT_blend_operation_advanced.hs @@ -0,0 +1,353 @@ +{-# OPTIONS_HADDOCK not-home#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE ViewPatterns #-} +module Graphics.Vulkan.Ext.VK_EXT_blend_operation_advanced + (-- * Vulkan extension: @VK_EXT_blend_operation_advanced@ + -- | + -- + -- supported: @vulkan@ + -- + -- contact: @Jeff Bolz @jbolz@ + -- + -- author: @NV@ + -- + -- type: @device@ + -- + -- Extension number: @149@ + module Graphics.Vulkan.Marshal, + module Graphics.Vulkan.Types.Enum.VkBlendFactor, + module Graphics.Vulkan.Types.Enum.VkBlendOp, + module Graphics.Vulkan.Types.Enum.VkBlendOverlapEXT, + module Graphics.Vulkan.Types.BaseTypes, + module Graphics.Vulkan.Types.Enum.VkColorComponentFlags, + module Graphics.Vulkan.Types.Bitmasks, + module Graphics.Vulkan.Types.Struct.VkDeviceCreateInfo, + module Graphics.Vulkan.Types.Struct.VkDeviceQueueCreateInfo, + module Graphics.Vulkan.Types.Enum.VkLogicOp, + module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT, + module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT, + module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceFeatures, + module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceFeatures2KHR, + module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceLimits, + module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceProperties, + module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceProperties2KHR, + module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceSparseProperties, + module Graphics.Vulkan.Types.Enum.VkPhysicalDeviceType, + module Graphics.Vulkan.Types.Struct.VkPipelineColorBlendAdvancedStateCreateInfoEXT, + module Graphics.Vulkan.Types.Struct.VkPipelineColorBlendAttachmentState, + module Graphics.Vulkan.Types.Struct.VkPipelineColorBlendStateCreateInfo, + module Graphics.Vulkan.Types.Enum.VkSampleCountFlags, + module Graphics.Vulkan.Types.Enum.VkStructureType, + -- > #include "vk_platform.h" + VK_EXT_BLEND_OPERATION_ADVANCED_SPEC_VERSION, + pattern VK_EXT_BLEND_OPERATION_ADVANCED_SPEC_VERSION, + VK_EXT_BLEND_OPERATION_ADVANCED_EXTENSION_NAME, + pattern VK_EXT_BLEND_OPERATION_ADVANCED_EXTENSION_NAME, + pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT, + pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT, + pattern VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT, + pattern VK_BLEND_OP_ZERO_EXT, pattern VK_BLEND_OP_SRC_EXT, + pattern VK_BLEND_OP_DST_EXT, pattern VK_BLEND_OP_SRC_OVER_EXT, + pattern VK_BLEND_OP_DST_OVER_EXT, pattern VK_BLEND_OP_SRC_IN_EXT, + pattern VK_BLEND_OP_DST_IN_EXT, pattern VK_BLEND_OP_SRC_OUT_EXT, + pattern VK_BLEND_OP_DST_OUT_EXT, pattern VK_BLEND_OP_SRC_ATOP_EXT, + pattern VK_BLEND_OP_DST_ATOP_EXT, pattern VK_BLEND_OP_XOR_EXT, + pattern VK_BLEND_OP_MULTIPLY_EXT, pattern VK_BLEND_OP_SCREEN_EXT, + pattern VK_BLEND_OP_OVERLAY_EXT, pattern VK_BLEND_OP_DARKEN_EXT, + pattern VK_BLEND_OP_LIGHTEN_EXT, + pattern VK_BLEND_OP_COLORDODGE_EXT, + pattern VK_BLEND_OP_COLORBURN_EXT, + pattern VK_BLEND_OP_HARDLIGHT_EXT, + pattern VK_BLEND_OP_SOFTLIGHT_EXT, + pattern VK_BLEND_OP_DIFFERENCE_EXT, + pattern VK_BLEND_OP_EXCLUSION_EXT, pattern VK_BLEND_OP_INVERT_EXT, + pattern VK_BLEND_OP_INVERT_RGB_EXT, + pattern VK_BLEND_OP_LINEARDODGE_EXT, + pattern VK_BLEND_OP_LINEARBURN_EXT, + pattern VK_BLEND_OP_VIVIDLIGHT_EXT, + pattern VK_BLEND_OP_LINEARLIGHT_EXT, + pattern VK_BLEND_OP_PINLIGHT_EXT, pattern VK_BLEND_OP_HARDMIX_EXT, + pattern VK_BLEND_OP_HSL_HUE_EXT, + pattern VK_BLEND_OP_HSL_SATURATION_EXT, + pattern VK_BLEND_OP_HSL_COLOR_EXT, + pattern VK_BLEND_OP_HSL_LUMINOSITY_EXT, + pattern VK_BLEND_OP_PLUS_EXT, pattern VK_BLEND_OP_PLUS_CLAMPED_EXT, + pattern VK_BLEND_OP_PLUS_CLAMPED_ALPHA_EXT, + pattern VK_BLEND_OP_PLUS_DARKER_EXT, pattern VK_BLEND_OP_MINUS_EXT, + pattern VK_BLEND_OP_MINUS_CLAMPED_EXT, + pattern VK_BLEND_OP_CONTRAST_EXT, + pattern VK_BLEND_OP_INVERT_OVG_EXT, pattern VK_BLEND_OP_RED_EXT, + pattern VK_BLEND_OP_GREEN_EXT, pattern VK_BLEND_OP_BLUE_EXT, + pattern VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT) + where +import GHC.Ptr + (Ptr (..)) +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Types.BaseTypes +import Graphics.Vulkan.Types.Bitmasks +import Graphics.Vulkan.Types.Enum.VkAccessFlags + (VkAccessBitmask (..), + VkAccessFlagBits) +import Graphics.Vulkan.Types.Enum.VkBlendFactor +import Graphics.Vulkan.Types.Enum.VkBlendOp +import Graphics.Vulkan.Types.Enum.VkBlendOverlapEXT +import Graphics.Vulkan.Types.Enum.VkColorComponentFlags +import Graphics.Vulkan.Types.Enum.VkLogicOp +import Graphics.Vulkan.Types.Enum.VkPhysicalDeviceType +import Graphics.Vulkan.Types.Enum.VkSampleCountFlags +import Graphics.Vulkan.Types.Enum.VkStructureType +import Graphics.Vulkan.Types.Struct.VkDeviceCreateInfo +import Graphics.Vulkan.Types.Struct.VkDeviceQueueCreateInfo +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceFeatures +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceFeatures2KHR +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceLimits +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceProperties +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceProperties2KHR +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceSparseProperties +import Graphics.Vulkan.Types.Struct.VkPipelineColorBlendAdvancedStateCreateInfoEXT +import Graphics.Vulkan.Types.Struct.VkPipelineColorBlendAttachmentState +import Graphics.Vulkan.Types.Struct.VkPipelineColorBlendStateCreateInfo + +pattern VK_EXT_BLEND_OPERATION_ADVANCED_SPEC_VERSION :: + (Num a, Eq a) => a + +pattern VK_EXT_BLEND_OPERATION_ADVANCED_SPEC_VERSION = 2 + +type VK_EXT_BLEND_OPERATION_ADVANCED_SPEC_VERSION = 2 + +pattern VK_EXT_BLEND_OPERATION_ADVANCED_EXTENSION_NAME :: CString + +pattern VK_EXT_BLEND_OPERATION_ADVANCED_EXTENSION_NAME <- + (is_VK_EXT_BLEND_OPERATION_ADVANCED_EXTENSION_NAME -> True) + where VK_EXT_BLEND_OPERATION_ADVANCED_EXTENSION_NAME + = _VK_EXT_BLEND_OPERATION_ADVANCED_EXTENSION_NAME + +{-# INLINE _VK_EXT_BLEND_OPERATION_ADVANCED_EXTENSION_NAME #-} + +_VK_EXT_BLEND_OPERATION_ADVANCED_EXTENSION_NAME :: CString +_VK_EXT_BLEND_OPERATION_ADVANCED_EXTENSION_NAME + = Ptr "VK_EXT_blend_operation_advanced\NUL"# + +{-# INLINE is_VK_EXT_BLEND_OPERATION_ADVANCED_EXTENSION_NAME #-} + +is_VK_EXT_BLEND_OPERATION_ADVANCED_EXTENSION_NAME :: + CString -> Bool +is_VK_EXT_BLEND_OPERATION_ADVANCED_EXTENSION_NAME + = eqCStrings _VK_EXT_BLEND_OPERATION_ADVANCED_EXTENSION_NAME + +type VK_EXT_BLEND_OPERATION_ADVANCED_EXTENSION_NAME = + "VK_EXT_blend_operation_advanced" + +pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT + :: VkStructureType + +pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT + = VkStructureType 1000148000 + +pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT + :: VkStructureType + +pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT + = VkStructureType 1000148001 + +pattern VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT + :: VkStructureType + +pattern VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT + = VkStructureType 1000148002 + +pattern VK_BLEND_OP_ZERO_EXT :: VkBlendOp + +pattern VK_BLEND_OP_ZERO_EXT = VkBlendOp 1000148000 + +pattern VK_BLEND_OP_SRC_EXT :: VkBlendOp + +pattern VK_BLEND_OP_SRC_EXT = VkBlendOp 1000148001 + +pattern VK_BLEND_OP_DST_EXT :: VkBlendOp + +pattern VK_BLEND_OP_DST_EXT = VkBlendOp 1000148002 + +pattern VK_BLEND_OP_SRC_OVER_EXT :: VkBlendOp + +pattern VK_BLEND_OP_SRC_OVER_EXT = VkBlendOp 1000148003 + +pattern VK_BLEND_OP_DST_OVER_EXT :: VkBlendOp + +pattern VK_BLEND_OP_DST_OVER_EXT = VkBlendOp 1000148004 + +pattern VK_BLEND_OP_SRC_IN_EXT :: VkBlendOp + +pattern VK_BLEND_OP_SRC_IN_EXT = VkBlendOp 1000148005 + +pattern VK_BLEND_OP_DST_IN_EXT :: VkBlendOp + +pattern VK_BLEND_OP_DST_IN_EXT = VkBlendOp 1000148006 + +pattern VK_BLEND_OP_SRC_OUT_EXT :: VkBlendOp + +pattern VK_BLEND_OP_SRC_OUT_EXT = VkBlendOp 1000148007 + +pattern VK_BLEND_OP_DST_OUT_EXT :: VkBlendOp + +pattern VK_BLEND_OP_DST_OUT_EXT = VkBlendOp 1000148008 + +pattern VK_BLEND_OP_SRC_ATOP_EXT :: VkBlendOp + +pattern VK_BLEND_OP_SRC_ATOP_EXT = VkBlendOp 1000148009 + +pattern VK_BLEND_OP_DST_ATOP_EXT :: VkBlendOp + +pattern VK_BLEND_OP_DST_ATOP_EXT = VkBlendOp 1000148010 + +pattern VK_BLEND_OP_XOR_EXT :: VkBlendOp + +pattern VK_BLEND_OP_XOR_EXT = VkBlendOp 1000148011 + +pattern VK_BLEND_OP_MULTIPLY_EXT :: VkBlendOp + +pattern VK_BLEND_OP_MULTIPLY_EXT = VkBlendOp 1000148012 + +pattern VK_BLEND_OP_SCREEN_EXT :: VkBlendOp + +pattern VK_BLEND_OP_SCREEN_EXT = VkBlendOp 1000148013 + +pattern VK_BLEND_OP_OVERLAY_EXT :: VkBlendOp + +pattern VK_BLEND_OP_OVERLAY_EXT = VkBlendOp 1000148014 + +pattern VK_BLEND_OP_DARKEN_EXT :: VkBlendOp + +pattern VK_BLEND_OP_DARKEN_EXT = VkBlendOp 1000148015 + +pattern VK_BLEND_OP_LIGHTEN_EXT :: VkBlendOp + +pattern VK_BLEND_OP_LIGHTEN_EXT = VkBlendOp 1000148016 + +pattern VK_BLEND_OP_COLORDODGE_EXT :: VkBlendOp + +pattern VK_BLEND_OP_COLORDODGE_EXT = VkBlendOp 1000148017 + +pattern VK_BLEND_OP_COLORBURN_EXT :: VkBlendOp + +pattern VK_BLEND_OP_COLORBURN_EXT = VkBlendOp 1000148018 + +pattern VK_BLEND_OP_HARDLIGHT_EXT :: VkBlendOp + +pattern VK_BLEND_OP_HARDLIGHT_EXT = VkBlendOp 1000148019 + +pattern VK_BLEND_OP_SOFTLIGHT_EXT :: VkBlendOp + +pattern VK_BLEND_OP_SOFTLIGHT_EXT = VkBlendOp 1000148020 + +pattern VK_BLEND_OP_DIFFERENCE_EXT :: VkBlendOp + +pattern VK_BLEND_OP_DIFFERENCE_EXT = VkBlendOp 1000148021 + +pattern VK_BLEND_OP_EXCLUSION_EXT :: VkBlendOp + +pattern VK_BLEND_OP_EXCLUSION_EXT = VkBlendOp 1000148022 + +pattern VK_BLEND_OP_INVERT_EXT :: VkBlendOp + +pattern VK_BLEND_OP_INVERT_EXT = VkBlendOp 1000148023 + +pattern VK_BLEND_OP_INVERT_RGB_EXT :: VkBlendOp + +pattern VK_BLEND_OP_INVERT_RGB_EXT = VkBlendOp 1000148024 + +pattern VK_BLEND_OP_LINEARDODGE_EXT :: VkBlendOp + +pattern VK_BLEND_OP_LINEARDODGE_EXT = VkBlendOp 1000148025 + +pattern VK_BLEND_OP_LINEARBURN_EXT :: VkBlendOp + +pattern VK_BLEND_OP_LINEARBURN_EXT = VkBlendOp 1000148026 + +pattern VK_BLEND_OP_VIVIDLIGHT_EXT :: VkBlendOp + +pattern VK_BLEND_OP_VIVIDLIGHT_EXT = VkBlendOp 1000148027 + +pattern VK_BLEND_OP_LINEARLIGHT_EXT :: VkBlendOp + +pattern VK_BLEND_OP_LINEARLIGHT_EXT = VkBlendOp 1000148028 + +pattern VK_BLEND_OP_PINLIGHT_EXT :: VkBlendOp + +pattern VK_BLEND_OP_PINLIGHT_EXT = VkBlendOp 1000148029 + +pattern VK_BLEND_OP_HARDMIX_EXT :: VkBlendOp + +pattern VK_BLEND_OP_HARDMIX_EXT = VkBlendOp 1000148030 + +pattern VK_BLEND_OP_HSL_HUE_EXT :: VkBlendOp + +pattern VK_BLEND_OP_HSL_HUE_EXT = VkBlendOp 1000148031 + +pattern VK_BLEND_OP_HSL_SATURATION_EXT :: VkBlendOp + +pattern VK_BLEND_OP_HSL_SATURATION_EXT = VkBlendOp 1000148032 + +pattern VK_BLEND_OP_HSL_COLOR_EXT :: VkBlendOp + +pattern VK_BLEND_OP_HSL_COLOR_EXT = VkBlendOp 1000148033 + +pattern VK_BLEND_OP_HSL_LUMINOSITY_EXT :: VkBlendOp + +pattern VK_BLEND_OP_HSL_LUMINOSITY_EXT = VkBlendOp 1000148034 + +pattern VK_BLEND_OP_PLUS_EXT :: VkBlendOp + +pattern VK_BLEND_OP_PLUS_EXT = VkBlendOp 1000148035 + +pattern VK_BLEND_OP_PLUS_CLAMPED_EXT :: VkBlendOp + +pattern VK_BLEND_OP_PLUS_CLAMPED_EXT = VkBlendOp 1000148036 + +pattern VK_BLEND_OP_PLUS_CLAMPED_ALPHA_EXT :: VkBlendOp + +pattern VK_BLEND_OP_PLUS_CLAMPED_ALPHA_EXT = VkBlendOp 1000148037 + +pattern VK_BLEND_OP_PLUS_DARKER_EXT :: VkBlendOp + +pattern VK_BLEND_OP_PLUS_DARKER_EXT = VkBlendOp 1000148038 + +pattern VK_BLEND_OP_MINUS_EXT :: VkBlendOp + +pattern VK_BLEND_OP_MINUS_EXT = VkBlendOp 1000148039 + +pattern VK_BLEND_OP_MINUS_CLAMPED_EXT :: VkBlendOp + +pattern VK_BLEND_OP_MINUS_CLAMPED_EXT = VkBlendOp 1000148040 + +pattern VK_BLEND_OP_CONTRAST_EXT :: VkBlendOp + +pattern VK_BLEND_OP_CONTRAST_EXT = VkBlendOp 1000148041 + +pattern VK_BLEND_OP_INVERT_OVG_EXT :: VkBlendOp + +pattern VK_BLEND_OP_INVERT_OVG_EXT = VkBlendOp 1000148042 + +pattern VK_BLEND_OP_RED_EXT :: VkBlendOp + +pattern VK_BLEND_OP_RED_EXT = VkBlendOp 1000148043 + +pattern VK_BLEND_OP_GREEN_EXT :: VkBlendOp + +pattern VK_BLEND_OP_GREEN_EXT = VkBlendOp 1000148044 + +pattern VK_BLEND_OP_BLUE_EXT :: VkBlendOp + +pattern VK_BLEND_OP_BLUE_EXT = VkBlendOp 1000148045 + +-- | bitpos = @19@ +pattern VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT :: + VkAccessFlagBits + +pattern VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT = + VkAccessFlagBits 524288 diff --git a/src-gen/Graphics/Vulkan/Ext/VK_EXT_conservative_rasterization.hs b/src-gen/Graphics/Vulkan/Ext/VK_EXT_conservative_rasterization.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Ext/VK_EXT_conservative_rasterization.hs @@ -0,0 +1,110 @@ +{-# OPTIONS_HADDOCK not-home#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE ViewPatterns #-} +module Graphics.Vulkan.Ext.VK_EXT_conservative_rasterization + (-- * Vulkan extension: @VK_EXT_conservative_rasterization@ + -- | + -- + -- supported: @vulkan@ + -- + -- contact: @Piers Daniell @pdaniell@ + -- + -- author: @NV@ + -- + -- type: @device@ + -- + -- Extension number: @102@ + -- + -- Required extensions: 'VK_KHR_get_physical_device_properties2'. + -- + + -- ** Required extensions: 'VK_KHR_get_physical_device_properties2'. + module Graphics.Vulkan.Marshal, + module Graphics.Vulkan.Types.BaseTypes, + module Graphics.Vulkan.Types.Enum.VkConservativeRasterizationModeEXT, + module Graphics.Vulkan.Types.Enum.VkCullModeFlags, + module Graphics.Vulkan.Types.Enum.VkFrontFace, + module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceConservativeRasterizationPropertiesEXT, + module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceLimits, + module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceProperties, + module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceProperties2KHR, + module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceSparseProperties, + module Graphics.Vulkan.Types.Enum.VkPhysicalDeviceType, + module Graphics.Vulkan.Types.Bitmasks, + module Graphics.Vulkan.Types.Struct.VkPipelineRasterizationConservativeStateCreateInfoEXT, + module Graphics.Vulkan.Types.Struct.VkPipelineRasterizationStateCreateInfo, + module Graphics.Vulkan.Types.Enum.VkPolygonMode, + module Graphics.Vulkan.Types.Enum.VkSampleCountFlags, + module Graphics.Vulkan.Types.Enum.VkStructureType, + -- > #include "vk_platform.h" + VK_EXT_CONSERVATIVE_RASTERIZATION_SPEC_VERSION, + pattern VK_EXT_CONSERVATIVE_RASTERIZATION_SPEC_VERSION, + VK_EXT_CONSERVATIVE_RASTERIZATION_EXTENSION_NAME, + pattern VK_EXT_CONSERVATIVE_RASTERIZATION_EXTENSION_NAME, + pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT, + pattern VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT) + where +import GHC.Ptr + (Ptr (..)) +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Types.BaseTypes +import Graphics.Vulkan.Types.Bitmasks +import Graphics.Vulkan.Types.Enum.VkConservativeRasterizationModeEXT +import Graphics.Vulkan.Types.Enum.VkCullModeFlags +import Graphics.Vulkan.Types.Enum.VkFrontFace +import Graphics.Vulkan.Types.Enum.VkPhysicalDeviceType +import Graphics.Vulkan.Types.Enum.VkPolygonMode +import Graphics.Vulkan.Types.Enum.VkSampleCountFlags +import Graphics.Vulkan.Types.Enum.VkStructureType +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceConservativeRasterizationPropertiesEXT +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceLimits +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceProperties +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceProperties2KHR +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceSparseProperties +import Graphics.Vulkan.Types.Struct.VkPipelineRasterizationConservativeStateCreateInfoEXT +import Graphics.Vulkan.Types.Struct.VkPipelineRasterizationStateCreateInfo + +pattern VK_EXT_CONSERVATIVE_RASTERIZATION_SPEC_VERSION :: + (Num a, Eq a) => a + +pattern VK_EXT_CONSERVATIVE_RASTERIZATION_SPEC_VERSION = 1 + +type VK_EXT_CONSERVATIVE_RASTERIZATION_SPEC_VERSION = 1 + +pattern VK_EXT_CONSERVATIVE_RASTERIZATION_EXTENSION_NAME :: CString + +pattern VK_EXT_CONSERVATIVE_RASTERIZATION_EXTENSION_NAME <- + (is_VK_EXT_CONSERVATIVE_RASTERIZATION_EXTENSION_NAME -> True) + where VK_EXT_CONSERVATIVE_RASTERIZATION_EXTENSION_NAME + = _VK_EXT_CONSERVATIVE_RASTERIZATION_EXTENSION_NAME + +{-# INLINE _VK_EXT_CONSERVATIVE_RASTERIZATION_EXTENSION_NAME #-} + +_VK_EXT_CONSERVATIVE_RASTERIZATION_EXTENSION_NAME :: CString +_VK_EXT_CONSERVATIVE_RASTERIZATION_EXTENSION_NAME + = Ptr "VK_EXT_conservative_rasterization\NUL"# + +{-# INLINE is_VK_EXT_CONSERVATIVE_RASTERIZATION_EXTENSION_NAME #-} + +is_VK_EXT_CONSERVATIVE_RASTERIZATION_EXTENSION_NAME :: + CString -> Bool +is_VK_EXT_CONSERVATIVE_RASTERIZATION_EXTENSION_NAME + = eqCStrings _VK_EXT_CONSERVATIVE_RASTERIZATION_EXTENSION_NAME + +type VK_EXT_CONSERVATIVE_RASTERIZATION_EXTENSION_NAME = + "VK_EXT_conservative_rasterization" + +pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT + :: VkStructureType + +pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT + = VkStructureType 1000101000 + +pattern VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT + :: VkStructureType + +pattern VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT + = VkStructureType 1000101001 diff --git a/src-gen/Graphics/Vulkan/Ext/VK_EXT_debug_marker.hs b/src-gen/Graphics/Vulkan/Ext/VK_EXT_debug_marker.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Ext/VK_EXT_debug_marker.hs @@ -0,0 +1,176 @@ +{-# OPTIONS_HADDOCK not-home#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE ForeignFunctionInterface #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE ViewPatterns #-} +module Graphics.Vulkan.Ext.VK_EXT_debug_marker + (-- * Vulkan extension: @VK_EXT_debug_marker@ + -- | + -- + -- supported: @vulkan@ + -- + -- contact: @baldurk@baldurk.org@ + -- + -- author: @Baldur Karlsson@ + -- + -- type: @device@ + -- + -- Extension number: @23@ + -- + -- Required extensions: 'VK_EXT_debug_report'. + -- + + -- ** Required extensions: 'VK_EXT_debug_report'. + module Graphics.Vulkan.Marshal, + module Graphics.Vulkan.Types.Struct.VkDebugMarkerMarkerInfoEXT, + module Graphics.Vulkan.Types.Struct.VkDebugMarkerObjectNameInfoEXT, + module Graphics.Vulkan.Types.Struct.VkDebugMarkerObjectTagInfoEXT, + module Graphics.Vulkan.Types.Enum.VkDebugReportObjectTypeEXT, + module Graphics.Vulkan.Types.Enum.VkStructureType, + -- > #include "vk_platform.h" + vkDebugMarkerSetObjectTagEXT, vkDebugMarkerSetObjectNameEXT, + vkCmdDebugMarkerBeginEXT, vkCmdDebugMarkerEndEXT, + vkCmdDebugMarkerInsertEXT, + module Graphics.Vulkan.Types.Enum.VkResult, + module Graphics.Vulkan.Types.Handles, + VK_EXT_DEBUG_MARKER_SPEC_VERSION, + pattern VK_EXT_DEBUG_MARKER_SPEC_VERSION, + VK_EXT_DEBUG_MARKER_EXTENSION_NAME, + pattern VK_EXT_DEBUG_MARKER_EXTENSION_NAME, + pattern VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT, + pattern VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT, + pattern VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT) + where +import GHC.Ptr (Ptr (..)) +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Types.Enum.VkDebugReportObjectTypeEXT +import Graphics.Vulkan.Types.Enum.VkResult +import Graphics.Vulkan.Types.Enum.VkStructureType +import Graphics.Vulkan.Types.Handles +import Graphics.Vulkan.Types.Struct.VkDebugMarkerMarkerInfoEXT +import Graphics.Vulkan.Types.Struct.VkDebugMarkerObjectNameInfoEXT +import Graphics.Vulkan.Types.Struct.VkDebugMarkerObjectTagInfoEXT + +-- | Success codes: 'VK_SUCCESS'. +-- +-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. +-- +-- > VkResult vkDebugMarkerSetObjectTagEXT +-- > ( VkDevice device +-- > , const VkDebugMarkerObjectTagInfoEXT* pTagInfo +-- > ) +-- +-- +foreign import ccall unsafe "vkDebugMarkerSetObjectTagEXT" + vkDebugMarkerSetObjectTagEXT :: + VkDevice -- ^ device + -> Ptr VkDebugMarkerObjectTagInfoEXT -- ^ pTagInfo + -> IO VkResult + +-- | Success codes: 'VK_SUCCESS'. +-- +-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. +-- +-- > VkResult vkDebugMarkerSetObjectNameEXT +-- > ( VkDevice device +-- > , const VkDebugMarkerObjectNameInfoEXT* pNameInfo +-- > ) +-- +-- +foreign import ccall unsafe "vkDebugMarkerSetObjectNameEXT" + vkDebugMarkerSetObjectNameEXT :: + VkDevice -- ^ device + -> Ptr VkDebugMarkerObjectNameInfoEXT -- ^ pNameInfo + -> IO VkResult + +-- | queues: 'graphics', 'compute'. +-- +-- renderpass: @both@ +-- +-- > () vkCmdDebugMarkerBeginEXT +-- > ( VkCommandBuffer commandBuffer +-- > , const VkDebugMarkerMarkerInfoEXT* pMarkerInfo +-- > ) +-- +-- +foreign import ccall unsafe "vkCmdDebugMarkerBeginEXT" + vkCmdDebugMarkerBeginEXT :: + VkCommandBuffer -- ^ commandBuffer + -> Ptr VkDebugMarkerMarkerInfoEXT -- ^ pMarkerInfo + -> IO () + +-- | queues: 'graphics', 'compute'. +-- +-- renderpass: @both@ +-- +-- > () vkCmdDebugMarkerEndEXT +-- > ( VkCommandBuffer commandBuffer +-- > ) +-- +-- +foreign import ccall unsafe "vkCmdDebugMarkerEndEXT" + vkCmdDebugMarkerEndEXT :: VkCommandBuffer -- ^ commandBuffer + -> IO () + +-- | queues: 'graphics', 'compute'. +-- +-- renderpass: @both@ +-- +-- > () vkCmdDebugMarkerInsertEXT +-- > ( VkCommandBuffer commandBuffer +-- > , const VkDebugMarkerMarkerInfoEXT* pMarkerInfo +-- > ) +-- +-- +foreign import ccall unsafe "vkCmdDebugMarkerInsertEXT" + vkCmdDebugMarkerInsertEXT :: + VkCommandBuffer -- ^ commandBuffer + -> Ptr VkDebugMarkerMarkerInfoEXT -- ^ pMarkerInfo + -> IO () + +pattern VK_EXT_DEBUG_MARKER_SPEC_VERSION :: (Num a, Eq a) => a + +pattern VK_EXT_DEBUG_MARKER_SPEC_VERSION = 4 + +type VK_EXT_DEBUG_MARKER_SPEC_VERSION = 4 + +pattern VK_EXT_DEBUG_MARKER_EXTENSION_NAME :: CString + +pattern VK_EXT_DEBUG_MARKER_EXTENSION_NAME <- + (is_VK_EXT_DEBUG_MARKER_EXTENSION_NAME -> True) + where VK_EXT_DEBUG_MARKER_EXTENSION_NAME + = _VK_EXT_DEBUG_MARKER_EXTENSION_NAME + +{-# INLINE _VK_EXT_DEBUG_MARKER_EXTENSION_NAME #-} + +_VK_EXT_DEBUG_MARKER_EXTENSION_NAME :: CString +_VK_EXT_DEBUG_MARKER_EXTENSION_NAME + = Ptr "VK_EXT_debug_marker\NUL"# + +{-# INLINE is_VK_EXT_DEBUG_MARKER_EXTENSION_NAME #-} + +is_VK_EXT_DEBUG_MARKER_EXTENSION_NAME :: CString -> Bool +is_VK_EXT_DEBUG_MARKER_EXTENSION_NAME + = eqCStrings _VK_EXT_DEBUG_MARKER_EXTENSION_NAME + +type VK_EXT_DEBUG_MARKER_EXTENSION_NAME = "VK_EXT_debug_marker" + +pattern VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT = + VkStructureType 1000022000 + +pattern VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT = + VkStructureType 1000022001 + +pattern VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT = + VkStructureType 1000022002 diff --git a/src-gen/Graphics/Vulkan/Ext/VK_EXT_debug_report.hs b/src-gen/Graphics/Vulkan/Ext/VK_EXT_debug_report.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Ext/VK_EXT_debug_report.hs @@ -0,0 +1,181 @@ +{-# OPTIONS_GHC -fno-warn-missing-pattern-synonym-signatures#-} +{-# OPTIONS_GHC -fno-warn-unused-imports#-} +{-# OPTIONS_HADDOCK not-home#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE ForeignFunctionInterface #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE ViewPatterns #-} +module Graphics.Vulkan.Ext.VK_EXT_debug_report + (-- * Vulkan extension: @VK_EXT_debug_report@ + -- | + -- + -- supported: @vulkan@ + -- + -- contact: @Courtney Goeltzenleuchter @courtney@ + -- + -- author: @GOOGLE@ + -- + -- type: @instance@ + -- + -- Extension number: @12@ + module Graphics.Vulkan.Marshal, + module Graphics.Vulkan.Types.Struct.VkApplicationInfo, + module Graphics.Vulkan.Types.BaseTypes, + module Graphics.Vulkan.Types.Struct.VkDebugReportCallbackCreateInfoEXT, + module Graphics.Vulkan.Types.Enum.VkDebugReportFlagsEXT, + module Graphics.Vulkan.Types.Enum.VkDebugReportObjectTypeEXT, + module Graphics.Vulkan.Types.Bitmasks, + module Graphics.Vulkan.Types.Struct.VkInstanceCreateInfo, + module Graphics.Vulkan.Types.Enum.VkStructureType, + -- > #include "vk_platform.h" + vkCreateDebugReportCallbackEXT, vkDestroyDebugReportCallbackEXT, + vkDebugReportMessageEXT, + module Graphics.Vulkan.Types.Enum.VkInternalAllocationType, + module Graphics.Vulkan.Types.Enum.VkResult, + module Graphics.Vulkan.Types.Enum.VkSystemAllocationScope, + module Graphics.Vulkan.Types.Funcpointers, + module Graphics.Vulkan.Types.Handles, + module Graphics.Vulkan.Types.Struct.VkAllocationCallbacks, + VK_EXT_DEBUG_REPORT_SPEC_VERSION, + pattern VK_EXT_DEBUG_REPORT_SPEC_VERSION, + VK_EXT_DEBUG_REPORT_EXTENSION_NAME, + pattern VK_EXT_DEBUG_REPORT_EXTENSION_NAME, + pattern VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT, + pattern VK_ERROR_VALIDATION_FAILED_EXT, + pattern VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT, + pattern VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT, + pattern VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT) + where +import GHC.Ptr (Ptr (..)) +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Types.BaseTypes +import Graphics.Vulkan.Types.Bitmasks +import Graphics.Vulkan.Types.Enum.VkDebugReportFlagsEXT +import Graphics.Vulkan.Types.Enum.VkDebugReportObjectTypeEXT +import Graphics.Vulkan.Types.Enum.VkInternalAllocationType +import Graphics.Vulkan.Types.Enum.VkObjectType (VkObjectType (..)) +import Graphics.Vulkan.Types.Enum.VkResult +import Graphics.Vulkan.Types.Enum.VkStructureType +import Graphics.Vulkan.Types.Enum.VkSystemAllocationScope +import Graphics.Vulkan.Types.Funcpointers +import Graphics.Vulkan.Types.Handles +import Graphics.Vulkan.Types.Struct.VkAllocationCallbacks +import Graphics.Vulkan.Types.Struct.VkApplicationInfo +import Graphics.Vulkan.Types.Struct.VkDebugReportCallbackCreateInfoEXT +import Graphics.Vulkan.Types.Struct.VkInstanceCreateInfo + +-- | Success codes: 'VK_SUCCESS'. +-- +-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY'. +-- +-- > VkResult vkCreateDebugReportCallbackEXT +-- > ( VkInstance instance +-- > , const VkDebugReportCallbackCreateInfoEXT* pCreateInfo +-- > , const VkAllocationCallbacks* pAllocator +-- > , VkDebugReportCallbackEXT* pCallback +-- > ) +-- +-- +foreign import ccall unsafe "vkCreateDebugReportCallbackEXT" + vkCreateDebugReportCallbackEXT :: + VkInstance -- ^ instance + -> + Ptr VkDebugReportCallbackCreateInfoEXT -- ^ pCreateInfo + -> + Ptr VkAllocationCallbacks -- ^ pAllocator + -> + Ptr VkDebugReportCallbackEXT -- ^ pCallback + -> IO VkResult + +-- | > () vkDestroyDebugReportCallbackEXT +-- > ( VkInstance instance +-- > , VkDebugReportCallbackEXT callback +-- > , const VkAllocationCallbacks* pAllocator +-- > ) +-- +-- +foreign import ccall unsafe "vkDestroyDebugReportCallbackEXT" + vkDestroyDebugReportCallbackEXT :: + VkInstance -- ^ instance + -> + VkDebugReportCallbackEXT -- ^ callback + -> Ptr VkAllocationCallbacks -- ^ pAllocator + -> IO () + +-- | > () vkDebugReportMessageEXT +-- > ( VkInstance instance +-- > , VkDebugReportFlagsEXT flags +-- > , VkDebugReportObjectTypeEXT objectType +-- > , uint64_t object +-- > , size_t location +-- > , int32_t messageCode +-- > , const char* pLayerPrefix +-- > , const char* pMessage +-- > ) +-- +-- +foreign import ccall unsafe "vkDebugReportMessageEXT" + vkDebugReportMessageEXT :: + VkInstance -- ^ instance + -> + VkDebugReportFlagsEXT -- ^ flags + -> + VkDebugReportObjectTypeEXT -- ^ objectType + -> + Word64 -- ^ object + -> CSize -- ^ location + -> Int32 -- ^ messageCode + -> CString -- ^ pLayerPrefix + -> CString -- ^ pMessage + -> IO () + +pattern VK_EXT_DEBUG_REPORT_SPEC_VERSION :: (Num a, Eq a) => a + +pattern VK_EXT_DEBUG_REPORT_SPEC_VERSION = 9 + +type VK_EXT_DEBUG_REPORT_SPEC_VERSION = 9 + +pattern VK_EXT_DEBUG_REPORT_EXTENSION_NAME :: CString + +pattern VK_EXT_DEBUG_REPORT_EXTENSION_NAME <- + (is_VK_EXT_DEBUG_REPORT_EXTENSION_NAME -> True) + where VK_EXT_DEBUG_REPORT_EXTENSION_NAME + = _VK_EXT_DEBUG_REPORT_EXTENSION_NAME + +{-# INLINE _VK_EXT_DEBUG_REPORT_EXTENSION_NAME #-} + +_VK_EXT_DEBUG_REPORT_EXTENSION_NAME :: CString +_VK_EXT_DEBUG_REPORT_EXTENSION_NAME + = Ptr "VK_EXT_debug_report\NUL"# + +{-# INLINE is_VK_EXT_DEBUG_REPORT_EXTENSION_NAME #-} + +is_VK_EXT_DEBUG_REPORT_EXTENSION_NAME :: CString -> Bool +is_VK_EXT_DEBUG_REPORT_EXTENSION_NAME + = eqCStrings _VK_EXT_DEBUG_REPORT_EXTENSION_NAME + +type VK_EXT_DEBUG_REPORT_EXTENSION_NAME = "VK_EXT_debug_report" + +pattern VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT = + VkStructureType 1000011000 + +pattern VK_ERROR_VALIDATION_FAILED_EXT :: VkResult + +pattern VK_ERROR_VALIDATION_FAILED_EXT = VkResult (-1000011001) + +pattern VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT = + VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT + +-- | VkDebugReportCallbackEXT +pattern VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT :: VkObjectType + +pattern VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT = + VkObjectType 1000011000 + +pattern VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT = + VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT diff --git a/src-gen/Graphics/Vulkan/Ext/VK_EXT_depth_range_unrestricted.hs b/src-gen/Graphics/Vulkan/Ext/VK_EXT_depth_range_unrestricted.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Ext/VK_EXT_depth_range_unrestricted.hs @@ -0,0 +1,56 @@ +{-# OPTIONS_HADDOCK not-home#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE ViewPatterns #-} +module Graphics.Vulkan.Ext.VK_EXT_depth_range_unrestricted + (-- * Vulkan extension: @VK_EXT_depth_range_unrestricted@ + -- | + -- + -- supported: @vulkan@ + -- + -- contact: @Piers Daniell @pdaniell@ + -- + -- author: @NV@ + -- + -- type: @device@ + -- + -- Extension number: @14@ + VK_EXT_DEPTH_RANGE_UNRESTRICTED_SPEC_VERSION, + pattern VK_EXT_DEPTH_RANGE_UNRESTRICTED_SPEC_VERSION, + VK_EXT_DEPTH_RANGE_UNRESTRICTED_EXTENSION_NAME, + pattern VK_EXT_DEPTH_RANGE_UNRESTRICTED_EXTENSION_NAME) + where +import GHC.Ptr (Ptr (..)) +import Graphics.Vulkan.Marshal + +pattern VK_EXT_DEPTH_RANGE_UNRESTRICTED_SPEC_VERSION :: + (Num a, Eq a) => a + +pattern VK_EXT_DEPTH_RANGE_UNRESTRICTED_SPEC_VERSION = 1 + +type VK_EXT_DEPTH_RANGE_UNRESTRICTED_SPEC_VERSION = 1 + +pattern VK_EXT_DEPTH_RANGE_UNRESTRICTED_EXTENSION_NAME :: CString + +pattern VK_EXT_DEPTH_RANGE_UNRESTRICTED_EXTENSION_NAME <- + (is_VK_EXT_DEPTH_RANGE_UNRESTRICTED_EXTENSION_NAME -> True) + where VK_EXT_DEPTH_RANGE_UNRESTRICTED_EXTENSION_NAME + = _VK_EXT_DEPTH_RANGE_UNRESTRICTED_EXTENSION_NAME + +{-# INLINE _VK_EXT_DEPTH_RANGE_UNRESTRICTED_EXTENSION_NAME #-} + +_VK_EXT_DEPTH_RANGE_UNRESTRICTED_EXTENSION_NAME :: CString +_VK_EXT_DEPTH_RANGE_UNRESTRICTED_EXTENSION_NAME + = Ptr "VK_EXT_depth_range_unrestricted\NUL"# + +{-# INLINE is_VK_EXT_DEPTH_RANGE_UNRESTRICTED_EXTENSION_NAME #-} + +is_VK_EXT_DEPTH_RANGE_UNRESTRICTED_EXTENSION_NAME :: + CString -> Bool +is_VK_EXT_DEPTH_RANGE_UNRESTRICTED_EXTENSION_NAME + = eqCStrings _VK_EXT_DEPTH_RANGE_UNRESTRICTED_EXTENSION_NAME + +type VK_EXT_DEPTH_RANGE_UNRESTRICTED_EXTENSION_NAME = + "VK_EXT_depth_range_unrestricted" diff --git a/src-gen/Graphics/Vulkan/Ext/VK_EXT_direct_mode_display.hs b/src-gen/Graphics/Vulkan/Ext/VK_EXT_direct_mode_display.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Ext/VK_EXT_direct_mode_display.hs @@ -0,0 +1,79 @@ +{-# OPTIONS_HADDOCK not-home#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE ForeignFunctionInterface #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE ViewPatterns #-} +module Graphics.Vulkan.Ext.VK_EXT_direct_mode_display + (-- * Vulkan extension: @VK_EXT_direct_mode_display@ + -- | + -- + -- supported: @vulkan@ + -- + -- contact: @James Jones @cubanismo@ + -- + -- author: @NV@ + -- + -- type: @instance@ + -- + -- Extension number: @89@ + -- + -- Required extensions: 'VK_KHR_display'. + -- + + -- ** Required extensions: 'VK_KHR_display'. + vkReleaseDisplayEXT, module Graphics.Vulkan.Types.Enum.VkResult, + module Graphics.Vulkan.Types.Handles, + VK_EXT_DIRECT_MODE_DISPLAY_SPEC_VERSION, + pattern VK_EXT_DIRECT_MODE_DISPLAY_SPEC_VERSION, + VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME, + pattern VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME) + where +import GHC.Ptr (Ptr (..)) +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Types.Enum.VkResult +import Graphics.Vulkan.Types.Handles + +-- | Success codes: 'VK_SUCCESS'. +-- +-- > VkResult vkReleaseDisplayEXT +-- > ( VkPhysicalDevice physicalDevice +-- > , VkDisplayKHR display +-- > ) +-- +-- +foreign import ccall unsafe "vkReleaseDisplayEXT" + vkReleaseDisplayEXT :: + VkPhysicalDevice -- ^ physicalDevice + -> VkDisplayKHR -- ^ display + -> IO VkResult + +pattern VK_EXT_DIRECT_MODE_DISPLAY_SPEC_VERSION :: (Num a, Eq a) => + a + +pattern VK_EXT_DIRECT_MODE_DISPLAY_SPEC_VERSION = 1 + +type VK_EXT_DIRECT_MODE_DISPLAY_SPEC_VERSION = 1 + +pattern VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME :: CString + +pattern VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME <- + (is_VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME -> True) + where VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME + = _VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME + +{-# INLINE _VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME #-} + +_VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME :: CString +_VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME + = Ptr "VK_EXT_direct_mode_display\NUL"# + +{-# INLINE is_VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME #-} + +is_VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME :: CString -> Bool +is_VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME + = eqCStrings _VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME + +type VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME = + "VK_EXT_direct_mode_display" diff --git a/src-gen/Graphics/Vulkan/Ext/VK_EXT_discard_rectangles.hs b/src-gen/Graphics/Vulkan/Ext/VK_EXT_discard_rectangles.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Ext/VK_EXT_discard_rectangles.hs @@ -0,0 +1,202 @@ +{-# OPTIONS_HADDOCK not-home#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE ForeignFunctionInterface #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE ViewPatterns #-} +module Graphics.Vulkan.Ext.VK_EXT_discard_rectangles + (-- * Vulkan extension: @VK_EXT_discard_rectangles@ + -- | + -- + -- supported: @vulkan@ + -- + -- contact: @Piers Daniell @pdaniell@ + -- + -- author: @NV@ + -- + -- type: @device@ + -- + -- Extension number: @100@ + -- + -- Required extensions: 'VK_KHR_get_physical_device_properties2'. + -- + + -- ** Required extensions: 'VK_KHR_get_physical_device_properties2'. + module Graphics.Vulkan.Marshal, + module Graphics.Vulkan.Types.Enum.VkBlendFactor, + module Graphics.Vulkan.Types.Enum.VkBlendOp, + module Graphics.Vulkan.Types.BaseTypes, + module Graphics.Vulkan.Types.Enum.VkColorComponentFlags, + module Graphics.Vulkan.Types.Enum.VkCompareOp, + module Graphics.Vulkan.Types.Enum.VkCullModeFlags, + module Graphics.Vulkan.Types.Enum.VkDiscardRectangleModeEXT, + module Graphics.Vulkan.Types.Enum.VkDynamicState, + module Graphics.Vulkan.Types.Struct.VkExtent2D, + module Graphics.Vulkan.Types.Enum.VkFormat, + module Graphics.Vulkan.Types.Enum.VkFrontFace, + module Graphics.Vulkan.Types.Struct.VkGraphicsPipelineCreateInfo, + module Graphics.Vulkan.Types.Enum.VkLogicOp, + module Graphics.Vulkan.Types.Struct.VkOffset2D, + module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceDiscardRectanglePropertiesEXT, + module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceLimits, + module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceProperties, + module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceProperties2KHR, + module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceSparseProperties, + module Graphics.Vulkan.Types.Enum.VkPhysicalDeviceType, + module Graphics.Vulkan.Types.Struct.VkPipelineColorBlendAttachmentState, + module Graphics.Vulkan.Types.Bitmasks, + module Graphics.Vulkan.Types.Struct.VkPipelineColorBlendStateCreateInfo, + module Graphics.Vulkan.Types.Enum.VkPipelineCreateFlags, + module Graphics.Vulkan.Types.Struct.VkPipelineDepthStencilStateCreateInfo, + module Graphics.Vulkan.Types.Struct.VkPipelineDiscardRectangleStateCreateInfoEXT, + module Graphics.Vulkan.Types.Struct.VkPipelineDynamicStateCreateInfo, + module Graphics.Vulkan.Types.Struct.VkPipelineInputAssemblyStateCreateInfo, + module Graphics.Vulkan.Types.Struct.VkPipelineMultisampleStateCreateInfo, + module Graphics.Vulkan.Types.Struct.VkPipelineRasterizationStateCreateInfo, + module Graphics.Vulkan.Types.Struct.VkPipelineShaderStageCreateInfo, + module Graphics.Vulkan.Types.Struct.VkPipelineTessellationStateCreateInfo, + module Graphics.Vulkan.Types.Struct.VkPipelineVertexInputStateCreateInfo, + module Graphics.Vulkan.Types.Struct.VkPipelineViewportStateCreateInfo, + module Graphics.Vulkan.Types.Enum.VkPolygonMode, + module Graphics.Vulkan.Types.Enum.VkPrimitiveTopology, + module Graphics.Vulkan.Types.Struct.VkRect2D, + module Graphics.Vulkan.Types.Enum.VkSampleCountFlags, + module Graphics.Vulkan.Types.Enum.VkShaderStageFlags, + module Graphics.Vulkan.Types.Struct.VkSpecializationInfo, + module Graphics.Vulkan.Types.Struct.VkSpecializationMapEntry, + module Graphics.Vulkan.Types.Enum.VkStencilOp, + module Graphics.Vulkan.Types.Struct.VkStencilOpState, + module Graphics.Vulkan.Types.Enum.VkStructureType, + module Graphics.Vulkan.Types.Struct.VkVertexInputAttributeDescription, + module Graphics.Vulkan.Types.Struct.VkVertexInputBindingDescription, + module Graphics.Vulkan.Types.Enum.VkVertexInputRate, + module Graphics.Vulkan.Types.Struct.VkViewport, + -- > #include "vk_platform.h" + vkCmdSetDiscardRectangleEXT, module Graphics.Vulkan.Types.Handles, + VK_EXT_DISCARD_RECTANGLES_SPEC_VERSION, + pattern VK_EXT_DISCARD_RECTANGLES_SPEC_VERSION, + VK_EXT_DISCARD_RECTANGLES_EXTENSION_NAME, + pattern VK_EXT_DISCARD_RECTANGLES_EXTENSION_NAME, + pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT, + pattern VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT, + pattern VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT) + where +import GHC.Ptr + (Ptr (..)) +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Types.BaseTypes +import Graphics.Vulkan.Types.Bitmasks +import Graphics.Vulkan.Types.Enum.VkBlendFactor +import Graphics.Vulkan.Types.Enum.VkBlendOp +import Graphics.Vulkan.Types.Enum.VkColorComponentFlags +import Graphics.Vulkan.Types.Enum.VkCompareOp +import Graphics.Vulkan.Types.Enum.VkCullModeFlags +import Graphics.Vulkan.Types.Enum.VkDiscardRectangleModeEXT +import Graphics.Vulkan.Types.Enum.VkDynamicState +import Graphics.Vulkan.Types.Enum.VkFormat +import Graphics.Vulkan.Types.Enum.VkFrontFace +import Graphics.Vulkan.Types.Enum.VkLogicOp +import Graphics.Vulkan.Types.Enum.VkPhysicalDeviceType +import Graphics.Vulkan.Types.Enum.VkPipelineCreateFlags +import Graphics.Vulkan.Types.Enum.VkPolygonMode +import Graphics.Vulkan.Types.Enum.VkPrimitiveTopology +import Graphics.Vulkan.Types.Enum.VkSampleCountFlags +import Graphics.Vulkan.Types.Enum.VkShaderStageFlags +import Graphics.Vulkan.Types.Enum.VkStencilOp +import Graphics.Vulkan.Types.Enum.VkStructureType +import Graphics.Vulkan.Types.Enum.VkVertexInputRate +import Graphics.Vulkan.Types.Handles +import Graphics.Vulkan.Types.Struct.VkExtent2D +import Graphics.Vulkan.Types.Struct.VkGraphicsPipelineCreateInfo +import Graphics.Vulkan.Types.Struct.VkOffset2D +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceDiscardRectanglePropertiesEXT +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceLimits +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceProperties +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceProperties2KHR +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceSparseProperties +import Graphics.Vulkan.Types.Struct.VkPipelineColorBlendAttachmentState +import Graphics.Vulkan.Types.Struct.VkPipelineColorBlendStateCreateInfo +import Graphics.Vulkan.Types.Struct.VkPipelineDepthStencilStateCreateInfo +import Graphics.Vulkan.Types.Struct.VkPipelineDiscardRectangleStateCreateInfoEXT +import Graphics.Vulkan.Types.Struct.VkPipelineDynamicStateCreateInfo +import Graphics.Vulkan.Types.Struct.VkPipelineInputAssemblyStateCreateInfo +import Graphics.Vulkan.Types.Struct.VkPipelineMultisampleStateCreateInfo +import Graphics.Vulkan.Types.Struct.VkPipelineRasterizationStateCreateInfo +import Graphics.Vulkan.Types.Struct.VkPipelineShaderStageCreateInfo +import Graphics.Vulkan.Types.Struct.VkPipelineTessellationStateCreateInfo +import Graphics.Vulkan.Types.Struct.VkPipelineVertexInputStateCreateInfo +import Graphics.Vulkan.Types.Struct.VkPipelineViewportStateCreateInfo +import Graphics.Vulkan.Types.Struct.VkRect2D +import Graphics.Vulkan.Types.Struct.VkSpecializationInfo +import Graphics.Vulkan.Types.Struct.VkSpecializationMapEntry +import Graphics.Vulkan.Types.Struct.VkStencilOpState +import Graphics.Vulkan.Types.Struct.VkVertexInputAttributeDescription +import Graphics.Vulkan.Types.Struct.VkVertexInputBindingDescription +import Graphics.Vulkan.Types.Struct.VkViewport + +-- | queues: 'graphics'. +-- +-- renderpass: @both@ +-- +-- > () vkCmdSetDiscardRectangleEXT +-- > ( VkCommandBuffer commandBuffer +-- > , uint32_t firstDiscardRectangle +-- > , uint32_t discardRectangleCount +-- > , const VkRect2D* pDiscardRectangles +-- > ) +-- +-- +foreign import ccall unsafe "vkCmdSetDiscardRectangleEXT" + vkCmdSetDiscardRectangleEXT :: + VkCommandBuffer -- ^ commandBuffer + -> Word32 -- ^ firstDiscardRectangle + -> Word32 -- ^ discardRectangleCount + -> Ptr VkRect2D -- ^ pDiscardRectangles + -> IO () + +pattern VK_EXT_DISCARD_RECTANGLES_SPEC_VERSION :: (Num a, Eq a) => + a + +pattern VK_EXT_DISCARD_RECTANGLES_SPEC_VERSION = 1 + +type VK_EXT_DISCARD_RECTANGLES_SPEC_VERSION = 1 + +pattern VK_EXT_DISCARD_RECTANGLES_EXTENSION_NAME :: CString + +pattern VK_EXT_DISCARD_RECTANGLES_EXTENSION_NAME <- + (is_VK_EXT_DISCARD_RECTANGLES_EXTENSION_NAME -> True) + where VK_EXT_DISCARD_RECTANGLES_EXTENSION_NAME + = _VK_EXT_DISCARD_RECTANGLES_EXTENSION_NAME + +{-# INLINE _VK_EXT_DISCARD_RECTANGLES_EXTENSION_NAME #-} + +_VK_EXT_DISCARD_RECTANGLES_EXTENSION_NAME :: CString +_VK_EXT_DISCARD_RECTANGLES_EXTENSION_NAME + = Ptr "VK_EXT_discard_rectangles\NUL"# + +{-# INLINE is_VK_EXT_DISCARD_RECTANGLES_EXTENSION_NAME #-} + +is_VK_EXT_DISCARD_RECTANGLES_EXTENSION_NAME :: CString -> Bool +is_VK_EXT_DISCARD_RECTANGLES_EXTENSION_NAME + = eqCStrings _VK_EXT_DISCARD_RECTANGLES_EXTENSION_NAME + +type VK_EXT_DISCARD_RECTANGLES_EXTENSION_NAME = + "VK_EXT_discard_rectangles" + +pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT + :: VkStructureType + +pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT + = VkStructureType 1000099000 + +pattern VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT + :: VkStructureType + +pattern VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT + = VkStructureType 1000099001 + +pattern VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT :: VkDynamicState + +pattern VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT = + VkDynamicState 1000099000 diff --git a/src-gen/Graphics/Vulkan/Ext/VK_EXT_display_control.hs b/src-gen/Graphics/Vulkan/Ext/VK_EXT_display_control.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Ext/VK_EXT_display_control.hs @@ -0,0 +1,222 @@ +{-# OPTIONS_GHC -fno-warn-unused-imports#-} +{-# OPTIONS_HADDOCK not-home#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE ForeignFunctionInterface #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE ViewPatterns #-} +module Graphics.Vulkan.Ext.VK_EXT_display_control + (-- * Vulkan extension: @VK_EXT_display_control@ + -- | + -- + -- supported: @vulkan@ + -- + -- contact: @James Jones @cubanismo@ + -- + -- author: @NV@ + -- + -- type: @device@ + -- + -- Extension number: @92@ + -- + -- Required extensions: 'VK_EXT_display_surface_counter', 'VK_KHR_swapchain'. + -- + + -- ** Required extensions: 'VK_EXT_display_surface_counter', 'VK_KHR_swapchain'. + module Graphics.Vulkan.Types.BaseTypes, + module Graphics.Vulkan.Types.Enum.VkColorSpaceKHR, + module Graphics.Vulkan.Types.Enum.VkCompositeAlphaFlagsKHR, + module Graphics.Vulkan.Types.Struct.VkDeviceEventInfoEXT, + module Graphics.Vulkan.Types.Enum.VkDeviceEventTypeEXT, + module Graphics.Vulkan.Types.Struct.VkDisplayEventInfoEXT, + module Graphics.Vulkan.Types.Enum.VkDisplayEventTypeEXT, + module Graphics.Vulkan.Types.Struct.VkDisplayPowerInfoEXT, + module Graphics.Vulkan.Types.Enum.VkDisplayPowerStateEXT, + module Graphics.Vulkan.Types.Struct.VkExtent2D, + module Graphics.Vulkan.Types.Enum.VkFormat, + module Graphics.Vulkan.Types.Enum.VkImageUsageFlags, + module Graphics.Vulkan.Types.Enum.VkPresentModeKHR, + module Graphics.Vulkan.Types.Enum.VkSharingMode, + module Graphics.Vulkan.Types.Enum.VkStructureType, + module Graphics.Vulkan.Types.Enum.VkSurfaceCounterFlagsEXT, + module Graphics.Vulkan.Types.Enum.VkSurfaceTransformFlagsKHR, + module Graphics.Vulkan.Types.Struct.VkSwapchainCounterCreateInfoEXT, + module Graphics.Vulkan.Types.Enum.VkSwapchainCreateFlagsKHR, + module Graphics.Vulkan.Types.Struct.VkSwapchainCreateInfoKHR, + -- > #include "vk_platform.h" + vkDisplayPowerControlEXT, vkRegisterDeviceEventEXT, + vkRegisterDisplayEventEXT, vkGetSwapchainCounterEXT, + module Graphics.Vulkan.Marshal, + module Graphics.Vulkan.Types.Enum.VkInternalAllocationType, + module Graphics.Vulkan.Types.Enum.VkResult, + module Graphics.Vulkan.Types.Enum.VkSystemAllocationScope, + module Graphics.Vulkan.Types.Funcpointers, + module Graphics.Vulkan.Types.Handles, + module Graphics.Vulkan.Types.Struct.VkAllocationCallbacks, + VK_EXT_DISPLAY_CONTROL_SPEC_VERSION, + pattern VK_EXT_DISPLAY_CONTROL_SPEC_VERSION, + VK_EXT_DISPLAY_CONTROL_EXTENSION_NAME, + pattern VK_EXT_DISPLAY_CONTROL_EXTENSION_NAME, + pattern VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT, + pattern VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT, + pattern VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT, + pattern VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT) + where +import GHC.Ptr (Ptr (..)) +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Types.BaseTypes +import Graphics.Vulkan.Types.Enum.VkColorSpaceKHR +import Graphics.Vulkan.Types.Enum.VkCompositeAlphaFlagsKHR +import Graphics.Vulkan.Types.Enum.VkDeviceEventTypeEXT +import Graphics.Vulkan.Types.Enum.VkDisplayEventTypeEXT +import Graphics.Vulkan.Types.Enum.VkDisplayPowerStateEXT +import Graphics.Vulkan.Types.Enum.VkFormat +import Graphics.Vulkan.Types.Enum.VkImageUsageFlags +import Graphics.Vulkan.Types.Enum.VkInternalAllocationType +import Graphics.Vulkan.Types.Enum.VkPresentModeKHR +import Graphics.Vulkan.Types.Enum.VkResult +import Graphics.Vulkan.Types.Enum.VkSharingMode +import Graphics.Vulkan.Types.Enum.VkStructureType +import Graphics.Vulkan.Types.Enum.VkSurfaceCounterFlagsEXT +import Graphics.Vulkan.Types.Enum.VkSurfaceTransformFlagsKHR +import Graphics.Vulkan.Types.Enum.VkSwapchainCreateFlagsKHR +import Graphics.Vulkan.Types.Enum.VkSystemAllocationScope +import Graphics.Vulkan.Types.Funcpointers +import Graphics.Vulkan.Types.Handles +import Graphics.Vulkan.Types.Struct.VkAllocationCallbacks +import Graphics.Vulkan.Types.Struct.VkDeviceEventInfoEXT +import Graphics.Vulkan.Types.Struct.VkDisplayEventInfoEXT +import Graphics.Vulkan.Types.Struct.VkDisplayPowerInfoEXT +import Graphics.Vulkan.Types.Struct.VkExtent2D +import Graphics.Vulkan.Types.Struct.VkSwapchainCounterCreateInfoEXT +import Graphics.Vulkan.Types.Struct.VkSwapchainCreateInfoKHR + +-- | Success codes: 'VK_SUCCESS'. +-- +-- > VkResult vkDisplayPowerControlEXT +-- > ( VkDevice device +-- > , VkDisplayKHR display +-- > , const VkDisplayPowerInfoEXT* pDisplayPowerInfo +-- > ) +-- +-- +foreign import ccall unsafe "vkDisplayPowerControlEXT" + vkDisplayPowerControlEXT :: + VkDevice -- ^ device + -> + VkDisplayKHR -- ^ display + -> Ptr VkDisplayPowerInfoEXT -- ^ pDisplayPowerInfo + -> IO VkResult + +-- | Success codes: 'VK_SUCCESS'. +-- +-- > VkResult vkRegisterDeviceEventEXT +-- > ( VkDevice device +-- > , const VkDeviceEventInfoEXT* pDeviceEventInfo +-- > , const VkAllocationCallbacks* pAllocator +-- > , VkFence* pFence +-- > ) +-- +-- +foreign import ccall unsafe "vkRegisterDeviceEventEXT" + vkRegisterDeviceEventEXT :: + VkDevice -- ^ device + -> + Ptr VkDeviceEventInfoEXT -- ^ pDeviceEventInfo + -> + Ptr VkAllocationCallbacks -- ^ pAllocator + -> Ptr VkFence -- ^ pFence + -> IO VkResult + +-- | Success codes: 'VK_SUCCESS'. +-- +-- > VkResult vkRegisterDisplayEventEXT +-- > ( VkDevice device +-- > , VkDisplayKHR display +-- > , const VkDisplayEventInfoEXT* pDisplayEventInfo +-- > , const VkAllocationCallbacks* pAllocator +-- > , VkFence* pFence +-- > ) +-- +-- +foreign import ccall unsafe "vkRegisterDisplayEventEXT" + vkRegisterDisplayEventEXT :: + VkDevice -- ^ device + -> + VkDisplayKHR -- ^ display + -> + Ptr VkDisplayEventInfoEXT -- ^ pDisplayEventInfo + -> + Ptr VkAllocationCallbacks -- ^ pAllocator + -> Ptr VkFence -- ^ pFence + -> IO VkResult + +-- | Success codes: 'VK_SUCCESS', 'VK_ERROR_DEVICE_LOST', 'VK_ERROR_OUT_OF_DATE_KHR'. +-- +-- > VkResult vkGetSwapchainCounterEXT +-- > ( VkDevice device +-- > , VkSwapchainKHR swapchain +-- > , VkSurfaceCounterFlagBitsEXT counter +-- > , uint64_t* pCounterValue +-- > ) +-- +-- +foreign import ccall unsafe "vkGetSwapchainCounterEXT" + vkGetSwapchainCounterEXT :: + VkDevice -- ^ device + -> + VkSwapchainKHR -- ^ swapchain + -> + VkSurfaceCounterFlagBitsEXT -- ^ counter + -> Ptr Word64 -- ^ pCounterValue + -> IO VkResult + +pattern VK_EXT_DISPLAY_CONTROL_SPEC_VERSION :: (Num a, Eq a) => a + +pattern VK_EXT_DISPLAY_CONTROL_SPEC_VERSION = 1 + +type VK_EXT_DISPLAY_CONTROL_SPEC_VERSION = 1 + +pattern VK_EXT_DISPLAY_CONTROL_EXTENSION_NAME :: CString + +pattern VK_EXT_DISPLAY_CONTROL_EXTENSION_NAME <- + (is_VK_EXT_DISPLAY_CONTROL_EXTENSION_NAME -> True) + where VK_EXT_DISPLAY_CONTROL_EXTENSION_NAME + = _VK_EXT_DISPLAY_CONTROL_EXTENSION_NAME + +{-# INLINE _VK_EXT_DISPLAY_CONTROL_EXTENSION_NAME #-} + +_VK_EXT_DISPLAY_CONTROL_EXTENSION_NAME :: CString +_VK_EXT_DISPLAY_CONTROL_EXTENSION_NAME + = Ptr "VK_EXT_display_control\NUL"# + +{-# INLINE is_VK_EXT_DISPLAY_CONTROL_EXTENSION_NAME #-} + +is_VK_EXT_DISPLAY_CONTROL_EXTENSION_NAME :: CString -> Bool +is_VK_EXT_DISPLAY_CONTROL_EXTENSION_NAME + = eqCStrings _VK_EXT_DISPLAY_CONTROL_EXTENSION_NAME + +type VK_EXT_DISPLAY_CONTROL_EXTENSION_NAME = + "VK_EXT_display_control" + +pattern VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT :: VkStructureType + +pattern VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT = + VkStructureType 1000091000 + +pattern VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT :: VkStructureType + +pattern VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT = + VkStructureType 1000091001 + +pattern VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT :: VkStructureType + +pattern VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT = + VkStructureType 1000091002 + +pattern VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT = + VkStructureType 1000091003 diff --git a/src-gen/Graphics/Vulkan/Ext/VK_EXT_display_surface_counter.hs b/src-gen/Graphics/Vulkan/Ext/VK_EXT_display_surface_counter.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Ext/VK_EXT_display_surface_counter.hs @@ -0,0 +1,116 @@ +{-# OPTIONS_GHC -fno-warn-missing-pattern-synonym-signatures#-} +{-# OPTIONS_HADDOCK not-home#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE ForeignFunctionInterface #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE ViewPatterns #-} +module Graphics.Vulkan.Ext.VK_EXT_display_surface_counter + (-- * Vulkan extension: @VK_EXT_display_surface_counter@ + -- | + -- + -- supported: @vulkan@ + -- + -- contact: @James Jones @cubanismo@ + -- + -- author: @NV@ + -- + -- type: @instance@ + -- + -- Extension number: @91@ + -- + -- Required extensions: 'VK_KHR_display'. + -- + + -- ** Required extensions: 'VK_KHR_display'. + module Graphics.Vulkan.Types.Enum.VkCompositeAlphaFlagsKHR, + module Graphics.Vulkan.Types.Struct.VkExtent2D, + module Graphics.Vulkan.Types.BaseTypes, + module Graphics.Vulkan.Types.Enum.VkImageUsageFlags, + module Graphics.Vulkan.Types.Enum.VkStructureType, + module Graphics.Vulkan.Types.Struct.VkSurfaceCapabilities2EXT, + module Graphics.Vulkan.Types.Enum.VkSurfaceCounterFlagsEXT, + module Graphics.Vulkan.Types.Enum.VkSurfaceTransformFlagsKHR, + -- > #include "vk_platform.h" + vkGetPhysicalDeviceSurfaceCapabilities2EXT, + module Graphics.Vulkan.Marshal, + module Graphics.Vulkan.Types.Enum.VkResult, + module Graphics.Vulkan.Types.Handles, + VK_EXT_DISPLAY_SURFACE_COUNTER_SPEC_VERSION, + pattern VK_EXT_DISPLAY_SURFACE_COUNTER_SPEC_VERSION, + VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME, + pattern VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME, + pattern VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT, + pattern VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES2_EXT) + where +import GHC.Ptr (Ptr (..)) +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Types.BaseTypes +import Graphics.Vulkan.Types.Enum.VkCompositeAlphaFlagsKHR +import Graphics.Vulkan.Types.Enum.VkImageUsageFlags +import Graphics.Vulkan.Types.Enum.VkResult +import Graphics.Vulkan.Types.Enum.VkStructureType +import Graphics.Vulkan.Types.Enum.VkSurfaceCounterFlagsEXT +import Graphics.Vulkan.Types.Enum.VkSurfaceTransformFlagsKHR +import Graphics.Vulkan.Types.Handles +import Graphics.Vulkan.Types.Struct.VkExtent2D +import Graphics.Vulkan.Types.Struct.VkSurfaceCapabilities2EXT + +-- | Success codes: 'VK_SUCCESS'. +-- +-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_SURFACE_LOST_KHR'. +-- +-- > VkResult vkGetPhysicalDeviceSurfaceCapabilities2EXT +-- > ( VkPhysicalDevice physicalDevice +-- > , VkSurfaceKHR surface +-- > , VkSurfaceCapabilities2EXT* pSurfaceCapabilities +-- > ) +-- +-- +foreign import ccall unsafe + "vkGetPhysicalDeviceSurfaceCapabilities2EXT" + vkGetPhysicalDeviceSurfaceCapabilities2EXT :: + VkPhysicalDevice -- ^ physicalDevice + -> + VkSurfaceKHR -- ^ surface + -> Ptr VkSurfaceCapabilities2EXT -- ^ pSurfaceCapabilities + -> IO VkResult + +pattern VK_EXT_DISPLAY_SURFACE_COUNTER_SPEC_VERSION :: + (Num a, Eq a) => a + +pattern VK_EXT_DISPLAY_SURFACE_COUNTER_SPEC_VERSION = 1 + +type VK_EXT_DISPLAY_SURFACE_COUNTER_SPEC_VERSION = 1 + +pattern VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME :: CString + +pattern VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME <- + (is_VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME -> True) + where VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME + = _VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME + +{-# INLINE _VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME #-} + +_VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME :: CString +_VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME + = Ptr "VK_EXT_display_surface_counter\NUL"# + +{-# INLINE is_VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME #-} + +is_VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME :: CString -> Bool +is_VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME + = eqCStrings _VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME + +type VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME = + "VK_EXT_display_surface_counter" + +pattern VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT = + VkStructureType 1000090000 + +pattern VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES2_EXT = + VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT diff --git a/src-gen/Graphics/Vulkan/Ext/VK_EXT_external_memory_dma_buf.hs b/src-gen/Graphics/Vulkan/Ext/VK_EXT_external_memory_dma_buf.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Ext/VK_EXT_external_memory_dma_buf.hs @@ -0,0 +1,70 @@ +{-# OPTIONS_HADDOCK not-home#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE ViewPatterns #-} +module Graphics.Vulkan.Ext.VK_EXT_external_memory_dma_buf + (-- * Vulkan extension: @VK_EXT_external_memory_dma_buf@ + -- | + -- + -- supported: @vulkan@ + -- + -- contact: @Chad Versace @chadversary@ + -- + -- author: @EXT@ + -- + -- type: @device@ + -- + -- Extension number: @126@ + -- + -- Required extensions: 'VK_KHR_external_memory_fd'. + -- + + -- ** Required extensions: 'VK_KHR_external_memory_fd'. + VK_EXT_EXTERNAL_MEMORY_DMA_BUF_SPEC_VERSION, + pattern VK_EXT_EXTERNAL_MEMORY_DMA_BUF_SPEC_VERSION, + VK_EXT_EXTERNAL_MEMORY_DMA_BUF_EXTENSION_NAME, + pattern VK_EXT_EXTERNAL_MEMORY_DMA_BUF_EXTENSION_NAME, + pattern VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT) + where +import GHC.Ptr (Ptr (..)) +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Types.Enum.VkExternalMemoryHandleTypeFlagsKHR (VkExternalMemoryHandleTypeBitmaskKHR (..), + VkExternalMemoryHandleTypeFlagBitsKHR) + +pattern VK_EXT_EXTERNAL_MEMORY_DMA_BUF_SPEC_VERSION :: + (Num a, Eq a) => a + +pattern VK_EXT_EXTERNAL_MEMORY_DMA_BUF_SPEC_VERSION = 1 + +type VK_EXT_EXTERNAL_MEMORY_DMA_BUF_SPEC_VERSION = 1 + +pattern VK_EXT_EXTERNAL_MEMORY_DMA_BUF_EXTENSION_NAME :: CString + +pattern VK_EXT_EXTERNAL_MEMORY_DMA_BUF_EXTENSION_NAME <- + (is_VK_EXT_EXTERNAL_MEMORY_DMA_BUF_EXTENSION_NAME -> True) + where VK_EXT_EXTERNAL_MEMORY_DMA_BUF_EXTENSION_NAME + = _VK_EXT_EXTERNAL_MEMORY_DMA_BUF_EXTENSION_NAME + +{-# INLINE _VK_EXT_EXTERNAL_MEMORY_DMA_BUF_EXTENSION_NAME #-} + +_VK_EXT_EXTERNAL_MEMORY_DMA_BUF_EXTENSION_NAME :: CString +_VK_EXT_EXTERNAL_MEMORY_DMA_BUF_EXTENSION_NAME + = Ptr "VK_EXT_external_memory_dma_buf\NUL"# + +{-# INLINE is_VK_EXT_EXTERNAL_MEMORY_DMA_BUF_EXTENSION_NAME #-} + +is_VK_EXT_EXTERNAL_MEMORY_DMA_BUF_EXTENSION_NAME :: CString -> Bool +is_VK_EXT_EXTERNAL_MEMORY_DMA_BUF_EXTENSION_NAME + = eqCStrings _VK_EXT_EXTERNAL_MEMORY_DMA_BUF_EXTENSION_NAME + +type VK_EXT_EXTERNAL_MEMORY_DMA_BUF_EXTENSION_NAME = + "VK_EXT_external_memory_dma_buf" + +-- | bitpos = @9@ +pattern VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT :: + VkExternalMemoryHandleTypeFlagBitsKHR + +pattern VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT = + VkExternalMemoryHandleTypeFlagBitsKHR 512 diff --git a/src-gen/Graphics/Vulkan/Ext/VK_EXT_external_memory_host.hs b/src-gen/Graphics/Vulkan/Ext/VK_EXT_external_memory_host.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Ext/VK_EXT_external_memory_host.hs @@ -0,0 +1,155 @@ +{-# OPTIONS_GHC -fno-warn-unused-imports#-} +{-# OPTIONS_HADDOCK not-home#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE ForeignFunctionInterface #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE ViewPatterns #-} +module Graphics.Vulkan.Ext.VK_EXT_external_memory_host + (-- * Vulkan extension: @VK_EXT_external_memory_host@ + -- | + -- + -- supported: @vulkan@ + -- + -- contact: @Daniel Rakos @aqnuep@ + -- + -- author: @EXT@ + -- + -- type: @device@ + -- + -- Extension number: @179@ + -- + -- Required extensions: 'VK_KHR_external_memory'. + -- + + -- ** Required extensions: 'VK_KHR_external_memory'. + module Graphics.Vulkan.Marshal, + module Graphics.Vulkan.Types.BaseTypes, + module Graphics.Vulkan.Types.Enum.VkExternalMemoryHandleTypeFlagsKHR, + module Graphics.Vulkan.Types.Struct.VkImportMemoryHostPointerInfoEXT, + module Graphics.Vulkan.Types.Struct.VkMemoryAllocateInfo, + module Graphics.Vulkan.Types.Struct.VkMemoryHostPointerPropertiesEXT, + module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceExternalMemoryHostPropertiesEXT, + module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceLimits, + module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceProperties, + module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceProperties2KHR, + module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceSparseProperties, + module Graphics.Vulkan.Types.Enum.VkPhysicalDeviceType, + module Graphics.Vulkan.Types.Enum.VkSampleCountFlags, + module Graphics.Vulkan.Types.Enum.VkStructureType, + -- > #include "vk_platform.h" + vkGetMemoryHostPointerPropertiesEXT, + module Graphics.Vulkan.Types.Enum.VkResult, + module Graphics.Vulkan.Types.Handles, + VK_EXT_EXTERNAL_MEMORY_HOST_SPEC_VERSION, + pattern VK_EXT_EXTERNAL_MEMORY_HOST_SPEC_VERSION, + VK_EXT_EXTERNAL_MEMORY_HOST_EXTENSION_NAME, + pattern VK_EXT_EXTERNAL_MEMORY_HOST_EXTENSION_NAME, + pattern VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT, + pattern VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT, + pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT, + pattern VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT, + pattern VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT) + where +import GHC.Ptr + (Ptr (..)) +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Types.BaseTypes +import Graphics.Vulkan.Types.Enum.VkExternalMemoryHandleTypeFlagsKHR +import Graphics.Vulkan.Types.Enum.VkPhysicalDeviceType +import Graphics.Vulkan.Types.Enum.VkResult +import Graphics.Vulkan.Types.Enum.VkSampleCountFlags +import Graphics.Vulkan.Types.Enum.VkStructureType +import Graphics.Vulkan.Types.Handles +import Graphics.Vulkan.Types.Struct.VkImportMemoryHostPointerInfoEXT +import Graphics.Vulkan.Types.Struct.VkMemoryAllocateInfo +import Graphics.Vulkan.Types.Struct.VkMemoryHostPointerPropertiesEXT +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceExternalMemoryHostPropertiesEXT +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceLimits +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceProperties +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceProperties2KHR +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceSparseProperties + +-- | Success codes: 'VK_SUCCESS'. +-- +-- Error codes: 'VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR'. +-- +-- > VkResult vkGetMemoryHostPointerPropertiesEXT +-- > ( VkDevice device +-- > , VkExternalMemoryHandleTypeFlagBitsKHR handleType +-- > , const void* pHostPointer +-- > , VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties +-- > ) +-- +-- +foreign import ccall unsafe "vkGetMemoryHostPointerPropertiesEXT" + vkGetMemoryHostPointerPropertiesEXT :: + VkDevice -- ^ device + -> + VkExternalMemoryHandleTypeFlagBitsKHR -- ^ handleType + -> + Ptr Void -- ^ pHostPointer + -> Ptr VkMemoryHostPointerPropertiesEXT -- ^ pMemoryHostPointerProperties + -> IO VkResult + +pattern VK_EXT_EXTERNAL_MEMORY_HOST_SPEC_VERSION :: + (Num a, Eq a) => a + +pattern VK_EXT_EXTERNAL_MEMORY_HOST_SPEC_VERSION = 1 + +type VK_EXT_EXTERNAL_MEMORY_HOST_SPEC_VERSION = 1 + +pattern VK_EXT_EXTERNAL_MEMORY_HOST_EXTENSION_NAME :: CString + +pattern VK_EXT_EXTERNAL_MEMORY_HOST_EXTENSION_NAME <- + (is_VK_EXT_EXTERNAL_MEMORY_HOST_EXTENSION_NAME -> True) + where VK_EXT_EXTERNAL_MEMORY_HOST_EXTENSION_NAME + = _VK_EXT_EXTERNAL_MEMORY_HOST_EXTENSION_NAME + +{-# INLINE _VK_EXT_EXTERNAL_MEMORY_HOST_EXTENSION_NAME #-} + +_VK_EXT_EXTERNAL_MEMORY_HOST_EXTENSION_NAME :: CString +_VK_EXT_EXTERNAL_MEMORY_HOST_EXTENSION_NAME + = Ptr "VK_EXT_external_memory_host\NUL"# + +{-# INLINE is_VK_EXT_EXTERNAL_MEMORY_HOST_EXTENSION_NAME #-} + +is_VK_EXT_EXTERNAL_MEMORY_HOST_EXTENSION_NAME :: CString -> Bool +is_VK_EXT_EXTERNAL_MEMORY_HOST_EXTENSION_NAME + = eqCStrings _VK_EXT_EXTERNAL_MEMORY_HOST_EXTENSION_NAME + +type VK_EXT_EXTERNAL_MEMORY_HOST_EXTENSION_NAME = + "VK_EXT_external_memory_host" + +pattern VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT = + VkStructureType 1000178000 + +pattern VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT = + VkStructureType 1000178001 + +pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT + :: VkStructureType + +pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT + = VkStructureType 1000178002 + +-- | bitpos = @7@ +pattern VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT :: + VkExternalMemoryHandleTypeFlagBitsKHR + +pattern VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT = + VkExternalMemoryHandleTypeFlagBitsKHR 128 + +-- | bitpos = @8@ +pattern VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT + :: VkExternalMemoryHandleTypeFlagBitsKHR + +pattern VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT + = VkExternalMemoryHandleTypeFlagBitsKHR 256 diff --git a/src-gen/Graphics/Vulkan/Ext/VK_EXT_global_priority.hs b/src-gen/Graphics/Vulkan/Ext/VK_EXT_global_priority.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Ext/VK_EXT_global_priority.hs @@ -0,0 +1,82 @@ +{-# OPTIONS_HADDOCK not-home#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE ViewPatterns #-} +module Graphics.Vulkan.Ext.VK_EXT_global_priority + (-- * Vulkan extension: @VK_EXT_global_priority@ + -- | + -- + -- supported: @vulkan@ + -- + -- contact: @Andres Rodriguez @lostgoat@ + -- + -- author: @EXT@ + -- + -- type: @device@ + -- + -- Extension number: @175@ + module Graphics.Vulkan.Types.Bitmasks, + module Graphics.Vulkan.Types.Struct.VkDeviceQueueCreateInfo, + module Graphics.Vulkan.Types.Struct.VkDeviceQueueGlobalPriorityCreateInfoEXT, + module Graphics.Vulkan.Types.BaseTypes, + module Graphics.Vulkan.Types.Enum.VkQueueGlobalPriorityEXT, + module Graphics.Vulkan.Types.Enum.VkStructureType, + -- > #include "vk_platform.h" + VK_EXT_GLOBAL_PRIORITY_SPEC_VERSION, + pattern VK_EXT_GLOBAL_PRIORITY_SPEC_VERSION, + VK_EXT_GLOBAL_PRIORITY_EXTENSION_NAME, + pattern VK_EXT_GLOBAL_PRIORITY_EXTENSION_NAME, + pattern VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT, + pattern VK_ERROR_NOT_PERMITTED_EXT) + where +import GHC.Ptr + (Ptr (..)) +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Types.BaseTypes +import Graphics.Vulkan.Types.Bitmasks +import Graphics.Vulkan.Types.Enum.VkQueueGlobalPriorityEXT +import Graphics.Vulkan.Types.Enum.VkResult + (VkResult (..)) +import Graphics.Vulkan.Types.Enum.VkStructureType +import Graphics.Vulkan.Types.Struct.VkDeviceQueueCreateInfo +import Graphics.Vulkan.Types.Struct.VkDeviceQueueGlobalPriorityCreateInfoEXT + +pattern VK_EXT_GLOBAL_PRIORITY_SPEC_VERSION :: (Num a, Eq a) => a + +pattern VK_EXT_GLOBAL_PRIORITY_SPEC_VERSION = 2 + +type VK_EXT_GLOBAL_PRIORITY_SPEC_VERSION = 2 + +pattern VK_EXT_GLOBAL_PRIORITY_EXTENSION_NAME :: CString + +pattern VK_EXT_GLOBAL_PRIORITY_EXTENSION_NAME <- + (is_VK_EXT_GLOBAL_PRIORITY_EXTENSION_NAME -> True) + where VK_EXT_GLOBAL_PRIORITY_EXTENSION_NAME + = _VK_EXT_GLOBAL_PRIORITY_EXTENSION_NAME + +{-# INLINE _VK_EXT_GLOBAL_PRIORITY_EXTENSION_NAME #-} + +_VK_EXT_GLOBAL_PRIORITY_EXTENSION_NAME :: CString +_VK_EXT_GLOBAL_PRIORITY_EXTENSION_NAME + = Ptr "VK_EXT_global_priority\NUL"# + +{-# INLINE is_VK_EXT_GLOBAL_PRIORITY_EXTENSION_NAME #-} + +is_VK_EXT_GLOBAL_PRIORITY_EXTENSION_NAME :: CString -> Bool +is_VK_EXT_GLOBAL_PRIORITY_EXTENSION_NAME + = eqCStrings _VK_EXT_GLOBAL_PRIORITY_EXTENSION_NAME + +type VK_EXT_GLOBAL_PRIORITY_EXTENSION_NAME = + "VK_EXT_global_priority" + +pattern VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT + :: VkStructureType + +pattern VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT + = VkStructureType 1000174000 + +pattern VK_ERROR_NOT_PERMITTED_EXT :: VkResult + +pattern VK_ERROR_NOT_PERMITTED_EXT = VkResult (-1000174001) diff --git a/src-gen/Graphics/Vulkan/Ext/VK_EXT_hdr_metadata.hs b/src-gen/Graphics/Vulkan/Ext/VK_EXT_hdr_metadata.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Ext/VK_EXT_hdr_metadata.hs @@ -0,0 +1,91 @@ +{-# OPTIONS_HADDOCK not-home#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE ForeignFunctionInterface #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE ViewPatterns #-} +module Graphics.Vulkan.Ext.VK_EXT_hdr_metadata + (-- * Vulkan extension: @VK_EXT_hdr_metadata@ + -- | + -- + -- supported: @vulkan@ + -- + -- contact: @Courtney Goeltzenleuchter @courtneygo@ + -- + -- author: @GOOGLE@ + -- + -- type: @device@ + -- + -- Extension number: @106@ + -- + -- Required extensions: 'VK_KHR_swapchain'. + -- + + -- ** Required extensions: 'VK_KHR_swapchain'. + module Graphics.Vulkan.Types.Struct.VkHdrMetadataEXT, + module Graphics.Vulkan.Types.Enum.VkStructureType, + module Graphics.Vulkan.Types.Struct.VkXYColorEXT, + -- > #include "vk_platform.h" + vkSetHdrMetadataEXT, module Graphics.Vulkan.Types.Handles, + VK_EXT_HDR_METADATA_SPEC_VERSION, + pattern VK_EXT_HDR_METADATA_SPEC_VERSION, + VK_EXT_HDR_METADATA_EXTENSION_NAME, + pattern VK_EXT_HDR_METADATA_EXTENSION_NAME, + pattern VK_STRUCTURE_TYPE_HDR_METADATA_EXT) + where +import GHC.Ptr (Ptr (..)) +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Types.Enum.VkStructureType +import Graphics.Vulkan.Types.Handles +import Graphics.Vulkan.Types.Struct.VkHdrMetadataEXT +import Graphics.Vulkan.Types.Struct.VkXYColorEXT + +-- | > () vkSetHdrMetadataEXT +-- > ( VkDevice device +-- > , uint32_t swapchainCount +-- > , const VkSwapchainKHR* pSwapchains +-- > , const VkHdrMetadataEXT* pMetadata +-- > ) +-- +-- +foreign import ccall unsafe "vkSetHdrMetadataEXT" + vkSetHdrMetadataEXT :: + VkDevice -- ^ device + -> + Word32 -- ^ swapchainCount + -> Ptr VkSwapchainKHR -- ^ pSwapchains + -> Ptr VkHdrMetadataEXT -- ^ pMetadata + -> IO () + +pattern VK_EXT_HDR_METADATA_SPEC_VERSION :: (Num a, Eq a) => a + +pattern VK_EXT_HDR_METADATA_SPEC_VERSION = 1 + +type VK_EXT_HDR_METADATA_SPEC_VERSION = 1 + +pattern VK_EXT_HDR_METADATA_EXTENSION_NAME :: CString + +pattern VK_EXT_HDR_METADATA_EXTENSION_NAME <- + (is_VK_EXT_HDR_METADATA_EXTENSION_NAME -> True) + where VK_EXT_HDR_METADATA_EXTENSION_NAME + = _VK_EXT_HDR_METADATA_EXTENSION_NAME + +{-# INLINE _VK_EXT_HDR_METADATA_EXTENSION_NAME #-} + +_VK_EXT_HDR_METADATA_EXTENSION_NAME :: CString +_VK_EXT_HDR_METADATA_EXTENSION_NAME + = Ptr "VK_EXT_hdr_metadata\NUL"# + +{-# INLINE is_VK_EXT_HDR_METADATA_EXTENSION_NAME #-} + +is_VK_EXT_HDR_METADATA_EXTENSION_NAME :: CString -> Bool +is_VK_EXT_HDR_METADATA_EXTENSION_NAME + = eqCStrings _VK_EXT_HDR_METADATA_EXTENSION_NAME + +type VK_EXT_HDR_METADATA_EXTENSION_NAME = "VK_EXT_hdr_metadata" + +pattern VK_STRUCTURE_TYPE_HDR_METADATA_EXT :: VkStructureType + +pattern VK_STRUCTURE_TYPE_HDR_METADATA_EXT = + VkStructureType 1000105000 diff --git a/src-gen/Graphics/Vulkan/Ext/VK_EXT_post_depth_coverage.hs b/src-gen/Graphics/Vulkan/Ext/VK_EXT_post_depth_coverage.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Ext/VK_EXT_post_depth_coverage.hs @@ -0,0 +1,55 @@ +{-# OPTIONS_HADDOCK not-home#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE ViewPatterns #-} +module Graphics.Vulkan.Ext.VK_EXT_post_depth_coverage + (-- * Vulkan extension: @VK_EXT_post_depth_coverage@ + -- | + -- + -- supported: @vulkan@ + -- + -- contact: @Daniel Koch @dgkoch@ + -- + -- author: @NV@ + -- + -- type: @device@ + -- + -- Extension number: @156@ + VK_EXT_POST_DEPTH_COVERAGE_SPEC_VERSION, + pattern VK_EXT_POST_DEPTH_COVERAGE_SPEC_VERSION, + VK_EXT_POST_DEPTH_COVERAGE_EXTENSION_NAME, + pattern VK_EXT_POST_DEPTH_COVERAGE_EXTENSION_NAME) + where +import GHC.Ptr (Ptr (..)) +import Graphics.Vulkan.Marshal + +pattern VK_EXT_POST_DEPTH_COVERAGE_SPEC_VERSION :: (Num a, Eq a) => + a + +pattern VK_EXT_POST_DEPTH_COVERAGE_SPEC_VERSION = 1 + +type VK_EXT_POST_DEPTH_COVERAGE_SPEC_VERSION = 1 + +pattern VK_EXT_POST_DEPTH_COVERAGE_EXTENSION_NAME :: CString + +pattern VK_EXT_POST_DEPTH_COVERAGE_EXTENSION_NAME <- + (is_VK_EXT_POST_DEPTH_COVERAGE_EXTENSION_NAME -> True) + where VK_EXT_POST_DEPTH_COVERAGE_EXTENSION_NAME + = _VK_EXT_POST_DEPTH_COVERAGE_EXTENSION_NAME + +{-# INLINE _VK_EXT_POST_DEPTH_COVERAGE_EXTENSION_NAME #-} + +_VK_EXT_POST_DEPTH_COVERAGE_EXTENSION_NAME :: CString +_VK_EXT_POST_DEPTH_COVERAGE_EXTENSION_NAME + = Ptr "VK_EXT_post_depth_coverage\NUL"# + +{-# INLINE is_VK_EXT_POST_DEPTH_COVERAGE_EXTENSION_NAME #-} + +is_VK_EXT_POST_DEPTH_COVERAGE_EXTENSION_NAME :: CString -> Bool +is_VK_EXT_POST_DEPTH_COVERAGE_EXTENSION_NAME + = eqCStrings _VK_EXT_POST_DEPTH_COVERAGE_EXTENSION_NAME + +type VK_EXT_POST_DEPTH_COVERAGE_EXTENSION_NAME = + "VK_EXT_post_depth_coverage" diff --git a/src-gen/Graphics/Vulkan/Ext/VK_EXT_queue_family_foreign.hs b/src-gen/Graphics/Vulkan/Ext/VK_EXT_queue_family_foreign.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Ext/VK_EXT_queue_family_foreign.hs @@ -0,0 +1,63 @@ +{-# OPTIONS_HADDOCK not-home#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE ViewPatterns #-} +module Graphics.Vulkan.Ext.VK_EXT_queue_family_foreign + (-- * Vulkan extension: @VK_EXT_queue_family_foreign@ + -- | + -- + -- supported: @vulkan@ + -- + -- contact: @Chad Versace @chadversary@ + -- + -- author: @EXT@ + -- + -- type: @device@ + -- + -- Extension number: @127@ + -- + -- Required extensions: 'VK_KHR_external_memory'. + -- + + -- ** Required extensions: 'VK_KHR_external_memory'. + VK_EXT_QUEUE_FAMILY_FOREIGN_SPEC_VERSION, + pattern VK_EXT_QUEUE_FAMILY_FOREIGN_SPEC_VERSION, + VK_EXT_QUEUE_FAMILY_FOREIGN_EXTENSION_NAME, + pattern VK_EXT_QUEUE_FAMILY_FOREIGN_EXTENSION_NAME, + pattern VK_QUEUE_FAMILY_FOREIGN_EXT, VK_QUEUE_FAMILY_FOREIGN_EXT) + where +import GHC.Ptr (Ptr (..)) +import Graphics.Vulkan.Constants (VK_QUEUE_FAMILY_FOREIGN_EXT, + pattern VK_QUEUE_FAMILY_FOREIGN_EXT) +import Graphics.Vulkan.Marshal + +pattern VK_EXT_QUEUE_FAMILY_FOREIGN_SPEC_VERSION :: + (Num a, Eq a) => a + +pattern VK_EXT_QUEUE_FAMILY_FOREIGN_SPEC_VERSION = 1 + +type VK_EXT_QUEUE_FAMILY_FOREIGN_SPEC_VERSION = 1 + +pattern VK_EXT_QUEUE_FAMILY_FOREIGN_EXTENSION_NAME :: CString + +pattern VK_EXT_QUEUE_FAMILY_FOREIGN_EXTENSION_NAME <- + (is_VK_EXT_QUEUE_FAMILY_FOREIGN_EXTENSION_NAME -> True) + where VK_EXT_QUEUE_FAMILY_FOREIGN_EXTENSION_NAME + = _VK_EXT_QUEUE_FAMILY_FOREIGN_EXTENSION_NAME + +{-# INLINE _VK_EXT_QUEUE_FAMILY_FOREIGN_EXTENSION_NAME #-} + +_VK_EXT_QUEUE_FAMILY_FOREIGN_EXTENSION_NAME :: CString +_VK_EXT_QUEUE_FAMILY_FOREIGN_EXTENSION_NAME + = Ptr "VK_EXT_queue_family_foreign\NUL"# + +{-# INLINE is_VK_EXT_QUEUE_FAMILY_FOREIGN_EXTENSION_NAME #-} + +is_VK_EXT_QUEUE_FAMILY_FOREIGN_EXTENSION_NAME :: CString -> Bool +is_VK_EXT_QUEUE_FAMILY_FOREIGN_EXTENSION_NAME + = eqCStrings _VK_EXT_QUEUE_FAMILY_FOREIGN_EXTENSION_NAME + +type VK_EXT_QUEUE_FAMILY_FOREIGN_EXTENSION_NAME = + "VK_EXT_queue_family_foreign" diff --git a/src-gen/Graphics/Vulkan/Ext/VK_EXT_sample_locations.hs b/src-gen/Graphics/Vulkan/Ext/VK_EXT_sample_locations.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Ext/VK_EXT_sample_locations.hs @@ -0,0 +1,209 @@ +{-# OPTIONS_GHC -fno-warn-unused-imports#-} +{-# OPTIONS_HADDOCK not-home#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE ForeignFunctionInterface #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE ViewPatterns #-} +module Graphics.Vulkan.Ext.VK_EXT_sample_locations + (-- * Vulkan extension: @VK_EXT_sample_locations@ + -- | + -- + -- supported: @vulkan@ + -- + -- contact: @Daniel Rakos @aqnuep@ + -- + -- author: @AMD@ + -- + -- type: @device@ + -- + -- Extension number: @144@ + module Graphics.Vulkan.Marshal, + module Graphics.Vulkan.Types.Enum.VkAccessFlags, + module Graphics.Vulkan.Types.Struct.VkAttachmentSampleLocationsEXT, + module Graphics.Vulkan.Types.BaseTypes, + module Graphics.Vulkan.Types.Struct.VkClearColorValue, + module Graphics.Vulkan.Types.Struct.VkClearDepthStencilValue, + module Graphics.Vulkan.Types.Struct.VkClearValue, + module Graphics.Vulkan.Types.Struct.VkExtent2D, + module Graphics.Vulkan.Types.Enum.VkImageAspectFlags, + module Graphics.Vulkan.Types.Enum.VkImageLayout, + module Graphics.Vulkan.Types.Struct.VkImageMemoryBarrier, + module Graphics.Vulkan.Types.Struct.VkImageSubresourceRange, + module Graphics.Vulkan.Types.Struct.VkMultisamplePropertiesEXT, + module Graphics.Vulkan.Types.Struct.VkOffset2D, + module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceLimits, + module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceProperties, + module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceProperties2KHR, + module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceSampleLocationsPropertiesEXT, + module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceSparseProperties, + module Graphics.Vulkan.Types.Enum.VkPhysicalDeviceType, + module Graphics.Vulkan.Types.Bitmasks, + module Graphics.Vulkan.Types.Struct.VkPipelineMultisampleStateCreateInfo, + module Graphics.Vulkan.Types.Struct.VkPipelineSampleLocationsStateCreateInfoEXT, + module Graphics.Vulkan.Types.Struct.VkRect2D, + module Graphics.Vulkan.Types.Struct.VkRenderPassBeginInfo, + module Graphics.Vulkan.Types.Struct.VkRenderPassSampleLocationsBeginInfoEXT, + module Graphics.Vulkan.Types.Enum.VkSampleCountFlags, + module Graphics.Vulkan.Types.Struct.VkSampleLocationEXT, + module Graphics.Vulkan.Types.Struct.VkSampleLocationsInfoEXT, + module Graphics.Vulkan.Types.Enum.VkStructureType, + module Graphics.Vulkan.Types.Struct.VkSubpassSampleLocationsEXT, + -- > #include "vk_platform.h" + vkCmdSetSampleLocationsEXT, + vkGetPhysicalDeviceMultisamplePropertiesEXT, + module Graphics.Vulkan.Types.Handles, + VK_EXT_SAMPLE_LOCATIONS_SPEC_VERSION, + pattern VK_EXT_SAMPLE_LOCATIONS_SPEC_VERSION, + VK_EXT_SAMPLE_LOCATIONS_EXTENSION_NAME, + pattern VK_EXT_SAMPLE_LOCATIONS_EXTENSION_NAME, + pattern VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT, + pattern VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT, + pattern VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT, + pattern VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT, + pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT, + pattern VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT, + pattern VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT) + where +import GHC.Ptr + (Ptr (..)) +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Types.BaseTypes +import Graphics.Vulkan.Types.Bitmasks +import Graphics.Vulkan.Types.Enum.VkAccessFlags +import Graphics.Vulkan.Types.Enum.VkDynamicState + (VkDynamicState (..)) +import Graphics.Vulkan.Types.Enum.VkImageAspectFlags +import Graphics.Vulkan.Types.Enum.VkImageCreateFlags + (VkImageCreateBitmask (..), + VkImageCreateFlagBits) +import Graphics.Vulkan.Types.Enum.VkImageLayout +import Graphics.Vulkan.Types.Enum.VkPhysicalDeviceType +import Graphics.Vulkan.Types.Enum.VkSampleCountFlags +import Graphics.Vulkan.Types.Enum.VkStructureType +import Graphics.Vulkan.Types.Handles +import Graphics.Vulkan.Types.Struct.VkAttachmentSampleLocationsEXT +import Graphics.Vulkan.Types.Struct.VkClearColorValue +import Graphics.Vulkan.Types.Struct.VkClearDepthStencilValue +import Graphics.Vulkan.Types.Struct.VkClearValue +import Graphics.Vulkan.Types.Struct.VkExtent2D +import Graphics.Vulkan.Types.Struct.VkImageMemoryBarrier +import Graphics.Vulkan.Types.Struct.VkImageSubresourceRange +import Graphics.Vulkan.Types.Struct.VkMultisamplePropertiesEXT +import Graphics.Vulkan.Types.Struct.VkOffset2D +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceLimits +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceProperties +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceProperties2KHR +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceSampleLocationsPropertiesEXT +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceSparseProperties +import Graphics.Vulkan.Types.Struct.VkPipelineMultisampleStateCreateInfo +import Graphics.Vulkan.Types.Struct.VkPipelineSampleLocationsStateCreateInfoEXT +import Graphics.Vulkan.Types.Struct.VkRect2D +import Graphics.Vulkan.Types.Struct.VkRenderPassBeginInfo +import Graphics.Vulkan.Types.Struct.VkRenderPassSampleLocationsBeginInfoEXT +import Graphics.Vulkan.Types.Struct.VkSampleLocationEXT +import Graphics.Vulkan.Types.Struct.VkSampleLocationsInfoEXT +import Graphics.Vulkan.Types.Struct.VkSubpassSampleLocationsEXT + +-- | queues: 'graphics'. +-- +-- renderpass: @both@ +-- +-- > () vkCmdSetSampleLocationsEXT +-- > ( VkCommandBuffer commandBuffer +-- > , const VkSampleLocationsInfoEXT* pSampleLocationsInfo +-- > ) +-- +-- +foreign import ccall unsafe "vkCmdSetSampleLocationsEXT" + vkCmdSetSampleLocationsEXT :: + VkCommandBuffer -- ^ commandBuffer + -> Ptr VkSampleLocationsInfoEXT -- ^ pSampleLocationsInfo + -> IO () + +-- | > () vkGetPhysicalDeviceMultisamplePropertiesEXT +-- > ( VkPhysicalDevice physicalDevice +-- > , VkSampleCountFlagBits samples +-- > , VkMultisamplePropertiesEXT* pMultisampleProperties +-- > ) +-- +-- +foreign import ccall unsafe + "vkGetPhysicalDeviceMultisamplePropertiesEXT" + vkGetPhysicalDeviceMultisamplePropertiesEXT :: + VkPhysicalDevice -- ^ physicalDevice + -> + VkSampleCountFlagBits -- ^ samples + -> Ptr VkMultisamplePropertiesEXT -- ^ pMultisampleProperties + -> IO () + +pattern VK_EXT_SAMPLE_LOCATIONS_SPEC_VERSION :: (Num a, Eq a) => a + +pattern VK_EXT_SAMPLE_LOCATIONS_SPEC_VERSION = 1 + +type VK_EXT_SAMPLE_LOCATIONS_SPEC_VERSION = 1 + +pattern VK_EXT_SAMPLE_LOCATIONS_EXTENSION_NAME :: CString + +pattern VK_EXT_SAMPLE_LOCATIONS_EXTENSION_NAME <- + (is_VK_EXT_SAMPLE_LOCATIONS_EXTENSION_NAME -> True) + where VK_EXT_SAMPLE_LOCATIONS_EXTENSION_NAME + = _VK_EXT_SAMPLE_LOCATIONS_EXTENSION_NAME + +{-# INLINE _VK_EXT_SAMPLE_LOCATIONS_EXTENSION_NAME #-} + +_VK_EXT_SAMPLE_LOCATIONS_EXTENSION_NAME :: CString +_VK_EXT_SAMPLE_LOCATIONS_EXTENSION_NAME + = Ptr "VK_EXT_sample_locations\NUL"# + +{-# INLINE is_VK_EXT_SAMPLE_LOCATIONS_EXTENSION_NAME #-} + +is_VK_EXT_SAMPLE_LOCATIONS_EXTENSION_NAME :: CString -> Bool +is_VK_EXT_SAMPLE_LOCATIONS_EXTENSION_NAME + = eqCStrings _VK_EXT_SAMPLE_LOCATIONS_EXTENSION_NAME + +type VK_EXT_SAMPLE_LOCATIONS_EXTENSION_NAME = + "VK_EXT_sample_locations" + +-- | bitpos = @12@ +pattern VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT + :: VkImageCreateFlagBits + +pattern VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT = + VkImageCreateFlagBits 4096 + +pattern VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT = + VkStructureType 1000143000 + +pattern VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT + :: VkStructureType + +pattern VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT + = VkStructureType 1000143001 + +pattern VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT + :: VkStructureType + +pattern VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT + = VkStructureType 1000143002 + +pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT + :: VkStructureType + +pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT + = VkStructureType 1000143003 + +pattern VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT = + VkStructureType 1000143004 + +pattern VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT :: VkDynamicState + +pattern VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT = + VkDynamicState 1000143000 diff --git a/src-gen/Graphics/Vulkan/Ext/VK_EXT_sampler_filter_minmax.hs b/src-gen/Graphics/Vulkan/Ext/VK_EXT_sampler_filter_minmax.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Ext/VK_EXT_sampler_filter_minmax.hs @@ -0,0 +1,126 @@ +{-# OPTIONS_HADDOCK not-home#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE ViewPatterns #-} +module Graphics.Vulkan.Ext.VK_EXT_sampler_filter_minmax + (-- * Vulkan extension: @VK_EXT_sampler_filter_minmax@ + -- | + -- + -- supported: @vulkan@ + -- + -- contact: @Jeff Bolz @jbolz@ + -- + -- author: @NV@ + -- + -- type: @device@ + -- + -- Extension number: @131@ + -- + -- Required extensions: 'VK_KHR_get_physical_device_properties2'. + -- + + -- ** Required extensions: 'VK_KHR_get_physical_device_properties2'. + module Graphics.Vulkan.Marshal, + module Graphics.Vulkan.Types.BaseTypes, + module Graphics.Vulkan.Types.Enum.VkBorderColor, + module Graphics.Vulkan.Types.Enum.VkCompareOp, + module Graphics.Vulkan.Types.Enum.VkFilter, + module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceLimits, + module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceProperties, + module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceProperties2KHR, + module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT, + module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceSparseProperties, + module Graphics.Vulkan.Types.Enum.VkPhysicalDeviceType, + module Graphics.Vulkan.Types.Enum.VkSampleCountFlags, + module Graphics.Vulkan.Types.Enum.VkSamplerAddressMode, + module Graphics.Vulkan.Types.Bitmasks, + module Graphics.Vulkan.Types.Struct.VkSamplerCreateInfo, + module Graphics.Vulkan.Types.Enum.VkSamplerMipmapMode, + module Graphics.Vulkan.Types.Struct.VkSamplerReductionModeCreateInfoEXT, + module Graphics.Vulkan.Types.Enum.VkSamplerReductionModeEXT, + module Graphics.Vulkan.Types.Enum.VkStructureType, + -- > #include "vk_platform.h" + VK_EXT_SAMPLER_FILTER_MINMAX_SPEC_VERSION, + pattern VK_EXT_SAMPLER_FILTER_MINMAX_SPEC_VERSION, + VK_EXT_SAMPLER_FILTER_MINMAX_EXTENSION_NAME, + pattern VK_EXT_SAMPLER_FILTER_MINMAX_EXTENSION_NAME, + pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT, + pattern VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT, + pattern VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT_EXT) + where +import GHC.Ptr + (Ptr (..)) +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Types.BaseTypes +import Graphics.Vulkan.Types.Bitmasks +import Graphics.Vulkan.Types.Enum.VkBorderColor +import Graphics.Vulkan.Types.Enum.VkCompareOp +import Graphics.Vulkan.Types.Enum.VkFilter +import Graphics.Vulkan.Types.Enum.VkFormatFeatureFlags + (VkFormatFeatureBitmask (..), + VkFormatFeatureFlagBits) +import Graphics.Vulkan.Types.Enum.VkPhysicalDeviceType +import Graphics.Vulkan.Types.Enum.VkSampleCountFlags +import Graphics.Vulkan.Types.Enum.VkSamplerAddressMode +import Graphics.Vulkan.Types.Enum.VkSamplerMipmapMode +import Graphics.Vulkan.Types.Enum.VkSamplerReductionModeEXT +import Graphics.Vulkan.Types.Enum.VkStructureType +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceLimits +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceProperties +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceProperties2KHR +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceSparseProperties +import Graphics.Vulkan.Types.Struct.VkSamplerCreateInfo +import Graphics.Vulkan.Types.Struct.VkSamplerReductionModeCreateInfoEXT + +pattern VK_EXT_SAMPLER_FILTER_MINMAX_SPEC_VERSION :: + (Num a, Eq a) => a + +pattern VK_EXT_SAMPLER_FILTER_MINMAX_SPEC_VERSION = 1 + +type VK_EXT_SAMPLER_FILTER_MINMAX_SPEC_VERSION = 1 + +pattern VK_EXT_SAMPLER_FILTER_MINMAX_EXTENSION_NAME :: CString + +pattern VK_EXT_SAMPLER_FILTER_MINMAX_EXTENSION_NAME <- + (is_VK_EXT_SAMPLER_FILTER_MINMAX_EXTENSION_NAME -> True) + where VK_EXT_SAMPLER_FILTER_MINMAX_EXTENSION_NAME + = _VK_EXT_SAMPLER_FILTER_MINMAX_EXTENSION_NAME + +{-# INLINE _VK_EXT_SAMPLER_FILTER_MINMAX_EXTENSION_NAME #-} + +_VK_EXT_SAMPLER_FILTER_MINMAX_EXTENSION_NAME :: CString +_VK_EXT_SAMPLER_FILTER_MINMAX_EXTENSION_NAME + = Ptr "VK_EXT_sampler_filter_minmax\NUL"# + +{-# INLINE is_VK_EXT_SAMPLER_FILTER_MINMAX_EXTENSION_NAME #-} + +is_VK_EXT_SAMPLER_FILTER_MINMAX_EXTENSION_NAME :: CString -> Bool +is_VK_EXT_SAMPLER_FILTER_MINMAX_EXTENSION_NAME + = eqCStrings _VK_EXT_SAMPLER_FILTER_MINMAX_EXTENSION_NAME + +type VK_EXT_SAMPLER_FILTER_MINMAX_EXTENSION_NAME = + "VK_EXT_sampler_filter_minmax" + +pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT + :: VkStructureType + +pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT + = VkStructureType 1000130000 + +pattern VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT = + VkStructureType 1000130001 + +-- | Format can be used with min/max reduction filtering +-- +-- bitpos = @16@ +pattern VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT_EXT :: + VkFormatFeatureFlagBits + +pattern VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT_EXT = + VkFormatFeatureFlagBits 65536 diff --git a/src-gen/Graphics/Vulkan/Ext/VK_EXT_shader_stencil_export.hs b/src-gen/Graphics/Vulkan/Ext/VK_EXT_shader_stencil_export.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Ext/VK_EXT_shader_stencil_export.hs @@ -0,0 +1,55 @@ +{-# OPTIONS_HADDOCK not-home#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE ViewPatterns #-} +module Graphics.Vulkan.Ext.VK_EXT_shader_stencil_export + (-- * Vulkan extension: @VK_EXT_shader_stencil_export@ + -- | + -- + -- supported: @vulkan@ + -- + -- contact: @dominik.witczak@amd.com@ + -- + -- author: @EXT@ + -- + -- type: @device@ + -- + -- Extension number: @141@ + VK_EXT_SHADER_STENCIL_EXPORT_SPEC_VERSION, + pattern VK_EXT_SHADER_STENCIL_EXPORT_SPEC_VERSION, + VK_EXT_SHADER_STENCIL_EXPORT_EXTENSION_NAME, + pattern VK_EXT_SHADER_STENCIL_EXPORT_EXTENSION_NAME) + where +import GHC.Ptr (Ptr (..)) +import Graphics.Vulkan.Marshal + +pattern VK_EXT_SHADER_STENCIL_EXPORT_SPEC_VERSION :: + (Num a, Eq a) => a + +pattern VK_EXT_SHADER_STENCIL_EXPORT_SPEC_VERSION = 1 + +type VK_EXT_SHADER_STENCIL_EXPORT_SPEC_VERSION = 1 + +pattern VK_EXT_SHADER_STENCIL_EXPORT_EXTENSION_NAME :: CString + +pattern VK_EXT_SHADER_STENCIL_EXPORT_EXTENSION_NAME <- + (is_VK_EXT_SHADER_STENCIL_EXPORT_EXTENSION_NAME -> True) + where VK_EXT_SHADER_STENCIL_EXPORT_EXTENSION_NAME + = _VK_EXT_SHADER_STENCIL_EXPORT_EXTENSION_NAME + +{-# INLINE _VK_EXT_SHADER_STENCIL_EXPORT_EXTENSION_NAME #-} + +_VK_EXT_SHADER_STENCIL_EXPORT_EXTENSION_NAME :: CString +_VK_EXT_SHADER_STENCIL_EXPORT_EXTENSION_NAME + = Ptr "VK_EXT_shader_stencil_export\NUL"# + +{-# INLINE is_VK_EXT_SHADER_STENCIL_EXPORT_EXTENSION_NAME #-} + +is_VK_EXT_SHADER_STENCIL_EXPORT_EXTENSION_NAME :: CString -> Bool +is_VK_EXT_SHADER_STENCIL_EXPORT_EXTENSION_NAME + = eqCStrings _VK_EXT_SHADER_STENCIL_EXPORT_EXTENSION_NAME + +type VK_EXT_SHADER_STENCIL_EXPORT_EXTENSION_NAME = + "VK_EXT_shader_stencil_export" diff --git a/src-gen/Graphics/Vulkan/Ext/VK_EXT_shader_subgroup_ballot.hs b/src-gen/Graphics/Vulkan/Ext/VK_EXT_shader_subgroup_ballot.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Ext/VK_EXT_shader_subgroup_ballot.hs @@ -0,0 +1,55 @@ +{-# OPTIONS_HADDOCK not-home#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE ViewPatterns #-} +module Graphics.Vulkan.Ext.VK_EXT_shader_subgroup_ballot + (-- * Vulkan extension: @VK_EXT_shader_subgroup_ballot@ + -- | + -- + -- supported: @vulkan@ + -- + -- contact: @Daniel Koch @dgkoch@ + -- + -- author: @NV@ + -- + -- type: @device@ + -- + -- Extension number: @65@ + VK_EXT_SHADER_SUBGROUP_BALLOT_SPEC_VERSION, + pattern VK_EXT_SHADER_SUBGROUP_BALLOT_SPEC_VERSION, + VK_EXT_SHADER_SUBGROUP_BALLOT_EXTENSION_NAME, + pattern VK_EXT_SHADER_SUBGROUP_BALLOT_EXTENSION_NAME) + where +import GHC.Ptr (Ptr (..)) +import Graphics.Vulkan.Marshal + +pattern VK_EXT_SHADER_SUBGROUP_BALLOT_SPEC_VERSION :: + (Num a, Eq a) => a + +pattern VK_EXT_SHADER_SUBGROUP_BALLOT_SPEC_VERSION = 1 + +type VK_EXT_SHADER_SUBGROUP_BALLOT_SPEC_VERSION = 1 + +pattern VK_EXT_SHADER_SUBGROUP_BALLOT_EXTENSION_NAME :: CString + +pattern VK_EXT_SHADER_SUBGROUP_BALLOT_EXTENSION_NAME <- + (is_VK_EXT_SHADER_SUBGROUP_BALLOT_EXTENSION_NAME -> True) + where VK_EXT_SHADER_SUBGROUP_BALLOT_EXTENSION_NAME + = _VK_EXT_SHADER_SUBGROUP_BALLOT_EXTENSION_NAME + +{-# INLINE _VK_EXT_SHADER_SUBGROUP_BALLOT_EXTENSION_NAME #-} + +_VK_EXT_SHADER_SUBGROUP_BALLOT_EXTENSION_NAME :: CString +_VK_EXT_SHADER_SUBGROUP_BALLOT_EXTENSION_NAME + = Ptr "VK_EXT_shader_subgroup_ballot\NUL"# + +{-# INLINE is_VK_EXT_SHADER_SUBGROUP_BALLOT_EXTENSION_NAME #-} + +is_VK_EXT_SHADER_SUBGROUP_BALLOT_EXTENSION_NAME :: CString -> Bool +is_VK_EXT_SHADER_SUBGROUP_BALLOT_EXTENSION_NAME + = eqCStrings _VK_EXT_SHADER_SUBGROUP_BALLOT_EXTENSION_NAME + +type VK_EXT_SHADER_SUBGROUP_BALLOT_EXTENSION_NAME = + "VK_EXT_shader_subgroup_ballot" diff --git a/src-gen/Graphics/Vulkan/Ext/VK_EXT_shader_subgroup_vote.hs b/src-gen/Graphics/Vulkan/Ext/VK_EXT_shader_subgroup_vote.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Ext/VK_EXT_shader_subgroup_vote.hs @@ -0,0 +1,55 @@ +{-# OPTIONS_HADDOCK not-home#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE ViewPatterns #-} +module Graphics.Vulkan.Ext.VK_EXT_shader_subgroup_vote + (-- * Vulkan extension: @VK_EXT_shader_subgroup_vote@ + -- | + -- + -- supported: @vulkan@ + -- + -- contact: @Daniel Koch @dgkoch@ + -- + -- author: @NV@ + -- + -- type: @device@ + -- + -- Extension number: @66@ + VK_EXT_SHADER_SUBGROUP_VOTE_SPEC_VERSION, + pattern VK_EXT_SHADER_SUBGROUP_VOTE_SPEC_VERSION, + VK_EXT_SHADER_SUBGROUP_VOTE_EXTENSION_NAME, + pattern VK_EXT_SHADER_SUBGROUP_VOTE_EXTENSION_NAME) + where +import GHC.Ptr (Ptr (..)) +import Graphics.Vulkan.Marshal + +pattern VK_EXT_SHADER_SUBGROUP_VOTE_SPEC_VERSION :: + (Num a, Eq a) => a + +pattern VK_EXT_SHADER_SUBGROUP_VOTE_SPEC_VERSION = 1 + +type VK_EXT_SHADER_SUBGROUP_VOTE_SPEC_VERSION = 1 + +pattern VK_EXT_SHADER_SUBGROUP_VOTE_EXTENSION_NAME :: CString + +pattern VK_EXT_SHADER_SUBGROUP_VOTE_EXTENSION_NAME <- + (is_VK_EXT_SHADER_SUBGROUP_VOTE_EXTENSION_NAME -> True) + where VK_EXT_SHADER_SUBGROUP_VOTE_EXTENSION_NAME + = _VK_EXT_SHADER_SUBGROUP_VOTE_EXTENSION_NAME + +{-# INLINE _VK_EXT_SHADER_SUBGROUP_VOTE_EXTENSION_NAME #-} + +_VK_EXT_SHADER_SUBGROUP_VOTE_EXTENSION_NAME :: CString +_VK_EXT_SHADER_SUBGROUP_VOTE_EXTENSION_NAME + = Ptr "VK_EXT_shader_subgroup_vote\NUL"# + +{-# INLINE is_VK_EXT_SHADER_SUBGROUP_VOTE_EXTENSION_NAME #-} + +is_VK_EXT_SHADER_SUBGROUP_VOTE_EXTENSION_NAME :: CString -> Bool +is_VK_EXT_SHADER_SUBGROUP_VOTE_EXTENSION_NAME + = eqCStrings _VK_EXT_SHADER_SUBGROUP_VOTE_EXTENSION_NAME + +type VK_EXT_SHADER_SUBGROUP_VOTE_EXTENSION_NAME = + "VK_EXT_shader_subgroup_vote" diff --git a/src-gen/Graphics/Vulkan/Ext/VK_EXT_shader_viewport_index_layer.hs b/src-gen/Graphics/Vulkan/Ext/VK_EXT_shader_viewport_index_layer.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Ext/VK_EXT_shader_viewport_index_layer.hs @@ -0,0 +1,57 @@ +{-# OPTIONS_HADDOCK not-home#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE ViewPatterns #-} +module Graphics.Vulkan.Ext.VK_EXT_shader_viewport_index_layer + (-- * Vulkan extension: @VK_EXT_shader_viewport_index_layer@ + -- | + -- + -- supported: @vulkan@ + -- + -- contact: @Daniel Koch @dgkoch@ + -- + -- author: @NV@ + -- + -- type: @device@ + -- + -- Extension number: @163@ + VK_EXT_SHADER_VIEWPORT_INDEX_LAYER_SPEC_VERSION, + pattern VK_EXT_SHADER_VIEWPORT_INDEX_LAYER_SPEC_VERSION, + VK_EXT_SHADER_VIEWPORT_INDEX_LAYER_EXTENSION_NAME, + pattern VK_EXT_SHADER_VIEWPORT_INDEX_LAYER_EXTENSION_NAME) + where +import GHC.Ptr (Ptr (..)) +import Graphics.Vulkan.Marshal + +pattern VK_EXT_SHADER_VIEWPORT_INDEX_LAYER_SPEC_VERSION :: + (Num a, Eq a) => a + +pattern VK_EXT_SHADER_VIEWPORT_INDEX_LAYER_SPEC_VERSION = 1 + +type VK_EXT_SHADER_VIEWPORT_INDEX_LAYER_SPEC_VERSION = 1 + +pattern VK_EXT_SHADER_VIEWPORT_INDEX_LAYER_EXTENSION_NAME :: + CString + +pattern VK_EXT_SHADER_VIEWPORT_INDEX_LAYER_EXTENSION_NAME <- + (is_VK_EXT_SHADER_VIEWPORT_INDEX_LAYER_EXTENSION_NAME -> True) + where VK_EXT_SHADER_VIEWPORT_INDEX_LAYER_EXTENSION_NAME + = _VK_EXT_SHADER_VIEWPORT_INDEX_LAYER_EXTENSION_NAME + +{-# INLINE _VK_EXT_SHADER_VIEWPORT_INDEX_LAYER_EXTENSION_NAME #-} + +_VK_EXT_SHADER_VIEWPORT_INDEX_LAYER_EXTENSION_NAME :: CString +_VK_EXT_SHADER_VIEWPORT_INDEX_LAYER_EXTENSION_NAME + = Ptr "VK_EXT_shader_viewport_index_layer\NUL"# + +{-# INLINE is_VK_EXT_SHADER_VIEWPORT_INDEX_LAYER_EXTENSION_NAME #-} + +is_VK_EXT_SHADER_VIEWPORT_INDEX_LAYER_EXTENSION_NAME :: + CString -> Bool +is_VK_EXT_SHADER_VIEWPORT_INDEX_LAYER_EXTENSION_NAME + = eqCStrings _VK_EXT_SHADER_VIEWPORT_INDEX_LAYER_EXTENSION_NAME + +type VK_EXT_SHADER_VIEWPORT_INDEX_LAYER_EXTENSION_NAME = + "VK_EXT_shader_viewport_index_layer" diff --git a/src-gen/Graphics/Vulkan/Ext/VK_EXT_swapchain_colorspace.hs b/src-gen/Graphics/Vulkan/Ext/VK_EXT_swapchain_colorspace.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Ext/VK_EXT_swapchain_colorspace.hs @@ -0,0 +1,144 @@ +{-# OPTIONS_HADDOCK not-home#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE ViewPatterns #-} +module Graphics.Vulkan.Ext.VK_EXT_swapchain_colorspace + (-- * Vulkan extension: @VK_EXT_swapchain_colorspace@ + -- | + -- + -- supported: @vulkan@ + -- + -- contact: @Courtney Goeltzenleuchter @courtneygo@ + -- + -- author: @GOOGLE@ + -- + -- type: @instance@ + -- + -- Extension number: @105@ + -- + -- Required extensions: 'VK_KHR_surface'. + -- + + -- ** Required extensions: 'VK_KHR_surface'. + VK_EXT_SWAPCHAIN_COLOR_SPACE_SPEC_VERSION, + pattern VK_EXT_SWAPCHAIN_COLOR_SPACE_SPEC_VERSION, + VK_EXT_SWAPCHAIN_COLOR_SPACE_EXTENSION_NAME, + pattern VK_EXT_SWAPCHAIN_COLOR_SPACE_EXTENSION_NAME, + pattern VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT, + pattern VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT, + pattern VK_COLOR_SPACE_DCI_P3_LINEAR_EXT, + pattern VK_COLOR_SPACE_DCI_P3_NONLINEAR_EXT, + pattern VK_COLOR_SPACE_BT709_LINEAR_EXT, + pattern VK_COLOR_SPACE_BT709_NONLINEAR_EXT, + pattern VK_COLOR_SPACE_BT2020_LINEAR_EXT, + pattern VK_COLOR_SPACE_HDR10_ST2084_EXT, + pattern VK_COLOR_SPACE_DOLBYVISION_EXT, + pattern VK_COLOR_SPACE_HDR10_HLG_EXT, + pattern VK_COLOR_SPACE_ADOBERGB_LINEAR_EXT, + pattern VK_COLOR_SPACE_ADOBERGB_NONLINEAR_EXT, + pattern VK_COLOR_SPACE_PASS_THROUGH_EXT, + pattern VK_COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT) + where +import GHC.Ptr (Ptr (..)) +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Types.Enum.VkColorSpaceKHR (VkColorSpaceKHR (..)) + +pattern VK_EXT_SWAPCHAIN_COLOR_SPACE_SPEC_VERSION :: + (Num a, Eq a) => a + +pattern VK_EXT_SWAPCHAIN_COLOR_SPACE_SPEC_VERSION = 3 + +type VK_EXT_SWAPCHAIN_COLOR_SPACE_SPEC_VERSION = 3 + +pattern VK_EXT_SWAPCHAIN_COLOR_SPACE_EXTENSION_NAME :: CString + +pattern VK_EXT_SWAPCHAIN_COLOR_SPACE_EXTENSION_NAME <- + (is_VK_EXT_SWAPCHAIN_COLOR_SPACE_EXTENSION_NAME -> True) + where VK_EXT_SWAPCHAIN_COLOR_SPACE_EXTENSION_NAME + = _VK_EXT_SWAPCHAIN_COLOR_SPACE_EXTENSION_NAME + +{-# INLINE _VK_EXT_SWAPCHAIN_COLOR_SPACE_EXTENSION_NAME #-} + +_VK_EXT_SWAPCHAIN_COLOR_SPACE_EXTENSION_NAME :: CString +_VK_EXT_SWAPCHAIN_COLOR_SPACE_EXTENSION_NAME + = Ptr "VK_EXT_swapchain_colorspace\NUL"# + +{-# INLINE is_VK_EXT_SWAPCHAIN_COLOR_SPACE_EXTENSION_NAME #-} + +is_VK_EXT_SWAPCHAIN_COLOR_SPACE_EXTENSION_NAME :: CString -> Bool +is_VK_EXT_SWAPCHAIN_COLOR_SPACE_EXTENSION_NAME + = eqCStrings _VK_EXT_SWAPCHAIN_COLOR_SPACE_EXTENSION_NAME + +type VK_EXT_SWAPCHAIN_COLOR_SPACE_EXTENSION_NAME = + "VK_EXT_swapchain_colorspace" + +pattern VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT :: VkColorSpaceKHR + +pattern VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT = + VkColorSpaceKHR 1000104001 + +pattern VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT :: VkColorSpaceKHR + +pattern VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT = + VkColorSpaceKHR 1000104002 + +pattern VK_COLOR_SPACE_DCI_P3_LINEAR_EXT :: VkColorSpaceKHR + +pattern VK_COLOR_SPACE_DCI_P3_LINEAR_EXT = + VkColorSpaceKHR 1000104003 + +pattern VK_COLOR_SPACE_DCI_P3_NONLINEAR_EXT :: VkColorSpaceKHR + +pattern VK_COLOR_SPACE_DCI_P3_NONLINEAR_EXT = + VkColorSpaceKHR 1000104004 + +pattern VK_COLOR_SPACE_BT709_LINEAR_EXT :: VkColorSpaceKHR + +pattern VK_COLOR_SPACE_BT709_LINEAR_EXT = + VkColorSpaceKHR 1000104005 + +pattern VK_COLOR_SPACE_BT709_NONLINEAR_EXT :: VkColorSpaceKHR + +pattern VK_COLOR_SPACE_BT709_NONLINEAR_EXT = + VkColorSpaceKHR 1000104006 + +pattern VK_COLOR_SPACE_BT2020_LINEAR_EXT :: VkColorSpaceKHR + +pattern VK_COLOR_SPACE_BT2020_LINEAR_EXT = + VkColorSpaceKHR 1000104007 + +pattern VK_COLOR_SPACE_HDR10_ST2084_EXT :: VkColorSpaceKHR + +pattern VK_COLOR_SPACE_HDR10_ST2084_EXT = + VkColorSpaceKHR 1000104008 + +pattern VK_COLOR_SPACE_DOLBYVISION_EXT :: VkColorSpaceKHR + +pattern VK_COLOR_SPACE_DOLBYVISION_EXT = VkColorSpaceKHR 1000104009 + +pattern VK_COLOR_SPACE_HDR10_HLG_EXT :: VkColorSpaceKHR + +pattern VK_COLOR_SPACE_HDR10_HLG_EXT = VkColorSpaceKHR 1000104010 + +pattern VK_COLOR_SPACE_ADOBERGB_LINEAR_EXT :: VkColorSpaceKHR + +pattern VK_COLOR_SPACE_ADOBERGB_LINEAR_EXT = + VkColorSpaceKHR 1000104011 + +pattern VK_COLOR_SPACE_ADOBERGB_NONLINEAR_EXT :: VkColorSpaceKHR + +pattern VK_COLOR_SPACE_ADOBERGB_NONLINEAR_EXT = + VkColorSpaceKHR 1000104012 + +pattern VK_COLOR_SPACE_PASS_THROUGH_EXT :: VkColorSpaceKHR + +pattern VK_COLOR_SPACE_PASS_THROUGH_EXT = + VkColorSpaceKHR 1000104013 + +pattern VK_COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT :: + VkColorSpaceKHR + +pattern VK_COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT = + VkColorSpaceKHR 1000104014 diff --git a/src-gen/Graphics/Vulkan/Ext/VK_EXT_validation_cache.hs b/src-gen/Graphics/Vulkan/Ext/VK_EXT_validation_cache.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Ext/VK_EXT_validation_cache.hs @@ -0,0 +1,197 @@ +{-# OPTIONS_GHC -fno-warn-missing-pattern-synonym-signatures#-} +{-# OPTIONS_HADDOCK not-home#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE ForeignFunctionInterface #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE ViewPatterns #-} +module Graphics.Vulkan.Ext.VK_EXT_validation_cache + (-- * Vulkan extension: @VK_EXT_validation_cache@ + -- | + -- + -- supported: @vulkan@ + -- + -- contact: @Cort Stratton @cdwfs@ + -- + -- author: @GOOGLE@ + -- + -- type: @device@ + -- + -- Extension number: @161@ + module Graphics.Vulkan.Marshal, + module Graphics.Vulkan.Types.BaseTypes, + module Graphics.Vulkan.Types.Bitmasks, + module Graphics.Vulkan.Types.Struct.VkShaderModuleCreateInfo, + module Graphics.Vulkan.Types.Struct.VkShaderModuleValidationCacheCreateInfoEXT, + module Graphics.Vulkan.Types.Enum.VkStructureType, + module Graphics.Vulkan.Types.Struct.VkValidationCacheCreateInfoEXT, + module Graphics.Vulkan.Types.Enum.VkValidationCacheHeaderVersionEXT, + -- > #include "vk_platform.h" + vkCreateValidationCacheEXT, vkDestroyValidationCacheEXT, + vkMergeValidationCachesEXT, vkGetValidationCacheDataEXT, + module Graphics.Vulkan.Types.Enum.VkInternalAllocationType, + module Graphics.Vulkan.Types.Enum.VkResult, + module Graphics.Vulkan.Types.Enum.VkSystemAllocationScope, + module Graphics.Vulkan.Types.Funcpointers, + module Graphics.Vulkan.Types.Handles, + module Graphics.Vulkan.Types.Struct.VkAllocationCallbacks, + VK_EXT_VALIDATION_CACHE_SPEC_VERSION, + pattern VK_EXT_VALIDATION_CACHE_SPEC_VERSION, + VK_EXT_VALIDATION_CACHE_EXTENSION_NAME, + pattern VK_EXT_VALIDATION_CACHE_EXTENSION_NAME, + pattern VK_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT, + pattern VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT, + pattern VK_OBJECT_TYPE_VALIDATION_CACHE_EXT, + pattern VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT) + where +import GHC.Ptr + (Ptr (..)) +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Types.BaseTypes +import Graphics.Vulkan.Types.Bitmasks +import Graphics.Vulkan.Types.Enum.VkDebugReportObjectTypeEXT + (VkDebugReportObjectTypeEXT (..)) +import Graphics.Vulkan.Types.Enum.VkInternalAllocationType +import Graphics.Vulkan.Types.Enum.VkObjectType + (VkObjectType (..)) +import Graphics.Vulkan.Types.Enum.VkResult +import Graphics.Vulkan.Types.Enum.VkStructureType +import Graphics.Vulkan.Types.Enum.VkSystemAllocationScope +import Graphics.Vulkan.Types.Enum.VkValidationCacheHeaderVersionEXT +import Graphics.Vulkan.Types.Funcpointers +import Graphics.Vulkan.Types.Handles +import Graphics.Vulkan.Types.Struct.VkAllocationCallbacks +import Graphics.Vulkan.Types.Struct.VkShaderModuleCreateInfo +import Graphics.Vulkan.Types.Struct.VkShaderModuleValidationCacheCreateInfoEXT +import Graphics.Vulkan.Types.Struct.VkValidationCacheCreateInfoEXT + +-- | Success codes: 'VK_SUCCESS'. +-- +-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY'. +-- +-- > VkResult vkCreateValidationCacheEXT +-- > ( VkDevice device +-- > , const VkValidationCacheCreateInfoEXT* pCreateInfo +-- > , const VkAllocationCallbacks* pAllocator +-- > , VkValidationCacheEXT* pValidationCache +-- > ) +-- +-- +foreign import ccall unsafe "vkCreateValidationCacheEXT" + vkCreateValidationCacheEXT :: + VkDevice -- ^ device + -> + Ptr VkValidationCacheCreateInfoEXT -- ^ pCreateInfo + -> + Ptr VkAllocationCallbacks -- ^ pAllocator + -> + Ptr VkValidationCacheEXT -- ^ pValidationCache + -> IO VkResult + +-- | > () vkDestroyValidationCacheEXT +-- > ( VkDevice device +-- > , VkValidationCacheEXT validationCache +-- > , const VkAllocationCallbacks* pAllocator +-- > ) +-- +-- +foreign import ccall unsafe "vkDestroyValidationCacheEXT" + vkDestroyValidationCacheEXT :: + VkDevice -- ^ device + -> + VkValidationCacheEXT -- ^ validationCache + -> Ptr VkAllocationCallbacks -- ^ pAllocator + -> IO () + +-- | Success codes: 'VK_SUCCESS'. +-- +-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. +-- +-- > VkResult vkMergeValidationCachesEXT +-- > ( VkDevice device +-- > , VkValidationCacheEXT dstCache +-- > , uint32_t srcCacheCount +-- > , const VkValidationCacheEXT* pSrcCaches +-- > ) +-- +-- +foreign import ccall unsafe "vkMergeValidationCachesEXT" + vkMergeValidationCachesEXT :: + VkDevice -- ^ device + -> + VkValidationCacheEXT -- ^ dstCache + -> + Word32 -- ^ srcCacheCount + -> Ptr VkValidationCacheEXT -- ^ pSrcCaches + -> IO VkResult + +-- | Success codes: 'VK_SUCCESS', 'VK_INCOMPLETE'. +-- +-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. +-- +-- > VkResult vkGetValidationCacheDataEXT +-- > ( VkDevice device +-- > , VkValidationCacheEXT validationCache +-- > , size_t* pDataSize +-- > , void* pData +-- > ) +-- +-- +foreign import ccall unsafe "vkGetValidationCacheDataEXT" + vkGetValidationCacheDataEXT :: + VkDevice -- ^ device + -> + VkValidationCacheEXT -- ^ validationCache + -> Ptr CSize -- ^ pDataSize + -> Ptr Void -- ^ pData + -> IO VkResult + +pattern VK_EXT_VALIDATION_CACHE_SPEC_VERSION :: (Num a, Eq a) => a + +pattern VK_EXT_VALIDATION_CACHE_SPEC_VERSION = 1 + +type VK_EXT_VALIDATION_CACHE_SPEC_VERSION = 1 + +pattern VK_EXT_VALIDATION_CACHE_EXTENSION_NAME :: CString + +pattern VK_EXT_VALIDATION_CACHE_EXTENSION_NAME <- + (is_VK_EXT_VALIDATION_CACHE_EXTENSION_NAME -> True) + where VK_EXT_VALIDATION_CACHE_EXTENSION_NAME + = _VK_EXT_VALIDATION_CACHE_EXTENSION_NAME + +{-# INLINE _VK_EXT_VALIDATION_CACHE_EXTENSION_NAME #-} + +_VK_EXT_VALIDATION_CACHE_EXTENSION_NAME :: CString +_VK_EXT_VALIDATION_CACHE_EXTENSION_NAME + = Ptr "VK_EXT_validation_cache\NUL"# + +{-# INLINE is_VK_EXT_VALIDATION_CACHE_EXTENSION_NAME #-} + +is_VK_EXT_VALIDATION_CACHE_EXTENSION_NAME :: CString -> Bool +is_VK_EXT_VALIDATION_CACHE_EXTENSION_NAME + = eqCStrings _VK_EXT_VALIDATION_CACHE_EXTENSION_NAME + +type VK_EXT_VALIDATION_CACHE_EXTENSION_NAME = + "VK_EXT_validation_cache" + +pattern VK_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT = + VkStructureType 1000160000 + +pattern VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT + :: VkStructureType + +pattern VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT + = VkStructureType 1000160001 + +-- | VkValidationCacheEXT +pattern VK_OBJECT_TYPE_VALIDATION_CACHE_EXT :: VkObjectType + +pattern VK_OBJECT_TYPE_VALIDATION_CACHE_EXT = + VkObjectType 1000160000 + +pattern VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT = + VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT diff --git a/src-gen/Graphics/Vulkan/Ext/VK_EXT_validation_flags.hs b/src-gen/Graphics/Vulkan/Ext/VK_EXT_validation_flags.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Ext/VK_EXT_validation_flags.hs @@ -0,0 +1,76 @@ +{-# OPTIONS_HADDOCK not-home#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE ViewPatterns #-} +module Graphics.Vulkan.Ext.VK_EXT_validation_flags + (-- * Vulkan extension: @VK_EXT_validation_flags@ + -- | + -- + -- supported: @vulkan@ + -- + -- contact: @Tobin Ehlis @tobine@ + -- + -- author: @GOOGLE@ + -- + -- type: @instance@ + -- + -- Extension number: @62@ + module Graphics.Vulkan.Marshal, + module Graphics.Vulkan.Types.Struct.VkApplicationInfo, + module Graphics.Vulkan.Types.BaseTypes, + module Graphics.Vulkan.Types.Bitmasks, + module Graphics.Vulkan.Types.Struct.VkInstanceCreateInfo, + module Graphics.Vulkan.Types.Enum.VkStructureType, + module Graphics.Vulkan.Types.Enum.VkValidationCheckEXT, + module Graphics.Vulkan.Types.Struct.VkValidationFlagsEXT, + -- > #include "vk_platform.h" + VK_EXT_VALIDATION_FLAGS_SPEC_VERSION, + pattern VK_EXT_VALIDATION_FLAGS_SPEC_VERSION, + VK_EXT_VALIDATION_FLAGS_EXTENSION_NAME, + pattern VK_EXT_VALIDATION_FLAGS_EXTENSION_NAME, + pattern VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT) + where +import GHC.Ptr (Ptr (..)) +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Types.BaseTypes +import Graphics.Vulkan.Types.Bitmasks +import Graphics.Vulkan.Types.Enum.VkStructureType +import Graphics.Vulkan.Types.Enum.VkValidationCheckEXT +import Graphics.Vulkan.Types.Struct.VkApplicationInfo +import Graphics.Vulkan.Types.Struct.VkInstanceCreateInfo +import Graphics.Vulkan.Types.Struct.VkValidationFlagsEXT + +pattern VK_EXT_VALIDATION_FLAGS_SPEC_VERSION :: (Num a, Eq a) => a + +pattern VK_EXT_VALIDATION_FLAGS_SPEC_VERSION = 1 + +type VK_EXT_VALIDATION_FLAGS_SPEC_VERSION = 1 + +pattern VK_EXT_VALIDATION_FLAGS_EXTENSION_NAME :: CString + +pattern VK_EXT_VALIDATION_FLAGS_EXTENSION_NAME <- + (is_VK_EXT_VALIDATION_FLAGS_EXTENSION_NAME -> True) + where VK_EXT_VALIDATION_FLAGS_EXTENSION_NAME + = _VK_EXT_VALIDATION_FLAGS_EXTENSION_NAME + +{-# INLINE _VK_EXT_VALIDATION_FLAGS_EXTENSION_NAME #-} + +_VK_EXT_VALIDATION_FLAGS_EXTENSION_NAME :: CString +_VK_EXT_VALIDATION_FLAGS_EXTENSION_NAME + = Ptr "VK_EXT_validation_flags\NUL"# + +{-# INLINE is_VK_EXT_VALIDATION_FLAGS_EXTENSION_NAME #-} + +is_VK_EXT_VALIDATION_FLAGS_EXTENSION_NAME :: CString -> Bool +is_VK_EXT_VALIDATION_FLAGS_EXTENSION_NAME + = eqCStrings _VK_EXT_VALIDATION_FLAGS_EXTENSION_NAME + +type VK_EXT_VALIDATION_FLAGS_EXTENSION_NAME = + "VK_EXT_validation_flags" + +pattern VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT :: VkStructureType + +pattern VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT = + VkStructureType 1000061000 diff --git a/src-gen/Graphics/Vulkan/Ext/VK_GOOGLE_display_timing.hs b/src-gen/Graphics/Vulkan/Ext/VK_GOOGLE_display_timing.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Ext/VK_GOOGLE_display_timing.hs @@ -0,0 +1,127 @@ +{-# OPTIONS_HADDOCK not-home#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE ForeignFunctionInterface #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE ViewPatterns #-} +module Graphics.Vulkan.Ext.VK_GOOGLE_display_timing + (-- * Vulkan extension: @VK_GOOGLE_display_timing@ + -- | + -- + -- supported: @vulkan@ + -- + -- contact: @Ian Elliott ianelliott@google.com@ + -- + -- author: @GOOGLE@ + -- + -- type: @device@ + -- + -- Extension number: @93@ + -- + -- Required extensions: 'VK_KHR_swapchain'. + -- + + -- ** Required extensions: 'VK_KHR_swapchain'. + module Graphics.Vulkan.Types.Struct.VkPastPresentationTimingGOOGLE, + module Graphics.Vulkan.Types.Struct.VkPresentInfoKHR, + module Graphics.Vulkan.Types.Struct.VkPresentTimeGOOGLE, + module Graphics.Vulkan.Types.Struct.VkPresentTimesInfoGOOGLE, + module Graphics.Vulkan.Types.Struct.VkRefreshCycleDurationGOOGLE, + module Graphics.Vulkan.Types.Enum.VkResult, + module Graphics.Vulkan.Types.Enum.VkStructureType, + -- > #include "vk_platform.h" + vkGetRefreshCycleDurationGOOGLE, vkGetPastPresentationTimingGOOGLE, + module Graphics.Vulkan.Marshal, + module Graphics.Vulkan.Types.Handles, + VK_GOOGLE_DISPLAY_TIMING_SPEC_VERSION, + pattern VK_GOOGLE_DISPLAY_TIMING_SPEC_VERSION, + VK_GOOGLE_DISPLAY_TIMING_EXTENSION_NAME, + pattern VK_GOOGLE_DISPLAY_TIMING_EXTENSION_NAME, + pattern VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE) + where +import GHC.Ptr (Ptr (..)) +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Types.Enum.VkResult +import Graphics.Vulkan.Types.Enum.VkStructureType +import Graphics.Vulkan.Types.Handles +import Graphics.Vulkan.Types.Struct.VkPastPresentationTimingGOOGLE +import Graphics.Vulkan.Types.Struct.VkPresentInfoKHR +import Graphics.Vulkan.Types.Struct.VkPresentTimeGOOGLE +import Graphics.Vulkan.Types.Struct.VkPresentTimesInfoGOOGLE +import Graphics.Vulkan.Types.Struct.VkRefreshCycleDurationGOOGLE + +-- | Success codes: 'VK_SUCCESS'. +-- +-- Error codes: 'VK_ERROR_DEVICE_LOST', 'VK_ERROR_SURFACE_LOST_KHR'. +-- +-- > VkResult vkGetRefreshCycleDurationGOOGLE +-- > ( VkDevice device +-- > , VkSwapchainKHR swapchain +-- > , VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties +-- > ) +-- +-- +foreign import ccall unsafe "vkGetRefreshCycleDurationGOOGLE" + vkGetRefreshCycleDurationGOOGLE :: + VkDevice -- ^ device + -> + VkSwapchainKHR -- ^ swapchain + -> Ptr VkRefreshCycleDurationGOOGLE -- ^ pDisplayTimingProperties + -> IO VkResult + +-- | Success codes: 'VK_SUCCESS', 'VK_INCOMPLETE'. +-- +-- Error codes: 'VK_ERROR_DEVICE_LOST', 'VK_ERROR_OUT_OF_DATE_KHR', 'VK_ERROR_SURFACE_LOST_KHR'. +-- +-- > VkResult vkGetPastPresentationTimingGOOGLE +-- > ( VkDevice device +-- > , VkSwapchainKHR swapchain +-- > , uint32_t* pPresentationTimingCount +-- > , VkPastPresentationTimingGOOGLE* pPresentationTimings +-- > ) +-- +-- +foreign import ccall unsafe "vkGetPastPresentationTimingGOOGLE" + vkGetPastPresentationTimingGOOGLE :: + VkDevice -- ^ device + -> + VkSwapchainKHR -- ^ swapchain + -> + Ptr Word32 -- ^ pPresentationTimingCount + -> Ptr VkPastPresentationTimingGOOGLE -- ^ pPresentationTimings + -> IO VkResult + +pattern VK_GOOGLE_DISPLAY_TIMING_SPEC_VERSION :: (Num a, Eq a) => a + +pattern VK_GOOGLE_DISPLAY_TIMING_SPEC_VERSION = 1 + +type VK_GOOGLE_DISPLAY_TIMING_SPEC_VERSION = 1 + +pattern VK_GOOGLE_DISPLAY_TIMING_EXTENSION_NAME :: CString + +pattern VK_GOOGLE_DISPLAY_TIMING_EXTENSION_NAME <- + (is_VK_GOOGLE_DISPLAY_TIMING_EXTENSION_NAME -> True) + where VK_GOOGLE_DISPLAY_TIMING_EXTENSION_NAME + = _VK_GOOGLE_DISPLAY_TIMING_EXTENSION_NAME + +{-# INLINE _VK_GOOGLE_DISPLAY_TIMING_EXTENSION_NAME #-} + +_VK_GOOGLE_DISPLAY_TIMING_EXTENSION_NAME :: CString +_VK_GOOGLE_DISPLAY_TIMING_EXTENSION_NAME + = Ptr "VK_GOOGLE_display_timing\NUL"# + +{-# INLINE is_VK_GOOGLE_DISPLAY_TIMING_EXTENSION_NAME #-} + +is_VK_GOOGLE_DISPLAY_TIMING_EXTENSION_NAME :: CString -> Bool +is_VK_GOOGLE_DISPLAY_TIMING_EXTENSION_NAME + = eqCStrings _VK_GOOGLE_DISPLAY_TIMING_EXTENSION_NAME + +type VK_GOOGLE_DISPLAY_TIMING_EXTENSION_NAME = + "VK_GOOGLE_display_timing" + +pattern VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE = + VkStructureType 1000092000 diff --git a/src-gen/Graphics/Vulkan/Ext/VK_IMG_filter_cubic.hs b/src-gen/Graphics/Vulkan/Ext/VK_IMG_filter_cubic.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Ext/VK_IMG_filter_cubic.hs @@ -0,0 +1,71 @@ +{-# OPTIONS_HADDOCK not-home#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE ViewPatterns #-} +module Graphics.Vulkan.Ext.VK_IMG_filter_cubic + (-- * Vulkan extension: @VK_IMG_filter_cubic@ + -- | + -- + -- supported: @vulkan@ + -- + -- contact: @Tobias Hector @tobias@ + -- + -- author: @IMG@ + -- + -- type: @device@ + -- + -- Extension number: @16@ + VK_IMG_FILTER_CUBIC_SPEC_VERSION, + pattern VK_IMG_FILTER_CUBIC_SPEC_VERSION, + VK_IMG_FILTER_CUBIC_EXTENSION_NAME, + pattern VK_IMG_FILTER_CUBIC_EXTENSION_NAME, + pattern VK_FILTER_CUBIC_IMG, + pattern VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG) + where +import GHC.Ptr (Ptr (..)) +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Types.Enum.VkFilter (VkFilter (..)) +import Graphics.Vulkan.Types.Enum.VkFormatFeatureFlags (VkFormatFeatureBitmask (..), + VkFormatFeatureFlagBits) + +pattern VK_IMG_FILTER_CUBIC_SPEC_VERSION :: (Num a, Eq a) => a + +pattern VK_IMG_FILTER_CUBIC_SPEC_VERSION = 1 + +type VK_IMG_FILTER_CUBIC_SPEC_VERSION = 1 + +pattern VK_IMG_FILTER_CUBIC_EXTENSION_NAME :: CString + +pattern VK_IMG_FILTER_CUBIC_EXTENSION_NAME <- + (is_VK_IMG_FILTER_CUBIC_EXTENSION_NAME -> True) + where VK_IMG_FILTER_CUBIC_EXTENSION_NAME + = _VK_IMG_FILTER_CUBIC_EXTENSION_NAME + +{-# INLINE _VK_IMG_FILTER_CUBIC_EXTENSION_NAME #-} + +_VK_IMG_FILTER_CUBIC_EXTENSION_NAME :: CString +_VK_IMG_FILTER_CUBIC_EXTENSION_NAME + = Ptr "VK_IMG_filter_cubic\NUL"# + +{-# INLINE is_VK_IMG_FILTER_CUBIC_EXTENSION_NAME #-} + +is_VK_IMG_FILTER_CUBIC_EXTENSION_NAME :: CString -> Bool +is_VK_IMG_FILTER_CUBIC_EXTENSION_NAME + = eqCStrings _VK_IMG_FILTER_CUBIC_EXTENSION_NAME + +type VK_IMG_FILTER_CUBIC_EXTENSION_NAME = "VK_IMG_filter_cubic" + +pattern VK_FILTER_CUBIC_IMG :: VkFilter + +pattern VK_FILTER_CUBIC_IMG = VkFilter 1000015000 + +-- | Format can be filtered with VK_FILTER_CUBIC_IMG when being sampled +-- +-- bitpos = @13@ +pattern VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG :: + VkFormatFeatureFlagBits + +pattern VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG = + VkFormatFeatureFlagBits 8192 diff --git a/src-gen/Graphics/Vulkan/Ext/VK_IMG_format_pvrtc.hs b/src-gen/Graphics/Vulkan/Ext/VK_IMG_format_pvrtc.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Ext/VK_IMG_format_pvrtc.hs @@ -0,0 +1,94 @@ +{-# OPTIONS_HADDOCK not-home#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE ViewPatterns #-} +module Graphics.Vulkan.Ext.VK_IMG_format_pvrtc + (-- * Vulkan extension: @VK_IMG_format_pvrtc@ + -- | + -- + -- supported: @vulkan@ + -- + -- contact: @Tobias Hector @tobias@ + -- + -- author: @IMG@ + -- + -- type: @device@ + -- + -- Extension number: @55@ + VK_IMG_FORMAT_PVRTC_SPEC_VERSION, + pattern VK_IMG_FORMAT_PVRTC_SPEC_VERSION, + VK_IMG_FORMAT_PVRTC_EXTENSION_NAME, + pattern VK_IMG_FORMAT_PVRTC_EXTENSION_NAME, + pattern VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG, + pattern VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG, + pattern VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG, + pattern VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG, + pattern VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG, + pattern VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG, + pattern VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG, + pattern VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG) + where +import GHC.Ptr (Ptr (..)) +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Types.Enum.VkFormat (VkFormat (..)) + +pattern VK_IMG_FORMAT_PVRTC_SPEC_VERSION :: (Num a, Eq a) => a + +pattern VK_IMG_FORMAT_PVRTC_SPEC_VERSION = 1 + +type VK_IMG_FORMAT_PVRTC_SPEC_VERSION = 1 + +pattern VK_IMG_FORMAT_PVRTC_EXTENSION_NAME :: CString + +pattern VK_IMG_FORMAT_PVRTC_EXTENSION_NAME <- + (is_VK_IMG_FORMAT_PVRTC_EXTENSION_NAME -> True) + where VK_IMG_FORMAT_PVRTC_EXTENSION_NAME + = _VK_IMG_FORMAT_PVRTC_EXTENSION_NAME + +{-# INLINE _VK_IMG_FORMAT_PVRTC_EXTENSION_NAME #-} + +_VK_IMG_FORMAT_PVRTC_EXTENSION_NAME :: CString +_VK_IMG_FORMAT_PVRTC_EXTENSION_NAME + = Ptr "VK_IMG_format_pvrtc\NUL"# + +{-# INLINE is_VK_IMG_FORMAT_PVRTC_EXTENSION_NAME #-} + +is_VK_IMG_FORMAT_PVRTC_EXTENSION_NAME :: CString -> Bool +is_VK_IMG_FORMAT_PVRTC_EXTENSION_NAME + = eqCStrings _VK_IMG_FORMAT_PVRTC_EXTENSION_NAME + +type VK_IMG_FORMAT_PVRTC_EXTENSION_NAME = "VK_IMG_format_pvrtc" + +pattern VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG :: VkFormat + +pattern VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG = VkFormat 1000054000 + +pattern VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG :: VkFormat + +pattern VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG = VkFormat 1000054001 + +pattern VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG :: VkFormat + +pattern VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG = VkFormat 1000054002 + +pattern VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG :: VkFormat + +pattern VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG = VkFormat 1000054003 + +pattern VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG :: VkFormat + +pattern VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG = VkFormat 1000054004 + +pattern VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG :: VkFormat + +pattern VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG = VkFormat 1000054005 + +pattern VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG :: VkFormat + +pattern VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG = VkFormat 1000054006 + +pattern VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG :: VkFormat + +pattern VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG = VkFormat 1000054007 diff --git a/src-gen/Graphics/Vulkan/Ext/VK_KHR_16bit_storage.hs b/src-gen/Graphics/Vulkan/Ext/VK_KHR_16bit_storage.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Ext/VK_KHR_16bit_storage.hs @@ -0,0 +1,84 @@ +{-# OPTIONS_HADDOCK not-home#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE ViewPatterns #-} +module Graphics.Vulkan.Ext.VK_KHR_16bit_storage + (-- * Vulkan extension: @VK_KHR_16bit_storage@ + -- | + -- + -- supported: @vulkan@ + -- + -- contact: @Jan-Harald Fredriksen @janharald@ + -- + -- author: @KHR@ + -- + -- type: @device@ + -- + -- Extension number: @84@ + -- + -- Required extensions: 'VK_KHR_get_physical_device_properties2', 'VK_KHR_storage_buffer_storage_class'. + -- + + -- ** Required extensions: 'VK_KHR_get_physical_device_properties2', 'VK_KHR_storage_buffer_storage_class'. + module Graphics.Vulkan.Marshal, + module Graphics.Vulkan.Types.BaseTypes, + module Graphics.Vulkan.Types.Bitmasks, + module Graphics.Vulkan.Types.Struct.VkDeviceCreateInfo, + module Graphics.Vulkan.Types.Struct.VkDeviceQueueCreateInfo, + module Graphics.Vulkan.Types.Struct.VkPhysicalDevice16BitStorageFeaturesKHR, + module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceFeatures, + module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceFeatures2KHR, + module Graphics.Vulkan.Types.Enum.VkStructureType, + -- > #include "vk_platform.h" + VK_KHR_16BIT_STORAGE_SPEC_VERSION, + pattern VK_KHR_16BIT_STORAGE_SPEC_VERSION, + VK_KHR_16BIT_STORAGE_EXTENSION_NAME, + pattern VK_KHR_16BIT_STORAGE_EXTENSION_NAME, + pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR) + where +import GHC.Ptr + (Ptr (..)) +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Types.BaseTypes +import Graphics.Vulkan.Types.Bitmasks +import Graphics.Vulkan.Types.Enum.VkStructureType +import Graphics.Vulkan.Types.Struct.VkDeviceCreateInfo +import Graphics.Vulkan.Types.Struct.VkDeviceQueueCreateInfo +import Graphics.Vulkan.Types.Struct.VkPhysicalDevice16BitStorageFeaturesKHR +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceFeatures +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceFeatures2KHR + +pattern VK_KHR_16BIT_STORAGE_SPEC_VERSION :: (Num a, Eq a) => a + +pattern VK_KHR_16BIT_STORAGE_SPEC_VERSION = 1 + +type VK_KHR_16BIT_STORAGE_SPEC_VERSION = 1 + +pattern VK_KHR_16BIT_STORAGE_EXTENSION_NAME :: CString + +pattern VK_KHR_16BIT_STORAGE_EXTENSION_NAME <- + (is_VK_KHR_16BIT_STORAGE_EXTENSION_NAME -> True) + where VK_KHR_16BIT_STORAGE_EXTENSION_NAME + = _VK_KHR_16BIT_STORAGE_EXTENSION_NAME + +{-# INLINE _VK_KHR_16BIT_STORAGE_EXTENSION_NAME #-} + +_VK_KHR_16BIT_STORAGE_EXTENSION_NAME :: CString +_VK_KHR_16BIT_STORAGE_EXTENSION_NAME + = Ptr "VK_KHR_16bit_storage\NUL"# + +{-# INLINE is_VK_KHR_16BIT_STORAGE_EXTENSION_NAME #-} + +is_VK_KHR_16BIT_STORAGE_EXTENSION_NAME :: CString -> Bool +is_VK_KHR_16BIT_STORAGE_EXTENSION_NAME + = eqCStrings _VK_KHR_16BIT_STORAGE_EXTENSION_NAME + +type VK_KHR_16BIT_STORAGE_EXTENSION_NAME = "VK_KHR_16bit_storage" + +pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR + :: VkStructureType + +pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR + = VkStructureType 1000083000 diff --git a/src-gen/Graphics/Vulkan/Ext/VK_KHR_android_surface.hs b/src-gen/Graphics/Vulkan/Ext/VK_KHR_android_surface.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Ext/VK_KHR_android_surface.hs @@ -0,0 +1,117 @@ +{-# OPTIONS_HADDOCK not-home#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE ForeignFunctionInterface #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE ViewPatterns #-} +module Graphics.Vulkan.Ext.VK_KHR_android_surface + (-- * Vulkan extension: @VK_KHR_android_surface@ + -- | + -- + -- supported: @vulkan@ + -- + -- contact: @Jesse Hall @jessehall@ + -- + -- author: @KHR@ + -- + -- type: @instance@ + -- + -- Extension number: @9@ + -- + -- Required extensions: 'VK_KHR_surface'. + -- + -- Protected by CPP ifdef: @VK_USE_PLATFORM_ANDROID_KHR@ + -- + + -- ** Required extensions: 'VK_KHR_surface'. + module Graphics.Vulkan.Types.Bitmasks, + module Graphics.Vulkan.Types.Struct.VkAndroidSurfaceCreateInfoKHR, + module Graphics.Vulkan.Types.BaseTypes, + module Graphics.Vulkan.Types.Enum.VkStructureType, + -- > #include "vk_platform.h" + -- + -- > #include + vkCreateAndroidSurfaceKHR, module Graphics.Vulkan.Marshal, + module Graphics.Vulkan.Types.Enum.VkInternalAllocationType, + module Graphics.Vulkan.Types.Enum.VkResult, + module Graphics.Vulkan.Types.Enum.VkSystemAllocationScope, + module Graphics.Vulkan.Types.Funcpointers, + module Graphics.Vulkan.Types.Handles, + module Graphics.Vulkan.Types.Include, + module Graphics.Vulkan.Types.Struct.VkAllocationCallbacks, + VK_KHR_ANDROID_SURFACE_SPEC_VERSION, + pattern VK_KHR_ANDROID_SURFACE_SPEC_VERSION, + VK_KHR_ANDROID_SURFACE_EXTENSION_NAME, + pattern VK_KHR_ANDROID_SURFACE_EXTENSION_NAME, + pattern VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR) + where +import GHC.Ptr (Ptr (..)) +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Types.BaseTypes +import Graphics.Vulkan.Types.Bitmasks +import Graphics.Vulkan.Types.Enum.VkInternalAllocationType +import Graphics.Vulkan.Types.Enum.VkResult +import Graphics.Vulkan.Types.Enum.VkStructureType +import Graphics.Vulkan.Types.Enum.VkSystemAllocationScope +import Graphics.Vulkan.Types.Funcpointers +import Graphics.Vulkan.Types.Handles +import Graphics.Vulkan.Types.Include +import Graphics.Vulkan.Types.Struct.VkAllocationCallbacks +import Graphics.Vulkan.Types.Struct.VkAndroidSurfaceCreateInfoKHR + +-- | Success codes: 'VK_SUCCESS'. +-- +-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_NATIVE_WINDOW_IN_USE_KHR'. +-- +-- > VkResult vkCreateAndroidSurfaceKHR +-- > ( VkInstance instance +-- > , const VkAndroidSurfaceCreateInfoKHR* pCreateInfo +-- > , const VkAllocationCallbacks* pAllocator +-- > , VkSurfaceKHR* pSurface +-- > ) +-- +-- +foreign import ccall unsafe "vkCreateAndroidSurfaceKHR" + vkCreateAndroidSurfaceKHR :: + VkInstance -- ^ instance + -> + Ptr VkAndroidSurfaceCreateInfoKHR -- ^ pCreateInfo + -> + Ptr VkAllocationCallbacks -- ^ pAllocator + -> Ptr VkSurfaceKHR -- ^ pSurface + -> IO VkResult + +pattern VK_KHR_ANDROID_SURFACE_SPEC_VERSION :: (Num a, Eq a) => a + +pattern VK_KHR_ANDROID_SURFACE_SPEC_VERSION = 6 + +type VK_KHR_ANDROID_SURFACE_SPEC_VERSION = 6 + +pattern VK_KHR_ANDROID_SURFACE_EXTENSION_NAME :: CString + +pattern VK_KHR_ANDROID_SURFACE_EXTENSION_NAME <- + (is_VK_KHR_ANDROID_SURFACE_EXTENSION_NAME -> True) + where VK_KHR_ANDROID_SURFACE_EXTENSION_NAME + = _VK_KHR_ANDROID_SURFACE_EXTENSION_NAME + +{-# INLINE _VK_KHR_ANDROID_SURFACE_EXTENSION_NAME #-} + +_VK_KHR_ANDROID_SURFACE_EXTENSION_NAME :: CString +_VK_KHR_ANDROID_SURFACE_EXTENSION_NAME + = Ptr "VK_KHR_android_surface\NUL"# + +{-# INLINE is_VK_KHR_ANDROID_SURFACE_EXTENSION_NAME #-} + +is_VK_KHR_ANDROID_SURFACE_EXTENSION_NAME :: CString -> Bool +is_VK_KHR_ANDROID_SURFACE_EXTENSION_NAME + = eqCStrings _VK_KHR_ANDROID_SURFACE_EXTENSION_NAME + +type VK_KHR_ANDROID_SURFACE_EXTENSION_NAME = + "VK_KHR_android_surface" + +pattern VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR = + VkStructureType 1000008000 diff --git a/src-gen/Graphics/Vulkan/Ext/VK_KHR_bind_memory2.hs b/src-gen/Graphics/Vulkan/Ext/VK_KHR_bind_memory2.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Ext/VK_KHR_bind_memory2.hs @@ -0,0 +1,127 @@ +{-# OPTIONS_HADDOCK not-home#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE ForeignFunctionInterface #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE ViewPatterns #-} +module Graphics.Vulkan.Ext.VK_KHR_bind_memory2 + (-- * Vulkan extension: @VK_KHR_bind_memory2@ + -- | + -- + -- supported: @vulkan@ + -- + -- contact: @Tobias Hector @tobias@ + -- + -- author: @KHR@ + -- + -- type: @device@ + -- + -- Extension number: @158@ + module Graphics.Vulkan.Types.Struct.VkBindBufferMemoryInfoKHR, + module Graphics.Vulkan.Types.Struct.VkBindImageMemoryInfoKHR, + module Graphics.Vulkan.Types.BaseTypes, + module Graphics.Vulkan.Types.Enum.VkStructureType, + -- > #include "vk_platform.h" + vkBindBufferMemory2KHR, vkBindImageMemory2KHR, + module Graphics.Vulkan.Marshal, + module Graphics.Vulkan.Types.Enum.VkResult, + module Graphics.Vulkan.Types.Handles, + VK_KHR_BIND_MEMORY_2_SPEC_VERSION, + pattern VK_KHR_BIND_MEMORY_2_SPEC_VERSION, + VK_KHR_BIND_MEMORY_2_EXTENSION_NAME, + pattern VK_KHR_BIND_MEMORY_2_EXTENSION_NAME, + pattern VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO_KHR, + pattern VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO_KHR, + pattern VK_IMAGE_CREATE_ALIAS_BIT_KHR) + where +import GHC.Ptr (Ptr (..)) +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Types.BaseTypes +import Graphics.Vulkan.Types.Enum.VkImageCreateFlags (VkImageCreateBitmask (..), + VkImageCreateFlagBits) +import Graphics.Vulkan.Types.Enum.VkResult +import Graphics.Vulkan.Types.Enum.VkStructureType +import Graphics.Vulkan.Types.Handles +import Graphics.Vulkan.Types.Struct.VkBindBufferMemoryInfoKHR +import Graphics.Vulkan.Types.Struct.VkBindImageMemoryInfoKHR + +-- | Success codes: 'VK_SUCCESS'. +-- +-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. +-- +-- > VkResult vkBindBufferMemory2KHR +-- > ( VkDevice device +-- > , uint32_t bindInfoCount +-- > , const VkBindBufferMemoryInfoKHR* pBindInfos +-- > ) +-- +-- +foreign import ccall unsafe "vkBindBufferMemory2KHR" + vkBindBufferMemory2KHR :: + VkDevice -- ^ device + -> Word32 -- ^ bindInfoCount + -> Ptr VkBindBufferMemoryInfoKHR -- ^ pBindInfos + -> IO VkResult + +-- | Success codes: 'VK_SUCCESS'. +-- +-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. +-- +-- > VkResult vkBindImageMemory2KHR +-- > ( VkDevice device +-- > , uint32_t bindInfoCount +-- > , const VkBindImageMemoryInfoKHR* pBindInfos +-- > ) +-- +-- +foreign import ccall unsafe "vkBindImageMemory2KHR" + vkBindImageMemory2KHR :: + VkDevice -- ^ device + -> Word32 -- ^ bindInfoCount + -> Ptr VkBindImageMemoryInfoKHR -- ^ pBindInfos + -> IO VkResult + +pattern VK_KHR_BIND_MEMORY_2_SPEC_VERSION :: (Num a, Eq a) => a + +pattern VK_KHR_BIND_MEMORY_2_SPEC_VERSION = 1 + +type VK_KHR_BIND_MEMORY_2_SPEC_VERSION = 1 + +pattern VK_KHR_BIND_MEMORY_2_EXTENSION_NAME :: CString + +pattern VK_KHR_BIND_MEMORY_2_EXTENSION_NAME <- + (is_VK_KHR_BIND_MEMORY_2_EXTENSION_NAME -> True) + where VK_KHR_BIND_MEMORY_2_EXTENSION_NAME + = _VK_KHR_BIND_MEMORY_2_EXTENSION_NAME + +{-# INLINE _VK_KHR_BIND_MEMORY_2_EXTENSION_NAME #-} + +_VK_KHR_BIND_MEMORY_2_EXTENSION_NAME :: CString +_VK_KHR_BIND_MEMORY_2_EXTENSION_NAME + = Ptr "VK_KHR_bind_memory2\NUL"# + +{-# INLINE is_VK_KHR_BIND_MEMORY_2_EXTENSION_NAME #-} + +is_VK_KHR_BIND_MEMORY_2_EXTENSION_NAME :: CString -> Bool +is_VK_KHR_BIND_MEMORY_2_EXTENSION_NAME + = eqCStrings _VK_KHR_BIND_MEMORY_2_EXTENSION_NAME + +type VK_KHR_BIND_MEMORY_2_EXTENSION_NAME = "VK_KHR_bind_memory2" + +pattern VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO_KHR :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO_KHR = + VkStructureType 1000157000 + +pattern VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO_KHR :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO_KHR = + VkStructureType 1000157001 + +-- | bitpos = @10@ +pattern VK_IMAGE_CREATE_ALIAS_BIT_KHR :: VkImageCreateFlagBits + +pattern VK_IMAGE_CREATE_ALIAS_BIT_KHR = VkImageCreateFlagBits 1024 diff --git a/src-gen/Graphics/Vulkan/Ext/VK_KHR_dedicated_allocation.hs b/src-gen/Graphics/Vulkan/Ext/VK_KHR_dedicated_allocation.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Ext/VK_KHR_dedicated_allocation.hs @@ -0,0 +1,89 @@ +{-# OPTIONS_HADDOCK not-home#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE ViewPatterns #-} +module Graphics.Vulkan.Ext.VK_KHR_dedicated_allocation + (-- * Vulkan extension: @VK_KHR_dedicated_allocation@ + -- | + -- + -- supported: @vulkan@ + -- + -- contact: @James Jones @cubanismo@ + -- + -- author: @KHR@ + -- + -- type: @device@ + -- + -- Extension number: @128@ + -- + -- Required extensions: 'VK_KHR_get_memory_requirements2'. + -- + + -- ** Required extensions: 'VK_KHR_get_memory_requirements2'. + module Graphics.Vulkan.Types.BaseTypes, + module Graphics.Vulkan.Types.Struct.VkMemoryAllocateInfo, + module Graphics.Vulkan.Types.Struct.VkMemoryDedicatedAllocateInfoKHR, + module Graphics.Vulkan.Types.Struct.VkMemoryDedicatedRequirementsKHR, + module Graphics.Vulkan.Types.Struct.VkMemoryRequirements, + module Graphics.Vulkan.Types.Struct.VkMemoryRequirements2KHR, + module Graphics.Vulkan.Types.Enum.VkStructureType, + -- > #include "vk_platform.h" + VK_KHR_DEDICATED_ALLOCATION_SPEC_VERSION, + pattern VK_KHR_DEDICATED_ALLOCATION_SPEC_VERSION, + VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME, + pattern VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME, + pattern VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR, + pattern VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR) + where +import GHC.Ptr (Ptr (..)) +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Types.BaseTypes +import Graphics.Vulkan.Types.Enum.VkStructureType +import Graphics.Vulkan.Types.Struct.VkMemoryAllocateInfo +import Graphics.Vulkan.Types.Struct.VkMemoryDedicatedAllocateInfoKHR +import Graphics.Vulkan.Types.Struct.VkMemoryDedicatedRequirementsKHR +import Graphics.Vulkan.Types.Struct.VkMemoryRequirements +import Graphics.Vulkan.Types.Struct.VkMemoryRequirements2KHR + +pattern VK_KHR_DEDICATED_ALLOCATION_SPEC_VERSION :: + (Num a, Eq a) => a + +pattern VK_KHR_DEDICATED_ALLOCATION_SPEC_VERSION = 3 + +type VK_KHR_DEDICATED_ALLOCATION_SPEC_VERSION = 3 + +pattern VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME :: CString + +pattern VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME <- + (is_VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME -> True) + where VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME + = _VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME + +{-# INLINE _VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME #-} + +_VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME :: CString +_VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME + = Ptr "VK_KHR_dedicated_allocation\NUL"# + +{-# INLINE is_VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME #-} + +is_VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME :: CString -> Bool +is_VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME + = eqCStrings _VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME + +type VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME = + "VK_KHR_dedicated_allocation" + +pattern VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR = + VkStructureType 1000127000 + +pattern VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR = + VkStructureType 1000127001 diff --git a/src-gen/Graphics/Vulkan/Ext/VK_KHR_descriptor_update_template.hs b/src-gen/Graphics/Vulkan/Ext/VK_KHR_descriptor_update_template.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Ext/VK_KHR_descriptor_update_template.hs @@ -0,0 +1,198 @@ +{-# OPTIONS_HADDOCK not-home#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE ForeignFunctionInterface #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE ViewPatterns #-} +module Graphics.Vulkan.Ext.VK_KHR_descriptor_update_template + (-- * Vulkan extension: @VK_KHR_descriptor_update_template@ + -- | + -- + -- supported: @vulkan@ + -- + -- contact: @Markus Tavenrath @mtavenrath@ + -- + -- author: @KHR@ + -- + -- type: @device@ + -- + -- Extension number: @86@ + module Graphics.Vulkan.Marshal, + module Graphics.Vulkan.Types.Enum.VkDescriptorType, + module Graphics.Vulkan.Types.Bitmasks, + module Graphics.Vulkan.Types.Struct.VkDescriptorUpdateTemplateCreateInfoKHR, + module Graphics.Vulkan.Types.Struct.VkDescriptorUpdateTemplateEntryKHR, + module Graphics.Vulkan.Types.Enum.VkDescriptorUpdateTemplateTypeKHR, + module Graphics.Vulkan.Types.BaseTypes, + module Graphics.Vulkan.Types.Enum.VkPipelineBindPoint, + module Graphics.Vulkan.Types.Enum.VkStructureType, + -- > #include "vk_platform.h" + vkCreateDescriptorUpdateTemplateKHR, + vkDestroyDescriptorUpdateTemplateKHR, + vkUpdateDescriptorSetWithTemplateKHR, + vkCmdPushDescriptorSetWithTemplateKHR, + module Graphics.Vulkan.Types.Enum.VkInternalAllocationType, + module Graphics.Vulkan.Types.Enum.VkResult, + module Graphics.Vulkan.Types.Enum.VkSystemAllocationScope, + module Graphics.Vulkan.Types.Funcpointers, + module Graphics.Vulkan.Types.Handles, + module Graphics.Vulkan.Types.Struct.VkAllocationCallbacks, + VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_SPEC_VERSION, + pattern VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_SPEC_VERSION, + VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_EXTENSION_NAME, + pattern VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_EXTENSION_NAME, + pattern VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR, + pattern VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR_EXT, + pattern VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR) + where +import GHC.Ptr + (Ptr (..)) +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Types.BaseTypes +import Graphics.Vulkan.Types.Bitmasks +import Graphics.Vulkan.Types.Enum.VkDebugReportObjectTypeEXT + (VkDebugReportObjectTypeEXT (..)) +import Graphics.Vulkan.Types.Enum.VkDescriptorType +import Graphics.Vulkan.Types.Enum.VkDescriptorUpdateTemplateTypeKHR +import Graphics.Vulkan.Types.Enum.VkInternalAllocationType +import Graphics.Vulkan.Types.Enum.VkObjectType + (VkObjectType (..)) +import Graphics.Vulkan.Types.Enum.VkPipelineBindPoint +import Graphics.Vulkan.Types.Enum.VkResult +import Graphics.Vulkan.Types.Enum.VkStructureType +import Graphics.Vulkan.Types.Enum.VkSystemAllocationScope +import Graphics.Vulkan.Types.Funcpointers +import Graphics.Vulkan.Types.Handles +import Graphics.Vulkan.Types.Struct.VkAllocationCallbacks +import Graphics.Vulkan.Types.Struct.VkDescriptorUpdateTemplateCreateInfoKHR +import Graphics.Vulkan.Types.Struct.VkDescriptorUpdateTemplateEntryKHR + +-- | Success codes: 'VK_SUCCESS'. +-- +-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. +-- +-- > VkResult vkCreateDescriptorUpdateTemplateKHR +-- > ( VkDevice device +-- > , const VkDescriptorUpdateTemplateCreateInfoKHR* pCreateInfo +-- > , const VkAllocationCallbacks* pAllocator +-- > , VkDescriptorUpdateTemplateKHR* pDescriptorUpdateTemplate +-- > ) +-- +-- +foreign import ccall unsafe "vkCreateDescriptorUpdateTemplateKHR" + vkCreateDescriptorUpdateTemplateKHR :: + VkDevice -- ^ device + -> + Ptr VkDescriptorUpdateTemplateCreateInfoKHR -- ^ pCreateInfo + -> + Ptr VkAllocationCallbacks -- ^ pAllocator + -> + Ptr VkDescriptorUpdateTemplateKHR -- ^ pDescriptorUpdateTemplate + -> IO VkResult + +-- | > () vkDestroyDescriptorUpdateTemplateKHR +-- > ( VkDevice device +-- > , VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate +-- > , const VkAllocationCallbacks* pAllocator +-- > ) +-- +-- +foreign import ccall unsafe "vkDestroyDescriptorUpdateTemplateKHR" + vkDestroyDescriptorUpdateTemplateKHR :: + VkDevice -- ^ device + -> + VkDescriptorUpdateTemplateKHR -- ^ descriptorUpdateTemplate + -> Ptr VkAllocationCallbacks -- ^ pAllocator + -> IO () + +-- | > () vkUpdateDescriptorSetWithTemplateKHR +-- > ( VkDevice device +-- > , VkDescriptorSet descriptorSet +-- > , VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate +-- > , const void* pData +-- > ) +-- +-- +foreign import ccall unsafe "vkUpdateDescriptorSetWithTemplateKHR" + vkUpdateDescriptorSetWithTemplateKHR :: + VkDevice -- ^ device + -> + VkDescriptorSet -- ^ descriptorSet + -> + VkDescriptorUpdateTemplateKHR -- ^ descriptorUpdateTemplate + -> Ptr Void -- ^ pData + -> IO () + +-- | queues: 'graphics', 'compute'. +-- +-- renderpass: @both@ +-- +-- > () vkCmdPushDescriptorSetWithTemplateKHR +-- > ( VkCommandBuffer commandBuffer +-- > , VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate +-- > , VkPipelineLayout layout +-- > , uint32_t set +-- > , const void* pData +-- > ) +-- +-- +foreign import ccall unsafe "vkCmdPushDescriptorSetWithTemplateKHR" + vkCmdPushDescriptorSetWithTemplateKHR :: + VkCommandBuffer -- ^ commandBuffer + -> + VkDescriptorUpdateTemplateKHR -- ^ descriptorUpdateTemplate + -> + VkPipelineLayout -- ^ layout + -> Word32 -- ^ set + -> Ptr Void -- ^ pData + -> IO () + +pattern VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_SPEC_VERSION :: + (Num a, Eq a) => a + +pattern VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_SPEC_VERSION = 1 + +type VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_SPEC_VERSION = 1 + +pattern VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_EXTENSION_NAME :: CString + +pattern VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_EXTENSION_NAME <- + (is_VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_EXTENSION_NAME -> True) + where VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_EXTENSION_NAME + = _VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_EXTENSION_NAME + +{-# INLINE _VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_EXTENSION_NAME #-} + +_VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_EXTENSION_NAME :: CString +_VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_EXTENSION_NAME + = Ptr "VK_KHR_descriptor_update_template\NUL"# + +{-# INLINE is_VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_EXTENSION_NAME #-} + +is_VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_EXTENSION_NAME :: + CString -> Bool +is_VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_EXTENSION_NAME + = eqCStrings _VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_EXTENSION_NAME + +type VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_EXTENSION_NAME = + "VK_KHR_descriptor_update_template" + +pattern VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR + :: VkStructureType + +pattern VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR + = VkStructureType 1000085000 + +pattern VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR_EXT + :: VkDebugReportObjectTypeEXT + +pattern VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR_EXT + = VkDebugReportObjectTypeEXT 1000085000 + +-- | VkDescriptorUpdateTemplateKHR +pattern VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR :: + VkObjectType + +pattern VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR = + VkObjectType 1000085000 diff --git a/src-gen/Graphics/Vulkan/Ext/VK_KHR_display.hs b/src-gen/Graphics/Vulkan/Ext/VK_KHR_display.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Ext/VK_KHR_display.hs @@ -0,0 +1,283 @@ +{-# OPTIONS_HADDOCK not-home#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE ForeignFunctionInterface #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE ViewPatterns #-} +module Graphics.Vulkan.Ext.VK_KHR_display + (-- * Vulkan extension: @VK_KHR_display@ + -- | + -- + -- supported: @vulkan@ + -- + -- contact: @James Jones @cubanismo,Norbert Nopper @FslNopper@ + -- + -- author: @KHR@ + -- + -- type: @instance@ + -- + -- Extension number: @3@ + -- + -- Required extensions: 'VK_KHR_surface'. + -- + + -- ** Required extensions: 'VK_KHR_surface'. + module Graphics.Vulkan.Marshal, + module Graphics.Vulkan.Types.BaseTypes, + module Graphics.Vulkan.Types.Bitmasks, + module Graphics.Vulkan.Types.Struct.VkDisplayModeCreateInfoKHR, + module Graphics.Vulkan.Types.Struct.VkDisplayModeParametersKHR, + module Graphics.Vulkan.Types.Struct.VkDisplayModePropertiesKHR, + module Graphics.Vulkan.Types.Enum.VkDisplayPlaneAlphaFlagsKHR, + module Graphics.Vulkan.Types.Struct.VkDisplayPlaneCapabilitiesKHR, + module Graphics.Vulkan.Types.Struct.VkDisplayPlanePropertiesKHR, + module Graphics.Vulkan.Types.Struct.VkDisplayPropertiesKHR, + module Graphics.Vulkan.Types.Struct.VkDisplaySurfaceCreateInfoKHR, + module Graphics.Vulkan.Types.Struct.VkExtent2D, + module Graphics.Vulkan.Types.Struct.VkOffset2D, + module Graphics.Vulkan.Types.Enum.VkStructureType, + module Graphics.Vulkan.Types.Enum.VkSurfaceTransformFlagsKHR, + -- > #include "vk_platform.h" + vkGetPhysicalDeviceDisplayPropertiesKHR, + vkGetPhysicalDeviceDisplayPlanePropertiesKHR, + vkGetDisplayPlaneSupportedDisplaysKHR, + vkGetDisplayModePropertiesKHR, vkCreateDisplayModeKHR, + vkGetDisplayPlaneCapabilitiesKHR, vkCreateDisplayPlaneSurfaceKHR, + module Graphics.Vulkan.Types.Enum.VkInternalAllocationType, + module Graphics.Vulkan.Types.Enum.VkResult, + module Graphics.Vulkan.Types.Enum.VkSystemAllocationScope, + module Graphics.Vulkan.Types.Funcpointers, + module Graphics.Vulkan.Types.Handles, + module Graphics.Vulkan.Types.Struct.VkAllocationCallbacks, + VK_KHR_DISPLAY_SPEC_VERSION, pattern VK_KHR_DISPLAY_SPEC_VERSION, + VK_KHR_DISPLAY_EXTENSION_NAME, + pattern VK_KHR_DISPLAY_EXTENSION_NAME, + pattern VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR, + pattern VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR, + pattern VK_OBJECT_TYPE_DISPLAY_KHR, + pattern VK_OBJECT_TYPE_DISPLAY_MODE_KHR) + where +import GHC.Ptr (Ptr (..)) +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Types.BaseTypes +import Graphics.Vulkan.Types.Bitmasks +import Graphics.Vulkan.Types.Enum.VkDisplayPlaneAlphaFlagsKHR +import Graphics.Vulkan.Types.Enum.VkInternalAllocationType +import Graphics.Vulkan.Types.Enum.VkObjectType (VkObjectType (..)) +import Graphics.Vulkan.Types.Enum.VkResult +import Graphics.Vulkan.Types.Enum.VkStructureType +import Graphics.Vulkan.Types.Enum.VkSurfaceTransformFlagsKHR +import Graphics.Vulkan.Types.Enum.VkSystemAllocationScope +import Graphics.Vulkan.Types.Funcpointers +import Graphics.Vulkan.Types.Handles +import Graphics.Vulkan.Types.Struct.VkAllocationCallbacks +import Graphics.Vulkan.Types.Struct.VkDisplayModeCreateInfoKHR +import Graphics.Vulkan.Types.Struct.VkDisplayModeParametersKHR +import Graphics.Vulkan.Types.Struct.VkDisplayModePropertiesKHR +import Graphics.Vulkan.Types.Struct.VkDisplayPlaneCapabilitiesKHR +import Graphics.Vulkan.Types.Struct.VkDisplayPlanePropertiesKHR +import Graphics.Vulkan.Types.Struct.VkDisplayPropertiesKHR +import Graphics.Vulkan.Types.Struct.VkDisplaySurfaceCreateInfoKHR +import Graphics.Vulkan.Types.Struct.VkExtent2D +import Graphics.Vulkan.Types.Struct.VkOffset2D + +-- | Success codes: 'VK_SUCCESS', 'VK_INCOMPLETE'. +-- +-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. +-- +-- > VkResult vkGetPhysicalDeviceDisplayPropertiesKHR +-- > ( VkPhysicalDevice physicalDevice +-- > , uint32_t* pPropertyCount +-- > , VkDisplayPropertiesKHR* pProperties +-- > ) +-- +-- +foreign import ccall unsafe + "vkGetPhysicalDeviceDisplayPropertiesKHR" + vkGetPhysicalDeviceDisplayPropertiesKHR :: + VkPhysicalDevice -- ^ physicalDevice + -> + Ptr Word32 -- ^ pPropertyCount + -> Ptr VkDisplayPropertiesKHR -- ^ pProperties + -> IO VkResult + +-- | Success codes: 'VK_SUCCESS', 'VK_INCOMPLETE'. +-- +-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. +-- +-- > VkResult vkGetPhysicalDeviceDisplayPlanePropertiesKHR +-- > ( VkPhysicalDevice physicalDevice +-- > , uint32_t* pPropertyCount +-- > , VkDisplayPlanePropertiesKHR* pProperties +-- > ) +-- +-- +foreign import ccall unsafe + "vkGetPhysicalDeviceDisplayPlanePropertiesKHR" + vkGetPhysicalDeviceDisplayPlanePropertiesKHR :: + VkPhysicalDevice -- ^ physicalDevice + -> + Ptr Word32 -- ^ pPropertyCount + -> Ptr VkDisplayPlanePropertiesKHR -- ^ pProperties + -> IO VkResult + +-- | Success codes: 'VK_SUCCESS', 'VK_INCOMPLETE'. +-- +-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. +-- +-- > VkResult vkGetDisplayPlaneSupportedDisplaysKHR +-- > ( VkPhysicalDevice physicalDevice +-- > , uint32_t planeIndex +-- > , uint32_t* pDisplayCount +-- > , VkDisplayKHR* pDisplays +-- > ) +-- +-- +foreign import ccall unsafe "vkGetDisplayPlaneSupportedDisplaysKHR" + vkGetDisplayPlaneSupportedDisplaysKHR :: + VkPhysicalDevice -- ^ physicalDevice + -> + Word32 -- ^ planeIndex + -> Ptr Word32 -- ^ pDisplayCount + -> Ptr VkDisplayKHR -- ^ pDisplays + -> IO VkResult + +-- | Success codes: 'VK_SUCCESS', 'VK_INCOMPLETE'. +-- +-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. +-- +-- > VkResult vkGetDisplayModePropertiesKHR +-- > ( VkPhysicalDevice physicalDevice +-- > , VkDisplayKHR display +-- > , uint32_t* pPropertyCount +-- > , VkDisplayModePropertiesKHR* pProperties +-- > ) +-- +-- +foreign import ccall unsafe "vkGetDisplayModePropertiesKHR" + vkGetDisplayModePropertiesKHR :: + VkPhysicalDevice -- ^ physicalDevice + -> + VkDisplayKHR -- ^ display + -> + Ptr Word32 -- ^ pPropertyCount + -> Ptr VkDisplayModePropertiesKHR -- ^ pProperties + -> IO VkResult + +-- | Success codes: 'VK_SUCCESS'. +-- +-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_INITIALIZATION_FAILED'. +-- +-- > VkResult vkCreateDisplayModeKHR +-- > ( VkPhysicalDevice physicalDevice +-- > , VkDisplayKHR display +-- > , const VkDisplayModeCreateInfoKHR* pCreateInfo +-- > , const VkAllocationCallbacks* pAllocator +-- > , VkDisplayModeKHR* pMode +-- > ) +-- +-- +foreign import ccall unsafe "vkCreateDisplayModeKHR" + vkCreateDisplayModeKHR :: + VkPhysicalDevice -- ^ physicalDevice + -> + VkDisplayKHR -- ^ display + -> + Ptr VkDisplayModeCreateInfoKHR -- ^ pCreateInfo + -> + Ptr VkAllocationCallbacks -- ^ pAllocator + -> Ptr VkDisplayModeKHR -- ^ pMode + -> IO VkResult + +-- | Success codes: 'VK_SUCCESS'. +-- +-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. +-- +-- > VkResult vkGetDisplayPlaneCapabilitiesKHR +-- > ( VkPhysicalDevice physicalDevice +-- > , VkDisplayModeKHR mode +-- > , uint32_t planeIndex +-- > , VkDisplayPlaneCapabilitiesKHR* pCapabilities +-- > ) +-- +-- +foreign import ccall unsafe "vkGetDisplayPlaneCapabilitiesKHR" + vkGetDisplayPlaneCapabilitiesKHR :: + VkPhysicalDevice -- ^ physicalDevice + -> + VkDisplayModeKHR -- ^ mode + -> + Word32 -- ^ planeIndex + -> Ptr VkDisplayPlaneCapabilitiesKHR -- ^ pCapabilities + -> IO VkResult + +-- | Success codes: 'VK_SUCCESS'. +-- +-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. +-- +-- > VkResult vkCreateDisplayPlaneSurfaceKHR +-- > ( VkInstance instance +-- > , const VkDisplaySurfaceCreateInfoKHR* pCreateInfo +-- > , const VkAllocationCallbacks* pAllocator +-- > , VkSurfaceKHR* pSurface +-- > ) +-- +-- +foreign import ccall unsafe "vkCreateDisplayPlaneSurfaceKHR" + vkCreateDisplayPlaneSurfaceKHR :: + VkInstance -- ^ instance + -> + Ptr VkDisplaySurfaceCreateInfoKHR -- ^ pCreateInfo + -> + Ptr VkAllocationCallbacks -- ^ pAllocator + -> Ptr VkSurfaceKHR -- ^ pSurface + -> IO VkResult + +pattern VK_KHR_DISPLAY_SPEC_VERSION :: (Num a, Eq a) => a + +pattern VK_KHR_DISPLAY_SPEC_VERSION = 21 + +type VK_KHR_DISPLAY_SPEC_VERSION = 21 + +pattern VK_KHR_DISPLAY_EXTENSION_NAME :: CString + +pattern VK_KHR_DISPLAY_EXTENSION_NAME <- + (is_VK_KHR_DISPLAY_EXTENSION_NAME -> True) + where VK_KHR_DISPLAY_EXTENSION_NAME + = _VK_KHR_DISPLAY_EXTENSION_NAME + +{-# INLINE _VK_KHR_DISPLAY_EXTENSION_NAME #-} + +_VK_KHR_DISPLAY_EXTENSION_NAME :: CString +_VK_KHR_DISPLAY_EXTENSION_NAME = Ptr "VK_KHR_display\NUL"# + +{-# INLINE is_VK_KHR_DISPLAY_EXTENSION_NAME #-} + +is_VK_KHR_DISPLAY_EXTENSION_NAME :: CString -> Bool +is_VK_KHR_DISPLAY_EXTENSION_NAME + = eqCStrings _VK_KHR_DISPLAY_EXTENSION_NAME + +type VK_KHR_DISPLAY_EXTENSION_NAME = "VK_KHR_display" + +pattern VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR = + VkStructureType 1000002000 + +pattern VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR = + VkStructureType 1000002001 + +-- | VkDisplayKHR +pattern VK_OBJECT_TYPE_DISPLAY_KHR :: VkObjectType + +pattern VK_OBJECT_TYPE_DISPLAY_KHR = VkObjectType 1000002000 + +-- | VkDisplayModeKHR +pattern VK_OBJECT_TYPE_DISPLAY_MODE_KHR :: VkObjectType + +pattern VK_OBJECT_TYPE_DISPLAY_MODE_KHR = VkObjectType 1000002001 diff --git a/src-gen/Graphics/Vulkan/Ext/VK_KHR_display_swapchain.hs b/src-gen/Graphics/Vulkan/Ext/VK_KHR_display_swapchain.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Ext/VK_KHR_display_swapchain.hs @@ -0,0 +1,143 @@ +{-# OPTIONS_HADDOCK not-home#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE ForeignFunctionInterface #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE ViewPatterns #-} +module Graphics.Vulkan.Ext.VK_KHR_display_swapchain + (-- * Vulkan extension: @VK_KHR_display_swapchain@ + -- | + -- + -- supported: @vulkan@ + -- + -- contact: @James Jones @cubanismo@ + -- + -- author: @KHR@ + -- + -- type: @device@ + -- + -- Extension number: @4@ + -- + -- Required extensions: 'VK_KHR_swapchain', 'VK_KHR_display'. + -- + + -- ** Required extensions: 'VK_KHR_swapchain', 'VK_KHR_display'. + module Graphics.Vulkan.Types.BaseTypes, + module Graphics.Vulkan.Types.Struct.VkDisplayPresentInfoKHR, + module Graphics.Vulkan.Types.Struct.VkExtent2D, + module Graphics.Vulkan.Types.Struct.VkOffset2D, + module Graphics.Vulkan.Types.Struct.VkPresentInfoKHR, + module Graphics.Vulkan.Types.Struct.VkRect2D, + module Graphics.Vulkan.Types.Enum.VkResult, + module Graphics.Vulkan.Types.Enum.VkStructureType, + -- > #include "vk_platform.h" + vkCreateSharedSwapchainsKHR, module Graphics.Vulkan.Marshal, + module Graphics.Vulkan.Types.Enum.VkColorSpaceKHR, + module Graphics.Vulkan.Types.Enum.VkCompositeAlphaFlagsKHR, + module Graphics.Vulkan.Types.Enum.VkFormat, + module Graphics.Vulkan.Types.Enum.VkImageUsageFlags, + module Graphics.Vulkan.Types.Enum.VkInternalAllocationType, + module Graphics.Vulkan.Types.Enum.VkPresentModeKHR, + module Graphics.Vulkan.Types.Enum.VkSharingMode, + module Graphics.Vulkan.Types.Enum.VkSurfaceTransformFlagsKHR, + module Graphics.Vulkan.Types.Enum.VkSwapchainCreateFlagsKHR, + module Graphics.Vulkan.Types.Enum.VkSystemAllocationScope, + module Graphics.Vulkan.Types.Funcpointers, + module Graphics.Vulkan.Types.Handles, + module Graphics.Vulkan.Types.Struct.VkAllocationCallbacks, + module Graphics.Vulkan.Types.Struct.VkSwapchainCreateInfoKHR, + VK_KHR_DISPLAY_SWAPCHAIN_SPEC_VERSION, + pattern VK_KHR_DISPLAY_SWAPCHAIN_SPEC_VERSION, + VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME, + pattern VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME, + pattern VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR, + pattern VK_ERROR_INCOMPATIBLE_DISPLAY_KHR) + where +import GHC.Ptr (Ptr (..)) +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Types.BaseTypes +import Graphics.Vulkan.Types.Enum.VkColorSpaceKHR +import Graphics.Vulkan.Types.Enum.VkCompositeAlphaFlagsKHR +import Graphics.Vulkan.Types.Enum.VkFormat +import Graphics.Vulkan.Types.Enum.VkImageUsageFlags +import Graphics.Vulkan.Types.Enum.VkInternalAllocationType +import Graphics.Vulkan.Types.Enum.VkPresentModeKHR +import Graphics.Vulkan.Types.Enum.VkResult +import Graphics.Vulkan.Types.Enum.VkSharingMode +import Graphics.Vulkan.Types.Enum.VkStructureType +import Graphics.Vulkan.Types.Enum.VkSurfaceTransformFlagsKHR +import Graphics.Vulkan.Types.Enum.VkSwapchainCreateFlagsKHR +import Graphics.Vulkan.Types.Enum.VkSystemAllocationScope +import Graphics.Vulkan.Types.Funcpointers +import Graphics.Vulkan.Types.Handles +import Graphics.Vulkan.Types.Struct.VkAllocationCallbacks +import Graphics.Vulkan.Types.Struct.VkDisplayPresentInfoKHR +import Graphics.Vulkan.Types.Struct.VkExtent2D +import Graphics.Vulkan.Types.Struct.VkOffset2D +import Graphics.Vulkan.Types.Struct.VkPresentInfoKHR +import Graphics.Vulkan.Types.Struct.VkRect2D +import Graphics.Vulkan.Types.Struct.VkSwapchainCreateInfoKHR + +-- | Success codes: 'VK_SUCCESS'. +-- +-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_INCOMPATIBLE_DISPLAY_KHR', 'VK_ERROR_DEVICE_LOST', 'VK_ERROR_SURFACE_LOST_KHR'. +-- +-- > VkResult vkCreateSharedSwapchainsKHR +-- > ( VkDevice device +-- > , uint32_t swapchainCount +-- > , const VkSwapchainCreateInfoKHR* pCreateInfos +-- > , const VkAllocationCallbacks* pAllocator +-- > , VkSwapchainKHR* pSwapchains +-- > ) +-- +-- +foreign import ccall unsafe "vkCreateSharedSwapchainsKHR" + vkCreateSharedSwapchainsKHR :: + VkDevice -- ^ device + -> + Word32 -- ^ swapchainCount + -> + Ptr VkSwapchainCreateInfoKHR -- ^ pCreateInfos + -> + Ptr VkAllocationCallbacks -- ^ pAllocator + -> Ptr VkSwapchainKHR -- ^ pSwapchains + -> IO VkResult + +pattern VK_KHR_DISPLAY_SWAPCHAIN_SPEC_VERSION :: (Num a, Eq a) => a + +pattern VK_KHR_DISPLAY_SWAPCHAIN_SPEC_VERSION = 9 + +type VK_KHR_DISPLAY_SWAPCHAIN_SPEC_VERSION = 9 + +pattern VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME :: CString + +pattern VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME <- + (is_VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME -> True) + where VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME + = _VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME + +{-# INLINE _VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME #-} + +_VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME :: CString +_VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME + = Ptr "VK_KHR_display_swapchain\NUL"# + +{-# INLINE is_VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME #-} + +is_VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME :: CString -> Bool +is_VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME + = eqCStrings _VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME + +type VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME = + "VK_KHR_display_swapchain" + +pattern VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR = + VkStructureType 1000003000 + +pattern VK_ERROR_INCOMPATIBLE_DISPLAY_KHR :: VkResult + +pattern VK_ERROR_INCOMPATIBLE_DISPLAY_KHR = VkResult (-1000003001) diff --git a/src-gen/Graphics/Vulkan/Ext/VK_KHR_external_fence.hs b/src-gen/Graphics/Vulkan/Ext/VK_KHR_external_fence.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Ext/VK_KHR_external_fence.hs @@ -0,0 +1,80 @@ +{-# OPTIONS_HADDOCK not-home#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE ViewPatterns #-} +module Graphics.Vulkan.Ext.VK_KHR_external_fence + (-- * Vulkan extension: @VK_KHR_external_fence@ + -- | + -- + -- supported: @vulkan@ + -- + -- contact: @Jesse Hall @jessehall@ + -- + -- author: @KHR@ + -- + -- type: @device@ + -- + -- Extension number: @114@ + -- + -- Required extensions: 'VK_KHR_external_fence_capabilities'. + -- + + -- ** Required extensions: 'VK_KHR_external_fence_capabilities'. + module Graphics.Vulkan.Types.Struct.VkExportFenceCreateInfoKHR, + module Graphics.Vulkan.Types.Enum.VkExternalFenceHandleTypeFlagsKHR, + module Graphics.Vulkan.Types.Enum.VkFenceCreateFlags, + module Graphics.Vulkan.Types.Struct.VkFenceCreateInfo, + module Graphics.Vulkan.Types.Enum.VkFenceImportFlagsKHR, + module Graphics.Vulkan.Types.BaseTypes, + module Graphics.Vulkan.Types.Enum.VkStructureType, + -- > #include "vk_platform.h" + VK_KHR_EXTERNAL_FENCE_SPEC_VERSION, + pattern VK_KHR_EXTERNAL_FENCE_SPEC_VERSION, + VK_KHR_EXTERNAL_FENCE_EXTENSION_NAME, + pattern VK_KHR_EXTERNAL_FENCE_EXTENSION_NAME, + pattern VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO_KHR) + where +import GHC.Ptr (Ptr (..)) +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Types.BaseTypes +import Graphics.Vulkan.Types.Enum.VkExternalFenceHandleTypeFlagsKHR +import Graphics.Vulkan.Types.Enum.VkFenceCreateFlags +import Graphics.Vulkan.Types.Enum.VkFenceImportFlagsKHR +import Graphics.Vulkan.Types.Enum.VkStructureType +import Graphics.Vulkan.Types.Struct.VkExportFenceCreateInfoKHR +import Graphics.Vulkan.Types.Struct.VkFenceCreateInfo + +pattern VK_KHR_EXTERNAL_FENCE_SPEC_VERSION :: (Num a, Eq a) => a + +pattern VK_KHR_EXTERNAL_FENCE_SPEC_VERSION = 1 + +type VK_KHR_EXTERNAL_FENCE_SPEC_VERSION = 1 + +pattern VK_KHR_EXTERNAL_FENCE_EXTENSION_NAME :: CString + +pattern VK_KHR_EXTERNAL_FENCE_EXTENSION_NAME <- + (is_VK_KHR_EXTERNAL_FENCE_EXTENSION_NAME -> True) + where VK_KHR_EXTERNAL_FENCE_EXTENSION_NAME + = _VK_KHR_EXTERNAL_FENCE_EXTENSION_NAME + +{-# INLINE _VK_KHR_EXTERNAL_FENCE_EXTENSION_NAME #-} + +_VK_KHR_EXTERNAL_FENCE_EXTENSION_NAME :: CString +_VK_KHR_EXTERNAL_FENCE_EXTENSION_NAME + = Ptr "VK_KHR_external_fence\NUL"# + +{-# INLINE is_VK_KHR_EXTERNAL_FENCE_EXTENSION_NAME #-} + +is_VK_KHR_EXTERNAL_FENCE_EXTENSION_NAME :: CString -> Bool +is_VK_KHR_EXTERNAL_FENCE_EXTENSION_NAME + = eqCStrings _VK_KHR_EXTERNAL_FENCE_EXTENSION_NAME + +type VK_KHR_EXTERNAL_FENCE_EXTENSION_NAME = "VK_KHR_external_fence" + +pattern VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO_KHR :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO_KHR = + VkStructureType 1000113000 diff --git a/src-gen/Graphics/Vulkan/Ext/VK_KHR_external_fence_capabilities.hs b/src-gen/Graphics/Vulkan/Ext/VK_KHR_external_fence_capabilities.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Ext/VK_KHR_external_fence_capabilities.hs @@ -0,0 +1,130 @@ +{-# OPTIONS_HADDOCK not-home#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE ForeignFunctionInterface #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE ViewPatterns #-} +module Graphics.Vulkan.Ext.VK_KHR_external_fence_capabilities + (-- * Vulkan extension: @VK_KHR_external_fence_capabilities@ + -- | + -- + -- supported: @vulkan@ + -- + -- contact: @Jesse Hall @jessehall@ + -- + -- author: @KHR@ + -- + -- type: @instance@ + -- + -- Extension number: @113@ + -- + -- Required extensions: 'VK_KHR_get_physical_device_properties2'. + -- + + -- ** Required extensions: 'VK_KHR_get_physical_device_properties2'. + module Graphics.Vulkan.Marshal, + module Graphics.Vulkan.Types.BaseTypes, + module Graphics.Vulkan.Types.Enum.VkExternalFenceFeatureFlagsKHR, + module Graphics.Vulkan.Types.Enum.VkExternalFenceHandleTypeFlagsKHR, + module Graphics.Vulkan.Types.Struct.VkExternalFencePropertiesKHR, + module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceExternalFenceInfoKHR, + module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceIDPropertiesKHR, + module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceLimits, + module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceProperties, + module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceProperties2KHR, + module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceSparseProperties, + module Graphics.Vulkan.Types.Enum.VkPhysicalDeviceType, + module Graphics.Vulkan.Types.Enum.VkSampleCountFlags, + module Graphics.Vulkan.Types.Enum.VkStructureType, + -- > #include "vk_platform.h" + vkGetPhysicalDeviceExternalFencePropertiesKHR, + module Graphics.Vulkan.Types.Handles, + VK_KHR_EXTERNAL_FENCE_CAPABILITIES_SPEC_VERSION, + pattern VK_KHR_EXTERNAL_FENCE_CAPABILITIES_SPEC_VERSION, + VK_KHR_EXTERNAL_FENCE_CAPABILITIES_EXTENSION_NAME, + pattern VK_KHR_EXTERNAL_FENCE_CAPABILITIES_EXTENSION_NAME, + pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO_KHR, + pattern VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES_KHR, + pattern VK_LUID_SIZE_KHR, VK_LUID_SIZE_KHR) + where +import GHC.Ptr + (Ptr (..)) +import Graphics.Vulkan.Constants + (VK_LUID_SIZE_KHR, + pattern VK_LUID_SIZE_KHR) +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Types.BaseTypes +import Graphics.Vulkan.Types.Enum.VkExternalFenceFeatureFlagsKHR +import Graphics.Vulkan.Types.Enum.VkExternalFenceHandleTypeFlagsKHR +import Graphics.Vulkan.Types.Enum.VkPhysicalDeviceType +import Graphics.Vulkan.Types.Enum.VkSampleCountFlags +import Graphics.Vulkan.Types.Enum.VkStructureType +import Graphics.Vulkan.Types.Handles +import Graphics.Vulkan.Types.Struct.VkExternalFencePropertiesKHR +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceExternalFenceInfoKHR +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceIDPropertiesKHR +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceLimits +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceProperties +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceProperties2KHR +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceSparseProperties + +-- | > () vkGetPhysicalDeviceExternalFencePropertiesKHR +-- > ( VkPhysicalDevice physicalDevice +-- > , const VkPhysicalDeviceExternalFenceInfoKHR* pExternalFenceInfo +-- > , VkExternalFencePropertiesKHR* pExternalFenceProperties +-- > ) +-- +-- +foreign import ccall unsafe + "vkGetPhysicalDeviceExternalFencePropertiesKHR" + vkGetPhysicalDeviceExternalFencePropertiesKHR :: + VkPhysicalDevice -- ^ physicalDevice + -> + Ptr VkPhysicalDeviceExternalFenceInfoKHR -- ^ pExternalFenceInfo + -> + Ptr VkExternalFencePropertiesKHR -- ^ pExternalFenceProperties + -> IO () + +pattern VK_KHR_EXTERNAL_FENCE_CAPABILITIES_SPEC_VERSION :: + (Num a, Eq a) => a + +pattern VK_KHR_EXTERNAL_FENCE_CAPABILITIES_SPEC_VERSION = 1 + +type VK_KHR_EXTERNAL_FENCE_CAPABILITIES_SPEC_VERSION = 1 + +pattern VK_KHR_EXTERNAL_FENCE_CAPABILITIES_EXTENSION_NAME :: + CString + +pattern VK_KHR_EXTERNAL_FENCE_CAPABILITIES_EXTENSION_NAME <- + (is_VK_KHR_EXTERNAL_FENCE_CAPABILITIES_EXTENSION_NAME -> True) + where VK_KHR_EXTERNAL_FENCE_CAPABILITIES_EXTENSION_NAME + = _VK_KHR_EXTERNAL_FENCE_CAPABILITIES_EXTENSION_NAME + +{-# INLINE _VK_KHR_EXTERNAL_FENCE_CAPABILITIES_EXTENSION_NAME #-} + +_VK_KHR_EXTERNAL_FENCE_CAPABILITIES_EXTENSION_NAME :: CString +_VK_KHR_EXTERNAL_FENCE_CAPABILITIES_EXTENSION_NAME + = Ptr "VK_KHR_external_fence_capabilities\NUL"# + +{-# INLINE is_VK_KHR_EXTERNAL_FENCE_CAPABILITIES_EXTENSION_NAME #-} + +is_VK_KHR_EXTERNAL_FENCE_CAPABILITIES_EXTENSION_NAME :: + CString -> Bool +is_VK_KHR_EXTERNAL_FENCE_CAPABILITIES_EXTENSION_NAME + = eqCStrings _VK_KHR_EXTERNAL_FENCE_CAPABILITIES_EXTENSION_NAME + +type VK_KHR_EXTERNAL_FENCE_CAPABILITIES_EXTENSION_NAME = + "VK_KHR_external_fence_capabilities" + +pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO_KHR + :: VkStructureType + +pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO_KHR = + VkStructureType 1000112000 + +pattern VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES_KHR :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES_KHR = + VkStructureType 1000112001 diff --git a/src-gen/Graphics/Vulkan/Ext/VK_KHR_external_fence_fd.hs b/src-gen/Graphics/Vulkan/Ext/VK_KHR_external_fence_fd.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Ext/VK_KHR_external_fence_fd.hs @@ -0,0 +1,124 @@ +{-# OPTIONS_HADDOCK not-home#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE ForeignFunctionInterface #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE ViewPatterns #-} +module Graphics.Vulkan.Ext.VK_KHR_external_fence_fd + (-- * Vulkan extension: @VK_KHR_external_fence_fd@ + -- | + -- + -- supported: @vulkan@ + -- + -- contact: @Jesse Hall @jessehall@ + -- + -- author: @KHR@ + -- + -- type: @device@ + -- + -- Extension number: @116@ + -- + -- Required extensions: 'VK_KHR_external_fence'. + -- + + -- ** Required extensions: 'VK_KHR_external_fence'. + module Graphics.Vulkan.Marshal, + module Graphics.Vulkan.Types.Enum.VkExternalFenceHandleTypeFlagsKHR, + module Graphics.Vulkan.Types.Struct.VkFenceGetFdInfoKHR, + module Graphics.Vulkan.Types.Enum.VkFenceImportFlagsKHR, + module Graphics.Vulkan.Types.BaseTypes, + module Graphics.Vulkan.Types.Struct.VkImportFenceFdInfoKHR, + module Graphics.Vulkan.Types.Enum.VkStructureType, + -- > #include "vk_platform.h" + vkImportFenceFdKHR, vkGetFenceFdKHR, + module Graphics.Vulkan.Types.Enum.VkResult, + module Graphics.Vulkan.Types.Handles, + VK_KHR_EXTERNAL_FENCE_FD_SPEC_VERSION, + pattern VK_KHR_EXTERNAL_FENCE_FD_SPEC_VERSION, + VK_KHR_EXTERNAL_FENCE_FD_EXTENSION_NAME, + pattern VK_KHR_EXTERNAL_FENCE_FD_EXTENSION_NAME, + pattern VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR, + pattern VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR) + where +import GHC.Ptr (Ptr (..)) +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Types.BaseTypes +import Graphics.Vulkan.Types.Enum.VkExternalFenceHandleTypeFlagsKHR +import Graphics.Vulkan.Types.Enum.VkFenceImportFlagsKHR +import Graphics.Vulkan.Types.Enum.VkResult +import Graphics.Vulkan.Types.Enum.VkStructureType +import Graphics.Vulkan.Types.Handles +import Graphics.Vulkan.Types.Struct.VkFenceGetFdInfoKHR +import Graphics.Vulkan.Types.Struct.VkImportFenceFdInfoKHR + +-- | Success codes: 'VK_SUCCESS'. +-- +-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR'. +-- +-- > VkResult vkImportFenceFdKHR +-- > ( VkDevice device +-- > , const VkImportFenceFdInfoKHR* pImportFenceFdInfo +-- > ) +-- +-- +foreign import ccall unsafe "vkImportFenceFdKHR" vkImportFenceFdKHR + :: VkDevice -- ^ device + -> Ptr VkImportFenceFdInfoKHR -- ^ pImportFenceFdInfo + -> IO VkResult + +-- | Success codes: 'VK_SUCCESS'. +-- +-- Error codes: 'VK_ERROR_TOO_MANY_OBJECTS', 'VK_ERROR_OUT_OF_HOST_MEMORY'. +-- +-- > VkResult vkGetFenceFdKHR +-- > ( VkDevice device +-- > , const VkFenceGetFdInfoKHR* pGetFdInfo +-- > , int* pFd +-- > ) +-- +-- +foreign import ccall unsafe "vkGetFenceFdKHR" vkGetFenceFdKHR :: + VkDevice -- ^ device + -> Ptr VkFenceGetFdInfoKHR -- ^ pGetFdInfo + -> Ptr CInt -- ^ pFd + -> IO VkResult + +pattern VK_KHR_EXTERNAL_FENCE_FD_SPEC_VERSION :: (Num a, Eq a) => a + +pattern VK_KHR_EXTERNAL_FENCE_FD_SPEC_VERSION = 1 + +type VK_KHR_EXTERNAL_FENCE_FD_SPEC_VERSION = 1 + +pattern VK_KHR_EXTERNAL_FENCE_FD_EXTENSION_NAME :: CString + +pattern VK_KHR_EXTERNAL_FENCE_FD_EXTENSION_NAME <- + (is_VK_KHR_EXTERNAL_FENCE_FD_EXTENSION_NAME -> True) + where VK_KHR_EXTERNAL_FENCE_FD_EXTENSION_NAME + = _VK_KHR_EXTERNAL_FENCE_FD_EXTENSION_NAME + +{-# INLINE _VK_KHR_EXTERNAL_FENCE_FD_EXTENSION_NAME #-} + +_VK_KHR_EXTERNAL_FENCE_FD_EXTENSION_NAME :: CString +_VK_KHR_EXTERNAL_FENCE_FD_EXTENSION_NAME + = Ptr "VK_KHR_external_fence_fd\NUL"# + +{-# INLINE is_VK_KHR_EXTERNAL_FENCE_FD_EXTENSION_NAME #-} + +is_VK_KHR_EXTERNAL_FENCE_FD_EXTENSION_NAME :: CString -> Bool +is_VK_KHR_EXTERNAL_FENCE_FD_EXTENSION_NAME + = eqCStrings _VK_KHR_EXTERNAL_FENCE_FD_EXTENSION_NAME + +type VK_KHR_EXTERNAL_FENCE_FD_EXTENSION_NAME = + "VK_KHR_external_fence_fd" + +pattern VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR = + VkStructureType 1000115000 + +pattern VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR :: VkStructureType + +pattern VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR = + VkStructureType 1000115001 diff --git a/src-gen/Graphics/Vulkan/Ext/VK_KHR_external_fence_win32.hs b/src-gen/Graphics/Vulkan/Ext/VK_KHR_external_fence_win32.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Ext/VK_KHR_external_fence_win32.hs @@ -0,0 +1,148 @@ +{-# OPTIONS_HADDOCK not-home#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE ForeignFunctionInterface #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE ViewPatterns #-} +module Graphics.Vulkan.Ext.VK_KHR_external_fence_win32 + (-- * Vulkan extension: @VK_KHR_external_fence_win32@ + -- | + -- + -- supported: @vulkan@ + -- + -- contact: @Jesse Hall @jessehall@ + -- + -- author: @KHR@ + -- + -- type: @device@ + -- + -- Extension number: @115@ + -- + -- Required extensions: 'VK_KHR_external_fence'. + -- + -- Protected by CPP ifdef: @VK_USE_PLATFORM_WIN32_KHR@ + -- + + -- ** Required extensions: 'VK_KHR_external_fence'. + module Graphics.Vulkan.Types.Struct.VkExportFenceWin32HandleInfoKHR, + module Graphics.Vulkan.Types.Enum.VkExternalFenceHandleTypeFlagsKHR, + module Graphics.Vulkan.Types.Enum.VkFenceCreateFlags, + module Graphics.Vulkan.Types.Struct.VkFenceCreateInfo, + module Graphics.Vulkan.Types.Struct.VkFenceGetWin32HandleInfoKHR, + module Graphics.Vulkan.Types.Enum.VkFenceImportFlagsKHR, + module Graphics.Vulkan.Types.BaseTypes, + module Graphics.Vulkan.Types.Struct.VkImportFenceWin32HandleInfoKHR, + module Graphics.Vulkan.Types.Enum.VkStructureType, + -- > #include "vk_platform.h" + -- + -- > #include + vkImportFenceWin32HandleKHR, vkGetFenceWin32HandleKHR, + module Graphics.Vulkan.Marshal, + module Graphics.Vulkan.Types.Enum.VkResult, + module Graphics.Vulkan.Types.Handles, + module Graphics.Vulkan.Types.Include, + VK_KHR_EXTERNAL_FENCE_WIN32_SPEC_VERSION, + pattern VK_KHR_EXTERNAL_FENCE_WIN32_SPEC_VERSION, + VK_KHR_EXTERNAL_FENCE_WIN32_EXTENSION_NAME, + pattern VK_KHR_EXTERNAL_FENCE_WIN32_EXTENSION_NAME, + pattern VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR, + pattern VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR, + pattern VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR) + where +import GHC.Ptr (Ptr (..)) +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Types.BaseTypes +import Graphics.Vulkan.Types.Enum.VkExternalFenceHandleTypeFlagsKHR +import Graphics.Vulkan.Types.Enum.VkFenceCreateFlags +import Graphics.Vulkan.Types.Enum.VkFenceImportFlagsKHR +import Graphics.Vulkan.Types.Enum.VkResult +import Graphics.Vulkan.Types.Enum.VkStructureType +import Graphics.Vulkan.Types.Handles +import Graphics.Vulkan.Types.Include +import Graphics.Vulkan.Types.Struct.VkExportFenceWin32HandleInfoKHR +import Graphics.Vulkan.Types.Struct.VkFenceCreateInfo +import Graphics.Vulkan.Types.Struct.VkFenceGetWin32HandleInfoKHR +import Graphics.Vulkan.Types.Struct.VkImportFenceWin32HandleInfoKHR + +-- | Success codes: 'VK_SUCCESS'. +-- +-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR'. +-- +-- > VkResult vkImportFenceWin32HandleKHR +-- > ( VkDevice device +-- > , const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo +-- > ) +-- +-- +foreign import ccall unsafe "vkImportFenceWin32HandleKHR" + vkImportFenceWin32HandleKHR :: + VkDevice -- ^ device + -> Ptr VkImportFenceWin32HandleInfoKHR -- ^ pImportFenceWin32HandleInfo + -> IO VkResult + +-- | Success codes: 'VK_SUCCESS'. +-- +-- Error codes: 'VK_ERROR_TOO_MANY_OBJECTS', 'VK_ERROR_OUT_OF_HOST_MEMORY'. +-- +-- > VkResult vkGetFenceWin32HandleKHR +-- > ( VkDevice device +-- > , const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo +-- > , HANDLE* pHandle +-- > ) +-- +-- +foreign import ccall unsafe "vkGetFenceWin32HandleKHR" + vkGetFenceWin32HandleKHR :: + VkDevice -- ^ device + -> + Ptr VkFenceGetWin32HandleInfoKHR -- ^ pGetWin32HandleInfo + -> Ptr HANDLE -- ^ pHandle + -> IO VkResult + +pattern VK_KHR_EXTERNAL_FENCE_WIN32_SPEC_VERSION :: + (Num a, Eq a) => a + +pattern VK_KHR_EXTERNAL_FENCE_WIN32_SPEC_VERSION = 1 + +type VK_KHR_EXTERNAL_FENCE_WIN32_SPEC_VERSION = 1 + +pattern VK_KHR_EXTERNAL_FENCE_WIN32_EXTENSION_NAME :: CString + +pattern VK_KHR_EXTERNAL_FENCE_WIN32_EXTENSION_NAME <- + (is_VK_KHR_EXTERNAL_FENCE_WIN32_EXTENSION_NAME -> True) + where VK_KHR_EXTERNAL_FENCE_WIN32_EXTENSION_NAME + = _VK_KHR_EXTERNAL_FENCE_WIN32_EXTENSION_NAME + +{-# INLINE _VK_KHR_EXTERNAL_FENCE_WIN32_EXTENSION_NAME #-} + +_VK_KHR_EXTERNAL_FENCE_WIN32_EXTENSION_NAME :: CString +_VK_KHR_EXTERNAL_FENCE_WIN32_EXTENSION_NAME + = Ptr "VK_KHR_external_fence_win32\NUL"# + +{-# INLINE is_VK_KHR_EXTERNAL_FENCE_WIN32_EXTENSION_NAME #-} + +is_VK_KHR_EXTERNAL_FENCE_WIN32_EXTENSION_NAME :: CString -> Bool +is_VK_KHR_EXTERNAL_FENCE_WIN32_EXTENSION_NAME + = eqCStrings _VK_KHR_EXTERNAL_FENCE_WIN32_EXTENSION_NAME + +type VK_KHR_EXTERNAL_FENCE_WIN32_EXTENSION_NAME = + "VK_KHR_external_fence_win32" + +pattern VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR = + VkStructureType 1000114000 + +pattern VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR = + VkStructureType 1000114001 + +pattern VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR = + VkStructureType 1000114002 diff --git a/src-gen/Graphics/Vulkan/Ext/VK_KHR_external_memory.hs b/src-gen/Graphics/Vulkan/Ext/VK_KHR_external_memory.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Ext/VK_KHR_external_memory.hs @@ -0,0 +1,134 @@ +{-# OPTIONS_HADDOCK not-home#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE ViewPatterns #-} +module Graphics.Vulkan.Ext.VK_KHR_external_memory + (-- * Vulkan extension: @VK_KHR_external_memory@ + -- | + -- + -- supported: @vulkan@ + -- + -- contact: @James Jones @cubanismo@ + -- + -- author: @KHR@ + -- + -- type: @device@ + -- + -- Extension number: @73@ + -- + -- Required extensions: 'VK_KHR_external_memory_capabilities'. + -- + + -- ** Required extensions: 'VK_KHR_external_memory_capabilities'. + module Graphics.Vulkan.Types.Enum.VkBufferCreateFlags, + module Graphics.Vulkan.Types.Struct.VkBufferCreateInfo, + module Graphics.Vulkan.Types.Enum.VkBufferUsageFlags, + module Graphics.Vulkan.Types.BaseTypes, + module Graphics.Vulkan.Types.Struct.VkExportMemoryAllocateInfoKHR, + module Graphics.Vulkan.Types.Struct.VkExtent3D, + module Graphics.Vulkan.Types.Struct.VkExternalMemoryBufferCreateInfoKHR, + module Graphics.Vulkan.Types.Enum.VkExternalMemoryHandleTypeFlagsKHR, + module Graphics.Vulkan.Types.Struct.VkExternalMemoryImageCreateInfoKHR, + module Graphics.Vulkan.Types.Enum.VkFormat, + module Graphics.Vulkan.Types.Enum.VkImageCreateFlags, + module Graphics.Vulkan.Types.Struct.VkImageCreateInfo, + module Graphics.Vulkan.Types.Enum.VkImageLayout, + module Graphics.Vulkan.Types.Enum.VkImageTiling, + module Graphics.Vulkan.Types.Enum.VkImageType, + module Graphics.Vulkan.Types.Enum.VkImageUsageFlags, + module Graphics.Vulkan.Types.Struct.VkMemoryAllocateInfo, + module Graphics.Vulkan.Types.Enum.VkSampleCountFlags, + module Graphics.Vulkan.Types.Enum.VkSharingMode, + module Graphics.Vulkan.Types.Enum.VkStructureType, + -- > #include "vk_platform.h" + VK_KHR_EXTERNAL_MEMORY_SPEC_VERSION, + pattern VK_KHR_EXTERNAL_MEMORY_SPEC_VERSION, + VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME, + pattern VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME, + pattern VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHR, + pattern VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHR, + pattern VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHR, + pattern VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR, + pattern VK_QUEUE_FAMILY_EXTERNAL_KHR, VK_QUEUE_FAMILY_EXTERNAL_KHR) + where +import GHC.Ptr + (Ptr (..)) +import Graphics.Vulkan.Constants + (VK_QUEUE_FAMILY_EXTERNAL_KHR, + pattern VK_QUEUE_FAMILY_EXTERNAL_KHR) +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Types.BaseTypes +import Graphics.Vulkan.Types.Enum.VkBufferCreateFlags +import Graphics.Vulkan.Types.Enum.VkBufferUsageFlags +import Graphics.Vulkan.Types.Enum.VkExternalMemoryHandleTypeFlagsKHR +import Graphics.Vulkan.Types.Enum.VkFormat +import Graphics.Vulkan.Types.Enum.VkImageCreateFlags +import Graphics.Vulkan.Types.Enum.VkImageLayout +import Graphics.Vulkan.Types.Enum.VkImageTiling +import Graphics.Vulkan.Types.Enum.VkImageType +import Graphics.Vulkan.Types.Enum.VkImageUsageFlags +import Graphics.Vulkan.Types.Enum.VkResult + (VkResult (..)) +import Graphics.Vulkan.Types.Enum.VkSampleCountFlags +import Graphics.Vulkan.Types.Enum.VkSharingMode +import Graphics.Vulkan.Types.Enum.VkStructureType +import Graphics.Vulkan.Types.Struct.VkBufferCreateInfo +import Graphics.Vulkan.Types.Struct.VkExportMemoryAllocateInfoKHR +import Graphics.Vulkan.Types.Struct.VkExtent3D +import Graphics.Vulkan.Types.Struct.VkExternalMemoryBufferCreateInfoKHR +import Graphics.Vulkan.Types.Struct.VkExternalMemoryImageCreateInfoKHR +import Graphics.Vulkan.Types.Struct.VkImageCreateInfo +import Graphics.Vulkan.Types.Struct.VkMemoryAllocateInfo + +pattern VK_KHR_EXTERNAL_MEMORY_SPEC_VERSION :: (Num a, Eq a) => a + +pattern VK_KHR_EXTERNAL_MEMORY_SPEC_VERSION = 1 + +type VK_KHR_EXTERNAL_MEMORY_SPEC_VERSION = 1 + +pattern VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME :: CString + +pattern VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME <- + (is_VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME -> True) + where VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME + = _VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME + +{-# INLINE _VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME #-} + +_VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME :: CString +_VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME + = Ptr "VK_KHR_external_memory\NUL"# + +{-# INLINE is_VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME #-} + +is_VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME :: CString -> Bool +is_VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME + = eqCStrings _VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME + +type VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME = + "VK_KHR_external_memory" + +pattern VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHR :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHR = + VkStructureType 1000072000 + +pattern VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHR :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHR = + VkStructureType 1000072001 + +pattern VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHR :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHR = + VkStructureType 1000072002 + +pattern VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR :: VkResult + +pattern VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR = + VkResult (-1000072003) diff --git a/src-gen/Graphics/Vulkan/Ext/VK_KHR_external_memory_capabilities.hs b/src-gen/Graphics/Vulkan/Ext/VK_KHR_external_memory_capabilities.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Ext/VK_KHR_external_memory_capabilities.hs @@ -0,0 +1,180 @@ +{-# OPTIONS_HADDOCK not-home#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE ForeignFunctionInterface #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE ViewPatterns #-} +module Graphics.Vulkan.Ext.VK_KHR_external_memory_capabilities + (-- * Vulkan extension: @VK_KHR_external_memory_capabilities@ + -- | + -- + -- supported: @vulkan@ + -- + -- contact: @James Jones @cubanismo@ + -- + -- author: @KHR@ + -- + -- type: @instance@ + -- + -- Extension number: @72@ + -- + -- Required extensions: 'VK_KHR_get_physical_device_properties2'. + -- + + -- ** Required extensions: 'VK_KHR_get_physical_device_properties2'. + module Graphics.Vulkan.Marshal, + module Graphics.Vulkan.Types.BaseTypes, + module Graphics.Vulkan.Types.Enum.VkBufferCreateFlags, + module Graphics.Vulkan.Types.Enum.VkBufferUsageFlags, + module Graphics.Vulkan.Types.Struct.VkExtent3D, + module Graphics.Vulkan.Types.Struct.VkExternalBufferPropertiesKHR, + module Graphics.Vulkan.Types.Struct.VkExternalImageFormatPropertiesKHR, + module Graphics.Vulkan.Types.Enum.VkExternalMemoryFeatureFlagsKHR, + module Graphics.Vulkan.Types.Enum.VkExternalMemoryHandleTypeFlagsKHR, + module Graphics.Vulkan.Types.Struct.VkExternalMemoryPropertiesKHR, + module Graphics.Vulkan.Types.Enum.VkFormat, + module Graphics.Vulkan.Types.Enum.VkImageCreateFlags, + module Graphics.Vulkan.Types.Struct.VkImageFormatProperties, + module Graphics.Vulkan.Types.Struct.VkImageFormatProperties2KHR, + module Graphics.Vulkan.Types.Enum.VkImageTiling, + module Graphics.Vulkan.Types.Enum.VkImageType, + module Graphics.Vulkan.Types.Enum.VkImageUsageFlags, + module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceExternalBufferInfoKHR, + module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceExternalImageFormatInfoKHR, + module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceIDPropertiesKHR, + module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceImageFormatInfo2KHR, + module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceLimits, + module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceProperties, + module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceProperties2KHR, + module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceSparseProperties, + module Graphics.Vulkan.Types.Enum.VkPhysicalDeviceType, + module Graphics.Vulkan.Types.Enum.VkSampleCountFlags, + module Graphics.Vulkan.Types.Enum.VkStructureType, + -- > #include "vk_platform.h" + vkGetPhysicalDeviceExternalBufferPropertiesKHR, + module Graphics.Vulkan.Types.Handles, + VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION, + pattern VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION, + VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME, + pattern VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME, + pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHR, + pattern VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHR, + pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHR, + pattern VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES_KHR, + pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHR, + pattern VK_LUID_SIZE_KHR, VK_LUID_SIZE_KHR) + where +import GHC.Ptr + (Ptr (..)) +import Graphics.Vulkan.Constants + (VK_LUID_SIZE_KHR, + pattern VK_LUID_SIZE_KHR) +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Types.BaseTypes +import Graphics.Vulkan.Types.Enum.VkBufferCreateFlags +import Graphics.Vulkan.Types.Enum.VkBufferUsageFlags +import Graphics.Vulkan.Types.Enum.VkExternalMemoryFeatureFlagsKHR +import Graphics.Vulkan.Types.Enum.VkExternalMemoryHandleTypeFlagsKHR +import Graphics.Vulkan.Types.Enum.VkFormat +import Graphics.Vulkan.Types.Enum.VkImageCreateFlags +import Graphics.Vulkan.Types.Enum.VkImageTiling +import Graphics.Vulkan.Types.Enum.VkImageType +import Graphics.Vulkan.Types.Enum.VkImageUsageFlags +import Graphics.Vulkan.Types.Enum.VkPhysicalDeviceType +import Graphics.Vulkan.Types.Enum.VkSampleCountFlags +import Graphics.Vulkan.Types.Enum.VkStructureType +import Graphics.Vulkan.Types.Handles +import Graphics.Vulkan.Types.Struct.VkExtent3D +import Graphics.Vulkan.Types.Struct.VkExternalBufferPropertiesKHR +import Graphics.Vulkan.Types.Struct.VkExternalImageFormatPropertiesKHR +import Graphics.Vulkan.Types.Struct.VkExternalMemoryPropertiesKHR +import Graphics.Vulkan.Types.Struct.VkImageFormatProperties +import Graphics.Vulkan.Types.Struct.VkImageFormatProperties2KHR +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceExternalBufferInfoKHR +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceExternalImageFormatInfoKHR +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceIDPropertiesKHR +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceImageFormatInfo2KHR +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceLimits +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceProperties +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceProperties2KHR +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceSparseProperties + +-- | > () vkGetPhysicalDeviceExternalBufferPropertiesKHR +-- > ( VkPhysicalDevice physicalDevice +-- > , const VkPhysicalDeviceExternalBufferInfoKHR* pExternalBufferInfo +-- > , VkExternalBufferPropertiesKHR* pExternalBufferProperties +-- > ) +-- +-- +foreign import ccall unsafe + "vkGetPhysicalDeviceExternalBufferPropertiesKHR" + vkGetPhysicalDeviceExternalBufferPropertiesKHR :: + VkPhysicalDevice -- ^ physicalDevice + -> + Ptr VkPhysicalDeviceExternalBufferInfoKHR -- ^ pExternalBufferInfo + -> + Ptr VkExternalBufferPropertiesKHR -- ^ pExternalBufferProperties + -> IO () + +pattern VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION :: + (Num a, Eq a) => a + +pattern VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION = 1 + +type VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION = 1 + +pattern VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME :: + CString + +pattern VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME <- + (is_VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME -> True) + where VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME + = _VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME + +{-# INLINE _VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME #-} + +_VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME :: CString +_VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME + = Ptr "VK_KHR_external_memory_capabilities\NUL"# + +{-# INLINE is_VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME + #-} + +is_VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME :: + CString -> Bool +is_VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME + = eqCStrings _VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME + +type VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME = + "VK_KHR_external_memory_capabilities" + +pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHR + :: VkStructureType + +pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHR + = VkStructureType 1000071000 + +pattern VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHR :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHR = + VkStructureType 1000071001 + +pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHR + :: VkStructureType + +pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHR + = VkStructureType 1000071002 + +pattern VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES_KHR :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES_KHR = + VkStructureType 1000071003 + +pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHR :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHR = + VkStructureType 1000071004 diff --git a/src-gen/Graphics/Vulkan/Ext/VK_KHR_external_memory_fd.hs b/src-gen/Graphics/Vulkan/Ext/VK_KHR_external_memory_fd.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Ext/VK_KHR_external_memory_fd.hs @@ -0,0 +1,142 @@ +{-# OPTIONS_GHC -fno-warn-unused-imports#-} +{-# OPTIONS_HADDOCK not-home#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE ForeignFunctionInterface #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE ViewPatterns #-} +module Graphics.Vulkan.Ext.VK_KHR_external_memory_fd + (-- * Vulkan extension: @VK_KHR_external_memory_fd@ + -- | + -- + -- supported: @vulkan@ + -- + -- contact: @James Jones @cubanismo@ + -- + -- author: @KHX@ + -- + -- type: @device@ + -- + -- Extension number: @75@ + -- + -- Required extensions: 'VK_KHR_external_memory'. + -- + + -- ** Required extensions: 'VK_KHR_external_memory'. + module Graphics.Vulkan.Marshal, + module Graphics.Vulkan.Types.BaseTypes, + module Graphics.Vulkan.Types.Enum.VkExternalMemoryHandleTypeFlagsKHR, + module Graphics.Vulkan.Types.Struct.VkImportMemoryFdInfoKHR, + module Graphics.Vulkan.Types.Struct.VkMemoryAllocateInfo, + module Graphics.Vulkan.Types.Struct.VkMemoryFdPropertiesKHR, + module Graphics.Vulkan.Types.Struct.VkMemoryGetFdInfoKHR, + module Graphics.Vulkan.Types.Enum.VkStructureType, + -- > #include "vk_platform.h" + vkGetMemoryFdKHR, vkGetMemoryFdPropertiesKHR, + module Graphics.Vulkan.Types.Enum.VkResult, + module Graphics.Vulkan.Types.Handles, + VK_KHR_EXTERNAL_MEMORY_FD_SPEC_VERSION, + pattern VK_KHR_EXTERNAL_MEMORY_FD_SPEC_VERSION, + VK_KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME, + pattern VK_KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME, + pattern VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR, + pattern VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR, + pattern VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR) + where +import GHC.Ptr (Ptr (..)) +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Types.BaseTypes +import Graphics.Vulkan.Types.Enum.VkExternalMemoryHandleTypeFlagsKHR +import Graphics.Vulkan.Types.Enum.VkResult +import Graphics.Vulkan.Types.Enum.VkStructureType +import Graphics.Vulkan.Types.Handles +import Graphics.Vulkan.Types.Struct.VkImportMemoryFdInfoKHR +import Graphics.Vulkan.Types.Struct.VkMemoryAllocateInfo +import Graphics.Vulkan.Types.Struct.VkMemoryFdPropertiesKHR +import Graphics.Vulkan.Types.Struct.VkMemoryGetFdInfoKHR + +-- | Success codes: 'VK_SUCCESS'. +-- +-- Error codes: 'VK_ERROR_TOO_MANY_OBJECTS', 'VK_ERROR_OUT_OF_HOST_MEMORY'. +-- +-- > VkResult vkGetMemoryFdKHR +-- > ( VkDevice device +-- > , const VkMemoryGetFdInfoKHR* pGetFdInfo +-- > , int* pFd +-- > ) +-- +-- +foreign import ccall unsafe "vkGetMemoryFdKHR" vkGetMemoryFdKHR :: + VkDevice -- ^ device + -> Ptr VkMemoryGetFdInfoKHR -- ^ pGetFdInfo + -> Ptr CInt -- ^ pFd + -> IO VkResult + +-- | Success codes: 'VK_SUCCESS'. +-- +-- Error codes: 'VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR'. +-- +-- > VkResult vkGetMemoryFdPropertiesKHR +-- > ( VkDevice device +-- > , VkExternalMemoryHandleTypeFlagBitsKHR handleType +-- > , int fd +-- > , VkMemoryFdPropertiesKHR* pMemoryFdProperties +-- > ) +-- +-- +foreign import ccall unsafe "vkGetMemoryFdPropertiesKHR" + vkGetMemoryFdPropertiesKHR :: + VkDevice -- ^ device + -> + VkExternalMemoryHandleTypeFlagBitsKHR -- ^ handleType + -> + CInt -- ^ fd + -> Ptr VkMemoryFdPropertiesKHR -- ^ pMemoryFdProperties + -> IO VkResult + +pattern VK_KHR_EXTERNAL_MEMORY_FD_SPEC_VERSION :: (Num a, Eq a) => + a + +pattern VK_KHR_EXTERNAL_MEMORY_FD_SPEC_VERSION = 1 + +type VK_KHR_EXTERNAL_MEMORY_FD_SPEC_VERSION = 1 + +pattern VK_KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME :: CString + +pattern VK_KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME <- + (is_VK_KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME -> True) + where VK_KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME + = _VK_KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME + +{-# INLINE _VK_KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME #-} + +_VK_KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME :: CString +_VK_KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME + = Ptr "VK_KHR_external_memory_fd\NUL"# + +{-# INLINE is_VK_KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME #-} + +is_VK_KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME :: CString -> Bool +is_VK_KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME + = eqCStrings _VK_KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME + +type VK_KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME = + "VK_KHR_external_memory_fd" + +pattern VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR = + VkStructureType 1000074000 + +pattern VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR = + VkStructureType 1000074001 + +pattern VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR :: VkStructureType + +pattern VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR = + VkStructureType 1000074002 diff --git a/src-gen/Graphics/Vulkan/Ext/VK_KHR_external_memory_win32.hs b/src-gen/Graphics/Vulkan/Ext/VK_KHR_external_memory_win32.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Ext/VK_KHR_external_memory_win32.hs @@ -0,0 +1,159 @@ +{-# OPTIONS_GHC -fno-warn-unused-imports#-} +{-# OPTIONS_HADDOCK not-home#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE ForeignFunctionInterface #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE ViewPatterns #-} +module Graphics.Vulkan.Ext.VK_KHR_external_memory_win32 + (-- * Vulkan extension: @VK_KHR_external_memory_win32@ + -- | + -- + -- supported: @vulkan@ + -- + -- contact: @James Jones @cubanismo@ + -- + -- author: @KHR@ + -- + -- type: @device@ + -- + -- Extension number: @74@ + -- + -- Required extensions: 'VK_KHR_external_memory'. + -- + -- Protected by CPP ifdef: @VK_USE_PLATFORM_WIN32_KHR@ + -- + + -- ** Required extensions: 'VK_KHR_external_memory'. + module Graphics.Vulkan.Types.BaseTypes, + module Graphics.Vulkan.Types.Struct.VkExportMemoryWin32HandleInfoKHR, + module Graphics.Vulkan.Types.Enum.VkExternalMemoryHandleTypeFlagsKHR, + module Graphics.Vulkan.Types.Struct.VkImportMemoryWin32HandleInfoKHR, + module Graphics.Vulkan.Types.Struct.VkMemoryAllocateInfo, + module Graphics.Vulkan.Types.Struct.VkMemoryGetWin32HandleInfoKHR, + module Graphics.Vulkan.Types.Struct.VkMemoryWin32HandlePropertiesKHR, + module Graphics.Vulkan.Types.Enum.VkStructureType, + -- > #include "vk_platform.h" + -- + -- > #include + vkGetMemoryWin32HandleKHR, vkGetMemoryWin32HandlePropertiesKHR, + module Graphics.Vulkan.Marshal, + module Graphics.Vulkan.Types.Enum.VkResult, + module Graphics.Vulkan.Types.Handles, + VK_KHR_EXTERNAL_MEMORY_WIN32_SPEC_VERSION, + pattern VK_KHR_EXTERNAL_MEMORY_WIN32_SPEC_VERSION, + VK_KHR_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME, + pattern VK_KHR_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME, + pattern VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR, + pattern VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR, + pattern VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR, + pattern VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR) + where +import GHC.Ptr (Ptr (..)) +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Types.BaseTypes +import Graphics.Vulkan.Types.Enum.VkExternalMemoryHandleTypeFlagsKHR +import Graphics.Vulkan.Types.Enum.VkResult +import Graphics.Vulkan.Types.Enum.VkStructureType +import Graphics.Vulkan.Types.Handles +import Graphics.Vulkan.Types.Include (HANDLE) +import Graphics.Vulkan.Types.Struct.VkExportMemoryWin32HandleInfoKHR +import Graphics.Vulkan.Types.Struct.VkImportMemoryWin32HandleInfoKHR +import Graphics.Vulkan.Types.Struct.VkMemoryAllocateInfo +import Graphics.Vulkan.Types.Struct.VkMemoryGetWin32HandleInfoKHR +import Graphics.Vulkan.Types.Struct.VkMemoryWin32HandlePropertiesKHR + +-- | Success codes: 'VK_SUCCESS'. +-- +-- Error codes: 'VK_ERROR_TOO_MANY_OBJECTS', 'VK_ERROR_OUT_OF_HOST_MEMORY'. +-- +-- > VkResult vkGetMemoryWin32HandleKHR +-- > ( VkDevice device +-- > , const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo +-- > , HANDLE* pHandle +-- > ) +-- +-- +foreign import ccall unsafe "vkGetMemoryWin32HandleKHR" + vkGetMemoryWin32HandleKHR :: + VkDevice -- ^ device + -> + Ptr VkMemoryGetWin32HandleInfoKHR -- ^ pGetWin32HandleInfo + -> Ptr HANDLE -- ^ pHandle + -> IO VkResult + +-- | Success codes: 'VK_SUCCESS'. +-- +-- Error codes: 'VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR'. +-- +-- > VkResult vkGetMemoryWin32HandlePropertiesKHR +-- > ( VkDevice device +-- > , VkExternalMemoryHandleTypeFlagBitsKHR handleType +-- > , HANDLE handle +-- > , VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties +-- > ) +-- +-- +foreign import ccall unsafe "vkGetMemoryWin32HandlePropertiesKHR" + vkGetMemoryWin32HandlePropertiesKHR :: + VkDevice -- ^ device + -> + VkExternalMemoryHandleTypeFlagBitsKHR -- ^ handleType + -> + HANDLE -- ^ handle + -> Ptr VkMemoryWin32HandlePropertiesKHR -- ^ pMemoryWin32HandleProperties + -> IO VkResult + +pattern VK_KHR_EXTERNAL_MEMORY_WIN32_SPEC_VERSION :: + (Num a, Eq a) => a + +pattern VK_KHR_EXTERNAL_MEMORY_WIN32_SPEC_VERSION = 1 + +type VK_KHR_EXTERNAL_MEMORY_WIN32_SPEC_VERSION = 1 + +pattern VK_KHR_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME :: CString + +pattern VK_KHR_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME <- + (is_VK_KHR_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME -> True) + where VK_KHR_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME + = _VK_KHR_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME + +{-# INLINE _VK_KHR_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME #-} + +_VK_KHR_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME :: CString +_VK_KHR_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME + = Ptr "VK_KHR_external_memory_win32\NUL"# + +{-# INLINE is_VK_KHR_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME #-} + +is_VK_KHR_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME :: CString -> Bool +is_VK_KHR_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME + = eqCStrings _VK_KHR_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME + +type VK_KHR_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME = + "VK_KHR_external_memory_win32" + +pattern VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR = + VkStructureType 1000073000 + +pattern VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR = + VkStructureType 1000073001 + +pattern VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR = + VkStructureType 1000073002 + +pattern VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR = + VkStructureType 1000073003 diff --git a/src-gen/Graphics/Vulkan/Ext/VK_KHR_external_semaphore.hs b/src-gen/Graphics/Vulkan/Ext/VK_KHR_external_semaphore.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Ext/VK_KHR_external_semaphore.hs @@ -0,0 +1,83 @@ +{-# OPTIONS_HADDOCK not-home#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE ViewPatterns #-} +module Graphics.Vulkan.Ext.VK_KHR_external_semaphore + (-- * Vulkan extension: @VK_KHR_external_semaphore@ + -- | + -- + -- supported: @vulkan@ + -- + -- contact: @James Jones @cubanismo@ + -- + -- author: @KHR@ + -- + -- type: @device@ + -- + -- Extension number: @78@ + -- + -- Required extensions: 'VK_KHR_external_semaphore_capabilities'. + -- + + -- ** Required extensions: 'VK_KHR_external_semaphore_capabilities'. + module Graphics.Vulkan.Types.Struct.VkExportSemaphoreCreateInfoKHR, + module Graphics.Vulkan.Types.Enum.VkExternalSemaphoreHandleTypeFlagsKHR, + module Graphics.Vulkan.Types.BaseTypes, + module Graphics.Vulkan.Types.Bitmasks, + module Graphics.Vulkan.Types.Struct.VkSemaphoreCreateInfo, + module Graphics.Vulkan.Types.Enum.VkSemaphoreImportFlagsKHR, + module Graphics.Vulkan.Types.Enum.VkStructureType, + -- > #include "vk_platform.h" + VK_KHR_EXTERNAL_SEMAPHORE_SPEC_VERSION, + pattern VK_KHR_EXTERNAL_SEMAPHORE_SPEC_VERSION, + VK_KHR_EXTERNAL_SEMAPHORE_EXTENSION_NAME, + pattern VK_KHR_EXTERNAL_SEMAPHORE_EXTENSION_NAME, + pattern VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHR) + where +import GHC.Ptr + (Ptr (..)) +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Types.BaseTypes +import Graphics.Vulkan.Types.Bitmasks +import Graphics.Vulkan.Types.Enum.VkExternalSemaphoreHandleTypeFlagsKHR +import Graphics.Vulkan.Types.Enum.VkSemaphoreImportFlagsKHR +import Graphics.Vulkan.Types.Enum.VkStructureType +import Graphics.Vulkan.Types.Struct.VkExportSemaphoreCreateInfoKHR +import Graphics.Vulkan.Types.Struct.VkSemaphoreCreateInfo + +pattern VK_KHR_EXTERNAL_SEMAPHORE_SPEC_VERSION :: (Num a, Eq a) => + a + +pattern VK_KHR_EXTERNAL_SEMAPHORE_SPEC_VERSION = 1 + +type VK_KHR_EXTERNAL_SEMAPHORE_SPEC_VERSION = 1 + +pattern VK_KHR_EXTERNAL_SEMAPHORE_EXTENSION_NAME :: CString + +pattern VK_KHR_EXTERNAL_SEMAPHORE_EXTENSION_NAME <- + (is_VK_KHR_EXTERNAL_SEMAPHORE_EXTENSION_NAME -> True) + where VK_KHR_EXTERNAL_SEMAPHORE_EXTENSION_NAME + = _VK_KHR_EXTERNAL_SEMAPHORE_EXTENSION_NAME + +{-# INLINE _VK_KHR_EXTERNAL_SEMAPHORE_EXTENSION_NAME #-} + +_VK_KHR_EXTERNAL_SEMAPHORE_EXTENSION_NAME :: CString +_VK_KHR_EXTERNAL_SEMAPHORE_EXTENSION_NAME + = Ptr "VK_KHR_external_semaphore\NUL"# + +{-# INLINE is_VK_KHR_EXTERNAL_SEMAPHORE_EXTENSION_NAME #-} + +is_VK_KHR_EXTERNAL_SEMAPHORE_EXTENSION_NAME :: CString -> Bool +is_VK_KHR_EXTERNAL_SEMAPHORE_EXTENSION_NAME + = eqCStrings _VK_KHR_EXTERNAL_SEMAPHORE_EXTENSION_NAME + +type VK_KHR_EXTERNAL_SEMAPHORE_EXTENSION_NAME = + "VK_KHR_external_semaphore" + +pattern VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHR :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHR = + VkStructureType 1000077000 diff --git a/src-gen/Graphics/Vulkan/Ext/VK_KHR_external_semaphore_capabilities.hs b/src-gen/Graphics/Vulkan/Ext/VK_KHR_external_semaphore_capabilities.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Ext/VK_KHR_external_semaphore_capabilities.hs @@ -0,0 +1,132 @@ +{-# OPTIONS_HADDOCK not-home#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE ForeignFunctionInterface #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE ViewPatterns #-} +module Graphics.Vulkan.Ext.VK_KHR_external_semaphore_capabilities + (-- * Vulkan extension: @VK_KHR_external_semaphore_capabilities@ + -- | + -- + -- supported: @vulkan@ + -- + -- contact: @James Jones @cubanismo@ + -- + -- author: @KHR@ + -- + -- type: @instance@ + -- + -- Extension number: @77@ + -- + -- Required extensions: 'VK_KHR_get_physical_device_properties2'. + -- + + -- ** Required extensions: 'VK_KHR_get_physical_device_properties2'. + module Graphics.Vulkan.Marshal, + module Graphics.Vulkan.Types.BaseTypes, + module Graphics.Vulkan.Types.Enum.VkExternalSemaphoreFeatureFlagsKHR, + module Graphics.Vulkan.Types.Enum.VkExternalSemaphoreHandleTypeFlagsKHR, + module Graphics.Vulkan.Types.Struct.VkExternalSemaphorePropertiesKHR, + module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceExternalSemaphoreInfoKHR, + module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceIDPropertiesKHR, + module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceLimits, + module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceProperties, + module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceProperties2KHR, + module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceSparseProperties, + module Graphics.Vulkan.Types.Enum.VkPhysicalDeviceType, + module Graphics.Vulkan.Types.Enum.VkSampleCountFlags, + module Graphics.Vulkan.Types.Enum.VkStructureType, + -- > #include "vk_platform.h" + vkGetPhysicalDeviceExternalSemaphorePropertiesKHR, + module Graphics.Vulkan.Types.Handles, + VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_SPEC_VERSION, + pattern VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_SPEC_VERSION, + VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME, + pattern VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME, + pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHR, + pattern VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES_KHR, + pattern VK_LUID_SIZE_KHR, VK_LUID_SIZE_KHR) + where +import GHC.Ptr + (Ptr (..)) +import Graphics.Vulkan.Constants + (VK_LUID_SIZE_KHR, + pattern VK_LUID_SIZE_KHR) +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Types.BaseTypes +import Graphics.Vulkan.Types.Enum.VkExternalSemaphoreFeatureFlagsKHR +import Graphics.Vulkan.Types.Enum.VkExternalSemaphoreHandleTypeFlagsKHR +import Graphics.Vulkan.Types.Enum.VkPhysicalDeviceType +import Graphics.Vulkan.Types.Enum.VkSampleCountFlags +import Graphics.Vulkan.Types.Enum.VkStructureType +import Graphics.Vulkan.Types.Handles +import Graphics.Vulkan.Types.Struct.VkExternalSemaphorePropertiesKHR +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceExternalSemaphoreInfoKHR +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceIDPropertiesKHR +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceLimits +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceProperties +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceProperties2KHR +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceSparseProperties + +-- | > () vkGetPhysicalDeviceExternalSemaphorePropertiesKHR +-- > ( VkPhysicalDevice physicalDevice +-- > , const VkPhysicalDeviceExternalSemaphoreInfoKHR* pExternalSemaphoreInfo +-- > , VkExternalSemaphorePropertiesKHR* pExternalSemaphoreProperties +-- > ) +-- +-- +foreign import ccall unsafe + "vkGetPhysicalDeviceExternalSemaphorePropertiesKHR" + vkGetPhysicalDeviceExternalSemaphorePropertiesKHR :: + VkPhysicalDevice -- ^ physicalDevice + -> + Ptr VkPhysicalDeviceExternalSemaphoreInfoKHR -- ^ pExternalSemaphoreInfo + -> + Ptr VkExternalSemaphorePropertiesKHR -- ^ pExternalSemaphoreProperties + -> IO () + +pattern VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_SPEC_VERSION :: + (Num a, Eq a) => a + +pattern VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_SPEC_VERSION = 1 + +type VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_SPEC_VERSION = 1 + +pattern VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME :: + CString + +pattern VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME <- + (is_VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME -> True) + where VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME + = _VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME + +{-# INLINE _VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME + #-} + +_VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME :: CString +_VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME + = Ptr "VK_KHR_external_semaphore_capabilities\NUL"# + +{-# INLINE is_VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME + #-} + +is_VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME :: + CString -> Bool +is_VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME + = eqCStrings _VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME + +type VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME = + "VK_KHR_external_semaphore_capabilities" + +pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHR + :: VkStructureType + +pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHR + = VkStructureType 1000076000 + +pattern VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES_KHR :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES_KHR = + VkStructureType 1000076001 diff --git a/src-gen/Graphics/Vulkan/Ext/VK_KHR_external_semaphore_fd.hs b/src-gen/Graphics/Vulkan/Ext/VK_KHR_external_semaphore_fd.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Ext/VK_KHR_external_semaphore_fd.hs @@ -0,0 +1,129 @@ +{-# OPTIONS_HADDOCK not-home#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE ForeignFunctionInterface #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE ViewPatterns #-} +module Graphics.Vulkan.Ext.VK_KHR_external_semaphore_fd + (-- * Vulkan extension: @VK_KHR_external_semaphore_fd@ + -- | + -- + -- supported: @vulkan@ + -- + -- contact: @James Jones @cubanismo@ + -- + -- author: @KHR@ + -- + -- type: @device@ + -- + -- Extension number: @80@ + -- + -- Required extensions: 'VK_KHR_external_semaphore'. + -- + + -- ** Required extensions: 'VK_KHR_external_semaphore'. + module Graphics.Vulkan.Marshal, + module Graphics.Vulkan.Types.Enum.VkExternalSemaphoreHandleTypeFlagsKHR, + module Graphics.Vulkan.Types.BaseTypes, + module Graphics.Vulkan.Types.Struct.VkImportSemaphoreFdInfoKHR, + module Graphics.Vulkan.Types.Struct.VkSemaphoreGetFdInfoKHR, + module Graphics.Vulkan.Types.Enum.VkSemaphoreImportFlagsKHR, + module Graphics.Vulkan.Types.Enum.VkStructureType, + -- > #include "vk_platform.h" + vkImportSemaphoreFdKHR, vkGetSemaphoreFdKHR, + module Graphics.Vulkan.Types.Enum.VkResult, + module Graphics.Vulkan.Types.Handles, + VK_KHR_EXTERNAL_SEMAPHORE_FD_SPEC_VERSION, + pattern VK_KHR_EXTERNAL_SEMAPHORE_FD_SPEC_VERSION, + VK_KHR_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME, + pattern VK_KHR_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME, + pattern VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR, + pattern VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR) + where +import GHC.Ptr + (Ptr (..)) +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Types.BaseTypes +import Graphics.Vulkan.Types.Enum.VkExternalSemaphoreHandleTypeFlagsKHR +import Graphics.Vulkan.Types.Enum.VkResult +import Graphics.Vulkan.Types.Enum.VkSemaphoreImportFlagsKHR +import Graphics.Vulkan.Types.Enum.VkStructureType +import Graphics.Vulkan.Types.Handles +import Graphics.Vulkan.Types.Struct.VkImportSemaphoreFdInfoKHR +import Graphics.Vulkan.Types.Struct.VkSemaphoreGetFdInfoKHR + +-- | Success codes: 'VK_SUCCESS'. +-- +-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR'. +-- +-- > VkResult vkImportSemaphoreFdKHR +-- > ( VkDevice device +-- > , const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo +-- > ) +-- +-- +foreign import ccall unsafe "vkImportSemaphoreFdKHR" + vkImportSemaphoreFdKHR :: + VkDevice -- ^ device + -> Ptr VkImportSemaphoreFdInfoKHR -- ^ pImportSemaphoreFdInfo + -> IO VkResult + +-- | Success codes: 'VK_SUCCESS'. +-- +-- Error codes: 'VK_ERROR_TOO_MANY_OBJECTS', 'VK_ERROR_OUT_OF_HOST_MEMORY'. +-- +-- > VkResult vkGetSemaphoreFdKHR +-- > ( VkDevice device +-- > , const VkSemaphoreGetFdInfoKHR* pGetFdInfo +-- > , int* pFd +-- > ) +-- +-- +foreign import ccall unsafe "vkGetSemaphoreFdKHR" + vkGetSemaphoreFdKHR :: + VkDevice -- ^ device + -> Ptr VkSemaphoreGetFdInfoKHR -- ^ pGetFdInfo + -> Ptr CInt -- ^ pFd + -> IO VkResult + +pattern VK_KHR_EXTERNAL_SEMAPHORE_FD_SPEC_VERSION :: + (Num a, Eq a) => a + +pattern VK_KHR_EXTERNAL_SEMAPHORE_FD_SPEC_VERSION = 1 + +type VK_KHR_EXTERNAL_SEMAPHORE_FD_SPEC_VERSION = 1 + +pattern VK_KHR_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME :: CString + +pattern VK_KHR_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME <- + (is_VK_KHR_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME -> True) + where VK_KHR_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME + = _VK_KHR_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME + +{-# INLINE _VK_KHR_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME #-} + +_VK_KHR_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME :: CString +_VK_KHR_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME + = Ptr "VK_KHR_external_semaphore_fd\NUL"# + +{-# INLINE is_VK_KHR_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME #-} + +is_VK_KHR_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME :: CString -> Bool +is_VK_KHR_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME + = eqCStrings _VK_KHR_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME + +type VK_KHR_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME = + "VK_KHR_external_semaphore_fd" + +pattern VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR = + VkStructureType 1000079000 + +pattern VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR = + VkStructureType 1000079001 diff --git a/src-gen/Graphics/Vulkan/Ext/VK_KHR_external_semaphore_win32.hs b/src-gen/Graphics/Vulkan/Ext/VK_KHR_external_semaphore_win32.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Ext/VK_KHR_external_semaphore_win32.hs @@ -0,0 +1,163 @@ +{-# OPTIONS_HADDOCK not-home#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE ForeignFunctionInterface #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE ViewPatterns #-} +module Graphics.Vulkan.Ext.VK_KHR_external_semaphore_win32 + (-- * Vulkan extension: @VK_KHR_external_semaphore_win32@ + -- | + -- + -- supported: @vulkan@ + -- + -- contact: @James Jones @cubanismo@ + -- + -- author: @KHR@ + -- + -- type: @device@ + -- + -- Extension number: @79@ + -- + -- Required extensions: 'VK_KHR_external_semaphore'. + -- + -- Protected by CPP ifdef: @VK_USE_PLATFORM_WIN32_KHR@ + -- + + -- ** Required extensions: 'VK_KHR_external_semaphore'. + module Graphics.Vulkan.Types.Struct.VkD3D12FenceSubmitInfoKHR, + module Graphics.Vulkan.Types.Struct.VkExportSemaphoreWin32HandleInfoKHR, + module Graphics.Vulkan.Types.Enum.VkExternalSemaphoreHandleTypeFlagsKHR, + module Graphics.Vulkan.Types.BaseTypes, + module Graphics.Vulkan.Types.Struct.VkImportSemaphoreWin32HandleInfoKHR, + module Graphics.Vulkan.Types.Enum.VkPipelineStageFlags, + module Graphics.Vulkan.Types.Bitmasks, + module Graphics.Vulkan.Types.Struct.VkSemaphoreCreateInfo, + module Graphics.Vulkan.Types.Struct.VkSemaphoreGetWin32HandleInfoKHR, + module Graphics.Vulkan.Types.Enum.VkSemaphoreImportFlagsKHR, + module Graphics.Vulkan.Types.Enum.VkStructureType, + module Graphics.Vulkan.Types.Struct.VkSubmitInfo, + -- > #include "vk_platform.h" + -- + -- > #include + vkImportSemaphoreWin32HandleKHR, vkGetSemaphoreWin32HandleKHR, + module Graphics.Vulkan.Marshal, + module Graphics.Vulkan.Types.Enum.VkResult, + module Graphics.Vulkan.Types.Handles, + module Graphics.Vulkan.Types.Include, + VK_KHR_EXTERNAL_SEMAPHORE_WIN32_SPEC_VERSION, + pattern VK_KHR_EXTERNAL_SEMAPHORE_WIN32_SPEC_VERSION, + VK_KHR_EXTERNAL_SEMAPHORE_WIN32_EXTENSION_NAME, + pattern VK_KHR_EXTERNAL_SEMAPHORE_WIN32_EXTENSION_NAME, + pattern VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR, + pattern VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR, + pattern VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR, + pattern VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR) + where +import GHC.Ptr + (Ptr (..)) +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Types.BaseTypes +import Graphics.Vulkan.Types.Bitmasks +import Graphics.Vulkan.Types.Enum.VkExternalSemaphoreHandleTypeFlagsKHR +import Graphics.Vulkan.Types.Enum.VkPipelineStageFlags +import Graphics.Vulkan.Types.Enum.VkResult +import Graphics.Vulkan.Types.Enum.VkSemaphoreImportFlagsKHR +import Graphics.Vulkan.Types.Enum.VkStructureType +import Graphics.Vulkan.Types.Handles +import Graphics.Vulkan.Types.Include +import Graphics.Vulkan.Types.Struct.VkD3D12FenceSubmitInfoKHR +import Graphics.Vulkan.Types.Struct.VkExportSemaphoreWin32HandleInfoKHR +import Graphics.Vulkan.Types.Struct.VkImportSemaphoreWin32HandleInfoKHR +import Graphics.Vulkan.Types.Struct.VkSemaphoreCreateInfo +import Graphics.Vulkan.Types.Struct.VkSemaphoreGetWin32HandleInfoKHR +import Graphics.Vulkan.Types.Struct.VkSubmitInfo + +-- | Success codes: 'VK_SUCCESS'. +-- +-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR'. +-- +-- > VkResult vkImportSemaphoreWin32HandleKHR +-- > ( VkDevice device +-- > , const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo +-- > ) +-- +-- +foreign import ccall unsafe "vkImportSemaphoreWin32HandleKHR" + vkImportSemaphoreWin32HandleKHR :: + VkDevice -- ^ device + -> Ptr VkImportSemaphoreWin32HandleInfoKHR -- ^ pImportSemaphoreWin32HandleInfo + -> IO VkResult + +-- | Success codes: 'VK_SUCCESS'. +-- +-- Error codes: 'VK_ERROR_TOO_MANY_OBJECTS', 'VK_ERROR_OUT_OF_HOST_MEMORY'. +-- +-- > VkResult vkGetSemaphoreWin32HandleKHR +-- > ( VkDevice device +-- > , const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo +-- > , HANDLE* pHandle +-- > ) +-- +-- +foreign import ccall unsafe "vkGetSemaphoreWin32HandleKHR" + vkGetSemaphoreWin32HandleKHR :: + VkDevice -- ^ device + -> + Ptr VkSemaphoreGetWin32HandleInfoKHR -- ^ pGetWin32HandleInfo + -> Ptr HANDLE -- ^ pHandle + -> IO VkResult + +pattern VK_KHR_EXTERNAL_SEMAPHORE_WIN32_SPEC_VERSION :: + (Num a, Eq a) => a + +pattern VK_KHR_EXTERNAL_SEMAPHORE_WIN32_SPEC_VERSION = 1 + +type VK_KHR_EXTERNAL_SEMAPHORE_WIN32_SPEC_VERSION = 1 + +pattern VK_KHR_EXTERNAL_SEMAPHORE_WIN32_EXTENSION_NAME :: CString + +pattern VK_KHR_EXTERNAL_SEMAPHORE_WIN32_EXTENSION_NAME <- + (is_VK_KHR_EXTERNAL_SEMAPHORE_WIN32_EXTENSION_NAME -> True) + where VK_KHR_EXTERNAL_SEMAPHORE_WIN32_EXTENSION_NAME + = _VK_KHR_EXTERNAL_SEMAPHORE_WIN32_EXTENSION_NAME + +{-# INLINE _VK_KHR_EXTERNAL_SEMAPHORE_WIN32_EXTENSION_NAME #-} + +_VK_KHR_EXTERNAL_SEMAPHORE_WIN32_EXTENSION_NAME :: CString +_VK_KHR_EXTERNAL_SEMAPHORE_WIN32_EXTENSION_NAME + = Ptr "VK_KHR_external_semaphore_win32\NUL"# + +{-# INLINE is_VK_KHR_EXTERNAL_SEMAPHORE_WIN32_EXTENSION_NAME #-} + +is_VK_KHR_EXTERNAL_SEMAPHORE_WIN32_EXTENSION_NAME :: + CString -> Bool +is_VK_KHR_EXTERNAL_SEMAPHORE_WIN32_EXTENSION_NAME + = eqCStrings _VK_KHR_EXTERNAL_SEMAPHORE_WIN32_EXTENSION_NAME + +type VK_KHR_EXTERNAL_SEMAPHORE_WIN32_EXTENSION_NAME = + "VK_KHR_external_semaphore_win32" + +pattern VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR = + VkStructureType 1000078000 + +pattern VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR = + VkStructureType 1000078001 + +pattern VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR = + VkStructureType 1000078002 + +pattern VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR = + VkStructureType 1000078003 diff --git a/src-gen/Graphics/Vulkan/Ext/VK_KHR_get_memory_requirements2.hs b/src-gen/Graphics/Vulkan/Ext/VK_KHR_get_memory_requirements2.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Ext/VK_KHR_get_memory_requirements2.hs @@ -0,0 +1,177 @@ +{-# OPTIONS_HADDOCK not-home#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE ForeignFunctionInterface #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE ViewPatterns #-} +module Graphics.Vulkan.Ext.VK_KHR_get_memory_requirements2 + (-- * Vulkan extension: @VK_KHR_get_memory_requirements2@ + -- | + -- + -- supported: @vulkan@ + -- + -- contact: @Jason Ekstrand @jekstrand@ + -- + -- author: @KHR@ + -- + -- type: @device@ + -- + -- Extension number: @147@ + module Graphics.Vulkan.Types.Struct.VkBufferMemoryRequirementsInfo2KHR, + module Graphics.Vulkan.Types.BaseTypes, + module Graphics.Vulkan.Types.Struct.VkExtent3D, + module Graphics.Vulkan.Types.Enum.VkImageAspectFlags, + module Graphics.Vulkan.Types.Struct.VkImageMemoryRequirementsInfo2KHR, + module Graphics.Vulkan.Types.Struct.VkImageSparseMemoryRequirementsInfo2KHR, + module Graphics.Vulkan.Types.Struct.VkMemoryRequirements, + module Graphics.Vulkan.Types.Struct.VkMemoryRequirements2KHR, + module Graphics.Vulkan.Types.Enum.VkSparseImageFormatFlags, + module Graphics.Vulkan.Types.Struct.VkSparseImageFormatProperties, + module Graphics.Vulkan.Types.Struct.VkSparseImageMemoryRequirements, + module Graphics.Vulkan.Types.Struct.VkSparseImageMemoryRequirements2KHR, + module Graphics.Vulkan.Types.Enum.VkStructureType, + -- > #include "vk_platform.h" + vkGetImageMemoryRequirements2KHR, + vkGetBufferMemoryRequirements2KHR, + vkGetImageSparseMemoryRequirements2KHR, + module Graphics.Vulkan.Marshal, + module Graphics.Vulkan.Types.Handles, + VK_KHR_GET_MEMORY_REQUIREMENTS_2_SPEC_VERSION, + pattern VK_KHR_GET_MEMORY_REQUIREMENTS_2_SPEC_VERSION, + VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME, + pattern VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME, + pattern VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2_KHR, + pattern VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2_KHR, + pattern VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2_KHR, + pattern VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR, + pattern VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2_KHR) + where +import GHC.Ptr + (Ptr (..)) +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Types.BaseTypes +import Graphics.Vulkan.Types.Enum.VkImageAspectFlags +import Graphics.Vulkan.Types.Enum.VkSparseImageFormatFlags +import Graphics.Vulkan.Types.Enum.VkStructureType +import Graphics.Vulkan.Types.Handles +import Graphics.Vulkan.Types.Struct.VkBufferMemoryRequirementsInfo2KHR +import Graphics.Vulkan.Types.Struct.VkExtent3D +import Graphics.Vulkan.Types.Struct.VkImageMemoryRequirementsInfo2KHR +import Graphics.Vulkan.Types.Struct.VkImageSparseMemoryRequirementsInfo2KHR +import Graphics.Vulkan.Types.Struct.VkMemoryRequirements +import Graphics.Vulkan.Types.Struct.VkMemoryRequirements2KHR +import Graphics.Vulkan.Types.Struct.VkSparseImageFormatProperties +import Graphics.Vulkan.Types.Struct.VkSparseImageMemoryRequirements +import Graphics.Vulkan.Types.Struct.VkSparseImageMemoryRequirements2KHR + +-- | > () vkGetImageMemoryRequirements2KHR +-- > ( VkDevice device +-- > , const VkImageMemoryRequirementsInfo2KHR* pInfo +-- > , VkMemoryRequirements2KHR* pMemoryRequirements +-- > ) +-- +-- +foreign import ccall unsafe "vkGetImageMemoryRequirements2KHR" + vkGetImageMemoryRequirements2KHR :: + VkDevice -- ^ device + -> + Ptr VkImageMemoryRequirementsInfo2KHR -- ^ pInfo + -> + Ptr VkMemoryRequirements2KHR -- ^ pMemoryRequirements + -> IO () + +-- | > () vkGetBufferMemoryRequirements2KHR +-- > ( VkDevice device +-- > , const VkBufferMemoryRequirementsInfo2KHR* pInfo +-- > , VkMemoryRequirements2KHR* pMemoryRequirements +-- > ) +-- +-- +foreign import ccall unsafe "vkGetBufferMemoryRequirements2KHR" + vkGetBufferMemoryRequirements2KHR :: + VkDevice -- ^ device + -> + Ptr VkBufferMemoryRequirementsInfo2KHR -- ^ pInfo + -> + Ptr VkMemoryRequirements2KHR -- ^ pMemoryRequirements + -> IO () + +-- | > () vkGetImageSparseMemoryRequirements2KHR +-- > ( VkDevice device +-- > , const VkImageSparseMemoryRequirementsInfo2KHR* pInfo +-- > , uint32_t* pSparseMemoryRequirementCount +-- > , VkSparseImageMemoryRequirements2KHR* pSparseMemoryRequirements +-- > ) +-- +-- +foreign import ccall unsafe + "vkGetImageSparseMemoryRequirements2KHR" + vkGetImageSparseMemoryRequirements2KHR :: + VkDevice -- ^ device + -> + Ptr VkImageSparseMemoryRequirementsInfo2KHR -- ^ pInfo + -> + Ptr Word32 -- ^ pSparseMemoryRequirementCount + -> Ptr VkSparseImageMemoryRequirements2KHR -- ^ pSparseMemoryRequirements + -> IO () + +pattern VK_KHR_GET_MEMORY_REQUIREMENTS_2_SPEC_VERSION :: + (Num a, Eq a) => a + +pattern VK_KHR_GET_MEMORY_REQUIREMENTS_2_SPEC_VERSION = 1 + +type VK_KHR_GET_MEMORY_REQUIREMENTS_2_SPEC_VERSION = 1 + +pattern VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME :: CString + +pattern VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME <- + (is_VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME -> True) + where VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME + = _VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME + +{-# INLINE _VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME #-} + +_VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME :: CString +_VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME + = Ptr "VK_KHR_get_memory_requirements2\NUL"# + +{-# INLINE is_VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME #-} + +is_VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME :: + CString -> Bool +is_VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME + = eqCStrings _VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME + +type VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME = + "VK_KHR_get_memory_requirements2" + +pattern VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2_KHR :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2_KHR = + VkStructureType 1000146000 + +pattern VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2_KHR :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2_KHR = + VkStructureType 1000146001 + +pattern VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2_KHR + :: VkStructureType + +pattern VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2_KHR + = VkStructureType 1000146002 + +pattern VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR = + VkStructureType 1000146003 + +pattern VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2_KHR :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2_KHR = + VkStructureType 1000146004 diff --git a/src-gen/Graphics/Vulkan/Ext/VK_KHR_get_physical_device_properties2.hs b/src-gen/Graphics/Vulkan/Ext/VK_KHR_get_physical_device_properties2.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Ext/VK_KHR_get_physical_device_properties2.hs @@ -0,0 +1,324 @@ +{-# OPTIONS_HADDOCK not-home#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE ForeignFunctionInterface #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE ViewPatterns #-} +module Graphics.Vulkan.Ext.VK_KHR_get_physical_device_properties2 + (-- * Vulkan extension: @VK_KHR_get_physical_device_properties2@ + -- | + -- + -- supported: @vulkan@ + -- + -- contact: @Jeff Bolz @jbolz@ + -- + -- author: @KHR@ + -- + -- type: @instance@ + -- + -- Extension number: @60@ + module Graphics.Vulkan.Marshal, + module Graphics.Vulkan.Types.BaseTypes, + module Graphics.Vulkan.Types.Bitmasks, + module Graphics.Vulkan.Types.Struct.VkDeviceCreateInfo, + module Graphics.Vulkan.Types.Struct.VkDeviceQueueCreateInfo, + module Graphics.Vulkan.Types.Struct.VkExtent3D, + module Graphics.Vulkan.Types.Enum.VkFormat, + module Graphics.Vulkan.Types.Enum.VkFormatFeatureFlags, + module Graphics.Vulkan.Types.Struct.VkFormatProperties, + module Graphics.Vulkan.Types.Struct.VkFormatProperties2KHR, + module Graphics.Vulkan.Types.Enum.VkImageAspectFlags, + module Graphics.Vulkan.Types.Enum.VkImageCreateFlags, + module Graphics.Vulkan.Types.Struct.VkImageFormatProperties, + module Graphics.Vulkan.Types.Struct.VkImageFormatProperties2KHR, + module Graphics.Vulkan.Types.Enum.VkImageTiling, + module Graphics.Vulkan.Types.Enum.VkImageType, + module Graphics.Vulkan.Types.Enum.VkImageUsageFlags, + module Graphics.Vulkan.Types.Struct.VkMemoryHeap, + module Graphics.Vulkan.Types.Enum.VkMemoryHeapFlags, + module Graphics.Vulkan.Types.Enum.VkMemoryPropertyFlags, + module Graphics.Vulkan.Types.Struct.VkMemoryType, + module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceFeatures, + module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceFeatures2KHR, + module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceImageFormatInfo2KHR, + module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceLimits, + module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceMemoryProperties, + module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceMemoryProperties2KHR, + module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceProperties, + module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceProperties2KHR, + module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceSparseImageFormatInfo2KHR, + module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceSparseProperties, + module Graphics.Vulkan.Types.Enum.VkPhysicalDeviceType, + module Graphics.Vulkan.Types.Struct.VkQueueFamilyProperties, + module Graphics.Vulkan.Types.Struct.VkQueueFamilyProperties2KHR, + module Graphics.Vulkan.Types.Enum.VkQueueFlags, + module Graphics.Vulkan.Types.Enum.VkSampleCountFlags, + module Graphics.Vulkan.Types.Enum.VkSparseImageFormatFlags, + module Graphics.Vulkan.Types.Struct.VkSparseImageFormatProperties, + module Graphics.Vulkan.Types.Struct.VkSparseImageFormatProperties2KHR, + module Graphics.Vulkan.Types.Enum.VkStructureType, + -- > #include "vk_platform.h" + vkGetPhysicalDeviceFeatures2KHR, vkGetPhysicalDeviceProperties2KHR, + vkGetPhysicalDeviceFormatProperties2KHR, + vkGetPhysicalDeviceImageFormatProperties2KHR, + vkGetPhysicalDeviceQueueFamilyProperties2KHR, + vkGetPhysicalDeviceMemoryProperties2KHR, + vkGetPhysicalDeviceSparseImageFormatProperties2KHR, + module Graphics.Vulkan.Types.Enum.VkResult, + module Graphics.Vulkan.Types.Handles, + VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_SPEC_VERSION, + pattern VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_SPEC_VERSION, + VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME, + pattern VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME, + pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR, + pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR, + pattern VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR, + pattern VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2_KHR, + pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHR, + pattern VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2_KHR, + pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2_KHR, + pattern VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2_KHR, + pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2_KHR) + where +import GHC.Ptr + (Ptr (..)) +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Types.BaseTypes +import Graphics.Vulkan.Types.Bitmasks +import Graphics.Vulkan.Types.Enum.VkFormat +import Graphics.Vulkan.Types.Enum.VkFormatFeatureFlags +import Graphics.Vulkan.Types.Enum.VkImageAspectFlags +import Graphics.Vulkan.Types.Enum.VkImageCreateFlags +import Graphics.Vulkan.Types.Enum.VkImageTiling +import Graphics.Vulkan.Types.Enum.VkImageType +import Graphics.Vulkan.Types.Enum.VkImageUsageFlags +import Graphics.Vulkan.Types.Enum.VkMemoryHeapFlags +import Graphics.Vulkan.Types.Enum.VkMemoryPropertyFlags +import Graphics.Vulkan.Types.Enum.VkPhysicalDeviceType +import Graphics.Vulkan.Types.Enum.VkQueueFlags +import Graphics.Vulkan.Types.Enum.VkResult +import Graphics.Vulkan.Types.Enum.VkSampleCountFlags +import Graphics.Vulkan.Types.Enum.VkSparseImageFormatFlags +import Graphics.Vulkan.Types.Enum.VkStructureType +import Graphics.Vulkan.Types.Handles +import Graphics.Vulkan.Types.Struct.VkDeviceCreateInfo +import Graphics.Vulkan.Types.Struct.VkDeviceQueueCreateInfo +import Graphics.Vulkan.Types.Struct.VkExtent3D +import Graphics.Vulkan.Types.Struct.VkFormatProperties +import Graphics.Vulkan.Types.Struct.VkFormatProperties2KHR +import Graphics.Vulkan.Types.Struct.VkImageFormatProperties +import Graphics.Vulkan.Types.Struct.VkImageFormatProperties2KHR +import Graphics.Vulkan.Types.Struct.VkMemoryHeap +import Graphics.Vulkan.Types.Struct.VkMemoryType +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceFeatures +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceFeatures2KHR +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceImageFormatInfo2KHR +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceLimits +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceMemoryProperties +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceMemoryProperties2KHR +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceProperties +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceProperties2KHR +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceSparseImageFormatInfo2KHR +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceSparseProperties +import Graphics.Vulkan.Types.Struct.VkQueueFamilyProperties +import Graphics.Vulkan.Types.Struct.VkQueueFamilyProperties2KHR +import Graphics.Vulkan.Types.Struct.VkSparseImageFormatProperties +import Graphics.Vulkan.Types.Struct.VkSparseImageFormatProperties2KHR + +-- | > () vkGetPhysicalDeviceFeatures2KHR +-- > ( VkPhysicalDevice physicalDevice +-- > , VkPhysicalDeviceFeatures2KHR* pFeatures +-- > ) +-- +-- +foreign import ccall unsafe "vkGetPhysicalDeviceFeatures2KHR" + vkGetPhysicalDeviceFeatures2KHR :: + VkPhysicalDevice -- ^ physicalDevice + -> Ptr VkPhysicalDeviceFeatures2KHR -- ^ pFeatures + -> IO () + +-- | > () vkGetPhysicalDeviceProperties2KHR +-- > ( VkPhysicalDevice physicalDevice +-- > , VkPhysicalDeviceProperties2KHR* pProperties +-- > ) +-- +-- +foreign import ccall unsafe "vkGetPhysicalDeviceProperties2KHR" + vkGetPhysicalDeviceProperties2KHR :: + VkPhysicalDevice -- ^ physicalDevice + -> Ptr VkPhysicalDeviceProperties2KHR -- ^ pProperties + -> IO () + +-- | > () vkGetPhysicalDeviceFormatProperties2KHR +-- > ( VkPhysicalDevice physicalDevice +-- > , VkFormat format +-- > , VkFormatProperties2KHR* pFormatProperties +-- > ) +-- +-- +foreign import ccall unsafe + "vkGetPhysicalDeviceFormatProperties2KHR" + vkGetPhysicalDeviceFormatProperties2KHR :: + VkPhysicalDevice -- ^ physicalDevice + -> VkFormat -- ^ format + -> Ptr VkFormatProperties2KHR -- ^ pFormatProperties + -> IO () + +-- | Success codes: 'VK_SUCCESS'. +-- +-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_FORMAT_NOT_SUPPORTED'. +-- +-- > VkResult vkGetPhysicalDeviceImageFormatProperties2KHR +-- > ( VkPhysicalDevice physicalDevice +-- > , const VkPhysicalDeviceImageFormatInfo2KHR* pImageFormatInfo +-- > , VkImageFormatProperties2KHR* pImageFormatProperties +-- > ) +-- +-- +foreign import ccall unsafe + "vkGetPhysicalDeviceImageFormatProperties2KHR" + vkGetPhysicalDeviceImageFormatProperties2KHR :: + VkPhysicalDevice -- ^ physicalDevice + -> + Ptr VkPhysicalDeviceImageFormatInfo2KHR -- ^ pImageFormatInfo + -> + Ptr VkImageFormatProperties2KHR -- ^ pImageFormatProperties + -> IO VkResult + +-- | > () vkGetPhysicalDeviceQueueFamilyProperties2KHR +-- > ( VkPhysicalDevice physicalDevice +-- > , uint32_t* pQueueFamilyPropertyCount +-- > , VkQueueFamilyProperties2KHR* pQueueFamilyProperties +-- > ) +-- +-- +foreign import ccall unsafe + "vkGetPhysicalDeviceQueueFamilyProperties2KHR" + vkGetPhysicalDeviceQueueFamilyProperties2KHR :: + VkPhysicalDevice -- ^ physicalDevice + -> + Ptr Word32 -- ^ pQueueFamilyPropertyCount + -> Ptr VkQueueFamilyProperties2KHR -- ^ pQueueFamilyProperties + -> IO () + +-- | > () vkGetPhysicalDeviceMemoryProperties2KHR +-- > ( VkPhysicalDevice physicalDevice +-- > , VkPhysicalDeviceMemoryProperties2KHR* pMemoryProperties +-- > ) +-- +-- +foreign import ccall unsafe + "vkGetPhysicalDeviceMemoryProperties2KHR" + vkGetPhysicalDeviceMemoryProperties2KHR :: + VkPhysicalDevice -- ^ physicalDevice + -> + Ptr VkPhysicalDeviceMemoryProperties2KHR -- ^ pMemoryProperties + -> IO () + +-- | > () vkGetPhysicalDeviceSparseImageFormatProperties2KHR +-- > ( VkPhysicalDevice physicalDevice +-- > , const VkPhysicalDeviceSparseImageFormatInfo2KHR* pFormatInfo +-- > , uint32_t* pPropertyCount +-- > , VkSparseImageFormatProperties2KHR* pProperties +-- > ) +-- +-- +foreign import ccall unsafe + "vkGetPhysicalDeviceSparseImageFormatProperties2KHR" + vkGetPhysicalDeviceSparseImageFormatProperties2KHR :: + VkPhysicalDevice -- ^ physicalDevice + -> + Ptr VkPhysicalDeviceSparseImageFormatInfo2KHR -- ^ pFormatInfo + -> + Ptr Word32 -- ^ pPropertyCount + -> Ptr VkSparseImageFormatProperties2KHR -- ^ pProperties + -> IO () + +pattern VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_SPEC_VERSION :: + (Num a, Eq a) => a + +pattern VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_SPEC_VERSION = 1 + +type VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_SPEC_VERSION = 1 + +pattern VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME :: + CString + +pattern VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME <- + (is_VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME -> True) + where VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME + = _VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME + +{-# INLINE _VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME + #-} + +_VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME :: CString +_VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME + = Ptr "VK_KHR_get_physical_device_properties2\NUL"# + +{-# INLINE is_VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME + #-} + +is_VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME :: + CString -> Bool +is_VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME + = eqCStrings + _VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME + +type VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME = + "VK_KHR_get_physical_device_properties2" + +pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR = + VkStructureType 1000059000 + +pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR = + VkStructureType 1000059001 + +pattern VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR = + VkStructureType 1000059002 + +pattern VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2_KHR :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2_KHR = + VkStructureType 1000059003 + +pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHR + :: VkStructureType + +pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHR = + VkStructureType 1000059004 + +pattern VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2_KHR :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2_KHR = + VkStructureType 1000059005 + +pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2_KHR + :: VkStructureType + +pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2_KHR = + VkStructureType 1000059006 + +pattern VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2_KHR :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2_KHR = + VkStructureType 1000059007 + +pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2_KHR + :: VkStructureType + +pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2_KHR + = VkStructureType 1000059008 diff --git a/src-gen/Graphics/Vulkan/Ext/VK_KHR_get_surface_capabilities2.hs b/src-gen/Graphics/Vulkan/Ext/VK_KHR_get_surface_capabilities2.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Ext/VK_KHR_get_surface_capabilities2.hs @@ -0,0 +1,159 @@ +{-# OPTIONS_HADDOCK not-home#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE ForeignFunctionInterface #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE ViewPatterns #-} +module Graphics.Vulkan.Ext.VK_KHR_get_surface_capabilities2 + (-- * Vulkan extension: @VK_KHR_get_surface_capabilities2@ + -- | + -- + -- supported: @vulkan@ + -- + -- contact: @James Jones @cubanismo@ + -- + -- author: @KHR@ + -- + -- type: @instance@ + -- + -- Extension number: @120@ + -- + -- Required extensions: 'VK_KHR_surface'. + -- + + -- ** Required extensions: 'VK_KHR_surface'. + module Graphics.Vulkan.Types.Enum.VkColorSpaceKHR, + module Graphics.Vulkan.Types.Enum.VkCompositeAlphaFlagsKHR, + module Graphics.Vulkan.Types.Struct.VkExtent2D, + module Graphics.Vulkan.Types.BaseTypes, + module Graphics.Vulkan.Types.Enum.VkFormat, + module Graphics.Vulkan.Types.Enum.VkImageUsageFlags, + module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceSurfaceInfo2KHR, + module Graphics.Vulkan.Types.Enum.VkStructureType, + module Graphics.Vulkan.Types.Struct.VkSurfaceCapabilities2KHR, + module Graphics.Vulkan.Types.Struct.VkSurfaceCapabilitiesKHR, + module Graphics.Vulkan.Types.Struct.VkSurfaceFormat2KHR, + module Graphics.Vulkan.Types.Struct.VkSurfaceFormatKHR, + module Graphics.Vulkan.Types.Enum.VkSurfaceTransformFlagsKHR, + -- > #include "vk_platform.h" + vkGetPhysicalDeviceSurfaceCapabilities2KHR, + vkGetPhysicalDeviceSurfaceFormats2KHR, + module Graphics.Vulkan.Marshal, + module Graphics.Vulkan.Types.Enum.VkResult, + module Graphics.Vulkan.Types.Handles, + VK_KHR_GET_SURFACE_CAPABILITIES_2_SPEC_VERSION, + pattern VK_KHR_GET_SURFACE_CAPABILITIES_2_SPEC_VERSION, + VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME, + pattern VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME, + pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR, + pattern VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR, + pattern VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR) + where +import GHC.Ptr (Ptr (..)) +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Types.BaseTypes +import Graphics.Vulkan.Types.Enum.VkColorSpaceKHR +import Graphics.Vulkan.Types.Enum.VkCompositeAlphaFlagsKHR +import Graphics.Vulkan.Types.Enum.VkFormat +import Graphics.Vulkan.Types.Enum.VkImageUsageFlags +import Graphics.Vulkan.Types.Enum.VkResult +import Graphics.Vulkan.Types.Enum.VkStructureType +import Graphics.Vulkan.Types.Enum.VkSurfaceTransformFlagsKHR +import Graphics.Vulkan.Types.Handles +import Graphics.Vulkan.Types.Struct.VkExtent2D +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceSurfaceInfo2KHR +import Graphics.Vulkan.Types.Struct.VkSurfaceCapabilities2KHR +import Graphics.Vulkan.Types.Struct.VkSurfaceCapabilitiesKHR +import Graphics.Vulkan.Types.Struct.VkSurfaceFormat2KHR +import Graphics.Vulkan.Types.Struct.VkSurfaceFormatKHR + +-- | Success codes: 'VK_SUCCESS'. +-- +-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_SURFACE_LOST_KHR'. +-- +-- > VkResult vkGetPhysicalDeviceSurfaceCapabilities2KHR +-- > ( VkPhysicalDevice physicalDevice +-- > , const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo +-- > , VkSurfaceCapabilities2KHR* pSurfaceCapabilities +-- > ) +-- +-- +foreign import ccall unsafe + "vkGetPhysicalDeviceSurfaceCapabilities2KHR" + vkGetPhysicalDeviceSurfaceCapabilities2KHR :: + VkPhysicalDevice -- ^ physicalDevice + -> + Ptr VkPhysicalDeviceSurfaceInfo2KHR -- ^ pSurfaceInfo + -> + Ptr VkSurfaceCapabilities2KHR -- ^ pSurfaceCapabilities + -> IO VkResult + +-- | Success codes: 'VK_SUCCESS', 'VK_INCOMPLETE'. +-- +-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_SURFACE_LOST_KHR'. +-- +-- > VkResult vkGetPhysicalDeviceSurfaceFormats2KHR +-- > ( VkPhysicalDevice physicalDevice +-- > , const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo +-- > , uint32_t* pSurfaceFormatCount +-- > , VkSurfaceFormat2KHR* pSurfaceFormats +-- > ) +-- +-- +foreign import ccall unsafe "vkGetPhysicalDeviceSurfaceFormats2KHR" + vkGetPhysicalDeviceSurfaceFormats2KHR :: + VkPhysicalDevice -- ^ physicalDevice + -> + Ptr VkPhysicalDeviceSurfaceInfo2KHR -- ^ pSurfaceInfo + -> + Ptr Word32 -- ^ pSurfaceFormatCount + -> Ptr VkSurfaceFormat2KHR -- ^ pSurfaceFormats + -> IO VkResult + +pattern VK_KHR_GET_SURFACE_CAPABILITIES_2_SPEC_VERSION :: + (Num a, Eq a) => a + +pattern VK_KHR_GET_SURFACE_CAPABILITIES_2_SPEC_VERSION = 1 + +type VK_KHR_GET_SURFACE_CAPABILITIES_2_SPEC_VERSION = 1 + +pattern VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME :: CString + +pattern VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME <- + (is_VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME -> True) + where VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME + = _VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME + +{-# INLINE _VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME #-} + +_VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME :: CString +_VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME + = Ptr "VK_KHR_get_surface_capabilities2\NUL"# + +{-# INLINE is_VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME #-} + +is_VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME :: + CString -> Bool +is_VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME + = eqCStrings _VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME + +type VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME = + "VK_KHR_get_surface_capabilities2" + +pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR = + VkStructureType 1000119000 + +pattern VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR = + VkStructureType 1000119001 + +pattern VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR :: VkStructureType + +pattern VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR = + VkStructureType 1000119002 diff --git a/src-gen/Graphics/Vulkan/Ext/VK_KHR_image_format_list.hs b/src-gen/Graphics/Vulkan/Ext/VK_KHR_image_format_list.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Ext/VK_KHR_image_format_list.hs @@ -0,0 +1,88 @@ +{-# OPTIONS_HADDOCK not-home#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE ViewPatterns #-} +module Graphics.Vulkan.Ext.VK_KHR_image_format_list + (-- * Vulkan extension: @VK_KHR_image_format_list@ + -- | + -- + -- supported: @vulkan@ + -- + -- contact: @Jason Ekstrand @jekstrand@ + -- + -- author: @KHR@ + -- + -- type: @device@ + -- + -- Extension number: @148@ + module Graphics.Vulkan.Types.Struct.VkExtent3D, + module Graphics.Vulkan.Types.BaseTypes, + module Graphics.Vulkan.Types.Enum.VkFormat, + module Graphics.Vulkan.Types.Enum.VkImageCreateFlags, + module Graphics.Vulkan.Types.Struct.VkImageCreateInfo, + module Graphics.Vulkan.Types.Struct.VkImageFormatListCreateInfoKHR, + module Graphics.Vulkan.Types.Enum.VkImageLayout, + module Graphics.Vulkan.Types.Enum.VkImageTiling, + module Graphics.Vulkan.Types.Enum.VkImageType, + module Graphics.Vulkan.Types.Enum.VkImageUsageFlags, + module Graphics.Vulkan.Types.Enum.VkSampleCountFlags, + module Graphics.Vulkan.Types.Enum.VkSharingMode, + module Graphics.Vulkan.Types.Enum.VkStructureType, + -- > #include "vk_platform.h" + VK_KHR_IMAGE_FORMAT_LIST_SPEC_VERSION, + pattern VK_KHR_IMAGE_FORMAT_LIST_SPEC_VERSION, + VK_KHR_IMAGE_FORMAT_LIST_EXTENSION_NAME, + pattern VK_KHR_IMAGE_FORMAT_LIST_EXTENSION_NAME, + pattern VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO_KHR) + where +import GHC.Ptr (Ptr (..)) +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Types.BaseTypes +import Graphics.Vulkan.Types.Enum.VkFormat +import Graphics.Vulkan.Types.Enum.VkImageCreateFlags +import Graphics.Vulkan.Types.Enum.VkImageLayout +import Graphics.Vulkan.Types.Enum.VkImageTiling +import Graphics.Vulkan.Types.Enum.VkImageType +import Graphics.Vulkan.Types.Enum.VkImageUsageFlags +import Graphics.Vulkan.Types.Enum.VkSampleCountFlags +import Graphics.Vulkan.Types.Enum.VkSharingMode +import Graphics.Vulkan.Types.Enum.VkStructureType +import Graphics.Vulkan.Types.Struct.VkExtent3D +import Graphics.Vulkan.Types.Struct.VkImageCreateInfo +import Graphics.Vulkan.Types.Struct.VkImageFormatListCreateInfoKHR + +pattern VK_KHR_IMAGE_FORMAT_LIST_SPEC_VERSION :: (Num a, Eq a) => a + +pattern VK_KHR_IMAGE_FORMAT_LIST_SPEC_VERSION = 1 + +type VK_KHR_IMAGE_FORMAT_LIST_SPEC_VERSION = 1 + +pattern VK_KHR_IMAGE_FORMAT_LIST_EXTENSION_NAME :: CString + +pattern VK_KHR_IMAGE_FORMAT_LIST_EXTENSION_NAME <- + (is_VK_KHR_IMAGE_FORMAT_LIST_EXTENSION_NAME -> True) + where VK_KHR_IMAGE_FORMAT_LIST_EXTENSION_NAME + = _VK_KHR_IMAGE_FORMAT_LIST_EXTENSION_NAME + +{-# INLINE _VK_KHR_IMAGE_FORMAT_LIST_EXTENSION_NAME #-} + +_VK_KHR_IMAGE_FORMAT_LIST_EXTENSION_NAME :: CString +_VK_KHR_IMAGE_FORMAT_LIST_EXTENSION_NAME + = Ptr "VK_KHR_image_format_list\NUL"# + +{-# INLINE is_VK_KHR_IMAGE_FORMAT_LIST_EXTENSION_NAME #-} + +is_VK_KHR_IMAGE_FORMAT_LIST_EXTENSION_NAME :: CString -> Bool +is_VK_KHR_IMAGE_FORMAT_LIST_EXTENSION_NAME + = eqCStrings _VK_KHR_IMAGE_FORMAT_LIST_EXTENSION_NAME + +type VK_KHR_IMAGE_FORMAT_LIST_EXTENSION_NAME = + "VK_KHR_image_format_list" + +pattern VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO_KHR :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO_KHR = + VkStructureType 1000147000 diff --git a/src-gen/Graphics/Vulkan/Ext/VK_KHR_incremental_present.hs b/src-gen/Graphics/Vulkan/Ext/VK_KHR_incremental_present.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Ext/VK_KHR_incremental_present.hs @@ -0,0 +1,83 @@ +{-# OPTIONS_HADDOCK not-home#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE ViewPatterns #-} +module Graphics.Vulkan.Ext.VK_KHR_incremental_present + (-- * Vulkan extension: @VK_KHR_incremental_present@ + -- | + -- + -- supported: @vulkan@ + -- + -- contact: @Ian Elliott ianelliott@google.com@ + -- + -- author: @KHR@ + -- + -- type: @device@ + -- + -- Extension number: @85@ + -- + -- Required extensions: 'VK_KHR_swapchain'. + -- + + -- ** Required extensions: 'VK_KHR_swapchain'. + module Graphics.Vulkan.Types.Struct.VkExtent2D, + module Graphics.Vulkan.Types.Struct.VkOffset2D, + module Graphics.Vulkan.Types.Struct.VkPresentInfoKHR, + module Graphics.Vulkan.Types.Struct.VkPresentRegionKHR, + module Graphics.Vulkan.Types.Struct.VkPresentRegionsKHR, + module Graphics.Vulkan.Types.Struct.VkRectLayerKHR, + module Graphics.Vulkan.Types.Enum.VkResult, + module Graphics.Vulkan.Types.Enum.VkStructureType, + -- > #include "vk_platform.h" + VK_KHR_INCREMENTAL_PRESENT_SPEC_VERSION, + pattern VK_KHR_INCREMENTAL_PRESENT_SPEC_VERSION, + VK_KHR_INCREMENTAL_PRESENT_EXTENSION_NAME, + pattern VK_KHR_INCREMENTAL_PRESENT_EXTENSION_NAME, + pattern VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR) + where +import GHC.Ptr (Ptr (..)) +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Types.Enum.VkResult +import Graphics.Vulkan.Types.Enum.VkStructureType +import Graphics.Vulkan.Types.Struct.VkExtent2D +import Graphics.Vulkan.Types.Struct.VkOffset2D +import Graphics.Vulkan.Types.Struct.VkPresentInfoKHR +import Graphics.Vulkan.Types.Struct.VkPresentRegionKHR +import Graphics.Vulkan.Types.Struct.VkPresentRegionsKHR +import Graphics.Vulkan.Types.Struct.VkRectLayerKHR + +pattern VK_KHR_INCREMENTAL_PRESENT_SPEC_VERSION :: (Num a, Eq a) => + a + +pattern VK_KHR_INCREMENTAL_PRESENT_SPEC_VERSION = 1 + +type VK_KHR_INCREMENTAL_PRESENT_SPEC_VERSION = 1 + +pattern VK_KHR_INCREMENTAL_PRESENT_EXTENSION_NAME :: CString + +pattern VK_KHR_INCREMENTAL_PRESENT_EXTENSION_NAME <- + (is_VK_KHR_INCREMENTAL_PRESENT_EXTENSION_NAME -> True) + where VK_KHR_INCREMENTAL_PRESENT_EXTENSION_NAME + = _VK_KHR_INCREMENTAL_PRESENT_EXTENSION_NAME + +{-# INLINE _VK_KHR_INCREMENTAL_PRESENT_EXTENSION_NAME #-} + +_VK_KHR_INCREMENTAL_PRESENT_EXTENSION_NAME :: CString +_VK_KHR_INCREMENTAL_PRESENT_EXTENSION_NAME + = Ptr "VK_KHR_incremental_present\NUL"# + +{-# INLINE is_VK_KHR_INCREMENTAL_PRESENT_EXTENSION_NAME #-} + +is_VK_KHR_INCREMENTAL_PRESENT_EXTENSION_NAME :: CString -> Bool +is_VK_KHR_INCREMENTAL_PRESENT_EXTENSION_NAME + = eqCStrings _VK_KHR_INCREMENTAL_PRESENT_EXTENSION_NAME + +type VK_KHR_INCREMENTAL_PRESENT_EXTENSION_NAME = + "VK_KHR_incremental_present" + +pattern VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR :: VkStructureType + +pattern VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR = + VkStructureType 1000084000 diff --git a/src-gen/Graphics/Vulkan/Ext/VK_KHR_maintenance1.hs b/src-gen/Graphics/Vulkan/Ext/VK_KHR_maintenance1.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Ext/VK_KHR_maintenance1.hs @@ -0,0 +1,116 @@ +{-# OPTIONS_GHC -fno-warn-unused-imports#-} +{-# OPTIONS_HADDOCK not-home#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE ForeignFunctionInterface #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE ViewPatterns #-} +module Graphics.Vulkan.Ext.VK_KHR_maintenance1 + (-- * Vulkan extension: @VK_KHR_maintenance1@ + -- | + -- + -- supported: @vulkan@ + -- + -- contact: @Piers Daniell @pdaniell@ + -- + -- author: @KHR@ + -- + -- type: @device@ + -- + -- Extension number: @70@ + vkTrimCommandPoolKHR, module Graphics.Vulkan.Marshal, + module Graphics.Vulkan.Types.BaseTypes, + module Graphics.Vulkan.Types.Bitmasks, + module Graphics.Vulkan.Types.Handles, + VK_KHR_MAINTENANCE1_SPEC_VERSION, + pattern VK_KHR_MAINTENANCE1_SPEC_VERSION, + VK_KHR_MAINTENANCE1_EXTENSION_NAME, + pattern VK_KHR_MAINTENANCE1_EXTENSION_NAME, + pattern VK_ERROR_OUT_OF_POOL_MEMORY_KHR, + pattern VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR, + pattern VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR, + pattern VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR) + where +import GHC.Ptr (Ptr (..)) +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Types.BaseTypes +import Graphics.Vulkan.Types.Bitmasks +import Graphics.Vulkan.Types.Enum.VkFormatFeatureFlags (VkFormatFeatureBitmask (..), + VkFormatFeatureFlagBits) +import Graphics.Vulkan.Types.Enum.VkImageCreateFlags (VkImageCreateBitmask (..), + VkImageCreateFlagBits) +import Graphics.Vulkan.Types.Enum.VkResult (VkResult (..)) +import Graphics.Vulkan.Types.Handles + +-- | > () vkTrimCommandPoolKHR +-- > ( VkDevice device +-- > , VkCommandPool commandPool +-- > , VkCommandPoolTrimFlagsKHR flags +-- > ) +-- +-- +foreign import ccall unsafe "vkTrimCommandPoolKHR" + vkTrimCommandPoolKHR :: + VkDevice -- ^ device + -> VkCommandPool -- ^ commandPool + -> VkCommandPoolTrimFlagsKHR -- ^ flags + -> IO () + +pattern VK_KHR_MAINTENANCE1_SPEC_VERSION :: (Num a, Eq a) => a + +pattern VK_KHR_MAINTENANCE1_SPEC_VERSION = 1 + +type VK_KHR_MAINTENANCE1_SPEC_VERSION = 1 + +pattern VK_KHR_MAINTENANCE1_EXTENSION_NAME :: CString + +pattern VK_KHR_MAINTENANCE1_EXTENSION_NAME <- + (is_VK_KHR_MAINTENANCE1_EXTENSION_NAME -> True) + where VK_KHR_MAINTENANCE1_EXTENSION_NAME + = _VK_KHR_MAINTENANCE1_EXTENSION_NAME + +{-# INLINE _VK_KHR_MAINTENANCE1_EXTENSION_NAME #-} + +_VK_KHR_MAINTENANCE1_EXTENSION_NAME :: CString +_VK_KHR_MAINTENANCE1_EXTENSION_NAME + = Ptr "VK_KHR_maintenance1\NUL"# + +{-# INLINE is_VK_KHR_MAINTENANCE1_EXTENSION_NAME #-} + +is_VK_KHR_MAINTENANCE1_EXTENSION_NAME :: CString -> Bool +is_VK_KHR_MAINTENANCE1_EXTENSION_NAME + = eqCStrings _VK_KHR_MAINTENANCE1_EXTENSION_NAME + +type VK_KHR_MAINTENANCE1_EXTENSION_NAME = "VK_KHR_maintenance1" + +pattern VK_ERROR_OUT_OF_POOL_MEMORY_KHR :: VkResult + +pattern VK_ERROR_OUT_OF_POOL_MEMORY_KHR = VkResult (-1000069000) + +-- | Format can be used as the source image of image transfer commands +-- +-- bitpos = @14@ +pattern VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR :: + VkFormatFeatureFlagBits + +pattern VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR = + VkFormatFeatureFlagBits 16384 + +-- | Format can be used as the destination image of image transfer commands +-- +-- bitpos = @15@ +pattern VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR :: + VkFormatFeatureFlagBits + +pattern VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR = + VkFormatFeatureFlagBits 32768 + +-- | The 3D image can be viewed as a 2D or 2D array image +-- +-- bitpos = @5@ +pattern VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR :: + VkImageCreateFlagBits + +pattern VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR = + VkImageCreateFlagBits 32 diff --git a/src-gen/Graphics/Vulkan/Ext/VK_KHR_maintenance2.hs b/src-gen/Graphics/Vulkan/Ext/VK_KHR_maintenance2.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Ext/VK_KHR_maintenance2.hs @@ -0,0 +1,195 @@ +{-# OPTIONS_HADDOCK not-home#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE ViewPatterns #-} +module Graphics.Vulkan.Ext.VK_KHR_maintenance2 + (-- * Vulkan extension: @VK_KHR_maintenance2@ + -- | + -- + -- supported: @vulkan@ + -- + -- contact: @Michael Worcester @michaelworcester@ + -- + -- author: @KHR@ + -- + -- type: @device@ + -- + -- Extension number: @118@ + module Graphics.Vulkan.Marshal, + module Graphics.Vulkan.Types.Enum.VkAccessFlags, + module Graphics.Vulkan.Types.Struct.VkAttachmentDescription, + module Graphics.Vulkan.Types.Enum.VkAttachmentDescriptionFlags, + module Graphics.Vulkan.Types.Enum.VkAttachmentLoadOp, + module Graphics.Vulkan.Types.Struct.VkAttachmentReference, + module Graphics.Vulkan.Types.Enum.VkAttachmentStoreOp, + module Graphics.Vulkan.Types.BaseTypes, + module Graphics.Vulkan.Types.Struct.VkComponentMapping, + module Graphics.Vulkan.Types.Enum.VkComponentSwizzle, + module Graphics.Vulkan.Types.Enum.VkDependencyFlags, + module Graphics.Vulkan.Types.Enum.VkFormat, + module Graphics.Vulkan.Types.Enum.VkImageAspectFlags, + module Graphics.Vulkan.Types.Enum.VkImageLayout, + module Graphics.Vulkan.Types.Struct.VkImageSubresourceRange, + module Graphics.Vulkan.Types.Enum.VkImageUsageFlags, + module Graphics.Vulkan.Types.Bitmasks, + module Graphics.Vulkan.Types.Struct.VkImageViewCreateInfo, + module Graphics.Vulkan.Types.Enum.VkImageViewType, + module Graphics.Vulkan.Types.Struct.VkImageViewUsageCreateInfoKHR, + module Graphics.Vulkan.Types.Struct.VkInputAttachmentAspectReferenceKHR, + module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceLimits, + module Graphics.Vulkan.Types.Struct.VkPhysicalDevicePointClippingPropertiesKHR, + module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceProperties, + module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceProperties2KHR, + module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceSparseProperties, + module Graphics.Vulkan.Types.Enum.VkPhysicalDeviceType, + module Graphics.Vulkan.Types.Enum.VkPipelineBindPoint, + module Graphics.Vulkan.Types.Enum.VkPipelineStageFlags, + module Graphics.Vulkan.Types.Struct.VkPipelineTessellationDomainOriginStateCreateInfoKHR, + module Graphics.Vulkan.Types.Struct.VkPipelineTessellationStateCreateInfo, + module Graphics.Vulkan.Types.Enum.VkPointClippingBehaviorKHR, + module Graphics.Vulkan.Types.Struct.VkRenderPassCreateInfo, + module Graphics.Vulkan.Types.Struct.VkRenderPassInputAttachmentAspectCreateInfoKHR, + module Graphics.Vulkan.Types.Enum.VkSampleCountFlags, + module Graphics.Vulkan.Types.Enum.VkStructureType, + module Graphics.Vulkan.Types.Struct.VkSubpassDependency, + module Graphics.Vulkan.Types.Struct.VkSubpassDescription, + module Graphics.Vulkan.Types.Enum.VkSubpassDescriptionFlags, + module Graphics.Vulkan.Types.Enum.VkTessellationDomainOriginKHR, + -- > #include "vk_platform.h" + VK_KHR_MAINTENANCE2_SPEC_VERSION, + pattern VK_KHR_MAINTENANCE2_SPEC_VERSION, + VK_KHR_MAINTENANCE2_EXTENSION_NAME, + pattern VK_KHR_MAINTENANCE2_EXTENSION_NAME, + pattern VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT_KHR, + pattern VK_IMAGE_CREATE_EXTENDED_USAGE_BIT_KHR, + pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES_KHR, + pattern VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO_KHR, + pattern VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO_KHR, + pattern VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO_KHR, + pattern VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR, + pattern VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL_KHR) + where +import GHC.Ptr + (Ptr (..)) +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Types.BaseTypes +import Graphics.Vulkan.Types.Bitmasks +import Graphics.Vulkan.Types.Enum.VkAccessFlags +import Graphics.Vulkan.Types.Enum.VkAttachmentDescriptionFlags +import Graphics.Vulkan.Types.Enum.VkAttachmentLoadOp +import Graphics.Vulkan.Types.Enum.VkAttachmentStoreOp +import Graphics.Vulkan.Types.Enum.VkComponentSwizzle +import Graphics.Vulkan.Types.Enum.VkDependencyFlags +import Graphics.Vulkan.Types.Enum.VkFormat +import Graphics.Vulkan.Types.Enum.VkImageAspectFlags +import Graphics.Vulkan.Types.Enum.VkImageCreateFlags + (VkImageCreateBitmask (..), + VkImageCreateFlagBits) +import Graphics.Vulkan.Types.Enum.VkImageLayout +import Graphics.Vulkan.Types.Enum.VkImageUsageFlags +import Graphics.Vulkan.Types.Enum.VkImageViewType +import Graphics.Vulkan.Types.Enum.VkPhysicalDeviceType +import Graphics.Vulkan.Types.Enum.VkPipelineBindPoint +import Graphics.Vulkan.Types.Enum.VkPipelineStageFlags +import Graphics.Vulkan.Types.Enum.VkPointClippingBehaviorKHR +import Graphics.Vulkan.Types.Enum.VkSampleCountFlags +import Graphics.Vulkan.Types.Enum.VkStructureType +import Graphics.Vulkan.Types.Enum.VkSubpassDescriptionFlags +import Graphics.Vulkan.Types.Enum.VkTessellationDomainOriginKHR +import Graphics.Vulkan.Types.Struct.VkAttachmentDescription +import Graphics.Vulkan.Types.Struct.VkAttachmentReference +import Graphics.Vulkan.Types.Struct.VkComponentMapping +import Graphics.Vulkan.Types.Struct.VkImageSubresourceRange +import Graphics.Vulkan.Types.Struct.VkImageViewCreateInfo +import Graphics.Vulkan.Types.Struct.VkImageViewUsageCreateInfoKHR +import Graphics.Vulkan.Types.Struct.VkInputAttachmentAspectReferenceKHR +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceLimits +import Graphics.Vulkan.Types.Struct.VkPhysicalDevicePointClippingPropertiesKHR +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceProperties +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceProperties2KHR +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceSparseProperties +import Graphics.Vulkan.Types.Struct.VkPipelineTessellationDomainOriginStateCreateInfoKHR +import Graphics.Vulkan.Types.Struct.VkPipelineTessellationStateCreateInfo +import Graphics.Vulkan.Types.Struct.VkRenderPassCreateInfo +import Graphics.Vulkan.Types.Struct.VkRenderPassInputAttachmentAspectCreateInfoKHR +import Graphics.Vulkan.Types.Struct.VkSubpassDependency +import Graphics.Vulkan.Types.Struct.VkSubpassDescription + +pattern VK_KHR_MAINTENANCE2_SPEC_VERSION :: (Num a, Eq a) => a + +pattern VK_KHR_MAINTENANCE2_SPEC_VERSION = 1 + +type VK_KHR_MAINTENANCE2_SPEC_VERSION = 1 + +pattern VK_KHR_MAINTENANCE2_EXTENSION_NAME :: CString + +pattern VK_KHR_MAINTENANCE2_EXTENSION_NAME <- + (is_VK_KHR_MAINTENANCE2_EXTENSION_NAME -> True) + where VK_KHR_MAINTENANCE2_EXTENSION_NAME + = _VK_KHR_MAINTENANCE2_EXTENSION_NAME + +{-# INLINE _VK_KHR_MAINTENANCE2_EXTENSION_NAME #-} + +_VK_KHR_MAINTENANCE2_EXTENSION_NAME :: CString +_VK_KHR_MAINTENANCE2_EXTENSION_NAME + = Ptr "VK_KHR_maintenance2\NUL"# + +{-# INLINE is_VK_KHR_MAINTENANCE2_EXTENSION_NAME #-} + +is_VK_KHR_MAINTENANCE2_EXTENSION_NAME :: CString -> Bool +is_VK_KHR_MAINTENANCE2_EXTENSION_NAME + = eqCStrings _VK_KHR_MAINTENANCE2_EXTENSION_NAME + +type VK_KHR_MAINTENANCE2_EXTENSION_NAME = "VK_KHR_maintenance2" + +-- | bitpos = @7@ +pattern VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT_KHR :: + VkImageCreateFlagBits + +pattern VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT_KHR = + VkImageCreateFlagBits 128 + +-- | bitpos = @8@ +pattern VK_IMAGE_CREATE_EXTENDED_USAGE_BIT_KHR :: + VkImageCreateFlagBits + +pattern VK_IMAGE_CREATE_EXTENDED_USAGE_BIT_KHR = + VkImageCreateFlagBits 256 + +pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES_KHR + :: VkStructureType + +pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES_KHR + = VkStructureType 1000117000 + +pattern VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO_KHR + :: VkStructureType + +pattern VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO_KHR + = VkStructureType 1000117001 + +pattern VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO_KHR :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO_KHR = + VkStructureType 1000117002 + +pattern VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO_KHR + :: VkStructureType + +pattern VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO_KHR + = VkStructureType 1000117003 + +pattern VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR + :: VkImageLayout + +pattern VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR + = VkImageLayout 1000117000 + +pattern VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL_KHR + :: VkImageLayout + +pattern VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL_KHR + = VkImageLayout 1000117001 diff --git a/src-gen/Graphics/Vulkan/Ext/VK_KHR_mir_surface.hs b/src-gen/Graphics/Vulkan/Ext/VK_KHR_mir_surface.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Ext/VK_KHR_mir_surface.hs @@ -0,0 +1,132 @@ +{-# OPTIONS_HADDOCK not-home#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE ForeignFunctionInterface #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE ViewPatterns #-} +module Graphics.Vulkan.Ext.VK_KHR_mir_surface + (-- * Vulkan extension: @VK_KHR_mir_surface@ + -- | + -- + -- supported: @vulkan@ + -- + -- contact: @Jesse Hall @jessehall,Ian Elliott ianelliott@google.com@ + -- + -- author: @KHR@ + -- + -- type: @instance@ + -- + -- Extension number: @8@ + -- + -- Required extensions: 'VK_KHR_surface'. + -- + -- Protected by CPP ifdef: @VK_USE_PLATFORM_MIR_KHR@ + -- + + -- ** Required extensions: 'VK_KHR_surface'. + module Graphics.Vulkan.Types.BaseTypes, + module Graphics.Vulkan.Types.Bitmasks, + module Graphics.Vulkan.Types.Struct.VkMirSurfaceCreateInfoKHR, + module Graphics.Vulkan.Types.Enum.VkStructureType, + -- > #include "vk_platform.h" + -- + -- > #include + vkCreateMirSurfaceKHR, + vkGetPhysicalDeviceMirPresentationSupportKHR, + module Graphics.Vulkan.Marshal, + module Graphics.Vulkan.Types.Enum.VkInternalAllocationType, + module Graphics.Vulkan.Types.Enum.VkResult, + module Graphics.Vulkan.Types.Enum.VkSystemAllocationScope, + module Graphics.Vulkan.Types.Funcpointers, + module Graphics.Vulkan.Types.Handles, + module Graphics.Vulkan.Types.Include, + module Graphics.Vulkan.Types.Struct.VkAllocationCallbacks, + VK_KHR_MIR_SURFACE_SPEC_VERSION, + pattern VK_KHR_MIR_SURFACE_SPEC_VERSION, + VK_KHR_MIR_SURFACE_EXTENSION_NAME, + pattern VK_KHR_MIR_SURFACE_EXTENSION_NAME, + pattern VK_STRUCTURE_TYPE_MIR_SURFACE_CREATE_INFO_KHR) + where +import GHC.Ptr (Ptr (..)) +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Types.BaseTypes +import Graphics.Vulkan.Types.Bitmasks +import Graphics.Vulkan.Types.Enum.VkInternalAllocationType +import Graphics.Vulkan.Types.Enum.VkResult +import Graphics.Vulkan.Types.Enum.VkStructureType +import Graphics.Vulkan.Types.Enum.VkSystemAllocationScope +import Graphics.Vulkan.Types.Funcpointers +import Graphics.Vulkan.Types.Handles +import Graphics.Vulkan.Types.Include +import Graphics.Vulkan.Types.Struct.VkAllocationCallbacks +import Graphics.Vulkan.Types.Struct.VkMirSurfaceCreateInfoKHR + +-- | Success codes: 'VK_SUCCESS'. +-- +-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. +-- +-- > VkResult vkCreateMirSurfaceKHR +-- > ( VkInstance instance +-- > , const VkMirSurfaceCreateInfoKHR* pCreateInfo +-- > , const VkAllocationCallbacks* pAllocator +-- > , VkSurfaceKHR* pSurface +-- > ) +-- +-- +foreign import ccall unsafe "vkCreateMirSurfaceKHR" + vkCreateMirSurfaceKHR :: + VkInstance -- ^ instance + -> + Ptr VkMirSurfaceCreateInfoKHR -- ^ pCreateInfo + -> + Ptr VkAllocationCallbacks -- ^ pAllocator + -> Ptr VkSurfaceKHR -- ^ pSurface + -> IO VkResult + +-- | > VkBool32 vkGetPhysicalDeviceMirPresentationSupportKHR +-- > ( VkPhysicalDevice physicalDevice +-- > , uint32_t queueFamilyIndex +-- > , MirConnection* connection +-- > ) +-- +-- +foreign import ccall unsafe + "vkGetPhysicalDeviceMirPresentationSupportKHR" + vkGetPhysicalDeviceMirPresentationSupportKHR :: + VkPhysicalDevice -- ^ physicalDevice + -> Word32 -- ^ queueFamilyIndex + -> Ptr MirConnection -- ^ connection + -> IO VkBool32 + +pattern VK_KHR_MIR_SURFACE_SPEC_VERSION :: (Num a, Eq a) => a + +pattern VK_KHR_MIR_SURFACE_SPEC_VERSION = 4 + +type VK_KHR_MIR_SURFACE_SPEC_VERSION = 4 + +pattern VK_KHR_MIR_SURFACE_EXTENSION_NAME :: CString + +pattern VK_KHR_MIR_SURFACE_EXTENSION_NAME <- + (is_VK_KHR_MIR_SURFACE_EXTENSION_NAME -> True) + where VK_KHR_MIR_SURFACE_EXTENSION_NAME + = _VK_KHR_MIR_SURFACE_EXTENSION_NAME + +{-# INLINE _VK_KHR_MIR_SURFACE_EXTENSION_NAME #-} + +_VK_KHR_MIR_SURFACE_EXTENSION_NAME :: CString +_VK_KHR_MIR_SURFACE_EXTENSION_NAME = Ptr "VK_KHR_mir_surface\NUL"# + +{-# INLINE is_VK_KHR_MIR_SURFACE_EXTENSION_NAME #-} + +is_VK_KHR_MIR_SURFACE_EXTENSION_NAME :: CString -> Bool +is_VK_KHR_MIR_SURFACE_EXTENSION_NAME + = eqCStrings _VK_KHR_MIR_SURFACE_EXTENSION_NAME + +type VK_KHR_MIR_SURFACE_EXTENSION_NAME = "VK_KHR_mir_surface" + +pattern VK_STRUCTURE_TYPE_MIR_SURFACE_CREATE_INFO_KHR :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_MIR_SURFACE_CREATE_INFO_KHR = + VkStructureType 1000007000 diff --git a/src-gen/Graphics/Vulkan/Ext/VK_KHR_push_descriptor.hs b/src-gen/Graphics/Vulkan/Ext/VK_KHR_push_descriptor.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Ext/VK_KHR_push_descriptor.hs @@ -0,0 +1,143 @@ +{-# OPTIONS_HADDOCK not-home#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE ForeignFunctionInterface #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE ViewPatterns #-} +module Graphics.Vulkan.Ext.VK_KHR_push_descriptor + (-- * Vulkan extension: @VK_KHR_push_descriptor@ + -- | + -- + -- supported: @vulkan@ + -- + -- contact: @Jeff Bolz @jbolz@ + -- + -- author: @KHR@ + -- + -- type: @device@ + -- + -- Extension number: @81@ + -- + -- Required extensions: 'VK_KHR_get_physical_device_properties2'. + -- + + -- ** Required extensions: 'VK_KHR_get_physical_device_properties2'. + module Graphics.Vulkan.Marshal, + module Graphics.Vulkan.Types.BaseTypes, + module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceLimits, + module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceProperties, + module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceProperties2KHR, + module Graphics.Vulkan.Types.Struct.VkPhysicalDevicePushDescriptorPropertiesKHR, + module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceSparseProperties, + module Graphics.Vulkan.Types.Enum.VkPhysicalDeviceType, + module Graphics.Vulkan.Types.Enum.VkSampleCountFlags, + module Graphics.Vulkan.Types.Enum.VkStructureType, + -- > #include "vk_platform.h" + vkCmdPushDescriptorSetKHR, + module Graphics.Vulkan.Types.Enum.VkDescriptorType, + module Graphics.Vulkan.Types.Enum.VkImageLayout, + module Graphics.Vulkan.Types.Enum.VkPipelineBindPoint, + module Graphics.Vulkan.Types.Handles, + module Graphics.Vulkan.Types.Struct.VkDescriptorBufferInfo, + module Graphics.Vulkan.Types.Struct.VkDescriptorImageInfo, + module Graphics.Vulkan.Types.Struct.VkWriteDescriptorSet, + VK_KHR_PUSH_DESCRIPTOR_SPEC_VERSION, + pattern VK_KHR_PUSH_DESCRIPTOR_SPEC_VERSION, + VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME, + pattern VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME, + pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR, + pattern VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR) + where +import GHC.Ptr + (Ptr (..)) +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Types.BaseTypes +import Graphics.Vulkan.Types.Enum.VkDescriptorSetLayoutCreateFlags + (VkDescriptorSetLayoutCreateBitmask (..), + VkDescriptorSetLayoutCreateFlagBits) +import Graphics.Vulkan.Types.Enum.VkDescriptorType +import Graphics.Vulkan.Types.Enum.VkImageLayout +import Graphics.Vulkan.Types.Enum.VkPhysicalDeviceType +import Graphics.Vulkan.Types.Enum.VkPipelineBindPoint +import Graphics.Vulkan.Types.Enum.VkSampleCountFlags +import Graphics.Vulkan.Types.Enum.VkStructureType +import Graphics.Vulkan.Types.Handles +import Graphics.Vulkan.Types.Struct.VkDescriptorBufferInfo +import Graphics.Vulkan.Types.Struct.VkDescriptorImageInfo +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceLimits +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceProperties +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceProperties2KHR +import Graphics.Vulkan.Types.Struct.VkPhysicalDevicePushDescriptorPropertiesKHR +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceSparseProperties +import Graphics.Vulkan.Types.Struct.VkWriteDescriptorSet + +-- | queues: 'graphics', 'compute'. +-- +-- renderpass: @both@ +-- +-- > () vkCmdPushDescriptorSetKHR +-- > ( VkCommandBuffer commandBuffer +-- > , VkPipelineBindPoint pipelineBindPoint +-- > , VkPipelineLayout layout +-- > , uint32_t set +-- > , uint32_t descriptorWriteCount +-- > , const VkWriteDescriptorSet* pDescriptorWrites +-- > ) +-- +-- +foreign import ccall unsafe "vkCmdPushDescriptorSetKHR" + vkCmdPushDescriptorSetKHR :: + VkCommandBuffer -- ^ commandBuffer + -> + VkPipelineBindPoint -- ^ pipelineBindPoint + -> + VkPipelineLayout -- ^ layout + -> + Word32 -- ^ set + -> Word32 -- ^ descriptorWriteCount + -> Ptr VkWriteDescriptorSet -- ^ pDescriptorWrites + -> IO () + +pattern VK_KHR_PUSH_DESCRIPTOR_SPEC_VERSION :: (Num a, Eq a) => a + +pattern VK_KHR_PUSH_DESCRIPTOR_SPEC_VERSION = 1 + +type VK_KHR_PUSH_DESCRIPTOR_SPEC_VERSION = 1 + +pattern VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME :: CString + +pattern VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME <- + (is_VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME -> True) + where VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME + = _VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME + +{-# INLINE _VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME #-} + +_VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME :: CString +_VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME + = Ptr "VK_KHR_push_descriptor\NUL"# + +{-# INLINE is_VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME #-} + +is_VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME :: CString -> Bool +is_VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME + = eqCStrings _VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME + +type VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME = + "VK_KHR_push_descriptor" + +pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR + :: VkStructureType + +pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR + = VkStructureType 1000080000 + +-- | Descriptors are pushed via flink:vkCmdPushDescriptorSetKHR +-- +-- bitpos = @0@ +pattern VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR :: + VkDescriptorSetLayoutCreateFlagBits + +pattern VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR = + VkDescriptorSetLayoutCreateFlagBits 1 diff --git a/src-gen/Graphics/Vulkan/Ext/VK_KHR_relaxed_block_layout.hs b/src-gen/Graphics/Vulkan/Ext/VK_KHR_relaxed_block_layout.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Ext/VK_KHR_relaxed_block_layout.hs @@ -0,0 +1,55 @@ +{-# OPTIONS_HADDOCK not-home#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE ViewPatterns #-} +module Graphics.Vulkan.Ext.VK_KHR_relaxed_block_layout + (-- * Vulkan extension: @VK_KHR_relaxed_block_layout@ + -- | + -- + -- supported: @vulkan@ + -- + -- contact: @John Kessenich @johnk@ + -- + -- author: @KHR@ + -- + -- type: @device@ + -- + -- Extension number: @145@ + VK_KHR_RELAXED_BLOCK_LAYOUT_SPEC_VERSION, + pattern VK_KHR_RELAXED_BLOCK_LAYOUT_SPEC_VERSION, + VK_KHR_RELAXED_BLOCK_LAYOUT_EXTENSION_NAME, + pattern VK_KHR_RELAXED_BLOCK_LAYOUT_EXTENSION_NAME) + where +import GHC.Ptr (Ptr (..)) +import Graphics.Vulkan.Marshal + +pattern VK_KHR_RELAXED_BLOCK_LAYOUT_SPEC_VERSION :: + (Num a, Eq a) => a + +pattern VK_KHR_RELAXED_BLOCK_LAYOUT_SPEC_VERSION = 1 + +type VK_KHR_RELAXED_BLOCK_LAYOUT_SPEC_VERSION = 1 + +pattern VK_KHR_RELAXED_BLOCK_LAYOUT_EXTENSION_NAME :: CString + +pattern VK_KHR_RELAXED_BLOCK_LAYOUT_EXTENSION_NAME <- + (is_VK_KHR_RELAXED_BLOCK_LAYOUT_EXTENSION_NAME -> True) + where VK_KHR_RELAXED_BLOCK_LAYOUT_EXTENSION_NAME + = _VK_KHR_RELAXED_BLOCK_LAYOUT_EXTENSION_NAME + +{-# INLINE _VK_KHR_RELAXED_BLOCK_LAYOUT_EXTENSION_NAME #-} + +_VK_KHR_RELAXED_BLOCK_LAYOUT_EXTENSION_NAME :: CString +_VK_KHR_RELAXED_BLOCK_LAYOUT_EXTENSION_NAME + = Ptr "VK_KHR_relaxed_block_layout\NUL"# + +{-# INLINE is_VK_KHR_RELAXED_BLOCK_LAYOUT_EXTENSION_NAME #-} + +is_VK_KHR_RELAXED_BLOCK_LAYOUT_EXTENSION_NAME :: CString -> Bool +is_VK_KHR_RELAXED_BLOCK_LAYOUT_EXTENSION_NAME + = eqCStrings _VK_KHR_RELAXED_BLOCK_LAYOUT_EXTENSION_NAME + +type VK_KHR_RELAXED_BLOCK_LAYOUT_EXTENSION_NAME = + "VK_KHR_relaxed_block_layout" diff --git a/src-gen/Graphics/Vulkan/Ext/VK_KHR_sampler_mirror_clamp_to_edge.hs b/src-gen/Graphics/Vulkan/Ext/VK_KHR_sampler_mirror_clamp_to_edge.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Ext/VK_KHR_sampler_mirror_clamp_to_edge.hs @@ -0,0 +1,67 @@ +{-# OPTIONS_HADDOCK not-home#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE ViewPatterns #-} +module Graphics.Vulkan.Ext.VK_KHR_sampler_mirror_clamp_to_edge + (-- * Vulkan extension: @VK_KHR_sampler_mirror_clamp_to_edge@ + -- | + -- + -- supported: @vulkan@ + -- + -- contact: @Tobias Hector @tobias@ + -- + -- author: @KHR@ + -- + -- type: @device@ + -- + -- Extension number: @15@ + VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_SPEC_VERSION, + pattern VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_SPEC_VERSION, + VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_EXTENSION_NAME, + pattern VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_EXTENSION_NAME, + pattern VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE) + where +import GHC.Ptr (Ptr (..)) +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Types.Enum.VkSamplerAddressMode (VkSamplerAddressMode (..)) + +pattern VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_SPEC_VERSION :: + (Num a, Eq a) => a + +pattern VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_SPEC_VERSION = 1 + +type VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_SPEC_VERSION = 1 + +pattern VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_EXTENSION_NAME :: + CString + +pattern VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_EXTENSION_NAME <- + (is_VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_EXTENSION_NAME -> True) + where VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_EXTENSION_NAME + = _VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_EXTENSION_NAME + +{-# INLINE _VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_EXTENSION_NAME #-} + +_VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_EXTENSION_NAME :: CString +_VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_EXTENSION_NAME + = Ptr "VK_KHR_sampler_mirror_clamp_to_edge\NUL"# + +{-# INLINE is_VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_EXTENSION_NAME + #-} + +is_VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_EXTENSION_NAME :: + CString -> Bool +is_VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_EXTENSION_NAME + = eqCStrings _VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_EXTENSION_NAME + +type VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_EXTENSION_NAME = + "VK_KHR_sampler_mirror_clamp_to_edge" + +-- | Note that this defines what was previously a core enum, and so uses the 'value' attribute rather than 'offset', and does not have a suffix. This is a special case, and should not be repeated +pattern VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE :: + VkSamplerAddressMode + +pattern VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE = + VkSamplerAddressMode 4 diff --git a/src-gen/Graphics/Vulkan/Ext/VK_KHR_sampler_ycbcr_conversion.hs b/src-gen/Graphics/Vulkan/Ext/VK_KHR_sampler_ycbcr_conversion.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Ext/VK_KHR_sampler_ycbcr_conversion.hs @@ -0,0 +1,557 @@ +{-# OPTIONS_HADDOCK not-home#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE ForeignFunctionInterface #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE ViewPatterns #-} +module Graphics.Vulkan.Ext.VK_KHR_sampler_ycbcr_conversion + (-- * Vulkan extension: @VK_KHR_sampler_ycbcr_conversion@ + -- | + -- + -- supported: @vulkan@ + -- + -- contact: @Andrew Garrard @fluppeteer@ + -- + -- author: @KHR@ + -- + -- type: @device@ + -- + -- Extension number: @157@ + -- + -- Required extensions: 'VK_KHR_maintenance1', 'VK_KHR_bind_memory2', 'VK_KHR_get_memory_requirements2', 'VK_KHR_get_physical_device_properties2'. + -- + + -- ** Required extensions: 'VK_KHR_maintenance1', 'VK_KHR_bind_memory2', 'VK_KHR_get_memory_requirements2', 'VK_KHR_get_physical_device_properties2'. + module Graphics.Vulkan.Marshal, + module Graphics.Vulkan.Types.Struct.VkBindImageMemoryInfoKHR, + module Graphics.Vulkan.Types.Struct.VkBindImagePlaneMemoryInfoKHR, + module Graphics.Vulkan.Types.BaseTypes, + module Graphics.Vulkan.Types.Enum.VkBorderColor, + module Graphics.Vulkan.Types.Enum.VkChromaLocationKHR, + module Graphics.Vulkan.Types.Enum.VkCompareOp, + module Graphics.Vulkan.Types.Struct.VkComponentMapping, + module Graphics.Vulkan.Types.Enum.VkComponentSwizzle, + module Graphics.Vulkan.Types.Bitmasks, + module Graphics.Vulkan.Types.Struct.VkDeviceCreateInfo, + module Graphics.Vulkan.Types.Struct.VkDeviceQueueCreateInfo, + module Graphics.Vulkan.Types.Struct.VkExtent3D, + module Graphics.Vulkan.Types.Enum.VkFilter, + module Graphics.Vulkan.Types.Enum.VkFormat, + module Graphics.Vulkan.Types.Enum.VkImageAspectFlags, + module Graphics.Vulkan.Types.Struct.VkImageFormatProperties, + module Graphics.Vulkan.Types.Struct.VkImageFormatProperties2KHR, + module Graphics.Vulkan.Types.Struct.VkImageMemoryRequirementsInfo2KHR, + module Graphics.Vulkan.Types.Struct.VkImagePlaneMemoryRequirementsInfoKHR, + module Graphics.Vulkan.Types.Struct.VkImageSubresourceRange, + module Graphics.Vulkan.Types.Struct.VkImageViewCreateInfo, + module Graphics.Vulkan.Types.Enum.VkImageViewType, + module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceFeatures, + module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceFeatures2KHR, + module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR, + module Graphics.Vulkan.Types.Enum.VkSampleCountFlags, + module Graphics.Vulkan.Types.Enum.VkSamplerAddressMode, + module Graphics.Vulkan.Types.Struct.VkSamplerCreateInfo, + module Graphics.Vulkan.Types.Enum.VkSamplerMipmapMode, + module Graphics.Vulkan.Types.Struct.VkSamplerYcbcrConversionCreateInfoKHR, + module Graphics.Vulkan.Types.Struct.VkSamplerYcbcrConversionImageFormatPropertiesKHR, + module Graphics.Vulkan.Types.Struct.VkSamplerYcbcrConversionInfoKHR, + module Graphics.Vulkan.Types.Enum.VkSamplerYcbcrModelConversionKHR, + module Graphics.Vulkan.Types.Enum.VkSamplerYcbcrRangeKHR, + module Graphics.Vulkan.Types.Enum.VkStructureType, + -- > #include "vk_platform.h" + vkCreateSamplerYcbcrConversionKHR, + vkDestroySamplerYcbcrConversionKHR, + module Graphics.Vulkan.Types.Enum.VkInternalAllocationType, + module Graphics.Vulkan.Types.Enum.VkResult, + module Graphics.Vulkan.Types.Enum.VkSystemAllocationScope, + module Graphics.Vulkan.Types.Funcpointers, + module Graphics.Vulkan.Types.Handles, + module Graphics.Vulkan.Types.Struct.VkAllocationCallbacks, + VK_KHR_SAMPLER_YCBCR_CONVERSION_SPEC_VERSION, + pattern VK_KHR_SAMPLER_YCBCR_CONVERSION_SPEC_VERSION, + VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME, + pattern VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME, + pattern VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO_KHR, + pattern VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO_KHR, + pattern VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO_KHR, + pattern VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO_KHR, + pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES_KHR, + pattern VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES_KHR, + pattern VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR_EXT, + pattern VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR, + pattern VK_FORMAT_G8B8G8R8_422_UNORM_KHR, + pattern VK_FORMAT_B8G8R8G8_422_UNORM_KHR, + pattern VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM_KHR, + pattern VK_FORMAT_G8_B8R8_2PLANE_420_UNORM_KHR, + pattern VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM_KHR, + pattern VK_FORMAT_G8_B8R8_2PLANE_422_UNORM_KHR, + pattern VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM_KHR, + pattern VK_FORMAT_R10X6_UNORM_PACK16_KHR, + pattern VK_FORMAT_R10X6G10X6_UNORM_2PACK16_KHR, + pattern VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16_KHR, + pattern VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16_KHR, + pattern VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16_KHR, + pattern VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16_KHR, + pattern VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16_KHR, + pattern VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16_KHR, + pattern VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16_KHR, + pattern VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16_KHR, + pattern VK_FORMAT_R12X4_UNORM_PACK16_KHR, + pattern VK_FORMAT_R12X4G12X4_UNORM_2PACK16_KHR, + pattern VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16_KHR, + pattern VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16_KHR, + pattern VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16_KHR, + pattern VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16_KHR, + pattern VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16_KHR, + pattern VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16_KHR, + pattern VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16_KHR, + pattern VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16_KHR, + pattern VK_FORMAT_G16B16G16R16_422_UNORM_KHR, + pattern VK_FORMAT_B16G16R16G16_422_UNORM_KHR, + pattern VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM_KHR, + pattern VK_FORMAT_G16_B16R16_2PLANE_420_UNORM_KHR, + pattern VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM_KHR, + pattern VK_FORMAT_G16_B16R16_2PLANE_422_UNORM_KHR, + pattern VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM_KHR, + pattern VK_IMAGE_ASPECT_PLANE_0_BIT_KHR, + pattern VK_IMAGE_ASPECT_PLANE_1_BIT_KHR, + pattern VK_IMAGE_ASPECT_PLANE_2_BIT_KHR, + pattern VK_IMAGE_CREATE_DISJOINT_BIT_KHR, + pattern VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT_KHR, + pattern VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT_KHR, + pattern VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT_KHR, + pattern VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT_KHR, + pattern VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT_KHR, + pattern VK_FORMAT_FEATURE_DISJOINT_BIT_KHR, + pattern VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT_KHR) + where +import GHC.Ptr + (Ptr (..)) +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Types.BaseTypes +import Graphics.Vulkan.Types.Bitmasks +import Graphics.Vulkan.Types.Enum.VkBorderColor +import Graphics.Vulkan.Types.Enum.VkChromaLocationKHR +import Graphics.Vulkan.Types.Enum.VkCompareOp +import Graphics.Vulkan.Types.Enum.VkComponentSwizzle +import Graphics.Vulkan.Types.Enum.VkDebugReportObjectTypeEXT + (VkDebugReportObjectTypeEXT (..)) +import Graphics.Vulkan.Types.Enum.VkFilter +import Graphics.Vulkan.Types.Enum.VkFormat +import Graphics.Vulkan.Types.Enum.VkFormatFeatureFlags + (VkFormatFeatureBitmask (..), + VkFormatFeatureFlagBits) +import Graphics.Vulkan.Types.Enum.VkImageAspectFlags +import Graphics.Vulkan.Types.Enum.VkImageCreateFlags + (VkImageCreateBitmask (..), + VkImageCreateFlagBits) +import Graphics.Vulkan.Types.Enum.VkImageViewType +import Graphics.Vulkan.Types.Enum.VkInternalAllocationType +import Graphics.Vulkan.Types.Enum.VkObjectType + (VkObjectType (..)) +import Graphics.Vulkan.Types.Enum.VkResult +import Graphics.Vulkan.Types.Enum.VkSampleCountFlags +import Graphics.Vulkan.Types.Enum.VkSamplerAddressMode +import Graphics.Vulkan.Types.Enum.VkSamplerMipmapMode +import Graphics.Vulkan.Types.Enum.VkSamplerYcbcrModelConversionKHR +import Graphics.Vulkan.Types.Enum.VkSamplerYcbcrRangeKHR +import Graphics.Vulkan.Types.Enum.VkStructureType +import Graphics.Vulkan.Types.Enum.VkSystemAllocationScope +import Graphics.Vulkan.Types.Funcpointers +import Graphics.Vulkan.Types.Handles +import Graphics.Vulkan.Types.Struct.VkAllocationCallbacks +import Graphics.Vulkan.Types.Struct.VkBindImageMemoryInfoKHR +import Graphics.Vulkan.Types.Struct.VkBindImagePlaneMemoryInfoKHR +import Graphics.Vulkan.Types.Struct.VkComponentMapping +import Graphics.Vulkan.Types.Struct.VkDeviceCreateInfo +import Graphics.Vulkan.Types.Struct.VkDeviceQueueCreateInfo +import Graphics.Vulkan.Types.Struct.VkExtent3D +import Graphics.Vulkan.Types.Struct.VkImageFormatProperties +import Graphics.Vulkan.Types.Struct.VkImageFormatProperties2KHR +import Graphics.Vulkan.Types.Struct.VkImageMemoryRequirementsInfo2KHR +import Graphics.Vulkan.Types.Struct.VkImagePlaneMemoryRequirementsInfoKHR +import Graphics.Vulkan.Types.Struct.VkImageSubresourceRange +import Graphics.Vulkan.Types.Struct.VkImageViewCreateInfo +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceFeatures +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceFeatures2KHR +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR +import Graphics.Vulkan.Types.Struct.VkSamplerCreateInfo +import Graphics.Vulkan.Types.Struct.VkSamplerYcbcrConversionCreateInfoKHR +import Graphics.Vulkan.Types.Struct.VkSamplerYcbcrConversionImageFormatPropertiesKHR +import Graphics.Vulkan.Types.Struct.VkSamplerYcbcrConversionInfoKHR + +-- | Success codes: 'VK_SUCCESS'. +-- +-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. +-- +-- > VkResult vkCreateSamplerYcbcrConversionKHR +-- > ( VkDevice device +-- > , const VkSamplerYcbcrConversionCreateInfoKHR* pCreateInfo +-- > , const VkAllocationCallbacks* pAllocator +-- > , VkSamplerYcbcrConversionKHR* pYcbcrConversion +-- > ) +-- +-- +foreign import ccall unsafe "vkCreateSamplerYcbcrConversionKHR" + vkCreateSamplerYcbcrConversionKHR :: + VkDevice -- ^ device + -> + Ptr VkSamplerYcbcrConversionCreateInfoKHR -- ^ pCreateInfo + -> + Ptr VkAllocationCallbacks -- ^ pAllocator + -> + Ptr VkSamplerYcbcrConversionKHR -- ^ pYcbcrConversion + -> IO VkResult + +-- | > () vkDestroySamplerYcbcrConversionKHR +-- > ( VkDevice device +-- > , VkSamplerYcbcrConversionKHR ycbcrConversion +-- > , const VkAllocationCallbacks* pAllocator +-- > ) +-- +-- +foreign import ccall unsafe "vkDestroySamplerYcbcrConversionKHR" + vkDestroySamplerYcbcrConversionKHR :: + VkDevice -- ^ device + -> + VkSamplerYcbcrConversionKHR -- ^ ycbcrConversion + -> Ptr VkAllocationCallbacks -- ^ pAllocator + -> IO () + +pattern VK_KHR_SAMPLER_YCBCR_CONVERSION_SPEC_VERSION :: + (Num a, Eq a) => a + +pattern VK_KHR_SAMPLER_YCBCR_CONVERSION_SPEC_VERSION = 1 + +type VK_KHR_SAMPLER_YCBCR_CONVERSION_SPEC_VERSION = 1 + +pattern VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME :: CString + +pattern VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME <- + (is_VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME -> True) + where VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME + = _VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME + +{-# INLINE _VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME #-} + +_VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME :: CString +_VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME + = Ptr "VK_KHR_sampler_ycbcr_conversion\NUL"# + +{-# INLINE is_VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME #-} + +is_VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME :: + CString -> Bool +is_VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME + = eqCStrings _VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME + +type VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME = + "VK_KHR_sampler_ycbcr_conversion" + +pattern VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO_KHR + :: VkStructureType + +pattern VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO_KHR + = VkStructureType 1000156000 + +pattern VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO_KHR :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO_KHR = + VkStructureType 1000156001 + +pattern VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO_KHR :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO_KHR = + VkStructureType 1000156002 + +pattern VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO_KHR + :: VkStructureType + +pattern VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO_KHR + = VkStructureType 1000156003 + +pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES_KHR + :: VkStructureType + +pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES_KHR + = VkStructureType 1000156004 + +pattern VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES_KHR + :: VkStructureType + +pattern VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES_KHR + = VkStructureType 1000156005 + +pattern VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR_EXT + :: VkDebugReportObjectTypeEXT + +pattern VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR_EXT + = VkDebugReportObjectTypeEXT 1000156000 + +pattern VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR :: VkObjectType + +pattern VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR = + VkObjectType 1000156000 + +pattern VK_FORMAT_G8B8G8R8_422_UNORM_KHR :: VkFormat + +pattern VK_FORMAT_G8B8G8R8_422_UNORM_KHR = VkFormat 1000156000 + +pattern VK_FORMAT_B8G8R8G8_422_UNORM_KHR :: VkFormat + +pattern VK_FORMAT_B8G8R8G8_422_UNORM_KHR = VkFormat 1000156001 + +pattern VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM_KHR :: VkFormat + +pattern VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM_KHR = + VkFormat 1000156002 + +pattern VK_FORMAT_G8_B8R8_2PLANE_420_UNORM_KHR :: VkFormat + +pattern VK_FORMAT_G8_B8R8_2PLANE_420_UNORM_KHR = + VkFormat 1000156003 + +pattern VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM_KHR :: VkFormat + +pattern VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM_KHR = + VkFormat 1000156004 + +pattern VK_FORMAT_G8_B8R8_2PLANE_422_UNORM_KHR :: VkFormat + +pattern VK_FORMAT_G8_B8R8_2PLANE_422_UNORM_KHR = + VkFormat 1000156005 + +pattern VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM_KHR :: VkFormat + +pattern VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM_KHR = + VkFormat 1000156006 + +pattern VK_FORMAT_R10X6_UNORM_PACK16_KHR :: VkFormat + +pattern VK_FORMAT_R10X6_UNORM_PACK16_KHR = VkFormat 1000156007 + +pattern VK_FORMAT_R10X6G10X6_UNORM_2PACK16_KHR :: VkFormat + +pattern VK_FORMAT_R10X6G10X6_UNORM_2PACK16_KHR = + VkFormat 1000156008 + +pattern VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16_KHR :: + VkFormat + +pattern VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16_KHR = + VkFormat 1000156009 + +pattern VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16_KHR :: + VkFormat + +pattern VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16_KHR = + VkFormat 1000156010 + +pattern VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16_KHR :: + VkFormat + +pattern VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16_KHR = + VkFormat 1000156011 + +pattern VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16_KHR :: + VkFormat + +pattern VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16_KHR = + VkFormat 1000156012 + +pattern VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16_KHR :: + VkFormat + +pattern VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16_KHR = + VkFormat 1000156013 + +pattern VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16_KHR :: + VkFormat + +pattern VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16_KHR = + VkFormat 1000156014 + +pattern VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16_KHR :: + VkFormat + +pattern VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16_KHR = + VkFormat 1000156015 + +pattern VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16_KHR :: + VkFormat + +pattern VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16_KHR = + VkFormat 1000156016 + +pattern VK_FORMAT_R12X4_UNORM_PACK16_KHR :: VkFormat + +pattern VK_FORMAT_R12X4_UNORM_PACK16_KHR = VkFormat 1000156017 + +pattern VK_FORMAT_R12X4G12X4_UNORM_2PACK16_KHR :: VkFormat + +pattern VK_FORMAT_R12X4G12X4_UNORM_2PACK16_KHR = + VkFormat 1000156018 + +pattern VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16_KHR :: + VkFormat + +pattern VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16_KHR = + VkFormat 1000156019 + +pattern VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16_KHR :: + VkFormat + +pattern VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16_KHR = + VkFormat 1000156020 + +pattern VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16_KHR :: + VkFormat + +pattern VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16_KHR = + VkFormat 1000156021 + +pattern VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16_KHR :: + VkFormat + +pattern VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16_KHR = + VkFormat 1000156022 + +pattern VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16_KHR :: + VkFormat + +pattern VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16_KHR = + VkFormat 1000156023 + +pattern VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16_KHR :: + VkFormat + +pattern VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16_KHR = + VkFormat 1000156024 + +pattern VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16_KHR :: + VkFormat + +pattern VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16_KHR = + VkFormat 1000156025 + +pattern VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16_KHR :: + VkFormat + +pattern VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16_KHR = + VkFormat 1000156026 + +pattern VK_FORMAT_G16B16G16R16_422_UNORM_KHR :: VkFormat + +pattern VK_FORMAT_G16B16G16R16_422_UNORM_KHR = VkFormat 1000156027 + +pattern VK_FORMAT_B16G16R16G16_422_UNORM_KHR :: VkFormat + +pattern VK_FORMAT_B16G16R16G16_422_UNORM_KHR = VkFormat 1000156028 + +pattern VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM_KHR :: VkFormat + +pattern VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM_KHR = + VkFormat 1000156029 + +pattern VK_FORMAT_G16_B16R16_2PLANE_420_UNORM_KHR :: VkFormat + +pattern VK_FORMAT_G16_B16R16_2PLANE_420_UNORM_KHR = + VkFormat 1000156030 + +pattern VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM_KHR :: VkFormat + +pattern VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM_KHR = + VkFormat 1000156031 + +pattern VK_FORMAT_G16_B16R16_2PLANE_422_UNORM_KHR :: VkFormat + +pattern VK_FORMAT_G16_B16R16_2PLANE_422_UNORM_KHR = + VkFormat 1000156032 + +pattern VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM_KHR :: VkFormat + +pattern VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM_KHR = + VkFormat 1000156033 + +-- | bitpos = @4@ +pattern VK_IMAGE_ASPECT_PLANE_0_BIT_KHR :: VkImageAspectFlagBits + +pattern VK_IMAGE_ASPECT_PLANE_0_BIT_KHR = VkImageAspectFlagBits 16 + +-- | bitpos = @5@ +pattern VK_IMAGE_ASPECT_PLANE_1_BIT_KHR :: VkImageAspectFlagBits + +pattern VK_IMAGE_ASPECT_PLANE_1_BIT_KHR = VkImageAspectFlagBits 32 + +-- | bitpos = @6@ +pattern VK_IMAGE_ASPECT_PLANE_2_BIT_KHR :: VkImageAspectFlagBits + +pattern VK_IMAGE_ASPECT_PLANE_2_BIT_KHR = VkImageAspectFlagBits 64 + +-- | bitpos = @9@ +pattern VK_IMAGE_CREATE_DISJOINT_BIT_KHR :: VkImageCreateFlagBits + +pattern VK_IMAGE_CREATE_DISJOINT_BIT_KHR = + VkImageCreateFlagBits 512 + +-- | Format can have midpoint rather than cosited chroma samples +-- +-- bitpos = @17@ +pattern VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT_KHR :: + VkFormatFeatureFlagBits + +pattern VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT_KHR = + VkFormatFeatureFlagBits 131072 + +-- | Format can be used with linear filtering whilst color conversion is enabled +-- +-- bitpos = @18@ +pattern VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT_KHR + :: VkFormatFeatureFlagBits + +pattern VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT_KHR + = VkFormatFeatureFlagBits 262144 + +-- | Format can have different chroma, min and mag filters +-- +-- bitpos = @19@ +pattern VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT_KHR + :: VkFormatFeatureFlagBits + +pattern VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT_KHR + = VkFormatFeatureFlagBits 524288 + +-- | bitpos = @20@ +pattern VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT_KHR + :: VkFormatFeatureFlagBits + +pattern VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT_KHR + = VkFormatFeatureFlagBits 1048576 + +-- | bitpos = @21@ +pattern VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT_KHR + :: VkFormatFeatureFlagBits + +pattern VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT_KHR + = VkFormatFeatureFlagBits 2097152 + +-- | Format supports disjoint planes +-- +-- bitpos = @22@ +pattern VK_FORMAT_FEATURE_DISJOINT_BIT_KHR :: + VkFormatFeatureFlagBits + +pattern VK_FORMAT_FEATURE_DISJOINT_BIT_KHR = + VkFormatFeatureFlagBits 4194304 + +-- | Format can have cosited rather than midpoint chroma samples +-- +-- bitpos = @23@ +pattern VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT_KHR :: + VkFormatFeatureFlagBits + +pattern VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT_KHR = + VkFormatFeatureFlagBits 8388608 diff --git a/src-gen/Graphics/Vulkan/Ext/VK_KHR_shader_draw_parameters.hs b/src-gen/Graphics/Vulkan/Ext/VK_KHR_shader_draw_parameters.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Ext/VK_KHR_shader_draw_parameters.hs @@ -0,0 +1,55 @@ +{-# OPTIONS_HADDOCK not-home#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE ViewPatterns #-} +module Graphics.Vulkan.Ext.VK_KHR_shader_draw_parameters + (-- * Vulkan extension: @VK_KHR_shader_draw_parameters@ + -- | + -- + -- supported: @vulkan@ + -- + -- contact: @Daniel Koch @dgkoch@ + -- + -- author: @KHR@ + -- + -- type: @device@ + -- + -- Extension number: @64@ + VK_KHR_SHADER_DRAW_PARAMETERS_SPEC_VERSION, + pattern VK_KHR_SHADER_DRAW_PARAMETERS_SPEC_VERSION, + VK_KHR_SHADER_DRAW_PARAMETERS_EXTENSION_NAME, + pattern VK_KHR_SHADER_DRAW_PARAMETERS_EXTENSION_NAME) + where +import GHC.Ptr (Ptr (..)) +import Graphics.Vulkan.Marshal + +pattern VK_KHR_SHADER_DRAW_PARAMETERS_SPEC_VERSION :: + (Num a, Eq a) => a + +pattern VK_KHR_SHADER_DRAW_PARAMETERS_SPEC_VERSION = 1 + +type VK_KHR_SHADER_DRAW_PARAMETERS_SPEC_VERSION = 1 + +pattern VK_KHR_SHADER_DRAW_PARAMETERS_EXTENSION_NAME :: CString + +pattern VK_KHR_SHADER_DRAW_PARAMETERS_EXTENSION_NAME <- + (is_VK_KHR_SHADER_DRAW_PARAMETERS_EXTENSION_NAME -> True) + where VK_KHR_SHADER_DRAW_PARAMETERS_EXTENSION_NAME + = _VK_KHR_SHADER_DRAW_PARAMETERS_EXTENSION_NAME + +{-# INLINE _VK_KHR_SHADER_DRAW_PARAMETERS_EXTENSION_NAME #-} + +_VK_KHR_SHADER_DRAW_PARAMETERS_EXTENSION_NAME :: CString +_VK_KHR_SHADER_DRAW_PARAMETERS_EXTENSION_NAME + = Ptr "VK_KHR_shader_draw_parameters\NUL"# + +{-# INLINE is_VK_KHR_SHADER_DRAW_PARAMETERS_EXTENSION_NAME #-} + +is_VK_KHR_SHADER_DRAW_PARAMETERS_EXTENSION_NAME :: CString -> Bool +is_VK_KHR_SHADER_DRAW_PARAMETERS_EXTENSION_NAME + = eqCStrings _VK_KHR_SHADER_DRAW_PARAMETERS_EXTENSION_NAME + +type VK_KHR_SHADER_DRAW_PARAMETERS_EXTENSION_NAME = + "VK_KHR_shader_draw_parameters" diff --git a/src-gen/Graphics/Vulkan/Ext/VK_KHR_shared_presentable_image.hs b/src-gen/Graphics/Vulkan/Ext/VK_KHR_shared_presentable_image.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Ext/VK_KHR_shared_presentable_image.hs @@ -0,0 +1,134 @@ +{-# OPTIONS_HADDOCK not-home#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE ForeignFunctionInterface #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE ViewPatterns #-} +module Graphics.Vulkan.Ext.VK_KHR_shared_presentable_image + (-- * Vulkan extension: @VK_KHR_shared_presentable_image@ + -- | + -- + -- supported: @vulkan@ + -- + -- contact: @Alon Or-bach @alonorbach@ + -- + -- author: @KHR@ + -- + -- type: @device@ + -- + -- Extension number: @112@ + -- + -- Required extensions: 'VK_KHR_swapchain', 'VK_KHR_get_physical_device_properties2', 'VK_KHR_get_surface_capabilities2'. + -- + + -- ** Required extensions: 'VK_KHR_swapchain', 'VK_KHR_get_physical_device_properties2', 'VK_KHR_get_surface_capabilities2'. + module Graphics.Vulkan.Types.Enum.VkCompositeAlphaFlagsKHR, + module Graphics.Vulkan.Types.Struct.VkExtent2D, + module Graphics.Vulkan.Types.BaseTypes, + module Graphics.Vulkan.Types.Enum.VkImageUsageFlags, + module Graphics.Vulkan.Types.Struct.VkSharedPresentSurfaceCapabilitiesKHR, + module Graphics.Vulkan.Types.Enum.VkStructureType, + module Graphics.Vulkan.Types.Struct.VkSurfaceCapabilities2KHR, + module Graphics.Vulkan.Types.Struct.VkSurfaceCapabilitiesKHR, + module Graphics.Vulkan.Types.Enum.VkSurfaceTransformFlagsKHR, + -- > #include "vk_platform.h" + vkGetSwapchainStatusKHR, + module Graphics.Vulkan.Types.Enum.VkResult, + module Graphics.Vulkan.Types.Handles, + VK_KHR_SHARED_PRESENTABLE_IMAGE_SPEC_VERSION, + pattern VK_KHR_SHARED_PRESENTABLE_IMAGE_SPEC_VERSION, + VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME, + pattern VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME, + pattern VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR, + pattern VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR, + pattern VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR, + pattern VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR) + where +import GHC.Ptr + (Ptr (..)) +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Types.BaseTypes +import Graphics.Vulkan.Types.Enum.VkCompositeAlphaFlagsKHR +import Graphics.Vulkan.Types.Enum.VkImageLayout + (VkImageLayout (..)) +import Graphics.Vulkan.Types.Enum.VkImageUsageFlags +import Graphics.Vulkan.Types.Enum.VkPresentModeKHR + (VkPresentModeKHR (..)) +import Graphics.Vulkan.Types.Enum.VkResult +import Graphics.Vulkan.Types.Enum.VkStructureType +import Graphics.Vulkan.Types.Enum.VkSurfaceTransformFlagsKHR +import Graphics.Vulkan.Types.Handles +import Graphics.Vulkan.Types.Struct.VkExtent2D +import Graphics.Vulkan.Types.Struct.VkSharedPresentSurfaceCapabilitiesKHR +import Graphics.Vulkan.Types.Struct.VkSurfaceCapabilities2KHR +import Graphics.Vulkan.Types.Struct.VkSurfaceCapabilitiesKHR + +-- | Success codes: 'VK_SUCCESS', 'VK_SUBOPTIMAL_KHR'. +-- +-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_DEVICE_LOST', 'VK_ERROR_OUT_OF_DATE_KHR', 'VK_ERROR_SURFACE_LOST_KHR'. +-- +-- > VkResult vkGetSwapchainStatusKHR +-- > ( VkDevice device +-- > , VkSwapchainKHR swapchain +-- > ) +-- +-- +foreign import ccall unsafe "vkGetSwapchainStatusKHR" + vkGetSwapchainStatusKHR :: + VkDevice -- ^ device + -> VkSwapchainKHR -- ^ swapchain + -> IO VkResult + +pattern VK_KHR_SHARED_PRESENTABLE_IMAGE_SPEC_VERSION :: + (Num a, Eq a) => a + +pattern VK_KHR_SHARED_PRESENTABLE_IMAGE_SPEC_VERSION = 1 + +type VK_KHR_SHARED_PRESENTABLE_IMAGE_SPEC_VERSION = 1 + +pattern VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME :: CString + +pattern VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME <- + (is_VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME -> True) + where VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME + = _VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME + +{-# INLINE _VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME #-} + +_VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME :: CString +_VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME + = Ptr "VK_KHR_shared_presentable_image\NUL"# + +{-# INLINE is_VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME #-} + +is_VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME :: + CString -> Bool +is_VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME + = eqCStrings _VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME + +type VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME = + "VK_KHR_shared_presentable_image" + +pattern VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR + :: VkStructureType + +pattern VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR = + VkStructureType 1000111000 + +pattern VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR :: + VkPresentModeKHR + +pattern VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR = + VkPresentModeKHR 1000111000 + +pattern VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR :: + VkPresentModeKHR + +pattern VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR = + VkPresentModeKHR 1000111001 + +pattern VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR :: VkImageLayout + +pattern VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR = + VkImageLayout 1000111000 diff --git a/src-gen/Graphics/Vulkan/Ext/VK_KHR_storage_buffer_storage_class.hs b/src-gen/Graphics/Vulkan/Ext/VK_KHR_storage_buffer_storage_class.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Ext/VK_KHR_storage_buffer_storage_class.hs @@ -0,0 +1,58 @@ +{-# OPTIONS_HADDOCK not-home#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE ViewPatterns #-} +module Graphics.Vulkan.Ext.VK_KHR_storage_buffer_storage_class + (-- * Vulkan extension: @VK_KHR_storage_buffer_storage_class@ + -- | + -- + -- supported: @vulkan@ + -- + -- contact: @Alexander Galazin @debater@ + -- + -- author: @KHR@ + -- + -- type: @device@ + -- + -- Extension number: @132@ + VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_SPEC_VERSION, + pattern VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_SPEC_VERSION, + VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_EXTENSION_NAME, + pattern VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_EXTENSION_NAME) + where +import GHC.Ptr (Ptr (..)) +import Graphics.Vulkan.Marshal + +pattern VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_SPEC_VERSION :: + (Num a, Eq a) => a + +pattern VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_SPEC_VERSION = 1 + +type VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_SPEC_VERSION = 1 + +pattern VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_EXTENSION_NAME :: + CString + +pattern VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_EXTENSION_NAME <- + (is_VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_EXTENSION_NAME -> True) + where VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_EXTENSION_NAME + = _VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_EXTENSION_NAME + +{-# INLINE _VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_EXTENSION_NAME #-} + +_VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_EXTENSION_NAME :: CString +_VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_EXTENSION_NAME + = Ptr "VK_KHR_storage_buffer_storage_class\NUL"# + +{-# INLINE is_VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_EXTENSION_NAME + #-} + +is_VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_EXTENSION_NAME :: + CString -> Bool +is_VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_EXTENSION_NAME + = eqCStrings _VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_EXTENSION_NAME + +type VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_EXTENSION_NAME = + "VK_KHR_storage_buffer_storage_class" diff --git a/src-gen/Graphics/Vulkan/Ext/VK_KHR_surface.hs b/src-gen/Graphics/Vulkan/Ext/VK_KHR_surface.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Ext/VK_KHR_surface.hs @@ -0,0 +1,209 @@ +{-# OPTIONS_GHC -fno-warn-missing-pattern-synonym-signatures#-} +{-# OPTIONS_HADDOCK not-home#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE ForeignFunctionInterface #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE ViewPatterns #-} +module Graphics.Vulkan.Ext.VK_KHR_surface + (-- * Vulkan extension: @VK_KHR_surface@ + -- | + -- + -- supported: @vulkan@ + -- + -- contact: @James Jones @cubanismo,Ian Elliott ianelliott@google.com@ + -- + -- author: @KHR@ + -- + -- type: @instance@ + -- + -- Extension number: @1@ + vkDestroySurfaceKHR, vkGetPhysicalDeviceSurfaceSupportKHR, + vkGetPhysicalDeviceSurfaceCapabilitiesKHR, + vkGetPhysicalDeviceSurfaceFormatsKHR, + vkGetPhysicalDeviceSurfacePresentModesKHR, + module Graphics.Vulkan.Marshal, + module Graphics.Vulkan.Types.BaseTypes, + module Graphics.Vulkan.Types.Enum.VkColorSpaceKHR, + module Graphics.Vulkan.Types.Enum.VkCompositeAlphaFlagsKHR, + module Graphics.Vulkan.Types.Enum.VkFormat, + module Graphics.Vulkan.Types.Enum.VkImageUsageFlags, + module Graphics.Vulkan.Types.Enum.VkInternalAllocationType, + module Graphics.Vulkan.Types.Enum.VkPresentModeKHR, + module Graphics.Vulkan.Types.Enum.VkResult, + module Graphics.Vulkan.Types.Enum.VkSurfaceTransformFlagsKHR, + module Graphics.Vulkan.Types.Enum.VkSystemAllocationScope, + module Graphics.Vulkan.Types.Funcpointers, + module Graphics.Vulkan.Types.Handles, + module Graphics.Vulkan.Types.Struct.VkAllocationCallbacks, + module Graphics.Vulkan.Types.Struct.VkExtent2D, + module Graphics.Vulkan.Types.Struct.VkSurfaceCapabilitiesKHR, + module Graphics.Vulkan.Types.Struct.VkSurfaceFormatKHR, + VK_KHR_SURFACE_SPEC_VERSION, pattern VK_KHR_SURFACE_SPEC_VERSION, + VK_KHR_SURFACE_EXTENSION_NAME, + pattern VK_KHR_SURFACE_EXTENSION_NAME, + pattern VK_ERROR_SURFACE_LOST_KHR, + pattern VK_ERROR_NATIVE_WINDOW_IN_USE_KHR, + pattern VK_COLORSPACE_SRGB_NONLINEAR_KHR, + pattern VK_OBJECT_TYPE_SURFACE_KHR) + where +import GHC.Ptr (Ptr (..)) +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Types.BaseTypes +import Graphics.Vulkan.Types.Enum.VkColorSpaceKHR +import Graphics.Vulkan.Types.Enum.VkCompositeAlphaFlagsKHR +import Graphics.Vulkan.Types.Enum.VkFormat +import Graphics.Vulkan.Types.Enum.VkImageUsageFlags +import Graphics.Vulkan.Types.Enum.VkInternalAllocationType +import Graphics.Vulkan.Types.Enum.VkObjectType (VkObjectType (..)) +import Graphics.Vulkan.Types.Enum.VkPresentModeKHR +import Graphics.Vulkan.Types.Enum.VkResult +import Graphics.Vulkan.Types.Enum.VkSurfaceTransformFlagsKHR +import Graphics.Vulkan.Types.Enum.VkSystemAllocationScope +import Graphics.Vulkan.Types.Funcpointers +import Graphics.Vulkan.Types.Handles +import Graphics.Vulkan.Types.Struct.VkAllocationCallbacks +import Graphics.Vulkan.Types.Struct.VkExtent2D +import Graphics.Vulkan.Types.Struct.VkSurfaceCapabilitiesKHR +import Graphics.Vulkan.Types.Struct.VkSurfaceFormatKHR + +-- | > () vkDestroySurfaceKHR +-- > ( VkInstance instance +-- > , VkSurfaceKHR surface +-- > , const VkAllocationCallbacks* pAllocator +-- > ) +-- +-- +foreign import ccall unsafe "vkDestroySurfaceKHR" + vkDestroySurfaceKHR :: + VkInstance -- ^ instance + -> VkSurfaceKHR -- ^ surface + -> Ptr VkAllocationCallbacks -- ^ pAllocator + -> IO () + +-- | Success codes: 'VK_SUCCESS'. +-- +-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_SURFACE_LOST_KHR'. +-- +-- > VkResult vkGetPhysicalDeviceSurfaceSupportKHR +-- > ( VkPhysicalDevice physicalDevice +-- > , uint32_t queueFamilyIndex +-- > , VkSurfaceKHR surface +-- > , VkBool32* pSupported +-- > ) +-- +-- +foreign import ccall unsafe "vkGetPhysicalDeviceSurfaceSupportKHR" + vkGetPhysicalDeviceSurfaceSupportKHR :: + VkPhysicalDevice -- ^ physicalDevice + -> + Word32 -- ^ queueFamilyIndex + -> VkSurfaceKHR -- ^ surface + -> Ptr VkBool32 -- ^ pSupported + -> IO VkResult + +-- | Success codes: 'VK_SUCCESS'. +-- +-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_SURFACE_LOST_KHR'. +-- +-- > VkResult vkGetPhysicalDeviceSurfaceCapabilitiesKHR +-- > ( VkPhysicalDevice physicalDevice +-- > , VkSurfaceKHR surface +-- > , VkSurfaceCapabilitiesKHR* pSurfaceCapabilities +-- > ) +-- +-- +foreign import ccall unsafe + "vkGetPhysicalDeviceSurfaceCapabilitiesKHR" + vkGetPhysicalDeviceSurfaceCapabilitiesKHR :: + VkPhysicalDevice -- ^ physicalDevice + -> + VkSurfaceKHR -- ^ surface + -> Ptr VkSurfaceCapabilitiesKHR -- ^ pSurfaceCapabilities + -> IO VkResult + +-- | Success codes: 'VK_SUCCESS', 'VK_INCOMPLETE'. +-- +-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_SURFACE_LOST_KHR'. +-- +-- > VkResult vkGetPhysicalDeviceSurfaceFormatsKHR +-- > ( VkPhysicalDevice physicalDevice +-- > , VkSurfaceKHR surface +-- > , uint32_t* pSurfaceFormatCount +-- > , VkSurfaceFormatKHR* pSurfaceFormats +-- > ) +-- +-- +foreign import ccall unsafe "vkGetPhysicalDeviceSurfaceFormatsKHR" + vkGetPhysicalDeviceSurfaceFormatsKHR :: + VkPhysicalDevice -- ^ physicalDevice + -> + VkSurfaceKHR -- ^ surface + -> Ptr Word32 -- ^ pSurfaceFormatCount + -> Ptr VkSurfaceFormatKHR -- ^ pSurfaceFormats + -> IO VkResult + +-- | Success codes: 'VK_SUCCESS', 'VK_INCOMPLETE'. +-- +-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_SURFACE_LOST_KHR'. +-- +-- > VkResult vkGetPhysicalDeviceSurfacePresentModesKHR +-- > ( VkPhysicalDevice physicalDevice +-- > , VkSurfaceKHR surface +-- > , uint32_t* pPresentModeCount +-- > , VkPresentModeKHR* pPresentModes +-- > ) +-- +-- +foreign import ccall unsafe + "vkGetPhysicalDeviceSurfacePresentModesKHR" + vkGetPhysicalDeviceSurfacePresentModesKHR :: + VkPhysicalDevice -- ^ physicalDevice + -> + VkSurfaceKHR -- ^ surface + -> Ptr Word32 -- ^ pPresentModeCount + -> Ptr VkPresentModeKHR -- ^ pPresentModes + -> IO VkResult + +pattern VK_KHR_SURFACE_SPEC_VERSION :: (Num a, Eq a) => a + +pattern VK_KHR_SURFACE_SPEC_VERSION = 25 + +type VK_KHR_SURFACE_SPEC_VERSION = 25 + +pattern VK_KHR_SURFACE_EXTENSION_NAME :: CString + +pattern VK_KHR_SURFACE_EXTENSION_NAME <- + (is_VK_KHR_SURFACE_EXTENSION_NAME -> True) + where VK_KHR_SURFACE_EXTENSION_NAME + = _VK_KHR_SURFACE_EXTENSION_NAME + +{-# INLINE _VK_KHR_SURFACE_EXTENSION_NAME #-} + +_VK_KHR_SURFACE_EXTENSION_NAME :: CString +_VK_KHR_SURFACE_EXTENSION_NAME = Ptr "VK_KHR_surface\NUL"# + +{-# INLINE is_VK_KHR_SURFACE_EXTENSION_NAME #-} + +is_VK_KHR_SURFACE_EXTENSION_NAME :: CString -> Bool +is_VK_KHR_SURFACE_EXTENSION_NAME + = eqCStrings _VK_KHR_SURFACE_EXTENSION_NAME + +type VK_KHR_SURFACE_EXTENSION_NAME = "VK_KHR_surface" + +pattern VK_ERROR_SURFACE_LOST_KHR :: VkResult + +pattern VK_ERROR_SURFACE_LOST_KHR = VkResult (-1000000000) + +pattern VK_ERROR_NATIVE_WINDOW_IN_USE_KHR :: VkResult + +pattern VK_ERROR_NATIVE_WINDOW_IN_USE_KHR = VkResult (-1000000001) + +pattern VK_COLORSPACE_SRGB_NONLINEAR_KHR = + VK_COLOR_SPACE_SRGB_NONLINEAR_KHR + +-- | VkSurfaceKHR +pattern VK_OBJECT_TYPE_SURFACE_KHR :: VkObjectType + +pattern VK_OBJECT_TYPE_SURFACE_KHR = VkObjectType 1000000000 diff --git a/src-gen/Graphics/Vulkan/Ext/VK_KHR_swapchain.hs b/src-gen/Graphics/Vulkan/Ext/VK_KHR_swapchain.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Ext/VK_KHR_swapchain.hs @@ -0,0 +1,232 @@ +{-# OPTIONS_HADDOCK not-home#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE ForeignFunctionInterface #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE ViewPatterns #-} +module Graphics.Vulkan.Ext.VK_KHR_swapchain + (-- * Vulkan extension: @VK_KHR_swapchain@ + -- | + -- + -- supported: @vulkan@ + -- + -- contact: @James Jones @cubanismo,Ian Elliott ianelliott@google.com@ + -- + -- author: @KHR@ + -- + -- type: @device@ + -- + -- Extension number: @2@ + -- + -- Required extensions: 'VK_KHR_surface'. + -- + + -- ** Required extensions: 'VK_KHR_surface'. + vkCreateSwapchainKHR, vkDestroySwapchainKHR, + vkGetSwapchainImagesKHR, vkAcquireNextImageKHR, vkQueuePresentKHR, + module Graphics.Vulkan.Marshal, + module Graphics.Vulkan.Types.BaseTypes, + module Graphics.Vulkan.Types.Enum.VkColorSpaceKHR, + module Graphics.Vulkan.Types.Enum.VkCompositeAlphaFlagsKHR, + module Graphics.Vulkan.Types.Enum.VkFormat, + module Graphics.Vulkan.Types.Enum.VkImageUsageFlags, + module Graphics.Vulkan.Types.Enum.VkInternalAllocationType, + module Graphics.Vulkan.Types.Enum.VkPresentModeKHR, + module Graphics.Vulkan.Types.Enum.VkResult, + module Graphics.Vulkan.Types.Enum.VkSharingMode, + module Graphics.Vulkan.Types.Enum.VkStructureType, + module Graphics.Vulkan.Types.Enum.VkSurfaceTransformFlagsKHR, + module Graphics.Vulkan.Types.Enum.VkSwapchainCreateFlagsKHR, + module Graphics.Vulkan.Types.Enum.VkSystemAllocationScope, + module Graphics.Vulkan.Types.Funcpointers, + module Graphics.Vulkan.Types.Handles, + module Graphics.Vulkan.Types.Struct.VkAllocationCallbacks, + module Graphics.Vulkan.Types.Struct.VkExtent2D, + module Graphics.Vulkan.Types.Struct.VkPresentInfoKHR, + module Graphics.Vulkan.Types.Struct.VkSwapchainCreateInfoKHR, + VK_KHR_SWAPCHAIN_SPEC_VERSION, + pattern VK_KHR_SWAPCHAIN_SPEC_VERSION, + VK_KHR_SWAPCHAIN_EXTENSION_NAME, + pattern VK_KHR_SWAPCHAIN_EXTENSION_NAME, + pattern VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR, + pattern VK_STRUCTURE_TYPE_PRESENT_INFO_KHR, + pattern VK_IMAGE_LAYOUT_PRESENT_SRC_KHR, pattern VK_SUBOPTIMAL_KHR, + pattern VK_ERROR_OUT_OF_DATE_KHR, + pattern VK_OBJECT_TYPE_SWAPCHAIN_KHR) + where +import GHC.Ptr (Ptr (..)) +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Types.BaseTypes +import Graphics.Vulkan.Types.Enum.VkColorSpaceKHR +import Graphics.Vulkan.Types.Enum.VkCompositeAlphaFlagsKHR +import Graphics.Vulkan.Types.Enum.VkFormat +import Graphics.Vulkan.Types.Enum.VkImageLayout (VkImageLayout (..)) +import Graphics.Vulkan.Types.Enum.VkImageUsageFlags +import Graphics.Vulkan.Types.Enum.VkInternalAllocationType +import Graphics.Vulkan.Types.Enum.VkObjectType (VkObjectType (..)) +import Graphics.Vulkan.Types.Enum.VkPresentModeKHR +import Graphics.Vulkan.Types.Enum.VkResult +import Graphics.Vulkan.Types.Enum.VkSharingMode +import Graphics.Vulkan.Types.Enum.VkStructureType +import Graphics.Vulkan.Types.Enum.VkSurfaceTransformFlagsKHR +import Graphics.Vulkan.Types.Enum.VkSwapchainCreateFlagsKHR +import Graphics.Vulkan.Types.Enum.VkSystemAllocationScope +import Graphics.Vulkan.Types.Funcpointers +import Graphics.Vulkan.Types.Handles +import Graphics.Vulkan.Types.Struct.VkAllocationCallbacks +import Graphics.Vulkan.Types.Struct.VkExtent2D +import Graphics.Vulkan.Types.Struct.VkPresentInfoKHR +import Graphics.Vulkan.Types.Struct.VkSwapchainCreateInfoKHR + +-- | Success codes: 'VK_SUCCESS'. +-- +-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_DEVICE_LOST', 'VK_ERROR_SURFACE_LOST_KHR', 'VK_ERROR_NATIVE_WINDOW_IN_USE_KHR'. +-- +-- > VkResult vkCreateSwapchainKHR +-- > ( VkDevice device +-- > , const VkSwapchainCreateInfoKHR* pCreateInfo +-- > , const VkAllocationCallbacks* pAllocator +-- > , VkSwapchainKHR* pSwapchain +-- > ) +-- +-- +foreign import ccall unsafe "vkCreateSwapchainKHR" + vkCreateSwapchainKHR :: + VkDevice -- ^ device + -> + Ptr VkSwapchainCreateInfoKHR -- ^ pCreateInfo + -> + Ptr VkAllocationCallbacks -- ^ pAllocator + -> Ptr VkSwapchainKHR -- ^ pSwapchain + -> IO VkResult + +-- | > () vkDestroySwapchainKHR +-- > ( VkDevice device +-- > , VkSwapchainKHR swapchain +-- > , const VkAllocationCallbacks* pAllocator +-- > ) +-- +-- +foreign import ccall unsafe "vkDestroySwapchainKHR" + vkDestroySwapchainKHR :: + VkDevice -- ^ device + -> VkSwapchainKHR -- ^ swapchain + -> Ptr VkAllocationCallbacks -- ^ pAllocator + -> IO () + +-- | Success codes: 'VK_SUCCESS', 'VK_INCOMPLETE'. +-- +-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. +-- +-- > VkResult vkGetSwapchainImagesKHR +-- > ( VkDevice device +-- > , VkSwapchainKHR swapchain +-- > , uint32_t* pSwapchainImageCount +-- > , VkImage* pSwapchainImages +-- > ) +-- +-- +foreign import ccall unsafe "vkGetSwapchainImagesKHR" + vkGetSwapchainImagesKHR :: + VkDevice -- ^ device + -> + VkSwapchainKHR -- ^ swapchain + -> Ptr Word32 -- ^ pSwapchainImageCount + -> Ptr VkImage -- ^ pSwapchainImages + -> IO VkResult + +-- | Success codes: 'VK_SUCCESS', 'VK_TIMEOUT', 'VK_NOT_READY', 'VK_SUBOPTIMAL_KHR'. +-- +-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_DEVICE_LOST', 'VK_ERROR_OUT_OF_DATE_KHR', 'VK_ERROR_SURFACE_LOST_KHR'. +-- +-- > VkResult vkAcquireNextImageKHR +-- > ( VkDevice device +-- > , VkSwapchainKHR swapchain +-- > , uint64_t timeout +-- > , VkSemaphore semaphore +-- > , VkFence fence +-- > , uint32_t* pImageIndex +-- > ) +-- +-- +foreign import ccall unsafe "vkAcquireNextImageKHR" + vkAcquireNextImageKHR :: + VkDevice -- ^ device + -> + VkSwapchainKHR -- ^ swapchain + -> + Word64 -- ^ timeout + -> VkSemaphore -- ^ semaphore + -> VkFence -- ^ fence + -> Ptr Word32 -- ^ pImageIndex + -> IO VkResult + +-- | Success codes: 'VK_SUCCESS', 'VK_SUBOPTIMAL_KHR'. +-- +-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_DEVICE_LOST', 'VK_ERROR_OUT_OF_DATE_KHR', 'VK_ERROR_SURFACE_LOST_KHR'. +-- +-- > VkResult vkQueuePresentKHR +-- > ( VkQueue queue +-- > , const VkPresentInfoKHR* pPresentInfo +-- > ) +-- +-- +foreign import ccall unsafe "vkQueuePresentKHR" vkQueuePresentKHR + :: VkQueue -- ^ queue + -> Ptr VkPresentInfoKHR -- ^ pPresentInfo + -> IO VkResult + +pattern VK_KHR_SWAPCHAIN_SPEC_VERSION :: (Num a, Eq a) => a + +pattern VK_KHR_SWAPCHAIN_SPEC_VERSION = 68 + +type VK_KHR_SWAPCHAIN_SPEC_VERSION = 68 + +pattern VK_KHR_SWAPCHAIN_EXTENSION_NAME :: CString + +pattern VK_KHR_SWAPCHAIN_EXTENSION_NAME <- + (is_VK_KHR_SWAPCHAIN_EXTENSION_NAME -> True) + where VK_KHR_SWAPCHAIN_EXTENSION_NAME + = _VK_KHR_SWAPCHAIN_EXTENSION_NAME + +{-# INLINE _VK_KHR_SWAPCHAIN_EXTENSION_NAME #-} + +_VK_KHR_SWAPCHAIN_EXTENSION_NAME :: CString +_VK_KHR_SWAPCHAIN_EXTENSION_NAME = Ptr "VK_KHR_swapchain\NUL"# + +{-# INLINE is_VK_KHR_SWAPCHAIN_EXTENSION_NAME #-} + +is_VK_KHR_SWAPCHAIN_EXTENSION_NAME :: CString -> Bool +is_VK_KHR_SWAPCHAIN_EXTENSION_NAME + = eqCStrings _VK_KHR_SWAPCHAIN_EXTENSION_NAME + +type VK_KHR_SWAPCHAIN_EXTENSION_NAME = "VK_KHR_swapchain" + +pattern VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR = + VkStructureType 1000001000 + +pattern VK_STRUCTURE_TYPE_PRESENT_INFO_KHR :: VkStructureType + +pattern VK_STRUCTURE_TYPE_PRESENT_INFO_KHR = + VkStructureType 1000001001 + +pattern VK_IMAGE_LAYOUT_PRESENT_SRC_KHR :: VkImageLayout + +pattern VK_IMAGE_LAYOUT_PRESENT_SRC_KHR = VkImageLayout 1000001002 + +pattern VK_SUBOPTIMAL_KHR :: VkResult + +pattern VK_SUBOPTIMAL_KHR = VkResult 1000001003 + +pattern VK_ERROR_OUT_OF_DATE_KHR :: VkResult + +pattern VK_ERROR_OUT_OF_DATE_KHR = VkResult (-1000001004) + +-- | VkSwapchainKHR +pattern VK_OBJECT_TYPE_SWAPCHAIN_KHR :: VkObjectType + +pattern VK_OBJECT_TYPE_SWAPCHAIN_KHR = VkObjectType 1000001000 diff --git a/src-gen/Graphics/Vulkan/Ext/VK_KHR_variable_pointers.hs b/src-gen/Graphics/Vulkan/Ext/VK_KHR_variable_pointers.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Ext/VK_KHR_variable_pointers.hs @@ -0,0 +1,85 @@ +{-# OPTIONS_HADDOCK not-home#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE ViewPatterns #-} +module Graphics.Vulkan.Ext.VK_KHR_variable_pointers + (-- * Vulkan extension: @VK_KHR_variable_pointers@ + -- | + -- + -- supported: @vulkan@ + -- + -- contact: @Jesse Hall @jessehall@ + -- + -- author: @KHR@ + -- + -- type: @device@ + -- + -- Extension number: @121@ + -- + -- Required extensions: 'VK_KHR_get_physical_device_properties2', 'VK_KHR_storage_buffer_storage_class'. + -- + + -- ** Required extensions: 'VK_KHR_get_physical_device_properties2', 'VK_KHR_storage_buffer_storage_class'. + module Graphics.Vulkan.Marshal, + module Graphics.Vulkan.Types.BaseTypes, + module Graphics.Vulkan.Types.Bitmasks, + module Graphics.Vulkan.Types.Struct.VkDeviceCreateInfo, + module Graphics.Vulkan.Types.Struct.VkDeviceQueueCreateInfo, + module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceFeatures, + module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceFeatures2KHR, + module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceVariablePointerFeaturesKHR, + module Graphics.Vulkan.Types.Enum.VkStructureType, + -- > #include "vk_platform.h" + VK_KHR_VARIABLE_POINTERS_SPEC_VERSION, + pattern VK_KHR_VARIABLE_POINTERS_SPEC_VERSION, + VK_KHR_VARIABLE_POINTERS_EXTENSION_NAME, + pattern VK_KHR_VARIABLE_POINTERS_EXTENSION_NAME, + pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES_KHR) + where +import GHC.Ptr + (Ptr (..)) +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Types.BaseTypes +import Graphics.Vulkan.Types.Bitmasks +import Graphics.Vulkan.Types.Enum.VkStructureType +import Graphics.Vulkan.Types.Struct.VkDeviceCreateInfo +import Graphics.Vulkan.Types.Struct.VkDeviceQueueCreateInfo +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceFeatures +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceFeatures2KHR +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceVariablePointerFeaturesKHR + +pattern VK_KHR_VARIABLE_POINTERS_SPEC_VERSION :: (Num a, Eq a) => a + +pattern VK_KHR_VARIABLE_POINTERS_SPEC_VERSION = 1 + +type VK_KHR_VARIABLE_POINTERS_SPEC_VERSION = 1 + +pattern VK_KHR_VARIABLE_POINTERS_EXTENSION_NAME :: CString + +pattern VK_KHR_VARIABLE_POINTERS_EXTENSION_NAME <- + (is_VK_KHR_VARIABLE_POINTERS_EXTENSION_NAME -> True) + where VK_KHR_VARIABLE_POINTERS_EXTENSION_NAME + = _VK_KHR_VARIABLE_POINTERS_EXTENSION_NAME + +{-# INLINE _VK_KHR_VARIABLE_POINTERS_EXTENSION_NAME #-} + +_VK_KHR_VARIABLE_POINTERS_EXTENSION_NAME :: CString +_VK_KHR_VARIABLE_POINTERS_EXTENSION_NAME + = Ptr "VK_KHR_variable_pointers\NUL"# + +{-# INLINE is_VK_KHR_VARIABLE_POINTERS_EXTENSION_NAME #-} + +is_VK_KHR_VARIABLE_POINTERS_EXTENSION_NAME :: CString -> Bool +is_VK_KHR_VARIABLE_POINTERS_EXTENSION_NAME + = eqCStrings _VK_KHR_VARIABLE_POINTERS_EXTENSION_NAME + +type VK_KHR_VARIABLE_POINTERS_EXTENSION_NAME = + "VK_KHR_variable_pointers" + +pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES_KHR + :: VkStructureType + +pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES_KHR + = VkStructureType 1000120000 diff --git a/src-gen/Graphics/Vulkan/Ext/VK_KHR_wayland_surface.hs b/src-gen/Graphics/Vulkan/Ext/VK_KHR_wayland_surface.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Ext/VK_KHR_wayland_surface.hs @@ -0,0 +1,134 @@ +{-# OPTIONS_HADDOCK not-home#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE ForeignFunctionInterface #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE ViewPatterns #-} +module Graphics.Vulkan.Ext.VK_KHR_wayland_surface + (-- * Vulkan extension: @VK_KHR_wayland_surface@ + -- | + -- + -- supported: @vulkan@ + -- + -- contact: @Jesse Hall @jessehall,Ian Elliott ianelliott@google.com@ + -- + -- author: @KHR@ + -- + -- type: @instance@ + -- + -- Extension number: @7@ + -- + -- Required extensions: 'VK_KHR_surface'. + -- + -- Protected by CPP ifdef: @VK_USE_PLATFORM_WAYLAND_KHR@ + -- + + -- ** Required extensions: 'VK_KHR_surface'. + module Graphics.Vulkan.Types.BaseTypes, + module Graphics.Vulkan.Types.Enum.VkStructureType, + module Graphics.Vulkan.Types.Bitmasks, + module Graphics.Vulkan.Types.Struct.VkWaylandSurfaceCreateInfoKHR, + -- > #include "vk_platform.h" + -- + -- > #include + vkCreateWaylandSurfaceKHR, + vkGetPhysicalDeviceWaylandPresentationSupportKHR, + module Graphics.Vulkan.Marshal, + module Graphics.Vulkan.Types.Enum.VkInternalAllocationType, + module Graphics.Vulkan.Types.Enum.VkResult, + module Graphics.Vulkan.Types.Enum.VkSystemAllocationScope, + module Graphics.Vulkan.Types.Funcpointers, + module Graphics.Vulkan.Types.Handles, + module Graphics.Vulkan.Types.Include, + module Graphics.Vulkan.Types.Struct.VkAllocationCallbacks, + VK_KHR_WAYLAND_SURFACE_SPEC_VERSION, + pattern VK_KHR_WAYLAND_SURFACE_SPEC_VERSION, + VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME, + pattern VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME, + pattern VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR) + where +import GHC.Ptr (Ptr (..)) +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Types.BaseTypes +import Graphics.Vulkan.Types.Bitmasks +import Graphics.Vulkan.Types.Enum.VkInternalAllocationType +import Graphics.Vulkan.Types.Enum.VkResult +import Graphics.Vulkan.Types.Enum.VkStructureType +import Graphics.Vulkan.Types.Enum.VkSystemAllocationScope +import Graphics.Vulkan.Types.Funcpointers +import Graphics.Vulkan.Types.Handles +import Graphics.Vulkan.Types.Include +import Graphics.Vulkan.Types.Struct.VkAllocationCallbacks +import Graphics.Vulkan.Types.Struct.VkWaylandSurfaceCreateInfoKHR + +-- | Success codes: 'VK_SUCCESS'. +-- +-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. +-- +-- > VkResult vkCreateWaylandSurfaceKHR +-- > ( VkInstance instance +-- > , const VkWaylandSurfaceCreateInfoKHR* pCreateInfo +-- > , const VkAllocationCallbacks* pAllocator +-- > , VkSurfaceKHR* pSurface +-- > ) +-- +-- +foreign import ccall unsafe "vkCreateWaylandSurfaceKHR" + vkCreateWaylandSurfaceKHR :: + VkInstance -- ^ instance + -> + Ptr VkWaylandSurfaceCreateInfoKHR -- ^ pCreateInfo + -> + Ptr VkAllocationCallbacks -- ^ pAllocator + -> Ptr VkSurfaceKHR -- ^ pSurface + -> IO VkResult + +-- | > VkBool32 vkGetPhysicalDeviceWaylandPresentationSupportKHR +-- > ( VkPhysicalDevice physicalDevice +-- > , uint32_t queueFamilyIndex +-- > , struct wl_display* display +-- > ) +-- +-- +foreign import ccall unsafe + "vkGetPhysicalDeviceWaylandPresentationSupportKHR" + vkGetPhysicalDeviceWaylandPresentationSupportKHR :: + VkPhysicalDevice -- ^ physicalDevice + -> Word32 -- ^ queueFamilyIndex + -> Ptr WlDisplay -- ^ display + -> IO VkBool32 + +pattern VK_KHR_WAYLAND_SURFACE_SPEC_VERSION :: (Num a, Eq a) => a + +pattern VK_KHR_WAYLAND_SURFACE_SPEC_VERSION = 6 + +type VK_KHR_WAYLAND_SURFACE_SPEC_VERSION = 6 + +pattern VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME :: CString + +pattern VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME <- + (is_VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME -> True) + where VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME + = _VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME + +{-# INLINE _VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME #-} + +_VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME :: CString +_VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME + = Ptr "VK_KHR_wayland_surface\NUL"# + +{-# INLINE is_VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME #-} + +is_VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME :: CString -> Bool +is_VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME + = eqCStrings _VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME + +type VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME = + "VK_KHR_wayland_surface" + +pattern VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR = + VkStructureType 1000006000 diff --git a/src-gen/Graphics/Vulkan/Ext/VK_KHR_win32_keyed_mutex.hs b/src-gen/Graphics/Vulkan/Ext/VK_KHR_win32_keyed_mutex.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Ext/VK_KHR_win32_keyed_mutex.hs @@ -0,0 +1,80 @@ +{-# OPTIONS_HADDOCK not-home#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE ViewPatterns #-} +module Graphics.Vulkan.Ext.VK_KHR_win32_keyed_mutex + (-- * Vulkan extension: @VK_KHR_win32_keyed_mutex@ + -- | + -- + -- supported: @vulkan@ + -- + -- contact: @Carsten Rohde@ + -- + -- author: @KHR@ + -- + -- type: @device@ + -- + -- Extension number: @76@ + -- + -- Required extensions: 'VK_KHR_external_memory_win32'. + -- + -- Protected by CPP ifdef: @VK_USE_PLATFORM_WIN32_KHR@ + -- + + -- ** Required extensions: 'VK_KHR_external_memory_win32'. + module Graphics.Vulkan.Types.BaseTypes, + module Graphics.Vulkan.Types.Enum.VkPipelineStageFlags, + module Graphics.Vulkan.Types.Enum.VkStructureType, + module Graphics.Vulkan.Types.Struct.VkSubmitInfo, + module Graphics.Vulkan.Types.Struct.VkWin32KeyedMutexAcquireReleaseInfoKHR, + -- > #include "vk_platform.h" + VK_KHR_WIN32_KEYED_MUTEX_SPEC_VERSION, + pattern VK_KHR_WIN32_KEYED_MUTEX_SPEC_VERSION, + VK_KHR_WIN32_KEYED_MUTEX_EXTENSION_NAME, + pattern VK_KHR_WIN32_KEYED_MUTEX_EXTENSION_NAME, + pattern VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR) + where +import GHC.Ptr + (Ptr (..)) +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Types.BaseTypes +import Graphics.Vulkan.Types.Enum.VkPipelineStageFlags +import Graphics.Vulkan.Types.Enum.VkStructureType +import Graphics.Vulkan.Types.Struct.VkSubmitInfo +import Graphics.Vulkan.Types.Struct.VkWin32KeyedMutexAcquireReleaseInfoKHR + +pattern VK_KHR_WIN32_KEYED_MUTEX_SPEC_VERSION :: (Num a, Eq a) => a + +pattern VK_KHR_WIN32_KEYED_MUTEX_SPEC_VERSION = 1 + +type VK_KHR_WIN32_KEYED_MUTEX_SPEC_VERSION = 1 + +pattern VK_KHR_WIN32_KEYED_MUTEX_EXTENSION_NAME :: CString + +pattern VK_KHR_WIN32_KEYED_MUTEX_EXTENSION_NAME <- + (is_VK_KHR_WIN32_KEYED_MUTEX_EXTENSION_NAME -> True) + where VK_KHR_WIN32_KEYED_MUTEX_EXTENSION_NAME + = _VK_KHR_WIN32_KEYED_MUTEX_EXTENSION_NAME + +{-# INLINE _VK_KHR_WIN32_KEYED_MUTEX_EXTENSION_NAME #-} + +_VK_KHR_WIN32_KEYED_MUTEX_EXTENSION_NAME :: CString +_VK_KHR_WIN32_KEYED_MUTEX_EXTENSION_NAME + = Ptr "VK_KHR_win32_keyed_mutex\NUL"# + +{-# INLINE is_VK_KHR_WIN32_KEYED_MUTEX_EXTENSION_NAME #-} + +is_VK_KHR_WIN32_KEYED_MUTEX_EXTENSION_NAME :: CString -> Bool +is_VK_KHR_WIN32_KEYED_MUTEX_EXTENSION_NAME + = eqCStrings _VK_KHR_WIN32_KEYED_MUTEX_EXTENSION_NAME + +type VK_KHR_WIN32_KEYED_MUTEX_EXTENSION_NAME = + "VK_KHR_win32_keyed_mutex" + +pattern VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR + :: VkStructureType + +pattern VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR + = VkStructureType 1000075000 diff --git a/src-gen/Graphics/Vulkan/Ext/VK_KHR_win32_surface.hs b/src-gen/Graphics/Vulkan/Ext/VK_KHR_win32_surface.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Ext/VK_KHR_win32_surface.hs @@ -0,0 +1,131 @@ +{-# OPTIONS_HADDOCK not-home#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE ForeignFunctionInterface #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE ViewPatterns #-} +module Graphics.Vulkan.Ext.VK_KHR_win32_surface + (-- * Vulkan extension: @VK_KHR_win32_surface@ + -- | + -- + -- supported: @vulkan@ + -- + -- contact: @Jesse Hall @jessehall,Ian Elliott ianelliott@google.com@ + -- + -- author: @KHR@ + -- + -- type: @instance@ + -- + -- Extension number: @10@ + -- + -- Required extensions: 'VK_KHR_surface'. + -- + -- Protected by CPP ifdef: @VK_USE_PLATFORM_WIN32_KHR@ + -- + + -- ** Required extensions: 'VK_KHR_surface'. + module Graphics.Vulkan.Types.BaseTypes, + module Graphics.Vulkan.Types.Enum.VkStructureType, + module Graphics.Vulkan.Types.Bitmasks, + module Graphics.Vulkan.Types.Struct.VkWin32SurfaceCreateInfoKHR, + -- > #include "vk_platform.h" + -- + -- > #include + vkCreateWin32SurfaceKHR, + vkGetPhysicalDeviceWin32PresentationSupportKHR, + module Graphics.Vulkan.Marshal, + module Graphics.Vulkan.Types.Enum.VkInternalAllocationType, + module Graphics.Vulkan.Types.Enum.VkResult, + module Graphics.Vulkan.Types.Enum.VkSystemAllocationScope, + module Graphics.Vulkan.Types.Funcpointers, + module Graphics.Vulkan.Types.Handles, + module Graphics.Vulkan.Types.Include, + module Graphics.Vulkan.Types.Struct.VkAllocationCallbacks, + VK_KHR_WIN32_SURFACE_SPEC_VERSION, + pattern VK_KHR_WIN32_SURFACE_SPEC_VERSION, + VK_KHR_WIN32_SURFACE_EXTENSION_NAME, + pattern VK_KHR_WIN32_SURFACE_EXTENSION_NAME, + pattern VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR) + where +import GHC.Ptr (Ptr (..)) +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Types.BaseTypes +import Graphics.Vulkan.Types.Bitmasks +import Graphics.Vulkan.Types.Enum.VkInternalAllocationType +import Graphics.Vulkan.Types.Enum.VkResult +import Graphics.Vulkan.Types.Enum.VkStructureType +import Graphics.Vulkan.Types.Enum.VkSystemAllocationScope +import Graphics.Vulkan.Types.Funcpointers +import Graphics.Vulkan.Types.Handles +import Graphics.Vulkan.Types.Include +import Graphics.Vulkan.Types.Struct.VkAllocationCallbacks +import Graphics.Vulkan.Types.Struct.VkWin32SurfaceCreateInfoKHR + +-- | Success codes: 'VK_SUCCESS'. +-- +-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. +-- +-- > VkResult vkCreateWin32SurfaceKHR +-- > ( VkInstance instance +-- > , const VkWin32SurfaceCreateInfoKHR* pCreateInfo +-- > , const VkAllocationCallbacks* pAllocator +-- > , VkSurfaceKHR* pSurface +-- > ) +-- +-- +foreign import ccall unsafe "vkCreateWin32SurfaceKHR" + vkCreateWin32SurfaceKHR :: + VkInstance -- ^ instance + -> + Ptr VkWin32SurfaceCreateInfoKHR -- ^ pCreateInfo + -> + Ptr VkAllocationCallbacks -- ^ pAllocator + -> Ptr VkSurfaceKHR -- ^ pSurface + -> IO VkResult + +-- | > VkBool32 vkGetPhysicalDeviceWin32PresentationSupportKHR +-- > ( VkPhysicalDevice physicalDevice +-- > , uint32_t queueFamilyIndex +-- > ) +-- +-- +foreign import ccall unsafe + "vkGetPhysicalDeviceWin32PresentationSupportKHR" + vkGetPhysicalDeviceWin32PresentationSupportKHR :: + VkPhysicalDevice -- ^ physicalDevice + -> Word32 -- ^ queueFamilyIndex + -> IO VkBool32 + +pattern VK_KHR_WIN32_SURFACE_SPEC_VERSION :: (Num a, Eq a) => a + +pattern VK_KHR_WIN32_SURFACE_SPEC_VERSION = 6 + +type VK_KHR_WIN32_SURFACE_SPEC_VERSION = 6 + +pattern VK_KHR_WIN32_SURFACE_EXTENSION_NAME :: CString + +pattern VK_KHR_WIN32_SURFACE_EXTENSION_NAME <- + (is_VK_KHR_WIN32_SURFACE_EXTENSION_NAME -> True) + where VK_KHR_WIN32_SURFACE_EXTENSION_NAME + = _VK_KHR_WIN32_SURFACE_EXTENSION_NAME + +{-# INLINE _VK_KHR_WIN32_SURFACE_EXTENSION_NAME #-} + +_VK_KHR_WIN32_SURFACE_EXTENSION_NAME :: CString +_VK_KHR_WIN32_SURFACE_EXTENSION_NAME + = Ptr "VK_KHR_win32_surface\NUL"# + +{-# INLINE is_VK_KHR_WIN32_SURFACE_EXTENSION_NAME #-} + +is_VK_KHR_WIN32_SURFACE_EXTENSION_NAME :: CString -> Bool +is_VK_KHR_WIN32_SURFACE_EXTENSION_NAME + = eqCStrings _VK_KHR_WIN32_SURFACE_EXTENSION_NAME + +type VK_KHR_WIN32_SURFACE_EXTENSION_NAME = "VK_KHR_win32_surface" + +pattern VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR = + VkStructureType 1000009000 diff --git a/src-gen/Graphics/Vulkan/Ext/VK_KHR_xcb_surface.hs b/src-gen/Graphics/Vulkan/Ext/VK_KHR_xcb_surface.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Ext/VK_KHR_xcb_surface.hs @@ -0,0 +1,135 @@ +{-# OPTIONS_HADDOCK not-home#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE ForeignFunctionInterface #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE ViewPatterns #-} +module Graphics.Vulkan.Ext.VK_KHR_xcb_surface + (-- * Vulkan extension: @VK_KHR_xcb_surface@ + -- | + -- + -- supported: @vulkan@ + -- + -- contact: @Jesse Hall @jessehall,Ian Elliott ianelliott@google.com@ + -- + -- author: @KHR@ + -- + -- type: @instance@ + -- + -- Extension number: @6@ + -- + -- Required extensions: 'VK_KHR_surface'. + -- + -- Protected by CPP ifdef: @VK_USE_PLATFORM_XCB_KHR@ + -- + + -- ** Required extensions: 'VK_KHR_surface'. + module Graphics.Vulkan.Types.BaseTypes, + module Graphics.Vulkan.Types.Enum.VkStructureType, + module Graphics.Vulkan.Types.Bitmasks, + module Graphics.Vulkan.Types.Struct.VkXcbSurfaceCreateInfoKHR, + -- > #include "vk_platform.h" + -- + -- > #include + vkCreateXcbSurfaceKHR, + vkGetPhysicalDeviceXcbPresentationSupportKHR, + module Graphics.Vulkan.Marshal, + module Graphics.Vulkan.Types.Enum.VkInternalAllocationType, + module Graphics.Vulkan.Types.Enum.VkResult, + module Graphics.Vulkan.Types.Enum.VkSystemAllocationScope, + module Graphics.Vulkan.Types.Funcpointers, + module Graphics.Vulkan.Types.Handles, + module Graphics.Vulkan.Types.Include, + module Graphics.Vulkan.Types.Struct.VkAllocationCallbacks, + VK_KHR_XCB_SURFACE_SPEC_VERSION, + pattern VK_KHR_XCB_SURFACE_SPEC_VERSION, + VK_KHR_XCB_SURFACE_EXTENSION_NAME, + pattern VK_KHR_XCB_SURFACE_EXTENSION_NAME, + pattern VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR) + where +import GHC.Ptr (Ptr (..)) +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Types.BaseTypes +import Graphics.Vulkan.Types.Bitmasks +import Graphics.Vulkan.Types.Enum.VkInternalAllocationType +import Graphics.Vulkan.Types.Enum.VkResult +import Graphics.Vulkan.Types.Enum.VkStructureType +import Graphics.Vulkan.Types.Enum.VkSystemAllocationScope +import Graphics.Vulkan.Types.Funcpointers +import Graphics.Vulkan.Types.Handles +import Graphics.Vulkan.Types.Include +import Graphics.Vulkan.Types.Struct.VkAllocationCallbacks +import Graphics.Vulkan.Types.Struct.VkXcbSurfaceCreateInfoKHR + +-- | Success codes: 'VK_SUCCESS'. +-- +-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. +-- +-- > VkResult vkCreateXcbSurfaceKHR +-- > ( VkInstance instance +-- > , const VkXcbSurfaceCreateInfoKHR* pCreateInfo +-- > , const VkAllocationCallbacks* pAllocator +-- > , VkSurfaceKHR* pSurface +-- > ) +-- +-- +foreign import ccall unsafe "vkCreateXcbSurfaceKHR" + vkCreateXcbSurfaceKHR :: + VkInstance -- ^ instance + -> + Ptr VkXcbSurfaceCreateInfoKHR -- ^ pCreateInfo + -> + Ptr VkAllocationCallbacks -- ^ pAllocator + -> Ptr VkSurfaceKHR -- ^ pSurface + -> IO VkResult + +-- | > VkBool32 vkGetPhysicalDeviceXcbPresentationSupportKHR +-- > ( VkPhysicalDevice physicalDevice +-- > , uint32_t queueFamilyIndex +-- > , xcb_connection_t* connection +-- > , xcb_visualid_t visual_id +-- > ) +-- +-- +foreign import ccall unsafe + "vkGetPhysicalDeviceXcbPresentationSupportKHR" + vkGetPhysicalDeviceXcbPresentationSupportKHR :: + VkPhysicalDevice -- ^ physicalDevice + -> + Word32 -- ^ queueFamilyIndex + -> Ptr XcbConnectionT -- ^ connection + -> XcbVisualidT -- ^ visual_id + -> IO VkBool32 + +pattern VK_KHR_XCB_SURFACE_SPEC_VERSION :: (Num a, Eq a) => a + +pattern VK_KHR_XCB_SURFACE_SPEC_VERSION = 6 + +type VK_KHR_XCB_SURFACE_SPEC_VERSION = 6 + +pattern VK_KHR_XCB_SURFACE_EXTENSION_NAME :: CString + +pattern VK_KHR_XCB_SURFACE_EXTENSION_NAME <- + (is_VK_KHR_XCB_SURFACE_EXTENSION_NAME -> True) + where VK_KHR_XCB_SURFACE_EXTENSION_NAME + = _VK_KHR_XCB_SURFACE_EXTENSION_NAME + +{-# INLINE _VK_KHR_XCB_SURFACE_EXTENSION_NAME #-} + +_VK_KHR_XCB_SURFACE_EXTENSION_NAME :: CString +_VK_KHR_XCB_SURFACE_EXTENSION_NAME = Ptr "VK_KHR_xcb_surface\NUL"# + +{-# INLINE is_VK_KHR_XCB_SURFACE_EXTENSION_NAME #-} + +is_VK_KHR_XCB_SURFACE_EXTENSION_NAME :: CString -> Bool +is_VK_KHR_XCB_SURFACE_EXTENSION_NAME + = eqCStrings _VK_KHR_XCB_SURFACE_EXTENSION_NAME + +type VK_KHR_XCB_SURFACE_EXTENSION_NAME = "VK_KHR_xcb_surface" + +pattern VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR = + VkStructureType 1000005000 diff --git a/src-gen/Graphics/Vulkan/Ext/VK_KHR_xlib_surface.hs b/src-gen/Graphics/Vulkan/Ext/VK_KHR_xlib_surface.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Ext/VK_KHR_xlib_surface.hs @@ -0,0 +1,136 @@ +{-# OPTIONS_HADDOCK not-home#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE ForeignFunctionInterface #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE ViewPatterns #-} +module Graphics.Vulkan.Ext.VK_KHR_xlib_surface + (-- * Vulkan extension: @VK_KHR_xlib_surface@ + -- | + -- + -- supported: @vulkan@ + -- + -- contact: @Jesse Hall @jessehall,Ian Elliott ianelliott@google.com@ + -- + -- author: @KHR@ + -- + -- type: @instance@ + -- + -- Extension number: @5@ + -- + -- Required extensions: 'VK_KHR_surface'. + -- + -- Protected by CPP ifdef: @VK_USE_PLATFORM_XLIB_KHR@ + -- + + -- ** Required extensions: 'VK_KHR_surface'. + module Graphics.Vulkan.Types.BaseTypes, + module Graphics.Vulkan.Types.Enum.VkStructureType, + module Graphics.Vulkan.Types.Bitmasks, + module Graphics.Vulkan.Types.Struct.VkXlibSurfaceCreateInfoKHR, + -- > #include "vk_platform.h" + -- + -- > #include + vkCreateXlibSurfaceKHR, + vkGetPhysicalDeviceXlibPresentationSupportKHR, + module Graphics.Vulkan.Marshal, + module Graphics.Vulkan.Types.Enum.VkInternalAllocationType, + module Graphics.Vulkan.Types.Enum.VkResult, + module Graphics.Vulkan.Types.Enum.VkSystemAllocationScope, + module Graphics.Vulkan.Types.Funcpointers, + module Graphics.Vulkan.Types.Handles, + module Graphics.Vulkan.Types.Include, + module Graphics.Vulkan.Types.Struct.VkAllocationCallbacks, + VK_KHR_XLIB_SURFACE_SPEC_VERSION, + pattern VK_KHR_XLIB_SURFACE_SPEC_VERSION, + VK_KHR_XLIB_SURFACE_EXTENSION_NAME, + pattern VK_KHR_XLIB_SURFACE_EXTENSION_NAME, + pattern VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR) + where +import GHC.Ptr (Ptr (..)) +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Types.BaseTypes +import Graphics.Vulkan.Types.Bitmasks +import Graphics.Vulkan.Types.Enum.VkInternalAllocationType +import Graphics.Vulkan.Types.Enum.VkResult +import Graphics.Vulkan.Types.Enum.VkStructureType +import Graphics.Vulkan.Types.Enum.VkSystemAllocationScope +import Graphics.Vulkan.Types.Funcpointers +import Graphics.Vulkan.Types.Handles +import Graphics.Vulkan.Types.Include +import Graphics.Vulkan.Types.Struct.VkAllocationCallbacks +import Graphics.Vulkan.Types.Struct.VkXlibSurfaceCreateInfoKHR + +-- | Success codes: 'VK_SUCCESS'. +-- +-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. +-- +-- > VkResult vkCreateXlibSurfaceKHR +-- > ( VkInstance instance +-- > , const VkXlibSurfaceCreateInfoKHR* pCreateInfo +-- > , const VkAllocationCallbacks* pAllocator +-- > , VkSurfaceKHR* pSurface +-- > ) +-- +-- +foreign import ccall unsafe "vkCreateXlibSurfaceKHR" + vkCreateXlibSurfaceKHR :: + VkInstance -- ^ instance + -> + Ptr VkXlibSurfaceCreateInfoKHR -- ^ pCreateInfo + -> + Ptr VkAllocationCallbacks -- ^ pAllocator + -> Ptr VkSurfaceKHR -- ^ pSurface + -> IO VkResult + +-- | > VkBool32 vkGetPhysicalDeviceXlibPresentationSupportKHR +-- > ( VkPhysicalDevice physicalDevice +-- > , uint32_t queueFamilyIndex +-- > , Display* dpy +-- > , VisualID visualID +-- > ) +-- +-- +foreign import ccall unsafe + "vkGetPhysicalDeviceXlibPresentationSupportKHR" + vkGetPhysicalDeviceXlibPresentationSupportKHR :: + VkPhysicalDevice -- ^ physicalDevice + -> + Word32 -- ^ queueFamilyIndex + -> Ptr Display -- ^ dpy + -> VisualID -- ^ visualID + -> IO VkBool32 + +pattern VK_KHR_XLIB_SURFACE_SPEC_VERSION :: (Num a, Eq a) => a + +pattern VK_KHR_XLIB_SURFACE_SPEC_VERSION = 6 + +type VK_KHR_XLIB_SURFACE_SPEC_VERSION = 6 + +pattern VK_KHR_XLIB_SURFACE_EXTENSION_NAME :: CString + +pattern VK_KHR_XLIB_SURFACE_EXTENSION_NAME <- + (is_VK_KHR_XLIB_SURFACE_EXTENSION_NAME -> True) + where VK_KHR_XLIB_SURFACE_EXTENSION_NAME + = _VK_KHR_XLIB_SURFACE_EXTENSION_NAME + +{-# INLINE _VK_KHR_XLIB_SURFACE_EXTENSION_NAME #-} + +_VK_KHR_XLIB_SURFACE_EXTENSION_NAME :: CString +_VK_KHR_XLIB_SURFACE_EXTENSION_NAME + = Ptr "VK_KHR_xlib_surface\NUL"# + +{-# INLINE is_VK_KHR_XLIB_SURFACE_EXTENSION_NAME #-} + +is_VK_KHR_XLIB_SURFACE_EXTENSION_NAME :: CString -> Bool +is_VK_KHR_XLIB_SURFACE_EXTENSION_NAME + = eqCStrings _VK_KHR_XLIB_SURFACE_EXTENSION_NAME + +type VK_KHR_XLIB_SURFACE_EXTENSION_NAME = "VK_KHR_xlib_surface" + +pattern VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR = + VkStructureType 1000004000 diff --git a/src-gen/Graphics/Vulkan/Ext/VK_KHX_device_group.hs b/src-gen/Graphics/Vulkan/Ext/VK_KHX_device_group.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Ext/VK_KHX_device_group.hs @@ -0,0 +1,481 @@ +{-# OPTIONS_GHC -fno-warn-unused-imports#-} +{-# OPTIONS_HADDOCK not-home#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE ForeignFunctionInterface #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE ViewPatterns #-} +module Graphics.Vulkan.Ext.VK_KHX_device_group + (-- * Vulkan extension: @VK_KHX_device_group@ + -- | + -- + -- supported: @vulkan@ + -- + -- contact: @Jeff Bolz @jbolz@ + -- + -- author: @KHX@ + -- + -- type: @device@ + -- + -- Extension number: @61@ + -- + -- Required extensions: 'VK_KHX_device_group_creation'. + -- + + -- ** Required extensions: 'VK_KHX_device_group_creation'. + module Graphics.Vulkan.Types.Struct.VkBindSparseInfo, + module Graphics.Vulkan.Types.BaseTypes, + module Graphics.Vulkan.Types.Struct.VkClearColorValue, + module Graphics.Vulkan.Types.Struct.VkClearDepthStencilValue, + module Graphics.Vulkan.Types.Struct.VkClearValue, + module Graphics.Vulkan.Types.Struct.VkCommandBufferBeginInfo, + module Graphics.Vulkan.Types.Struct.VkCommandBufferInheritanceInfo, + module Graphics.Vulkan.Types.Enum.VkCommandBufferUsageFlags, + module Graphics.Vulkan.Types.Struct.VkDeviceGroupBindSparseInfoKHX, + module Graphics.Vulkan.Types.Struct.VkDeviceGroupCommandBufferBeginInfoKHX, + module Graphics.Vulkan.Types.Struct.VkDeviceGroupRenderPassBeginInfoKHX, + module Graphics.Vulkan.Types.Struct.VkDeviceGroupSubmitInfoKHX, + module Graphics.Vulkan.Types.Struct.VkExtent2D, + module Graphics.Vulkan.Types.Struct.VkExtent3D, + module Graphics.Vulkan.Types.Enum.VkImageAspectFlags, + module Graphics.Vulkan.Types.Struct.VkImageSubresource, + module Graphics.Vulkan.Types.Enum.VkMemoryAllocateFlagsKHX, + module Graphics.Vulkan.Types.Struct.VkMemoryAllocateFlagsInfoKHX, + module Graphics.Vulkan.Types.Struct.VkMemoryAllocateInfo, + module Graphics.Vulkan.Types.Struct.VkOffset2D, + module Graphics.Vulkan.Types.Struct.VkOffset3D, + module Graphics.Vulkan.Types.Enum.VkPeerMemoryFeatureFlagsKHX, + module Graphics.Vulkan.Types.Enum.VkPipelineStageFlags, + module Graphics.Vulkan.Types.Enum.VkQueryControlFlags, + module Graphics.Vulkan.Types.Enum.VkQueryPipelineStatisticFlags, + module Graphics.Vulkan.Types.Struct.VkRect2D, + module Graphics.Vulkan.Types.Struct.VkRenderPassBeginInfo, + module Graphics.Vulkan.Types.Struct.VkSparseBufferMemoryBindInfo, + module Graphics.Vulkan.Types.Struct.VkSparseImageMemoryBind, + module Graphics.Vulkan.Types.Struct.VkSparseImageMemoryBindInfo, + module Graphics.Vulkan.Types.Struct.VkSparseImageOpaqueMemoryBindInfo, + module Graphics.Vulkan.Types.Struct.VkSparseMemoryBind, + module Graphics.Vulkan.Types.Enum.VkSparseMemoryBindFlags, + module Graphics.Vulkan.Types.Enum.VkStructureType, + module Graphics.Vulkan.Types.Struct.VkSubmitInfo, + -- > #include "vk_platform.h" + vkGetDeviceGroupPeerMemoryFeaturesKHX, vkCmdSetDeviceMaskKHX, + vkCmdDispatchBaseKHX, module Graphics.Vulkan.Marshal, + module Graphics.Vulkan.Types.Handles, + VK_KHX_DEVICE_GROUP_SPEC_VERSION, + pattern VK_KHX_DEVICE_GROUP_SPEC_VERSION, + VK_KHX_DEVICE_GROUP_EXTENSION_NAME, + pattern VK_KHX_DEVICE_GROUP_EXTENSION_NAME, + pattern VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO_KHX, + pattern VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO_KHX, + pattern VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO_KHX, + pattern VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO_KHX, + pattern VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO_KHX, + pattern VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHX, + pattern VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHX, + pattern VK_PIPELINE_CREATE_DISPATCH_BASE_KHX, + pattern VK_DEPENDENCY_DEVICE_GROUP_BIT_KHX, + -- ** Required extensions: 'VK_KHR_bind_memory2', 'VK_KHX_device_group_creation'. + module Graphics.Vulkan.Types.Struct.VkBindBufferMemoryDeviceGroupInfoKHX, + module Graphics.Vulkan.Types.Struct.VkBindBufferMemoryInfoKHR, + module Graphics.Vulkan.Types.Struct.VkBindImageMemoryDeviceGroupInfoKHX, + module Graphics.Vulkan.Types.Struct.VkBindImageMemoryInfoKHR, + -- > #include "vk_platform.h" + pattern VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO_KHX, + pattern VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO_KHX, + pattern VK_IMAGE_CREATE_BIND_SFR_BIT_KHX, + -- ** Required extensions: 'VK_KHR_surface', 'VK_KHX_device_group_creation'. + module Graphics.Vulkan.Types.Struct.VkDeviceGroupPresentCapabilitiesKHX, + module Graphics.Vulkan.Types.Enum.VkDeviceGroupPresentModeFlagsKHX, + -- > #include "vk_platform.h" + vkGetDeviceGroupPresentCapabilitiesKHX, + vkGetDeviceGroupSurfacePresentModesKHX, + vkGetPhysicalDevicePresentRectanglesKHX, + module Graphics.Vulkan.Types.Enum.VkResult, + pattern VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHX, + -- ** Required extensions: 'VK_KHR_swapchain', 'VK_KHX_device_group_creation'. + module Graphics.Vulkan.Types.Struct.VkAcquireNextImageInfoKHX, + module Graphics.Vulkan.Types.Struct.VkBindImageMemorySwapchainInfoKHX, + module Graphics.Vulkan.Types.Enum.VkColorSpaceKHR, + module Graphics.Vulkan.Types.Enum.VkCompositeAlphaFlagsKHR, + module Graphics.Vulkan.Types.Struct.VkDeviceGroupPresentInfoKHX, + module Graphics.Vulkan.Types.Struct.VkDeviceGroupSwapchainCreateInfoKHX, + module Graphics.Vulkan.Types.Enum.VkFormat, + module Graphics.Vulkan.Types.Enum.VkImageCreateFlags, + module Graphics.Vulkan.Types.Struct.VkImageCreateInfo, + module Graphics.Vulkan.Types.Enum.VkImageLayout, + module Graphics.Vulkan.Types.Struct.VkImageSwapchainCreateInfoKHX, + module Graphics.Vulkan.Types.Enum.VkImageTiling, + module Graphics.Vulkan.Types.Enum.VkImageType, + module Graphics.Vulkan.Types.Enum.VkImageUsageFlags, + module Graphics.Vulkan.Types.Struct.VkPresentInfoKHR, + module Graphics.Vulkan.Types.Enum.VkPresentModeKHR, + module Graphics.Vulkan.Types.Enum.VkSampleCountFlags, + module Graphics.Vulkan.Types.Enum.VkSharingMode, + module Graphics.Vulkan.Types.Enum.VkSurfaceTransformFlagsKHR, + module Graphics.Vulkan.Types.Enum.VkSwapchainCreateFlagsKHR, + module Graphics.Vulkan.Types.Struct.VkSwapchainCreateInfoKHR, + -- > #include "vk_platform.h" + vkAcquireNextImage2KHX, + pattern VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHX, + pattern VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHX, + pattern VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHX, + pattern VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHX, + pattern VK_SWAPCHAIN_CREATE_BIND_SFR_BIT_KHX) + where +import GHC.Ptr + (Ptr (..)) +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Types.BaseTypes +import Graphics.Vulkan.Types.Enum.VkColorSpaceKHR +import Graphics.Vulkan.Types.Enum.VkCommandBufferUsageFlags +import Graphics.Vulkan.Types.Enum.VkCompositeAlphaFlagsKHR +import Graphics.Vulkan.Types.Enum.VkDependencyFlags + (VkDependencyBitmask (..), + VkDependencyFlagBits) +import Graphics.Vulkan.Types.Enum.VkDeviceGroupPresentModeFlagsKHX +import Graphics.Vulkan.Types.Enum.VkFormat +import Graphics.Vulkan.Types.Enum.VkImageAspectFlags +import Graphics.Vulkan.Types.Enum.VkImageCreateFlags +import Graphics.Vulkan.Types.Enum.VkImageLayout +import Graphics.Vulkan.Types.Enum.VkImageTiling +import Graphics.Vulkan.Types.Enum.VkImageType +import Graphics.Vulkan.Types.Enum.VkImageUsageFlags +import Graphics.Vulkan.Types.Enum.VkMemoryAllocateFlagsKHX +import Graphics.Vulkan.Types.Enum.VkPeerMemoryFeatureFlagsKHX +import Graphics.Vulkan.Types.Enum.VkPipelineCreateFlags + (VkPipelineCreateBitmask (..), + VkPipelineCreateFlagBits) +import Graphics.Vulkan.Types.Enum.VkPipelineStageFlags +import Graphics.Vulkan.Types.Enum.VkPresentModeKHR +import Graphics.Vulkan.Types.Enum.VkQueryControlFlags +import Graphics.Vulkan.Types.Enum.VkQueryPipelineStatisticFlags +import Graphics.Vulkan.Types.Enum.VkResult +import Graphics.Vulkan.Types.Enum.VkSampleCountFlags +import Graphics.Vulkan.Types.Enum.VkSharingMode +import Graphics.Vulkan.Types.Enum.VkSparseMemoryBindFlags +import Graphics.Vulkan.Types.Enum.VkStructureType +import Graphics.Vulkan.Types.Enum.VkSurfaceTransformFlagsKHR +import Graphics.Vulkan.Types.Enum.VkSwapchainCreateFlagsKHR +import Graphics.Vulkan.Types.Handles +import Graphics.Vulkan.Types.Struct.VkAcquireNextImageInfoKHX +import Graphics.Vulkan.Types.Struct.VkBindBufferMemoryDeviceGroupInfoKHX +import Graphics.Vulkan.Types.Struct.VkBindBufferMemoryInfoKHR +import Graphics.Vulkan.Types.Struct.VkBindImageMemoryDeviceGroupInfoKHX +import Graphics.Vulkan.Types.Struct.VkBindImageMemoryInfoKHR +import Graphics.Vulkan.Types.Struct.VkBindImageMemorySwapchainInfoKHX +import Graphics.Vulkan.Types.Struct.VkBindSparseInfo +import Graphics.Vulkan.Types.Struct.VkClearColorValue +import Graphics.Vulkan.Types.Struct.VkClearDepthStencilValue +import Graphics.Vulkan.Types.Struct.VkClearValue +import Graphics.Vulkan.Types.Struct.VkCommandBufferBeginInfo +import Graphics.Vulkan.Types.Struct.VkCommandBufferInheritanceInfo +import Graphics.Vulkan.Types.Struct.VkDeviceGroupBindSparseInfoKHX +import Graphics.Vulkan.Types.Struct.VkDeviceGroupCommandBufferBeginInfoKHX +import Graphics.Vulkan.Types.Struct.VkDeviceGroupPresentCapabilitiesKHX +import Graphics.Vulkan.Types.Struct.VkDeviceGroupPresentInfoKHX +import Graphics.Vulkan.Types.Struct.VkDeviceGroupRenderPassBeginInfoKHX +import Graphics.Vulkan.Types.Struct.VkDeviceGroupSubmitInfoKHX +import Graphics.Vulkan.Types.Struct.VkDeviceGroupSwapchainCreateInfoKHX +import Graphics.Vulkan.Types.Struct.VkExtent2D +import Graphics.Vulkan.Types.Struct.VkExtent3D +import Graphics.Vulkan.Types.Struct.VkImageCreateInfo +import Graphics.Vulkan.Types.Struct.VkImageSubresource +import Graphics.Vulkan.Types.Struct.VkImageSwapchainCreateInfoKHX +import Graphics.Vulkan.Types.Struct.VkMemoryAllocateFlagsInfoKHX +import Graphics.Vulkan.Types.Struct.VkMemoryAllocateInfo +import Graphics.Vulkan.Types.Struct.VkOffset2D +import Graphics.Vulkan.Types.Struct.VkOffset3D +import Graphics.Vulkan.Types.Struct.VkPresentInfoKHR +import Graphics.Vulkan.Types.Struct.VkRect2D +import Graphics.Vulkan.Types.Struct.VkRenderPassBeginInfo +import Graphics.Vulkan.Types.Struct.VkSparseBufferMemoryBindInfo +import Graphics.Vulkan.Types.Struct.VkSparseImageMemoryBind +import Graphics.Vulkan.Types.Struct.VkSparseImageMemoryBindInfo +import Graphics.Vulkan.Types.Struct.VkSparseImageOpaqueMemoryBindInfo +import Graphics.Vulkan.Types.Struct.VkSparseMemoryBind +import Graphics.Vulkan.Types.Struct.VkSubmitInfo +import Graphics.Vulkan.Types.Struct.VkSwapchainCreateInfoKHR + +-- | > () vkGetDeviceGroupPeerMemoryFeaturesKHX +-- > ( VkDevice device +-- > , uint32_t heapIndex +-- > , uint32_t localDeviceIndex +-- > , uint32_t remoteDeviceIndex +-- > , VkPeerMemoryFeatureFlagsKHX* pPeerMemoryFeatures +-- > ) +-- +-- +foreign import ccall unsafe "vkGetDeviceGroupPeerMemoryFeaturesKHX" + vkGetDeviceGroupPeerMemoryFeaturesKHX :: + VkDevice -- ^ device + -> + Word32 -- ^ heapIndex + -> + Word32 -- ^ localDeviceIndex + -> Word32 -- ^ remoteDeviceIndex + -> Ptr VkPeerMemoryFeatureFlagsKHX -- ^ pPeerMemoryFeatures + -> IO () + +-- | queues: 'graphics', 'compute', 'transfer'. +-- +-- renderpass: @both@ +-- +-- > () vkCmdSetDeviceMaskKHX +-- > ( VkCommandBuffer commandBuffer +-- > , uint32_t deviceMask +-- > ) +-- +-- +foreign import ccall unsafe "vkCmdSetDeviceMaskKHX" + vkCmdSetDeviceMaskKHX :: VkCommandBuffer -- ^ commandBuffer + -> Word32 -- ^ deviceMask + -> IO () + +-- | queues: 'compute'. +-- +-- renderpass: @outside@ +-- +-- > () vkCmdDispatchBaseKHX +-- > ( VkCommandBuffer commandBuffer +-- > , uint32_t baseGroupX +-- > , uint32_t baseGroupY +-- > , uint32_t baseGroupZ +-- > , uint32_t groupCountX +-- > , uint32_t groupCountY +-- > , uint32_t groupCountZ +-- > ) +-- +-- +foreign import ccall unsafe "vkCmdDispatchBaseKHX" + vkCmdDispatchBaseKHX :: + VkCommandBuffer -- ^ commandBuffer + -> + Word32 -- ^ baseGroupX + -> Word32 -- ^ baseGroupY + -> Word32 -- ^ baseGroupZ + -> Word32 -- ^ groupCountX + -> Word32 -- ^ groupCountY + -> Word32 -- ^ groupCountZ + -> IO () + +pattern VK_KHX_DEVICE_GROUP_SPEC_VERSION :: (Num a, Eq a) => a + +pattern VK_KHX_DEVICE_GROUP_SPEC_VERSION = 2 + +type VK_KHX_DEVICE_GROUP_SPEC_VERSION = 2 + +pattern VK_KHX_DEVICE_GROUP_EXTENSION_NAME :: CString + +pattern VK_KHX_DEVICE_GROUP_EXTENSION_NAME <- + (is_VK_KHX_DEVICE_GROUP_EXTENSION_NAME -> True) + where VK_KHX_DEVICE_GROUP_EXTENSION_NAME + = _VK_KHX_DEVICE_GROUP_EXTENSION_NAME + +{-# INLINE _VK_KHX_DEVICE_GROUP_EXTENSION_NAME #-} + +_VK_KHX_DEVICE_GROUP_EXTENSION_NAME :: CString +_VK_KHX_DEVICE_GROUP_EXTENSION_NAME + = Ptr "VK_KHX_device_group\NUL"# + +{-# INLINE is_VK_KHX_DEVICE_GROUP_EXTENSION_NAME #-} + +is_VK_KHX_DEVICE_GROUP_EXTENSION_NAME :: CString -> Bool +is_VK_KHX_DEVICE_GROUP_EXTENSION_NAME + = eqCStrings _VK_KHX_DEVICE_GROUP_EXTENSION_NAME + +type VK_KHX_DEVICE_GROUP_EXTENSION_NAME = "VK_KHX_device_group" + +pattern VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO_KHX :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO_KHX = + VkStructureType 1000060000 + +pattern VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO_KHX + :: VkStructureType + +pattern VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO_KHX = + VkStructureType 1000060003 + +pattern VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO_KHX + :: VkStructureType + +pattern VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO_KHX + = VkStructureType 1000060004 + +pattern VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO_KHX :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO_KHX = + VkStructureType 1000060005 + +pattern VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO_KHX :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO_KHX = + VkStructureType 1000060006 + +pattern VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHX :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHX = + VkStructureType 1000060010 + +-- | bitpos = @3@ +pattern VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHX :: + VkPipelineCreateFlagBits + +pattern VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHX = + VkPipelineCreateFlagBits 8 + +-- | bitpos = @4@ +pattern VK_PIPELINE_CREATE_DISPATCH_BASE_KHX :: + VkPipelineCreateFlagBits + +pattern VK_PIPELINE_CREATE_DISPATCH_BASE_KHX = + VkPipelineCreateFlagBits 16 + +-- | Dependency is across devices +-- +-- bitpos = @2@ +pattern VK_DEPENDENCY_DEVICE_GROUP_BIT_KHX :: VkDependencyFlagBits + +pattern VK_DEPENDENCY_DEVICE_GROUP_BIT_KHX = VkDependencyFlagBits 4 + +pattern VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO_KHX + :: VkStructureType + +pattern VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO_KHX + = VkStructureType 1000060013 + +pattern VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO_KHX + :: VkStructureType + +pattern VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO_KHX = + VkStructureType 1000060014 + +-- | Allows using VkBindImageMemoryDeviceGroupInfoKHX::pSFRRects when binding memory to the image +-- +-- bitpos = @6@ +pattern VK_IMAGE_CREATE_BIND_SFR_BIT_KHX :: VkImageCreateFlagBits + +pattern VK_IMAGE_CREATE_BIND_SFR_BIT_KHX = VkImageCreateFlagBits 64 + +-- | Success codes: 'VK_SUCCESS'. +-- +-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. +-- +-- > VkResult vkGetDeviceGroupPresentCapabilitiesKHX +-- > ( VkDevice device +-- > , VkDeviceGroupPresentCapabilitiesKHX* pDeviceGroupPresentCapabilities +-- > ) +-- +-- +foreign import ccall unsafe + "vkGetDeviceGroupPresentCapabilitiesKHX" + vkGetDeviceGroupPresentCapabilitiesKHX :: + VkDevice -- ^ device + -> Ptr VkDeviceGroupPresentCapabilitiesKHX -- ^ pDeviceGroupPresentCapabilities + -> IO VkResult + +-- | Success codes: 'VK_SUCCESS'. +-- +-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_SURFACE_LOST_KHR'. +-- +-- > VkResult vkGetDeviceGroupSurfacePresentModesKHX +-- > ( VkDevice device +-- > , VkSurfaceKHR surface +-- > , VkDeviceGroupPresentModeFlagsKHX* pModes +-- > ) +-- +-- +foreign import ccall unsafe + "vkGetDeviceGroupSurfacePresentModesKHX" + vkGetDeviceGroupSurfacePresentModesKHX :: + VkDevice -- ^ device + -> + VkSurfaceKHR -- ^ surface + -> Ptr VkDeviceGroupPresentModeFlagsKHX -- ^ pModes + -> IO VkResult + +-- | Success codes: 'VK_SUCCESS', 'VK_INCOMPLETE'. +-- +-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. +-- +-- > VkResult vkGetPhysicalDevicePresentRectanglesKHX +-- > ( VkPhysicalDevice physicalDevice +-- > , VkSurfaceKHR surface +-- > , uint32_t* pRectCount +-- > , VkRect2D* pRects +-- > ) +-- +-- +foreign import ccall unsafe + "vkGetPhysicalDevicePresentRectanglesKHX" + vkGetPhysicalDevicePresentRectanglesKHX :: + VkPhysicalDevice -- ^ physicalDevice + -> + VkSurfaceKHR -- ^ surface + -> Ptr Word32 -- ^ pRectCount + -> Ptr VkRect2D -- ^ pRects + -> IO VkResult + +pattern VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHX :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHX = + VkStructureType 1000060007 + +-- | Success codes: 'VK_SUCCESS', 'VK_TIMEOUT', 'VK_NOT_READY', 'VK_SUBOPTIMAL_KHR'. +-- +-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_DEVICE_LOST', 'VK_ERROR_OUT_OF_DATE_KHR', 'VK_ERROR_SURFACE_LOST_KHR'. +-- +-- > VkResult vkAcquireNextImage2KHX +-- > ( VkDevice device +-- > , const VkAcquireNextImageInfoKHX* pAcquireInfo +-- > , uint32_t* pImageIndex +-- > ) +-- +-- +foreign import ccall unsafe "vkAcquireNextImage2KHX" + vkAcquireNextImage2KHX :: + VkDevice -- ^ device + -> + Ptr VkAcquireNextImageInfoKHX -- ^ pAcquireInfo + -> Ptr Word32 -- ^ pImageIndex + -> IO VkResult + +pattern VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHX :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHX = + VkStructureType 1000060008 + +pattern VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHX :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHX = + VkStructureType 1000060009 + +pattern VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHX :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHX = + VkStructureType 1000060011 + +pattern VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHX :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHX = + VkStructureType 1000060012 + +-- | Allow images with VK_IMAGE_CREATE_BIND_SFR_BIT_KHX +-- +-- bitpos = @0@ +pattern VK_SWAPCHAIN_CREATE_BIND_SFR_BIT_KHX :: + VkSwapchainCreateFlagBitsKHR + +pattern VK_SWAPCHAIN_CREATE_BIND_SFR_BIT_KHX = + VkSwapchainCreateFlagBitsKHR 1 diff --git a/src-gen/Graphics/Vulkan/Ext/VK_KHX_device_group_creation.hs b/src-gen/Graphics/Vulkan/Ext/VK_KHX_device_group_creation.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Ext/VK_KHX_device_group_creation.hs @@ -0,0 +1,127 @@ +{-# OPTIONS_HADDOCK not-home#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE ForeignFunctionInterface #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE ViewPatterns #-} +module Graphics.Vulkan.Ext.VK_KHX_device_group_creation + (-- * Vulkan extension: @VK_KHX_device_group_creation@ + -- | + -- + -- supported: @vulkan@ + -- + -- contact: @Jeff Bolz @jbolz@ + -- + -- author: @KHX@ + -- + -- type: @instance@ + -- + -- Extension number: @71@ + module Graphics.Vulkan.Marshal, + module Graphics.Vulkan.Types.BaseTypes, + module Graphics.Vulkan.Types.Bitmasks, + module Graphics.Vulkan.Types.Struct.VkDeviceCreateInfo, + module Graphics.Vulkan.Types.Struct.VkDeviceGroupDeviceCreateInfoKHX, + module Graphics.Vulkan.Types.Struct.VkDeviceQueueCreateInfo, + module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceFeatures, + module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceGroupPropertiesKHX, + module Graphics.Vulkan.Types.Enum.VkStructureType, + -- > #include "vk_platform.h" + vkEnumeratePhysicalDeviceGroupsKHX, + module Graphics.Vulkan.Types.Enum.VkResult, + module Graphics.Vulkan.Types.Handles, + VK_KHX_DEVICE_GROUP_CREATION_SPEC_VERSION, + pattern VK_KHX_DEVICE_GROUP_CREATION_SPEC_VERSION, + VK_KHX_DEVICE_GROUP_CREATION_EXTENSION_NAME, + pattern VK_KHX_DEVICE_GROUP_CREATION_EXTENSION_NAME, + pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES_KHX, + pattern VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO_KHX, + pattern VK_MAX_DEVICE_GROUP_SIZE_KHX, VK_MAX_DEVICE_GROUP_SIZE_KHX, + pattern VK_MEMORY_HEAP_MULTI_INSTANCE_BIT_KHX) + where +import GHC.Ptr (Ptr (..)) +import Graphics.Vulkan.Constants (VK_MAX_DEVICE_GROUP_SIZE_KHX, + pattern VK_MAX_DEVICE_GROUP_SIZE_KHX) +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Types.BaseTypes +import Graphics.Vulkan.Types.Bitmasks +import Graphics.Vulkan.Types.Enum.VkMemoryHeapFlags (VkMemoryHeapBitmask (..), + VkMemoryHeapFlagBits) +import Graphics.Vulkan.Types.Enum.VkResult +import Graphics.Vulkan.Types.Enum.VkStructureType +import Graphics.Vulkan.Types.Handles +import Graphics.Vulkan.Types.Struct.VkDeviceCreateInfo +import Graphics.Vulkan.Types.Struct.VkDeviceGroupDeviceCreateInfoKHX +import Graphics.Vulkan.Types.Struct.VkDeviceQueueCreateInfo +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceFeatures +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceGroupPropertiesKHX + +-- | Success codes: 'VK_SUCCESS', 'VK_INCOMPLETE'. +-- +-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_INITIALIZATION_FAILED'. +-- +-- > VkResult vkEnumeratePhysicalDeviceGroupsKHX +-- > ( VkInstance instance +-- > , uint32_t* pPhysicalDeviceGroupCount +-- > , VkPhysicalDeviceGroupPropertiesKHX* pPhysicalDeviceGroupProperties +-- > ) +-- +-- +foreign import ccall unsafe "vkEnumeratePhysicalDeviceGroupsKHX" + vkEnumeratePhysicalDeviceGroupsKHX :: + VkInstance -- ^ instance + -> + Ptr Word32 -- ^ pPhysicalDeviceGroupCount + -> Ptr VkPhysicalDeviceGroupPropertiesKHX -- ^ pPhysicalDeviceGroupProperties + -> IO VkResult + +pattern VK_KHX_DEVICE_GROUP_CREATION_SPEC_VERSION :: + (Num a, Eq a) => a + +pattern VK_KHX_DEVICE_GROUP_CREATION_SPEC_VERSION = 1 + +type VK_KHX_DEVICE_GROUP_CREATION_SPEC_VERSION = 1 + +pattern VK_KHX_DEVICE_GROUP_CREATION_EXTENSION_NAME :: CString + +pattern VK_KHX_DEVICE_GROUP_CREATION_EXTENSION_NAME <- + (is_VK_KHX_DEVICE_GROUP_CREATION_EXTENSION_NAME -> True) + where VK_KHX_DEVICE_GROUP_CREATION_EXTENSION_NAME + = _VK_KHX_DEVICE_GROUP_CREATION_EXTENSION_NAME + +{-# INLINE _VK_KHX_DEVICE_GROUP_CREATION_EXTENSION_NAME #-} + +_VK_KHX_DEVICE_GROUP_CREATION_EXTENSION_NAME :: CString +_VK_KHX_DEVICE_GROUP_CREATION_EXTENSION_NAME + = Ptr "VK_KHX_device_group_creation\NUL"# + +{-# INLINE is_VK_KHX_DEVICE_GROUP_CREATION_EXTENSION_NAME #-} + +is_VK_KHX_DEVICE_GROUP_CREATION_EXTENSION_NAME :: CString -> Bool +is_VK_KHX_DEVICE_GROUP_CREATION_EXTENSION_NAME + = eqCStrings _VK_KHX_DEVICE_GROUP_CREATION_EXTENSION_NAME + +type VK_KHX_DEVICE_GROUP_CREATION_EXTENSION_NAME = + "VK_KHX_device_group_creation" + +pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES_KHX :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES_KHX = + VkStructureType 1000070000 + +pattern VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO_KHX :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO_KHX = + VkStructureType 1000070001 + +-- | If set, heap allocations allocate multiple instances by default +-- +-- bitpos = @1@ +pattern VK_MEMORY_HEAP_MULTI_INSTANCE_BIT_KHX :: + VkMemoryHeapFlagBits + +pattern VK_MEMORY_HEAP_MULTI_INSTANCE_BIT_KHX = + VkMemoryHeapFlagBits 2 diff --git a/src-gen/Graphics/Vulkan/Ext/VK_KHX_multiview.hs b/src-gen/Graphics/Vulkan/Ext/VK_KHX_multiview.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Ext/VK_KHX_multiview.hs @@ -0,0 +1,149 @@ +{-# OPTIONS_HADDOCK not-home#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE ViewPatterns #-} +module Graphics.Vulkan.Ext.VK_KHX_multiview + (-- * Vulkan extension: @VK_KHX_multiview@ + -- | + -- + -- supported: @vulkan@ + -- + -- contact: @Jeff Bolz @jbolz@ + -- + -- author: @NV@ + -- + -- type: @device@ + -- + -- Extension number: @54@ + -- + -- Required extensions: 'VK_KHR_get_physical_device_properties2'. + -- + + -- ** Required extensions: 'VK_KHR_get_physical_device_properties2'. + module Graphics.Vulkan.Marshal, + module Graphics.Vulkan.Types.Enum.VkAccessFlags, + module Graphics.Vulkan.Types.Struct.VkAttachmentDescription, + module Graphics.Vulkan.Types.Enum.VkAttachmentDescriptionFlags, + module Graphics.Vulkan.Types.Enum.VkAttachmentLoadOp, + module Graphics.Vulkan.Types.Struct.VkAttachmentReference, + module Graphics.Vulkan.Types.Enum.VkAttachmentStoreOp, + module Graphics.Vulkan.Types.BaseTypes, + module Graphics.Vulkan.Types.Enum.VkDependencyFlags, + module Graphics.Vulkan.Types.Bitmasks, + module Graphics.Vulkan.Types.Struct.VkDeviceCreateInfo, + module Graphics.Vulkan.Types.Struct.VkDeviceQueueCreateInfo, + module Graphics.Vulkan.Types.Enum.VkFormat, + module Graphics.Vulkan.Types.Enum.VkImageLayout, + module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceFeatures, + module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceFeatures2KHR, + module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceLimits, + module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceMultiviewFeaturesKHX, + module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceMultiviewPropertiesKHX, + module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceProperties, + module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceProperties2KHR, + module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceSparseProperties, + module Graphics.Vulkan.Types.Enum.VkPhysicalDeviceType, + module Graphics.Vulkan.Types.Enum.VkPipelineBindPoint, + module Graphics.Vulkan.Types.Enum.VkPipelineStageFlags, + module Graphics.Vulkan.Types.Struct.VkRenderPassCreateInfo, + module Graphics.Vulkan.Types.Struct.VkRenderPassMultiviewCreateInfoKHX, + module Graphics.Vulkan.Types.Enum.VkSampleCountFlags, + module Graphics.Vulkan.Types.Enum.VkStructureType, + module Graphics.Vulkan.Types.Struct.VkSubpassDependency, + module Graphics.Vulkan.Types.Struct.VkSubpassDescription, + module Graphics.Vulkan.Types.Enum.VkSubpassDescriptionFlags, + -- > #include "vk_platform.h" + VK_KHX_MULTIVIEW_SPEC_VERSION, + pattern VK_KHX_MULTIVIEW_SPEC_VERSION, + VK_KHX_MULTIVIEW_EXTENSION_NAME, + pattern VK_KHX_MULTIVIEW_EXTENSION_NAME, + pattern VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO_KHX, + pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHX, + pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHX, + pattern VK_DEPENDENCY_VIEW_LOCAL_BIT_KHX) + where +import GHC.Ptr + (Ptr (..)) +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Types.BaseTypes +import Graphics.Vulkan.Types.Bitmasks +import Graphics.Vulkan.Types.Enum.VkAccessFlags +import Graphics.Vulkan.Types.Enum.VkAttachmentDescriptionFlags +import Graphics.Vulkan.Types.Enum.VkAttachmentLoadOp +import Graphics.Vulkan.Types.Enum.VkAttachmentStoreOp +import Graphics.Vulkan.Types.Enum.VkDependencyFlags +import Graphics.Vulkan.Types.Enum.VkFormat +import Graphics.Vulkan.Types.Enum.VkImageLayout +import Graphics.Vulkan.Types.Enum.VkPhysicalDeviceType +import Graphics.Vulkan.Types.Enum.VkPipelineBindPoint +import Graphics.Vulkan.Types.Enum.VkPipelineStageFlags +import Graphics.Vulkan.Types.Enum.VkSampleCountFlags +import Graphics.Vulkan.Types.Enum.VkStructureType +import Graphics.Vulkan.Types.Enum.VkSubpassDescriptionFlags +import Graphics.Vulkan.Types.Struct.VkAttachmentDescription +import Graphics.Vulkan.Types.Struct.VkAttachmentReference +import Graphics.Vulkan.Types.Struct.VkDeviceCreateInfo +import Graphics.Vulkan.Types.Struct.VkDeviceQueueCreateInfo +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceFeatures +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceFeatures2KHR +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceLimits +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceMultiviewFeaturesKHX +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceMultiviewPropertiesKHX +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceProperties +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceProperties2KHR +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceSparseProperties +import Graphics.Vulkan.Types.Struct.VkRenderPassCreateInfo +import Graphics.Vulkan.Types.Struct.VkRenderPassMultiviewCreateInfoKHX +import Graphics.Vulkan.Types.Struct.VkSubpassDependency +import Graphics.Vulkan.Types.Struct.VkSubpassDescription + +pattern VK_KHX_MULTIVIEW_SPEC_VERSION :: (Num a, Eq a) => a + +pattern VK_KHX_MULTIVIEW_SPEC_VERSION = 1 + +type VK_KHX_MULTIVIEW_SPEC_VERSION = 1 + +pattern VK_KHX_MULTIVIEW_EXTENSION_NAME :: CString + +pattern VK_KHX_MULTIVIEW_EXTENSION_NAME <- + (is_VK_KHX_MULTIVIEW_EXTENSION_NAME -> True) + where VK_KHX_MULTIVIEW_EXTENSION_NAME + = _VK_KHX_MULTIVIEW_EXTENSION_NAME + +{-# INLINE _VK_KHX_MULTIVIEW_EXTENSION_NAME #-} + +_VK_KHX_MULTIVIEW_EXTENSION_NAME :: CString +_VK_KHX_MULTIVIEW_EXTENSION_NAME = Ptr "VK_KHX_multiview\NUL"# + +{-# INLINE is_VK_KHX_MULTIVIEW_EXTENSION_NAME #-} + +is_VK_KHX_MULTIVIEW_EXTENSION_NAME :: CString -> Bool +is_VK_KHX_MULTIVIEW_EXTENSION_NAME + = eqCStrings _VK_KHX_MULTIVIEW_EXTENSION_NAME + +type VK_KHX_MULTIVIEW_EXTENSION_NAME = "VK_KHX_multiview" + +pattern VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO_KHX :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO_KHX = + VkStructureType 1000053000 + +pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHX :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHX = + VkStructureType 1000053001 + +pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHX + :: VkStructureType + +pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHX + = VkStructureType 1000053002 + +-- | bitpos = @1@ +pattern VK_DEPENDENCY_VIEW_LOCAL_BIT_KHX :: VkDependencyFlagBits + +pattern VK_DEPENDENCY_VIEW_LOCAL_BIT_KHX = VkDependencyFlagBits 2 diff --git a/src-gen/Graphics/Vulkan/Ext/VK_MVK_ios_surface.hs b/src-gen/Graphics/Vulkan/Ext/VK_MVK_ios_surface.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Ext/VK_MVK_ios_surface.hs @@ -0,0 +1,111 @@ +{-# OPTIONS_HADDOCK not-home#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE ForeignFunctionInterface #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE ViewPatterns #-} +module Graphics.Vulkan.Ext.VK_MVK_ios_surface + (-- * Vulkan extension: @VK_MVK_ios_surface@ + -- | + -- + -- supported: @vulkan@ + -- + -- contact: @Bill Hollings @billhollings@ + -- + -- author: @MVK@ + -- + -- type: @instance@ + -- + -- Extension number: @123@ + -- + -- Required extensions: 'VK_KHR_surface'. + -- + -- Protected by CPP ifdef: @VK_USE_PLATFORM_IOS_MVK@ + -- + + -- ** Required extensions: 'VK_KHR_surface'. + module Graphics.Vulkan.Types.BaseTypes, + module Graphics.Vulkan.Types.Bitmasks, + module Graphics.Vulkan.Types.Struct.VkIOSSurfaceCreateInfoMVK, + module Graphics.Vulkan.Types.Enum.VkStructureType, + -- > #include "vk_platform.h" + vkCreateIOSSurfaceMVK, module Graphics.Vulkan.Marshal, + module Graphics.Vulkan.Types.Enum.VkInternalAllocationType, + module Graphics.Vulkan.Types.Enum.VkResult, + module Graphics.Vulkan.Types.Enum.VkSystemAllocationScope, + module Graphics.Vulkan.Types.Funcpointers, + module Graphics.Vulkan.Types.Handles, + module Graphics.Vulkan.Types.Struct.VkAllocationCallbacks, + VK_MVK_IOS_SURFACE_SPEC_VERSION, + pattern VK_MVK_IOS_SURFACE_SPEC_VERSION, + VK_MVK_IOS_SURFACE_EXTENSION_NAME, + pattern VK_MVK_IOS_SURFACE_EXTENSION_NAME, + pattern VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK) + where +import GHC.Ptr (Ptr (..)) +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Types.BaseTypes +import Graphics.Vulkan.Types.Bitmasks +import Graphics.Vulkan.Types.Enum.VkInternalAllocationType +import Graphics.Vulkan.Types.Enum.VkResult +import Graphics.Vulkan.Types.Enum.VkStructureType +import Graphics.Vulkan.Types.Enum.VkSystemAllocationScope +import Graphics.Vulkan.Types.Funcpointers +import Graphics.Vulkan.Types.Handles +import Graphics.Vulkan.Types.Struct.VkAllocationCallbacks +import Graphics.Vulkan.Types.Struct.VkIOSSurfaceCreateInfoMVK + +-- | Success codes: 'VK_SUCCESS'. +-- +-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_NATIVE_WINDOW_IN_USE_KHR'. +-- +-- > VkResult vkCreateIOSSurfaceMVK +-- > ( VkInstance instance +-- > , const VkIOSSurfaceCreateInfoMVK* pCreateInfo +-- > , const VkAllocationCallbacks* pAllocator +-- > , VkSurfaceKHR* pSurface +-- > ) +-- +-- +foreign import ccall unsafe "vkCreateIOSSurfaceMVK" + vkCreateIOSSurfaceMVK :: + VkInstance -- ^ instance + -> + Ptr VkIOSSurfaceCreateInfoMVK -- ^ pCreateInfo + -> + Ptr VkAllocationCallbacks -- ^ pAllocator + -> Ptr VkSurfaceKHR -- ^ pSurface + -> IO VkResult + +pattern VK_MVK_IOS_SURFACE_SPEC_VERSION :: (Num a, Eq a) => a + +pattern VK_MVK_IOS_SURFACE_SPEC_VERSION = 2 + +type VK_MVK_IOS_SURFACE_SPEC_VERSION = 2 + +pattern VK_MVK_IOS_SURFACE_EXTENSION_NAME :: CString + +pattern VK_MVK_IOS_SURFACE_EXTENSION_NAME <- + (is_VK_MVK_IOS_SURFACE_EXTENSION_NAME -> True) + where VK_MVK_IOS_SURFACE_EXTENSION_NAME + = _VK_MVK_IOS_SURFACE_EXTENSION_NAME + +{-# INLINE _VK_MVK_IOS_SURFACE_EXTENSION_NAME #-} + +_VK_MVK_IOS_SURFACE_EXTENSION_NAME :: CString +_VK_MVK_IOS_SURFACE_EXTENSION_NAME = Ptr "VK_MVK_ios_surface\NUL"# + +{-# INLINE is_VK_MVK_IOS_SURFACE_EXTENSION_NAME #-} + +is_VK_MVK_IOS_SURFACE_EXTENSION_NAME :: CString -> Bool +is_VK_MVK_IOS_SURFACE_EXTENSION_NAME + = eqCStrings _VK_MVK_IOS_SURFACE_EXTENSION_NAME + +type VK_MVK_IOS_SURFACE_EXTENSION_NAME = "VK_MVK_ios_surface" + +pattern VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK = + VkStructureType 1000122000 diff --git a/src-gen/Graphics/Vulkan/Ext/VK_MVK_macos_surface.hs b/src-gen/Graphics/Vulkan/Ext/VK_MVK_macos_surface.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Ext/VK_MVK_macos_surface.hs @@ -0,0 +1,112 @@ +{-# OPTIONS_HADDOCK not-home#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE ForeignFunctionInterface #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE ViewPatterns #-} +module Graphics.Vulkan.Ext.VK_MVK_macos_surface + (-- * Vulkan extension: @VK_MVK_macos_surface@ + -- | + -- + -- supported: @vulkan@ + -- + -- contact: @Bill Hollings @billhollings@ + -- + -- author: @MVK@ + -- + -- type: @instance@ + -- + -- Extension number: @124@ + -- + -- Required extensions: 'VK_KHR_surface'. + -- + -- Protected by CPP ifdef: @VK_USE_PLATFORM_MACOS_MVK@ + -- + + -- ** Required extensions: 'VK_KHR_surface'. + module Graphics.Vulkan.Types.BaseTypes, + module Graphics.Vulkan.Types.Bitmasks, + module Graphics.Vulkan.Types.Struct.VkMacOSSurfaceCreateInfoMVK, + module Graphics.Vulkan.Types.Enum.VkStructureType, + -- > #include "vk_platform.h" + vkCreateMacOSSurfaceMVK, module Graphics.Vulkan.Marshal, + module Graphics.Vulkan.Types.Enum.VkInternalAllocationType, + module Graphics.Vulkan.Types.Enum.VkResult, + module Graphics.Vulkan.Types.Enum.VkSystemAllocationScope, + module Graphics.Vulkan.Types.Funcpointers, + module Graphics.Vulkan.Types.Handles, + module Graphics.Vulkan.Types.Struct.VkAllocationCallbacks, + VK_MVK_MACOS_SURFACE_SPEC_VERSION, + pattern VK_MVK_MACOS_SURFACE_SPEC_VERSION, + VK_MVK_MACOS_SURFACE_EXTENSION_NAME, + pattern VK_MVK_MACOS_SURFACE_EXTENSION_NAME, + pattern VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK) + where +import GHC.Ptr (Ptr (..)) +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Types.BaseTypes +import Graphics.Vulkan.Types.Bitmasks +import Graphics.Vulkan.Types.Enum.VkInternalAllocationType +import Graphics.Vulkan.Types.Enum.VkResult +import Graphics.Vulkan.Types.Enum.VkStructureType +import Graphics.Vulkan.Types.Enum.VkSystemAllocationScope +import Graphics.Vulkan.Types.Funcpointers +import Graphics.Vulkan.Types.Handles +import Graphics.Vulkan.Types.Struct.VkAllocationCallbacks +import Graphics.Vulkan.Types.Struct.VkMacOSSurfaceCreateInfoMVK + +-- | Success codes: 'VK_SUCCESS'. +-- +-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_NATIVE_WINDOW_IN_USE_KHR'. +-- +-- > VkResult vkCreateMacOSSurfaceMVK +-- > ( VkInstance instance +-- > , const VkMacOSSurfaceCreateInfoMVK* pCreateInfo +-- > , const VkAllocationCallbacks* pAllocator +-- > , VkSurfaceKHR* pSurface +-- > ) +-- +-- +foreign import ccall unsafe "vkCreateMacOSSurfaceMVK" + vkCreateMacOSSurfaceMVK :: + VkInstance -- ^ instance + -> + Ptr VkMacOSSurfaceCreateInfoMVK -- ^ pCreateInfo + -> + Ptr VkAllocationCallbacks -- ^ pAllocator + -> Ptr VkSurfaceKHR -- ^ pSurface + -> IO VkResult + +pattern VK_MVK_MACOS_SURFACE_SPEC_VERSION :: (Num a, Eq a) => a + +pattern VK_MVK_MACOS_SURFACE_SPEC_VERSION = 2 + +type VK_MVK_MACOS_SURFACE_SPEC_VERSION = 2 + +pattern VK_MVK_MACOS_SURFACE_EXTENSION_NAME :: CString + +pattern VK_MVK_MACOS_SURFACE_EXTENSION_NAME <- + (is_VK_MVK_MACOS_SURFACE_EXTENSION_NAME -> True) + where VK_MVK_MACOS_SURFACE_EXTENSION_NAME + = _VK_MVK_MACOS_SURFACE_EXTENSION_NAME + +{-# INLINE _VK_MVK_MACOS_SURFACE_EXTENSION_NAME #-} + +_VK_MVK_MACOS_SURFACE_EXTENSION_NAME :: CString +_VK_MVK_MACOS_SURFACE_EXTENSION_NAME + = Ptr "VK_MVK_macos_surface\NUL"# + +{-# INLINE is_VK_MVK_MACOS_SURFACE_EXTENSION_NAME #-} + +is_VK_MVK_MACOS_SURFACE_EXTENSION_NAME :: CString -> Bool +is_VK_MVK_MACOS_SURFACE_EXTENSION_NAME + = eqCStrings _VK_MVK_MACOS_SURFACE_EXTENSION_NAME + +type VK_MVK_MACOS_SURFACE_EXTENSION_NAME = "VK_MVK_macos_surface" + +pattern VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK = + VkStructureType 1000123000 diff --git a/src-gen/Graphics/Vulkan/Ext/VK_NN_vi_surface.hs b/src-gen/Graphics/Vulkan/Ext/VK_NN_vi_surface.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Ext/VK_NN_vi_surface.hs @@ -0,0 +1,111 @@ +{-# OPTIONS_HADDOCK not-home#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE ForeignFunctionInterface #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE ViewPatterns #-} +module Graphics.Vulkan.Ext.VK_NN_vi_surface + (-- * Vulkan extension: @VK_NN_vi_surface@ + -- | + -- + -- supported: @vulkan@ + -- + -- contact: @Mathias Heyer @mheyer@ + -- + -- author: @NN@ + -- + -- type: @instance@ + -- + -- Extension number: @63@ + -- + -- Required extensions: 'VK_KHR_surface'. + -- + -- Protected by CPP ifdef: @VK_USE_PLATFORM_VI_NN@ + -- + + -- ** Required extensions: 'VK_KHR_surface'. + module Graphics.Vulkan.Types.BaseTypes, + module Graphics.Vulkan.Types.Enum.VkStructureType, + module Graphics.Vulkan.Types.Bitmasks, + module Graphics.Vulkan.Types.Struct.VkViSurfaceCreateInfoNN, + -- > #include "vk_platform.h" + vkCreateViSurfaceNN, module Graphics.Vulkan.Marshal, + module Graphics.Vulkan.Types.Enum.VkInternalAllocationType, + module Graphics.Vulkan.Types.Enum.VkResult, + module Graphics.Vulkan.Types.Enum.VkSystemAllocationScope, + module Graphics.Vulkan.Types.Funcpointers, + module Graphics.Vulkan.Types.Handles, + module Graphics.Vulkan.Types.Struct.VkAllocationCallbacks, + VK_NN_VI_SURFACE_SPEC_VERSION, + pattern VK_NN_VI_SURFACE_SPEC_VERSION, + VK_NN_VI_SURFACE_EXTENSION_NAME, + pattern VK_NN_VI_SURFACE_EXTENSION_NAME, + pattern VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN) + where +import GHC.Ptr (Ptr (..)) +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Types.BaseTypes +import Graphics.Vulkan.Types.Bitmasks +import Graphics.Vulkan.Types.Enum.VkInternalAllocationType +import Graphics.Vulkan.Types.Enum.VkResult +import Graphics.Vulkan.Types.Enum.VkStructureType +import Graphics.Vulkan.Types.Enum.VkSystemAllocationScope +import Graphics.Vulkan.Types.Funcpointers +import Graphics.Vulkan.Types.Handles +import Graphics.Vulkan.Types.Struct.VkAllocationCallbacks +import Graphics.Vulkan.Types.Struct.VkViSurfaceCreateInfoNN + +-- | Success codes: 'VK_SUCCESS'. +-- +-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_NATIVE_WINDOW_IN_USE_KHR'. +-- +-- > VkResult vkCreateViSurfaceNN +-- > ( VkInstance instance +-- > , const VkViSurfaceCreateInfoNN* pCreateInfo +-- > , const VkAllocationCallbacks* pAllocator +-- > , VkSurfaceKHR* pSurface +-- > ) +-- +-- +foreign import ccall unsafe "vkCreateViSurfaceNN" + vkCreateViSurfaceNN :: + VkInstance -- ^ instance + -> + Ptr VkViSurfaceCreateInfoNN -- ^ pCreateInfo + -> + Ptr VkAllocationCallbacks -- ^ pAllocator + -> Ptr VkSurfaceKHR -- ^ pSurface + -> IO VkResult + +pattern VK_NN_VI_SURFACE_SPEC_VERSION :: (Num a, Eq a) => a + +pattern VK_NN_VI_SURFACE_SPEC_VERSION = 1 + +type VK_NN_VI_SURFACE_SPEC_VERSION = 1 + +pattern VK_NN_VI_SURFACE_EXTENSION_NAME :: CString + +pattern VK_NN_VI_SURFACE_EXTENSION_NAME <- + (is_VK_NN_VI_SURFACE_EXTENSION_NAME -> True) + where VK_NN_VI_SURFACE_EXTENSION_NAME + = _VK_NN_VI_SURFACE_EXTENSION_NAME + +{-# INLINE _VK_NN_VI_SURFACE_EXTENSION_NAME #-} + +_VK_NN_VI_SURFACE_EXTENSION_NAME :: CString +_VK_NN_VI_SURFACE_EXTENSION_NAME = Ptr "VK_NN_vi_surface\NUL"# + +{-# INLINE is_VK_NN_VI_SURFACE_EXTENSION_NAME #-} + +is_VK_NN_VI_SURFACE_EXTENSION_NAME :: CString -> Bool +is_VK_NN_VI_SURFACE_EXTENSION_NAME + = eqCStrings _VK_NN_VI_SURFACE_EXTENSION_NAME + +type VK_NN_VI_SURFACE_EXTENSION_NAME = "VK_NN_vi_surface" + +pattern VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN = + VkStructureType 1000062000 diff --git a/src-gen/Graphics/Vulkan/Ext/VK_NVX_device_generated_commands.hs b/src-gen/Graphics/Vulkan/Ext/VK_NVX_device_generated_commands.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Ext/VK_NVX_device_generated_commands.hs @@ -0,0 +1,381 @@ +{-# OPTIONS_HADDOCK not-home#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE ForeignFunctionInterface #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE ViewPatterns #-} +module Graphics.Vulkan.Ext.VK_NVX_device_generated_commands + (-- * Vulkan extension: @VK_NVX_device_generated_commands@ + -- | + -- + -- supported: @vulkan@ + -- + -- contact: @Christoph Kubisch @pixeljetstream@ + -- + -- author: @NVX@ + -- + -- type: @device@ + -- + -- Extension number: @87@ + module Graphics.Vulkan.Types.BaseTypes, + module Graphics.Vulkan.Types.Struct.VkCmdProcessCommandsInfoNVX, + module Graphics.Vulkan.Types.Struct.VkCmdReserveSpaceForCommandsInfoNVX, + module Graphics.Vulkan.Types.Struct.VkDeviceGeneratedCommandsFeaturesNVX, + module Graphics.Vulkan.Types.Struct.VkDeviceGeneratedCommandsLimitsNVX, + module Graphics.Vulkan.Types.Enum.VkIndexType, + module Graphics.Vulkan.Types.Struct.VkIndirectCommandsLayoutCreateInfoNVX, + module Graphics.Vulkan.Types.Struct.VkIndirectCommandsLayoutTokenNVX, + module Graphics.Vulkan.Types.Enum.VkIndirectCommandsLayoutUsageFlagsNVX, + module Graphics.Vulkan.Types.Struct.VkIndirectCommandsTokenNVX, + module Graphics.Vulkan.Types.Enum.VkIndirectCommandsTokenTypeNVX, + module Graphics.Vulkan.Types.Enum.VkObjectEntryTypeNVX, + module Graphics.Vulkan.Types.Enum.VkObjectEntryUsageFlagsNVX, + module Graphics.Vulkan.Types.Struct.VkObjectTableCreateInfoNVX, + module Graphics.Vulkan.Types.Struct.VkObjectTableDescriptorSetEntryNVX, + module Graphics.Vulkan.Types.Struct.VkObjectTableEntryNVX, + module Graphics.Vulkan.Types.Struct.VkObjectTableIndexBufferEntryNVX, + module Graphics.Vulkan.Types.Struct.VkObjectTablePipelineEntryNVX, + module Graphics.Vulkan.Types.Struct.VkObjectTablePushConstantEntryNVX, + module Graphics.Vulkan.Types.Struct.VkObjectTableVertexBufferEntryNVX, + module Graphics.Vulkan.Types.Enum.VkPipelineBindPoint, + module Graphics.Vulkan.Types.Enum.VkShaderStageFlags, + module Graphics.Vulkan.Types.Enum.VkStructureType, + -- > #include "vk_platform.h" + vkCmdProcessCommandsNVX, vkCmdReserveSpaceForCommandsNVX, + vkCreateIndirectCommandsLayoutNVX, + vkDestroyIndirectCommandsLayoutNVX, vkCreateObjectTableNVX, + vkDestroyObjectTableNVX, vkRegisterObjectsNVX, + vkUnregisterObjectsNVX, + vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX, + module Graphics.Vulkan.Marshal, + module Graphics.Vulkan.Types.Enum.VkInternalAllocationType, + module Graphics.Vulkan.Types.Enum.VkResult, + module Graphics.Vulkan.Types.Enum.VkSystemAllocationScope, + module Graphics.Vulkan.Types.Funcpointers, + module Graphics.Vulkan.Types.Handles, + module Graphics.Vulkan.Types.Struct.VkAllocationCallbacks, + VK_NVX_DEVICE_GENERATED_COMMANDS_SPEC_VERSION, + pattern VK_NVX_DEVICE_GENERATED_COMMANDS_SPEC_VERSION, + VK_NVX_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME, + pattern VK_NVX_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME, + pattern VK_STRUCTURE_TYPE_OBJECT_TABLE_CREATE_INFO_NVX, + pattern VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NVX, + pattern VK_STRUCTURE_TYPE_CMD_PROCESS_COMMANDS_INFO_NVX, + pattern VK_STRUCTURE_TYPE_CMD_RESERVE_SPACE_FOR_COMMANDS_INFO_NVX, + pattern VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_LIMITS_NVX, + pattern VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_FEATURES_NVX, + pattern VK_PIPELINE_STAGE_COMMAND_PROCESS_BIT_NVX, + pattern VK_ACCESS_COMMAND_PROCESS_READ_BIT_NVX, + pattern VK_ACCESS_COMMAND_PROCESS_WRITE_BIT_NVX, + pattern VK_OBJECT_TYPE_OBJECT_TABLE_NVX, + pattern VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX) + where +import GHC.Ptr + (Ptr (..)) +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Types.BaseTypes +import Graphics.Vulkan.Types.Enum.VkAccessFlags + (VkAccessBitmask (..), + VkAccessFlagBits) +import Graphics.Vulkan.Types.Enum.VkIndexType +import Graphics.Vulkan.Types.Enum.VkIndirectCommandsLayoutUsageFlagsNVX +import Graphics.Vulkan.Types.Enum.VkIndirectCommandsTokenTypeNVX +import Graphics.Vulkan.Types.Enum.VkInternalAllocationType +import Graphics.Vulkan.Types.Enum.VkObjectEntryTypeNVX +import Graphics.Vulkan.Types.Enum.VkObjectEntryUsageFlagsNVX +import Graphics.Vulkan.Types.Enum.VkObjectType + (VkObjectType (..)) +import Graphics.Vulkan.Types.Enum.VkPipelineBindPoint +import Graphics.Vulkan.Types.Enum.VkPipelineStageFlags + (VkPipelineStageBitmask (..), + VkPipelineStageFlagBits) +import Graphics.Vulkan.Types.Enum.VkResult +import Graphics.Vulkan.Types.Enum.VkShaderStageFlags +import Graphics.Vulkan.Types.Enum.VkStructureType +import Graphics.Vulkan.Types.Enum.VkSystemAllocationScope +import Graphics.Vulkan.Types.Funcpointers +import Graphics.Vulkan.Types.Handles +import Graphics.Vulkan.Types.Struct.VkAllocationCallbacks +import Graphics.Vulkan.Types.Struct.VkCmdProcessCommandsInfoNVX +import Graphics.Vulkan.Types.Struct.VkCmdReserveSpaceForCommandsInfoNVX +import Graphics.Vulkan.Types.Struct.VkDeviceGeneratedCommandsFeaturesNVX +import Graphics.Vulkan.Types.Struct.VkDeviceGeneratedCommandsLimitsNVX +import Graphics.Vulkan.Types.Struct.VkIndirectCommandsLayoutCreateInfoNVX +import Graphics.Vulkan.Types.Struct.VkIndirectCommandsLayoutTokenNVX +import Graphics.Vulkan.Types.Struct.VkIndirectCommandsTokenNVX +import Graphics.Vulkan.Types.Struct.VkObjectTableCreateInfoNVX +import Graphics.Vulkan.Types.Struct.VkObjectTableDescriptorSetEntryNVX +import Graphics.Vulkan.Types.Struct.VkObjectTableEntryNVX +import Graphics.Vulkan.Types.Struct.VkObjectTableIndexBufferEntryNVX +import Graphics.Vulkan.Types.Struct.VkObjectTablePipelineEntryNVX +import Graphics.Vulkan.Types.Struct.VkObjectTablePushConstantEntryNVX +import Graphics.Vulkan.Types.Struct.VkObjectTableVertexBufferEntryNVX + +-- | queues: 'graphics', 'compute'. +-- +-- renderpass: @inside@ +-- +-- > () vkCmdProcessCommandsNVX +-- > ( VkCommandBuffer commandBuffer +-- > , const VkCmdProcessCommandsInfoNVX* pProcessCommandsInfo +-- > ) +-- +-- +foreign import ccall unsafe "vkCmdProcessCommandsNVX" + vkCmdProcessCommandsNVX :: + VkCommandBuffer -- ^ commandBuffer + -> Ptr VkCmdProcessCommandsInfoNVX -- ^ pProcessCommandsInfo + -> IO () + +-- | queues: 'graphics', 'compute'. +-- +-- renderpass: @inside@ +-- +-- > () vkCmdReserveSpaceForCommandsNVX +-- > ( VkCommandBuffer commandBuffer +-- > , const VkCmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo +-- > ) +-- +-- +foreign import ccall unsafe "vkCmdReserveSpaceForCommandsNVX" + vkCmdReserveSpaceForCommandsNVX :: + VkCommandBuffer -- ^ commandBuffer + -> Ptr VkCmdReserveSpaceForCommandsInfoNVX -- ^ pReserveSpaceInfo + -> IO () + +-- | Success codes: 'VK_SUCCESS'. +-- +-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. +-- +-- > VkResult vkCreateIndirectCommandsLayoutNVX +-- > ( VkDevice device +-- > , const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo +-- > , const VkAllocationCallbacks* pAllocator +-- > , VkIndirectCommandsLayoutNVX* pIndirectCommandsLayout +-- > ) +-- +-- +foreign import ccall unsafe "vkCreateIndirectCommandsLayoutNVX" + vkCreateIndirectCommandsLayoutNVX :: + VkDevice -- ^ device + -> + Ptr VkIndirectCommandsLayoutCreateInfoNVX -- ^ pCreateInfo + -> + Ptr VkAllocationCallbacks -- ^ pAllocator + -> + Ptr VkIndirectCommandsLayoutNVX -- ^ pIndirectCommandsLayout + -> IO VkResult + +-- | > () vkDestroyIndirectCommandsLayoutNVX +-- > ( VkDevice device +-- > , VkIndirectCommandsLayoutNVX indirectCommandsLayout +-- > , const VkAllocationCallbacks* pAllocator +-- > ) +-- +-- +foreign import ccall unsafe "vkDestroyIndirectCommandsLayoutNVX" + vkDestroyIndirectCommandsLayoutNVX :: + VkDevice -- ^ device + -> + VkIndirectCommandsLayoutNVX -- ^ indirectCommandsLayout + -> Ptr VkAllocationCallbacks -- ^ pAllocator + -> IO () + +-- | Success codes: 'VK_SUCCESS'. +-- +-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. +-- +-- > VkResult vkCreateObjectTableNVX +-- > ( VkDevice device +-- > , const VkObjectTableCreateInfoNVX* pCreateInfo +-- > , const VkAllocationCallbacks* pAllocator +-- > , VkObjectTableNVX* pObjectTable +-- > ) +-- +-- +foreign import ccall unsafe "vkCreateObjectTableNVX" + vkCreateObjectTableNVX :: + VkDevice -- ^ device + -> + Ptr VkObjectTableCreateInfoNVX -- ^ pCreateInfo + -> + Ptr VkAllocationCallbacks -- ^ pAllocator + -> Ptr VkObjectTableNVX -- ^ pObjectTable + -> IO VkResult + +-- | > () vkDestroyObjectTableNVX +-- > ( VkDevice device +-- > , VkObjectTableNVX objectTable +-- > , const VkAllocationCallbacks* pAllocator +-- > ) +-- +-- +foreign import ccall unsafe "vkDestroyObjectTableNVX" + vkDestroyObjectTableNVX :: + VkDevice -- ^ device + -> VkObjectTableNVX -- ^ objectTable + -> Ptr VkAllocationCallbacks -- ^ pAllocator + -> IO () + +-- | Success codes: 'VK_SUCCESS'. +-- +-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. +-- +-- > VkResult vkRegisterObjectsNVX +-- > ( VkDevice device +-- > , VkObjectTableNVX objectTable +-- > , uint32_t objectCount +-- > , const VkObjectTableEntryNVX* const* ppObjectTableEntries +-- > , const uint32_t* pObjectIndices +-- > ) +-- +-- +foreign import ccall unsafe "vkRegisterObjectsNVX" + vkRegisterObjectsNVX :: + VkDevice -- ^ device + -> + VkObjectTableNVX -- ^ objectTable + -> + Word32 -- ^ objectCount + -> + Ptr (Ptr VkObjectTableEntryNVX) -- ^ ppObjectTableEntries + -> Ptr Word32 -- ^ pObjectIndices + -> IO VkResult + +-- | Success codes: 'VK_SUCCESS'. +-- +-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY'. +-- +-- > VkResult vkUnregisterObjectsNVX +-- > ( VkDevice device +-- > , VkObjectTableNVX objectTable +-- > , uint32_t objectCount +-- > , const VkObjectEntryTypeNVX* pObjectEntryTypes +-- > , const uint32_t* pObjectIndices +-- > ) +-- +-- +foreign import ccall unsafe "vkUnregisterObjectsNVX" + vkUnregisterObjectsNVX :: + VkDevice -- ^ device + -> + VkObjectTableNVX -- ^ objectTable + -> + Word32 -- ^ objectCount + -> Ptr VkObjectEntryTypeNVX -- ^ pObjectEntryTypes + -> Ptr Word32 -- ^ pObjectIndices + -> IO VkResult + +-- | > () vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX +-- > ( VkPhysicalDevice physicalDevice +-- > , VkDeviceGeneratedCommandsFeaturesNVX* pFeatures +-- > , VkDeviceGeneratedCommandsLimitsNVX* pLimits +-- > ) +-- +-- +foreign import ccall unsafe + "vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX" + vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX :: + VkPhysicalDevice -- ^ physicalDevice + -> + Ptr VkDeviceGeneratedCommandsFeaturesNVX -- ^ pFeatures + -> + Ptr VkDeviceGeneratedCommandsLimitsNVX -- ^ pLimits + -> IO () + +pattern VK_NVX_DEVICE_GENERATED_COMMANDS_SPEC_VERSION :: + (Num a, Eq a) => a + +pattern VK_NVX_DEVICE_GENERATED_COMMANDS_SPEC_VERSION = 3 + +type VK_NVX_DEVICE_GENERATED_COMMANDS_SPEC_VERSION = 3 + +pattern VK_NVX_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME :: CString + +pattern VK_NVX_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME <- + (is_VK_NVX_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME -> True) + where VK_NVX_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME + = _VK_NVX_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME + +{-# INLINE _VK_NVX_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME #-} + +_VK_NVX_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME :: CString +_VK_NVX_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME + = Ptr "VK_NVX_device_generated_commands\NUL"# + +{-# INLINE is_VK_NVX_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME #-} + +is_VK_NVX_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME :: + CString -> Bool +is_VK_NVX_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME + = eqCStrings _VK_NVX_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME + +type VK_NVX_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME = + "VK_NVX_device_generated_commands" + +pattern VK_STRUCTURE_TYPE_OBJECT_TABLE_CREATE_INFO_NVX :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_OBJECT_TABLE_CREATE_INFO_NVX = + VkStructureType 1000086000 + +pattern VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NVX + :: VkStructureType + +pattern VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NVX + = VkStructureType 1000086001 + +pattern VK_STRUCTURE_TYPE_CMD_PROCESS_COMMANDS_INFO_NVX :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_CMD_PROCESS_COMMANDS_INFO_NVX = + VkStructureType 1000086002 + +pattern VK_STRUCTURE_TYPE_CMD_RESERVE_SPACE_FOR_COMMANDS_INFO_NVX + :: VkStructureType + +pattern VK_STRUCTURE_TYPE_CMD_RESERVE_SPACE_FOR_COMMANDS_INFO_NVX = + VkStructureType 1000086003 + +pattern VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_LIMITS_NVX :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_LIMITS_NVX = + VkStructureType 1000086004 + +pattern VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_FEATURES_NVX :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_FEATURES_NVX = + VkStructureType 1000086005 + +-- | bitpos = @17@ +pattern VK_PIPELINE_STAGE_COMMAND_PROCESS_BIT_NVX :: + VkPipelineStageFlagBits + +pattern VK_PIPELINE_STAGE_COMMAND_PROCESS_BIT_NVX = + VkPipelineStageFlagBits 131072 + +-- | bitpos = @17@ +pattern VK_ACCESS_COMMAND_PROCESS_READ_BIT_NVX :: VkAccessFlagBits + +pattern VK_ACCESS_COMMAND_PROCESS_READ_BIT_NVX = + VkAccessFlagBits 131072 + +-- | bitpos = @18@ +pattern VK_ACCESS_COMMAND_PROCESS_WRITE_BIT_NVX :: VkAccessFlagBits + +pattern VK_ACCESS_COMMAND_PROCESS_WRITE_BIT_NVX = + VkAccessFlagBits 262144 + +-- | VkobjectTableNVX +pattern VK_OBJECT_TYPE_OBJECT_TABLE_NVX :: VkObjectType + +pattern VK_OBJECT_TYPE_OBJECT_TABLE_NVX = VkObjectType 1000086000 + +-- | VkIndirectCommandsLayoutNVX +pattern VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX :: VkObjectType + +pattern VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX = + VkObjectType 1000086001 diff --git a/src-gen/Graphics/Vulkan/Ext/VK_NVX_multiview_per_view_attributes.hs b/src-gen/Graphics/Vulkan/Ext/VK_NVX_multiview_per_view_attributes.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Ext/VK_NVX_multiview_per_view_attributes.hs @@ -0,0 +1,110 @@ +{-# OPTIONS_HADDOCK not-home#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE ViewPatterns #-} +module Graphics.Vulkan.Ext.VK_NVX_multiview_per_view_attributes + (-- * Vulkan extension: @VK_NVX_multiview_per_view_attributes@ + -- | + -- + -- supported: @vulkan@ + -- + -- contact: @Jeff Bolz @jbolz@ + -- + -- author: @NVX@ + -- + -- type: @device@ + -- + -- Extension number: @98@ + -- + -- Required extensions: 'VK_KHX_multiview'. + -- + + -- ** Required extensions: 'VK_KHX_multiview'. + module Graphics.Vulkan.Marshal, + module Graphics.Vulkan.Types.BaseTypes, + module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceLimits, + module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX, + module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceProperties, + module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceProperties2KHR, + module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceSparseProperties, + module Graphics.Vulkan.Types.Enum.VkPhysicalDeviceType, + module Graphics.Vulkan.Types.Enum.VkSampleCountFlags, + module Graphics.Vulkan.Types.Enum.VkStructureType, + -- > #include "vk_platform.h" + VK_NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_SPEC_VERSION, + pattern VK_NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_SPEC_VERSION, + VK_NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_EXTENSION_NAME, + pattern VK_NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_EXTENSION_NAME, + pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX, + pattern VK_SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX, + pattern VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX) + where +import GHC.Ptr + (Ptr (..)) +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Types.BaseTypes +import Graphics.Vulkan.Types.Enum.VkPhysicalDeviceType +import Graphics.Vulkan.Types.Enum.VkSampleCountFlags +import Graphics.Vulkan.Types.Enum.VkStructureType +import Graphics.Vulkan.Types.Enum.VkSubpassDescriptionFlags + (VkSubpassDescriptionBitmask (..), + VkSubpassDescriptionFlagBits) +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceLimits +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceProperties +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceProperties2KHR +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceSparseProperties + +pattern VK_NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_SPEC_VERSION :: + (Num a, Eq a) => a + +pattern VK_NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_SPEC_VERSION = 1 + +type VK_NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_SPEC_VERSION = 1 + +pattern VK_NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_EXTENSION_NAME :: + CString + +pattern VK_NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_EXTENSION_NAME <- + (is_VK_NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_EXTENSION_NAME -> True) + where VK_NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_EXTENSION_NAME + = _VK_NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_EXTENSION_NAME + +{-# INLINE _VK_NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_EXTENSION_NAME #-} + +_VK_NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_EXTENSION_NAME :: CString +_VK_NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_EXTENSION_NAME + = Ptr "VK_NVX_multiview_per_view_attributes\NUL"# + +{-# INLINE is_VK_NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_EXTENSION_NAME + #-} + +is_VK_NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_EXTENSION_NAME :: + CString -> Bool +is_VK_NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_EXTENSION_NAME + = eqCStrings _VK_NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_EXTENSION_NAME + +type VK_NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_EXTENSION_NAME = + "VK_NVX_multiview_per_view_attributes" + +pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX + :: VkStructureType + +pattern VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX + = VkStructureType 1000097000 + +-- | bitpos = @0@ +pattern VK_SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX :: + VkSubpassDescriptionFlagBits + +pattern VK_SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX = + VkSubpassDescriptionFlagBits 1 + +-- | bitpos = @1@ +pattern VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX :: + VkSubpassDescriptionFlagBits + +pattern VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX = + VkSubpassDescriptionFlagBits 2 diff --git a/src-gen/Graphics/Vulkan/Ext/VK_NV_clip_space_w_scaling.hs b/src-gen/Graphics/Vulkan/Ext/VK_NV_clip_space_w_scaling.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Ext/VK_NV_clip_space_w_scaling.hs @@ -0,0 +1,116 @@ +{-# OPTIONS_HADDOCK not-home#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE ForeignFunctionInterface #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE ViewPatterns #-} +module Graphics.Vulkan.Ext.VK_NV_clip_space_w_scaling + (-- * Vulkan extension: @VK_NV_clip_space_w_scaling@ + -- | + -- + -- supported: @vulkan@ + -- + -- contact: @Eric Werness @ewerness@ + -- + -- author: @NV@ + -- + -- type: @device@ + -- + -- Extension number: @88@ + module Graphics.Vulkan.Types.BaseTypes, + module Graphics.Vulkan.Types.Struct.VkExtent2D, + module Graphics.Vulkan.Types.Struct.VkOffset2D, + module Graphics.Vulkan.Types.Bitmasks, + module Graphics.Vulkan.Types.Struct.VkPipelineViewportStateCreateInfo, + module Graphics.Vulkan.Types.Struct.VkPipelineViewportWScalingStateCreateInfoNV, + module Graphics.Vulkan.Types.Struct.VkRect2D, + module Graphics.Vulkan.Types.Enum.VkStructureType, + module Graphics.Vulkan.Types.Struct.VkViewport, + module Graphics.Vulkan.Types.Struct.VkViewportWScalingNV, + -- > #include "vk_platform.h" + vkCmdSetViewportWScalingNV, module Graphics.Vulkan.Types.Handles, + VK_NV_CLIP_SPACE_W_SCALING_SPEC_VERSION, + pattern VK_NV_CLIP_SPACE_W_SCALING_SPEC_VERSION, + VK_NV_CLIP_SPACE_W_SCALING_EXTENSION_NAME, + pattern VK_NV_CLIP_SPACE_W_SCALING_EXTENSION_NAME, + pattern VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV, + pattern VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV) + where +import GHC.Ptr + (Ptr (..)) +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Types.BaseTypes +import Graphics.Vulkan.Types.Bitmasks +import Graphics.Vulkan.Types.Enum.VkDynamicState + (VkDynamicState (..)) +import Graphics.Vulkan.Types.Enum.VkStructureType +import Graphics.Vulkan.Types.Handles +import Graphics.Vulkan.Types.Struct.VkExtent2D +import Graphics.Vulkan.Types.Struct.VkOffset2D +import Graphics.Vulkan.Types.Struct.VkPipelineViewportStateCreateInfo +import Graphics.Vulkan.Types.Struct.VkPipelineViewportWScalingStateCreateInfoNV +import Graphics.Vulkan.Types.Struct.VkRect2D +import Graphics.Vulkan.Types.Struct.VkViewport +import Graphics.Vulkan.Types.Struct.VkViewportWScalingNV + +-- | queues: 'graphics'. +-- +-- renderpass: @both@ +-- +-- > () vkCmdSetViewportWScalingNV +-- > ( VkCommandBuffer commandBuffer +-- > , uint32_t firstViewport +-- > , uint32_t viewportCount +-- > , const VkViewportWScalingNV* pViewportWScalings +-- > ) +-- +-- +foreign import ccall unsafe "vkCmdSetViewportWScalingNV" + vkCmdSetViewportWScalingNV :: + VkCommandBuffer -- ^ commandBuffer + -> + Word32 -- ^ firstViewport + -> Word32 -- ^ viewportCount + -> Ptr VkViewportWScalingNV -- ^ pViewportWScalings + -> IO () + +pattern VK_NV_CLIP_SPACE_W_SCALING_SPEC_VERSION :: (Num a, Eq a) => + a + +pattern VK_NV_CLIP_SPACE_W_SCALING_SPEC_VERSION = 1 + +type VK_NV_CLIP_SPACE_W_SCALING_SPEC_VERSION = 1 + +pattern VK_NV_CLIP_SPACE_W_SCALING_EXTENSION_NAME :: CString + +pattern VK_NV_CLIP_SPACE_W_SCALING_EXTENSION_NAME <- + (is_VK_NV_CLIP_SPACE_W_SCALING_EXTENSION_NAME -> True) + where VK_NV_CLIP_SPACE_W_SCALING_EXTENSION_NAME + = _VK_NV_CLIP_SPACE_W_SCALING_EXTENSION_NAME + +{-# INLINE _VK_NV_CLIP_SPACE_W_SCALING_EXTENSION_NAME #-} + +_VK_NV_CLIP_SPACE_W_SCALING_EXTENSION_NAME :: CString +_VK_NV_CLIP_SPACE_W_SCALING_EXTENSION_NAME + = Ptr "VK_NV_clip_space_w_scaling\NUL"# + +{-# INLINE is_VK_NV_CLIP_SPACE_W_SCALING_EXTENSION_NAME #-} + +is_VK_NV_CLIP_SPACE_W_SCALING_EXTENSION_NAME :: CString -> Bool +is_VK_NV_CLIP_SPACE_W_SCALING_EXTENSION_NAME + = eqCStrings _VK_NV_CLIP_SPACE_W_SCALING_EXTENSION_NAME + +type VK_NV_CLIP_SPACE_W_SCALING_EXTENSION_NAME = + "VK_NV_clip_space_w_scaling" + +pattern VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV + :: VkStructureType + +pattern VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV + = VkStructureType 1000087000 + +pattern VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV :: VkDynamicState + +pattern VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV = + VkDynamicState 1000087000 diff --git a/src-gen/Graphics/Vulkan/Ext/VK_NV_dedicated_allocation.hs b/src-gen/Graphics/Vulkan/Ext/VK_NV_dedicated_allocation.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Ext/VK_NV_dedicated_allocation.hs @@ -0,0 +1,116 @@ +{-# OPTIONS_HADDOCK not-home#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE ViewPatterns #-} +module Graphics.Vulkan.Ext.VK_NV_dedicated_allocation + (-- * Vulkan extension: @VK_NV_dedicated_allocation@ + -- | + -- + -- supported: @vulkan@ + -- + -- contact: @Jeff Bolz @jbolz@ + -- + -- author: @NV@ + -- + -- type: @device@ + -- + -- Extension number: @27@ + module Graphics.Vulkan.Types.BaseTypes, + module Graphics.Vulkan.Types.Enum.VkBufferCreateFlags, + module Graphics.Vulkan.Types.Struct.VkBufferCreateInfo, + module Graphics.Vulkan.Types.Enum.VkBufferUsageFlags, + module Graphics.Vulkan.Types.Struct.VkDedicatedAllocationBufferCreateInfoNV, + module Graphics.Vulkan.Types.Struct.VkDedicatedAllocationImageCreateInfoNV, + module Graphics.Vulkan.Types.Struct.VkDedicatedAllocationMemoryAllocateInfoNV, + module Graphics.Vulkan.Types.Struct.VkExtent3D, + module Graphics.Vulkan.Types.Enum.VkFormat, + module Graphics.Vulkan.Types.Enum.VkImageCreateFlags, + module Graphics.Vulkan.Types.Struct.VkImageCreateInfo, + module Graphics.Vulkan.Types.Enum.VkImageLayout, + module Graphics.Vulkan.Types.Enum.VkImageTiling, + module Graphics.Vulkan.Types.Enum.VkImageType, + module Graphics.Vulkan.Types.Enum.VkImageUsageFlags, + module Graphics.Vulkan.Types.Struct.VkMemoryAllocateInfo, + module Graphics.Vulkan.Types.Enum.VkSampleCountFlags, + module Graphics.Vulkan.Types.Enum.VkSharingMode, + module Graphics.Vulkan.Types.Enum.VkStructureType, + -- > #include "vk_platform.h" + VK_NV_DEDICATED_ALLOCATION_SPEC_VERSION, + pattern VK_NV_DEDICATED_ALLOCATION_SPEC_VERSION, + VK_NV_DEDICATED_ALLOCATION_EXTENSION_NAME, + pattern VK_NV_DEDICATED_ALLOCATION_EXTENSION_NAME, + pattern VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV, + pattern VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV, + pattern VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV) + where +import GHC.Ptr + (Ptr (..)) +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Types.BaseTypes +import Graphics.Vulkan.Types.Enum.VkBufferCreateFlags +import Graphics.Vulkan.Types.Enum.VkBufferUsageFlags +import Graphics.Vulkan.Types.Enum.VkFormat +import Graphics.Vulkan.Types.Enum.VkImageCreateFlags +import Graphics.Vulkan.Types.Enum.VkImageLayout +import Graphics.Vulkan.Types.Enum.VkImageTiling +import Graphics.Vulkan.Types.Enum.VkImageType +import Graphics.Vulkan.Types.Enum.VkImageUsageFlags +import Graphics.Vulkan.Types.Enum.VkSampleCountFlags +import Graphics.Vulkan.Types.Enum.VkSharingMode +import Graphics.Vulkan.Types.Enum.VkStructureType +import Graphics.Vulkan.Types.Struct.VkBufferCreateInfo +import Graphics.Vulkan.Types.Struct.VkDedicatedAllocationBufferCreateInfoNV +import Graphics.Vulkan.Types.Struct.VkDedicatedAllocationImageCreateInfoNV +import Graphics.Vulkan.Types.Struct.VkDedicatedAllocationMemoryAllocateInfoNV +import Graphics.Vulkan.Types.Struct.VkExtent3D +import Graphics.Vulkan.Types.Struct.VkImageCreateInfo +import Graphics.Vulkan.Types.Struct.VkMemoryAllocateInfo + +pattern VK_NV_DEDICATED_ALLOCATION_SPEC_VERSION :: (Num a, Eq a) => + a + +pattern VK_NV_DEDICATED_ALLOCATION_SPEC_VERSION = 1 + +type VK_NV_DEDICATED_ALLOCATION_SPEC_VERSION = 1 + +pattern VK_NV_DEDICATED_ALLOCATION_EXTENSION_NAME :: CString + +pattern VK_NV_DEDICATED_ALLOCATION_EXTENSION_NAME <- + (is_VK_NV_DEDICATED_ALLOCATION_EXTENSION_NAME -> True) + where VK_NV_DEDICATED_ALLOCATION_EXTENSION_NAME + = _VK_NV_DEDICATED_ALLOCATION_EXTENSION_NAME + +{-# INLINE _VK_NV_DEDICATED_ALLOCATION_EXTENSION_NAME #-} + +_VK_NV_DEDICATED_ALLOCATION_EXTENSION_NAME :: CString +_VK_NV_DEDICATED_ALLOCATION_EXTENSION_NAME + = Ptr "VK_NV_dedicated_allocation\NUL"# + +{-# INLINE is_VK_NV_DEDICATED_ALLOCATION_EXTENSION_NAME #-} + +is_VK_NV_DEDICATED_ALLOCATION_EXTENSION_NAME :: CString -> Bool +is_VK_NV_DEDICATED_ALLOCATION_EXTENSION_NAME + = eqCStrings _VK_NV_DEDICATED_ALLOCATION_EXTENSION_NAME + +type VK_NV_DEDICATED_ALLOCATION_EXTENSION_NAME = + "VK_NV_dedicated_allocation" + +pattern VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV + :: VkStructureType + +pattern VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV + = VkStructureType 1000026000 + +pattern VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV + :: VkStructureType + +pattern VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV + = VkStructureType 1000026001 + +pattern VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV + :: VkStructureType + +pattern VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV + = VkStructureType 1000026002 diff --git a/src-gen/Graphics/Vulkan/Ext/VK_NV_external_memory.hs b/src-gen/Graphics/Vulkan/Ext/VK_NV_external_memory.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Ext/VK_NV_external_memory.hs @@ -0,0 +1,105 @@ +{-# OPTIONS_HADDOCK not-home#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE ViewPatterns #-} +module Graphics.Vulkan.Ext.VK_NV_external_memory + (-- * Vulkan extension: @VK_NV_external_memory@ + -- | + -- + -- supported: @vulkan@ + -- + -- contact: @James Jones @cubanismo@ + -- + -- author: @NV@ + -- + -- type: @device@ + -- + -- Extension number: @57@ + -- + -- Required extensions: 'VK_NV_external_memory_capabilities'. + -- + + -- ** Required extensions: 'VK_NV_external_memory_capabilities'. + module Graphics.Vulkan.Types.BaseTypes, + module Graphics.Vulkan.Types.Struct.VkExportMemoryAllocateInfoNV, + module Graphics.Vulkan.Types.Struct.VkExtent3D, + module Graphics.Vulkan.Types.Enum.VkExternalMemoryHandleTypeFlagsNV, + module Graphics.Vulkan.Types.Struct.VkExternalMemoryImageCreateInfoNV, + module Graphics.Vulkan.Types.Enum.VkFormat, + module Graphics.Vulkan.Types.Enum.VkImageCreateFlags, + module Graphics.Vulkan.Types.Struct.VkImageCreateInfo, + module Graphics.Vulkan.Types.Enum.VkImageLayout, + module Graphics.Vulkan.Types.Enum.VkImageTiling, + module Graphics.Vulkan.Types.Enum.VkImageType, + module Graphics.Vulkan.Types.Enum.VkImageUsageFlags, + module Graphics.Vulkan.Types.Struct.VkMemoryAllocateInfo, + module Graphics.Vulkan.Types.Enum.VkSampleCountFlags, + module Graphics.Vulkan.Types.Enum.VkSharingMode, + module Graphics.Vulkan.Types.Enum.VkStructureType, + -- > #include "vk_platform.h" + VK_NV_EXTERNAL_MEMORY_SPEC_VERSION, + pattern VK_NV_EXTERNAL_MEMORY_SPEC_VERSION, + VK_NV_EXTERNAL_MEMORY_EXTENSION_NAME, + pattern VK_NV_EXTERNAL_MEMORY_EXTENSION_NAME, + pattern VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV, + pattern VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV) + where +import GHC.Ptr (Ptr (..)) +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Types.BaseTypes +import Graphics.Vulkan.Types.Enum.VkExternalMemoryHandleTypeFlagsNV +import Graphics.Vulkan.Types.Enum.VkFormat +import Graphics.Vulkan.Types.Enum.VkImageCreateFlags +import Graphics.Vulkan.Types.Enum.VkImageLayout +import Graphics.Vulkan.Types.Enum.VkImageTiling +import Graphics.Vulkan.Types.Enum.VkImageType +import Graphics.Vulkan.Types.Enum.VkImageUsageFlags +import Graphics.Vulkan.Types.Enum.VkSampleCountFlags +import Graphics.Vulkan.Types.Enum.VkSharingMode +import Graphics.Vulkan.Types.Enum.VkStructureType +import Graphics.Vulkan.Types.Struct.VkExportMemoryAllocateInfoNV +import Graphics.Vulkan.Types.Struct.VkExtent3D +import Graphics.Vulkan.Types.Struct.VkExternalMemoryImageCreateInfoNV +import Graphics.Vulkan.Types.Struct.VkImageCreateInfo +import Graphics.Vulkan.Types.Struct.VkMemoryAllocateInfo + +pattern VK_NV_EXTERNAL_MEMORY_SPEC_VERSION :: (Num a, Eq a) => a + +pattern VK_NV_EXTERNAL_MEMORY_SPEC_VERSION = 1 + +type VK_NV_EXTERNAL_MEMORY_SPEC_VERSION = 1 + +pattern VK_NV_EXTERNAL_MEMORY_EXTENSION_NAME :: CString + +pattern VK_NV_EXTERNAL_MEMORY_EXTENSION_NAME <- + (is_VK_NV_EXTERNAL_MEMORY_EXTENSION_NAME -> True) + where VK_NV_EXTERNAL_MEMORY_EXTENSION_NAME + = _VK_NV_EXTERNAL_MEMORY_EXTENSION_NAME + +{-# INLINE _VK_NV_EXTERNAL_MEMORY_EXTENSION_NAME #-} + +_VK_NV_EXTERNAL_MEMORY_EXTENSION_NAME :: CString +_VK_NV_EXTERNAL_MEMORY_EXTENSION_NAME + = Ptr "VK_NV_external_memory\NUL"# + +{-# INLINE is_VK_NV_EXTERNAL_MEMORY_EXTENSION_NAME #-} + +is_VK_NV_EXTERNAL_MEMORY_EXTENSION_NAME :: CString -> Bool +is_VK_NV_EXTERNAL_MEMORY_EXTENSION_NAME + = eqCStrings _VK_NV_EXTERNAL_MEMORY_EXTENSION_NAME + +type VK_NV_EXTERNAL_MEMORY_EXTENSION_NAME = "VK_NV_external_memory" + +pattern VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV = + VkStructureType 1000056000 + +pattern VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV = + VkStructureType 1000056001 diff --git a/src-gen/Graphics/Vulkan/Ext/VK_NV_external_memory_capabilities.hs b/src-gen/Graphics/Vulkan/Ext/VK_NV_external_memory_capabilities.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Ext/VK_NV_external_memory_capabilities.hs @@ -0,0 +1,126 @@ +{-# OPTIONS_GHC -fno-warn-unused-imports#-} +{-# OPTIONS_HADDOCK not-home#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE ForeignFunctionInterface #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE ViewPatterns #-} +module Graphics.Vulkan.Ext.VK_NV_external_memory_capabilities + (-- * Vulkan extension: @VK_NV_external_memory_capabilities@ + -- | + -- + -- supported: @vulkan@ + -- + -- contact: @James Jones @cubanismo@ + -- + -- author: @NV@ + -- + -- type: @instance@ + -- + -- Extension number: @56@ + module Graphics.Vulkan.Types.BaseTypes, + module Graphics.Vulkan.Types.Struct.VkExtent3D, + module Graphics.Vulkan.Types.Struct.VkExternalImageFormatPropertiesNV, + module Graphics.Vulkan.Types.Enum.VkExternalMemoryFeatureFlagsNV, + module Graphics.Vulkan.Types.Enum.VkExternalMemoryHandleTypeFlagsNV, + module Graphics.Vulkan.Types.Struct.VkImageFormatProperties, + module Graphics.Vulkan.Types.Enum.VkSampleCountFlags, + -- > #include "vk_platform.h" + vkGetPhysicalDeviceExternalImageFormatPropertiesNV, + module Graphics.Vulkan.Marshal, + module Graphics.Vulkan.Types.Enum.VkFormat, + module Graphics.Vulkan.Types.Enum.VkImageCreateFlags, + module Graphics.Vulkan.Types.Enum.VkImageTiling, + module Graphics.Vulkan.Types.Enum.VkImageType, + module Graphics.Vulkan.Types.Enum.VkImageUsageFlags, + module Graphics.Vulkan.Types.Enum.VkResult, + module Graphics.Vulkan.Types.Handles, + VK_NV_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION, + pattern VK_NV_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION, + VK_NV_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME, + pattern VK_NV_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME) + where +import GHC.Ptr (Ptr (..)) +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Types.BaseTypes +import Graphics.Vulkan.Types.Enum.VkExternalMemoryFeatureFlagsNV +import Graphics.Vulkan.Types.Enum.VkExternalMemoryHandleTypeFlagsNV +import Graphics.Vulkan.Types.Enum.VkFormat +import Graphics.Vulkan.Types.Enum.VkImageCreateFlags +import Graphics.Vulkan.Types.Enum.VkImageTiling +import Graphics.Vulkan.Types.Enum.VkImageType +import Graphics.Vulkan.Types.Enum.VkImageUsageFlags +import Graphics.Vulkan.Types.Enum.VkResult +import Graphics.Vulkan.Types.Enum.VkSampleCountFlags +import Graphics.Vulkan.Types.Handles +import Graphics.Vulkan.Types.Struct.VkExtent3D +import Graphics.Vulkan.Types.Struct.VkExternalImageFormatPropertiesNV +import Graphics.Vulkan.Types.Struct.VkImageFormatProperties + +-- | Success codes: 'VK_SUCCESS'. +-- +-- Error codes: 'VK_ERROR_OUT_OF_HOST_MEMORY', 'VK_ERROR_OUT_OF_DEVICE_MEMORY', 'VK_ERROR_FORMAT_NOT_SUPPORTED'. +-- +-- > VkResult vkGetPhysicalDeviceExternalImageFormatPropertiesNV +-- > ( VkPhysicalDevice physicalDevice +-- > , VkFormat format +-- > , VkImageType type +-- > , VkImageTiling tiling +-- > , VkImageUsageFlags usage +-- > , VkImageCreateFlags flags +-- > , VkExternalMemoryHandleTypeFlagsNV externalHandleType +-- > , VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties +-- > ) +-- +-- +foreign import ccall unsafe + "vkGetPhysicalDeviceExternalImageFormatPropertiesNV" + vkGetPhysicalDeviceExternalImageFormatPropertiesNV :: + VkPhysicalDevice -- ^ physicalDevice + -> + VkFormat -- ^ format + -> + VkImageType -- ^ type + -> + VkImageTiling -- ^ tiling + -> + VkImageUsageFlags -- ^ usage + -> + VkImageCreateFlags -- ^ flags + -> + VkExternalMemoryHandleTypeFlagsNV -- ^ externalHandleType + -> + Ptr VkExternalImageFormatPropertiesNV -- ^ pExternalImageFormatProperties + -> IO VkResult + +pattern VK_NV_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION :: + (Num a, Eq a) => a + +pattern VK_NV_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION = 1 + +type VK_NV_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION = 1 + +pattern VK_NV_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME :: + CString + +pattern VK_NV_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME <- + (is_VK_NV_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME -> True) + where VK_NV_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME + = _VK_NV_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME + +{-# INLINE _VK_NV_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME #-} + +_VK_NV_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME :: CString +_VK_NV_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME + = Ptr "VK_NV_external_memory_capabilities\NUL"# + +{-# INLINE is_VK_NV_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME #-} + +is_VK_NV_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME :: + CString -> Bool +is_VK_NV_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME + = eqCStrings _VK_NV_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME + +type VK_NV_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME = + "VK_NV_external_memory_capabilities" diff --git a/src-gen/Graphics/Vulkan/Ext/VK_NV_external_memory_win32.hs b/src-gen/Graphics/Vulkan/Ext/VK_NV_external_memory_win32.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Ext/VK_NV_external_memory_win32.hs @@ -0,0 +1,121 @@ +{-# OPTIONS_GHC -fno-warn-unused-imports#-} +{-# OPTIONS_HADDOCK not-home#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE ForeignFunctionInterface #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE ViewPatterns #-} +module Graphics.Vulkan.Ext.VK_NV_external_memory_win32 + (-- * Vulkan extension: @VK_NV_external_memory_win32@ + -- | + -- + -- supported: @vulkan@ + -- + -- contact: @James Jones @cubanismo@ + -- + -- author: @NV@ + -- + -- type: @device@ + -- + -- Extension number: @58@ + -- + -- Required extensions: 'VK_NV_external_memory'. + -- + -- Protected by CPP ifdef: @VK_USE_PLATFORM_WIN32_KHR@ + -- + + -- ** Required extensions: 'VK_NV_external_memory'. + module Graphics.Vulkan.Types.BaseTypes, + module Graphics.Vulkan.Types.Struct.VkExportMemoryWin32HandleInfoNV, + module Graphics.Vulkan.Types.Enum.VkExternalMemoryHandleTypeFlagsNV, + module Graphics.Vulkan.Types.Struct.VkImportMemoryWin32HandleInfoNV, + module Graphics.Vulkan.Types.Struct.VkMemoryAllocateInfo, + module Graphics.Vulkan.Types.Enum.VkStructureType, + -- > #include "vk_platform.h" + -- + -- > #include + vkGetMemoryWin32HandleNV, module Graphics.Vulkan.Marshal, + module Graphics.Vulkan.Types.Enum.VkResult, + module Graphics.Vulkan.Types.Handles, + VK_NV_EXTERNAL_MEMORY_WIN32_SPEC_VERSION, + pattern VK_NV_EXTERNAL_MEMORY_WIN32_SPEC_VERSION, + VK_NV_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME, + pattern VK_NV_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME, + pattern VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV, + pattern VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV) + where +import GHC.Ptr (Ptr (..)) +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Types.BaseTypes +import Graphics.Vulkan.Types.Enum.VkExternalMemoryHandleTypeFlagsNV +import Graphics.Vulkan.Types.Enum.VkResult +import Graphics.Vulkan.Types.Enum.VkStructureType +import Graphics.Vulkan.Types.Handles +import Graphics.Vulkan.Types.Include (HANDLE) +import Graphics.Vulkan.Types.Struct.VkExportMemoryWin32HandleInfoNV +import Graphics.Vulkan.Types.Struct.VkImportMemoryWin32HandleInfoNV +import Graphics.Vulkan.Types.Struct.VkMemoryAllocateInfo + +-- | Success codes: 'VK_SUCCESS'. +-- +-- Error codes: 'VK_ERROR_TOO_MANY_OBJECTS', 'VK_ERROR_OUT_OF_HOST_MEMORY'. +-- +-- > VkResult vkGetMemoryWin32HandleNV +-- > ( VkDevice device +-- > , VkDeviceMemory memory +-- > , VkExternalMemoryHandleTypeFlagsNV handleType +-- > , HANDLE* pHandle +-- > ) +-- +-- +foreign import ccall unsafe "vkGetMemoryWin32HandleNV" + vkGetMemoryWin32HandleNV :: + VkDevice -- ^ device + -> + VkDeviceMemory -- ^ memory + -> + VkExternalMemoryHandleTypeFlagsNV -- ^ handleType + -> Ptr HANDLE -- ^ pHandle + -> IO VkResult + +pattern VK_NV_EXTERNAL_MEMORY_WIN32_SPEC_VERSION :: + (Num a, Eq a) => a + +pattern VK_NV_EXTERNAL_MEMORY_WIN32_SPEC_VERSION = 1 + +type VK_NV_EXTERNAL_MEMORY_WIN32_SPEC_VERSION = 1 + +pattern VK_NV_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME :: CString + +pattern VK_NV_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME <- + (is_VK_NV_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME -> True) + where VK_NV_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME + = _VK_NV_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME + +{-# INLINE _VK_NV_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME #-} + +_VK_NV_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME :: CString +_VK_NV_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME + = Ptr "VK_NV_external_memory_win32\NUL"# + +{-# INLINE is_VK_NV_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME #-} + +is_VK_NV_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME :: CString -> Bool +is_VK_NV_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME + = eqCStrings _VK_NV_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME + +type VK_NV_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME = + "VK_NV_external_memory_win32" + +pattern VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV = + VkStructureType 1000057000 + +pattern VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV = + VkStructureType 1000057001 diff --git a/src-gen/Graphics/Vulkan/Ext/VK_NV_fill_rectangle.hs b/src-gen/Graphics/Vulkan/Ext/VK_NV_fill_rectangle.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Ext/VK_NV_fill_rectangle.hs @@ -0,0 +1,60 @@ +{-# OPTIONS_HADDOCK not-home#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE ViewPatterns #-} +module Graphics.Vulkan.Ext.VK_NV_fill_rectangle + (-- * Vulkan extension: @VK_NV_fill_rectangle@ + -- | + -- + -- supported: @vulkan@ + -- + -- contact: @Jeff Bolz @jbolz@ + -- + -- author: @NV@ + -- + -- type: @device@ + -- + -- Extension number: @154@ + VK_NV_FILL_RECTANGLE_SPEC_VERSION, + pattern VK_NV_FILL_RECTANGLE_SPEC_VERSION, + VK_NV_FILL_RECTANGLE_EXTENSION_NAME, + pattern VK_NV_FILL_RECTANGLE_EXTENSION_NAME, + pattern VK_POLYGON_MODE_FILL_RECTANGLE_NV) + where +import GHC.Ptr (Ptr (..)) +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Types.Enum.VkPolygonMode (VkPolygonMode (..)) + +pattern VK_NV_FILL_RECTANGLE_SPEC_VERSION :: (Num a, Eq a) => a + +pattern VK_NV_FILL_RECTANGLE_SPEC_VERSION = 1 + +type VK_NV_FILL_RECTANGLE_SPEC_VERSION = 1 + +pattern VK_NV_FILL_RECTANGLE_EXTENSION_NAME :: CString + +pattern VK_NV_FILL_RECTANGLE_EXTENSION_NAME <- + (is_VK_NV_FILL_RECTANGLE_EXTENSION_NAME -> True) + where VK_NV_FILL_RECTANGLE_EXTENSION_NAME + = _VK_NV_FILL_RECTANGLE_EXTENSION_NAME + +{-# INLINE _VK_NV_FILL_RECTANGLE_EXTENSION_NAME #-} + +_VK_NV_FILL_RECTANGLE_EXTENSION_NAME :: CString +_VK_NV_FILL_RECTANGLE_EXTENSION_NAME + = Ptr "VK_NV_fill_rectangle\NUL"# + +{-# INLINE is_VK_NV_FILL_RECTANGLE_EXTENSION_NAME #-} + +is_VK_NV_FILL_RECTANGLE_EXTENSION_NAME :: CString -> Bool +is_VK_NV_FILL_RECTANGLE_EXTENSION_NAME + = eqCStrings _VK_NV_FILL_RECTANGLE_EXTENSION_NAME + +type VK_NV_FILL_RECTANGLE_EXTENSION_NAME = "VK_NV_fill_rectangle" + +pattern VK_POLYGON_MODE_FILL_RECTANGLE_NV :: VkPolygonMode + +pattern VK_POLYGON_MODE_FILL_RECTANGLE_NV = + VkPolygonMode 1000153000 diff --git a/src-gen/Graphics/Vulkan/Ext/VK_NV_fragment_coverage_to_color.hs b/src-gen/Graphics/Vulkan/Ext/VK_NV_fragment_coverage_to_color.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Ext/VK_NV_fragment_coverage_to_color.hs @@ -0,0 +1,77 @@ +{-# OPTIONS_HADDOCK not-home#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE ViewPatterns #-} +module Graphics.Vulkan.Ext.VK_NV_fragment_coverage_to_color + (-- * Vulkan extension: @VK_NV_fragment_coverage_to_color@ + -- | + -- + -- supported: @vulkan@ + -- + -- contact: @Jeff Bolz @jbolz@ + -- + -- author: @NV@ + -- + -- type: @device@ + -- + -- Extension number: @150@ + module Graphics.Vulkan.Types.BaseTypes, + module Graphics.Vulkan.Types.Bitmasks, + module Graphics.Vulkan.Types.Struct.VkPipelineCoverageToColorStateCreateInfoNV, + module Graphics.Vulkan.Types.Struct.VkPipelineMultisampleStateCreateInfo, + module Graphics.Vulkan.Types.Enum.VkSampleCountFlags, + module Graphics.Vulkan.Types.Enum.VkStructureType, + -- > #include "vk_platform.h" + VK_NV_FRAGMENT_COVERAGE_TO_COLOR_SPEC_VERSION, + pattern VK_NV_FRAGMENT_COVERAGE_TO_COLOR_SPEC_VERSION, + VK_NV_FRAGMENT_COVERAGE_TO_COLOR_EXTENSION_NAME, + pattern VK_NV_FRAGMENT_COVERAGE_TO_COLOR_EXTENSION_NAME, + pattern VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV) + where +import GHC.Ptr + (Ptr (..)) +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Types.BaseTypes +import Graphics.Vulkan.Types.Bitmasks +import Graphics.Vulkan.Types.Enum.VkSampleCountFlags +import Graphics.Vulkan.Types.Enum.VkStructureType +import Graphics.Vulkan.Types.Struct.VkPipelineCoverageToColorStateCreateInfoNV +import Graphics.Vulkan.Types.Struct.VkPipelineMultisampleStateCreateInfo + +pattern VK_NV_FRAGMENT_COVERAGE_TO_COLOR_SPEC_VERSION :: + (Num a, Eq a) => a + +pattern VK_NV_FRAGMENT_COVERAGE_TO_COLOR_SPEC_VERSION = 1 + +type VK_NV_FRAGMENT_COVERAGE_TO_COLOR_SPEC_VERSION = 1 + +pattern VK_NV_FRAGMENT_COVERAGE_TO_COLOR_EXTENSION_NAME :: CString + +pattern VK_NV_FRAGMENT_COVERAGE_TO_COLOR_EXTENSION_NAME <- + (is_VK_NV_FRAGMENT_COVERAGE_TO_COLOR_EXTENSION_NAME -> True) + where VK_NV_FRAGMENT_COVERAGE_TO_COLOR_EXTENSION_NAME + = _VK_NV_FRAGMENT_COVERAGE_TO_COLOR_EXTENSION_NAME + +{-# INLINE _VK_NV_FRAGMENT_COVERAGE_TO_COLOR_EXTENSION_NAME #-} + +_VK_NV_FRAGMENT_COVERAGE_TO_COLOR_EXTENSION_NAME :: CString +_VK_NV_FRAGMENT_COVERAGE_TO_COLOR_EXTENSION_NAME + = Ptr "VK_NV_fragment_coverage_to_color\NUL"# + +{-# INLINE is_VK_NV_FRAGMENT_COVERAGE_TO_COLOR_EXTENSION_NAME #-} + +is_VK_NV_FRAGMENT_COVERAGE_TO_COLOR_EXTENSION_NAME :: + CString -> Bool +is_VK_NV_FRAGMENT_COVERAGE_TO_COLOR_EXTENSION_NAME + = eqCStrings _VK_NV_FRAGMENT_COVERAGE_TO_COLOR_EXTENSION_NAME + +type VK_NV_FRAGMENT_COVERAGE_TO_COLOR_EXTENSION_NAME = + "VK_NV_fragment_coverage_to_color" + +pattern VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV + :: VkStructureType + +pattern VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV + = VkStructureType 1000149000 diff --git a/src-gen/Graphics/Vulkan/Ext/VK_NV_framebuffer_mixed_samples.hs b/src-gen/Graphics/Vulkan/Ext/VK_NV_framebuffer_mixed_samples.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Ext/VK_NV_framebuffer_mixed_samples.hs @@ -0,0 +1,79 @@ +{-# OPTIONS_HADDOCK not-home#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE ViewPatterns #-} +module Graphics.Vulkan.Ext.VK_NV_framebuffer_mixed_samples + (-- * Vulkan extension: @VK_NV_framebuffer_mixed_samples@ + -- | + -- + -- supported: @vulkan@ + -- + -- contact: @Jeff Bolz @jbolz@ + -- + -- author: @NV@ + -- + -- type: @device@ + -- + -- Extension number: @153@ + module Graphics.Vulkan.Types.BaseTypes, + module Graphics.Vulkan.Types.Enum.VkCoverageModulationModeNV, + module Graphics.Vulkan.Types.Bitmasks, + module Graphics.Vulkan.Types.Struct.VkPipelineCoverageModulationStateCreateInfoNV, + module Graphics.Vulkan.Types.Struct.VkPipelineMultisampleStateCreateInfo, + module Graphics.Vulkan.Types.Enum.VkSampleCountFlags, + module Graphics.Vulkan.Types.Enum.VkStructureType, + -- > #include "vk_platform.h" + VK_NV_FRAMEBUFFER_MIXED_SAMPLES_SPEC_VERSION, + pattern VK_NV_FRAMEBUFFER_MIXED_SAMPLES_SPEC_VERSION, + VK_NV_FRAMEBUFFER_MIXED_SAMPLES_EXTENSION_NAME, + pattern VK_NV_FRAMEBUFFER_MIXED_SAMPLES_EXTENSION_NAME, + pattern VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV) + where +import GHC.Ptr + (Ptr (..)) +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Types.BaseTypes +import Graphics.Vulkan.Types.Bitmasks +import Graphics.Vulkan.Types.Enum.VkCoverageModulationModeNV +import Graphics.Vulkan.Types.Enum.VkSampleCountFlags +import Graphics.Vulkan.Types.Enum.VkStructureType +import Graphics.Vulkan.Types.Struct.VkPipelineCoverageModulationStateCreateInfoNV +import Graphics.Vulkan.Types.Struct.VkPipelineMultisampleStateCreateInfo + +pattern VK_NV_FRAMEBUFFER_MIXED_SAMPLES_SPEC_VERSION :: + (Num a, Eq a) => a + +pattern VK_NV_FRAMEBUFFER_MIXED_SAMPLES_SPEC_VERSION = 1 + +type VK_NV_FRAMEBUFFER_MIXED_SAMPLES_SPEC_VERSION = 1 + +pattern VK_NV_FRAMEBUFFER_MIXED_SAMPLES_EXTENSION_NAME :: CString + +pattern VK_NV_FRAMEBUFFER_MIXED_SAMPLES_EXTENSION_NAME <- + (is_VK_NV_FRAMEBUFFER_MIXED_SAMPLES_EXTENSION_NAME -> True) + where VK_NV_FRAMEBUFFER_MIXED_SAMPLES_EXTENSION_NAME + = _VK_NV_FRAMEBUFFER_MIXED_SAMPLES_EXTENSION_NAME + +{-# INLINE _VK_NV_FRAMEBUFFER_MIXED_SAMPLES_EXTENSION_NAME #-} + +_VK_NV_FRAMEBUFFER_MIXED_SAMPLES_EXTENSION_NAME :: CString +_VK_NV_FRAMEBUFFER_MIXED_SAMPLES_EXTENSION_NAME + = Ptr "VK_NV_framebuffer_mixed_samples\NUL"# + +{-# INLINE is_VK_NV_FRAMEBUFFER_MIXED_SAMPLES_EXTENSION_NAME #-} + +is_VK_NV_FRAMEBUFFER_MIXED_SAMPLES_EXTENSION_NAME :: + CString -> Bool +is_VK_NV_FRAMEBUFFER_MIXED_SAMPLES_EXTENSION_NAME + = eqCStrings _VK_NV_FRAMEBUFFER_MIXED_SAMPLES_EXTENSION_NAME + +type VK_NV_FRAMEBUFFER_MIXED_SAMPLES_EXTENSION_NAME = + "VK_NV_framebuffer_mixed_samples" + +pattern VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV + :: VkStructureType + +pattern VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV + = VkStructureType 1000152000 diff --git a/src-gen/Graphics/Vulkan/Ext/VK_NV_geometry_shader_passthrough.hs b/src-gen/Graphics/Vulkan/Ext/VK_NV_geometry_shader_passthrough.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Ext/VK_NV_geometry_shader_passthrough.hs @@ -0,0 +1,56 @@ +{-# OPTIONS_HADDOCK not-home#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE ViewPatterns #-} +module Graphics.Vulkan.Ext.VK_NV_geometry_shader_passthrough + (-- * Vulkan extension: @VK_NV_geometry_shader_passthrough@ + -- | + -- + -- supported: @vulkan@ + -- + -- contact: @Daniel Koch @dgkoch@ + -- + -- author: @NV@ + -- + -- type: @device@ + -- + -- Extension number: @96@ + VK_NV_GEOMETRY_SHADER_PASSTHROUGH_SPEC_VERSION, + pattern VK_NV_GEOMETRY_SHADER_PASSTHROUGH_SPEC_VERSION, + VK_NV_GEOMETRY_SHADER_PASSTHROUGH_EXTENSION_NAME, + pattern VK_NV_GEOMETRY_SHADER_PASSTHROUGH_EXTENSION_NAME) + where +import GHC.Ptr (Ptr (..)) +import Graphics.Vulkan.Marshal + +pattern VK_NV_GEOMETRY_SHADER_PASSTHROUGH_SPEC_VERSION :: + (Num a, Eq a) => a + +pattern VK_NV_GEOMETRY_SHADER_PASSTHROUGH_SPEC_VERSION = 1 + +type VK_NV_GEOMETRY_SHADER_PASSTHROUGH_SPEC_VERSION = 1 + +pattern VK_NV_GEOMETRY_SHADER_PASSTHROUGH_EXTENSION_NAME :: CString + +pattern VK_NV_GEOMETRY_SHADER_PASSTHROUGH_EXTENSION_NAME <- + (is_VK_NV_GEOMETRY_SHADER_PASSTHROUGH_EXTENSION_NAME -> True) + where VK_NV_GEOMETRY_SHADER_PASSTHROUGH_EXTENSION_NAME + = _VK_NV_GEOMETRY_SHADER_PASSTHROUGH_EXTENSION_NAME + +{-# INLINE _VK_NV_GEOMETRY_SHADER_PASSTHROUGH_EXTENSION_NAME #-} + +_VK_NV_GEOMETRY_SHADER_PASSTHROUGH_EXTENSION_NAME :: CString +_VK_NV_GEOMETRY_SHADER_PASSTHROUGH_EXTENSION_NAME + = Ptr "VK_NV_geometry_shader_passthrough\NUL"# + +{-# INLINE is_VK_NV_GEOMETRY_SHADER_PASSTHROUGH_EXTENSION_NAME #-} + +is_VK_NV_GEOMETRY_SHADER_PASSTHROUGH_EXTENSION_NAME :: + CString -> Bool +is_VK_NV_GEOMETRY_SHADER_PASSTHROUGH_EXTENSION_NAME + = eqCStrings _VK_NV_GEOMETRY_SHADER_PASSTHROUGH_EXTENSION_NAME + +type VK_NV_GEOMETRY_SHADER_PASSTHROUGH_EXTENSION_NAME = + "VK_NV_geometry_shader_passthrough" diff --git a/src-gen/Graphics/Vulkan/Ext/VK_NV_glsl_shader.hs b/src-gen/Graphics/Vulkan/Ext/VK_NV_glsl_shader.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Ext/VK_NV_glsl_shader.hs @@ -0,0 +1,58 @@ +{-# OPTIONS_HADDOCK not-home#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE ViewPatterns #-} +module Graphics.Vulkan.Ext.VK_NV_glsl_shader + (-- * Vulkan extension: @VK_NV_glsl_shader@ + -- | + -- + -- supported: @vulkan@ + -- + -- contact: @Piers Daniell @pdaniell@ + -- + -- author: @NV@ + -- + -- type: @device@ + -- + -- Extension number: @13@ + VK_NV_GLSL_SHADER_SPEC_VERSION, + pattern VK_NV_GLSL_SHADER_SPEC_VERSION, + VK_NV_GLSL_SHADER_EXTENSION_NAME, + pattern VK_NV_GLSL_SHADER_EXTENSION_NAME, + pattern VK_ERROR_INVALID_SHADER_NV) + where +import GHC.Ptr (Ptr (..)) +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Types.Enum.VkResult (VkResult (..)) + +pattern VK_NV_GLSL_SHADER_SPEC_VERSION :: (Num a, Eq a) => a + +pattern VK_NV_GLSL_SHADER_SPEC_VERSION = 1 + +type VK_NV_GLSL_SHADER_SPEC_VERSION = 1 + +pattern VK_NV_GLSL_SHADER_EXTENSION_NAME :: CString + +pattern VK_NV_GLSL_SHADER_EXTENSION_NAME <- + (is_VK_NV_GLSL_SHADER_EXTENSION_NAME -> True) + where VK_NV_GLSL_SHADER_EXTENSION_NAME + = _VK_NV_GLSL_SHADER_EXTENSION_NAME + +{-# INLINE _VK_NV_GLSL_SHADER_EXTENSION_NAME #-} + +_VK_NV_GLSL_SHADER_EXTENSION_NAME :: CString +_VK_NV_GLSL_SHADER_EXTENSION_NAME = Ptr "VK_NV_glsl_shader\NUL"# + +{-# INLINE is_VK_NV_GLSL_SHADER_EXTENSION_NAME #-} + +is_VK_NV_GLSL_SHADER_EXTENSION_NAME :: CString -> Bool +is_VK_NV_GLSL_SHADER_EXTENSION_NAME + = eqCStrings _VK_NV_GLSL_SHADER_EXTENSION_NAME + +type VK_NV_GLSL_SHADER_EXTENSION_NAME = "VK_NV_glsl_shader" + +pattern VK_ERROR_INVALID_SHADER_NV :: VkResult + +pattern VK_ERROR_INVALID_SHADER_NV = VkResult (-1000012000) diff --git a/src-gen/Graphics/Vulkan/Ext/VK_NV_sample_mask_override_coverage.hs b/src-gen/Graphics/Vulkan/Ext/VK_NV_sample_mask_override_coverage.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Ext/VK_NV_sample_mask_override_coverage.hs @@ -0,0 +1,58 @@ +{-# OPTIONS_HADDOCK not-home#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE ViewPatterns #-} +module Graphics.Vulkan.Ext.VK_NV_sample_mask_override_coverage + (-- * Vulkan extension: @VK_NV_sample_mask_override_coverage@ + -- | + -- + -- supported: @vulkan@ + -- + -- contact: @Piers Daniell @pdaniell@ + -- + -- author: @NV@ + -- + -- type: @device@ + -- + -- Extension number: @95@ + VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_SPEC_VERSION, + pattern VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_SPEC_VERSION, + VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_EXTENSION_NAME, + pattern VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_EXTENSION_NAME) + where +import GHC.Ptr (Ptr (..)) +import Graphics.Vulkan.Marshal + +pattern VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_SPEC_VERSION :: + (Num a, Eq a) => a + +pattern VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_SPEC_VERSION = 1 + +type VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_SPEC_VERSION = 1 + +pattern VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_EXTENSION_NAME :: + CString + +pattern VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_EXTENSION_NAME <- + (is_VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_EXTENSION_NAME -> True) + where VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_EXTENSION_NAME + = _VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_EXTENSION_NAME + +{-# INLINE _VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_EXTENSION_NAME #-} + +_VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_EXTENSION_NAME :: CString +_VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_EXTENSION_NAME + = Ptr "VK_NV_sample_mask_override_coverage\NUL"# + +{-# INLINE is_VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_EXTENSION_NAME + #-} + +is_VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_EXTENSION_NAME :: + CString -> Bool +is_VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_EXTENSION_NAME + = eqCStrings _VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_EXTENSION_NAME + +type VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_EXTENSION_NAME = + "VK_NV_sample_mask_override_coverage" diff --git a/src-gen/Graphics/Vulkan/Ext/VK_NV_viewport_array2.hs b/src-gen/Graphics/Vulkan/Ext/VK_NV_viewport_array2.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Ext/VK_NV_viewport_array2.hs @@ -0,0 +1,53 @@ +{-# OPTIONS_HADDOCK not-home#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE ViewPatterns #-} +module Graphics.Vulkan.Ext.VK_NV_viewport_array2 + (-- * Vulkan extension: @VK_NV_viewport_array2@ + -- | + -- + -- supported: @vulkan@ + -- + -- contact: @Daniel Koch @dgkoch@ + -- + -- author: @NV@ + -- + -- type: @device@ + -- + -- Extension number: @97@ + VK_NV_VIEWPORT_ARRAY2_SPEC_VERSION, + pattern VK_NV_VIEWPORT_ARRAY2_SPEC_VERSION, + VK_NV_VIEWPORT_ARRAY2_EXTENSION_NAME, + pattern VK_NV_VIEWPORT_ARRAY2_EXTENSION_NAME) + where +import GHC.Ptr (Ptr (..)) +import Graphics.Vulkan.Marshal + +pattern VK_NV_VIEWPORT_ARRAY2_SPEC_VERSION :: (Num a, Eq a) => a + +pattern VK_NV_VIEWPORT_ARRAY2_SPEC_VERSION = 1 + +type VK_NV_VIEWPORT_ARRAY2_SPEC_VERSION = 1 + +pattern VK_NV_VIEWPORT_ARRAY2_EXTENSION_NAME :: CString + +pattern VK_NV_VIEWPORT_ARRAY2_EXTENSION_NAME <- + (is_VK_NV_VIEWPORT_ARRAY2_EXTENSION_NAME -> True) + where VK_NV_VIEWPORT_ARRAY2_EXTENSION_NAME + = _VK_NV_VIEWPORT_ARRAY2_EXTENSION_NAME + +{-# INLINE _VK_NV_VIEWPORT_ARRAY2_EXTENSION_NAME #-} + +_VK_NV_VIEWPORT_ARRAY2_EXTENSION_NAME :: CString +_VK_NV_VIEWPORT_ARRAY2_EXTENSION_NAME + = Ptr "VK_NV_viewport_array2\NUL"# + +{-# INLINE is_VK_NV_VIEWPORT_ARRAY2_EXTENSION_NAME #-} + +is_VK_NV_VIEWPORT_ARRAY2_EXTENSION_NAME :: CString -> Bool +is_VK_NV_VIEWPORT_ARRAY2_EXTENSION_NAME + = eqCStrings _VK_NV_VIEWPORT_ARRAY2_EXTENSION_NAME + +type VK_NV_VIEWPORT_ARRAY2_EXTENSION_NAME = "VK_NV_viewport_array2" diff --git a/src-gen/Graphics/Vulkan/Ext/VK_NV_viewport_swizzle.hs b/src-gen/Graphics/Vulkan/Ext/VK_NV_viewport_swizzle.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Ext/VK_NV_viewport_swizzle.hs @@ -0,0 +1,85 @@ +{-# OPTIONS_HADDOCK not-home#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE ViewPatterns #-} +module Graphics.Vulkan.Ext.VK_NV_viewport_swizzle + (-- * Vulkan extension: @VK_NV_viewport_swizzle@ + -- | + -- + -- supported: @vulkan@ + -- + -- contact: @Piers Daniell @pdaniell@ + -- + -- author: @NV@ + -- + -- type: @device@ + -- + -- Extension number: @99@ + module Graphics.Vulkan.Types.Struct.VkExtent2D, + module Graphics.Vulkan.Types.BaseTypes, + module Graphics.Vulkan.Types.Struct.VkOffset2D, + module Graphics.Vulkan.Types.Bitmasks, + module Graphics.Vulkan.Types.Struct.VkPipelineViewportStateCreateInfo, + module Graphics.Vulkan.Types.Struct.VkPipelineViewportSwizzleStateCreateInfoNV, + module Graphics.Vulkan.Types.Struct.VkRect2D, + module Graphics.Vulkan.Types.Enum.VkStructureType, + module Graphics.Vulkan.Types.Struct.VkViewport, + module Graphics.Vulkan.Types.Enum.VkViewportCoordinateSwizzleNV, + module Graphics.Vulkan.Types.Struct.VkViewportSwizzleNV, + -- > #include "vk_platform.h" + VK_NV_VIEWPORT_SWIZZLE_SPEC_VERSION, + pattern VK_NV_VIEWPORT_SWIZZLE_SPEC_VERSION, + VK_NV_VIEWPORT_SWIZZLE_EXTENSION_NAME, + pattern VK_NV_VIEWPORT_SWIZZLE_EXTENSION_NAME, + pattern VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV) + where +import GHC.Ptr + (Ptr (..)) +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Types.BaseTypes +import Graphics.Vulkan.Types.Bitmasks +import Graphics.Vulkan.Types.Enum.VkStructureType +import Graphics.Vulkan.Types.Enum.VkViewportCoordinateSwizzleNV +import Graphics.Vulkan.Types.Struct.VkExtent2D +import Graphics.Vulkan.Types.Struct.VkOffset2D +import Graphics.Vulkan.Types.Struct.VkPipelineViewportStateCreateInfo +import Graphics.Vulkan.Types.Struct.VkPipelineViewportSwizzleStateCreateInfoNV +import Graphics.Vulkan.Types.Struct.VkRect2D +import Graphics.Vulkan.Types.Struct.VkViewport +import Graphics.Vulkan.Types.Struct.VkViewportSwizzleNV + +pattern VK_NV_VIEWPORT_SWIZZLE_SPEC_VERSION :: (Num a, Eq a) => a + +pattern VK_NV_VIEWPORT_SWIZZLE_SPEC_VERSION = 1 + +type VK_NV_VIEWPORT_SWIZZLE_SPEC_VERSION = 1 + +pattern VK_NV_VIEWPORT_SWIZZLE_EXTENSION_NAME :: CString + +pattern VK_NV_VIEWPORT_SWIZZLE_EXTENSION_NAME <- + (is_VK_NV_VIEWPORT_SWIZZLE_EXTENSION_NAME -> True) + where VK_NV_VIEWPORT_SWIZZLE_EXTENSION_NAME + = _VK_NV_VIEWPORT_SWIZZLE_EXTENSION_NAME + +{-# INLINE _VK_NV_VIEWPORT_SWIZZLE_EXTENSION_NAME #-} + +_VK_NV_VIEWPORT_SWIZZLE_EXTENSION_NAME :: CString +_VK_NV_VIEWPORT_SWIZZLE_EXTENSION_NAME + = Ptr "VK_NV_viewport_swizzle\NUL"# + +{-# INLINE is_VK_NV_VIEWPORT_SWIZZLE_EXTENSION_NAME #-} + +is_VK_NV_VIEWPORT_SWIZZLE_EXTENSION_NAME :: CString -> Bool +is_VK_NV_VIEWPORT_SWIZZLE_EXTENSION_NAME + = eqCStrings _VK_NV_VIEWPORT_SWIZZLE_EXTENSION_NAME + +type VK_NV_VIEWPORT_SWIZZLE_EXTENSION_NAME = + "VK_NV_viewport_swizzle" + +pattern VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV + :: VkStructureType + +pattern VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV + = VkStructureType 1000098000 diff --git a/src-gen/Graphics/Vulkan/Ext/VK_NV_win32_keyed_mutex.hs b/src-gen/Graphics/Vulkan/Ext/VK_NV_win32_keyed_mutex.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Ext/VK_NV_win32_keyed_mutex.hs @@ -0,0 +1,80 @@ +{-# OPTIONS_HADDOCK not-home#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE ViewPatterns #-} +module Graphics.Vulkan.Ext.VK_NV_win32_keyed_mutex + (-- * Vulkan extension: @VK_NV_win32_keyed_mutex@ + -- | + -- + -- supported: @vulkan@ + -- + -- contact: @Carsten Rohde@ + -- + -- author: @NV@ + -- + -- type: @device@ + -- + -- Extension number: @59@ + -- + -- Required extensions: 'VK_NV_external_memory_win32'. + -- + -- Protected by CPP ifdef: @VK_USE_PLATFORM_WIN32_KHR@ + -- + + -- ** Required extensions: 'VK_NV_external_memory_win32'. + module Graphics.Vulkan.Types.BaseTypes, + module Graphics.Vulkan.Types.Enum.VkPipelineStageFlags, + module Graphics.Vulkan.Types.Enum.VkStructureType, + module Graphics.Vulkan.Types.Struct.VkSubmitInfo, + module Graphics.Vulkan.Types.Struct.VkWin32KeyedMutexAcquireReleaseInfoNV, + -- > #include "vk_platform.h" + VK_NV_WIN32_KEYED_MUTEX_SPEC_VERSION, + pattern VK_NV_WIN32_KEYED_MUTEX_SPEC_VERSION, + VK_NV_WIN32_KEYED_MUTEX_EXTENSION_NAME, + pattern VK_NV_WIN32_KEYED_MUTEX_EXTENSION_NAME, + pattern VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV) + where +import GHC.Ptr + (Ptr (..)) +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Types.BaseTypes +import Graphics.Vulkan.Types.Enum.VkPipelineStageFlags +import Graphics.Vulkan.Types.Enum.VkStructureType +import Graphics.Vulkan.Types.Struct.VkSubmitInfo +import Graphics.Vulkan.Types.Struct.VkWin32KeyedMutexAcquireReleaseInfoNV + +pattern VK_NV_WIN32_KEYED_MUTEX_SPEC_VERSION :: (Num a, Eq a) => a + +pattern VK_NV_WIN32_KEYED_MUTEX_SPEC_VERSION = 1 + +type VK_NV_WIN32_KEYED_MUTEX_SPEC_VERSION = 1 + +pattern VK_NV_WIN32_KEYED_MUTEX_EXTENSION_NAME :: CString + +pattern VK_NV_WIN32_KEYED_MUTEX_EXTENSION_NAME <- + (is_VK_NV_WIN32_KEYED_MUTEX_EXTENSION_NAME -> True) + where VK_NV_WIN32_KEYED_MUTEX_EXTENSION_NAME + = _VK_NV_WIN32_KEYED_MUTEX_EXTENSION_NAME + +{-# INLINE _VK_NV_WIN32_KEYED_MUTEX_EXTENSION_NAME #-} + +_VK_NV_WIN32_KEYED_MUTEX_EXTENSION_NAME :: CString +_VK_NV_WIN32_KEYED_MUTEX_EXTENSION_NAME + = Ptr "VK_NV_win32_keyed_mutex\NUL"# + +{-# INLINE is_VK_NV_WIN32_KEYED_MUTEX_EXTENSION_NAME #-} + +is_VK_NV_WIN32_KEYED_MUTEX_EXTENSION_NAME :: CString -> Bool +is_VK_NV_WIN32_KEYED_MUTEX_EXTENSION_NAME + = eqCStrings _VK_NV_WIN32_KEYED_MUTEX_EXTENSION_NAME + +type VK_NV_WIN32_KEYED_MUTEX_EXTENSION_NAME = + "VK_NV_win32_keyed_mutex" + +pattern VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV + :: VkStructureType + +pattern VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV + = VkStructureType 1000058000 diff --git a/src-gen/Graphics/Vulkan/Types/BaseTypes.hs b/src-gen/Graphics/Vulkan/Types/BaseTypes.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/BaseTypes.hs @@ -0,0 +1,62 @@ +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE Strict #-} +module Graphics.Vulkan.Types.BaseTypes + (VkBool32(..), VkDeviceSize(..), VkFlags(..), VkSampleMask(..)) + where +import Data.Bits (Bits, FiniteBits) +import Data.Coerce (coerce) +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import Graphics.Vulkan.Marshal (Word32, Word64) + +newtype VkBool32 = VkBool32 Word32 + deriving (Eq, Ord, Num, Bounded, Enum, Integral, Bits, FiniteBits, + Storable, Real, Data, Generic) + +instance Show VkBool32 where + {-# INLINE show #-} + show (VkBool32 x) = show x + +instance Read VkBool32 where + {-# INLINE readsPrec #-} + readsPrec = coerce (readsPrec :: Int -> ReadS Word32) + +newtype VkDeviceSize = VkDeviceSize Word64 + deriving (Eq, Ord, Num, Bounded, Enum, Integral, Bits, FiniteBits, + Storable, Real, Data, Generic) + +instance Show VkDeviceSize where + {-# INLINE show #-} + show (VkDeviceSize x) = show x + +instance Read VkDeviceSize where + {-# INLINE readsPrec #-} + readsPrec = coerce (readsPrec :: Int -> ReadS Word64) + +newtype VkFlags = VkFlags Word32 + deriving (Eq, Ord, Num, Bounded, Enum, Integral, Bits, FiniteBits, + Storable, Real, Data, Generic) + +instance Show VkFlags where + {-# INLINE show #-} + show (VkFlags x) = show x + +instance Read VkFlags where + {-# INLINE readsPrec #-} + readsPrec = coerce (readsPrec :: Int -> ReadS Word32) + +newtype VkSampleMask = VkSampleMask Word32 + deriving (Eq, Ord, Num, Bounded, Enum, Integral, Bits, FiniteBits, + Storable, Real, Data, Generic) + +instance Show VkSampleMask where + {-# INLINE show #-} + show (VkSampleMask x) = show x + +instance Read VkSampleMask where + {-# INLINE readsPrec #-} + readsPrec = coerce (readsPrec :: Int -> ReadS Word32) diff --git a/src-gen/Graphics/Vulkan/Types/Bitmasks.hs b/src-gen/Graphics/Vulkan/Types/Bitmasks.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Bitmasks.hs @@ -0,0 +1,605 @@ +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE Strict #-} +module Graphics.Vulkan.Types.Bitmasks + (VkAndroidSurfaceCreateFlagsKHR(..), VkBufferViewCreateFlags(..), + VkCommandPoolTrimFlagsKHR(..), VkDescriptorPoolResetFlags(..), + VkDescriptorUpdateTemplateCreateFlagsKHR(..), + VkDeviceCreateFlags(..), VkDeviceQueueCreateFlags(..), + VkDisplayModeCreateFlagsKHR(..), + VkDisplaySurfaceCreateFlagsKHR(..), VkEventCreateFlags(..), + VkFramebufferCreateFlags(..), VkIOSSurfaceCreateFlagsMVK(..), + VkImageViewCreateFlags(..), VkInstanceCreateFlags(..), + VkMacOSSurfaceCreateFlagsMVK(..), VkMemoryMapFlags(..), + VkMirSurfaceCreateFlagsKHR(..), VkPipelineCacheCreateFlags(..), + VkPipelineColorBlendStateCreateFlags(..), + VkPipelineCoverageModulationStateCreateFlagsNV(..), + VkPipelineCoverageToColorStateCreateFlagsNV(..), + VkPipelineDepthStencilStateCreateFlags(..), + VkPipelineDiscardRectangleStateCreateFlagsEXT(..), + VkPipelineDynamicStateCreateFlags(..), + VkPipelineInputAssemblyStateCreateFlags(..), + VkPipelineLayoutCreateFlags(..), + VkPipelineMultisampleStateCreateFlags(..), + VkPipelineRasterizationConservativeStateCreateFlagsEXT(..), + VkPipelineRasterizationStateCreateFlags(..), + VkPipelineShaderStageCreateFlags(..), + VkPipelineTessellationStateCreateFlags(..), + VkPipelineVertexInputStateCreateFlags(..), + VkPipelineViewportStateCreateFlags(..), + VkPipelineViewportSwizzleStateCreateFlagsNV(..), + VkQueryPoolCreateFlags(..), VkRenderPassCreateFlags(..), + VkSamplerCreateFlags(..), VkSemaphoreCreateFlags(..), + VkShaderModuleCreateFlags(..), VkValidationCacheCreateFlagsEXT(..), + VkViSurfaceCreateFlagsNN(..), VkWaylandSurfaceCreateFlagsKHR(..), + VkWin32SurfaceCreateFlagsKHR(..), VkXcbSurfaceCreateFlagsKHR(..), + VkXlibSurfaceCreateFlagsKHR(..)) + where +import Data.Bits (Bits, FiniteBits) +import Data.Coerce (coerce) +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import Graphics.Vulkan.Types.BaseTypes (VkFlags) + +newtype VkAndroidSurfaceCreateFlagsKHR = VkAndroidSurfaceCreateFlagsKHR VkFlags + deriving (Eq, Ord, Num, Bounded, Enum, Integral, Bits, + FiniteBits, Storable, Real, Data, Generic) + +instance Show VkAndroidSurfaceCreateFlagsKHR where + {-# INLINE show #-} + show (VkAndroidSurfaceCreateFlagsKHR x) = show x + +instance Read VkAndroidSurfaceCreateFlagsKHR where + {-# INLINE readsPrec #-} + readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags) + +newtype VkBufferViewCreateFlags = VkBufferViewCreateFlags VkFlags + deriving (Eq, Ord, Num, Bounded, Enum, Integral, Bits, + FiniteBits, Storable, Real, Data, Generic) + +instance Show VkBufferViewCreateFlags where + {-# INLINE show #-} + show (VkBufferViewCreateFlags x) = show x + +instance Read VkBufferViewCreateFlags where + {-# INLINE readsPrec #-} + readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags) + +newtype VkCommandPoolTrimFlagsKHR = VkCommandPoolTrimFlagsKHR VkFlags + deriving (Eq, Ord, Num, Bounded, Enum, Integral, Bits, + FiniteBits, Storable, Real, Data, Generic) + +instance Show VkCommandPoolTrimFlagsKHR where + {-# INLINE show #-} + show (VkCommandPoolTrimFlagsKHR x) = show x + +instance Read VkCommandPoolTrimFlagsKHR where + {-# INLINE readsPrec #-} + readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags) + +newtype VkDescriptorPoolResetFlags = VkDescriptorPoolResetFlags VkFlags + deriving (Eq, Ord, Num, Bounded, Enum, Integral, Bits, + FiniteBits, Storable, Real, Data, Generic) + +instance Show VkDescriptorPoolResetFlags where + {-# INLINE show #-} + show (VkDescriptorPoolResetFlags x) = show x + +instance Read VkDescriptorPoolResetFlags where + {-# INLINE readsPrec #-} + readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags) + +newtype VkDescriptorUpdateTemplateCreateFlagsKHR = VkDescriptorUpdateTemplateCreateFlagsKHR VkFlags + deriving (Eq, Ord, Num, Bounded, Enum, + Integral, Bits, FiniteBits, Storable, + Real, Data, Generic) + +instance Show VkDescriptorUpdateTemplateCreateFlagsKHR where + {-# INLINE show #-} + show (VkDescriptorUpdateTemplateCreateFlagsKHR x) = show x + +instance Read VkDescriptorUpdateTemplateCreateFlagsKHR where + {-# INLINE readsPrec #-} + readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags) + +newtype VkDeviceCreateFlags = VkDeviceCreateFlags VkFlags + deriving (Eq, Ord, Num, Bounded, Enum, Integral, Bits, FiniteBits, + Storable, Real, Data, Generic) + +instance Show VkDeviceCreateFlags where + {-# INLINE show #-} + show (VkDeviceCreateFlags x) = show x + +instance Read VkDeviceCreateFlags where + {-# INLINE readsPrec #-} + readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags) + +newtype VkDeviceQueueCreateFlags = VkDeviceQueueCreateFlags VkFlags + deriving (Eq, Ord, Num, Bounded, Enum, Integral, Bits, + FiniteBits, Storable, Real, Data, Generic) + +instance Show VkDeviceQueueCreateFlags where + {-# INLINE show #-} + show (VkDeviceQueueCreateFlags x) = show x + +instance Read VkDeviceQueueCreateFlags where + {-# INLINE readsPrec #-} + readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags) + +newtype VkDisplayModeCreateFlagsKHR = VkDisplayModeCreateFlagsKHR VkFlags + deriving (Eq, Ord, Num, Bounded, Enum, Integral, Bits, + FiniteBits, Storable, Real, Data, Generic) + +instance Show VkDisplayModeCreateFlagsKHR where + {-# INLINE show #-} + show (VkDisplayModeCreateFlagsKHR x) = show x + +instance Read VkDisplayModeCreateFlagsKHR where + {-# INLINE readsPrec #-} + readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags) + +newtype VkDisplaySurfaceCreateFlagsKHR = VkDisplaySurfaceCreateFlagsKHR VkFlags + deriving (Eq, Ord, Num, Bounded, Enum, Integral, Bits, + FiniteBits, Storable, Real, Data, Generic) + +instance Show VkDisplaySurfaceCreateFlagsKHR where + {-# INLINE show #-} + show (VkDisplaySurfaceCreateFlagsKHR x) = show x + +instance Read VkDisplaySurfaceCreateFlagsKHR where + {-# INLINE readsPrec #-} + readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags) + +newtype VkEventCreateFlags = VkEventCreateFlags VkFlags + deriving (Eq, Ord, Num, Bounded, Enum, Integral, Bits, FiniteBits, + Storable, Real, Data, Generic) + +instance Show VkEventCreateFlags where + {-# INLINE show #-} + show (VkEventCreateFlags x) = show x + +instance Read VkEventCreateFlags where + {-# INLINE readsPrec #-} + readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags) + +newtype VkFramebufferCreateFlags = VkFramebufferCreateFlags VkFlags + deriving (Eq, Ord, Num, Bounded, Enum, Integral, Bits, + FiniteBits, Storable, Real, Data, Generic) + +instance Show VkFramebufferCreateFlags where + {-# INLINE show #-} + show (VkFramebufferCreateFlags x) = show x + +instance Read VkFramebufferCreateFlags where + {-# INLINE readsPrec #-} + readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags) + +newtype VkIOSSurfaceCreateFlagsMVK = VkIOSSurfaceCreateFlagsMVK VkFlags + deriving (Eq, Ord, Num, Bounded, Enum, Integral, Bits, + FiniteBits, Storable, Real, Data, Generic) + +instance Show VkIOSSurfaceCreateFlagsMVK where + {-# INLINE show #-} + show (VkIOSSurfaceCreateFlagsMVK x) = show x + +instance Read VkIOSSurfaceCreateFlagsMVK where + {-# INLINE readsPrec #-} + readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags) + +newtype VkImageViewCreateFlags = VkImageViewCreateFlags VkFlags + deriving (Eq, Ord, Num, Bounded, Enum, Integral, Bits, + FiniteBits, Storable, Real, Data, Generic) + +instance Show VkImageViewCreateFlags where + {-# INLINE show #-} + show (VkImageViewCreateFlags x) = show x + +instance Read VkImageViewCreateFlags where + {-# INLINE readsPrec #-} + readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags) + +newtype VkInstanceCreateFlags = VkInstanceCreateFlags VkFlags + deriving (Eq, Ord, Num, Bounded, Enum, Integral, Bits, FiniteBits, + Storable, Real, Data, Generic) + +instance Show VkInstanceCreateFlags where + {-# INLINE show #-} + show (VkInstanceCreateFlags x) = show x + +instance Read VkInstanceCreateFlags where + {-# INLINE readsPrec #-} + readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags) + +newtype VkMacOSSurfaceCreateFlagsMVK = VkMacOSSurfaceCreateFlagsMVK VkFlags + deriving (Eq, Ord, Num, Bounded, Enum, Integral, Bits, + FiniteBits, Storable, Real, Data, Generic) + +instance Show VkMacOSSurfaceCreateFlagsMVK where + {-# INLINE show #-} + show (VkMacOSSurfaceCreateFlagsMVK x) = show x + +instance Read VkMacOSSurfaceCreateFlagsMVK where + {-# INLINE readsPrec #-} + readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags) + +newtype VkMemoryMapFlags = VkMemoryMapFlags VkFlags + deriving (Eq, Ord, Num, Bounded, Enum, Integral, Bits, FiniteBits, + Storable, Real, Data, Generic) + +instance Show VkMemoryMapFlags where + {-# INLINE show #-} + show (VkMemoryMapFlags x) = show x + +instance Read VkMemoryMapFlags where + {-# INLINE readsPrec #-} + readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags) + +newtype VkMirSurfaceCreateFlagsKHR = VkMirSurfaceCreateFlagsKHR VkFlags + deriving (Eq, Ord, Num, Bounded, Enum, Integral, Bits, + FiniteBits, Storable, Real, Data, Generic) + +instance Show VkMirSurfaceCreateFlagsKHR where + {-# INLINE show #-} + show (VkMirSurfaceCreateFlagsKHR x) = show x + +instance Read VkMirSurfaceCreateFlagsKHR where + {-# INLINE readsPrec #-} + readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags) + +newtype VkPipelineCacheCreateFlags = VkPipelineCacheCreateFlags VkFlags + deriving (Eq, Ord, Num, Bounded, Enum, Integral, Bits, + FiniteBits, Storable, Real, Data, Generic) + +instance Show VkPipelineCacheCreateFlags where + {-# INLINE show #-} + show (VkPipelineCacheCreateFlags x) = show x + +instance Read VkPipelineCacheCreateFlags where + {-# INLINE readsPrec #-} + readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags) + +newtype VkPipelineColorBlendStateCreateFlags = VkPipelineColorBlendStateCreateFlags VkFlags + deriving (Eq, Ord, Num, Bounded, Enum, Integral, + Bits, FiniteBits, Storable, Real, Data, + Generic) + +instance Show VkPipelineColorBlendStateCreateFlags where + {-# INLINE show #-} + show (VkPipelineColorBlendStateCreateFlags x) = show x + +instance Read VkPipelineColorBlendStateCreateFlags where + {-# INLINE readsPrec #-} + readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags) + +newtype VkPipelineCoverageModulationStateCreateFlagsNV = VkPipelineCoverageModulationStateCreateFlagsNV VkFlags + deriving (Eq, Ord, Num, Bounded, Enum, + Integral, Bits, FiniteBits, + Storable, Real, Data, Generic) + +instance Show VkPipelineCoverageModulationStateCreateFlagsNV where + {-# INLINE show #-} + show (VkPipelineCoverageModulationStateCreateFlagsNV x) = show x + +instance Read VkPipelineCoverageModulationStateCreateFlagsNV where + {-# INLINE readsPrec #-} + readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags) + +newtype VkPipelineCoverageToColorStateCreateFlagsNV = VkPipelineCoverageToColorStateCreateFlagsNV VkFlags + deriving (Eq, Ord, Num, Bounded, Enum, + Integral, Bits, FiniteBits, + Storable, Real, Data, Generic) + +instance Show VkPipelineCoverageToColorStateCreateFlagsNV where + {-# INLINE show #-} + show (VkPipelineCoverageToColorStateCreateFlagsNV x) = show x + +instance Read VkPipelineCoverageToColorStateCreateFlagsNV where + {-# INLINE readsPrec #-} + readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags) + +newtype VkPipelineDepthStencilStateCreateFlags = VkPipelineDepthStencilStateCreateFlags VkFlags + deriving (Eq, Ord, Num, Bounded, Enum, Integral, + Bits, FiniteBits, Storable, Real, Data, + Generic) + +instance Show VkPipelineDepthStencilStateCreateFlags where + {-# INLINE show #-} + show (VkPipelineDepthStencilStateCreateFlags x) = show x + +instance Read VkPipelineDepthStencilStateCreateFlags where + {-# INLINE readsPrec #-} + readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags) + +newtype VkPipelineDiscardRectangleStateCreateFlagsEXT = VkPipelineDiscardRectangleStateCreateFlagsEXT VkFlags + deriving (Eq, Ord, Num, Bounded, Enum, + Integral, Bits, FiniteBits, + Storable, Real, Data, Generic) + +instance Show VkPipelineDiscardRectangleStateCreateFlagsEXT where + {-# INLINE show #-} + show (VkPipelineDiscardRectangleStateCreateFlagsEXT x) = show x + +instance Read VkPipelineDiscardRectangleStateCreateFlagsEXT where + {-# INLINE readsPrec #-} + readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags) + +newtype VkPipelineDynamicStateCreateFlags = VkPipelineDynamicStateCreateFlags VkFlags + deriving (Eq, Ord, Num, Bounded, Enum, Integral, Bits, + FiniteBits, Storable, Real, Data, Generic) + +instance Show VkPipelineDynamicStateCreateFlags where + {-# INLINE show #-} + show (VkPipelineDynamicStateCreateFlags x) = show x + +instance Read VkPipelineDynamicStateCreateFlags where + {-# INLINE readsPrec #-} + readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags) + +newtype VkPipelineInputAssemblyStateCreateFlags = VkPipelineInputAssemblyStateCreateFlags VkFlags + deriving (Eq, Ord, Num, Bounded, Enum, Integral, + Bits, FiniteBits, Storable, Real, + Data, Generic) + +instance Show VkPipelineInputAssemblyStateCreateFlags where + {-# INLINE show #-} + show (VkPipelineInputAssemblyStateCreateFlags x) = show x + +instance Read VkPipelineInputAssemblyStateCreateFlags where + {-# INLINE readsPrec #-} + readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags) + +newtype VkPipelineLayoutCreateFlags = VkPipelineLayoutCreateFlags VkFlags + deriving (Eq, Ord, Num, Bounded, Enum, Integral, Bits, + FiniteBits, Storable, Real, Data, Generic) + +instance Show VkPipelineLayoutCreateFlags where + {-# INLINE show #-} + show (VkPipelineLayoutCreateFlags x) = show x + +instance Read VkPipelineLayoutCreateFlags where + {-# INLINE readsPrec #-} + readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags) + +newtype VkPipelineMultisampleStateCreateFlags = VkPipelineMultisampleStateCreateFlags VkFlags + deriving (Eq, Ord, Num, Bounded, Enum, Integral, + Bits, FiniteBits, Storable, Real, Data, + Generic) + +instance Show VkPipelineMultisampleStateCreateFlags where + {-# INLINE show #-} + show (VkPipelineMultisampleStateCreateFlags x) = show x + +instance Read VkPipelineMultisampleStateCreateFlags where + {-# INLINE readsPrec #-} + readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags) + +newtype VkPipelineRasterizationConservativeStateCreateFlagsEXT = VkPipelineRasterizationConservativeStateCreateFlagsEXT VkFlags + deriving (Eq, Ord, Num, Bounded, + Enum, Integral, Bits, + FiniteBits, Storable, + Real, Data, Generic) + +instance Show + VkPipelineRasterizationConservativeStateCreateFlagsEXT + where + {-# INLINE show #-} + show (VkPipelineRasterizationConservativeStateCreateFlagsEXT x) + = show x + +instance Read + VkPipelineRasterizationConservativeStateCreateFlagsEXT + where + {-# INLINE readsPrec #-} + readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags) + +newtype VkPipelineRasterizationStateCreateFlags = VkPipelineRasterizationStateCreateFlags VkFlags + deriving (Eq, Ord, Num, Bounded, Enum, Integral, + Bits, FiniteBits, Storable, Real, + Data, Generic) + +instance Show VkPipelineRasterizationStateCreateFlags where + {-# INLINE show #-} + show (VkPipelineRasterizationStateCreateFlags x) = show x + +instance Read VkPipelineRasterizationStateCreateFlags where + {-# INLINE readsPrec #-} + readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags) + +newtype VkPipelineShaderStageCreateFlags = VkPipelineShaderStageCreateFlags VkFlags + deriving (Eq, Ord, Num, Bounded, Enum, Integral, Bits, + FiniteBits, Storable, Real, Data, Generic) + +instance Show VkPipelineShaderStageCreateFlags where + {-# INLINE show #-} + show (VkPipelineShaderStageCreateFlags x) = show x + +instance Read VkPipelineShaderStageCreateFlags where + {-# INLINE readsPrec #-} + readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags) + +newtype VkPipelineTessellationStateCreateFlags = VkPipelineTessellationStateCreateFlags VkFlags + deriving (Eq, Ord, Num, Bounded, Enum, Integral, + Bits, FiniteBits, Storable, Real, Data, + Generic) + +instance Show VkPipelineTessellationStateCreateFlags where + {-# INLINE show #-} + show (VkPipelineTessellationStateCreateFlags x) = show x + +instance Read VkPipelineTessellationStateCreateFlags where + {-# INLINE readsPrec #-} + readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags) + +newtype VkPipelineVertexInputStateCreateFlags = VkPipelineVertexInputStateCreateFlags VkFlags + deriving (Eq, Ord, Num, Bounded, Enum, Integral, + Bits, FiniteBits, Storable, Real, Data, + Generic) + +instance Show VkPipelineVertexInputStateCreateFlags where + {-# INLINE show #-} + show (VkPipelineVertexInputStateCreateFlags x) = show x + +instance Read VkPipelineVertexInputStateCreateFlags where + {-# INLINE readsPrec #-} + readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags) + +newtype VkPipelineViewportStateCreateFlags = VkPipelineViewportStateCreateFlags VkFlags + deriving (Eq, Ord, Num, Bounded, Enum, Integral, + Bits, FiniteBits, Storable, Real, Data, + Generic) + +instance Show VkPipelineViewportStateCreateFlags where + {-# INLINE show #-} + show (VkPipelineViewportStateCreateFlags x) = show x + +instance Read VkPipelineViewportStateCreateFlags where + {-# INLINE readsPrec #-} + readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags) + +newtype VkPipelineViewportSwizzleStateCreateFlagsNV = VkPipelineViewportSwizzleStateCreateFlagsNV VkFlags + deriving (Eq, Ord, Num, Bounded, Enum, + Integral, Bits, FiniteBits, + Storable, Real, Data, Generic) + +instance Show VkPipelineViewportSwizzleStateCreateFlagsNV where + {-# INLINE show #-} + show (VkPipelineViewportSwizzleStateCreateFlagsNV x) = show x + +instance Read VkPipelineViewportSwizzleStateCreateFlagsNV where + {-# INLINE readsPrec #-} + readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags) + +newtype VkQueryPoolCreateFlags = VkQueryPoolCreateFlags VkFlags + deriving (Eq, Ord, Num, Bounded, Enum, Integral, Bits, + FiniteBits, Storable, Real, Data, Generic) + +instance Show VkQueryPoolCreateFlags where + {-# INLINE show #-} + show (VkQueryPoolCreateFlags x) = show x + +instance Read VkQueryPoolCreateFlags where + {-# INLINE readsPrec #-} + readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags) + +newtype VkRenderPassCreateFlags = VkRenderPassCreateFlags VkFlags + deriving (Eq, Ord, Num, Bounded, Enum, Integral, Bits, + FiniteBits, Storable, Real, Data, Generic) + +instance Show VkRenderPassCreateFlags where + {-# INLINE show #-} + show (VkRenderPassCreateFlags x) = show x + +instance Read VkRenderPassCreateFlags where + {-# INLINE readsPrec #-} + readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags) + +newtype VkSamplerCreateFlags = VkSamplerCreateFlags VkFlags + deriving (Eq, Ord, Num, Bounded, Enum, Integral, Bits, FiniteBits, + Storable, Real, Data, Generic) + +instance Show VkSamplerCreateFlags where + {-# INLINE show #-} + show (VkSamplerCreateFlags x) = show x + +instance Read VkSamplerCreateFlags where + {-# INLINE readsPrec #-} + readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags) + +newtype VkSemaphoreCreateFlags = VkSemaphoreCreateFlags VkFlags + deriving (Eq, Ord, Num, Bounded, Enum, Integral, Bits, + FiniteBits, Storable, Real, Data, Generic) + +instance Show VkSemaphoreCreateFlags where + {-# INLINE show #-} + show (VkSemaphoreCreateFlags x) = show x + +instance Read VkSemaphoreCreateFlags where + {-# INLINE readsPrec #-} + readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags) + +newtype VkShaderModuleCreateFlags = VkShaderModuleCreateFlags VkFlags + deriving (Eq, Ord, Num, Bounded, Enum, Integral, Bits, + FiniteBits, Storable, Real, Data, Generic) + +instance Show VkShaderModuleCreateFlags where + {-# INLINE show #-} + show (VkShaderModuleCreateFlags x) = show x + +instance Read VkShaderModuleCreateFlags where + {-# INLINE readsPrec #-} + readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags) + +newtype VkValidationCacheCreateFlagsEXT = VkValidationCacheCreateFlagsEXT VkFlags + deriving (Eq, Ord, Num, Bounded, Enum, Integral, Bits, + FiniteBits, Storable, Real, Data, Generic) + +instance Show VkValidationCacheCreateFlagsEXT where + {-# INLINE show #-} + show (VkValidationCacheCreateFlagsEXT x) = show x + +instance Read VkValidationCacheCreateFlagsEXT where + {-# INLINE readsPrec #-} + readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags) + +newtype VkViSurfaceCreateFlagsNN = VkViSurfaceCreateFlagsNN VkFlags + deriving (Eq, Ord, Num, Bounded, Enum, Integral, Bits, + FiniteBits, Storable, Real, Data, Generic) + +instance Show VkViSurfaceCreateFlagsNN where + {-# INLINE show #-} + show (VkViSurfaceCreateFlagsNN x) = show x + +instance Read VkViSurfaceCreateFlagsNN where + {-# INLINE readsPrec #-} + readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags) + +newtype VkWaylandSurfaceCreateFlagsKHR = VkWaylandSurfaceCreateFlagsKHR VkFlags + deriving (Eq, Ord, Num, Bounded, Enum, Integral, Bits, + FiniteBits, Storable, Real, Data, Generic) + +instance Show VkWaylandSurfaceCreateFlagsKHR where + {-# INLINE show #-} + show (VkWaylandSurfaceCreateFlagsKHR x) = show x + +instance Read VkWaylandSurfaceCreateFlagsKHR where + {-# INLINE readsPrec #-} + readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags) + +newtype VkWin32SurfaceCreateFlagsKHR = VkWin32SurfaceCreateFlagsKHR VkFlags + deriving (Eq, Ord, Num, Bounded, Enum, Integral, Bits, + FiniteBits, Storable, Real, Data, Generic) + +instance Show VkWin32SurfaceCreateFlagsKHR where + {-# INLINE show #-} + show (VkWin32SurfaceCreateFlagsKHR x) = show x + +instance Read VkWin32SurfaceCreateFlagsKHR where + {-# INLINE readsPrec #-} + readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags) + +newtype VkXcbSurfaceCreateFlagsKHR = VkXcbSurfaceCreateFlagsKHR VkFlags + deriving (Eq, Ord, Num, Bounded, Enum, Integral, Bits, + FiniteBits, Storable, Real, Data, Generic) + +instance Show VkXcbSurfaceCreateFlagsKHR where + {-# INLINE show #-} + show (VkXcbSurfaceCreateFlagsKHR x) = show x + +instance Read VkXcbSurfaceCreateFlagsKHR where + {-# INLINE readsPrec #-} + readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags) + +newtype VkXlibSurfaceCreateFlagsKHR = VkXlibSurfaceCreateFlagsKHR VkFlags + deriving (Eq, Ord, Num, Bounded, Enum, Integral, Bits, + FiniteBits, Storable, Real, Data, Generic) + +instance Show VkXlibSurfaceCreateFlagsKHR where + {-# INLINE show #-} + show (VkXlibSurfaceCreateFlagsKHR x) = show x + +instance Read VkXlibSurfaceCreateFlagsKHR where + {-# INLINE readsPrec #-} + readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags) diff --git a/src-gen/Graphics/Vulkan/Types/Defines.hs b/src-gen/Graphics/Vulkan/Types/Defines.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Defines.hs @@ -0,0 +1,77 @@ +{-# LANGUAGE CPP #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +module Graphics.Vulkan.Types.Defines + (-- | ===== @VK_API_VERSION@ + -- > // DEPRECATED: This define has been removed. Specific version defines (e.g. VK_API_VERSION_1_0), or the VK_MAKE_VERSION macro, should be used instead. + -- > //#define VK_API_VERSION VK_MAKE_VERSION(1, 0, 0) // Patch version should always be set to 0 + VK_API_VERSION_1_0, pattern VK_API_VERSION_1_0, Ptr(), -- | ===== @VK_DEFINE_HANDLE@ + -- Dispatchable handles are represented as `Foreign.Ptr` + -- + -- > + -- > #define VK_DEFINE_HANDLE(object) typedef struct object##_T* object; + VkPtr(..), + -- | ===== @VK_DEFINE_NON_DISPATCHABLE_HANDLE@ + -- Non-dispatchable handles are represented as `VkPtr` + -- + -- > + -- > #if !defined(VK_DEFINE_NON_DISPATCHABLE_HANDLE) + -- > #if defined(__LP64__) || defined(_WIN64) || (defined(__x86_64__) && !defined(__ILP32__) ) || defined(_M_X64) || defined(__ia64) || defined (_M_IA64) || defined(__aarch64__) || defined(__powerpc64__) + -- > #define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef struct object##_T *object; + -- > #else + -- > #define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef uint64_t object; + -- > #endif + -- > #endif + -- > + VK_HEADER_VERSION, pattern VK_HEADER_VERSION, _VK_MAKE_VERSION, + VulkanPtr(..), pattern VK_NULL_HANDLE, _VK_VERSION_MAJOR, + _VK_VERSION_MINOR, _VK_VERSION_PATCH) + where +import Data.Bits (Bits (..)) +import Graphics.Vulkan.Marshal + +-- | > // Vulkan 1.0 version number +-- > #define VK_API_VERSION_1_0 VK_MAKE_VERSION(1, 0, 0)// Patch version should always be set to 0 +pattern VK_API_VERSION_1_0 :: (Num a, Eq a) => a + +pattern VK_API_VERSION_1_0 = 4194304 + +type VK_API_VERSION_1_0 = 4194304 + +-- | > // Version of this file +-- > #define VK_HEADER_VERSION 69 +pattern VK_HEADER_VERSION :: (Num a, Eq a) => a + +pattern VK_HEADER_VERSION = 69 + +type VK_HEADER_VERSION = 69 + +-- | > #define VK_MAKE_VERSION(major, minor, patch) \ +-- > (((major) << 22) | ((minor) << 12) | (patch)) +_VK_MAKE_VERSION :: Bits a => a -> a -> a -> a +_VK_MAKE_VERSION major minor patch + = unsafeShiftL major 22 .|. unsafeShiftL minor 12 .|. patch + +{-# INLINE _VK_MAKE_VERSION #-} +#define VK_MAKE_VERSION(major, minor, patch) _VK_MAKE_VERSION major minor patch + +-- | > #define VK_VERSION_MAJOR(version) ((uint32_t)(version) >> 22) +_VK_VERSION_MAJOR :: Bits a => a -> a +_VK_VERSION_MAJOR version = unsafeShiftR version 22 + +{-# INLINE _VK_VERSION_MAJOR #-} +#define VK_VERSION_MAJOR(version) _VK_VERSION_MAJOR version + +-- | > #define VK_VERSION_MINOR(version) (((uint32_t)(version) >> 12) & 0x3ff) +_VK_VERSION_MINOR :: (Bits a, Num a) => a -> a +_VK_VERSION_MINOR version = unsafeShiftR version 12 .&. 1023 + +{-# INLINE _VK_VERSION_MINOR #-} +#define VK_VERSION_MINOR(version) _VK_VERSION_MINOR version + +-- | > #define VK_VERSION_PATCH(version) ((uint32_t)(version) & 0xfff) +_VK_VERSION_PATCH :: (Bits a, Num a) => a -> a +_VK_VERSION_PATCH = (.&. 4095) + +{-# INLINE _VK_VERSION_PATCH #-} diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkAccessFlags.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkAccessFlags.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkAccessFlags.hs @@ -0,0 +1,260 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE KindSignatures #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE StandaloneDeriving #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeSynonymInstances #-} +module Graphics.Vulkan.Types.Enum.VkAccessFlags + (VkAccessBitmask(VkAccessBitmask, VkAccessFlags, VkAccessFlagBits, + VK_ACCESS_INDIRECT_COMMAND_READ_BIT, VK_ACCESS_INDEX_READ_BIT, + VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT, VK_ACCESS_UNIFORM_READ_BIT, + VK_ACCESS_INPUT_ATTACHMENT_READ_BIT, VK_ACCESS_SHADER_READ_BIT, + VK_ACCESS_SHADER_WRITE_BIT, VK_ACCESS_COLOR_ATTACHMENT_READ_BIT, + VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, + VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT, + VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT, + VK_ACCESS_TRANSFER_READ_BIT, VK_ACCESS_TRANSFER_WRITE_BIT, + VK_ACCESS_HOST_READ_BIT, VK_ACCESS_HOST_WRITE_BIT, + VK_ACCESS_MEMORY_READ_BIT, VK_ACCESS_MEMORY_WRITE_BIT), + VkAccessFlags, VkAccessFlagBits) + where +import Data.Bits (Bits, FiniteBits) +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (FlagBit, FlagMask, FlagType) +import Graphics.Vulkan.Types.BaseTypes (VkFlags (..)) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +newtype VkAccessBitmask (a :: FlagType) = VkAccessBitmask VkFlags + deriving (Eq, Ord, Storable, Data, Generic) + +type VkAccessFlags = VkAccessBitmask FlagMask + +type VkAccessFlagBits = VkAccessBitmask FlagBit + +pattern VkAccessFlagBits :: VkFlags -> VkAccessBitmask FlagBit + +pattern VkAccessFlagBits n = VkAccessBitmask n + +pattern VkAccessFlags :: VkFlags -> VkAccessBitmask FlagMask + +pattern VkAccessFlags n = VkAccessBitmask n + +deriving instance Bits (VkAccessBitmask FlagMask) + +deriving instance FiniteBits (VkAccessBitmask FlagMask) + +deriving instance Integral (VkAccessBitmask FlagMask) + +deriving instance Num (VkAccessBitmask FlagMask) + +deriving instance Bounded (VkAccessBitmask FlagMask) + +deriving instance Enum (VkAccessBitmask FlagMask) + +deriving instance Real (VkAccessBitmask FlagMask) + +instance Show (VkAccessBitmask a) where + showsPrec _ VK_ACCESS_INDIRECT_COMMAND_READ_BIT + = showString "VK_ACCESS_INDIRECT_COMMAND_READ_BIT" + showsPrec _ VK_ACCESS_INDEX_READ_BIT + = showString "VK_ACCESS_INDEX_READ_BIT" + showsPrec _ VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT + = showString "VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT" + showsPrec _ VK_ACCESS_UNIFORM_READ_BIT + = showString "VK_ACCESS_UNIFORM_READ_BIT" + showsPrec _ VK_ACCESS_INPUT_ATTACHMENT_READ_BIT + = showString "VK_ACCESS_INPUT_ATTACHMENT_READ_BIT" + showsPrec _ VK_ACCESS_SHADER_READ_BIT + = showString "VK_ACCESS_SHADER_READ_BIT" + showsPrec _ VK_ACCESS_SHADER_WRITE_BIT + = showString "VK_ACCESS_SHADER_WRITE_BIT" + showsPrec _ VK_ACCESS_COLOR_ATTACHMENT_READ_BIT + = showString "VK_ACCESS_COLOR_ATTACHMENT_READ_BIT" + showsPrec _ VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT + = showString "VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT" + showsPrec _ VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT + = showString "VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT" + showsPrec _ VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT + = showString "VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT" + showsPrec _ VK_ACCESS_TRANSFER_READ_BIT + = showString "VK_ACCESS_TRANSFER_READ_BIT" + showsPrec _ VK_ACCESS_TRANSFER_WRITE_BIT + = showString "VK_ACCESS_TRANSFER_WRITE_BIT" + showsPrec _ VK_ACCESS_HOST_READ_BIT + = showString "VK_ACCESS_HOST_READ_BIT" + showsPrec _ VK_ACCESS_HOST_WRITE_BIT + = showString "VK_ACCESS_HOST_WRITE_BIT" + showsPrec _ VK_ACCESS_MEMORY_READ_BIT + = showString "VK_ACCESS_MEMORY_READ_BIT" + showsPrec _ VK_ACCESS_MEMORY_WRITE_BIT + = showString "VK_ACCESS_MEMORY_WRITE_BIT" + showsPrec p (VkAccessBitmask x) + = showParen (p >= 11) + (showString "VkAccessBitmask " . showsPrec 11 x) + +instance Read (VkAccessBitmask a) where + readPrec + = parens + (choose + [("VK_ACCESS_INDIRECT_COMMAND_READ_BIT", + pure VK_ACCESS_INDIRECT_COMMAND_READ_BIT), + ("VK_ACCESS_INDEX_READ_BIT", pure VK_ACCESS_INDEX_READ_BIT), + ("VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT", + pure VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT), + ("VK_ACCESS_UNIFORM_READ_BIT", pure VK_ACCESS_UNIFORM_READ_BIT), + ("VK_ACCESS_INPUT_ATTACHMENT_READ_BIT", + pure VK_ACCESS_INPUT_ATTACHMENT_READ_BIT), + ("VK_ACCESS_SHADER_READ_BIT", pure VK_ACCESS_SHADER_READ_BIT), + ("VK_ACCESS_SHADER_WRITE_BIT", pure VK_ACCESS_SHADER_WRITE_BIT), + ("VK_ACCESS_COLOR_ATTACHMENT_READ_BIT", + pure VK_ACCESS_COLOR_ATTACHMENT_READ_BIT), + ("VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT", + pure VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT), + ("VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT", + pure VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT), + ("VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT", + pure VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT), + ("VK_ACCESS_TRANSFER_READ_BIT", pure VK_ACCESS_TRANSFER_READ_BIT), + ("VK_ACCESS_TRANSFER_WRITE_BIT", + pure VK_ACCESS_TRANSFER_WRITE_BIT), + ("VK_ACCESS_HOST_READ_BIT", pure VK_ACCESS_HOST_READ_BIT), + ("VK_ACCESS_HOST_WRITE_BIT", pure VK_ACCESS_HOST_WRITE_BIT), + ("VK_ACCESS_MEMORY_READ_BIT", pure VK_ACCESS_MEMORY_READ_BIT), + ("VK_ACCESS_MEMORY_WRITE_BIT", pure VK_ACCESS_MEMORY_WRITE_BIT)] + +++ + prec 10 + (expectP (Ident "VkAccessBitmask") >> + (VkAccessBitmask <$> step readPrec))) + +-- | Controls coherency of indirect command reads +-- +-- bitpos = @0@ +pattern VK_ACCESS_INDIRECT_COMMAND_READ_BIT :: VkAccessBitmask a + +pattern VK_ACCESS_INDIRECT_COMMAND_READ_BIT = VkAccessBitmask 1 + +-- | Controls coherency of index reads +-- +-- bitpos = @1@ +pattern VK_ACCESS_INDEX_READ_BIT :: VkAccessBitmask a + +pattern VK_ACCESS_INDEX_READ_BIT = VkAccessBitmask 2 + +-- | Controls coherency of vertex attribute reads +-- +-- bitpos = @2@ +pattern VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT :: VkAccessBitmask a + +pattern VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT = VkAccessBitmask 4 + +-- | Controls coherency of uniform buffer reads +-- +-- bitpos = @3@ +pattern VK_ACCESS_UNIFORM_READ_BIT :: VkAccessBitmask a + +pattern VK_ACCESS_UNIFORM_READ_BIT = VkAccessBitmask 8 + +-- | Controls coherency of input attachment reads +-- +-- bitpos = @4@ +pattern VK_ACCESS_INPUT_ATTACHMENT_READ_BIT :: VkAccessBitmask a + +pattern VK_ACCESS_INPUT_ATTACHMENT_READ_BIT = VkAccessBitmask 16 + +-- | Controls coherency of shader reads +-- +-- bitpos = @5@ +pattern VK_ACCESS_SHADER_READ_BIT :: VkAccessBitmask a + +pattern VK_ACCESS_SHADER_READ_BIT = VkAccessBitmask 32 + +-- | Controls coherency of shader writes +-- +-- bitpos = @6@ +pattern VK_ACCESS_SHADER_WRITE_BIT :: VkAccessBitmask a + +pattern VK_ACCESS_SHADER_WRITE_BIT = VkAccessBitmask 64 + +-- | Controls coherency of color attachment reads +-- +-- bitpos = @7@ +pattern VK_ACCESS_COLOR_ATTACHMENT_READ_BIT :: VkAccessBitmask a + +pattern VK_ACCESS_COLOR_ATTACHMENT_READ_BIT = VkAccessBitmask 128 + +-- | Controls coherency of color attachment writes +-- +-- bitpos = @8@ +pattern VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT :: VkAccessBitmask a + +pattern VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT = VkAccessBitmask 256 + +-- | Controls coherency of depth/stencil attachment reads +-- +-- bitpos = @9@ +pattern VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT :: + VkAccessBitmask a + +pattern VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT = + VkAccessBitmask 512 + +-- | Controls coherency of depth/stencil attachment writes +-- +-- bitpos = @10@ +pattern VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT :: + VkAccessBitmask a + +pattern VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT = + VkAccessBitmask 1024 + +-- | Controls coherency of transfer reads +-- +-- bitpos = @11@ +pattern VK_ACCESS_TRANSFER_READ_BIT :: VkAccessBitmask a + +pattern VK_ACCESS_TRANSFER_READ_BIT = VkAccessBitmask 2048 + +-- | Controls coherency of transfer writes +-- +-- bitpos = @12@ +pattern VK_ACCESS_TRANSFER_WRITE_BIT :: VkAccessBitmask a + +pattern VK_ACCESS_TRANSFER_WRITE_BIT = VkAccessBitmask 4096 + +-- | Controls coherency of host reads +-- +-- bitpos = @13@ +pattern VK_ACCESS_HOST_READ_BIT :: VkAccessBitmask a + +pattern VK_ACCESS_HOST_READ_BIT = VkAccessBitmask 8192 + +-- | Controls coherency of host writes +-- +-- bitpos = @14@ +pattern VK_ACCESS_HOST_WRITE_BIT :: VkAccessBitmask a + +pattern VK_ACCESS_HOST_WRITE_BIT = VkAccessBitmask 16384 + +-- | Controls coherency of memory reads +-- +-- bitpos = @15@ +pattern VK_ACCESS_MEMORY_READ_BIT :: VkAccessBitmask a + +pattern VK_ACCESS_MEMORY_READ_BIT = VkAccessBitmask 32768 + +-- | Controls coherency of memory writes +-- +-- bitpos = @16@ +pattern VK_ACCESS_MEMORY_WRITE_BIT :: VkAccessBitmask a + +pattern VK_ACCESS_MEMORY_WRITE_BIT = VkAccessBitmask 65536 diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkAttachmentDescriptionFlags.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkAttachmentDescriptionFlags.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkAttachmentDescriptionFlags.hs @@ -0,0 +1,93 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE KindSignatures #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE StandaloneDeriving #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeSynonymInstances #-} +module Graphics.Vulkan.Types.Enum.VkAttachmentDescriptionFlags + (VkAttachmentDescriptionBitmask(VkAttachmentDescriptionBitmask, + VkAttachmentDescriptionFlags, + VkAttachmentDescriptionFlagBits, + VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT), + VkAttachmentDescriptionFlags, VkAttachmentDescriptionFlagBits) + where +import Data.Bits (Bits, FiniteBits) +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (FlagBit, FlagMask, FlagType) +import Graphics.Vulkan.Types.BaseTypes (VkFlags (..)) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +newtype VkAttachmentDescriptionBitmask (a :: + FlagType) = VkAttachmentDescriptionBitmask VkFlags + deriving (Eq, Ord, Storable, Data, Generic) + +type VkAttachmentDescriptionFlags = + VkAttachmentDescriptionBitmask FlagMask + +type VkAttachmentDescriptionFlagBits = + VkAttachmentDescriptionBitmask FlagBit + +pattern VkAttachmentDescriptionFlagBits :: + VkFlags -> VkAttachmentDescriptionBitmask FlagBit + +pattern VkAttachmentDescriptionFlagBits n = + VkAttachmentDescriptionBitmask n + +pattern VkAttachmentDescriptionFlags :: + VkFlags -> VkAttachmentDescriptionBitmask FlagMask + +pattern VkAttachmentDescriptionFlags n = + VkAttachmentDescriptionBitmask n + +deriving instance Bits (VkAttachmentDescriptionBitmask FlagMask) + +deriving instance + FiniteBits (VkAttachmentDescriptionBitmask FlagMask) + +deriving instance + Integral (VkAttachmentDescriptionBitmask FlagMask) + +deriving instance Num (VkAttachmentDescriptionBitmask FlagMask) + +deriving instance Bounded (VkAttachmentDescriptionBitmask FlagMask) + +deriving instance Enum (VkAttachmentDescriptionBitmask FlagMask) + +deriving instance Real (VkAttachmentDescriptionBitmask FlagMask) + +instance Show (VkAttachmentDescriptionBitmask a) where + showsPrec _ VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT + = showString "VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT" + showsPrec p (VkAttachmentDescriptionBitmask x) + = showParen (p >= 11) + (showString "VkAttachmentDescriptionBitmask " . showsPrec 11 x) + +instance Read (VkAttachmentDescriptionBitmask a) where + readPrec + = parens + (choose + [("VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT", + pure VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT)] + +++ + prec 10 + (expectP (Ident "VkAttachmentDescriptionBitmask") >> + (VkAttachmentDescriptionBitmask <$> step readPrec))) + +-- | The attachment may alias physical memory of another attachment in the same render pass +-- +-- bitpos = @0@ +pattern VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT :: + VkAttachmentDescriptionBitmask a + +pattern VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT = + VkAttachmentDescriptionBitmask 1 diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkAttachmentLoadOp.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkAttachmentLoadOp.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkAttachmentLoadOp.hs @@ -0,0 +1,61 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +module Graphics.Vulkan.Types.Enum.VkAttachmentLoadOp + (VkAttachmentLoadOp(VkAttachmentLoadOp, VK_ATTACHMENT_LOAD_OP_LOAD, + VK_ATTACHMENT_LOAD_OP_CLEAR, VK_ATTACHMENT_LOAD_OP_DONT_CARE)) + where +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (Int32) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +-- | type = @enum@ +-- +-- +newtype VkAttachmentLoadOp = VkAttachmentLoadOp Int32 + deriving (Eq, Ord, Num, Bounded, Storable, Enum, Data, Generic) + +instance Show VkAttachmentLoadOp where + showsPrec _ VK_ATTACHMENT_LOAD_OP_LOAD + = showString "VK_ATTACHMENT_LOAD_OP_LOAD" + showsPrec _ VK_ATTACHMENT_LOAD_OP_CLEAR + = showString "VK_ATTACHMENT_LOAD_OP_CLEAR" + showsPrec _ VK_ATTACHMENT_LOAD_OP_DONT_CARE + = showString "VK_ATTACHMENT_LOAD_OP_DONT_CARE" + showsPrec p (VkAttachmentLoadOp x) + = showParen (p >= 11) + (showString "VkAttachmentLoadOp " . showsPrec 11 x) + +instance Read VkAttachmentLoadOp where + readPrec + = parens + (choose + [("VK_ATTACHMENT_LOAD_OP_LOAD", pure VK_ATTACHMENT_LOAD_OP_LOAD), + ("VK_ATTACHMENT_LOAD_OP_CLEAR", pure VK_ATTACHMENT_LOAD_OP_CLEAR), + ("VK_ATTACHMENT_LOAD_OP_DONT_CARE", + pure VK_ATTACHMENT_LOAD_OP_DONT_CARE)] + +++ + prec 10 + (expectP (Ident "VkAttachmentLoadOp") >> + (VkAttachmentLoadOp <$> step readPrec))) + +pattern VK_ATTACHMENT_LOAD_OP_LOAD :: VkAttachmentLoadOp + +pattern VK_ATTACHMENT_LOAD_OP_LOAD = VkAttachmentLoadOp 0 + +pattern VK_ATTACHMENT_LOAD_OP_CLEAR :: VkAttachmentLoadOp + +pattern VK_ATTACHMENT_LOAD_OP_CLEAR = VkAttachmentLoadOp 1 + +pattern VK_ATTACHMENT_LOAD_OP_DONT_CARE :: VkAttachmentLoadOp + +pattern VK_ATTACHMENT_LOAD_OP_DONT_CARE = VkAttachmentLoadOp 2 diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkAttachmentStoreOp.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkAttachmentStoreOp.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkAttachmentStoreOp.hs @@ -0,0 +1,55 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +module Graphics.Vulkan.Types.Enum.VkAttachmentStoreOp + (VkAttachmentStoreOp(VkAttachmentStoreOp, + VK_ATTACHMENT_STORE_OP_STORE, VK_ATTACHMENT_STORE_OP_DONT_CARE)) + where +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (Int32) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +-- | type = @enum@ +-- +-- +newtype VkAttachmentStoreOp = VkAttachmentStoreOp Int32 + deriving (Eq, Ord, Num, Bounded, Storable, Enum, Data, Generic) + +instance Show VkAttachmentStoreOp where + showsPrec _ VK_ATTACHMENT_STORE_OP_STORE + = showString "VK_ATTACHMENT_STORE_OP_STORE" + showsPrec _ VK_ATTACHMENT_STORE_OP_DONT_CARE + = showString "VK_ATTACHMENT_STORE_OP_DONT_CARE" + showsPrec p (VkAttachmentStoreOp x) + = showParen (p >= 11) + (showString "VkAttachmentStoreOp " . showsPrec 11 x) + +instance Read VkAttachmentStoreOp where + readPrec + = parens + (choose + [("VK_ATTACHMENT_STORE_OP_STORE", + pure VK_ATTACHMENT_STORE_OP_STORE), + ("VK_ATTACHMENT_STORE_OP_DONT_CARE", + pure VK_ATTACHMENT_STORE_OP_DONT_CARE)] + +++ + prec 10 + (expectP (Ident "VkAttachmentStoreOp") >> + (VkAttachmentStoreOp <$> step readPrec))) + +pattern VK_ATTACHMENT_STORE_OP_STORE :: VkAttachmentStoreOp + +pattern VK_ATTACHMENT_STORE_OP_STORE = VkAttachmentStoreOp 0 + +pattern VK_ATTACHMENT_STORE_OP_DONT_CARE :: VkAttachmentStoreOp + +pattern VK_ATTACHMENT_STORE_OP_DONT_CARE = VkAttachmentStoreOp 1 diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkBlendFactor.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkBlendFactor.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkBlendFactor.hs @@ -0,0 +1,193 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +module Graphics.Vulkan.Types.Enum.VkBlendFactor + (VkBlendFactor(VkBlendFactor, VK_BLEND_FACTOR_ZERO, + VK_BLEND_FACTOR_ONE, VK_BLEND_FACTOR_SRC_COLOR, + VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR, VK_BLEND_FACTOR_DST_COLOR, + VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR, VK_BLEND_FACTOR_SRC_ALPHA, + VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA, VK_BLEND_FACTOR_DST_ALPHA, + VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA, + VK_BLEND_FACTOR_CONSTANT_COLOR, + VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR, + VK_BLEND_FACTOR_CONSTANT_ALPHA, + VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA, + VK_BLEND_FACTOR_SRC_ALPHA_SATURATE, VK_BLEND_FACTOR_SRC1_COLOR, + VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR, VK_BLEND_FACTOR_SRC1_ALPHA, + VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA)) + where +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (Int32) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +-- | type = @enum@ +-- +-- +newtype VkBlendFactor = VkBlendFactor Int32 + deriving (Eq, Ord, Num, Bounded, Storable, Enum, Data, Generic) + +instance Show VkBlendFactor where + showsPrec _ VK_BLEND_FACTOR_ZERO + = showString "VK_BLEND_FACTOR_ZERO" + showsPrec _ VK_BLEND_FACTOR_ONE = showString "VK_BLEND_FACTOR_ONE" + showsPrec _ VK_BLEND_FACTOR_SRC_COLOR + = showString "VK_BLEND_FACTOR_SRC_COLOR" + showsPrec _ VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR + = showString "VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR" + showsPrec _ VK_BLEND_FACTOR_DST_COLOR + = showString "VK_BLEND_FACTOR_DST_COLOR" + showsPrec _ VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR + = showString "VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR" + showsPrec _ VK_BLEND_FACTOR_SRC_ALPHA + = showString "VK_BLEND_FACTOR_SRC_ALPHA" + showsPrec _ VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA + = showString "VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA" + showsPrec _ VK_BLEND_FACTOR_DST_ALPHA + = showString "VK_BLEND_FACTOR_DST_ALPHA" + showsPrec _ VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA + = showString "VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA" + showsPrec _ VK_BLEND_FACTOR_CONSTANT_COLOR + = showString "VK_BLEND_FACTOR_CONSTANT_COLOR" + showsPrec _ VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR + = showString "VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR" + showsPrec _ VK_BLEND_FACTOR_CONSTANT_ALPHA + = showString "VK_BLEND_FACTOR_CONSTANT_ALPHA" + showsPrec _ VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA + = showString "VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA" + showsPrec _ VK_BLEND_FACTOR_SRC_ALPHA_SATURATE + = showString "VK_BLEND_FACTOR_SRC_ALPHA_SATURATE" + showsPrec _ VK_BLEND_FACTOR_SRC1_COLOR + = showString "VK_BLEND_FACTOR_SRC1_COLOR" + showsPrec _ VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR + = showString "VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR" + showsPrec _ VK_BLEND_FACTOR_SRC1_ALPHA + = showString "VK_BLEND_FACTOR_SRC1_ALPHA" + showsPrec _ VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA + = showString "VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA" + showsPrec p (VkBlendFactor x) + = showParen (p >= 11) + (showString "VkBlendFactor " . showsPrec 11 x) + +instance Read VkBlendFactor where + readPrec + = parens + (choose + [("VK_BLEND_FACTOR_ZERO", pure VK_BLEND_FACTOR_ZERO), + ("VK_BLEND_FACTOR_ONE", pure VK_BLEND_FACTOR_ONE), + ("VK_BLEND_FACTOR_SRC_COLOR", pure VK_BLEND_FACTOR_SRC_COLOR), + ("VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR", + pure VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR), + ("VK_BLEND_FACTOR_DST_COLOR", pure VK_BLEND_FACTOR_DST_COLOR), + ("VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR", + pure VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR), + ("VK_BLEND_FACTOR_SRC_ALPHA", pure VK_BLEND_FACTOR_SRC_ALPHA), + ("VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA", + pure VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA), + ("VK_BLEND_FACTOR_DST_ALPHA", pure VK_BLEND_FACTOR_DST_ALPHA), + ("VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA", + pure VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA), + ("VK_BLEND_FACTOR_CONSTANT_COLOR", + pure VK_BLEND_FACTOR_CONSTANT_COLOR), + ("VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR", + pure VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR), + ("VK_BLEND_FACTOR_CONSTANT_ALPHA", + pure VK_BLEND_FACTOR_CONSTANT_ALPHA), + ("VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA", + pure VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA), + ("VK_BLEND_FACTOR_SRC_ALPHA_SATURATE", + pure VK_BLEND_FACTOR_SRC_ALPHA_SATURATE), + ("VK_BLEND_FACTOR_SRC1_COLOR", pure VK_BLEND_FACTOR_SRC1_COLOR), + ("VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR", + pure VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR), + ("VK_BLEND_FACTOR_SRC1_ALPHA", pure VK_BLEND_FACTOR_SRC1_ALPHA), + ("VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA", + pure VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA)] + +++ + prec 10 + (expectP (Ident "VkBlendFactor") >> + (VkBlendFactor <$> step readPrec))) + +pattern VK_BLEND_FACTOR_ZERO :: VkBlendFactor + +pattern VK_BLEND_FACTOR_ZERO = VkBlendFactor 0 + +pattern VK_BLEND_FACTOR_ONE :: VkBlendFactor + +pattern VK_BLEND_FACTOR_ONE = VkBlendFactor 1 + +pattern VK_BLEND_FACTOR_SRC_COLOR :: VkBlendFactor + +pattern VK_BLEND_FACTOR_SRC_COLOR = VkBlendFactor 2 + +pattern VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR :: VkBlendFactor + +pattern VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR = VkBlendFactor 3 + +pattern VK_BLEND_FACTOR_DST_COLOR :: VkBlendFactor + +pattern VK_BLEND_FACTOR_DST_COLOR = VkBlendFactor 4 + +pattern VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR :: VkBlendFactor + +pattern VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR = VkBlendFactor 5 + +pattern VK_BLEND_FACTOR_SRC_ALPHA :: VkBlendFactor + +pattern VK_BLEND_FACTOR_SRC_ALPHA = VkBlendFactor 6 + +pattern VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA :: VkBlendFactor + +pattern VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA = VkBlendFactor 7 + +pattern VK_BLEND_FACTOR_DST_ALPHA :: VkBlendFactor + +pattern VK_BLEND_FACTOR_DST_ALPHA = VkBlendFactor 8 + +pattern VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA :: VkBlendFactor + +pattern VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA = VkBlendFactor 9 + +pattern VK_BLEND_FACTOR_CONSTANT_COLOR :: VkBlendFactor + +pattern VK_BLEND_FACTOR_CONSTANT_COLOR = VkBlendFactor 10 + +pattern VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR :: VkBlendFactor + +pattern VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR = VkBlendFactor 11 + +pattern VK_BLEND_FACTOR_CONSTANT_ALPHA :: VkBlendFactor + +pattern VK_BLEND_FACTOR_CONSTANT_ALPHA = VkBlendFactor 12 + +pattern VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA :: VkBlendFactor + +pattern VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA = VkBlendFactor 13 + +pattern VK_BLEND_FACTOR_SRC_ALPHA_SATURATE :: VkBlendFactor + +pattern VK_BLEND_FACTOR_SRC_ALPHA_SATURATE = VkBlendFactor 14 + +pattern VK_BLEND_FACTOR_SRC1_COLOR :: VkBlendFactor + +pattern VK_BLEND_FACTOR_SRC1_COLOR = VkBlendFactor 15 + +pattern VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR :: VkBlendFactor + +pattern VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR = VkBlendFactor 16 + +pattern VK_BLEND_FACTOR_SRC1_ALPHA :: VkBlendFactor + +pattern VK_BLEND_FACTOR_SRC1_ALPHA = VkBlendFactor 17 + +pattern VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA :: VkBlendFactor + +pattern VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA = VkBlendFactor 18 diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkBlendOp.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkBlendOp.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkBlendOp.hs @@ -0,0 +1,70 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +module Graphics.Vulkan.Types.Enum.VkBlendOp + (VkBlendOp(VkBlendOp, VK_BLEND_OP_ADD, VK_BLEND_OP_SUBTRACT, + VK_BLEND_OP_REVERSE_SUBTRACT, VK_BLEND_OP_MIN, VK_BLEND_OP_MAX)) + where +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (Int32) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +-- | type = @enum@ +-- +-- +newtype VkBlendOp = VkBlendOp Int32 + deriving (Eq, Ord, Num, Bounded, Storable, Enum, Data, Generic) + +instance Show VkBlendOp where + showsPrec _ VK_BLEND_OP_ADD = showString "VK_BLEND_OP_ADD" + showsPrec _ VK_BLEND_OP_SUBTRACT + = showString "VK_BLEND_OP_SUBTRACT" + showsPrec _ VK_BLEND_OP_REVERSE_SUBTRACT + = showString "VK_BLEND_OP_REVERSE_SUBTRACT" + showsPrec _ VK_BLEND_OP_MIN = showString "VK_BLEND_OP_MIN" + showsPrec _ VK_BLEND_OP_MAX = showString "VK_BLEND_OP_MAX" + showsPrec p (VkBlendOp x) + = showParen (p >= 11) (showString "VkBlendOp " . showsPrec 11 x) + +instance Read VkBlendOp where + readPrec + = parens + (choose + [("VK_BLEND_OP_ADD", pure VK_BLEND_OP_ADD), + ("VK_BLEND_OP_SUBTRACT", pure VK_BLEND_OP_SUBTRACT), + ("VK_BLEND_OP_REVERSE_SUBTRACT", + pure VK_BLEND_OP_REVERSE_SUBTRACT), + ("VK_BLEND_OP_MIN", pure VK_BLEND_OP_MIN), + ("VK_BLEND_OP_MAX", pure VK_BLEND_OP_MAX)] + +++ + prec 10 + (expectP (Ident "VkBlendOp") >> (VkBlendOp <$> step readPrec))) + +pattern VK_BLEND_OP_ADD :: VkBlendOp + +pattern VK_BLEND_OP_ADD = VkBlendOp 0 + +pattern VK_BLEND_OP_SUBTRACT :: VkBlendOp + +pattern VK_BLEND_OP_SUBTRACT = VkBlendOp 1 + +pattern VK_BLEND_OP_REVERSE_SUBTRACT :: VkBlendOp + +pattern VK_BLEND_OP_REVERSE_SUBTRACT = VkBlendOp 2 + +pattern VK_BLEND_OP_MIN :: VkBlendOp + +pattern VK_BLEND_OP_MIN = VkBlendOp 3 + +pattern VK_BLEND_OP_MAX :: VkBlendOp + +pattern VK_BLEND_OP_MAX = VkBlendOp 4 diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkBlendOverlapEXT.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkBlendOverlapEXT.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkBlendOverlapEXT.hs @@ -0,0 +1,64 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +module Graphics.Vulkan.Types.Enum.VkBlendOverlapEXT + (VkBlendOverlapEXT(VkBlendOverlapEXT, + VK_BLEND_OVERLAP_UNCORRELATED_EXT, VK_BLEND_OVERLAP_DISJOINT_EXT, + VK_BLEND_OVERLAP_CONJOINT_EXT)) + where +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (Int32) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +-- | type = @enum@ +-- +-- +newtype VkBlendOverlapEXT = VkBlendOverlapEXT Int32 + deriving (Eq, Ord, Num, Bounded, Storable, Enum, Data, Generic) + +instance Show VkBlendOverlapEXT where + showsPrec _ VK_BLEND_OVERLAP_UNCORRELATED_EXT + = showString "VK_BLEND_OVERLAP_UNCORRELATED_EXT" + showsPrec _ VK_BLEND_OVERLAP_DISJOINT_EXT + = showString "VK_BLEND_OVERLAP_DISJOINT_EXT" + showsPrec _ VK_BLEND_OVERLAP_CONJOINT_EXT + = showString "VK_BLEND_OVERLAP_CONJOINT_EXT" + showsPrec p (VkBlendOverlapEXT x) + = showParen (p >= 11) + (showString "VkBlendOverlapEXT " . showsPrec 11 x) + +instance Read VkBlendOverlapEXT where + readPrec + = parens + (choose + [("VK_BLEND_OVERLAP_UNCORRELATED_EXT", + pure VK_BLEND_OVERLAP_UNCORRELATED_EXT), + ("VK_BLEND_OVERLAP_DISJOINT_EXT", + pure VK_BLEND_OVERLAP_DISJOINT_EXT), + ("VK_BLEND_OVERLAP_CONJOINT_EXT", + pure VK_BLEND_OVERLAP_CONJOINT_EXT)] + +++ + prec 10 + (expectP (Ident "VkBlendOverlapEXT") >> + (VkBlendOverlapEXT <$> step readPrec))) + +pattern VK_BLEND_OVERLAP_UNCORRELATED_EXT :: VkBlendOverlapEXT + +pattern VK_BLEND_OVERLAP_UNCORRELATED_EXT = VkBlendOverlapEXT 0 + +pattern VK_BLEND_OVERLAP_DISJOINT_EXT :: VkBlendOverlapEXT + +pattern VK_BLEND_OVERLAP_DISJOINT_EXT = VkBlendOverlapEXT 1 + +pattern VK_BLEND_OVERLAP_CONJOINT_EXT :: VkBlendOverlapEXT + +pattern VK_BLEND_OVERLAP_CONJOINT_EXT = VkBlendOverlapEXT 2 diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkBorderColor.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkBorderColor.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkBorderColor.hs @@ -0,0 +1,92 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +module Graphics.Vulkan.Types.Enum.VkBorderColor + (VkBorderColor(VkBorderColor, + VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK, + VK_BORDER_COLOR_INT_TRANSPARENT_BLACK, + VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK, + VK_BORDER_COLOR_INT_OPAQUE_BLACK, + VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE, + VK_BORDER_COLOR_INT_OPAQUE_WHITE)) + where +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (Int32) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +-- | type = @enum@ +-- +-- +newtype VkBorderColor = VkBorderColor Int32 + deriving (Eq, Ord, Num, Bounded, Storable, Enum, Data, Generic) + +instance Show VkBorderColor where + showsPrec _ VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK + = showString "VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK" + showsPrec _ VK_BORDER_COLOR_INT_TRANSPARENT_BLACK + = showString "VK_BORDER_COLOR_INT_TRANSPARENT_BLACK" + showsPrec _ VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK + = showString "VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK" + showsPrec _ VK_BORDER_COLOR_INT_OPAQUE_BLACK + = showString "VK_BORDER_COLOR_INT_OPAQUE_BLACK" + showsPrec _ VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE + = showString "VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE" + showsPrec _ VK_BORDER_COLOR_INT_OPAQUE_WHITE + = showString "VK_BORDER_COLOR_INT_OPAQUE_WHITE" + showsPrec p (VkBorderColor x) + = showParen (p >= 11) + (showString "VkBorderColor " . showsPrec 11 x) + +instance Read VkBorderColor where + readPrec + = parens + (choose + [("VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK", + pure VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK), + ("VK_BORDER_COLOR_INT_TRANSPARENT_BLACK", + pure VK_BORDER_COLOR_INT_TRANSPARENT_BLACK), + ("VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK", + pure VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK), + ("VK_BORDER_COLOR_INT_OPAQUE_BLACK", + pure VK_BORDER_COLOR_INT_OPAQUE_BLACK), + ("VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE", + pure VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE), + ("VK_BORDER_COLOR_INT_OPAQUE_WHITE", + pure VK_BORDER_COLOR_INT_OPAQUE_WHITE)] + +++ + prec 10 + (expectP (Ident "VkBorderColor") >> + (VkBorderColor <$> step readPrec))) + +pattern VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK :: VkBorderColor + +pattern VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK = VkBorderColor 0 + +pattern VK_BORDER_COLOR_INT_TRANSPARENT_BLACK :: VkBorderColor + +pattern VK_BORDER_COLOR_INT_TRANSPARENT_BLACK = VkBorderColor 1 + +pattern VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK :: VkBorderColor + +pattern VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK = VkBorderColor 2 + +pattern VK_BORDER_COLOR_INT_OPAQUE_BLACK :: VkBorderColor + +pattern VK_BORDER_COLOR_INT_OPAQUE_BLACK = VkBorderColor 3 + +pattern VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE :: VkBorderColor + +pattern VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE = VkBorderColor 4 + +pattern VK_BORDER_COLOR_INT_OPAQUE_WHITE :: VkBorderColor + +pattern VK_BORDER_COLOR_INT_OPAQUE_WHITE = VkBorderColor 5 diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkBufferCreateFlags.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkBufferCreateFlags.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkBufferCreateFlags.hs @@ -0,0 +1,113 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE KindSignatures #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE StandaloneDeriving #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeSynonymInstances #-} +module Graphics.Vulkan.Types.Enum.VkBufferCreateFlags + (VkBufferCreateBitmask(VkBufferCreateBitmask, VkBufferCreateFlags, + VkBufferCreateFlagBits, VK_BUFFER_CREATE_SPARSE_BINDING_BIT, + VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT, + VK_BUFFER_CREATE_SPARSE_ALIASED_BIT), + VkBufferCreateFlags, VkBufferCreateFlagBits) + where +import Data.Bits (Bits, FiniteBits) +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (FlagBit, FlagMask, FlagType) +import Graphics.Vulkan.Types.BaseTypes (VkFlags (..)) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +newtype VkBufferCreateBitmask (a :: + FlagType) = VkBufferCreateBitmask VkFlags + deriving (Eq, Ord, Storable, Data, Generic) + +type VkBufferCreateFlags = VkBufferCreateBitmask FlagMask + +type VkBufferCreateFlagBits = VkBufferCreateBitmask FlagBit + +pattern VkBufferCreateFlagBits :: + VkFlags -> VkBufferCreateBitmask FlagBit + +pattern VkBufferCreateFlagBits n = VkBufferCreateBitmask n + +pattern VkBufferCreateFlags :: + VkFlags -> VkBufferCreateBitmask FlagMask + +pattern VkBufferCreateFlags n = VkBufferCreateBitmask n + +deriving instance Bits (VkBufferCreateBitmask FlagMask) + +deriving instance FiniteBits (VkBufferCreateBitmask FlagMask) + +deriving instance Integral (VkBufferCreateBitmask FlagMask) + +deriving instance Num (VkBufferCreateBitmask FlagMask) + +deriving instance Bounded (VkBufferCreateBitmask FlagMask) + +deriving instance Enum (VkBufferCreateBitmask FlagMask) + +deriving instance Real (VkBufferCreateBitmask FlagMask) + +instance Show (VkBufferCreateBitmask a) where + showsPrec _ VK_BUFFER_CREATE_SPARSE_BINDING_BIT + = showString "VK_BUFFER_CREATE_SPARSE_BINDING_BIT" + showsPrec _ VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT + = showString "VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT" + showsPrec _ VK_BUFFER_CREATE_SPARSE_ALIASED_BIT + = showString "VK_BUFFER_CREATE_SPARSE_ALIASED_BIT" + showsPrec p (VkBufferCreateBitmask x) + = showParen (p >= 11) + (showString "VkBufferCreateBitmask " . showsPrec 11 x) + +instance Read (VkBufferCreateBitmask a) where + readPrec + = parens + (choose + [("VK_BUFFER_CREATE_SPARSE_BINDING_BIT", + pure VK_BUFFER_CREATE_SPARSE_BINDING_BIT), + ("VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT", + pure VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT), + ("VK_BUFFER_CREATE_SPARSE_ALIASED_BIT", + pure VK_BUFFER_CREATE_SPARSE_ALIASED_BIT)] + +++ + prec 10 + (expectP (Ident "VkBufferCreateBitmask") >> + (VkBufferCreateBitmask <$> step readPrec))) + +-- | Buffer should support sparse backing +-- +-- bitpos = @0@ +pattern VK_BUFFER_CREATE_SPARSE_BINDING_BIT :: + VkBufferCreateBitmask a + +pattern VK_BUFFER_CREATE_SPARSE_BINDING_BIT = + VkBufferCreateBitmask 1 + +-- | Buffer should support sparse backing with partial residency +-- +-- bitpos = @1@ +pattern VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT :: + VkBufferCreateBitmask a + +pattern VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT = + VkBufferCreateBitmask 2 + +-- | Buffer should support constent data access to physical memory ranges mapped into multiple locations of sparse buffers +-- +-- bitpos = @2@ +pattern VK_BUFFER_CREATE_SPARSE_ALIASED_BIT :: + VkBufferCreateBitmask a + +pattern VK_BUFFER_CREATE_SPARSE_ALIASED_BIT = + VkBufferCreateBitmask 4 diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkBufferUsageFlags.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkBufferUsageFlags.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkBufferUsageFlags.hs @@ -0,0 +1,190 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE KindSignatures #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE StandaloneDeriving #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeSynonymInstances #-} +module Graphics.Vulkan.Types.Enum.VkBufferUsageFlags + (VkBufferUsageBitmask(VkBufferUsageBitmask, VkBufferUsageFlags, + VkBufferUsageFlagBits, VK_BUFFER_USAGE_TRANSFER_SRC_BIT, + VK_BUFFER_USAGE_TRANSFER_DST_BIT, + VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT, + VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT, + VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, + VK_BUFFER_USAGE_STORAGE_BUFFER_BIT, + VK_BUFFER_USAGE_INDEX_BUFFER_BIT, + VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, + VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT), + VkBufferUsageFlags, VkBufferUsageFlagBits) + where +import Data.Bits (Bits, FiniteBits) +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (FlagBit, FlagMask, FlagType) +import Graphics.Vulkan.Types.BaseTypes (VkFlags (..)) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +newtype VkBufferUsageBitmask (a :: + FlagType) = VkBufferUsageBitmask VkFlags + deriving (Eq, Ord, Storable, Data, Generic) + +type VkBufferUsageFlags = VkBufferUsageBitmask FlagMask + +type VkBufferUsageFlagBits = VkBufferUsageBitmask FlagBit + +pattern VkBufferUsageFlagBits :: + VkFlags -> VkBufferUsageBitmask FlagBit + +pattern VkBufferUsageFlagBits n = VkBufferUsageBitmask n + +pattern VkBufferUsageFlags :: + VkFlags -> VkBufferUsageBitmask FlagMask + +pattern VkBufferUsageFlags n = VkBufferUsageBitmask n + +deriving instance Bits (VkBufferUsageBitmask FlagMask) + +deriving instance FiniteBits (VkBufferUsageBitmask FlagMask) + +deriving instance Integral (VkBufferUsageBitmask FlagMask) + +deriving instance Num (VkBufferUsageBitmask FlagMask) + +deriving instance Bounded (VkBufferUsageBitmask FlagMask) + +deriving instance Enum (VkBufferUsageBitmask FlagMask) + +deriving instance Real (VkBufferUsageBitmask FlagMask) + +instance Show (VkBufferUsageBitmask a) where + showsPrec _ VK_BUFFER_USAGE_TRANSFER_SRC_BIT + = showString "VK_BUFFER_USAGE_TRANSFER_SRC_BIT" + showsPrec _ VK_BUFFER_USAGE_TRANSFER_DST_BIT + = showString "VK_BUFFER_USAGE_TRANSFER_DST_BIT" + showsPrec _ VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT + = showString "VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT" + showsPrec _ VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT + = showString "VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT" + showsPrec _ VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT + = showString "VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT" + showsPrec _ VK_BUFFER_USAGE_STORAGE_BUFFER_BIT + = showString "VK_BUFFER_USAGE_STORAGE_BUFFER_BIT" + showsPrec _ VK_BUFFER_USAGE_INDEX_BUFFER_BIT + = showString "VK_BUFFER_USAGE_INDEX_BUFFER_BIT" + showsPrec _ VK_BUFFER_USAGE_VERTEX_BUFFER_BIT + = showString "VK_BUFFER_USAGE_VERTEX_BUFFER_BIT" + showsPrec _ VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT + = showString "VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT" + showsPrec p (VkBufferUsageBitmask x) + = showParen (p >= 11) + (showString "VkBufferUsageBitmask " . showsPrec 11 x) + +instance Read (VkBufferUsageBitmask a) where + readPrec + = parens + (choose + [("VK_BUFFER_USAGE_TRANSFER_SRC_BIT", + pure VK_BUFFER_USAGE_TRANSFER_SRC_BIT), + ("VK_BUFFER_USAGE_TRANSFER_DST_BIT", + pure VK_BUFFER_USAGE_TRANSFER_DST_BIT), + ("VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT", + pure VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT), + ("VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT", + pure VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT), + ("VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT", + pure VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT), + ("VK_BUFFER_USAGE_STORAGE_BUFFER_BIT", + pure VK_BUFFER_USAGE_STORAGE_BUFFER_BIT), + ("VK_BUFFER_USAGE_INDEX_BUFFER_BIT", + pure VK_BUFFER_USAGE_INDEX_BUFFER_BIT), + ("VK_BUFFER_USAGE_VERTEX_BUFFER_BIT", + pure VK_BUFFER_USAGE_VERTEX_BUFFER_BIT), + ("VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT", + pure VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT)] + +++ + prec 10 + (expectP (Ident "VkBufferUsageBitmask") >> + (VkBufferUsageBitmask <$> step readPrec))) + +-- | Can be used as a source of transfer operations +-- +-- bitpos = @0@ +pattern VK_BUFFER_USAGE_TRANSFER_SRC_BIT :: VkBufferUsageBitmask a + +pattern VK_BUFFER_USAGE_TRANSFER_SRC_BIT = VkBufferUsageBitmask 1 + +-- | Can be used as a destination of transfer operations +-- +-- bitpos = @1@ +pattern VK_BUFFER_USAGE_TRANSFER_DST_BIT :: VkBufferUsageBitmask a + +pattern VK_BUFFER_USAGE_TRANSFER_DST_BIT = VkBufferUsageBitmask 2 + +-- | Can be used as TBO +-- +-- bitpos = @2@ +pattern VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT :: + VkBufferUsageBitmask a + +pattern VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT = + VkBufferUsageBitmask 4 + +-- | Can be used as IBO +-- +-- bitpos = @3@ +pattern VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT :: + VkBufferUsageBitmask a + +pattern VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT = + VkBufferUsageBitmask 8 + +-- | Can be used as UBO +-- +-- bitpos = @4@ +pattern VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT :: + VkBufferUsageBitmask a + +pattern VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT = + VkBufferUsageBitmask 16 + +-- | Can be used as SSBO +-- +-- bitpos = @5@ +pattern VK_BUFFER_USAGE_STORAGE_BUFFER_BIT :: + VkBufferUsageBitmask a + +pattern VK_BUFFER_USAGE_STORAGE_BUFFER_BIT = + VkBufferUsageBitmask 32 + +-- | Can be used as source of fixed-function index fetch (index buffer) +-- +-- bitpos = @6@ +pattern VK_BUFFER_USAGE_INDEX_BUFFER_BIT :: VkBufferUsageBitmask a + +pattern VK_BUFFER_USAGE_INDEX_BUFFER_BIT = VkBufferUsageBitmask 64 + +-- | Can be used as source of fixed-function vertex fetch (VBO) +-- +-- bitpos = @7@ +pattern VK_BUFFER_USAGE_VERTEX_BUFFER_BIT :: VkBufferUsageBitmask a + +pattern VK_BUFFER_USAGE_VERTEX_BUFFER_BIT = + VkBufferUsageBitmask 128 + +-- | Can be the source of indirect parameters (e.g. indirect buffer, parameter buffer) +-- +-- bitpos = @8@ +pattern VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT :: + VkBufferUsageBitmask a + +pattern VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT = + VkBufferUsageBitmask 256 diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkBufferViewCreateFlagBits.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkBufferViewCreateFlagBits.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkBufferViewCreateFlagBits.hs @@ -0,0 +1,25 @@ +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE Strict #-} +module Graphics.Vulkan.Types.Enum.VkBufferViewCreateFlagBits + (VkBufferViewCreateFlagBits(..)) where +import Data.Bits (Bits, FiniteBits) +import Data.Coerce (coerce) +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import Graphics.Vulkan.Types.BaseTypes (VkFlags) + +newtype VkBufferViewCreateFlagBits = VkBufferViewCreateFlagBits VkFlags + deriving (Eq, Ord, Num, Bounded, Enum, Integral, Bits, + FiniteBits, Storable, Real, Data, Generic) + +instance Show VkBufferViewCreateFlagBits where + {-# INLINE show #-} + show (VkBufferViewCreateFlagBits x) = show x + +instance Read VkBufferViewCreateFlagBits where + {-# INLINE readsPrec #-} + readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags) diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkChromaLocationKHR.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkChromaLocationKHR.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkChromaLocationKHR.hs @@ -0,0 +1,56 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +module Graphics.Vulkan.Types.Enum.VkChromaLocationKHR + (VkChromaLocationKHR(VkChromaLocationKHR, + VK_CHROMA_LOCATION_COSITED_EVEN_KHR, + VK_CHROMA_LOCATION_MIDPOINT_KHR)) + where +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (Int32) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +-- | type = @enum@ +-- +-- +newtype VkChromaLocationKHR = VkChromaLocationKHR Int32 + deriving (Eq, Ord, Num, Bounded, Storable, Enum, Data, Generic) + +instance Show VkChromaLocationKHR where + showsPrec _ VK_CHROMA_LOCATION_COSITED_EVEN_KHR + = showString "VK_CHROMA_LOCATION_COSITED_EVEN_KHR" + showsPrec _ VK_CHROMA_LOCATION_MIDPOINT_KHR + = showString "VK_CHROMA_LOCATION_MIDPOINT_KHR" + showsPrec p (VkChromaLocationKHR x) + = showParen (p >= 11) + (showString "VkChromaLocationKHR " . showsPrec 11 x) + +instance Read VkChromaLocationKHR where + readPrec + = parens + (choose + [("VK_CHROMA_LOCATION_COSITED_EVEN_KHR", + pure VK_CHROMA_LOCATION_COSITED_EVEN_KHR), + ("VK_CHROMA_LOCATION_MIDPOINT_KHR", + pure VK_CHROMA_LOCATION_MIDPOINT_KHR)] + +++ + prec 10 + (expectP (Ident "VkChromaLocationKHR") >> + (VkChromaLocationKHR <$> step readPrec))) + +pattern VK_CHROMA_LOCATION_COSITED_EVEN_KHR :: VkChromaLocationKHR + +pattern VK_CHROMA_LOCATION_COSITED_EVEN_KHR = VkChromaLocationKHR 0 + +pattern VK_CHROMA_LOCATION_MIDPOINT_KHR :: VkChromaLocationKHR + +pattern VK_CHROMA_LOCATION_MIDPOINT_KHR = VkChromaLocationKHR 1 diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkColorComponentFlags.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkColorComponentFlags.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkColorComponentFlags.hs @@ -0,0 +1,106 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE KindSignatures #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE StandaloneDeriving #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeSynonymInstances #-} +module Graphics.Vulkan.Types.Enum.VkColorComponentFlags + (VkColorComponentBitmask(VkColorComponentBitmask, + VkColorComponentFlags, VkColorComponentFlagBits, + VK_COLOR_COMPONENT_R_BIT, VK_COLOR_COMPONENT_G_BIT, + VK_COLOR_COMPONENT_B_BIT, VK_COLOR_COMPONENT_A_BIT), + VkColorComponentFlags, VkColorComponentFlagBits) + where +import Data.Bits (Bits, FiniteBits) +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (FlagBit, FlagMask, FlagType) +import Graphics.Vulkan.Types.BaseTypes (VkFlags (..)) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +newtype VkColorComponentBitmask (a :: + FlagType) = VkColorComponentBitmask VkFlags + deriving (Eq, Ord, Storable, Data, Generic) + +type VkColorComponentFlags = VkColorComponentBitmask FlagMask + +type VkColorComponentFlagBits = VkColorComponentBitmask FlagBit + +pattern VkColorComponentFlagBits :: + VkFlags -> VkColorComponentBitmask FlagBit + +pattern VkColorComponentFlagBits n = VkColorComponentBitmask n + +pattern VkColorComponentFlags :: + VkFlags -> VkColorComponentBitmask FlagMask + +pattern VkColorComponentFlags n = VkColorComponentBitmask n + +deriving instance Bits (VkColorComponentBitmask FlagMask) + +deriving instance FiniteBits (VkColorComponentBitmask FlagMask) + +deriving instance Integral (VkColorComponentBitmask FlagMask) + +deriving instance Num (VkColorComponentBitmask FlagMask) + +deriving instance Bounded (VkColorComponentBitmask FlagMask) + +deriving instance Enum (VkColorComponentBitmask FlagMask) + +deriving instance Real (VkColorComponentBitmask FlagMask) + +instance Show (VkColorComponentBitmask a) where + showsPrec _ VK_COLOR_COMPONENT_R_BIT + = showString "VK_COLOR_COMPONENT_R_BIT" + showsPrec _ VK_COLOR_COMPONENT_G_BIT + = showString "VK_COLOR_COMPONENT_G_BIT" + showsPrec _ VK_COLOR_COMPONENT_B_BIT + = showString "VK_COLOR_COMPONENT_B_BIT" + showsPrec _ VK_COLOR_COMPONENT_A_BIT + = showString "VK_COLOR_COMPONENT_A_BIT" + showsPrec p (VkColorComponentBitmask x) + = showParen (p >= 11) + (showString "VkColorComponentBitmask " . showsPrec 11 x) + +instance Read (VkColorComponentBitmask a) where + readPrec + = parens + (choose + [("VK_COLOR_COMPONENT_R_BIT", pure VK_COLOR_COMPONENT_R_BIT), + ("VK_COLOR_COMPONENT_G_BIT", pure VK_COLOR_COMPONENT_G_BIT), + ("VK_COLOR_COMPONENT_B_BIT", pure VK_COLOR_COMPONENT_B_BIT), + ("VK_COLOR_COMPONENT_A_BIT", pure VK_COLOR_COMPONENT_A_BIT)] + +++ + prec 10 + (expectP (Ident "VkColorComponentBitmask") >> + (VkColorComponentBitmask <$> step readPrec))) + +-- | bitpos = @0@ +pattern VK_COLOR_COMPONENT_R_BIT :: VkColorComponentBitmask a + +pattern VK_COLOR_COMPONENT_R_BIT = VkColorComponentBitmask 1 + +-- | bitpos = @1@ +pattern VK_COLOR_COMPONENT_G_BIT :: VkColorComponentBitmask a + +pattern VK_COLOR_COMPONENT_G_BIT = VkColorComponentBitmask 2 + +-- | bitpos = @2@ +pattern VK_COLOR_COMPONENT_B_BIT :: VkColorComponentBitmask a + +pattern VK_COLOR_COMPONENT_B_BIT = VkColorComponentBitmask 4 + +-- | bitpos = @3@ +pattern VK_COLOR_COMPONENT_A_BIT :: VkColorComponentBitmask a + +pattern VK_COLOR_COMPONENT_A_BIT = VkColorComponentBitmask 8 diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkColorSpaceKHR.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkColorSpaceKHR.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkColorSpaceKHR.hs @@ -0,0 +1,47 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +module Graphics.Vulkan.Types.Enum.VkColorSpaceKHR + (VkColorSpaceKHR(VkColorSpaceKHR, + VK_COLOR_SPACE_SRGB_NONLINEAR_KHR)) + where +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (Int32) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +-- | type = @enum@ +-- +-- +newtype VkColorSpaceKHR = VkColorSpaceKHR Int32 + deriving (Eq, Ord, Num, Bounded, Storable, Enum, Data, Generic) + +instance Show VkColorSpaceKHR where + showsPrec _ VK_COLOR_SPACE_SRGB_NONLINEAR_KHR + = showString "VK_COLOR_SPACE_SRGB_NONLINEAR_KHR" + showsPrec p (VkColorSpaceKHR x) + = showParen (p >= 11) + (showString "VkColorSpaceKHR " . showsPrec 11 x) + +instance Read VkColorSpaceKHR where + readPrec + = parens + (choose + [("VK_COLOR_SPACE_SRGB_NONLINEAR_KHR", + pure VK_COLOR_SPACE_SRGB_NONLINEAR_KHR)] + +++ + prec 10 + (expectP (Ident "VkColorSpaceKHR") >> + (VkColorSpaceKHR <$> step readPrec))) + +pattern VK_COLOR_SPACE_SRGB_NONLINEAR_KHR :: VkColorSpaceKHR + +pattern VK_COLOR_SPACE_SRGB_NONLINEAR_KHR = VkColorSpaceKHR 0 diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkCommandBufferLevel.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkCommandBufferLevel.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkCommandBufferLevel.hs @@ -0,0 +1,56 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +module Graphics.Vulkan.Types.Enum.VkCommandBufferLevel + (VkCommandBufferLevel(VkCommandBufferLevel, + VK_COMMAND_BUFFER_LEVEL_PRIMARY, + VK_COMMAND_BUFFER_LEVEL_SECONDARY)) + where +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (Int32) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +-- | type = @enum@ +-- +-- +newtype VkCommandBufferLevel = VkCommandBufferLevel Int32 + deriving (Eq, Ord, Num, Bounded, Storable, Enum, Data, Generic) + +instance Show VkCommandBufferLevel where + showsPrec _ VK_COMMAND_BUFFER_LEVEL_PRIMARY + = showString "VK_COMMAND_BUFFER_LEVEL_PRIMARY" + showsPrec _ VK_COMMAND_BUFFER_LEVEL_SECONDARY + = showString "VK_COMMAND_BUFFER_LEVEL_SECONDARY" + showsPrec p (VkCommandBufferLevel x) + = showParen (p >= 11) + (showString "VkCommandBufferLevel " . showsPrec 11 x) + +instance Read VkCommandBufferLevel where + readPrec + = parens + (choose + [("VK_COMMAND_BUFFER_LEVEL_PRIMARY", + pure VK_COMMAND_BUFFER_LEVEL_PRIMARY), + ("VK_COMMAND_BUFFER_LEVEL_SECONDARY", + pure VK_COMMAND_BUFFER_LEVEL_SECONDARY)] + +++ + prec 10 + (expectP (Ident "VkCommandBufferLevel") >> + (VkCommandBufferLevel <$> step readPrec))) + +pattern VK_COMMAND_BUFFER_LEVEL_PRIMARY :: VkCommandBufferLevel + +pattern VK_COMMAND_BUFFER_LEVEL_PRIMARY = VkCommandBufferLevel 0 + +pattern VK_COMMAND_BUFFER_LEVEL_SECONDARY :: VkCommandBufferLevel + +pattern VK_COMMAND_BUFFER_LEVEL_SECONDARY = VkCommandBufferLevel 1 diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkCommandBufferResetFlags.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkCommandBufferResetFlags.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkCommandBufferResetFlags.hs @@ -0,0 +1,89 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE KindSignatures #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE StandaloneDeriving #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeSynonymInstances #-} +module Graphics.Vulkan.Types.Enum.VkCommandBufferResetFlags + (VkCommandBufferResetBitmask(VkCommandBufferResetBitmask, + VkCommandBufferResetFlags, VkCommandBufferResetFlagBits, + VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT), + VkCommandBufferResetFlags, VkCommandBufferResetFlagBits) + where +import Data.Bits (Bits, FiniteBits) +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (FlagBit, FlagMask, FlagType) +import Graphics.Vulkan.Types.BaseTypes (VkFlags (..)) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +newtype VkCommandBufferResetBitmask (a :: + FlagType) = VkCommandBufferResetBitmask VkFlags + deriving (Eq, Ord, Storable, Data, Generic) + +type VkCommandBufferResetFlags = + VkCommandBufferResetBitmask FlagMask + +type VkCommandBufferResetFlagBits = + VkCommandBufferResetBitmask FlagBit + +pattern VkCommandBufferResetFlagBits :: + VkFlags -> VkCommandBufferResetBitmask FlagBit + +pattern VkCommandBufferResetFlagBits n = + VkCommandBufferResetBitmask n + +pattern VkCommandBufferResetFlags :: + VkFlags -> VkCommandBufferResetBitmask FlagMask + +pattern VkCommandBufferResetFlags n = VkCommandBufferResetBitmask n + +deriving instance Bits (VkCommandBufferResetBitmask FlagMask) + +deriving instance FiniteBits (VkCommandBufferResetBitmask FlagMask) + +deriving instance Integral (VkCommandBufferResetBitmask FlagMask) + +deriving instance Num (VkCommandBufferResetBitmask FlagMask) + +deriving instance Bounded (VkCommandBufferResetBitmask FlagMask) + +deriving instance Enum (VkCommandBufferResetBitmask FlagMask) + +deriving instance Real (VkCommandBufferResetBitmask FlagMask) + +instance Show (VkCommandBufferResetBitmask a) where + showsPrec _ VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT + = showString "VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT" + showsPrec p (VkCommandBufferResetBitmask x) + = showParen (p >= 11) + (showString "VkCommandBufferResetBitmask " . showsPrec 11 x) + +instance Read (VkCommandBufferResetBitmask a) where + readPrec + = parens + (choose + [("VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT", + pure VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT)] + +++ + prec 10 + (expectP (Ident "VkCommandBufferResetBitmask") >> + (VkCommandBufferResetBitmask <$> step readPrec))) + +-- | Release resources owned by the buffer +-- +-- bitpos = @0@ +pattern VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT :: + VkCommandBufferResetBitmask a + +pattern VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT = + VkCommandBufferResetBitmask 1 diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkCommandBufferUsageFlags.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkCommandBufferUsageFlags.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkCommandBufferUsageFlags.hs @@ -0,0 +1,113 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE KindSignatures #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE StandaloneDeriving #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeSynonymInstances #-} +module Graphics.Vulkan.Types.Enum.VkCommandBufferUsageFlags + (VkCommandBufferUsageBitmask(VkCommandBufferUsageBitmask, + VkCommandBufferUsageFlags, VkCommandBufferUsageFlagBits, + VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, + VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT, + VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT), + VkCommandBufferUsageFlags, VkCommandBufferUsageFlagBits) + where +import Data.Bits (Bits, FiniteBits) +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (FlagBit, FlagMask, FlagType) +import Graphics.Vulkan.Types.BaseTypes (VkFlags (..)) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +newtype VkCommandBufferUsageBitmask (a :: + FlagType) = VkCommandBufferUsageBitmask VkFlags + deriving (Eq, Ord, Storable, Data, Generic) + +type VkCommandBufferUsageFlags = + VkCommandBufferUsageBitmask FlagMask + +type VkCommandBufferUsageFlagBits = + VkCommandBufferUsageBitmask FlagBit + +pattern VkCommandBufferUsageFlagBits :: + VkFlags -> VkCommandBufferUsageBitmask FlagBit + +pattern VkCommandBufferUsageFlagBits n = + VkCommandBufferUsageBitmask n + +pattern VkCommandBufferUsageFlags :: + VkFlags -> VkCommandBufferUsageBitmask FlagMask + +pattern VkCommandBufferUsageFlags n = VkCommandBufferUsageBitmask n + +deriving instance Bits (VkCommandBufferUsageBitmask FlagMask) + +deriving instance FiniteBits (VkCommandBufferUsageBitmask FlagMask) + +deriving instance Integral (VkCommandBufferUsageBitmask FlagMask) + +deriving instance Num (VkCommandBufferUsageBitmask FlagMask) + +deriving instance Bounded (VkCommandBufferUsageBitmask FlagMask) + +deriving instance Enum (VkCommandBufferUsageBitmask FlagMask) + +deriving instance Real (VkCommandBufferUsageBitmask FlagMask) + +instance Show (VkCommandBufferUsageBitmask a) where + showsPrec _ VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT + = showString "VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT" + showsPrec _ VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT + = showString "VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT" + showsPrec _ VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT + = showString "VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT" + showsPrec p (VkCommandBufferUsageBitmask x) + = showParen (p >= 11) + (showString "VkCommandBufferUsageBitmask " . showsPrec 11 x) + +instance Read (VkCommandBufferUsageBitmask a) where + readPrec + = parens + (choose + [("VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT", + pure VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT), + ("VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT", + pure VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT), + ("VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT", + pure VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT)] + +++ + prec 10 + (expectP (Ident "VkCommandBufferUsageBitmask") >> + (VkCommandBufferUsageBitmask <$> step readPrec))) + +-- | bitpos = @0@ +pattern VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT :: + VkCommandBufferUsageBitmask a + +pattern VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT = + VkCommandBufferUsageBitmask 1 + +-- | bitpos = @1@ +pattern VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT :: + VkCommandBufferUsageBitmask a + +pattern VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT = + VkCommandBufferUsageBitmask 2 + +-- | Command buffer may be submitted/executed more than once simultaneously +-- +-- bitpos = @2@ +pattern VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT :: + VkCommandBufferUsageBitmask a + +pattern VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT = + VkCommandBufferUsageBitmask 4 diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkCommandPoolCreateFlags.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkCommandPoolCreateFlags.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkCommandPoolCreateFlags.hs @@ -0,0 +1,102 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE KindSignatures #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE StandaloneDeriving #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeSynonymInstances #-} +module Graphics.Vulkan.Types.Enum.VkCommandPoolCreateFlags + (VkCommandPoolCreateBitmask(VkCommandPoolCreateBitmask, + VkCommandPoolCreateFlags, VkCommandPoolCreateFlagBits, + VK_COMMAND_POOL_CREATE_TRANSIENT_BIT, + VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT), + VkCommandPoolCreateFlags, VkCommandPoolCreateFlagBits) + where +import Data.Bits (Bits, FiniteBits) +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (FlagBit, FlagMask, FlagType) +import Graphics.Vulkan.Types.BaseTypes (VkFlags (..)) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +newtype VkCommandPoolCreateBitmask (a :: + FlagType) = VkCommandPoolCreateBitmask VkFlags + deriving (Eq, Ord, Storable, Data, Generic) + +type VkCommandPoolCreateFlags = VkCommandPoolCreateBitmask FlagMask + +type VkCommandPoolCreateFlagBits = + VkCommandPoolCreateBitmask FlagBit + +pattern VkCommandPoolCreateFlagBits :: + VkFlags -> VkCommandPoolCreateBitmask FlagBit + +pattern VkCommandPoolCreateFlagBits n = + VkCommandPoolCreateBitmask n + +pattern VkCommandPoolCreateFlags :: + VkFlags -> VkCommandPoolCreateBitmask FlagMask + +pattern VkCommandPoolCreateFlags n = VkCommandPoolCreateBitmask n + +deriving instance Bits (VkCommandPoolCreateBitmask FlagMask) + +deriving instance FiniteBits (VkCommandPoolCreateBitmask FlagMask) + +deriving instance Integral (VkCommandPoolCreateBitmask FlagMask) + +deriving instance Num (VkCommandPoolCreateBitmask FlagMask) + +deriving instance Bounded (VkCommandPoolCreateBitmask FlagMask) + +deriving instance Enum (VkCommandPoolCreateBitmask FlagMask) + +deriving instance Real (VkCommandPoolCreateBitmask FlagMask) + +instance Show (VkCommandPoolCreateBitmask a) where + showsPrec _ VK_COMMAND_POOL_CREATE_TRANSIENT_BIT + = showString "VK_COMMAND_POOL_CREATE_TRANSIENT_BIT" + showsPrec _ VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT + = showString "VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT" + showsPrec p (VkCommandPoolCreateBitmask x) + = showParen (p >= 11) + (showString "VkCommandPoolCreateBitmask " . showsPrec 11 x) + +instance Read (VkCommandPoolCreateBitmask a) where + readPrec + = parens + (choose + [("VK_COMMAND_POOL_CREATE_TRANSIENT_BIT", + pure VK_COMMAND_POOL_CREATE_TRANSIENT_BIT), + ("VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT", + pure VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT)] + +++ + prec 10 + (expectP (Ident "VkCommandPoolCreateBitmask") >> + (VkCommandPoolCreateBitmask <$> step readPrec))) + +-- | Command buffers have a short lifetime +-- +-- bitpos = @0@ +pattern VK_COMMAND_POOL_CREATE_TRANSIENT_BIT :: + VkCommandPoolCreateBitmask a + +pattern VK_COMMAND_POOL_CREATE_TRANSIENT_BIT = + VkCommandPoolCreateBitmask 1 + +-- | Command buffers may release their memory individually +-- +-- bitpos = @1@ +pattern VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT :: + VkCommandPoolCreateBitmask a + +pattern VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT = + VkCommandPoolCreateBitmask 2 diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkCommandPoolResetFlags.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkCommandPoolResetFlags.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkCommandPoolResetFlags.hs @@ -0,0 +1,86 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE KindSignatures #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE StandaloneDeriving #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeSynonymInstances #-} +module Graphics.Vulkan.Types.Enum.VkCommandPoolResetFlags + (VkCommandPoolResetBitmask(VkCommandPoolResetBitmask, + VkCommandPoolResetFlags, VkCommandPoolResetFlagBits, + VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT), + VkCommandPoolResetFlags, VkCommandPoolResetFlagBits) + where +import Data.Bits (Bits, FiniteBits) +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (FlagBit, FlagMask, FlagType) +import Graphics.Vulkan.Types.BaseTypes (VkFlags (..)) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +newtype VkCommandPoolResetBitmask (a :: + FlagType) = VkCommandPoolResetBitmask VkFlags + deriving (Eq, Ord, Storable, Data, Generic) + +type VkCommandPoolResetFlags = VkCommandPoolResetBitmask FlagMask + +type VkCommandPoolResetFlagBits = VkCommandPoolResetBitmask FlagBit + +pattern VkCommandPoolResetFlagBits :: + VkFlags -> VkCommandPoolResetBitmask FlagBit + +pattern VkCommandPoolResetFlagBits n = VkCommandPoolResetBitmask n + +pattern VkCommandPoolResetFlags :: + VkFlags -> VkCommandPoolResetBitmask FlagMask + +pattern VkCommandPoolResetFlags n = VkCommandPoolResetBitmask n + +deriving instance Bits (VkCommandPoolResetBitmask FlagMask) + +deriving instance FiniteBits (VkCommandPoolResetBitmask FlagMask) + +deriving instance Integral (VkCommandPoolResetBitmask FlagMask) + +deriving instance Num (VkCommandPoolResetBitmask FlagMask) + +deriving instance Bounded (VkCommandPoolResetBitmask FlagMask) + +deriving instance Enum (VkCommandPoolResetBitmask FlagMask) + +deriving instance Real (VkCommandPoolResetBitmask FlagMask) + +instance Show (VkCommandPoolResetBitmask a) where + showsPrec _ VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT + = showString "VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT" + showsPrec p (VkCommandPoolResetBitmask x) + = showParen (p >= 11) + (showString "VkCommandPoolResetBitmask " . showsPrec 11 x) + +instance Read (VkCommandPoolResetBitmask a) where + readPrec + = parens + (choose + [("VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT", + pure VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT)] + +++ + prec 10 + (expectP (Ident "VkCommandPoolResetBitmask") >> + (VkCommandPoolResetBitmask <$> step readPrec))) + +-- | Release resources owned by the pool +-- +-- bitpos = @0@ +pattern VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT :: + VkCommandPoolResetBitmask a + +pattern VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT = + VkCommandPoolResetBitmask 1 diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkCompareOp.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkCompareOp.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkCompareOp.hs @@ -0,0 +1,93 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +module Graphics.Vulkan.Types.Enum.VkCompareOp + (VkCompareOp(VkCompareOp, VK_COMPARE_OP_NEVER, VK_COMPARE_OP_LESS, + VK_COMPARE_OP_EQUAL, VK_COMPARE_OP_LESS_OR_EQUAL, + VK_COMPARE_OP_GREATER, VK_COMPARE_OP_NOT_EQUAL, + VK_COMPARE_OP_GREATER_OR_EQUAL, VK_COMPARE_OP_ALWAYS)) + where +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (Int32) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +-- | type = @enum@ +-- +-- +newtype VkCompareOp = VkCompareOp Int32 + deriving (Eq, Ord, Num, Bounded, Storable, Enum, Data, Generic) + +instance Show VkCompareOp where + showsPrec _ VK_COMPARE_OP_NEVER = showString "VK_COMPARE_OP_NEVER" + showsPrec _ VK_COMPARE_OP_LESS = showString "VK_COMPARE_OP_LESS" + showsPrec _ VK_COMPARE_OP_EQUAL = showString "VK_COMPARE_OP_EQUAL" + showsPrec _ VK_COMPARE_OP_LESS_OR_EQUAL + = showString "VK_COMPARE_OP_LESS_OR_EQUAL" + showsPrec _ VK_COMPARE_OP_GREATER + = showString "VK_COMPARE_OP_GREATER" + showsPrec _ VK_COMPARE_OP_NOT_EQUAL + = showString "VK_COMPARE_OP_NOT_EQUAL" + showsPrec _ VK_COMPARE_OP_GREATER_OR_EQUAL + = showString "VK_COMPARE_OP_GREATER_OR_EQUAL" + showsPrec _ VK_COMPARE_OP_ALWAYS + = showString "VK_COMPARE_OP_ALWAYS" + showsPrec p (VkCompareOp x) + = showParen (p >= 11) (showString "VkCompareOp " . showsPrec 11 x) + +instance Read VkCompareOp where + readPrec + = parens + (choose + [("VK_COMPARE_OP_NEVER", pure VK_COMPARE_OP_NEVER), + ("VK_COMPARE_OP_LESS", pure VK_COMPARE_OP_LESS), + ("VK_COMPARE_OP_EQUAL", pure VK_COMPARE_OP_EQUAL), + ("VK_COMPARE_OP_LESS_OR_EQUAL", pure VK_COMPARE_OP_LESS_OR_EQUAL), + ("VK_COMPARE_OP_GREATER", pure VK_COMPARE_OP_GREATER), + ("VK_COMPARE_OP_NOT_EQUAL", pure VK_COMPARE_OP_NOT_EQUAL), + ("VK_COMPARE_OP_GREATER_OR_EQUAL", + pure VK_COMPARE_OP_GREATER_OR_EQUAL), + ("VK_COMPARE_OP_ALWAYS", pure VK_COMPARE_OP_ALWAYS)] + +++ + prec 10 + (expectP (Ident "VkCompareOp") >> (VkCompareOp <$> step readPrec))) + +pattern VK_COMPARE_OP_NEVER :: VkCompareOp + +pattern VK_COMPARE_OP_NEVER = VkCompareOp 0 + +pattern VK_COMPARE_OP_LESS :: VkCompareOp + +pattern VK_COMPARE_OP_LESS = VkCompareOp 1 + +pattern VK_COMPARE_OP_EQUAL :: VkCompareOp + +pattern VK_COMPARE_OP_EQUAL = VkCompareOp 2 + +pattern VK_COMPARE_OP_LESS_OR_EQUAL :: VkCompareOp + +pattern VK_COMPARE_OP_LESS_OR_EQUAL = VkCompareOp 3 + +pattern VK_COMPARE_OP_GREATER :: VkCompareOp + +pattern VK_COMPARE_OP_GREATER = VkCompareOp 4 + +pattern VK_COMPARE_OP_NOT_EQUAL :: VkCompareOp + +pattern VK_COMPARE_OP_NOT_EQUAL = VkCompareOp 5 + +pattern VK_COMPARE_OP_GREATER_OR_EQUAL :: VkCompareOp + +pattern VK_COMPARE_OP_GREATER_OR_EQUAL = VkCompareOp 6 + +pattern VK_COMPARE_OP_ALWAYS :: VkCompareOp + +pattern VK_COMPARE_OP_ALWAYS = VkCompareOp 7 diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkComponentSwizzle.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkComponentSwizzle.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkComponentSwizzle.hs @@ -0,0 +1,92 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +module Graphics.Vulkan.Types.Enum.VkComponentSwizzle + (VkComponentSwizzle(VkComponentSwizzle, + VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_ZERO, + VK_COMPONENT_SWIZZLE_ONE, VK_COMPONENT_SWIZZLE_R, + VK_COMPONENT_SWIZZLE_G, VK_COMPONENT_SWIZZLE_B, + VK_COMPONENT_SWIZZLE_A)) + where +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (Int32) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +-- | type = @enum@ +-- +-- +newtype VkComponentSwizzle = VkComponentSwizzle Int32 + deriving (Eq, Ord, Num, Bounded, Storable, Enum, Data, Generic) + +instance Show VkComponentSwizzle where + showsPrec _ VK_COMPONENT_SWIZZLE_IDENTITY + = showString "VK_COMPONENT_SWIZZLE_IDENTITY" + showsPrec _ VK_COMPONENT_SWIZZLE_ZERO + = showString "VK_COMPONENT_SWIZZLE_ZERO" + showsPrec _ VK_COMPONENT_SWIZZLE_ONE + = showString "VK_COMPONENT_SWIZZLE_ONE" + showsPrec _ VK_COMPONENT_SWIZZLE_R + = showString "VK_COMPONENT_SWIZZLE_R" + showsPrec _ VK_COMPONENT_SWIZZLE_G + = showString "VK_COMPONENT_SWIZZLE_G" + showsPrec _ VK_COMPONENT_SWIZZLE_B + = showString "VK_COMPONENT_SWIZZLE_B" + showsPrec _ VK_COMPONENT_SWIZZLE_A + = showString "VK_COMPONENT_SWIZZLE_A" + showsPrec p (VkComponentSwizzle x) + = showParen (p >= 11) + (showString "VkComponentSwizzle " . showsPrec 11 x) + +instance Read VkComponentSwizzle where + readPrec + = parens + (choose + [("VK_COMPONENT_SWIZZLE_IDENTITY", + pure VK_COMPONENT_SWIZZLE_IDENTITY), + ("VK_COMPONENT_SWIZZLE_ZERO", pure VK_COMPONENT_SWIZZLE_ZERO), + ("VK_COMPONENT_SWIZZLE_ONE", pure VK_COMPONENT_SWIZZLE_ONE), + ("VK_COMPONENT_SWIZZLE_R", pure VK_COMPONENT_SWIZZLE_R), + ("VK_COMPONENT_SWIZZLE_G", pure VK_COMPONENT_SWIZZLE_G), + ("VK_COMPONENT_SWIZZLE_B", pure VK_COMPONENT_SWIZZLE_B), + ("VK_COMPONENT_SWIZZLE_A", pure VK_COMPONENT_SWIZZLE_A)] + +++ + prec 10 + (expectP (Ident "VkComponentSwizzle") >> + (VkComponentSwizzle <$> step readPrec))) + +pattern VK_COMPONENT_SWIZZLE_IDENTITY :: VkComponentSwizzle + +pattern VK_COMPONENT_SWIZZLE_IDENTITY = VkComponentSwizzle 0 + +pattern VK_COMPONENT_SWIZZLE_ZERO :: VkComponentSwizzle + +pattern VK_COMPONENT_SWIZZLE_ZERO = VkComponentSwizzle 1 + +pattern VK_COMPONENT_SWIZZLE_ONE :: VkComponentSwizzle + +pattern VK_COMPONENT_SWIZZLE_ONE = VkComponentSwizzle 2 + +pattern VK_COMPONENT_SWIZZLE_R :: VkComponentSwizzle + +pattern VK_COMPONENT_SWIZZLE_R = VkComponentSwizzle 3 + +pattern VK_COMPONENT_SWIZZLE_G :: VkComponentSwizzle + +pattern VK_COMPONENT_SWIZZLE_G = VkComponentSwizzle 4 + +pattern VK_COMPONENT_SWIZZLE_B :: VkComponentSwizzle + +pattern VK_COMPONENT_SWIZZLE_B = VkComponentSwizzle 5 + +pattern VK_COMPONENT_SWIZZLE_A :: VkComponentSwizzle + +pattern VK_COMPONENT_SWIZZLE_A = VkComponentSwizzle 6 diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkCompositeAlphaFlagsKHR.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkCompositeAlphaFlagsKHR.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkCompositeAlphaFlagsKHR.hs @@ -0,0 +1,122 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE KindSignatures #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE StandaloneDeriving #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeSynonymInstances #-} +module Graphics.Vulkan.Types.Enum.VkCompositeAlphaFlagsKHR + (VkCompositeAlphaBitmaskKHR(VkCompositeAlphaBitmaskKHR, + VkCompositeAlphaFlagsKHR, VkCompositeAlphaFlagBitsKHR, + VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR, + VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR, + VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR, + VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR), + VkCompositeAlphaFlagsKHR, VkCompositeAlphaFlagBitsKHR) + where +import Data.Bits (Bits, FiniteBits) +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (FlagBit, FlagMask, FlagType) +import Graphics.Vulkan.Types.BaseTypes (VkFlags (..)) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +newtype VkCompositeAlphaBitmaskKHR (a :: + FlagType) = VkCompositeAlphaBitmaskKHR VkFlags + deriving (Eq, Ord, Storable, Data, Generic) + +type VkCompositeAlphaFlagsKHR = VkCompositeAlphaBitmaskKHR FlagMask + +type VkCompositeAlphaFlagBitsKHR = + VkCompositeAlphaBitmaskKHR FlagBit + +pattern VkCompositeAlphaFlagBitsKHR :: + VkFlags -> VkCompositeAlphaBitmaskKHR FlagBit + +pattern VkCompositeAlphaFlagBitsKHR n = + VkCompositeAlphaBitmaskKHR n + +pattern VkCompositeAlphaFlagsKHR :: + VkFlags -> VkCompositeAlphaBitmaskKHR FlagMask + +pattern VkCompositeAlphaFlagsKHR n = VkCompositeAlphaBitmaskKHR n + +deriving instance Bits (VkCompositeAlphaBitmaskKHR FlagMask) + +deriving instance FiniteBits (VkCompositeAlphaBitmaskKHR FlagMask) + +deriving instance Integral (VkCompositeAlphaBitmaskKHR FlagMask) + +deriving instance Num (VkCompositeAlphaBitmaskKHR FlagMask) + +deriving instance Bounded (VkCompositeAlphaBitmaskKHR FlagMask) + +deriving instance Enum (VkCompositeAlphaBitmaskKHR FlagMask) + +deriving instance Real (VkCompositeAlphaBitmaskKHR FlagMask) + +instance Show (VkCompositeAlphaBitmaskKHR a) where + showsPrec _ VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR + = showString "VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR" + showsPrec _ VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR + = showString "VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR" + showsPrec _ VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR + = showString "VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR" + showsPrec _ VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR + = showString "VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR" + showsPrec p (VkCompositeAlphaBitmaskKHR x) + = showParen (p >= 11) + (showString "VkCompositeAlphaBitmaskKHR " . showsPrec 11 x) + +instance Read (VkCompositeAlphaBitmaskKHR a) where + readPrec + = parens + (choose + [("VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR", + pure VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR), + ("VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR", + pure VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR), + ("VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR", + pure VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR), + ("VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR", + pure VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR)] + +++ + prec 10 + (expectP (Ident "VkCompositeAlphaBitmaskKHR") >> + (VkCompositeAlphaBitmaskKHR <$> step readPrec))) + +-- | bitpos = @0@ +pattern VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR :: + VkCompositeAlphaBitmaskKHR a + +pattern VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR = + VkCompositeAlphaBitmaskKHR 1 + +-- | bitpos = @1@ +pattern VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR :: + VkCompositeAlphaBitmaskKHR a + +pattern VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR = + VkCompositeAlphaBitmaskKHR 2 + +-- | bitpos = @2@ +pattern VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR :: + VkCompositeAlphaBitmaskKHR a + +pattern VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR = + VkCompositeAlphaBitmaskKHR 4 + +-- | bitpos = @3@ +pattern VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR :: + VkCompositeAlphaBitmaskKHR a + +pattern VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR = + VkCompositeAlphaBitmaskKHR 8 diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkConservativeRasterizationModeEXT.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkConservativeRasterizationModeEXT.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkConservativeRasterizationModeEXT.hs @@ -0,0 +1,72 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +module Graphics.Vulkan.Types.Enum.VkConservativeRasterizationModeEXT + (VkConservativeRasterizationModeEXT(VkConservativeRasterizationModeEXT, + VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT, + VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT, + VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT)) + where +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (Int32) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +-- | type = @enum@ +-- +-- +newtype VkConservativeRasterizationModeEXT = VkConservativeRasterizationModeEXT Int32 + deriving (Eq, Ord, Num, Bounded, Storable, Enum, + Data, Generic) + +instance Show VkConservativeRasterizationModeEXT where + showsPrec _ VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT + = showString "VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT" + showsPrec _ VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT + = showString "VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT" + showsPrec _ VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT + = showString "VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT" + showsPrec p (VkConservativeRasterizationModeEXT x) + = showParen (p >= 11) + (showString "VkConservativeRasterizationModeEXT " . showsPrec 11 x) + +instance Read VkConservativeRasterizationModeEXT where + readPrec + = parens + (choose + [("VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT", + pure VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT), + ("VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT", + pure VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT), + ("VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT", + pure VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT)] + +++ + prec 10 + (expectP (Ident "VkConservativeRasterizationModeEXT") >> + (VkConservativeRasterizationModeEXT <$> step readPrec))) + +pattern VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT :: + VkConservativeRasterizationModeEXT + +pattern VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT = + VkConservativeRasterizationModeEXT 0 + +pattern VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT :: + VkConservativeRasterizationModeEXT + +pattern VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT = + VkConservativeRasterizationModeEXT 1 + +pattern VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT :: + VkConservativeRasterizationModeEXT + +pattern VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT = + VkConservativeRasterizationModeEXT 2 diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkCoverageModulationModeNV.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkCoverageModulationModeNV.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkCoverageModulationModeNV.hs @@ -0,0 +1,83 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +module Graphics.Vulkan.Types.Enum.VkCoverageModulationModeNV + (VkCoverageModulationModeNV(VkCoverageModulationModeNV, + VK_COVERAGE_MODULATION_MODE_NONE_NV, + VK_COVERAGE_MODULATION_MODE_RGB_NV, + VK_COVERAGE_MODULATION_MODE_ALPHA_NV, + VK_COVERAGE_MODULATION_MODE_RGBA_NV)) + where +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (Int32) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +-- | type = @enum@ +-- +-- +newtype VkCoverageModulationModeNV = VkCoverageModulationModeNV Int32 + deriving (Eq, Ord, Num, Bounded, Storable, Enum, Data, + Generic) + +instance Show VkCoverageModulationModeNV where + showsPrec _ VK_COVERAGE_MODULATION_MODE_NONE_NV + = showString "VK_COVERAGE_MODULATION_MODE_NONE_NV" + showsPrec _ VK_COVERAGE_MODULATION_MODE_RGB_NV + = showString "VK_COVERAGE_MODULATION_MODE_RGB_NV" + showsPrec _ VK_COVERAGE_MODULATION_MODE_ALPHA_NV + = showString "VK_COVERAGE_MODULATION_MODE_ALPHA_NV" + showsPrec _ VK_COVERAGE_MODULATION_MODE_RGBA_NV + = showString "VK_COVERAGE_MODULATION_MODE_RGBA_NV" + showsPrec p (VkCoverageModulationModeNV x) + = showParen (p >= 11) + (showString "VkCoverageModulationModeNV " . showsPrec 11 x) + +instance Read VkCoverageModulationModeNV where + readPrec + = parens + (choose + [("VK_COVERAGE_MODULATION_MODE_NONE_NV", + pure VK_COVERAGE_MODULATION_MODE_NONE_NV), + ("VK_COVERAGE_MODULATION_MODE_RGB_NV", + pure VK_COVERAGE_MODULATION_MODE_RGB_NV), + ("VK_COVERAGE_MODULATION_MODE_ALPHA_NV", + pure VK_COVERAGE_MODULATION_MODE_ALPHA_NV), + ("VK_COVERAGE_MODULATION_MODE_RGBA_NV", + pure VK_COVERAGE_MODULATION_MODE_RGBA_NV)] + +++ + prec 10 + (expectP (Ident "VkCoverageModulationModeNV") >> + (VkCoverageModulationModeNV <$> step readPrec))) + +pattern VK_COVERAGE_MODULATION_MODE_NONE_NV :: + VkCoverageModulationModeNV + +pattern VK_COVERAGE_MODULATION_MODE_NONE_NV = + VkCoverageModulationModeNV 0 + +pattern VK_COVERAGE_MODULATION_MODE_RGB_NV :: + VkCoverageModulationModeNV + +pattern VK_COVERAGE_MODULATION_MODE_RGB_NV = + VkCoverageModulationModeNV 1 + +pattern VK_COVERAGE_MODULATION_MODE_ALPHA_NV :: + VkCoverageModulationModeNV + +pattern VK_COVERAGE_MODULATION_MODE_ALPHA_NV = + VkCoverageModulationModeNV 2 + +pattern VK_COVERAGE_MODULATION_MODE_RGBA_NV :: + VkCoverageModulationModeNV + +pattern VK_COVERAGE_MODULATION_MODE_RGBA_NV = + VkCoverageModulationModeNV 3 diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkCullModeFlags.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkCullModeFlags.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkCullModeFlags.hs @@ -0,0 +1,100 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE KindSignatures #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE StandaloneDeriving #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeSynonymInstances #-} +module Graphics.Vulkan.Types.Enum.VkCullModeFlags + (VkCullModeBitmask(VkCullModeBitmask, VkCullModeFlags, + VkCullModeFlagBits, VK_CULL_MODE_NONE, VK_CULL_MODE_FRONT_BIT, + VK_CULL_MODE_BACK_BIT, VK_CULL_MODE_FRONT_AND_BACK), + VkCullModeFlags, VkCullModeFlagBits) + where +import Data.Bits (Bits, FiniteBits) +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (FlagBit, FlagMask, FlagType) +import Graphics.Vulkan.Types.BaseTypes (VkFlags (..)) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +newtype VkCullModeBitmask (a :: + FlagType) = VkCullModeBitmask VkFlags + deriving (Eq, Ord, Storable, Data, Generic) + +type VkCullModeFlags = VkCullModeBitmask FlagMask + +type VkCullModeFlagBits = VkCullModeBitmask FlagBit + +pattern VkCullModeFlagBits :: VkFlags -> VkCullModeBitmask FlagBit + +pattern VkCullModeFlagBits n = VkCullModeBitmask n + +pattern VkCullModeFlags :: VkFlags -> VkCullModeBitmask FlagMask + +pattern VkCullModeFlags n = VkCullModeBitmask n + +deriving instance Bits (VkCullModeBitmask FlagMask) + +deriving instance FiniteBits (VkCullModeBitmask FlagMask) + +deriving instance Integral (VkCullModeBitmask FlagMask) + +deriving instance Num (VkCullModeBitmask FlagMask) + +deriving instance Bounded (VkCullModeBitmask FlagMask) + +deriving instance Enum (VkCullModeBitmask FlagMask) + +deriving instance Real (VkCullModeBitmask FlagMask) + +instance Show (VkCullModeBitmask a) where + showsPrec _ VK_CULL_MODE_NONE = showString "VK_CULL_MODE_NONE" + showsPrec _ VK_CULL_MODE_FRONT_BIT + = showString "VK_CULL_MODE_FRONT_BIT" + showsPrec _ VK_CULL_MODE_BACK_BIT + = showString "VK_CULL_MODE_BACK_BIT" + showsPrec _ VK_CULL_MODE_FRONT_AND_BACK + = showString "VK_CULL_MODE_FRONT_AND_BACK" + showsPrec p (VkCullModeBitmask x) + = showParen (p >= 11) + (showString "VkCullModeBitmask " . showsPrec 11 x) + +instance Read (VkCullModeBitmask a) where + readPrec + = parens + (choose + [("VK_CULL_MODE_NONE", pure VK_CULL_MODE_NONE), + ("VK_CULL_MODE_FRONT_BIT", pure VK_CULL_MODE_FRONT_BIT), + ("VK_CULL_MODE_BACK_BIT", pure VK_CULL_MODE_BACK_BIT), + ("VK_CULL_MODE_FRONT_AND_BACK", pure VK_CULL_MODE_FRONT_AND_BACK)] + +++ + prec 10 + (expectP (Ident "VkCullModeBitmask") >> + (VkCullModeBitmask <$> step readPrec))) + +pattern VK_CULL_MODE_NONE :: VkCullModeBitmask a + +pattern VK_CULL_MODE_NONE = VkCullModeBitmask 0 + +-- | bitpos = @0@ +pattern VK_CULL_MODE_FRONT_BIT :: VkCullModeBitmask a + +pattern VK_CULL_MODE_FRONT_BIT = VkCullModeBitmask 1 + +-- | bitpos = @1@ +pattern VK_CULL_MODE_BACK_BIT :: VkCullModeBitmask a + +pattern VK_CULL_MODE_BACK_BIT = VkCullModeBitmask 2 + +pattern VK_CULL_MODE_FRONT_AND_BACK :: VkCullModeBitmask a + +pattern VK_CULL_MODE_FRONT_AND_BACK = VkCullModeBitmask 3 diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkDebugReportFlagsEXT.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkDebugReportFlagsEXT.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkDebugReportFlagsEXT.hs @@ -0,0 +1,126 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE KindSignatures #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE StandaloneDeriving #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeSynonymInstances #-} +module Graphics.Vulkan.Types.Enum.VkDebugReportFlagsEXT + (VkDebugReportBitmaskEXT(VkDebugReportBitmaskEXT, + VkDebugReportFlagsEXT, VkDebugReportFlagBitsEXT, + VK_DEBUG_REPORT_INFORMATION_BIT_EXT, + VK_DEBUG_REPORT_WARNING_BIT_EXT, + VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT, + VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_DEBUG_BIT_EXT), + VkDebugReportFlagsEXT, VkDebugReportFlagBitsEXT) + where +import Data.Bits (Bits, FiniteBits) +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (FlagBit, FlagMask, FlagType) +import Graphics.Vulkan.Types.BaseTypes (VkFlags (..)) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +newtype VkDebugReportBitmaskEXT (a :: + FlagType) = VkDebugReportBitmaskEXT VkFlags + deriving (Eq, Ord, Storable, Data, Generic) + +type VkDebugReportFlagsEXT = VkDebugReportBitmaskEXT FlagMask + +type VkDebugReportFlagBitsEXT = VkDebugReportBitmaskEXT FlagBit + +pattern VkDebugReportFlagBitsEXT :: + VkFlags -> VkDebugReportBitmaskEXT FlagBit + +pattern VkDebugReportFlagBitsEXT n = VkDebugReportBitmaskEXT n + +pattern VkDebugReportFlagsEXT :: + VkFlags -> VkDebugReportBitmaskEXT FlagMask + +pattern VkDebugReportFlagsEXT n = VkDebugReportBitmaskEXT n + +deriving instance Bits (VkDebugReportBitmaskEXT FlagMask) + +deriving instance FiniteBits (VkDebugReportBitmaskEXT FlagMask) + +deriving instance Integral (VkDebugReportBitmaskEXT FlagMask) + +deriving instance Num (VkDebugReportBitmaskEXT FlagMask) + +deriving instance Bounded (VkDebugReportBitmaskEXT FlagMask) + +deriving instance Enum (VkDebugReportBitmaskEXT FlagMask) + +deriving instance Real (VkDebugReportBitmaskEXT FlagMask) + +instance Show (VkDebugReportBitmaskEXT a) where + showsPrec _ VK_DEBUG_REPORT_INFORMATION_BIT_EXT + = showString "VK_DEBUG_REPORT_INFORMATION_BIT_EXT" + showsPrec _ VK_DEBUG_REPORT_WARNING_BIT_EXT + = showString "VK_DEBUG_REPORT_WARNING_BIT_EXT" + showsPrec _ VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT + = showString "VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT" + showsPrec _ VK_DEBUG_REPORT_ERROR_BIT_EXT + = showString "VK_DEBUG_REPORT_ERROR_BIT_EXT" + showsPrec _ VK_DEBUG_REPORT_DEBUG_BIT_EXT + = showString "VK_DEBUG_REPORT_DEBUG_BIT_EXT" + showsPrec p (VkDebugReportBitmaskEXT x) + = showParen (p >= 11) + (showString "VkDebugReportBitmaskEXT " . showsPrec 11 x) + +instance Read (VkDebugReportBitmaskEXT a) where + readPrec + = parens + (choose + [("VK_DEBUG_REPORT_INFORMATION_BIT_EXT", + pure VK_DEBUG_REPORT_INFORMATION_BIT_EXT), + ("VK_DEBUG_REPORT_WARNING_BIT_EXT", + pure VK_DEBUG_REPORT_WARNING_BIT_EXT), + ("VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT", + pure VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT), + ("VK_DEBUG_REPORT_ERROR_BIT_EXT", + pure VK_DEBUG_REPORT_ERROR_BIT_EXT), + ("VK_DEBUG_REPORT_DEBUG_BIT_EXT", + pure VK_DEBUG_REPORT_DEBUG_BIT_EXT)] + +++ + prec 10 + (expectP (Ident "VkDebugReportBitmaskEXT") >> + (VkDebugReportBitmaskEXT <$> step readPrec))) + +-- | bitpos = @0@ +pattern VK_DEBUG_REPORT_INFORMATION_BIT_EXT :: + VkDebugReportBitmaskEXT a + +pattern VK_DEBUG_REPORT_INFORMATION_BIT_EXT = + VkDebugReportBitmaskEXT 1 + +-- | bitpos = @1@ +pattern VK_DEBUG_REPORT_WARNING_BIT_EXT :: + VkDebugReportBitmaskEXT a + +pattern VK_DEBUG_REPORT_WARNING_BIT_EXT = VkDebugReportBitmaskEXT 2 + +-- | bitpos = @2@ +pattern VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT :: + VkDebugReportBitmaskEXT a + +pattern VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT = + VkDebugReportBitmaskEXT 4 + +-- | bitpos = @3@ +pattern VK_DEBUG_REPORT_ERROR_BIT_EXT :: VkDebugReportBitmaskEXT a + +pattern VK_DEBUG_REPORT_ERROR_BIT_EXT = VkDebugReportBitmaskEXT 8 + +-- | bitpos = @4@ +pattern VK_DEBUG_REPORT_DEBUG_BIT_EXT :: VkDebugReportBitmaskEXT a + +pattern VK_DEBUG_REPORT_DEBUG_BIT_EXT = VkDebugReportBitmaskEXT 16 diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkDebugReportObjectTypeEXT.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkDebugReportObjectTypeEXT.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkDebugReportObjectTypeEXT.hs @@ -0,0 +1,418 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +module Graphics.Vulkan.Types.Enum.VkDebugReportObjectTypeEXT + (VkDebugReportObjectTypeEXT(VkDebugReportObjectTypeEXT, + VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, + VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT, + VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT, + VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, + VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT, + VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT, + VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, + VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT, + VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, + VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, + VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, + VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT, + VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT, + VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT, + VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT, + VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT, + VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT, + VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT, + VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT, + VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT, + VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT, + VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT, + VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT, + VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT, + VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT, + VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT, + VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT, + VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT, + VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT, + VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT, + VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT, + VK_DEBUG_REPORT_OBJECT_TYPE_OBJECT_TABLE_NVX_EXT, + VK_DEBUG_REPORT_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX_EXT, + VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT)) + where +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (Int32) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +-- | type = @enum@ +-- +-- +newtype VkDebugReportObjectTypeEXT = VkDebugReportObjectTypeEXT Int32 + deriving (Eq, Ord, Num, Bounded, Storable, Enum, Data, + Generic) + +instance Show VkDebugReportObjectTypeEXT where + showsPrec _ VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT + = showString "VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT" + showsPrec _ VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT + = showString "VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT" + showsPrec _ VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT + = showString "VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT" + showsPrec _ VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT + = showString "VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT" + showsPrec _ VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT + = showString "VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT" + showsPrec _ VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT + = showString "VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT" + showsPrec _ VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT + = showString "VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT" + showsPrec _ VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT + = showString "VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT" + showsPrec _ VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT + = showString "VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT" + showsPrec _ VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT + = showString "VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT" + showsPrec _ VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT + = showString "VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT" + showsPrec _ VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT + = showString "VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT" + showsPrec _ VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT + = showString "VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT" + showsPrec _ VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT + = showString "VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT" + showsPrec _ VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT + = showString "VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT" + showsPrec _ VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT + = showString "VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT" + showsPrec _ VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT + = showString "VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT" + showsPrec _ VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT + = showString "VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT" + showsPrec _ VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT + = showString "VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT" + showsPrec _ VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT + = showString "VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT" + showsPrec _ VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT + = showString + "VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT" + showsPrec _ VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT + = showString "VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT" + showsPrec _ VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT + = showString "VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT" + showsPrec _ VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT + = showString "VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT" + showsPrec _ VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT + = showString "VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT" + showsPrec _ VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT + = showString "VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT" + showsPrec _ VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT + = showString "VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT" + showsPrec _ VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT + = showString "VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT" + showsPrec _ + VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT + = showString + "VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT" + showsPrec _ VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT + = showString "VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT" + showsPrec _ VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT + = showString "VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT" + showsPrec _ VK_DEBUG_REPORT_OBJECT_TYPE_OBJECT_TABLE_NVX_EXT + = showString "VK_DEBUG_REPORT_OBJECT_TYPE_OBJECT_TABLE_NVX_EXT" + showsPrec _ + VK_DEBUG_REPORT_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX_EXT + = showString + "VK_DEBUG_REPORT_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX_EXT" + showsPrec _ VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT + = showString "VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT" + showsPrec p (VkDebugReportObjectTypeEXT x) + = showParen (p >= 11) + (showString "VkDebugReportObjectTypeEXT " . showsPrec 11 x) + +instance Read VkDebugReportObjectTypeEXT where + readPrec + = parens + (choose + [("VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT", + pure VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT), + ("VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT", + pure VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT), + ("VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT", + pure VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT), + ("VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT", + pure VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT), + ("VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT", + pure VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT), + ("VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT", + pure VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT), + ("VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT", + pure VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT), + ("VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT", + pure VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT), + ("VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT", + pure VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT), + ("VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT", + pure VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT), + ("VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT", + pure VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT), + ("VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT", + pure VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT), + ("VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT", + pure VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT), + ("VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT", + pure VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT), + ("VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT", + pure VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT), + ("VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT", + pure VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT), + ("VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT", + pure VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT), + ("VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT", + pure VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT), + ("VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT", + pure VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT), + ("VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT", + pure VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT), + ("VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT", + pure VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT), + ("VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT", + pure VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT), + ("VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT", + pure VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT), + ("VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT", + pure VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT), + ("VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT", + pure VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT), + ("VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT", + pure VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT), + ("VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT", + pure VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT), + ("VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT", + pure VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT), + ("VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT", + pure VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT), + ("VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT", + pure VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT), + ("VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT", + pure VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT), + ("VK_DEBUG_REPORT_OBJECT_TYPE_OBJECT_TABLE_NVX_EXT", + pure VK_DEBUG_REPORT_OBJECT_TYPE_OBJECT_TABLE_NVX_EXT), + ("VK_DEBUG_REPORT_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX_EXT", + pure VK_DEBUG_REPORT_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX_EXT), + ("VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT", + pure VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT)] + +++ + prec 10 + (expectP (Ident "VkDebugReportObjectTypeEXT") >> + (VkDebugReportObjectTypeEXT <$> step readPrec))) + +pattern VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT :: + VkDebugReportObjectTypeEXT + +pattern VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT = + VkDebugReportObjectTypeEXT 0 + +pattern VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT :: + VkDebugReportObjectTypeEXT + +pattern VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT = + VkDebugReportObjectTypeEXT 1 + +pattern VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT :: + VkDebugReportObjectTypeEXT + +pattern VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT = + VkDebugReportObjectTypeEXT 2 + +pattern VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT :: + VkDebugReportObjectTypeEXT + +pattern VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT = + VkDebugReportObjectTypeEXT 3 + +pattern VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT :: + VkDebugReportObjectTypeEXT + +pattern VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT = + VkDebugReportObjectTypeEXT 4 + +pattern VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT :: + VkDebugReportObjectTypeEXT + +pattern VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT = + VkDebugReportObjectTypeEXT 5 + +pattern VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT :: + VkDebugReportObjectTypeEXT + +pattern VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT = + VkDebugReportObjectTypeEXT 6 + +pattern VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT :: + VkDebugReportObjectTypeEXT + +pattern VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT = + VkDebugReportObjectTypeEXT 7 + +pattern VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT :: + VkDebugReportObjectTypeEXT + +pattern VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT = + VkDebugReportObjectTypeEXT 8 + +pattern VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT :: + VkDebugReportObjectTypeEXT + +pattern VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT = + VkDebugReportObjectTypeEXT 9 + +pattern VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT :: + VkDebugReportObjectTypeEXT + +pattern VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT = + VkDebugReportObjectTypeEXT 10 + +pattern VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT :: + VkDebugReportObjectTypeEXT + +pattern VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT = + VkDebugReportObjectTypeEXT 11 + +pattern VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT :: + VkDebugReportObjectTypeEXT + +pattern VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT = + VkDebugReportObjectTypeEXT 12 + +pattern VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT :: + VkDebugReportObjectTypeEXT + +pattern VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT = + VkDebugReportObjectTypeEXT 13 + +pattern VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT :: + VkDebugReportObjectTypeEXT + +pattern VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT = + VkDebugReportObjectTypeEXT 14 + +pattern VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT :: + VkDebugReportObjectTypeEXT + +pattern VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT = + VkDebugReportObjectTypeEXT 15 + +pattern VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT :: + VkDebugReportObjectTypeEXT + +pattern VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT = + VkDebugReportObjectTypeEXT 16 + +pattern VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT :: + VkDebugReportObjectTypeEXT + +pattern VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT = + VkDebugReportObjectTypeEXT 17 + +pattern VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT :: + VkDebugReportObjectTypeEXT + +pattern VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT = + VkDebugReportObjectTypeEXT 18 + +pattern VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT :: + VkDebugReportObjectTypeEXT + +pattern VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT = + VkDebugReportObjectTypeEXT 19 + +pattern VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT :: + VkDebugReportObjectTypeEXT + +pattern VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT = + VkDebugReportObjectTypeEXT 20 + +pattern VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT :: + VkDebugReportObjectTypeEXT + +pattern VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT = + VkDebugReportObjectTypeEXT 21 + +pattern VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT :: + VkDebugReportObjectTypeEXT + +pattern VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT = + VkDebugReportObjectTypeEXT 22 + +pattern VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT :: + VkDebugReportObjectTypeEXT + +pattern VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT = + VkDebugReportObjectTypeEXT 23 + +pattern VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT :: + VkDebugReportObjectTypeEXT + +pattern VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT = + VkDebugReportObjectTypeEXT 24 + +pattern VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT :: + VkDebugReportObjectTypeEXT + +pattern VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT = + VkDebugReportObjectTypeEXT 25 + +pattern VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT :: + VkDebugReportObjectTypeEXT + +pattern VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT = + VkDebugReportObjectTypeEXT 26 + +pattern VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT :: + VkDebugReportObjectTypeEXT + +pattern VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT = + VkDebugReportObjectTypeEXT 27 + +pattern VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT + :: VkDebugReportObjectTypeEXT + +pattern VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT = + VkDebugReportObjectTypeEXT 28 + +pattern VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT :: + VkDebugReportObjectTypeEXT + +pattern VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT = + VkDebugReportObjectTypeEXT 29 + +pattern VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT :: + VkDebugReportObjectTypeEXT + +pattern VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT = + VkDebugReportObjectTypeEXT 30 + +pattern VK_DEBUG_REPORT_OBJECT_TYPE_OBJECT_TABLE_NVX_EXT :: + VkDebugReportObjectTypeEXT + +pattern VK_DEBUG_REPORT_OBJECT_TYPE_OBJECT_TABLE_NVX_EXT = + VkDebugReportObjectTypeEXT 31 + +pattern VK_DEBUG_REPORT_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX_EXT + :: VkDebugReportObjectTypeEXT + +pattern VK_DEBUG_REPORT_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX_EXT + = VkDebugReportObjectTypeEXT 32 + +pattern VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT :: + VkDebugReportObjectTypeEXT + +pattern VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT = + VkDebugReportObjectTypeEXT 33 diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkDependencyFlags.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkDependencyFlags.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkDependencyFlags.hs @@ -0,0 +1,82 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE KindSignatures #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE StandaloneDeriving #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeSynonymInstances #-} +module Graphics.Vulkan.Types.Enum.VkDependencyFlags + (VkDependencyBitmask(VkDependencyBitmask, VkDependencyFlags, + VkDependencyFlagBits, VK_DEPENDENCY_BY_REGION_BIT), + VkDependencyFlags, VkDependencyFlagBits) + where +import Data.Bits (Bits, FiniteBits) +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (FlagBit, FlagMask, FlagType) +import Graphics.Vulkan.Types.BaseTypes (VkFlags (..)) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +newtype VkDependencyBitmask (a :: + FlagType) = VkDependencyBitmask VkFlags + deriving (Eq, Ord, Storable, Data, Generic) + +type VkDependencyFlags = VkDependencyBitmask FlagMask + +type VkDependencyFlagBits = VkDependencyBitmask FlagBit + +pattern VkDependencyFlagBits :: + VkFlags -> VkDependencyBitmask FlagBit + +pattern VkDependencyFlagBits n = VkDependencyBitmask n + +pattern VkDependencyFlags :: + VkFlags -> VkDependencyBitmask FlagMask + +pattern VkDependencyFlags n = VkDependencyBitmask n + +deriving instance Bits (VkDependencyBitmask FlagMask) + +deriving instance FiniteBits (VkDependencyBitmask FlagMask) + +deriving instance Integral (VkDependencyBitmask FlagMask) + +deriving instance Num (VkDependencyBitmask FlagMask) + +deriving instance Bounded (VkDependencyBitmask FlagMask) + +deriving instance Enum (VkDependencyBitmask FlagMask) + +deriving instance Real (VkDependencyBitmask FlagMask) + +instance Show (VkDependencyBitmask a) where + showsPrec _ VK_DEPENDENCY_BY_REGION_BIT + = showString "VK_DEPENDENCY_BY_REGION_BIT" + showsPrec p (VkDependencyBitmask x) + = showParen (p >= 11) + (showString "VkDependencyBitmask " . showsPrec 11 x) + +instance Read (VkDependencyBitmask a) where + readPrec + = parens + (choose + [("VK_DEPENDENCY_BY_REGION_BIT", pure VK_DEPENDENCY_BY_REGION_BIT)] + +++ + prec 10 + (expectP (Ident "VkDependencyBitmask") >> + (VkDependencyBitmask <$> step readPrec))) + +-- | Dependency is per pixel region +-- +-- bitpos = @0@ +pattern VK_DEPENDENCY_BY_REGION_BIT :: VkDependencyBitmask a + +pattern VK_DEPENDENCY_BY_REGION_BIT = VkDependencyBitmask 1 diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkDescriptorPoolCreateFlags.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkDescriptorPoolCreateFlags.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkDescriptorPoolCreateFlags.hs @@ -0,0 +1,91 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE KindSignatures #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE StandaloneDeriving #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeSynonymInstances #-} +module Graphics.Vulkan.Types.Enum.VkDescriptorPoolCreateFlags + (VkDescriptorPoolCreateBitmask(VkDescriptorPoolCreateBitmask, + VkDescriptorPoolCreateFlags, VkDescriptorPoolCreateFlagBits, + VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT), + VkDescriptorPoolCreateFlags, VkDescriptorPoolCreateFlagBits) + where +import Data.Bits (Bits, FiniteBits) +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (FlagBit, FlagMask, FlagType) +import Graphics.Vulkan.Types.BaseTypes (VkFlags (..)) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +newtype VkDescriptorPoolCreateBitmask (a :: + FlagType) = VkDescriptorPoolCreateBitmask VkFlags + deriving (Eq, Ord, Storable, Data, Generic) + +type VkDescriptorPoolCreateFlags = + VkDescriptorPoolCreateBitmask FlagMask + +type VkDescriptorPoolCreateFlagBits = + VkDescriptorPoolCreateBitmask FlagBit + +pattern VkDescriptorPoolCreateFlagBits :: + VkFlags -> VkDescriptorPoolCreateBitmask FlagBit + +pattern VkDescriptorPoolCreateFlagBits n = + VkDescriptorPoolCreateBitmask n + +pattern VkDescriptorPoolCreateFlags :: + VkFlags -> VkDescriptorPoolCreateBitmask FlagMask + +pattern VkDescriptorPoolCreateFlags n = + VkDescriptorPoolCreateBitmask n + +deriving instance Bits (VkDescriptorPoolCreateBitmask FlagMask) + +deriving instance + FiniteBits (VkDescriptorPoolCreateBitmask FlagMask) + +deriving instance Integral (VkDescriptorPoolCreateBitmask FlagMask) + +deriving instance Num (VkDescriptorPoolCreateBitmask FlagMask) + +deriving instance Bounded (VkDescriptorPoolCreateBitmask FlagMask) + +deriving instance Enum (VkDescriptorPoolCreateBitmask FlagMask) + +deriving instance Real (VkDescriptorPoolCreateBitmask FlagMask) + +instance Show (VkDescriptorPoolCreateBitmask a) where + showsPrec _ VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT + = showString "VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT" + showsPrec p (VkDescriptorPoolCreateBitmask x) + = showParen (p >= 11) + (showString "VkDescriptorPoolCreateBitmask " . showsPrec 11 x) + +instance Read (VkDescriptorPoolCreateBitmask a) where + readPrec + = parens + (choose + [("VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT", + pure VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT)] + +++ + prec 10 + (expectP (Ident "VkDescriptorPoolCreateBitmask") >> + (VkDescriptorPoolCreateBitmask <$> step readPrec))) + +-- | Descriptor sets may be freed individually +-- +-- bitpos = @0@ +pattern VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT :: + VkDescriptorPoolCreateBitmask a + +pattern VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT = + VkDescriptorPoolCreateBitmask 1 diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkDescriptorSetLayoutCreateFlags.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkDescriptorSetLayoutCreateFlags.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkDescriptorSetLayoutCreateFlags.hs @@ -0,0 +1,84 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE KindSignatures #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE StandaloneDeriving #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeSynonymInstances #-} +module Graphics.Vulkan.Types.Enum.VkDescriptorSetLayoutCreateFlags + (VkDescriptorSetLayoutCreateBitmask(VkDescriptorSetLayoutCreateBitmask, + VkDescriptorSetLayoutCreateFlags, + VkDescriptorSetLayoutCreateFlagBits), + VkDescriptorSetLayoutCreateFlags, + VkDescriptorSetLayoutCreateFlagBits) + where +import Data.Bits (Bits, FiniteBits) +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (FlagBit, FlagMask, FlagType) +import Graphics.Vulkan.Types.BaseTypes (VkFlags (..)) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +newtype VkDescriptorSetLayoutCreateBitmask (a :: + FlagType) = VkDescriptorSetLayoutCreateBitmask VkFlags + deriving (Eq, Ord, Storable, Data, + Generic) + +type VkDescriptorSetLayoutCreateFlags = + VkDescriptorSetLayoutCreateBitmask FlagMask + +type VkDescriptorSetLayoutCreateFlagBits = + VkDescriptorSetLayoutCreateBitmask FlagBit + +pattern VkDescriptorSetLayoutCreateFlagBits :: + VkFlags -> VkDescriptorSetLayoutCreateBitmask FlagBit + +pattern VkDescriptorSetLayoutCreateFlagBits n = + VkDescriptorSetLayoutCreateBitmask n + +pattern VkDescriptorSetLayoutCreateFlags :: + VkFlags -> VkDescriptorSetLayoutCreateBitmask FlagMask + +pattern VkDescriptorSetLayoutCreateFlags n = + VkDescriptorSetLayoutCreateBitmask n + +deriving instance + Bits (VkDescriptorSetLayoutCreateBitmask FlagMask) + +deriving instance + FiniteBits (VkDescriptorSetLayoutCreateBitmask FlagMask) + +deriving instance + Integral (VkDescriptorSetLayoutCreateBitmask FlagMask) + +deriving instance Num (VkDescriptorSetLayoutCreateBitmask FlagMask) + +deriving instance + Bounded (VkDescriptorSetLayoutCreateBitmask FlagMask) + +deriving instance + Enum (VkDescriptorSetLayoutCreateBitmask FlagMask) + +deriving instance + Real (VkDescriptorSetLayoutCreateBitmask FlagMask) + +instance Show (VkDescriptorSetLayoutCreateBitmask a) where + showsPrec p (VkDescriptorSetLayoutCreateBitmask x) + = showParen (p >= 11) + (showString "VkDescriptorSetLayoutCreateBitmask " . showsPrec 11 x) + +instance Read (VkDescriptorSetLayoutCreateBitmask a) where + readPrec + = parens + (choose [] +++ + prec 10 + (expectP (Ident "VkDescriptorSetLayoutCreateBitmask") >> + (VkDescriptorSetLayoutCreateBitmask <$> step readPrec))) diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkDescriptorType.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkDescriptorType.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkDescriptorType.hs @@ -0,0 +1,142 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +module Graphics.Vulkan.Types.Enum.VkDescriptorType + (VkDescriptorType(VkDescriptorType, VK_DESCRIPTOR_TYPE_SAMPLER, + VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, + VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, + VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER, + VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER, + VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, + VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, + VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, + VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC, + VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT)) + where +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (Int32) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +-- | type = @enum@ +-- +-- +newtype VkDescriptorType = VkDescriptorType Int32 + deriving (Eq, Ord, Num, Bounded, Storable, Enum, Data, Generic) + +instance Show VkDescriptorType where + showsPrec _ VK_DESCRIPTOR_TYPE_SAMPLER + = showString "VK_DESCRIPTOR_TYPE_SAMPLER" + showsPrec _ VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER + = showString "VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER" + showsPrec _ VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE + = showString "VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE" + showsPrec _ VK_DESCRIPTOR_TYPE_STORAGE_IMAGE + = showString "VK_DESCRIPTOR_TYPE_STORAGE_IMAGE" + showsPrec _ VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER + = showString "VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER" + showsPrec _ VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER + = showString "VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER" + showsPrec _ VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER + = showString "VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER" + showsPrec _ VK_DESCRIPTOR_TYPE_STORAGE_BUFFER + = showString "VK_DESCRIPTOR_TYPE_STORAGE_BUFFER" + showsPrec _ VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC + = showString "VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC" + showsPrec _ VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC + = showString "VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC" + showsPrec _ VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT + = showString "VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT" + showsPrec p (VkDescriptorType x) + = showParen (p >= 11) + (showString "VkDescriptorType " . showsPrec 11 x) + +instance Read VkDescriptorType where + readPrec + = parens + (choose + [("VK_DESCRIPTOR_TYPE_SAMPLER", pure VK_DESCRIPTOR_TYPE_SAMPLER), + ("VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER", + pure VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER), + ("VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE", + pure VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE), + ("VK_DESCRIPTOR_TYPE_STORAGE_IMAGE", + pure VK_DESCRIPTOR_TYPE_STORAGE_IMAGE), + ("VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER", + pure VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER), + ("VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER", + pure VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER), + ("VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER", + pure VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER), + ("VK_DESCRIPTOR_TYPE_STORAGE_BUFFER", + pure VK_DESCRIPTOR_TYPE_STORAGE_BUFFER), + ("VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC", + pure VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC), + ("VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC", + pure VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC), + ("VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT", + pure VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT)] + +++ + prec 10 + (expectP (Ident "VkDescriptorType") >> + (VkDescriptorType <$> step readPrec))) + +pattern VK_DESCRIPTOR_TYPE_SAMPLER :: VkDescriptorType + +pattern VK_DESCRIPTOR_TYPE_SAMPLER = VkDescriptorType 0 + +pattern VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER :: + VkDescriptorType + +pattern VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER = + VkDescriptorType 1 + +pattern VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE :: VkDescriptorType + +pattern VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE = VkDescriptorType 2 + +pattern VK_DESCRIPTOR_TYPE_STORAGE_IMAGE :: VkDescriptorType + +pattern VK_DESCRIPTOR_TYPE_STORAGE_IMAGE = VkDescriptorType 3 + +pattern VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER :: VkDescriptorType + +pattern VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER = + VkDescriptorType 4 + +pattern VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER :: VkDescriptorType + +pattern VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER = + VkDescriptorType 5 + +pattern VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER :: VkDescriptorType + +pattern VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER = VkDescriptorType 6 + +pattern VK_DESCRIPTOR_TYPE_STORAGE_BUFFER :: VkDescriptorType + +pattern VK_DESCRIPTOR_TYPE_STORAGE_BUFFER = VkDescriptorType 7 + +pattern VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC :: + VkDescriptorType + +pattern VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC = + VkDescriptorType 8 + +pattern VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC :: + VkDescriptorType + +pattern VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC = + VkDescriptorType 9 + +pattern VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT :: VkDescriptorType + +pattern VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT = VkDescriptorType 10 diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkDescriptorUpdateTemplateTypeKHR.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkDescriptorUpdateTemplateTypeKHR.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkDescriptorUpdateTemplateTypeKHR.hs @@ -0,0 +1,65 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +module Graphics.Vulkan.Types.Enum.VkDescriptorUpdateTemplateTypeKHR + (VkDescriptorUpdateTemplateTypeKHR(VkDescriptorUpdateTemplateTypeKHR, + VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET_KHR, + VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR)) + where +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (Int32) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +-- | type = @enum@ +-- +-- +newtype VkDescriptorUpdateTemplateTypeKHR = VkDescriptorUpdateTemplateTypeKHR Int32 + deriving (Eq, Ord, Num, Bounded, Storable, Enum, Data, + Generic) + +instance Show VkDescriptorUpdateTemplateTypeKHR where + showsPrec _ VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET_KHR + = showString + "VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET_KHR" + showsPrec _ VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR + = showString + "VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR" + showsPrec p (VkDescriptorUpdateTemplateTypeKHR x) + = showParen (p >= 11) + (showString "VkDescriptorUpdateTemplateTypeKHR " . showsPrec 11 x) + +instance Read VkDescriptorUpdateTemplateTypeKHR where + readPrec + = parens + (choose + [("VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET_KHR", + pure VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET_KHR), + ("VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR", + pure VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR)] + +++ + prec 10 + (expectP (Ident "VkDescriptorUpdateTemplateTypeKHR") >> + (VkDescriptorUpdateTemplateTypeKHR <$> step readPrec))) + +-- | Create descriptor update template for descriptor set updates +pattern VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET_KHR :: + VkDescriptorUpdateTemplateTypeKHR + +pattern VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET_KHR = + VkDescriptorUpdateTemplateTypeKHR 0 + +-- | Create descriptor update template for pushed descriptor updates +pattern VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR :: + VkDescriptorUpdateTemplateTypeKHR + +pattern VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR = + VkDescriptorUpdateTemplateTypeKHR 1 diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkDeviceCreateFlagBits.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkDeviceCreateFlagBits.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkDeviceCreateFlagBits.hs @@ -0,0 +1,25 @@ +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE Strict #-} +module Graphics.Vulkan.Types.Enum.VkDeviceCreateFlagBits + (VkDeviceCreateFlagBits(..)) where +import Data.Bits (Bits, FiniteBits) +import Data.Coerce (coerce) +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import Graphics.Vulkan.Types.BaseTypes (VkFlags) + +newtype VkDeviceCreateFlagBits = VkDeviceCreateFlagBits VkFlags + deriving (Eq, Ord, Num, Bounded, Enum, Integral, Bits, + FiniteBits, Storable, Real, Data, Generic) + +instance Show VkDeviceCreateFlagBits where + {-# INLINE show #-} + show (VkDeviceCreateFlagBits x) = show x + +instance Read VkDeviceCreateFlagBits where + {-# INLINE readsPrec #-} + readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags) diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkDeviceEventTypeEXT.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkDeviceEventTypeEXT.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkDeviceEventTypeEXT.hs @@ -0,0 +1,49 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +module Graphics.Vulkan.Types.Enum.VkDeviceEventTypeEXT + (VkDeviceEventTypeEXT(VkDeviceEventTypeEXT, + VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT)) + where +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (Int32) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +-- | type = @enum@ +-- +-- +newtype VkDeviceEventTypeEXT = VkDeviceEventTypeEXT Int32 + deriving (Eq, Ord, Num, Bounded, Storable, Enum, Data, Generic) + +instance Show VkDeviceEventTypeEXT where + showsPrec _ VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT + = showString "VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT" + showsPrec p (VkDeviceEventTypeEXT x) + = showParen (p >= 11) + (showString "VkDeviceEventTypeEXT " . showsPrec 11 x) + +instance Read VkDeviceEventTypeEXT where + readPrec + = parens + (choose + [("VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT", + pure VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT)] + +++ + prec 10 + (expectP (Ident "VkDeviceEventTypeEXT") >> + (VkDeviceEventTypeEXT <$> step readPrec))) + +pattern VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT :: + VkDeviceEventTypeEXT + +pattern VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT = + VkDeviceEventTypeEXT 0 diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkDeviceGroupPresentModeFlagsKHX.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkDeviceGroupPresentModeFlagsKHX.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkDeviceGroupPresentModeFlagsKHX.hs @@ -0,0 +1,142 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE KindSignatures #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE StandaloneDeriving #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeSynonymInstances #-} +module Graphics.Vulkan.Types.Enum.VkDeviceGroupPresentModeFlagsKHX + (VkDeviceGroupPresentModeBitmaskKHX(VkDeviceGroupPresentModeBitmaskKHX, + VkDeviceGroupPresentModeFlagsKHX, + VkDeviceGroupPresentModeFlagBitsKHX, + VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHX, + VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHX, + VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHX, + VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHX), + VkDeviceGroupPresentModeFlagsKHX, + VkDeviceGroupPresentModeFlagBitsKHX) + where +import Data.Bits (Bits, FiniteBits) +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (FlagBit, FlagMask, FlagType) +import Graphics.Vulkan.Types.BaseTypes (VkFlags (..)) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +newtype VkDeviceGroupPresentModeBitmaskKHX (a :: + FlagType) = VkDeviceGroupPresentModeBitmaskKHX VkFlags + deriving (Eq, Ord, Storable, Data, + Generic) + +type VkDeviceGroupPresentModeFlagsKHX = + VkDeviceGroupPresentModeBitmaskKHX FlagMask + +type VkDeviceGroupPresentModeFlagBitsKHX = + VkDeviceGroupPresentModeBitmaskKHX FlagBit + +pattern VkDeviceGroupPresentModeFlagBitsKHX :: + VkFlags -> VkDeviceGroupPresentModeBitmaskKHX FlagBit + +pattern VkDeviceGroupPresentModeFlagBitsKHX n = + VkDeviceGroupPresentModeBitmaskKHX n + +pattern VkDeviceGroupPresentModeFlagsKHX :: + VkFlags -> VkDeviceGroupPresentModeBitmaskKHX FlagMask + +pattern VkDeviceGroupPresentModeFlagsKHX n = + VkDeviceGroupPresentModeBitmaskKHX n + +deriving instance + Bits (VkDeviceGroupPresentModeBitmaskKHX FlagMask) + +deriving instance + FiniteBits (VkDeviceGroupPresentModeBitmaskKHX FlagMask) + +deriving instance + Integral (VkDeviceGroupPresentModeBitmaskKHX FlagMask) + +deriving instance Num (VkDeviceGroupPresentModeBitmaskKHX FlagMask) + +deriving instance + Bounded (VkDeviceGroupPresentModeBitmaskKHX FlagMask) + +deriving instance + Enum (VkDeviceGroupPresentModeBitmaskKHX FlagMask) + +deriving instance + Real (VkDeviceGroupPresentModeBitmaskKHX FlagMask) + +instance Show (VkDeviceGroupPresentModeBitmaskKHX a) where + showsPrec _ VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHX + = showString "VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHX" + showsPrec _ VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHX + = showString "VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHX" + showsPrec _ VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHX + = showString "VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHX" + showsPrec _ VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHX + = showString + "VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHX" + showsPrec p (VkDeviceGroupPresentModeBitmaskKHX x) + = showParen (p >= 11) + (showString "VkDeviceGroupPresentModeBitmaskKHX " . showsPrec 11 x) + +instance Read (VkDeviceGroupPresentModeBitmaskKHX a) where + readPrec + = parens + (choose + [("VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHX", + pure VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHX), + ("VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHX", + pure VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHX), + ("VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHX", + pure VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHX), + ("VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHX", + pure VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHX)] + +++ + prec 10 + (expectP (Ident "VkDeviceGroupPresentModeBitmaskKHX") >> + (VkDeviceGroupPresentModeBitmaskKHX <$> step readPrec))) + +-- | Present from local memory +-- +-- bitpos = @0@ +pattern VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHX :: + VkDeviceGroupPresentModeBitmaskKHX a + +pattern VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHX = + VkDeviceGroupPresentModeBitmaskKHX 1 + +-- | Present from remote memory +-- +-- bitpos = @1@ +pattern VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHX :: + VkDeviceGroupPresentModeBitmaskKHX a + +pattern VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHX = + VkDeviceGroupPresentModeBitmaskKHX 2 + +-- | Present sum of local and/or remote memory +-- +-- bitpos = @2@ +pattern VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHX :: + VkDeviceGroupPresentModeBitmaskKHX a + +pattern VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHX = + VkDeviceGroupPresentModeBitmaskKHX 4 + +-- | Each physical device presents from local memory +-- +-- bitpos = @3@ +pattern VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHX :: + VkDeviceGroupPresentModeBitmaskKHX a + +pattern VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHX = + VkDeviceGroupPresentModeBitmaskKHX 8 diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkDeviceQueueCreateFlagBits.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkDeviceQueueCreateFlagBits.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkDeviceQueueCreateFlagBits.hs @@ -0,0 +1,25 @@ +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE Strict #-} +module Graphics.Vulkan.Types.Enum.VkDeviceQueueCreateFlagBits + (VkDeviceQueueCreateFlagBits(..)) where +import Data.Bits (Bits, FiniteBits) +import Data.Coerce (coerce) +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import Graphics.Vulkan.Types.BaseTypes (VkFlags) + +newtype VkDeviceQueueCreateFlagBits = VkDeviceQueueCreateFlagBits VkFlags + deriving (Eq, Ord, Num, Bounded, Enum, Integral, Bits, + FiniteBits, Storable, Real, Data, Generic) + +instance Show VkDeviceQueueCreateFlagBits where + {-# INLINE show #-} + show (VkDeviceQueueCreateFlagBits x) = show x + +instance Read VkDeviceQueueCreateFlagBits where + {-# INLINE readsPrec #-} + readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags) diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkDiscardRectangleModeEXT.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkDiscardRectangleModeEXT.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkDiscardRectangleModeEXT.hs @@ -0,0 +1,61 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +module Graphics.Vulkan.Types.Enum.VkDiscardRectangleModeEXT + (VkDiscardRectangleModeEXT(VkDiscardRectangleModeEXT, + VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT, + VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT)) + where +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (Int32) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +-- | type = @enum@ +-- +-- +newtype VkDiscardRectangleModeEXT = VkDiscardRectangleModeEXT Int32 + deriving (Eq, Ord, Num, Bounded, Storable, Enum, Data, + Generic) + +instance Show VkDiscardRectangleModeEXT where + showsPrec _ VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT + = showString "VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT" + showsPrec _ VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT + = showString "VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT" + showsPrec p (VkDiscardRectangleModeEXT x) + = showParen (p >= 11) + (showString "VkDiscardRectangleModeEXT " . showsPrec 11 x) + +instance Read VkDiscardRectangleModeEXT where + readPrec + = parens + (choose + [("VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT", + pure VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT), + ("VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT", + pure VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT)] + +++ + prec 10 + (expectP (Ident "VkDiscardRectangleModeEXT") >> + (VkDiscardRectangleModeEXT <$> step readPrec))) + +pattern VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT :: + VkDiscardRectangleModeEXT + +pattern VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT = + VkDiscardRectangleModeEXT 0 + +pattern VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT :: + VkDiscardRectangleModeEXT + +pattern VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT = + VkDiscardRectangleModeEXT 1 diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkDisplayEventTypeEXT.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkDisplayEventTypeEXT.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkDisplayEventTypeEXT.hs @@ -0,0 +1,49 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +module Graphics.Vulkan.Types.Enum.VkDisplayEventTypeEXT + (VkDisplayEventTypeEXT(VkDisplayEventTypeEXT, + VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT)) + where +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (Int32) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +-- | type = @enum@ +-- +-- +newtype VkDisplayEventTypeEXT = VkDisplayEventTypeEXT Int32 + deriving (Eq, Ord, Num, Bounded, Storable, Enum, Data, Generic) + +instance Show VkDisplayEventTypeEXT where + showsPrec _ VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT + = showString "VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT" + showsPrec p (VkDisplayEventTypeEXT x) + = showParen (p >= 11) + (showString "VkDisplayEventTypeEXT " . showsPrec 11 x) + +instance Read VkDisplayEventTypeEXT where + readPrec + = parens + (choose + [("VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT", + pure VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT)] + +++ + prec 10 + (expectP (Ident "VkDisplayEventTypeEXT") >> + (VkDisplayEventTypeEXT <$> step readPrec))) + +pattern VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT :: + VkDisplayEventTypeEXT + +pattern VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT = + VkDisplayEventTypeEXT 0 diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkDisplayPlaneAlphaFlagsKHR.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkDisplayPlaneAlphaFlagsKHR.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkDisplayPlaneAlphaFlagsKHR.hs @@ -0,0 +1,126 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE KindSignatures #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE StandaloneDeriving #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeSynonymInstances #-} +module Graphics.Vulkan.Types.Enum.VkDisplayPlaneAlphaFlagsKHR + (VkDisplayPlaneAlphaBitmaskKHR(VkDisplayPlaneAlphaBitmaskKHR, + VkDisplayPlaneAlphaFlagsKHR, VkDisplayPlaneAlphaFlagBitsKHR, + VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR, + VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR, + VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR, + VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR), + VkDisplayPlaneAlphaFlagsKHR, VkDisplayPlaneAlphaFlagBitsKHR) + where +import Data.Bits (Bits, FiniteBits) +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (FlagBit, FlagMask, FlagType) +import Graphics.Vulkan.Types.BaseTypes (VkFlags (..)) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +newtype VkDisplayPlaneAlphaBitmaskKHR (a :: + FlagType) = VkDisplayPlaneAlphaBitmaskKHR VkFlags + deriving (Eq, Ord, Storable, Data, Generic) + +type VkDisplayPlaneAlphaFlagsKHR = + VkDisplayPlaneAlphaBitmaskKHR FlagMask + +type VkDisplayPlaneAlphaFlagBitsKHR = + VkDisplayPlaneAlphaBitmaskKHR FlagBit + +pattern VkDisplayPlaneAlphaFlagBitsKHR :: + VkFlags -> VkDisplayPlaneAlphaBitmaskKHR FlagBit + +pattern VkDisplayPlaneAlphaFlagBitsKHR n = + VkDisplayPlaneAlphaBitmaskKHR n + +pattern VkDisplayPlaneAlphaFlagsKHR :: + VkFlags -> VkDisplayPlaneAlphaBitmaskKHR FlagMask + +pattern VkDisplayPlaneAlphaFlagsKHR n = + VkDisplayPlaneAlphaBitmaskKHR n + +deriving instance Bits (VkDisplayPlaneAlphaBitmaskKHR FlagMask) + +deriving instance + FiniteBits (VkDisplayPlaneAlphaBitmaskKHR FlagMask) + +deriving instance Integral (VkDisplayPlaneAlphaBitmaskKHR FlagMask) + +deriving instance Num (VkDisplayPlaneAlphaBitmaskKHR FlagMask) + +deriving instance Bounded (VkDisplayPlaneAlphaBitmaskKHR FlagMask) + +deriving instance Enum (VkDisplayPlaneAlphaBitmaskKHR FlagMask) + +deriving instance Real (VkDisplayPlaneAlphaBitmaskKHR FlagMask) + +instance Show (VkDisplayPlaneAlphaBitmaskKHR a) where + showsPrec _ VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR + = showString "VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR" + showsPrec _ VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR + = showString "VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR" + showsPrec _ VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR + = showString "VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR" + showsPrec _ VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR + = showString + "VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR" + showsPrec p (VkDisplayPlaneAlphaBitmaskKHR x) + = showParen (p >= 11) + (showString "VkDisplayPlaneAlphaBitmaskKHR " . showsPrec 11 x) + +instance Read (VkDisplayPlaneAlphaBitmaskKHR a) where + readPrec + = parens + (choose + [("VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR", + pure VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR), + ("VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR", + pure VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR), + ("VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR", + pure VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR), + ("VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR", + pure VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR)] + +++ + prec 10 + (expectP (Ident "VkDisplayPlaneAlphaBitmaskKHR") >> + (VkDisplayPlaneAlphaBitmaskKHR <$> step readPrec))) + +-- | bitpos = @0@ +pattern VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR :: + VkDisplayPlaneAlphaBitmaskKHR a + +pattern VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR = + VkDisplayPlaneAlphaBitmaskKHR 1 + +-- | bitpos = @1@ +pattern VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR :: + VkDisplayPlaneAlphaBitmaskKHR a + +pattern VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR = + VkDisplayPlaneAlphaBitmaskKHR 2 + +-- | bitpos = @2@ +pattern VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR :: + VkDisplayPlaneAlphaBitmaskKHR a + +pattern VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR = + VkDisplayPlaneAlphaBitmaskKHR 4 + +-- | bitpos = @3@ +pattern VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR :: + VkDisplayPlaneAlphaBitmaskKHR a + +pattern VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR = + VkDisplayPlaneAlphaBitmaskKHR 8 diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkDisplayPowerStateEXT.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkDisplayPowerStateEXT.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkDisplayPowerStateEXT.hs @@ -0,0 +1,66 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +module Graphics.Vulkan.Types.Enum.VkDisplayPowerStateEXT + (VkDisplayPowerStateEXT(VkDisplayPowerStateEXT, + VK_DISPLAY_POWER_STATE_OFF_EXT, VK_DISPLAY_POWER_STATE_SUSPEND_EXT, + VK_DISPLAY_POWER_STATE_ON_EXT)) + where +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (Int32) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +-- | type = @enum@ +-- +-- +newtype VkDisplayPowerStateEXT = VkDisplayPowerStateEXT Int32 + deriving (Eq, Ord, Num, Bounded, Storable, Enum, Data, Generic) + +instance Show VkDisplayPowerStateEXT where + showsPrec _ VK_DISPLAY_POWER_STATE_OFF_EXT + = showString "VK_DISPLAY_POWER_STATE_OFF_EXT" + showsPrec _ VK_DISPLAY_POWER_STATE_SUSPEND_EXT + = showString "VK_DISPLAY_POWER_STATE_SUSPEND_EXT" + showsPrec _ VK_DISPLAY_POWER_STATE_ON_EXT + = showString "VK_DISPLAY_POWER_STATE_ON_EXT" + showsPrec p (VkDisplayPowerStateEXT x) + = showParen (p >= 11) + (showString "VkDisplayPowerStateEXT " . showsPrec 11 x) + +instance Read VkDisplayPowerStateEXT where + readPrec + = parens + (choose + [("VK_DISPLAY_POWER_STATE_OFF_EXT", + pure VK_DISPLAY_POWER_STATE_OFF_EXT), + ("VK_DISPLAY_POWER_STATE_SUSPEND_EXT", + pure VK_DISPLAY_POWER_STATE_SUSPEND_EXT), + ("VK_DISPLAY_POWER_STATE_ON_EXT", + pure VK_DISPLAY_POWER_STATE_ON_EXT)] + +++ + prec 10 + (expectP (Ident "VkDisplayPowerStateEXT") >> + (VkDisplayPowerStateEXT <$> step readPrec))) + +pattern VK_DISPLAY_POWER_STATE_OFF_EXT :: VkDisplayPowerStateEXT + +pattern VK_DISPLAY_POWER_STATE_OFF_EXT = VkDisplayPowerStateEXT 0 + +pattern VK_DISPLAY_POWER_STATE_SUSPEND_EXT :: + VkDisplayPowerStateEXT + +pattern VK_DISPLAY_POWER_STATE_SUSPEND_EXT = + VkDisplayPowerStateEXT 1 + +pattern VK_DISPLAY_POWER_STATE_ON_EXT :: VkDisplayPowerStateEXT + +pattern VK_DISPLAY_POWER_STATE_ON_EXT = VkDisplayPowerStateEXT 2 diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkDynamicState.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkDynamicState.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkDynamicState.hs @@ -0,0 +1,112 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +module Graphics.Vulkan.Types.Enum.VkDynamicState + (VkDynamicState(VkDynamicState, VK_DYNAMIC_STATE_VIEWPORT, + VK_DYNAMIC_STATE_SCISSOR, VK_DYNAMIC_STATE_LINE_WIDTH, + VK_DYNAMIC_STATE_DEPTH_BIAS, VK_DYNAMIC_STATE_BLEND_CONSTANTS, + VK_DYNAMIC_STATE_DEPTH_BOUNDS, + VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK, + VK_DYNAMIC_STATE_STENCIL_WRITE_MASK, + VK_DYNAMIC_STATE_STENCIL_REFERENCE)) + where +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (Int32) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +-- | type = @enum@ +-- +-- +newtype VkDynamicState = VkDynamicState Int32 + deriving (Eq, Ord, Num, Bounded, Storable, Enum, Data, Generic) + +instance Show VkDynamicState where + showsPrec _ VK_DYNAMIC_STATE_VIEWPORT + = showString "VK_DYNAMIC_STATE_VIEWPORT" + showsPrec _ VK_DYNAMIC_STATE_SCISSOR + = showString "VK_DYNAMIC_STATE_SCISSOR" + showsPrec _ VK_DYNAMIC_STATE_LINE_WIDTH + = showString "VK_DYNAMIC_STATE_LINE_WIDTH" + showsPrec _ VK_DYNAMIC_STATE_DEPTH_BIAS + = showString "VK_DYNAMIC_STATE_DEPTH_BIAS" + showsPrec _ VK_DYNAMIC_STATE_BLEND_CONSTANTS + = showString "VK_DYNAMIC_STATE_BLEND_CONSTANTS" + showsPrec _ VK_DYNAMIC_STATE_DEPTH_BOUNDS + = showString "VK_DYNAMIC_STATE_DEPTH_BOUNDS" + showsPrec _ VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK + = showString "VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK" + showsPrec _ VK_DYNAMIC_STATE_STENCIL_WRITE_MASK + = showString "VK_DYNAMIC_STATE_STENCIL_WRITE_MASK" + showsPrec _ VK_DYNAMIC_STATE_STENCIL_REFERENCE + = showString "VK_DYNAMIC_STATE_STENCIL_REFERENCE" + showsPrec p (VkDynamicState x) + = showParen (p >= 11) + (showString "VkDynamicState " . showsPrec 11 x) + +instance Read VkDynamicState where + readPrec + = parens + (choose + [("VK_DYNAMIC_STATE_VIEWPORT", pure VK_DYNAMIC_STATE_VIEWPORT), + ("VK_DYNAMIC_STATE_SCISSOR", pure VK_DYNAMIC_STATE_SCISSOR), + ("VK_DYNAMIC_STATE_LINE_WIDTH", pure VK_DYNAMIC_STATE_LINE_WIDTH), + ("VK_DYNAMIC_STATE_DEPTH_BIAS", pure VK_DYNAMIC_STATE_DEPTH_BIAS), + ("VK_DYNAMIC_STATE_BLEND_CONSTANTS", + pure VK_DYNAMIC_STATE_BLEND_CONSTANTS), + ("VK_DYNAMIC_STATE_DEPTH_BOUNDS", + pure VK_DYNAMIC_STATE_DEPTH_BOUNDS), + ("VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK", + pure VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK), + ("VK_DYNAMIC_STATE_STENCIL_WRITE_MASK", + pure VK_DYNAMIC_STATE_STENCIL_WRITE_MASK), + ("VK_DYNAMIC_STATE_STENCIL_REFERENCE", + pure VK_DYNAMIC_STATE_STENCIL_REFERENCE)] + +++ + prec 10 + (expectP (Ident "VkDynamicState") >> + (VkDynamicState <$> step readPrec))) + +pattern VK_DYNAMIC_STATE_VIEWPORT :: VkDynamicState + +pattern VK_DYNAMIC_STATE_VIEWPORT = VkDynamicState 0 + +pattern VK_DYNAMIC_STATE_SCISSOR :: VkDynamicState + +pattern VK_DYNAMIC_STATE_SCISSOR = VkDynamicState 1 + +pattern VK_DYNAMIC_STATE_LINE_WIDTH :: VkDynamicState + +pattern VK_DYNAMIC_STATE_LINE_WIDTH = VkDynamicState 2 + +pattern VK_DYNAMIC_STATE_DEPTH_BIAS :: VkDynamicState + +pattern VK_DYNAMIC_STATE_DEPTH_BIAS = VkDynamicState 3 + +pattern VK_DYNAMIC_STATE_BLEND_CONSTANTS :: VkDynamicState + +pattern VK_DYNAMIC_STATE_BLEND_CONSTANTS = VkDynamicState 4 + +pattern VK_DYNAMIC_STATE_DEPTH_BOUNDS :: VkDynamicState + +pattern VK_DYNAMIC_STATE_DEPTH_BOUNDS = VkDynamicState 5 + +pattern VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK :: VkDynamicState + +pattern VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK = VkDynamicState 6 + +pattern VK_DYNAMIC_STATE_STENCIL_WRITE_MASK :: VkDynamicState + +pattern VK_DYNAMIC_STATE_STENCIL_WRITE_MASK = VkDynamicState 7 + +pattern VK_DYNAMIC_STATE_STENCIL_REFERENCE :: VkDynamicState + +pattern VK_DYNAMIC_STATE_STENCIL_REFERENCE = VkDynamicState 8 diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkExternalFenceFeatureFlagsKHR.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkExternalFenceFeatureFlagsKHR.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkExternalFenceFeatureFlagsKHR.hs @@ -0,0 +1,105 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE KindSignatures #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE StandaloneDeriving #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeSynonymInstances #-} +module Graphics.Vulkan.Types.Enum.VkExternalFenceFeatureFlagsKHR + (VkExternalFenceFeatureBitmaskKHR(VkExternalFenceFeatureBitmaskKHR, + VkExternalFenceFeatureFlagsKHR, + VkExternalFenceFeatureFlagBitsKHR, + VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT_KHR, + VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT_KHR), + VkExternalFenceFeatureFlagsKHR, VkExternalFenceFeatureFlagBitsKHR) + where +import Data.Bits (Bits, FiniteBits) +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (FlagBit, FlagMask, FlagType) +import Graphics.Vulkan.Types.BaseTypes (VkFlags (..)) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +newtype VkExternalFenceFeatureBitmaskKHR (a :: + FlagType) = VkExternalFenceFeatureBitmaskKHR VkFlags + deriving (Eq, Ord, Storable, Data, + Generic) + +type VkExternalFenceFeatureFlagsKHR = + VkExternalFenceFeatureBitmaskKHR FlagMask + +type VkExternalFenceFeatureFlagBitsKHR = + VkExternalFenceFeatureBitmaskKHR FlagBit + +pattern VkExternalFenceFeatureFlagBitsKHR :: + VkFlags -> VkExternalFenceFeatureBitmaskKHR FlagBit + +pattern VkExternalFenceFeatureFlagBitsKHR n = + VkExternalFenceFeatureBitmaskKHR n + +pattern VkExternalFenceFeatureFlagsKHR :: + VkFlags -> VkExternalFenceFeatureBitmaskKHR FlagMask + +pattern VkExternalFenceFeatureFlagsKHR n = + VkExternalFenceFeatureBitmaskKHR n + +deriving instance Bits (VkExternalFenceFeatureBitmaskKHR FlagMask) + +deriving instance + FiniteBits (VkExternalFenceFeatureBitmaskKHR FlagMask) + +deriving instance + Integral (VkExternalFenceFeatureBitmaskKHR FlagMask) + +deriving instance Num (VkExternalFenceFeatureBitmaskKHR FlagMask) + +deriving instance + Bounded (VkExternalFenceFeatureBitmaskKHR FlagMask) + +deriving instance Enum (VkExternalFenceFeatureBitmaskKHR FlagMask) + +deriving instance Real (VkExternalFenceFeatureBitmaskKHR FlagMask) + +instance Show (VkExternalFenceFeatureBitmaskKHR a) where + showsPrec _ VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT_KHR + = showString "VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT_KHR" + showsPrec _ VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT_KHR + = showString "VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT_KHR" + showsPrec p (VkExternalFenceFeatureBitmaskKHR x) + = showParen (p >= 11) + (showString "VkExternalFenceFeatureBitmaskKHR " . showsPrec 11 x) + +instance Read (VkExternalFenceFeatureBitmaskKHR a) where + readPrec + = parens + (choose + [("VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT_KHR", + pure VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT_KHR), + ("VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT_KHR", + pure VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT_KHR)] + +++ + prec 10 + (expectP (Ident "VkExternalFenceFeatureBitmaskKHR") >> + (VkExternalFenceFeatureBitmaskKHR <$> step readPrec))) + +-- | bitpos = @0@ +pattern VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT_KHR :: + VkExternalFenceFeatureBitmaskKHR a + +pattern VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT_KHR = + VkExternalFenceFeatureBitmaskKHR 1 + +-- | bitpos = @1@ +pattern VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT_KHR :: + VkExternalFenceFeatureBitmaskKHR a + +pattern VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT_KHR = + VkExternalFenceFeatureBitmaskKHR 2 diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkExternalFenceHandleTypeFlagsKHR.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkExternalFenceHandleTypeFlagsKHR.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkExternalFenceHandleTypeFlagsKHR.hs @@ -0,0 +1,136 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE KindSignatures #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE StandaloneDeriving #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeSynonymInstances #-} +module Graphics.Vulkan.Types.Enum.VkExternalFenceHandleTypeFlagsKHR + (VkExternalFenceHandleTypeBitmaskKHR(VkExternalFenceHandleTypeBitmaskKHR, + VkExternalFenceHandleTypeFlagsKHR, + VkExternalFenceHandleTypeFlagBitsKHR, + VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR, + VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR, + VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR, + VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT_KHR), + VkExternalFenceHandleTypeFlagsKHR, + VkExternalFenceHandleTypeFlagBitsKHR) + where +import Data.Bits (Bits, FiniteBits) +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (FlagBit, FlagMask, FlagType) +import Graphics.Vulkan.Types.BaseTypes (VkFlags (..)) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +newtype VkExternalFenceHandleTypeBitmaskKHR (a :: + FlagType) = VkExternalFenceHandleTypeBitmaskKHR VkFlags + deriving (Eq, Ord, Storable, Data, + Generic) + +type VkExternalFenceHandleTypeFlagsKHR = + VkExternalFenceHandleTypeBitmaskKHR FlagMask + +type VkExternalFenceHandleTypeFlagBitsKHR = + VkExternalFenceHandleTypeBitmaskKHR FlagBit + +pattern VkExternalFenceHandleTypeFlagBitsKHR :: + VkFlags -> VkExternalFenceHandleTypeBitmaskKHR FlagBit + +pattern VkExternalFenceHandleTypeFlagBitsKHR n = + VkExternalFenceHandleTypeBitmaskKHR n + +pattern VkExternalFenceHandleTypeFlagsKHR :: + VkFlags -> VkExternalFenceHandleTypeBitmaskKHR FlagMask + +pattern VkExternalFenceHandleTypeFlagsKHR n = + VkExternalFenceHandleTypeBitmaskKHR n + +deriving instance + Bits (VkExternalFenceHandleTypeBitmaskKHR FlagMask) + +deriving instance + FiniteBits (VkExternalFenceHandleTypeBitmaskKHR FlagMask) + +deriving instance + Integral (VkExternalFenceHandleTypeBitmaskKHR FlagMask) + +deriving instance + Num (VkExternalFenceHandleTypeBitmaskKHR FlagMask) + +deriving instance + Bounded (VkExternalFenceHandleTypeBitmaskKHR FlagMask) + +deriving instance + Enum (VkExternalFenceHandleTypeBitmaskKHR FlagMask) + +deriving instance + Real (VkExternalFenceHandleTypeBitmaskKHR FlagMask) + +instance Show (VkExternalFenceHandleTypeBitmaskKHR a) where + showsPrec _ VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR + = showString "VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR" + showsPrec _ VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR + = showString "VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR" + showsPrec _ VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR + = showString + "VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR" + showsPrec _ VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT_KHR + = showString "VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT_KHR" + showsPrec p (VkExternalFenceHandleTypeBitmaskKHR x) + = showParen (p >= 11) + (showString "VkExternalFenceHandleTypeBitmaskKHR " . + showsPrec 11 x) + +instance Read (VkExternalFenceHandleTypeBitmaskKHR a) where + readPrec + = parens + (choose + [("VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR", + pure VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR), + ("VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR", + pure VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR), + ("VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR", + pure VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR), + ("VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT_KHR", + pure VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT_KHR)] + +++ + prec 10 + (expectP (Ident "VkExternalFenceHandleTypeBitmaskKHR") >> + (VkExternalFenceHandleTypeBitmaskKHR <$> step readPrec))) + +-- | bitpos = @0@ +pattern VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR :: + VkExternalFenceHandleTypeBitmaskKHR a + +pattern VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR = + VkExternalFenceHandleTypeBitmaskKHR 1 + +-- | bitpos = @1@ +pattern VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR :: + VkExternalFenceHandleTypeBitmaskKHR a + +pattern VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR = + VkExternalFenceHandleTypeBitmaskKHR 2 + +-- | bitpos = @2@ +pattern VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR :: + VkExternalFenceHandleTypeBitmaskKHR a + +pattern VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR = + VkExternalFenceHandleTypeBitmaskKHR 4 + +-- | bitpos = @3@ +pattern VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT_KHR :: + VkExternalFenceHandleTypeBitmaskKHR a + +pattern VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT_KHR = + VkExternalFenceHandleTypeBitmaskKHR 8 diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkExternalMemoryFeatureFlagsKHR.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkExternalMemoryFeatureFlagsKHR.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkExternalMemoryFeatureFlagsKHR.hs @@ -0,0 +1,118 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE KindSignatures #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE StandaloneDeriving #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeSynonymInstances #-} +module Graphics.Vulkan.Types.Enum.VkExternalMemoryFeatureFlagsKHR + (VkExternalMemoryFeatureBitmaskKHR(VkExternalMemoryFeatureBitmaskKHR, + VkExternalMemoryFeatureFlagsKHR, + VkExternalMemoryFeatureFlagBitsKHR, + VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHR, + VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHR, + VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHR), + VkExternalMemoryFeatureFlagsKHR, + VkExternalMemoryFeatureFlagBitsKHR) + where +import Data.Bits (Bits, FiniteBits) +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (FlagBit, FlagMask, FlagType) +import Graphics.Vulkan.Types.BaseTypes (VkFlags (..)) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +newtype VkExternalMemoryFeatureBitmaskKHR (a :: + FlagType) = VkExternalMemoryFeatureBitmaskKHR VkFlags + deriving (Eq, Ord, Storable, Data, + Generic) + +type VkExternalMemoryFeatureFlagsKHR = + VkExternalMemoryFeatureBitmaskKHR FlagMask + +type VkExternalMemoryFeatureFlagBitsKHR = + VkExternalMemoryFeatureBitmaskKHR FlagBit + +pattern VkExternalMemoryFeatureFlagBitsKHR :: + VkFlags -> VkExternalMemoryFeatureBitmaskKHR FlagBit + +pattern VkExternalMemoryFeatureFlagBitsKHR n = + VkExternalMemoryFeatureBitmaskKHR n + +pattern VkExternalMemoryFeatureFlagsKHR :: + VkFlags -> VkExternalMemoryFeatureBitmaskKHR FlagMask + +pattern VkExternalMemoryFeatureFlagsKHR n = + VkExternalMemoryFeatureBitmaskKHR n + +deriving instance Bits (VkExternalMemoryFeatureBitmaskKHR FlagMask) + +deriving instance + FiniteBits (VkExternalMemoryFeatureBitmaskKHR FlagMask) + +deriving instance + Integral (VkExternalMemoryFeatureBitmaskKHR FlagMask) + +deriving instance Num (VkExternalMemoryFeatureBitmaskKHR FlagMask) + +deriving instance + Bounded (VkExternalMemoryFeatureBitmaskKHR FlagMask) + +deriving instance Enum (VkExternalMemoryFeatureBitmaskKHR FlagMask) + +deriving instance Real (VkExternalMemoryFeatureBitmaskKHR FlagMask) + +instance Show (VkExternalMemoryFeatureBitmaskKHR a) where + showsPrec _ VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHR + = showString "VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHR" + showsPrec _ VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHR + = showString "VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHR" + showsPrec _ VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHR + = showString "VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHR" + showsPrec p (VkExternalMemoryFeatureBitmaskKHR x) + = showParen (p >= 11) + (showString "VkExternalMemoryFeatureBitmaskKHR " . showsPrec 11 x) + +instance Read (VkExternalMemoryFeatureBitmaskKHR a) where + readPrec + = parens + (choose + [("VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHR", + pure VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHR), + ("VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHR", + pure VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHR), + ("VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHR", + pure VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHR)] + +++ + prec 10 + (expectP (Ident "VkExternalMemoryFeatureBitmaskKHR") >> + (VkExternalMemoryFeatureBitmaskKHR <$> step readPrec))) + +-- | bitpos = @0@ +pattern VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHR :: + VkExternalMemoryFeatureBitmaskKHR a + +pattern VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHR = + VkExternalMemoryFeatureBitmaskKHR 1 + +-- | bitpos = @1@ +pattern VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHR :: + VkExternalMemoryFeatureBitmaskKHR a + +pattern VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHR = + VkExternalMemoryFeatureBitmaskKHR 2 + +-- | bitpos = @2@ +pattern VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHR :: + VkExternalMemoryFeatureBitmaskKHR a + +pattern VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHR = + VkExternalMemoryFeatureBitmaskKHR 4 diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkExternalMemoryFeatureFlagsNV.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkExternalMemoryFeatureFlagsNV.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkExternalMemoryFeatureFlagsNV.hs @@ -0,0 +1,117 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE KindSignatures #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE StandaloneDeriving #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeSynonymInstances #-} +module Graphics.Vulkan.Types.Enum.VkExternalMemoryFeatureFlagsNV + (VkExternalMemoryFeatureBitmaskNV(VkExternalMemoryFeatureBitmaskNV, + VkExternalMemoryFeatureFlagsNV, + VkExternalMemoryFeatureFlagBitsNV, + VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_NV, + VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_NV, + VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_NV), + VkExternalMemoryFeatureFlagsNV, VkExternalMemoryFeatureFlagBitsNV) + where +import Data.Bits (Bits, FiniteBits) +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (FlagBit, FlagMask, FlagType) +import Graphics.Vulkan.Types.BaseTypes (VkFlags (..)) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +newtype VkExternalMemoryFeatureBitmaskNV (a :: + FlagType) = VkExternalMemoryFeatureBitmaskNV VkFlags + deriving (Eq, Ord, Storable, Data, + Generic) + +type VkExternalMemoryFeatureFlagsNV = + VkExternalMemoryFeatureBitmaskNV FlagMask + +type VkExternalMemoryFeatureFlagBitsNV = + VkExternalMemoryFeatureBitmaskNV FlagBit + +pattern VkExternalMemoryFeatureFlagBitsNV :: + VkFlags -> VkExternalMemoryFeatureBitmaskNV FlagBit + +pattern VkExternalMemoryFeatureFlagBitsNV n = + VkExternalMemoryFeatureBitmaskNV n + +pattern VkExternalMemoryFeatureFlagsNV :: + VkFlags -> VkExternalMemoryFeatureBitmaskNV FlagMask + +pattern VkExternalMemoryFeatureFlagsNV n = + VkExternalMemoryFeatureBitmaskNV n + +deriving instance Bits (VkExternalMemoryFeatureBitmaskNV FlagMask) + +deriving instance + FiniteBits (VkExternalMemoryFeatureBitmaskNV FlagMask) + +deriving instance + Integral (VkExternalMemoryFeatureBitmaskNV FlagMask) + +deriving instance Num (VkExternalMemoryFeatureBitmaskNV FlagMask) + +deriving instance + Bounded (VkExternalMemoryFeatureBitmaskNV FlagMask) + +deriving instance Enum (VkExternalMemoryFeatureBitmaskNV FlagMask) + +deriving instance Real (VkExternalMemoryFeatureBitmaskNV FlagMask) + +instance Show (VkExternalMemoryFeatureBitmaskNV a) where + showsPrec _ VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_NV + = showString "VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_NV" + showsPrec _ VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_NV + = showString "VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_NV" + showsPrec _ VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_NV + = showString "VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_NV" + showsPrec p (VkExternalMemoryFeatureBitmaskNV x) + = showParen (p >= 11) + (showString "VkExternalMemoryFeatureBitmaskNV " . showsPrec 11 x) + +instance Read (VkExternalMemoryFeatureBitmaskNV a) where + readPrec + = parens + (choose + [("VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_NV", + pure VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_NV), + ("VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_NV", + pure VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_NV), + ("VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_NV", + pure VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_NV)] + +++ + prec 10 + (expectP (Ident "VkExternalMemoryFeatureBitmaskNV") >> + (VkExternalMemoryFeatureBitmaskNV <$> step readPrec))) + +-- | bitpos = @0@ +pattern VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_NV :: + VkExternalMemoryFeatureBitmaskNV a + +pattern VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_NV = + VkExternalMemoryFeatureBitmaskNV 1 + +-- | bitpos = @1@ +pattern VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_NV :: + VkExternalMemoryFeatureBitmaskNV a + +pattern VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_NV = + VkExternalMemoryFeatureBitmaskNV 2 + +-- | bitpos = @2@ +pattern VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_NV :: + VkExternalMemoryFeatureBitmaskNV a + +pattern VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_NV = + VkExternalMemoryFeatureBitmaskNV 4 diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkExternalMemoryHandleTypeFlagsKHR.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkExternalMemoryHandleTypeFlagsKHR.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkExternalMemoryHandleTypeFlagsKHR.hs @@ -0,0 +1,175 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE KindSignatures #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE StandaloneDeriving #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeSynonymInstances #-} +module Graphics.Vulkan.Types.Enum.VkExternalMemoryHandleTypeFlagsKHR + (VkExternalMemoryHandleTypeBitmaskKHR(VkExternalMemoryHandleTypeBitmaskKHR, + VkExternalMemoryHandleTypeFlagsKHR, + VkExternalMemoryHandleTypeFlagBitsKHR, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT_KHR, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT_KHR, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT_KHR, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT_KHR), + VkExternalMemoryHandleTypeFlagsKHR, + VkExternalMemoryHandleTypeFlagBitsKHR) + where +import Data.Bits (Bits, FiniteBits) +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (FlagBit, FlagMask, FlagType) +import Graphics.Vulkan.Types.BaseTypes (VkFlags (..)) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +newtype VkExternalMemoryHandleTypeBitmaskKHR (a :: + FlagType) = VkExternalMemoryHandleTypeBitmaskKHR VkFlags + deriving (Eq, Ord, Storable, Data, + Generic) + +type VkExternalMemoryHandleTypeFlagsKHR = + VkExternalMemoryHandleTypeBitmaskKHR FlagMask + +type VkExternalMemoryHandleTypeFlagBitsKHR = + VkExternalMemoryHandleTypeBitmaskKHR FlagBit + +pattern VkExternalMemoryHandleTypeFlagBitsKHR :: + VkFlags -> VkExternalMemoryHandleTypeBitmaskKHR FlagBit + +pattern VkExternalMemoryHandleTypeFlagBitsKHR n = + VkExternalMemoryHandleTypeBitmaskKHR n + +pattern VkExternalMemoryHandleTypeFlagsKHR :: + VkFlags -> VkExternalMemoryHandleTypeBitmaskKHR FlagMask + +pattern VkExternalMemoryHandleTypeFlagsKHR n = + VkExternalMemoryHandleTypeBitmaskKHR n + +deriving instance + Bits (VkExternalMemoryHandleTypeBitmaskKHR FlagMask) + +deriving instance + FiniteBits (VkExternalMemoryHandleTypeBitmaskKHR FlagMask) + +deriving instance + Integral (VkExternalMemoryHandleTypeBitmaskKHR FlagMask) + +deriving instance + Num (VkExternalMemoryHandleTypeBitmaskKHR FlagMask) + +deriving instance + Bounded (VkExternalMemoryHandleTypeBitmaskKHR FlagMask) + +deriving instance + Enum (VkExternalMemoryHandleTypeBitmaskKHR FlagMask) + +deriving instance + Real (VkExternalMemoryHandleTypeBitmaskKHR FlagMask) + +instance Show (VkExternalMemoryHandleTypeBitmaskKHR a) where + showsPrec _ VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR + = showString "VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR" + showsPrec _ VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR + = showString "VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR" + showsPrec _ VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR + = showString + "VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR" + showsPrec _ VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT_KHR + = showString "VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT_KHR" + showsPrec _ + VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT_KHR + = showString + "VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT_KHR" + showsPrec _ VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT_KHR + = showString "VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT_KHR" + showsPrec _ VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT_KHR + = showString + "VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT_KHR" + showsPrec p (VkExternalMemoryHandleTypeBitmaskKHR x) + = showParen (p >= 11) + (showString "VkExternalMemoryHandleTypeBitmaskKHR " . + showsPrec 11 x) + +instance Read (VkExternalMemoryHandleTypeBitmaskKHR a) where + readPrec + = parens + (choose + [("VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR", + pure VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR), + ("VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR", + pure VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR), + ("VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR", + pure VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR), + ("VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT_KHR", + pure VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT_KHR), + ("VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT_KHR", + pure VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT_KHR), + ("VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT_KHR", + pure VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT_KHR), + ("VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT_KHR", + pure VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT_KHR)] + +++ + prec 10 + (expectP (Ident "VkExternalMemoryHandleTypeBitmaskKHR") >> + (VkExternalMemoryHandleTypeBitmaskKHR <$> step readPrec))) + +-- | bitpos = @0@ +pattern VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR :: + VkExternalMemoryHandleTypeBitmaskKHR a + +pattern VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR = + VkExternalMemoryHandleTypeBitmaskKHR 1 + +-- | bitpos = @1@ +pattern VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR :: + VkExternalMemoryHandleTypeBitmaskKHR a + +pattern VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR = + VkExternalMemoryHandleTypeBitmaskKHR 2 + +-- | bitpos = @2@ +pattern VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR :: + VkExternalMemoryHandleTypeBitmaskKHR a + +pattern VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR = + VkExternalMemoryHandleTypeBitmaskKHR 4 + +-- | bitpos = @3@ +pattern VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT_KHR :: + VkExternalMemoryHandleTypeBitmaskKHR a + +pattern VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT_KHR = + VkExternalMemoryHandleTypeBitmaskKHR 8 + +-- | bitpos = @4@ +pattern VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT_KHR :: + VkExternalMemoryHandleTypeBitmaskKHR a + +pattern VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT_KHR = + VkExternalMemoryHandleTypeBitmaskKHR 16 + +-- | bitpos = @5@ +pattern VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT_KHR :: + VkExternalMemoryHandleTypeBitmaskKHR a + +pattern VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT_KHR = + VkExternalMemoryHandleTypeBitmaskKHR 32 + +-- | bitpos = @6@ +pattern VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT_KHR :: + VkExternalMemoryHandleTypeBitmaskKHR a + +pattern VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT_KHR = + VkExternalMemoryHandleTypeBitmaskKHR 64 diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkExternalMemoryHandleTypeFlagsNV.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkExternalMemoryHandleTypeFlagsNV.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkExternalMemoryHandleTypeFlagsNV.hs @@ -0,0 +1,137 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE KindSignatures #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE StandaloneDeriving #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeSynonymInstances #-} +module Graphics.Vulkan.Types.Enum.VkExternalMemoryHandleTypeFlagsNV + (VkExternalMemoryHandleTypeBitmaskNV(VkExternalMemoryHandleTypeBitmaskNV, + VkExternalMemoryHandleTypeFlagsNV, + VkExternalMemoryHandleTypeFlagBitsNV, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_NV, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_BIT_NV, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_BIT_NV), + VkExternalMemoryHandleTypeFlagsNV, + VkExternalMemoryHandleTypeFlagBitsNV) + where +import Data.Bits (Bits, FiniteBits) +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (FlagBit, FlagMask, FlagType) +import Graphics.Vulkan.Types.BaseTypes (VkFlags (..)) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +newtype VkExternalMemoryHandleTypeBitmaskNV (a :: + FlagType) = VkExternalMemoryHandleTypeBitmaskNV VkFlags + deriving (Eq, Ord, Storable, Data, + Generic) + +type VkExternalMemoryHandleTypeFlagsNV = + VkExternalMemoryHandleTypeBitmaskNV FlagMask + +type VkExternalMemoryHandleTypeFlagBitsNV = + VkExternalMemoryHandleTypeBitmaskNV FlagBit + +pattern VkExternalMemoryHandleTypeFlagBitsNV :: + VkFlags -> VkExternalMemoryHandleTypeBitmaskNV FlagBit + +pattern VkExternalMemoryHandleTypeFlagBitsNV n = + VkExternalMemoryHandleTypeBitmaskNV n + +pattern VkExternalMemoryHandleTypeFlagsNV :: + VkFlags -> VkExternalMemoryHandleTypeBitmaskNV FlagMask + +pattern VkExternalMemoryHandleTypeFlagsNV n = + VkExternalMemoryHandleTypeBitmaskNV n + +deriving instance + Bits (VkExternalMemoryHandleTypeBitmaskNV FlagMask) + +deriving instance + FiniteBits (VkExternalMemoryHandleTypeBitmaskNV FlagMask) + +deriving instance + Integral (VkExternalMemoryHandleTypeBitmaskNV FlagMask) + +deriving instance + Num (VkExternalMemoryHandleTypeBitmaskNV FlagMask) + +deriving instance + Bounded (VkExternalMemoryHandleTypeBitmaskNV FlagMask) + +deriving instance + Enum (VkExternalMemoryHandleTypeBitmaskNV FlagMask) + +deriving instance + Real (VkExternalMemoryHandleTypeBitmaskNV FlagMask) + +instance Show (VkExternalMemoryHandleTypeBitmaskNV a) where + showsPrec _ VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV + = showString "VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV" + showsPrec _ VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_NV + = showString + "VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_NV" + showsPrec _ VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_BIT_NV + = showString "VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_BIT_NV" + showsPrec _ VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_BIT_NV + = showString + "VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_BIT_NV" + showsPrec p (VkExternalMemoryHandleTypeBitmaskNV x) + = showParen (p >= 11) + (showString "VkExternalMemoryHandleTypeBitmaskNV " . + showsPrec 11 x) + +instance Read (VkExternalMemoryHandleTypeBitmaskNV a) where + readPrec + = parens + (choose + [("VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV", + pure VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV), + ("VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_NV", + pure VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_NV), + ("VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_BIT_NV", + pure VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_BIT_NV), + ("VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_BIT_NV", + pure VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_BIT_NV)] + +++ + prec 10 + (expectP (Ident "VkExternalMemoryHandleTypeBitmaskNV") >> + (VkExternalMemoryHandleTypeBitmaskNV <$> step readPrec))) + +-- | bitpos = @0@ +pattern VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV :: + VkExternalMemoryHandleTypeBitmaskNV a + +pattern VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV = + VkExternalMemoryHandleTypeBitmaskNV 1 + +-- | bitpos = @1@ +pattern VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_NV :: + VkExternalMemoryHandleTypeBitmaskNV a + +pattern VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_NV = + VkExternalMemoryHandleTypeBitmaskNV 2 + +-- | bitpos = @2@ +pattern VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_BIT_NV :: + VkExternalMemoryHandleTypeBitmaskNV a + +pattern VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_BIT_NV = + VkExternalMemoryHandleTypeBitmaskNV 4 + +-- | bitpos = @3@ +pattern VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_BIT_NV :: + VkExternalMemoryHandleTypeBitmaskNV a + +pattern VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_BIT_NV = + VkExternalMemoryHandleTypeBitmaskNV 8 diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkExternalSemaphoreFeatureFlagsKHR.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkExternalSemaphoreFeatureFlagsKHR.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkExternalSemaphoreFeatureFlagsKHR.hs @@ -0,0 +1,111 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE KindSignatures #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE StandaloneDeriving #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeSynonymInstances #-} +module Graphics.Vulkan.Types.Enum.VkExternalSemaphoreFeatureFlagsKHR + (VkExternalSemaphoreFeatureBitmaskKHR(VkExternalSemaphoreFeatureBitmaskKHR, + VkExternalSemaphoreFeatureFlagsKHR, + VkExternalSemaphoreFeatureFlagBitsKHR, + VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT_KHR, + VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT_KHR), + VkExternalSemaphoreFeatureFlagsKHR, + VkExternalSemaphoreFeatureFlagBitsKHR) + where +import Data.Bits (Bits, FiniteBits) +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (FlagBit, FlagMask, FlagType) +import Graphics.Vulkan.Types.BaseTypes (VkFlags (..)) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +newtype VkExternalSemaphoreFeatureBitmaskKHR (a :: + FlagType) = VkExternalSemaphoreFeatureBitmaskKHR VkFlags + deriving (Eq, Ord, Storable, Data, + Generic) + +type VkExternalSemaphoreFeatureFlagsKHR = + VkExternalSemaphoreFeatureBitmaskKHR FlagMask + +type VkExternalSemaphoreFeatureFlagBitsKHR = + VkExternalSemaphoreFeatureBitmaskKHR FlagBit + +pattern VkExternalSemaphoreFeatureFlagBitsKHR :: + VkFlags -> VkExternalSemaphoreFeatureBitmaskKHR FlagBit + +pattern VkExternalSemaphoreFeatureFlagBitsKHR n = + VkExternalSemaphoreFeatureBitmaskKHR n + +pattern VkExternalSemaphoreFeatureFlagsKHR :: + VkFlags -> VkExternalSemaphoreFeatureBitmaskKHR FlagMask + +pattern VkExternalSemaphoreFeatureFlagsKHR n = + VkExternalSemaphoreFeatureBitmaskKHR n + +deriving instance + Bits (VkExternalSemaphoreFeatureBitmaskKHR FlagMask) + +deriving instance + FiniteBits (VkExternalSemaphoreFeatureBitmaskKHR FlagMask) + +deriving instance + Integral (VkExternalSemaphoreFeatureBitmaskKHR FlagMask) + +deriving instance + Num (VkExternalSemaphoreFeatureBitmaskKHR FlagMask) + +deriving instance + Bounded (VkExternalSemaphoreFeatureBitmaskKHR FlagMask) + +deriving instance + Enum (VkExternalSemaphoreFeatureBitmaskKHR FlagMask) + +deriving instance + Real (VkExternalSemaphoreFeatureBitmaskKHR FlagMask) + +instance Show (VkExternalSemaphoreFeatureBitmaskKHR a) where + showsPrec _ VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT_KHR + = showString "VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT_KHR" + showsPrec _ VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT_KHR + = showString "VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT_KHR" + showsPrec p (VkExternalSemaphoreFeatureBitmaskKHR x) + = showParen (p >= 11) + (showString "VkExternalSemaphoreFeatureBitmaskKHR " . + showsPrec 11 x) + +instance Read (VkExternalSemaphoreFeatureBitmaskKHR a) where + readPrec + = parens + (choose + [("VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT_KHR", + pure VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT_KHR), + ("VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT_KHR", + pure VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT_KHR)] + +++ + prec 10 + (expectP (Ident "VkExternalSemaphoreFeatureBitmaskKHR") >> + (VkExternalSemaphoreFeatureBitmaskKHR <$> step readPrec))) + +-- | bitpos = @0@ +pattern VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT_KHR :: + VkExternalSemaphoreFeatureBitmaskKHR a + +pattern VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT_KHR = + VkExternalSemaphoreFeatureBitmaskKHR 1 + +-- | bitpos = @1@ +pattern VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT_KHR :: + VkExternalSemaphoreFeatureBitmaskKHR a + +pattern VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT_KHR = + VkExternalSemaphoreFeatureBitmaskKHR 2 diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkExternalSemaphoreHandleTypeFlagsKHR.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkExternalSemaphoreHandleTypeFlagsKHR.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkExternalSemaphoreHandleTypeFlagsKHR.hs @@ -0,0 +1,151 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE KindSignatures #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE StandaloneDeriving #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeSynonymInstances #-} +module Graphics.Vulkan.Types.Enum.VkExternalSemaphoreHandleTypeFlagsKHR + (VkExternalSemaphoreHandleTypeBitmaskKHR(VkExternalSemaphoreHandleTypeBitmaskKHR, + VkExternalSemaphoreHandleTypeFlagsKHR, + VkExternalSemaphoreHandleTypeFlagBitsKHR, + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR, + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR, + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR, + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT_KHR, + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT_KHR), + VkExternalSemaphoreHandleTypeFlagsKHR, + VkExternalSemaphoreHandleTypeFlagBitsKHR) + where +import Data.Bits (Bits, FiniteBits) +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (FlagBit, FlagMask, FlagType) +import Graphics.Vulkan.Types.BaseTypes (VkFlags (..)) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +newtype VkExternalSemaphoreHandleTypeBitmaskKHR (a :: + FlagType) = VkExternalSemaphoreHandleTypeBitmaskKHR VkFlags + deriving (Eq, Ord, Storable, Data, + Generic) + +type VkExternalSemaphoreHandleTypeFlagsKHR = + VkExternalSemaphoreHandleTypeBitmaskKHR FlagMask + +type VkExternalSemaphoreHandleTypeFlagBitsKHR = + VkExternalSemaphoreHandleTypeBitmaskKHR FlagBit + +pattern VkExternalSemaphoreHandleTypeFlagBitsKHR :: + VkFlags -> VkExternalSemaphoreHandleTypeBitmaskKHR FlagBit + +pattern VkExternalSemaphoreHandleTypeFlagBitsKHR n = + VkExternalSemaphoreHandleTypeBitmaskKHR n + +pattern VkExternalSemaphoreHandleTypeFlagsKHR :: + VkFlags -> VkExternalSemaphoreHandleTypeBitmaskKHR FlagMask + +pattern VkExternalSemaphoreHandleTypeFlagsKHR n = + VkExternalSemaphoreHandleTypeBitmaskKHR n + +deriving instance + Bits (VkExternalSemaphoreHandleTypeBitmaskKHR FlagMask) + +deriving instance + FiniteBits (VkExternalSemaphoreHandleTypeBitmaskKHR FlagMask) + +deriving instance + Integral (VkExternalSemaphoreHandleTypeBitmaskKHR FlagMask) + +deriving instance + Num (VkExternalSemaphoreHandleTypeBitmaskKHR FlagMask) + +deriving instance + Bounded (VkExternalSemaphoreHandleTypeBitmaskKHR FlagMask) + +deriving instance + Enum (VkExternalSemaphoreHandleTypeBitmaskKHR FlagMask) + +deriving instance + Real (VkExternalSemaphoreHandleTypeBitmaskKHR FlagMask) + +instance Show (VkExternalSemaphoreHandleTypeBitmaskKHR a) where + showsPrec _ VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR + = showString "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR" + showsPrec _ VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR + = showString + "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR" + showsPrec _ + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR + = showString + "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR" + showsPrec _ VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT_KHR + = showString + "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT_KHR" + showsPrec _ VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT_KHR + = showString "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT_KHR" + showsPrec p (VkExternalSemaphoreHandleTypeBitmaskKHR x) + = showParen (p >= 11) + (showString "VkExternalSemaphoreHandleTypeBitmaskKHR " . + showsPrec 11 x) + +instance Read (VkExternalSemaphoreHandleTypeBitmaskKHR a) where + readPrec + = parens + (choose + [("VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR", + pure VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR), + ("VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR", + pure VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR), + ("VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR", + pure VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR), + ("VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT_KHR", + pure VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT_KHR), + ("VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT_KHR", + pure VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT_KHR)] + +++ + prec 10 + (expectP (Ident "VkExternalSemaphoreHandleTypeBitmaskKHR") >> + (VkExternalSemaphoreHandleTypeBitmaskKHR <$> step readPrec))) + +-- | bitpos = @0@ +pattern VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR :: + VkExternalSemaphoreHandleTypeBitmaskKHR a + +pattern VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR = + VkExternalSemaphoreHandleTypeBitmaskKHR 1 + +-- | bitpos = @1@ +pattern VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR :: + VkExternalSemaphoreHandleTypeBitmaskKHR a + +pattern VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR = + VkExternalSemaphoreHandleTypeBitmaskKHR 2 + +-- | bitpos = @2@ +pattern VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR + :: VkExternalSemaphoreHandleTypeBitmaskKHR a + +pattern VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR + = VkExternalSemaphoreHandleTypeBitmaskKHR 4 + +-- | bitpos = @3@ +pattern VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT_KHR :: + VkExternalSemaphoreHandleTypeBitmaskKHR a + +pattern VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT_KHR = + VkExternalSemaphoreHandleTypeBitmaskKHR 8 + +-- | bitpos = @4@ +pattern VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT_KHR :: + VkExternalSemaphoreHandleTypeBitmaskKHR a + +pattern VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT_KHR = + VkExternalSemaphoreHandleTypeBitmaskKHR 16 diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkFenceCreateFlags.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkFenceCreateFlags.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkFenceCreateFlags.hs @@ -0,0 +1,81 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE KindSignatures #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE StandaloneDeriving #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeSynonymInstances #-} +module Graphics.Vulkan.Types.Enum.VkFenceCreateFlags + (VkFenceCreateBitmask(VkFenceCreateBitmask, VkFenceCreateFlags, + VkFenceCreateFlagBits, VK_FENCE_CREATE_SIGNALED_BIT), + VkFenceCreateFlags, VkFenceCreateFlagBits) + where +import Data.Bits (Bits, FiniteBits) +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (FlagBit, FlagMask, FlagType) +import Graphics.Vulkan.Types.BaseTypes (VkFlags (..)) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +newtype VkFenceCreateBitmask (a :: + FlagType) = VkFenceCreateBitmask VkFlags + deriving (Eq, Ord, Storable, Data, Generic) + +type VkFenceCreateFlags = VkFenceCreateBitmask FlagMask + +type VkFenceCreateFlagBits = VkFenceCreateBitmask FlagBit + +pattern VkFenceCreateFlagBits :: + VkFlags -> VkFenceCreateBitmask FlagBit + +pattern VkFenceCreateFlagBits n = VkFenceCreateBitmask n + +pattern VkFenceCreateFlags :: + VkFlags -> VkFenceCreateBitmask FlagMask + +pattern VkFenceCreateFlags n = VkFenceCreateBitmask n + +deriving instance Bits (VkFenceCreateBitmask FlagMask) + +deriving instance FiniteBits (VkFenceCreateBitmask FlagMask) + +deriving instance Integral (VkFenceCreateBitmask FlagMask) + +deriving instance Num (VkFenceCreateBitmask FlagMask) + +deriving instance Bounded (VkFenceCreateBitmask FlagMask) + +deriving instance Enum (VkFenceCreateBitmask FlagMask) + +deriving instance Real (VkFenceCreateBitmask FlagMask) + +instance Show (VkFenceCreateBitmask a) where + showsPrec _ VK_FENCE_CREATE_SIGNALED_BIT + = showString "VK_FENCE_CREATE_SIGNALED_BIT" + showsPrec p (VkFenceCreateBitmask x) + = showParen (p >= 11) + (showString "VkFenceCreateBitmask " . showsPrec 11 x) + +instance Read (VkFenceCreateBitmask a) where + readPrec + = parens + (choose + [("VK_FENCE_CREATE_SIGNALED_BIT", + pure VK_FENCE_CREATE_SIGNALED_BIT)] + +++ + prec 10 + (expectP (Ident "VkFenceCreateBitmask") >> + (VkFenceCreateBitmask <$> step readPrec))) + +-- | bitpos = @0@ +pattern VK_FENCE_CREATE_SIGNALED_BIT :: VkFenceCreateBitmask a + +pattern VK_FENCE_CREATE_SIGNALED_BIT = VkFenceCreateBitmask 1 diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkFenceImportFlagsKHR.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkFenceImportFlagsKHR.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkFenceImportFlagsKHR.hs @@ -0,0 +1,84 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE KindSignatures #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE StandaloneDeriving #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeSynonymInstances #-} +module Graphics.Vulkan.Types.Enum.VkFenceImportFlagsKHR + (VkFenceImportBitmaskKHR(VkFenceImportBitmaskKHR, + VkFenceImportFlagsKHR, VkFenceImportFlagBitsKHR, + VK_FENCE_IMPORT_TEMPORARY_BIT_KHR), + VkFenceImportFlagsKHR, VkFenceImportFlagBitsKHR) + where +import Data.Bits (Bits, FiniteBits) +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (FlagBit, FlagMask, FlagType) +import Graphics.Vulkan.Types.BaseTypes (VkFlags (..)) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +newtype VkFenceImportBitmaskKHR (a :: + FlagType) = VkFenceImportBitmaskKHR VkFlags + deriving (Eq, Ord, Storable, Data, Generic) + +type VkFenceImportFlagsKHR = VkFenceImportBitmaskKHR FlagMask + +type VkFenceImportFlagBitsKHR = VkFenceImportBitmaskKHR FlagBit + +pattern VkFenceImportFlagBitsKHR :: + VkFlags -> VkFenceImportBitmaskKHR FlagBit + +pattern VkFenceImportFlagBitsKHR n = VkFenceImportBitmaskKHR n + +pattern VkFenceImportFlagsKHR :: + VkFlags -> VkFenceImportBitmaskKHR FlagMask + +pattern VkFenceImportFlagsKHR n = VkFenceImportBitmaskKHR n + +deriving instance Bits (VkFenceImportBitmaskKHR FlagMask) + +deriving instance FiniteBits (VkFenceImportBitmaskKHR FlagMask) + +deriving instance Integral (VkFenceImportBitmaskKHR FlagMask) + +deriving instance Num (VkFenceImportBitmaskKHR FlagMask) + +deriving instance Bounded (VkFenceImportBitmaskKHR FlagMask) + +deriving instance Enum (VkFenceImportBitmaskKHR FlagMask) + +deriving instance Real (VkFenceImportBitmaskKHR FlagMask) + +instance Show (VkFenceImportBitmaskKHR a) where + showsPrec _ VK_FENCE_IMPORT_TEMPORARY_BIT_KHR + = showString "VK_FENCE_IMPORT_TEMPORARY_BIT_KHR" + showsPrec p (VkFenceImportBitmaskKHR x) + = showParen (p >= 11) + (showString "VkFenceImportBitmaskKHR " . showsPrec 11 x) + +instance Read (VkFenceImportBitmaskKHR a) where + readPrec + = parens + (choose + [("VK_FENCE_IMPORT_TEMPORARY_BIT_KHR", + pure VK_FENCE_IMPORT_TEMPORARY_BIT_KHR)] + +++ + prec 10 + (expectP (Ident "VkFenceImportBitmaskKHR") >> + (VkFenceImportBitmaskKHR <$> step readPrec))) + +-- | bitpos = @0@ +pattern VK_FENCE_IMPORT_TEMPORARY_BIT_KHR :: + VkFenceImportBitmaskKHR a + +pattern VK_FENCE_IMPORT_TEMPORARY_BIT_KHR = + VkFenceImportBitmaskKHR 1 diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkFilter.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkFilter.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkFilter.hs @@ -0,0 +1,47 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +module Graphics.Vulkan.Types.Enum.VkFilter + (VkFilter(VkFilter, VK_FILTER_NEAREST, VK_FILTER_LINEAR)) where +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (Int32) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +-- | type = @enum@ +-- +-- +newtype VkFilter = VkFilter Int32 + deriving (Eq, Ord, Num, Bounded, Storable, Enum, Data, Generic) + +instance Show VkFilter where + showsPrec _ VK_FILTER_NEAREST = showString "VK_FILTER_NEAREST" + showsPrec _ VK_FILTER_LINEAR = showString "VK_FILTER_LINEAR" + showsPrec p (VkFilter x) + = showParen (p >= 11) (showString "VkFilter " . showsPrec 11 x) + +instance Read VkFilter where + readPrec + = parens + (choose + [("VK_FILTER_NEAREST", pure VK_FILTER_NEAREST), + ("VK_FILTER_LINEAR", pure VK_FILTER_LINEAR)] + +++ + prec 10 + (expectP (Ident "VkFilter") >> (VkFilter <$> step readPrec))) + +pattern VK_FILTER_NEAREST :: VkFilter + +pattern VK_FILTER_NEAREST = VkFilter 0 + +pattern VK_FILTER_LINEAR :: VkFilter + +pattern VK_FILTER_LINEAR = VkFilter 1 diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkFormat.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkFormat.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkFormat.hs @@ -0,0 +1,1491 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +module Graphics.Vulkan.Types.Enum.VkFormat + (VkFormat(VkFormat, VK_FORMAT_UNDEFINED, + VK_FORMAT_R4G4_UNORM_PACK8, VK_FORMAT_R4G4B4A4_UNORM_PACK16, + VK_FORMAT_B4G4R4A4_UNORM_PACK16, VK_FORMAT_R5G6B5_UNORM_PACK16, + VK_FORMAT_B5G6R5_UNORM_PACK16, VK_FORMAT_R5G5B5A1_UNORM_PACK16, + VK_FORMAT_B5G5R5A1_UNORM_PACK16, VK_FORMAT_A1R5G5B5_UNORM_PACK16, + VK_FORMAT_R8_UNORM, VK_FORMAT_R8_SNORM, VK_FORMAT_R8_USCALED, + VK_FORMAT_R8_SSCALED, VK_FORMAT_R8_UINT, VK_FORMAT_R8_SINT, + VK_FORMAT_R8_SRGB, VK_FORMAT_R8G8_UNORM, VK_FORMAT_R8G8_SNORM, + VK_FORMAT_R8G8_USCALED, VK_FORMAT_R8G8_SSCALED, + VK_FORMAT_R8G8_UINT, VK_FORMAT_R8G8_SINT, VK_FORMAT_R8G8_SRGB, + VK_FORMAT_R8G8B8_UNORM, VK_FORMAT_R8G8B8_SNORM, + VK_FORMAT_R8G8B8_USCALED, VK_FORMAT_R8G8B8_SSCALED, + VK_FORMAT_R8G8B8_UINT, VK_FORMAT_R8G8B8_SINT, + VK_FORMAT_R8G8B8_SRGB, VK_FORMAT_B8G8R8_UNORM, + VK_FORMAT_B8G8R8_SNORM, VK_FORMAT_B8G8R8_USCALED, + VK_FORMAT_B8G8R8_SSCALED, VK_FORMAT_B8G8R8_UINT, + VK_FORMAT_B8G8R8_SINT, VK_FORMAT_B8G8R8_SRGB, + VK_FORMAT_R8G8B8A8_UNORM, VK_FORMAT_R8G8B8A8_SNORM, + VK_FORMAT_R8G8B8A8_USCALED, VK_FORMAT_R8G8B8A8_SSCALED, + VK_FORMAT_R8G8B8A8_UINT, VK_FORMAT_R8G8B8A8_SINT, + VK_FORMAT_R8G8B8A8_SRGB, VK_FORMAT_B8G8R8A8_UNORM, + VK_FORMAT_B8G8R8A8_SNORM, VK_FORMAT_B8G8R8A8_USCALED, + VK_FORMAT_B8G8R8A8_SSCALED, VK_FORMAT_B8G8R8A8_UINT, + VK_FORMAT_B8G8R8A8_SINT, VK_FORMAT_B8G8R8A8_SRGB, + VK_FORMAT_A8B8G8R8_UNORM_PACK32, VK_FORMAT_A8B8G8R8_SNORM_PACK32, + VK_FORMAT_A8B8G8R8_USCALED_PACK32, + VK_FORMAT_A8B8G8R8_SSCALED_PACK32, VK_FORMAT_A8B8G8R8_UINT_PACK32, + VK_FORMAT_A8B8G8R8_SINT_PACK32, VK_FORMAT_A8B8G8R8_SRGB_PACK32, + VK_FORMAT_A2R10G10B10_UNORM_PACK32, + VK_FORMAT_A2R10G10B10_SNORM_PACK32, + VK_FORMAT_A2R10G10B10_USCALED_PACK32, + VK_FORMAT_A2R10G10B10_SSCALED_PACK32, + VK_FORMAT_A2R10G10B10_UINT_PACK32, + VK_FORMAT_A2R10G10B10_SINT_PACK32, + VK_FORMAT_A2B10G10R10_UNORM_PACK32, + VK_FORMAT_A2B10G10R10_SNORM_PACK32, + VK_FORMAT_A2B10G10R10_USCALED_PACK32, + VK_FORMAT_A2B10G10R10_SSCALED_PACK32, + VK_FORMAT_A2B10G10R10_UINT_PACK32, + VK_FORMAT_A2B10G10R10_SINT_PACK32, VK_FORMAT_R16_UNORM, + VK_FORMAT_R16_SNORM, VK_FORMAT_R16_USCALED, VK_FORMAT_R16_SSCALED, + VK_FORMAT_R16_UINT, VK_FORMAT_R16_SINT, VK_FORMAT_R16_SFLOAT, + VK_FORMAT_R16G16_UNORM, VK_FORMAT_R16G16_SNORM, + VK_FORMAT_R16G16_USCALED, VK_FORMAT_R16G16_SSCALED, + VK_FORMAT_R16G16_UINT, VK_FORMAT_R16G16_SINT, + VK_FORMAT_R16G16_SFLOAT, VK_FORMAT_R16G16B16_UNORM, + VK_FORMAT_R16G16B16_SNORM, VK_FORMAT_R16G16B16_USCALED, + VK_FORMAT_R16G16B16_SSCALED, VK_FORMAT_R16G16B16_UINT, + VK_FORMAT_R16G16B16_SINT, VK_FORMAT_R16G16B16_SFLOAT, + VK_FORMAT_R16G16B16A16_UNORM, VK_FORMAT_R16G16B16A16_SNORM, + VK_FORMAT_R16G16B16A16_USCALED, VK_FORMAT_R16G16B16A16_SSCALED, + VK_FORMAT_R16G16B16A16_UINT, VK_FORMAT_R16G16B16A16_SINT, + VK_FORMAT_R16G16B16A16_SFLOAT, VK_FORMAT_R32_UINT, + VK_FORMAT_R32_SINT, VK_FORMAT_R32_SFLOAT, VK_FORMAT_R32G32_UINT, + VK_FORMAT_R32G32_SINT, VK_FORMAT_R32G32_SFLOAT, + VK_FORMAT_R32G32B32_UINT, VK_FORMAT_R32G32B32_SINT, + VK_FORMAT_R32G32B32_SFLOAT, VK_FORMAT_R32G32B32A32_UINT, + VK_FORMAT_R32G32B32A32_SINT, VK_FORMAT_R32G32B32A32_SFLOAT, + VK_FORMAT_R64_UINT, VK_FORMAT_R64_SINT, VK_FORMAT_R64_SFLOAT, + VK_FORMAT_R64G64_UINT, VK_FORMAT_R64G64_SINT, + VK_FORMAT_R64G64_SFLOAT, VK_FORMAT_R64G64B64_UINT, + VK_FORMAT_R64G64B64_SINT, VK_FORMAT_R64G64B64_SFLOAT, + VK_FORMAT_R64G64B64A64_UINT, VK_FORMAT_R64G64B64A64_SINT, + VK_FORMAT_R64G64B64A64_SFLOAT, VK_FORMAT_B10G11R11_UFLOAT_PACK32, + VK_FORMAT_E5B9G9R9_UFLOAT_PACK32, VK_FORMAT_D16_UNORM, + VK_FORMAT_X8_D24_UNORM_PACK32, VK_FORMAT_D32_SFLOAT, + VK_FORMAT_S8_UINT, VK_FORMAT_D16_UNORM_S8_UINT, + VK_FORMAT_D24_UNORM_S8_UINT, VK_FORMAT_D32_SFLOAT_S8_UINT, + VK_FORMAT_BC1_RGB_UNORM_BLOCK, VK_FORMAT_BC1_RGB_SRGB_BLOCK, + VK_FORMAT_BC1_RGBA_UNORM_BLOCK, VK_FORMAT_BC1_RGBA_SRGB_BLOCK, + VK_FORMAT_BC2_UNORM_BLOCK, VK_FORMAT_BC2_SRGB_BLOCK, + VK_FORMAT_BC3_UNORM_BLOCK, VK_FORMAT_BC3_SRGB_BLOCK, + VK_FORMAT_BC4_UNORM_BLOCK, VK_FORMAT_BC4_SNORM_BLOCK, + VK_FORMAT_BC5_UNORM_BLOCK, VK_FORMAT_BC5_SNORM_BLOCK, + VK_FORMAT_BC6H_UFLOAT_BLOCK, VK_FORMAT_BC6H_SFLOAT_BLOCK, + VK_FORMAT_BC7_UNORM_BLOCK, VK_FORMAT_BC7_SRGB_BLOCK, + VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK, + VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK, + VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK, + VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK, + VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK, + VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK, VK_FORMAT_EAC_R11_UNORM_BLOCK, + VK_FORMAT_EAC_R11_SNORM_BLOCK, VK_FORMAT_EAC_R11G11_UNORM_BLOCK, + VK_FORMAT_EAC_R11G11_SNORM_BLOCK, VK_FORMAT_ASTC_4x4_UNORM_BLOCK, + VK_FORMAT_ASTC_4x4_SRGB_BLOCK, VK_FORMAT_ASTC_5x4_UNORM_BLOCK, + VK_FORMAT_ASTC_5x4_SRGB_BLOCK, VK_FORMAT_ASTC_5x5_UNORM_BLOCK, + VK_FORMAT_ASTC_5x5_SRGB_BLOCK, VK_FORMAT_ASTC_6x5_UNORM_BLOCK, + VK_FORMAT_ASTC_6x5_SRGB_BLOCK, VK_FORMAT_ASTC_6x6_UNORM_BLOCK, + VK_FORMAT_ASTC_6x6_SRGB_BLOCK, VK_FORMAT_ASTC_8x5_UNORM_BLOCK, + VK_FORMAT_ASTC_8x5_SRGB_BLOCK, VK_FORMAT_ASTC_8x6_UNORM_BLOCK, + VK_FORMAT_ASTC_8x6_SRGB_BLOCK, VK_FORMAT_ASTC_8x8_UNORM_BLOCK, + VK_FORMAT_ASTC_8x8_SRGB_BLOCK, VK_FORMAT_ASTC_10x5_UNORM_BLOCK, + VK_FORMAT_ASTC_10x5_SRGB_BLOCK, VK_FORMAT_ASTC_10x6_UNORM_BLOCK, + VK_FORMAT_ASTC_10x6_SRGB_BLOCK, VK_FORMAT_ASTC_10x8_UNORM_BLOCK, + VK_FORMAT_ASTC_10x8_SRGB_BLOCK, VK_FORMAT_ASTC_10x10_UNORM_BLOCK, + VK_FORMAT_ASTC_10x10_SRGB_BLOCK, VK_FORMAT_ASTC_12x10_UNORM_BLOCK, + VK_FORMAT_ASTC_12x10_SRGB_BLOCK, VK_FORMAT_ASTC_12x12_UNORM_BLOCK, + VK_FORMAT_ASTC_12x12_SRGB_BLOCK)) + where +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (Int32) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +-- | Vulkan format definitions +-- +-- type = @enum@ +-- +-- +-- +newtype VkFormat = VkFormat Int32 + deriving (Eq, Ord, Num, Bounded, Storable, Enum, Data, Generic) + +instance Show VkFormat where + showsPrec _ VK_FORMAT_UNDEFINED = showString "VK_FORMAT_UNDEFINED" + showsPrec _ VK_FORMAT_R4G4_UNORM_PACK8 + = showString "VK_FORMAT_R4G4_UNORM_PACK8" + showsPrec _ VK_FORMAT_R4G4B4A4_UNORM_PACK16 + = showString "VK_FORMAT_R4G4B4A4_UNORM_PACK16" + showsPrec _ VK_FORMAT_B4G4R4A4_UNORM_PACK16 + = showString "VK_FORMAT_B4G4R4A4_UNORM_PACK16" + showsPrec _ VK_FORMAT_R5G6B5_UNORM_PACK16 + = showString "VK_FORMAT_R5G6B5_UNORM_PACK16" + showsPrec _ VK_FORMAT_B5G6R5_UNORM_PACK16 + = showString "VK_FORMAT_B5G6R5_UNORM_PACK16" + showsPrec _ VK_FORMAT_R5G5B5A1_UNORM_PACK16 + = showString "VK_FORMAT_R5G5B5A1_UNORM_PACK16" + showsPrec _ VK_FORMAT_B5G5R5A1_UNORM_PACK16 + = showString "VK_FORMAT_B5G5R5A1_UNORM_PACK16" + showsPrec _ VK_FORMAT_A1R5G5B5_UNORM_PACK16 + = showString "VK_FORMAT_A1R5G5B5_UNORM_PACK16" + showsPrec _ VK_FORMAT_R8_UNORM = showString "VK_FORMAT_R8_UNORM" + showsPrec _ VK_FORMAT_R8_SNORM = showString "VK_FORMAT_R8_SNORM" + showsPrec _ VK_FORMAT_R8_USCALED + = showString "VK_FORMAT_R8_USCALED" + showsPrec _ VK_FORMAT_R8_SSCALED + = showString "VK_FORMAT_R8_SSCALED" + showsPrec _ VK_FORMAT_R8_UINT = showString "VK_FORMAT_R8_UINT" + showsPrec _ VK_FORMAT_R8_SINT = showString "VK_FORMAT_R8_SINT" + showsPrec _ VK_FORMAT_R8_SRGB = showString "VK_FORMAT_R8_SRGB" + showsPrec _ VK_FORMAT_R8G8_UNORM + = showString "VK_FORMAT_R8G8_UNORM" + showsPrec _ VK_FORMAT_R8G8_SNORM + = showString "VK_FORMAT_R8G8_SNORM" + showsPrec _ VK_FORMAT_R8G8_USCALED + = showString "VK_FORMAT_R8G8_USCALED" + showsPrec _ VK_FORMAT_R8G8_SSCALED + = showString "VK_FORMAT_R8G8_SSCALED" + showsPrec _ VK_FORMAT_R8G8_UINT = showString "VK_FORMAT_R8G8_UINT" + showsPrec _ VK_FORMAT_R8G8_SINT = showString "VK_FORMAT_R8G8_SINT" + showsPrec _ VK_FORMAT_R8G8_SRGB = showString "VK_FORMAT_R8G8_SRGB" + showsPrec _ VK_FORMAT_R8G8B8_UNORM + = showString "VK_FORMAT_R8G8B8_UNORM" + showsPrec _ VK_FORMAT_R8G8B8_SNORM + = showString "VK_FORMAT_R8G8B8_SNORM" + showsPrec _ VK_FORMAT_R8G8B8_USCALED + = showString "VK_FORMAT_R8G8B8_USCALED" + showsPrec _ VK_FORMAT_R8G8B8_SSCALED + = showString "VK_FORMAT_R8G8B8_SSCALED" + showsPrec _ VK_FORMAT_R8G8B8_UINT + = showString "VK_FORMAT_R8G8B8_UINT" + showsPrec _ VK_FORMAT_R8G8B8_SINT + = showString "VK_FORMAT_R8G8B8_SINT" + showsPrec _ VK_FORMAT_R8G8B8_SRGB + = showString "VK_FORMAT_R8G8B8_SRGB" + showsPrec _ VK_FORMAT_B8G8R8_UNORM + = showString "VK_FORMAT_B8G8R8_UNORM" + showsPrec _ VK_FORMAT_B8G8R8_SNORM + = showString "VK_FORMAT_B8G8R8_SNORM" + showsPrec _ VK_FORMAT_B8G8R8_USCALED + = showString "VK_FORMAT_B8G8R8_USCALED" + showsPrec _ VK_FORMAT_B8G8R8_SSCALED + = showString "VK_FORMAT_B8G8R8_SSCALED" + showsPrec _ VK_FORMAT_B8G8R8_UINT + = showString "VK_FORMAT_B8G8R8_UINT" + showsPrec _ VK_FORMAT_B8G8R8_SINT + = showString "VK_FORMAT_B8G8R8_SINT" + showsPrec _ VK_FORMAT_B8G8R8_SRGB + = showString "VK_FORMAT_B8G8R8_SRGB" + showsPrec _ VK_FORMAT_R8G8B8A8_UNORM + = showString "VK_FORMAT_R8G8B8A8_UNORM" + showsPrec _ VK_FORMAT_R8G8B8A8_SNORM + = showString "VK_FORMAT_R8G8B8A8_SNORM" + showsPrec _ VK_FORMAT_R8G8B8A8_USCALED + = showString "VK_FORMAT_R8G8B8A8_USCALED" + showsPrec _ VK_FORMAT_R8G8B8A8_SSCALED + = showString "VK_FORMAT_R8G8B8A8_SSCALED" + showsPrec _ VK_FORMAT_R8G8B8A8_UINT + = showString "VK_FORMAT_R8G8B8A8_UINT" + showsPrec _ VK_FORMAT_R8G8B8A8_SINT + = showString "VK_FORMAT_R8G8B8A8_SINT" + showsPrec _ VK_FORMAT_R8G8B8A8_SRGB + = showString "VK_FORMAT_R8G8B8A8_SRGB" + showsPrec _ VK_FORMAT_B8G8R8A8_UNORM + = showString "VK_FORMAT_B8G8R8A8_UNORM" + showsPrec _ VK_FORMAT_B8G8R8A8_SNORM + = showString "VK_FORMAT_B8G8R8A8_SNORM" + showsPrec _ VK_FORMAT_B8G8R8A8_USCALED + = showString "VK_FORMAT_B8G8R8A8_USCALED" + showsPrec _ VK_FORMAT_B8G8R8A8_SSCALED + = showString "VK_FORMAT_B8G8R8A8_SSCALED" + showsPrec _ VK_FORMAT_B8G8R8A8_UINT + = showString "VK_FORMAT_B8G8R8A8_UINT" + showsPrec _ VK_FORMAT_B8G8R8A8_SINT + = showString "VK_FORMAT_B8G8R8A8_SINT" + showsPrec _ VK_FORMAT_B8G8R8A8_SRGB + = showString "VK_FORMAT_B8G8R8A8_SRGB" + showsPrec _ VK_FORMAT_A8B8G8R8_UNORM_PACK32 + = showString "VK_FORMAT_A8B8G8R8_UNORM_PACK32" + showsPrec _ VK_FORMAT_A8B8G8R8_SNORM_PACK32 + = showString "VK_FORMAT_A8B8G8R8_SNORM_PACK32" + showsPrec _ VK_FORMAT_A8B8G8R8_USCALED_PACK32 + = showString "VK_FORMAT_A8B8G8R8_USCALED_PACK32" + showsPrec _ VK_FORMAT_A8B8G8R8_SSCALED_PACK32 + = showString "VK_FORMAT_A8B8G8R8_SSCALED_PACK32" + showsPrec _ VK_FORMAT_A8B8G8R8_UINT_PACK32 + = showString "VK_FORMAT_A8B8G8R8_UINT_PACK32" + showsPrec _ VK_FORMAT_A8B8G8R8_SINT_PACK32 + = showString "VK_FORMAT_A8B8G8R8_SINT_PACK32" + showsPrec _ VK_FORMAT_A8B8G8R8_SRGB_PACK32 + = showString "VK_FORMAT_A8B8G8R8_SRGB_PACK32" + showsPrec _ VK_FORMAT_A2R10G10B10_UNORM_PACK32 + = showString "VK_FORMAT_A2R10G10B10_UNORM_PACK32" + showsPrec _ VK_FORMAT_A2R10G10B10_SNORM_PACK32 + = showString "VK_FORMAT_A2R10G10B10_SNORM_PACK32" + showsPrec _ VK_FORMAT_A2R10G10B10_USCALED_PACK32 + = showString "VK_FORMAT_A2R10G10B10_USCALED_PACK32" + showsPrec _ VK_FORMAT_A2R10G10B10_SSCALED_PACK32 + = showString "VK_FORMAT_A2R10G10B10_SSCALED_PACK32" + showsPrec _ VK_FORMAT_A2R10G10B10_UINT_PACK32 + = showString "VK_FORMAT_A2R10G10B10_UINT_PACK32" + showsPrec _ VK_FORMAT_A2R10G10B10_SINT_PACK32 + = showString "VK_FORMAT_A2R10G10B10_SINT_PACK32" + showsPrec _ VK_FORMAT_A2B10G10R10_UNORM_PACK32 + = showString "VK_FORMAT_A2B10G10R10_UNORM_PACK32" + showsPrec _ VK_FORMAT_A2B10G10R10_SNORM_PACK32 + = showString "VK_FORMAT_A2B10G10R10_SNORM_PACK32" + showsPrec _ VK_FORMAT_A2B10G10R10_USCALED_PACK32 + = showString "VK_FORMAT_A2B10G10R10_USCALED_PACK32" + showsPrec _ VK_FORMAT_A2B10G10R10_SSCALED_PACK32 + = showString "VK_FORMAT_A2B10G10R10_SSCALED_PACK32" + showsPrec _ VK_FORMAT_A2B10G10R10_UINT_PACK32 + = showString "VK_FORMAT_A2B10G10R10_UINT_PACK32" + showsPrec _ VK_FORMAT_A2B10G10R10_SINT_PACK32 + = showString "VK_FORMAT_A2B10G10R10_SINT_PACK32" + showsPrec _ VK_FORMAT_R16_UNORM = showString "VK_FORMAT_R16_UNORM" + showsPrec _ VK_FORMAT_R16_SNORM = showString "VK_FORMAT_R16_SNORM" + showsPrec _ VK_FORMAT_R16_USCALED + = showString "VK_FORMAT_R16_USCALED" + showsPrec _ VK_FORMAT_R16_SSCALED + = showString "VK_FORMAT_R16_SSCALED" + showsPrec _ VK_FORMAT_R16_UINT = showString "VK_FORMAT_R16_UINT" + showsPrec _ VK_FORMAT_R16_SINT = showString "VK_FORMAT_R16_SINT" + showsPrec _ VK_FORMAT_R16_SFLOAT + = showString "VK_FORMAT_R16_SFLOAT" + showsPrec _ VK_FORMAT_R16G16_UNORM + = showString "VK_FORMAT_R16G16_UNORM" + showsPrec _ VK_FORMAT_R16G16_SNORM + = showString "VK_FORMAT_R16G16_SNORM" + showsPrec _ VK_FORMAT_R16G16_USCALED + = showString "VK_FORMAT_R16G16_USCALED" + showsPrec _ VK_FORMAT_R16G16_SSCALED + = showString "VK_FORMAT_R16G16_SSCALED" + showsPrec _ VK_FORMAT_R16G16_UINT + = showString "VK_FORMAT_R16G16_UINT" + showsPrec _ VK_FORMAT_R16G16_SINT + = showString "VK_FORMAT_R16G16_SINT" + showsPrec _ VK_FORMAT_R16G16_SFLOAT + = showString "VK_FORMAT_R16G16_SFLOAT" + showsPrec _ VK_FORMAT_R16G16B16_UNORM + = showString "VK_FORMAT_R16G16B16_UNORM" + showsPrec _ VK_FORMAT_R16G16B16_SNORM + = showString "VK_FORMAT_R16G16B16_SNORM" + showsPrec _ VK_FORMAT_R16G16B16_USCALED + = showString "VK_FORMAT_R16G16B16_USCALED" + showsPrec _ VK_FORMAT_R16G16B16_SSCALED + = showString "VK_FORMAT_R16G16B16_SSCALED" + showsPrec _ VK_FORMAT_R16G16B16_UINT + = showString "VK_FORMAT_R16G16B16_UINT" + showsPrec _ VK_FORMAT_R16G16B16_SINT + = showString "VK_FORMAT_R16G16B16_SINT" + showsPrec _ VK_FORMAT_R16G16B16_SFLOAT + = showString "VK_FORMAT_R16G16B16_SFLOAT" + showsPrec _ VK_FORMAT_R16G16B16A16_UNORM + = showString "VK_FORMAT_R16G16B16A16_UNORM" + showsPrec _ VK_FORMAT_R16G16B16A16_SNORM + = showString "VK_FORMAT_R16G16B16A16_SNORM" + showsPrec _ VK_FORMAT_R16G16B16A16_USCALED + = showString "VK_FORMAT_R16G16B16A16_USCALED" + showsPrec _ VK_FORMAT_R16G16B16A16_SSCALED + = showString "VK_FORMAT_R16G16B16A16_SSCALED" + showsPrec _ VK_FORMAT_R16G16B16A16_UINT + = showString "VK_FORMAT_R16G16B16A16_UINT" + showsPrec _ VK_FORMAT_R16G16B16A16_SINT + = showString "VK_FORMAT_R16G16B16A16_SINT" + showsPrec _ VK_FORMAT_R16G16B16A16_SFLOAT + = showString "VK_FORMAT_R16G16B16A16_SFLOAT" + showsPrec _ VK_FORMAT_R32_UINT = showString "VK_FORMAT_R32_UINT" + showsPrec _ VK_FORMAT_R32_SINT = showString "VK_FORMAT_R32_SINT" + showsPrec _ VK_FORMAT_R32_SFLOAT + = showString "VK_FORMAT_R32_SFLOAT" + showsPrec _ VK_FORMAT_R32G32_UINT + = showString "VK_FORMAT_R32G32_UINT" + showsPrec _ VK_FORMAT_R32G32_SINT + = showString "VK_FORMAT_R32G32_SINT" + showsPrec _ VK_FORMAT_R32G32_SFLOAT + = showString "VK_FORMAT_R32G32_SFLOAT" + showsPrec _ VK_FORMAT_R32G32B32_UINT + = showString "VK_FORMAT_R32G32B32_UINT" + showsPrec _ VK_FORMAT_R32G32B32_SINT + = showString "VK_FORMAT_R32G32B32_SINT" + showsPrec _ VK_FORMAT_R32G32B32_SFLOAT + = showString "VK_FORMAT_R32G32B32_SFLOAT" + showsPrec _ VK_FORMAT_R32G32B32A32_UINT + = showString "VK_FORMAT_R32G32B32A32_UINT" + showsPrec _ VK_FORMAT_R32G32B32A32_SINT + = showString "VK_FORMAT_R32G32B32A32_SINT" + showsPrec _ VK_FORMAT_R32G32B32A32_SFLOAT + = showString "VK_FORMAT_R32G32B32A32_SFLOAT" + showsPrec _ VK_FORMAT_R64_UINT = showString "VK_FORMAT_R64_UINT" + showsPrec _ VK_FORMAT_R64_SINT = showString "VK_FORMAT_R64_SINT" + showsPrec _ VK_FORMAT_R64_SFLOAT + = showString "VK_FORMAT_R64_SFLOAT" + showsPrec _ VK_FORMAT_R64G64_UINT + = showString "VK_FORMAT_R64G64_UINT" + showsPrec _ VK_FORMAT_R64G64_SINT + = showString "VK_FORMAT_R64G64_SINT" + showsPrec _ VK_FORMAT_R64G64_SFLOAT + = showString "VK_FORMAT_R64G64_SFLOAT" + showsPrec _ VK_FORMAT_R64G64B64_UINT + = showString "VK_FORMAT_R64G64B64_UINT" + showsPrec _ VK_FORMAT_R64G64B64_SINT + = showString "VK_FORMAT_R64G64B64_SINT" + showsPrec _ VK_FORMAT_R64G64B64_SFLOAT + = showString "VK_FORMAT_R64G64B64_SFLOAT" + showsPrec _ VK_FORMAT_R64G64B64A64_UINT + = showString "VK_FORMAT_R64G64B64A64_UINT" + showsPrec _ VK_FORMAT_R64G64B64A64_SINT + = showString "VK_FORMAT_R64G64B64A64_SINT" + showsPrec _ VK_FORMAT_R64G64B64A64_SFLOAT + = showString "VK_FORMAT_R64G64B64A64_SFLOAT" + showsPrec _ VK_FORMAT_B10G11R11_UFLOAT_PACK32 + = showString "VK_FORMAT_B10G11R11_UFLOAT_PACK32" + showsPrec _ VK_FORMAT_E5B9G9R9_UFLOAT_PACK32 + = showString "VK_FORMAT_E5B9G9R9_UFLOAT_PACK32" + showsPrec _ VK_FORMAT_D16_UNORM = showString "VK_FORMAT_D16_UNORM" + showsPrec _ VK_FORMAT_X8_D24_UNORM_PACK32 + = showString "VK_FORMAT_X8_D24_UNORM_PACK32" + showsPrec _ VK_FORMAT_D32_SFLOAT + = showString "VK_FORMAT_D32_SFLOAT" + showsPrec _ VK_FORMAT_S8_UINT = showString "VK_FORMAT_S8_UINT" + showsPrec _ VK_FORMAT_D16_UNORM_S8_UINT + = showString "VK_FORMAT_D16_UNORM_S8_UINT" + showsPrec _ VK_FORMAT_D24_UNORM_S8_UINT + = showString "VK_FORMAT_D24_UNORM_S8_UINT" + showsPrec _ VK_FORMAT_D32_SFLOAT_S8_UINT + = showString "VK_FORMAT_D32_SFLOAT_S8_UINT" + showsPrec _ VK_FORMAT_BC1_RGB_UNORM_BLOCK + = showString "VK_FORMAT_BC1_RGB_UNORM_BLOCK" + showsPrec _ VK_FORMAT_BC1_RGB_SRGB_BLOCK + = showString "VK_FORMAT_BC1_RGB_SRGB_BLOCK" + showsPrec _ VK_FORMAT_BC1_RGBA_UNORM_BLOCK + = showString "VK_FORMAT_BC1_RGBA_UNORM_BLOCK" + showsPrec _ VK_FORMAT_BC1_RGBA_SRGB_BLOCK + = showString "VK_FORMAT_BC1_RGBA_SRGB_BLOCK" + showsPrec _ VK_FORMAT_BC2_UNORM_BLOCK + = showString "VK_FORMAT_BC2_UNORM_BLOCK" + showsPrec _ VK_FORMAT_BC2_SRGB_BLOCK + = showString "VK_FORMAT_BC2_SRGB_BLOCK" + showsPrec _ VK_FORMAT_BC3_UNORM_BLOCK + = showString "VK_FORMAT_BC3_UNORM_BLOCK" + showsPrec _ VK_FORMAT_BC3_SRGB_BLOCK + = showString "VK_FORMAT_BC3_SRGB_BLOCK" + showsPrec _ VK_FORMAT_BC4_UNORM_BLOCK + = showString "VK_FORMAT_BC4_UNORM_BLOCK" + showsPrec _ VK_FORMAT_BC4_SNORM_BLOCK + = showString "VK_FORMAT_BC4_SNORM_BLOCK" + showsPrec _ VK_FORMAT_BC5_UNORM_BLOCK + = showString "VK_FORMAT_BC5_UNORM_BLOCK" + showsPrec _ VK_FORMAT_BC5_SNORM_BLOCK + = showString "VK_FORMAT_BC5_SNORM_BLOCK" + showsPrec _ VK_FORMAT_BC6H_UFLOAT_BLOCK + = showString "VK_FORMAT_BC6H_UFLOAT_BLOCK" + showsPrec _ VK_FORMAT_BC6H_SFLOAT_BLOCK + = showString "VK_FORMAT_BC6H_SFLOAT_BLOCK" + showsPrec _ VK_FORMAT_BC7_UNORM_BLOCK + = showString "VK_FORMAT_BC7_UNORM_BLOCK" + showsPrec _ VK_FORMAT_BC7_SRGB_BLOCK + = showString "VK_FORMAT_BC7_SRGB_BLOCK" + showsPrec _ VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK + = showString "VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK" + showsPrec _ VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK + = showString "VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK" + showsPrec _ VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK + = showString "VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK" + showsPrec _ VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK + = showString "VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK" + showsPrec _ VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK + = showString "VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK" + showsPrec _ VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK + = showString "VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK" + showsPrec _ VK_FORMAT_EAC_R11_UNORM_BLOCK + = showString "VK_FORMAT_EAC_R11_UNORM_BLOCK" + showsPrec _ VK_FORMAT_EAC_R11_SNORM_BLOCK + = showString "VK_FORMAT_EAC_R11_SNORM_BLOCK" + showsPrec _ VK_FORMAT_EAC_R11G11_UNORM_BLOCK + = showString "VK_FORMAT_EAC_R11G11_UNORM_BLOCK" + showsPrec _ VK_FORMAT_EAC_R11G11_SNORM_BLOCK + = showString "VK_FORMAT_EAC_R11G11_SNORM_BLOCK" + showsPrec _ VK_FORMAT_ASTC_4x4_UNORM_BLOCK + = showString "VK_FORMAT_ASTC_4x4_UNORM_BLOCK" + showsPrec _ VK_FORMAT_ASTC_4x4_SRGB_BLOCK + = showString "VK_FORMAT_ASTC_4x4_SRGB_BLOCK" + showsPrec _ VK_FORMAT_ASTC_5x4_UNORM_BLOCK + = showString "VK_FORMAT_ASTC_5x4_UNORM_BLOCK" + showsPrec _ VK_FORMAT_ASTC_5x4_SRGB_BLOCK + = showString "VK_FORMAT_ASTC_5x4_SRGB_BLOCK" + showsPrec _ VK_FORMAT_ASTC_5x5_UNORM_BLOCK + = showString "VK_FORMAT_ASTC_5x5_UNORM_BLOCK" + showsPrec _ VK_FORMAT_ASTC_5x5_SRGB_BLOCK + = showString "VK_FORMAT_ASTC_5x5_SRGB_BLOCK" + showsPrec _ VK_FORMAT_ASTC_6x5_UNORM_BLOCK + = showString "VK_FORMAT_ASTC_6x5_UNORM_BLOCK" + showsPrec _ VK_FORMAT_ASTC_6x5_SRGB_BLOCK + = showString "VK_FORMAT_ASTC_6x5_SRGB_BLOCK" + showsPrec _ VK_FORMAT_ASTC_6x6_UNORM_BLOCK + = showString "VK_FORMAT_ASTC_6x6_UNORM_BLOCK" + showsPrec _ VK_FORMAT_ASTC_6x6_SRGB_BLOCK + = showString "VK_FORMAT_ASTC_6x6_SRGB_BLOCK" + showsPrec _ VK_FORMAT_ASTC_8x5_UNORM_BLOCK + = showString "VK_FORMAT_ASTC_8x5_UNORM_BLOCK" + showsPrec _ VK_FORMAT_ASTC_8x5_SRGB_BLOCK + = showString "VK_FORMAT_ASTC_8x5_SRGB_BLOCK" + showsPrec _ VK_FORMAT_ASTC_8x6_UNORM_BLOCK + = showString "VK_FORMAT_ASTC_8x6_UNORM_BLOCK" + showsPrec _ VK_FORMAT_ASTC_8x6_SRGB_BLOCK + = showString "VK_FORMAT_ASTC_8x6_SRGB_BLOCK" + showsPrec _ VK_FORMAT_ASTC_8x8_UNORM_BLOCK + = showString "VK_FORMAT_ASTC_8x8_UNORM_BLOCK" + showsPrec _ VK_FORMAT_ASTC_8x8_SRGB_BLOCK + = showString "VK_FORMAT_ASTC_8x8_SRGB_BLOCK" + showsPrec _ VK_FORMAT_ASTC_10x5_UNORM_BLOCK + = showString "VK_FORMAT_ASTC_10x5_UNORM_BLOCK" + showsPrec _ VK_FORMAT_ASTC_10x5_SRGB_BLOCK + = showString "VK_FORMAT_ASTC_10x5_SRGB_BLOCK" + showsPrec _ VK_FORMAT_ASTC_10x6_UNORM_BLOCK + = showString "VK_FORMAT_ASTC_10x6_UNORM_BLOCK" + showsPrec _ VK_FORMAT_ASTC_10x6_SRGB_BLOCK + = showString "VK_FORMAT_ASTC_10x6_SRGB_BLOCK" + showsPrec _ VK_FORMAT_ASTC_10x8_UNORM_BLOCK + = showString "VK_FORMAT_ASTC_10x8_UNORM_BLOCK" + showsPrec _ VK_FORMAT_ASTC_10x8_SRGB_BLOCK + = showString "VK_FORMAT_ASTC_10x8_SRGB_BLOCK" + showsPrec _ VK_FORMAT_ASTC_10x10_UNORM_BLOCK + = showString "VK_FORMAT_ASTC_10x10_UNORM_BLOCK" + showsPrec _ VK_FORMAT_ASTC_10x10_SRGB_BLOCK + = showString "VK_FORMAT_ASTC_10x10_SRGB_BLOCK" + showsPrec _ VK_FORMAT_ASTC_12x10_UNORM_BLOCK + = showString "VK_FORMAT_ASTC_12x10_UNORM_BLOCK" + showsPrec _ VK_FORMAT_ASTC_12x10_SRGB_BLOCK + = showString "VK_FORMAT_ASTC_12x10_SRGB_BLOCK" + showsPrec _ VK_FORMAT_ASTC_12x12_UNORM_BLOCK + = showString "VK_FORMAT_ASTC_12x12_UNORM_BLOCK" + showsPrec _ VK_FORMAT_ASTC_12x12_SRGB_BLOCK + = showString "VK_FORMAT_ASTC_12x12_SRGB_BLOCK" + showsPrec p (VkFormat x) + = showParen (p >= 11) (showString "VkFormat " . showsPrec 11 x) + +instance Read VkFormat where + readPrec + = parens + (choose + [("VK_FORMAT_UNDEFINED", pure VK_FORMAT_UNDEFINED), + ("VK_FORMAT_R4G4_UNORM_PACK8", pure VK_FORMAT_R4G4_UNORM_PACK8), + ("VK_FORMAT_R4G4B4A4_UNORM_PACK16", + pure VK_FORMAT_R4G4B4A4_UNORM_PACK16), + ("VK_FORMAT_B4G4R4A4_UNORM_PACK16", + pure VK_FORMAT_B4G4R4A4_UNORM_PACK16), + ("VK_FORMAT_R5G6B5_UNORM_PACK16", + pure VK_FORMAT_R5G6B5_UNORM_PACK16), + ("VK_FORMAT_B5G6R5_UNORM_PACK16", + pure VK_FORMAT_B5G6R5_UNORM_PACK16), + ("VK_FORMAT_R5G5B5A1_UNORM_PACK16", + pure VK_FORMAT_R5G5B5A1_UNORM_PACK16), + ("VK_FORMAT_B5G5R5A1_UNORM_PACK16", + pure VK_FORMAT_B5G5R5A1_UNORM_PACK16), + ("VK_FORMAT_A1R5G5B5_UNORM_PACK16", + pure VK_FORMAT_A1R5G5B5_UNORM_PACK16), + ("VK_FORMAT_R8_UNORM", pure VK_FORMAT_R8_UNORM), + ("VK_FORMAT_R8_SNORM", pure VK_FORMAT_R8_SNORM), + ("VK_FORMAT_R8_USCALED", pure VK_FORMAT_R8_USCALED), + ("VK_FORMAT_R8_SSCALED", pure VK_FORMAT_R8_SSCALED), + ("VK_FORMAT_R8_UINT", pure VK_FORMAT_R8_UINT), + ("VK_FORMAT_R8_SINT", pure VK_FORMAT_R8_SINT), + ("VK_FORMAT_R8_SRGB", pure VK_FORMAT_R8_SRGB), + ("VK_FORMAT_R8G8_UNORM", pure VK_FORMAT_R8G8_UNORM), + ("VK_FORMAT_R8G8_SNORM", pure VK_FORMAT_R8G8_SNORM), + ("VK_FORMAT_R8G8_USCALED", pure VK_FORMAT_R8G8_USCALED), + ("VK_FORMAT_R8G8_SSCALED", pure VK_FORMAT_R8G8_SSCALED), + ("VK_FORMAT_R8G8_UINT", pure VK_FORMAT_R8G8_UINT), + ("VK_FORMAT_R8G8_SINT", pure VK_FORMAT_R8G8_SINT), + ("VK_FORMAT_R8G8_SRGB", pure VK_FORMAT_R8G8_SRGB), + ("VK_FORMAT_R8G8B8_UNORM", pure VK_FORMAT_R8G8B8_UNORM), + ("VK_FORMAT_R8G8B8_SNORM", pure VK_FORMAT_R8G8B8_SNORM), + ("VK_FORMAT_R8G8B8_USCALED", pure VK_FORMAT_R8G8B8_USCALED), + ("VK_FORMAT_R8G8B8_SSCALED", pure VK_FORMAT_R8G8B8_SSCALED), + ("VK_FORMAT_R8G8B8_UINT", pure VK_FORMAT_R8G8B8_UINT), + ("VK_FORMAT_R8G8B8_SINT", pure VK_FORMAT_R8G8B8_SINT), + ("VK_FORMAT_R8G8B8_SRGB", pure VK_FORMAT_R8G8B8_SRGB), + ("VK_FORMAT_B8G8R8_UNORM", pure VK_FORMAT_B8G8R8_UNORM), + ("VK_FORMAT_B8G8R8_SNORM", pure VK_FORMAT_B8G8R8_SNORM), + ("VK_FORMAT_B8G8R8_USCALED", pure VK_FORMAT_B8G8R8_USCALED), + ("VK_FORMAT_B8G8R8_SSCALED", pure VK_FORMAT_B8G8R8_SSCALED), + ("VK_FORMAT_B8G8R8_UINT", pure VK_FORMAT_B8G8R8_UINT), + ("VK_FORMAT_B8G8R8_SINT", pure VK_FORMAT_B8G8R8_SINT), + ("VK_FORMAT_B8G8R8_SRGB", pure VK_FORMAT_B8G8R8_SRGB), + ("VK_FORMAT_R8G8B8A8_UNORM", pure VK_FORMAT_R8G8B8A8_UNORM), + ("VK_FORMAT_R8G8B8A8_SNORM", pure VK_FORMAT_R8G8B8A8_SNORM), + ("VK_FORMAT_R8G8B8A8_USCALED", pure VK_FORMAT_R8G8B8A8_USCALED), + ("VK_FORMAT_R8G8B8A8_SSCALED", pure VK_FORMAT_R8G8B8A8_SSCALED), + ("VK_FORMAT_R8G8B8A8_UINT", pure VK_FORMAT_R8G8B8A8_UINT), + ("VK_FORMAT_R8G8B8A8_SINT", pure VK_FORMAT_R8G8B8A8_SINT), + ("VK_FORMAT_R8G8B8A8_SRGB", pure VK_FORMAT_R8G8B8A8_SRGB), + ("VK_FORMAT_B8G8R8A8_UNORM", pure VK_FORMAT_B8G8R8A8_UNORM), + ("VK_FORMAT_B8G8R8A8_SNORM", pure VK_FORMAT_B8G8R8A8_SNORM), + ("VK_FORMAT_B8G8R8A8_USCALED", pure VK_FORMAT_B8G8R8A8_USCALED), + ("VK_FORMAT_B8G8R8A8_SSCALED", pure VK_FORMAT_B8G8R8A8_SSCALED), + ("VK_FORMAT_B8G8R8A8_UINT", pure VK_FORMAT_B8G8R8A8_UINT), + ("VK_FORMAT_B8G8R8A8_SINT", pure VK_FORMAT_B8G8R8A8_SINT), + ("VK_FORMAT_B8G8R8A8_SRGB", pure VK_FORMAT_B8G8R8A8_SRGB), + ("VK_FORMAT_A8B8G8R8_UNORM_PACK32", + pure VK_FORMAT_A8B8G8R8_UNORM_PACK32), + ("VK_FORMAT_A8B8G8R8_SNORM_PACK32", + pure VK_FORMAT_A8B8G8R8_SNORM_PACK32), + ("VK_FORMAT_A8B8G8R8_USCALED_PACK32", + pure VK_FORMAT_A8B8G8R8_USCALED_PACK32), + ("VK_FORMAT_A8B8G8R8_SSCALED_PACK32", + pure VK_FORMAT_A8B8G8R8_SSCALED_PACK32), + ("VK_FORMAT_A8B8G8R8_UINT_PACK32", + pure VK_FORMAT_A8B8G8R8_UINT_PACK32), + ("VK_FORMAT_A8B8G8R8_SINT_PACK32", + pure VK_FORMAT_A8B8G8R8_SINT_PACK32), + ("VK_FORMAT_A8B8G8R8_SRGB_PACK32", + pure VK_FORMAT_A8B8G8R8_SRGB_PACK32), + ("VK_FORMAT_A2R10G10B10_UNORM_PACK32", + pure VK_FORMAT_A2R10G10B10_UNORM_PACK32), + ("VK_FORMAT_A2R10G10B10_SNORM_PACK32", + pure VK_FORMAT_A2R10G10B10_SNORM_PACK32), + ("VK_FORMAT_A2R10G10B10_USCALED_PACK32", + pure VK_FORMAT_A2R10G10B10_USCALED_PACK32), + ("VK_FORMAT_A2R10G10B10_SSCALED_PACK32", + pure VK_FORMAT_A2R10G10B10_SSCALED_PACK32), + ("VK_FORMAT_A2R10G10B10_UINT_PACK32", + pure VK_FORMAT_A2R10G10B10_UINT_PACK32), + ("VK_FORMAT_A2R10G10B10_SINT_PACK32", + pure VK_FORMAT_A2R10G10B10_SINT_PACK32), + ("VK_FORMAT_A2B10G10R10_UNORM_PACK32", + pure VK_FORMAT_A2B10G10R10_UNORM_PACK32), + ("VK_FORMAT_A2B10G10R10_SNORM_PACK32", + pure VK_FORMAT_A2B10G10R10_SNORM_PACK32), + ("VK_FORMAT_A2B10G10R10_USCALED_PACK32", + pure VK_FORMAT_A2B10G10R10_USCALED_PACK32), + ("VK_FORMAT_A2B10G10R10_SSCALED_PACK32", + pure VK_FORMAT_A2B10G10R10_SSCALED_PACK32), + ("VK_FORMAT_A2B10G10R10_UINT_PACK32", + pure VK_FORMAT_A2B10G10R10_UINT_PACK32), + ("VK_FORMAT_A2B10G10R10_SINT_PACK32", + pure VK_FORMAT_A2B10G10R10_SINT_PACK32), + ("VK_FORMAT_R16_UNORM", pure VK_FORMAT_R16_UNORM), + ("VK_FORMAT_R16_SNORM", pure VK_FORMAT_R16_SNORM), + ("VK_FORMAT_R16_USCALED", pure VK_FORMAT_R16_USCALED), + ("VK_FORMAT_R16_SSCALED", pure VK_FORMAT_R16_SSCALED), + ("VK_FORMAT_R16_UINT", pure VK_FORMAT_R16_UINT), + ("VK_FORMAT_R16_SINT", pure VK_FORMAT_R16_SINT), + ("VK_FORMAT_R16_SFLOAT", pure VK_FORMAT_R16_SFLOAT), + ("VK_FORMAT_R16G16_UNORM", pure VK_FORMAT_R16G16_UNORM), + ("VK_FORMAT_R16G16_SNORM", pure VK_FORMAT_R16G16_SNORM), + ("VK_FORMAT_R16G16_USCALED", pure VK_FORMAT_R16G16_USCALED), + ("VK_FORMAT_R16G16_SSCALED", pure VK_FORMAT_R16G16_SSCALED), + ("VK_FORMAT_R16G16_UINT", pure VK_FORMAT_R16G16_UINT), + ("VK_FORMAT_R16G16_SINT", pure VK_FORMAT_R16G16_SINT), + ("VK_FORMAT_R16G16_SFLOAT", pure VK_FORMAT_R16G16_SFLOAT), + ("VK_FORMAT_R16G16B16_UNORM", pure VK_FORMAT_R16G16B16_UNORM), + ("VK_FORMAT_R16G16B16_SNORM", pure VK_FORMAT_R16G16B16_SNORM), + ("VK_FORMAT_R16G16B16_USCALED", pure VK_FORMAT_R16G16B16_USCALED), + ("VK_FORMAT_R16G16B16_SSCALED", pure VK_FORMAT_R16G16B16_SSCALED), + ("VK_FORMAT_R16G16B16_UINT", pure VK_FORMAT_R16G16B16_UINT), + ("VK_FORMAT_R16G16B16_SINT", pure VK_FORMAT_R16G16B16_SINT), + ("VK_FORMAT_R16G16B16_SFLOAT", pure VK_FORMAT_R16G16B16_SFLOAT), + ("VK_FORMAT_R16G16B16A16_UNORM", + pure VK_FORMAT_R16G16B16A16_UNORM), + ("VK_FORMAT_R16G16B16A16_SNORM", + pure VK_FORMAT_R16G16B16A16_SNORM), + ("VK_FORMAT_R16G16B16A16_USCALED", + pure VK_FORMAT_R16G16B16A16_USCALED), + ("VK_FORMAT_R16G16B16A16_SSCALED", + pure VK_FORMAT_R16G16B16A16_SSCALED), + ("VK_FORMAT_R16G16B16A16_UINT", pure VK_FORMAT_R16G16B16A16_UINT), + ("VK_FORMAT_R16G16B16A16_SINT", pure VK_FORMAT_R16G16B16A16_SINT), + ("VK_FORMAT_R16G16B16A16_SFLOAT", + pure VK_FORMAT_R16G16B16A16_SFLOAT), + ("VK_FORMAT_R32_UINT", pure VK_FORMAT_R32_UINT), + ("VK_FORMAT_R32_SINT", pure VK_FORMAT_R32_SINT), + ("VK_FORMAT_R32_SFLOAT", pure VK_FORMAT_R32_SFLOAT), + ("VK_FORMAT_R32G32_UINT", pure VK_FORMAT_R32G32_UINT), + ("VK_FORMAT_R32G32_SINT", pure VK_FORMAT_R32G32_SINT), + ("VK_FORMAT_R32G32_SFLOAT", pure VK_FORMAT_R32G32_SFLOAT), + ("VK_FORMAT_R32G32B32_UINT", pure VK_FORMAT_R32G32B32_UINT), + ("VK_FORMAT_R32G32B32_SINT", pure VK_FORMAT_R32G32B32_SINT), + ("VK_FORMAT_R32G32B32_SFLOAT", pure VK_FORMAT_R32G32B32_SFLOAT), + ("VK_FORMAT_R32G32B32A32_UINT", pure VK_FORMAT_R32G32B32A32_UINT), + ("VK_FORMAT_R32G32B32A32_SINT", pure VK_FORMAT_R32G32B32A32_SINT), + ("VK_FORMAT_R32G32B32A32_SFLOAT", + pure VK_FORMAT_R32G32B32A32_SFLOAT), + ("VK_FORMAT_R64_UINT", pure VK_FORMAT_R64_UINT), + ("VK_FORMAT_R64_SINT", pure VK_FORMAT_R64_SINT), + ("VK_FORMAT_R64_SFLOAT", pure VK_FORMAT_R64_SFLOAT), + ("VK_FORMAT_R64G64_UINT", pure VK_FORMAT_R64G64_UINT), + ("VK_FORMAT_R64G64_SINT", pure VK_FORMAT_R64G64_SINT), + ("VK_FORMAT_R64G64_SFLOAT", pure VK_FORMAT_R64G64_SFLOAT), + ("VK_FORMAT_R64G64B64_UINT", pure VK_FORMAT_R64G64B64_UINT), + ("VK_FORMAT_R64G64B64_SINT", pure VK_FORMAT_R64G64B64_SINT), + ("VK_FORMAT_R64G64B64_SFLOAT", pure VK_FORMAT_R64G64B64_SFLOAT), + ("VK_FORMAT_R64G64B64A64_UINT", pure VK_FORMAT_R64G64B64A64_UINT), + ("VK_FORMAT_R64G64B64A64_SINT", pure VK_FORMAT_R64G64B64A64_SINT), + ("VK_FORMAT_R64G64B64A64_SFLOAT", + pure VK_FORMAT_R64G64B64A64_SFLOAT), + ("VK_FORMAT_B10G11R11_UFLOAT_PACK32", + pure VK_FORMAT_B10G11R11_UFLOAT_PACK32), + ("VK_FORMAT_E5B9G9R9_UFLOAT_PACK32", + pure VK_FORMAT_E5B9G9R9_UFLOAT_PACK32), + ("VK_FORMAT_D16_UNORM", pure VK_FORMAT_D16_UNORM), + ("VK_FORMAT_X8_D24_UNORM_PACK32", + pure VK_FORMAT_X8_D24_UNORM_PACK32), + ("VK_FORMAT_D32_SFLOAT", pure VK_FORMAT_D32_SFLOAT), + ("VK_FORMAT_S8_UINT", pure VK_FORMAT_S8_UINT), + ("VK_FORMAT_D16_UNORM_S8_UINT", pure VK_FORMAT_D16_UNORM_S8_UINT), + ("VK_FORMAT_D24_UNORM_S8_UINT", pure VK_FORMAT_D24_UNORM_S8_UINT), + ("VK_FORMAT_D32_SFLOAT_S8_UINT", + pure VK_FORMAT_D32_SFLOAT_S8_UINT), + ("VK_FORMAT_BC1_RGB_UNORM_BLOCK", + pure VK_FORMAT_BC1_RGB_UNORM_BLOCK), + ("VK_FORMAT_BC1_RGB_SRGB_BLOCK", + pure VK_FORMAT_BC1_RGB_SRGB_BLOCK), + ("VK_FORMAT_BC1_RGBA_UNORM_BLOCK", + pure VK_FORMAT_BC1_RGBA_UNORM_BLOCK), + ("VK_FORMAT_BC1_RGBA_SRGB_BLOCK", + pure VK_FORMAT_BC1_RGBA_SRGB_BLOCK), + ("VK_FORMAT_BC2_UNORM_BLOCK", pure VK_FORMAT_BC2_UNORM_BLOCK), + ("VK_FORMAT_BC2_SRGB_BLOCK", pure VK_FORMAT_BC2_SRGB_BLOCK), + ("VK_FORMAT_BC3_UNORM_BLOCK", pure VK_FORMAT_BC3_UNORM_BLOCK), + ("VK_FORMAT_BC3_SRGB_BLOCK", pure VK_FORMAT_BC3_SRGB_BLOCK), + ("VK_FORMAT_BC4_UNORM_BLOCK", pure VK_FORMAT_BC4_UNORM_BLOCK), + ("VK_FORMAT_BC4_SNORM_BLOCK", pure VK_FORMAT_BC4_SNORM_BLOCK), + ("VK_FORMAT_BC5_UNORM_BLOCK", pure VK_FORMAT_BC5_UNORM_BLOCK), + ("VK_FORMAT_BC5_SNORM_BLOCK", pure VK_FORMAT_BC5_SNORM_BLOCK), + ("VK_FORMAT_BC6H_UFLOAT_BLOCK", pure VK_FORMAT_BC6H_UFLOAT_BLOCK), + ("VK_FORMAT_BC6H_SFLOAT_BLOCK", pure VK_FORMAT_BC6H_SFLOAT_BLOCK), + ("VK_FORMAT_BC7_UNORM_BLOCK", pure VK_FORMAT_BC7_UNORM_BLOCK), + ("VK_FORMAT_BC7_SRGB_BLOCK", pure VK_FORMAT_BC7_SRGB_BLOCK), + ("VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK", + pure VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK), + ("VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK", + pure VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK), + ("VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK", + pure VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK), + ("VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK", + pure VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK), + ("VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK", + pure VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK), + ("VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK", + pure VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK), + ("VK_FORMAT_EAC_R11_UNORM_BLOCK", + pure VK_FORMAT_EAC_R11_UNORM_BLOCK), + ("VK_FORMAT_EAC_R11_SNORM_BLOCK", + pure VK_FORMAT_EAC_R11_SNORM_BLOCK), + ("VK_FORMAT_EAC_R11G11_UNORM_BLOCK", + pure VK_FORMAT_EAC_R11G11_UNORM_BLOCK), + ("VK_FORMAT_EAC_R11G11_SNORM_BLOCK", + pure VK_FORMAT_EAC_R11G11_SNORM_BLOCK), + ("VK_FORMAT_ASTC_4x4_UNORM_BLOCK", + pure VK_FORMAT_ASTC_4x4_UNORM_BLOCK), + ("VK_FORMAT_ASTC_4x4_SRGB_BLOCK", + pure VK_FORMAT_ASTC_4x4_SRGB_BLOCK), + ("VK_FORMAT_ASTC_5x4_UNORM_BLOCK", + pure VK_FORMAT_ASTC_5x4_UNORM_BLOCK), + ("VK_FORMAT_ASTC_5x4_SRGB_BLOCK", + pure VK_FORMAT_ASTC_5x4_SRGB_BLOCK), + ("VK_FORMAT_ASTC_5x5_UNORM_BLOCK", + pure VK_FORMAT_ASTC_5x5_UNORM_BLOCK), + ("VK_FORMAT_ASTC_5x5_SRGB_BLOCK", + pure VK_FORMAT_ASTC_5x5_SRGB_BLOCK), + ("VK_FORMAT_ASTC_6x5_UNORM_BLOCK", + pure VK_FORMAT_ASTC_6x5_UNORM_BLOCK), + ("VK_FORMAT_ASTC_6x5_SRGB_BLOCK", + pure VK_FORMAT_ASTC_6x5_SRGB_BLOCK), + ("VK_FORMAT_ASTC_6x6_UNORM_BLOCK", + pure VK_FORMAT_ASTC_6x6_UNORM_BLOCK), + ("VK_FORMAT_ASTC_6x6_SRGB_BLOCK", + pure VK_FORMAT_ASTC_6x6_SRGB_BLOCK), + ("VK_FORMAT_ASTC_8x5_UNORM_BLOCK", + pure VK_FORMAT_ASTC_8x5_UNORM_BLOCK), + ("VK_FORMAT_ASTC_8x5_SRGB_BLOCK", + pure VK_FORMAT_ASTC_8x5_SRGB_BLOCK), + ("VK_FORMAT_ASTC_8x6_UNORM_BLOCK", + pure VK_FORMAT_ASTC_8x6_UNORM_BLOCK), + ("VK_FORMAT_ASTC_8x6_SRGB_BLOCK", + pure VK_FORMAT_ASTC_8x6_SRGB_BLOCK), + ("VK_FORMAT_ASTC_8x8_UNORM_BLOCK", + pure VK_FORMAT_ASTC_8x8_UNORM_BLOCK), + ("VK_FORMAT_ASTC_8x8_SRGB_BLOCK", + pure VK_FORMAT_ASTC_8x8_SRGB_BLOCK), + ("VK_FORMAT_ASTC_10x5_UNORM_BLOCK", + pure VK_FORMAT_ASTC_10x5_UNORM_BLOCK), + ("VK_FORMAT_ASTC_10x5_SRGB_BLOCK", + pure VK_FORMAT_ASTC_10x5_SRGB_BLOCK), + ("VK_FORMAT_ASTC_10x6_UNORM_BLOCK", + pure VK_FORMAT_ASTC_10x6_UNORM_BLOCK), + ("VK_FORMAT_ASTC_10x6_SRGB_BLOCK", + pure VK_FORMAT_ASTC_10x6_SRGB_BLOCK), + ("VK_FORMAT_ASTC_10x8_UNORM_BLOCK", + pure VK_FORMAT_ASTC_10x8_UNORM_BLOCK), + ("VK_FORMAT_ASTC_10x8_SRGB_BLOCK", + pure VK_FORMAT_ASTC_10x8_SRGB_BLOCK), + ("VK_FORMAT_ASTC_10x10_UNORM_BLOCK", + pure VK_FORMAT_ASTC_10x10_UNORM_BLOCK), + ("VK_FORMAT_ASTC_10x10_SRGB_BLOCK", + pure VK_FORMAT_ASTC_10x10_SRGB_BLOCK), + ("VK_FORMAT_ASTC_12x10_UNORM_BLOCK", + pure VK_FORMAT_ASTC_12x10_UNORM_BLOCK), + ("VK_FORMAT_ASTC_12x10_SRGB_BLOCK", + pure VK_FORMAT_ASTC_12x10_SRGB_BLOCK), + ("VK_FORMAT_ASTC_12x12_UNORM_BLOCK", + pure VK_FORMAT_ASTC_12x12_UNORM_BLOCK), + ("VK_FORMAT_ASTC_12x12_SRGB_BLOCK", + pure VK_FORMAT_ASTC_12x12_SRGB_BLOCK)] + +++ + prec 10 + (expectP (Ident "VkFormat") >> (VkFormat <$> step readPrec))) + +pattern VK_FORMAT_UNDEFINED :: VkFormat + +pattern VK_FORMAT_UNDEFINED = VkFormat 0 + +pattern VK_FORMAT_R4G4_UNORM_PACK8 :: VkFormat + +pattern VK_FORMAT_R4G4_UNORM_PACK8 = VkFormat 1 + +pattern VK_FORMAT_R4G4B4A4_UNORM_PACK16 :: VkFormat + +pattern VK_FORMAT_R4G4B4A4_UNORM_PACK16 = VkFormat 2 + +pattern VK_FORMAT_B4G4R4A4_UNORM_PACK16 :: VkFormat + +pattern VK_FORMAT_B4G4R4A4_UNORM_PACK16 = VkFormat 3 + +pattern VK_FORMAT_R5G6B5_UNORM_PACK16 :: VkFormat + +pattern VK_FORMAT_R5G6B5_UNORM_PACK16 = VkFormat 4 + +pattern VK_FORMAT_B5G6R5_UNORM_PACK16 :: VkFormat + +pattern VK_FORMAT_B5G6R5_UNORM_PACK16 = VkFormat 5 + +pattern VK_FORMAT_R5G5B5A1_UNORM_PACK16 :: VkFormat + +pattern VK_FORMAT_R5G5B5A1_UNORM_PACK16 = VkFormat 6 + +pattern VK_FORMAT_B5G5R5A1_UNORM_PACK16 :: VkFormat + +pattern VK_FORMAT_B5G5R5A1_UNORM_PACK16 = VkFormat 7 + +pattern VK_FORMAT_A1R5G5B5_UNORM_PACK16 :: VkFormat + +pattern VK_FORMAT_A1R5G5B5_UNORM_PACK16 = VkFormat 8 + +pattern VK_FORMAT_R8_UNORM :: VkFormat + +pattern VK_FORMAT_R8_UNORM = VkFormat 9 + +pattern VK_FORMAT_R8_SNORM :: VkFormat + +pattern VK_FORMAT_R8_SNORM = VkFormat 10 + +pattern VK_FORMAT_R8_USCALED :: VkFormat + +pattern VK_FORMAT_R8_USCALED = VkFormat 11 + +pattern VK_FORMAT_R8_SSCALED :: VkFormat + +pattern VK_FORMAT_R8_SSCALED = VkFormat 12 + +pattern VK_FORMAT_R8_UINT :: VkFormat + +pattern VK_FORMAT_R8_UINT = VkFormat 13 + +pattern VK_FORMAT_R8_SINT :: VkFormat + +pattern VK_FORMAT_R8_SINT = VkFormat 14 + +pattern VK_FORMAT_R8_SRGB :: VkFormat + +pattern VK_FORMAT_R8_SRGB = VkFormat 15 + +pattern VK_FORMAT_R8G8_UNORM :: VkFormat + +pattern VK_FORMAT_R8G8_UNORM = VkFormat 16 + +pattern VK_FORMAT_R8G8_SNORM :: VkFormat + +pattern VK_FORMAT_R8G8_SNORM = VkFormat 17 + +pattern VK_FORMAT_R8G8_USCALED :: VkFormat + +pattern VK_FORMAT_R8G8_USCALED = VkFormat 18 + +pattern VK_FORMAT_R8G8_SSCALED :: VkFormat + +pattern VK_FORMAT_R8G8_SSCALED = VkFormat 19 + +pattern VK_FORMAT_R8G8_UINT :: VkFormat + +pattern VK_FORMAT_R8G8_UINT = VkFormat 20 + +pattern VK_FORMAT_R8G8_SINT :: VkFormat + +pattern VK_FORMAT_R8G8_SINT = VkFormat 21 + +pattern VK_FORMAT_R8G8_SRGB :: VkFormat + +pattern VK_FORMAT_R8G8_SRGB = VkFormat 22 + +pattern VK_FORMAT_R8G8B8_UNORM :: VkFormat + +pattern VK_FORMAT_R8G8B8_UNORM = VkFormat 23 + +pattern VK_FORMAT_R8G8B8_SNORM :: VkFormat + +pattern VK_FORMAT_R8G8B8_SNORM = VkFormat 24 + +pattern VK_FORMAT_R8G8B8_USCALED :: VkFormat + +pattern VK_FORMAT_R8G8B8_USCALED = VkFormat 25 + +pattern VK_FORMAT_R8G8B8_SSCALED :: VkFormat + +pattern VK_FORMAT_R8G8B8_SSCALED = VkFormat 26 + +pattern VK_FORMAT_R8G8B8_UINT :: VkFormat + +pattern VK_FORMAT_R8G8B8_UINT = VkFormat 27 + +pattern VK_FORMAT_R8G8B8_SINT :: VkFormat + +pattern VK_FORMAT_R8G8B8_SINT = VkFormat 28 + +pattern VK_FORMAT_R8G8B8_SRGB :: VkFormat + +pattern VK_FORMAT_R8G8B8_SRGB = VkFormat 29 + +pattern VK_FORMAT_B8G8R8_UNORM :: VkFormat + +pattern VK_FORMAT_B8G8R8_UNORM = VkFormat 30 + +pattern VK_FORMAT_B8G8R8_SNORM :: VkFormat + +pattern VK_FORMAT_B8G8R8_SNORM = VkFormat 31 + +pattern VK_FORMAT_B8G8R8_USCALED :: VkFormat + +pattern VK_FORMAT_B8G8R8_USCALED = VkFormat 32 + +pattern VK_FORMAT_B8G8R8_SSCALED :: VkFormat + +pattern VK_FORMAT_B8G8R8_SSCALED = VkFormat 33 + +pattern VK_FORMAT_B8G8R8_UINT :: VkFormat + +pattern VK_FORMAT_B8G8R8_UINT = VkFormat 34 + +pattern VK_FORMAT_B8G8R8_SINT :: VkFormat + +pattern VK_FORMAT_B8G8R8_SINT = VkFormat 35 + +pattern VK_FORMAT_B8G8R8_SRGB :: VkFormat + +pattern VK_FORMAT_B8G8R8_SRGB = VkFormat 36 + +pattern VK_FORMAT_R8G8B8A8_UNORM :: VkFormat + +pattern VK_FORMAT_R8G8B8A8_UNORM = VkFormat 37 + +pattern VK_FORMAT_R8G8B8A8_SNORM :: VkFormat + +pattern VK_FORMAT_R8G8B8A8_SNORM = VkFormat 38 + +pattern VK_FORMAT_R8G8B8A8_USCALED :: VkFormat + +pattern VK_FORMAT_R8G8B8A8_USCALED = VkFormat 39 + +pattern VK_FORMAT_R8G8B8A8_SSCALED :: VkFormat + +pattern VK_FORMAT_R8G8B8A8_SSCALED = VkFormat 40 + +pattern VK_FORMAT_R8G8B8A8_UINT :: VkFormat + +pattern VK_FORMAT_R8G8B8A8_UINT = VkFormat 41 + +pattern VK_FORMAT_R8G8B8A8_SINT :: VkFormat + +pattern VK_FORMAT_R8G8B8A8_SINT = VkFormat 42 + +pattern VK_FORMAT_R8G8B8A8_SRGB :: VkFormat + +pattern VK_FORMAT_R8G8B8A8_SRGB = VkFormat 43 + +pattern VK_FORMAT_B8G8R8A8_UNORM :: VkFormat + +pattern VK_FORMAT_B8G8R8A8_UNORM = VkFormat 44 + +pattern VK_FORMAT_B8G8R8A8_SNORM :: VkFormat + +pattern VK_FORMAT_B8G8R8A8_SNORM = VkFormat 45 + +pattern VK_FORMAT_B8G8R8A8_USCALED :: VkFormat + +pattern VK_FORMAT_B8G8R8A8_USCALED = VkFormat 46 + +pattern VK_FORMAT_B8G8R8A8_SSCALED :: VkFormat + +pattern VK_FORMAT_B8G8R8A8_SSCALED = VkFormat 47 + +pattern VK_FORMAT_B8G8R8A8_UINT :: VkFormat + +pattern VK_FORMAT_B8G8R8A8_UINT = VkFormat 48 + +pattern VK_FORMAT_B8G8R8A8_SINT :: VkFormat + +pattern VK_FORMAT_B8G8R8A8_SINT = VkFormat 49 + +pattern VK_FORMAT_B8G8R8A8_SRGB :: VkFormat + +pattern VK_FORMAT_B8G8R8A8_SRGB = VkFormat 50 + +pattern VK_FORMAT_A8B8G8R8_UNORM_PACK32 :: VkFormat + +pattern VK_FORMAT_A8B8G8R8_UNORM_PACK32 = VkFormat 51 + +pattern VK_FORMAT_A8B8G8R8_SNORM_PACK32 :: VkFormat + +pattern VK_FORMAT_A8B8G8R8_SNORM_PACK32 = VkFormat 52 + +pattern VK_FORMAT_A8B8G8R8_USCALED_PACK32 :: VkFormat + +pattern VK_FORMAT_A8B8G8R8_USCALED_PACK32 = VkFormat 53 + +pattern VK_FORMAT_A8B8G8R8_SSCALED_PACK32 :: VkFormat + +pattern VK_FORMAT_A8B8G8R8_SSCALED_PACK32 = VkFormat 54 + +pattern VK_FORMAT_A8B8G8R8_UINT_PACK32 :: VkFormat + +pattern VK_FORMAT_A8B8G8R8_UINT_PACK32 = VkFormat 55 + +pattern VK_FORMAT_A8B8G8R8_SINT_PACK32 :: VkFormat + +pattern VK_FORMAT_A8B8G8R8_SINT_PACK32 = VkFormat 56 + +pattern VK_FORMAT_A8B8G8R8_SRGB_PACK32 :: VkFormat + +pattern VK_FORMAT_A8B8G8R8_SRGB_PACK32 = VkFormat 57 + +pattern VK_FORMAT_A2R10G10B10_UNORM_PACK32 :: VkFormat + +pattern VK_FORMAT_A2R10G10B10_UNORM_PACK32 = VkFormat 58 + +pattern VK_FORMAT_A2R10G10B10_SNORM_PACK32 :: VkFormat + +pattern VK_FORMAT_A2R10G10B10_SNORM_PACK32 = VkFormat 59 + +pattern VK_FORMAT_A2R10G10B10_USCALED_PACK32 :: VkFormat + +pattern VK_FORMAT_A2R10G10B10_USCALED_PACK32 = VkFormat 60 + +pattern VK_FORMAT_A2R10G10B10_SSCALED_PACK32 :: VkFormat + +pattern VK_FORMAT_A2R10G10B10_SSCALED_PACK32 = VkFormat 61 + +pattern VK_FORMAT_A2R10G10B10_UINT_PACK32 :: VkFormat + +pattern VK_FORMAT_A2R10G10B10_UINT_PACK32 = VkFormat 62 + +pattern VK_FORMAT_A2R10G10B10_SINT_PACK32 :: VkFormat + +pattern VK_FORMAT_A2R10G10B10_SINT_PACK32 = VkFormat 63 + +pattern VK_FORMAT_A2B10G10R10_UNORM_PACK32 :: VkFormat + +pattern VK_FORMAT_A2B10G10R10_UNORM_PACK32 = VkFormat 64 + +pattern VK_FORMAT_A2B10G10R10_SNORM_PACK32 :: VkFormat + +pattern VK_FORMAT_A2B10G10R10_SNORM_PACK32 = VkFormat 65 + +pattern VK_FORMAT_A2B10G10R10_USCALED_PACK32 :: VkFormat + +pattern VK_FORMAT_A2B10G10R10_USCALED_PACK32 = VkFormat 66 + +pattern VK_FORMAT_A2B10G10R10_SSCALED_PACK32 :: VkFormat + +pattern VK_FORMAT_A2B10G10R10_SSCALED_PACK32 = VkFormat 67 + +pattern VK_FORMAT_A2B10G10R10_UINT_PACK32 :: VkFormat + +pattern VK_FORMAT_A2B10G10R10_UINT_PACK32 = VkFormat 68 + +pattern VK_FORMAT_A2B10G10R10_SINT_PACK32 :: VkFormat + +pattern VK_FORMAT_A2B10G10R10_SINT_PACK32 = VkFormat 69 + +pattern VK_FORMAT_R16_UNORM :: VkFormat + +pattern VK_FORMAT_R16_UNORM = VkFormat 70 + +pattern VK_FORMAT_R16_SNORM :: VkFormat + +pattern VK_FORMAT_R16_SNORM = VkFormat 71 + +pattern VK_FORMAT_R16_USCALED :: VkFormat + +pattern VK_FORMAT_R16_USCALED = VkFormat 72 + +pattern VK_FORMAT_R16_SSCALED :: VkFormat + +pattern VK_FORMAT_R16_SSCALED = VkFormat 73 + +pattern VK_FORMAT_R16_UINT :: VkFormat + +pattern VK_FORMAT_R16_UINT = VkFormat 74 + +pattern VK_FORMAT_R16_SINT :: VkFormat + +pattern VK_FORMAT_R16_SINT = VkFormat 75 + +pattern VK_FORMAT_R16_SFLOAT :: VkFormat + +pattern VK_FORMAT_R16_SFLOAT = VkFormat 76 + +pattern VK_FORMAT_R16G16_UNORM :: VkFormat + +pattern VK_FORMAT_R16G16_UNORM = VkFormat 77 + +pattern VK_FORMAT_R16G16_SNORM :: VkFormat + +pattern VK_FORMAT_R16G16_SNORM = VkFormat 78 + +pattern VK_FORMAT_R16G16_USCALED :: VkFormat + +pattern VK_FORMAT_R16G16_USCALED = VkFormat 79 + +pattern VK_FORMAT_R16G16_SSCALED :: VkFormat + +pattern VK_FORMAT_R16G16_SSCALED = VkFormat 80 + +pattern VK_FORMAT_R16G16_UINT :: VkFormat + +pattern VK_FORMAT_R16G16_UINT = VkFormat 81 + +pattern VK_FORMAT_R16G16_SINT :: VkFormat + +pattern VK_FORMAT_R16G16_SINT = VkFormat 82 + +pattern VK_FORMAT_R16G16_SFLOAT :: VkFormat + +pattern VK_FORMAT_R16G16_SFLOAT = VkFormat 83 + +pattern VK_FORMAT_R16G16B16_UNORM :: VkFormat + +pattern VK_FORMAT_R16G16B16_UNORM = VkFormat 84 + +pattern VK_FORMAT_R16G16B16_SNORM :: VkFormat + +pattern VK_FORMAT_R16G16B16_SNORM = VkFormat 85 + +pattern VK_FORMAT_R16G16B16_USCALED :: VkFormat + +pattern VK_FORMAT_R16G16B16_USCALED = VkFormat 86 + +pattern VK_FORMAT_R16G16B16_SSCALED :: VkFormat + +pattern VK_FORMAT_R16G16B16_SSCALED = VkFormat 87 + +pattern VK_FORMAT_R16G16B16_UINT :: VkFormat + +pattern VK_FORMAT_R16G16B16_UINT = VkFormat 88 + +pattern VK_FORMAT_R16G16B16_SINT :: VkFormat + +pattern VK_FORMAT_R16G16B16_SINT = VkFormat 89 + +pattern VK_FORMAT_R16G16B16_SFLOAT :: VkFormat + +pattern VK_FORMAT_R16G16B16_SFLOAT = VkFormat 90 + +pattern VK_FORMAT_R16G16B16A16_UNORM :: VkFormat + +pattern VK_FORMAT_R16G16B16A16_UNORM = VkFormat 91 + +pattern VK_FORMAT_R16G16B16A16_SNORM :: VkFormat + +pattern VK_FORMAT_R16G16B16A16_SNORM = VkFormat 92 + +pattern VK_FORMAT_R16G16B16A16_USCALED :: VkFormat + +pattern VK_FORMAT_R16G16B16A16_USCALED = VkFormat 93 + +pattern VK_FORMAT_R16G16B16A16_SSCALED :: VkFormat + +pattern VK_FORMAT_R16G16B16A16_SSCALED = VkFormat 94 + +pattern VK_FORMAT_R16G16B16A16_UINT :: VkFormat + +pattern VK_FORMAT_R16G16B16A16_UINT = VkFormat 95 + +pattern VK_FORMAT_R16G16B16A16_SINT :: VkFormat + +pattern VK_FORMAT_R16G16B16A16_SINT = VkFormat 96 + +pattern VK_FORMAT_R16G16B16A16_SFLOAT :: VkFormat + +pattern VK_FORMAT_R16G16B16A16_SFLOAT = VkFormat 97 + +pattern VK_FORMAT_R32_UINT :: VkFormat + +pattern VK_FORMAT_R32_UINT = VkFormat 98 + +pattern VK_FORMAT_R32_SINT :: VkFormat + +pattern VK_FORMAT_R32_SINT = VkFormat 99 + +pattern VK_FORMAT_R32_SFLOAT :: VkFormat + +pattern VK_FORMAT_R32_SFLOAT = VkFormat 100 + +pattern VK_FORMAT_R32G32_UINT :: VkFormat + +pattern VK_FORMAT_R32G32_UINT = VkFormat 101 + +pattern VK_FORMAT_R32G32_SINT :: VkFormat + +pattern VK_FORMAT_R32G32_SINT = VkFormat 102 + +pattern VK_FORMAT_R32G32_SFLOAT :: VkFormat + +pattern VK_FORMAT_R32G32_SFLOAT = VkFormat 103 + +pattern VK_FORMAT_R32G32B32_UINT :: VkFormat + +pattern VK_FORMAT_R32G32B32_UINT = VkFormat 104 + +pattern VK_FORMAT_R32G32B32_SINT :: VkFormat + +pattern VK_FORMAT_R32G32B32_SINT = VkFormat 105 + +pattern VK_FORMAT_R32G32B32_SFLOAT :: VkFormat + +pattern VK_FORMAT_R32G32B32_SFLOAT = VkFormat 106 + +pattern VK_FORMAT_R32G32B32A32_UINT :: VkFormat + +pattern VK_FORMAT_R32G32B32A32_UINT = VkFormat 107 + +pattern VK_FORMAT_R32G32B32A32_SINT :: VkFormat + +pattern VK_FORMAT_R32G32B32A32_SINT = VkFormat 108 + +pattern VK_FORMAT_R32G32B32A32_SFLOAT :: VkFormat + +pattern VK_FORMAT_R32G32B32A32_SFLOAT = VkFormat 109 + +pattern VK_FORMAT_R64_UINT :: VkFormat + +pattern VK_FORMAT_R64_UINT = VkFormat 110 + +pattern VK_FORMAT_R64_SINT :: VkFormat + +pattern VK_FORMAT_R64_SINT = VkFormat 111 + +pattern VK_FORMAT_R64_SFLOAT :: VkFormat + +pattern VK_FORMAT_R64_SFLOAT = VkFormat 112 + +pattern VK_FORMAT_R64G64_UINT :: VkFormat + +pattern VK_FORMAT_R64G64_UINT = VkFormat 113 + +pattern VK_FORMAT_R64G64_SINT :: VkFormat + +pattern VK_FORMAT_R64G64_SINT = VkFormat 114 + +pattern VK_FORMAT_R64G64_SFLOAT :: VkFormat + +pattern VK_FORMAT_R64G64_SFLOAT = VkFormat 115 + +pattern VK_FORMAT_R64G64B64_UINT :: VkFormat + +pattern VK_FORMAT_R64G64B64_UINT = VkFormat 116 + +pattern VK_FORMAT_R64G64B64_SINT :: VkFormat + +pattern VK_FORMAT_R64G64B64_SINT = VkFormat 117 + +pattern VK_FORMAT_R64G64B64_SFLOAT :: VkFormat + +pattern VK_FORMAT_R64G64B64_SFLOAT = VkFormat 118 + +pattern VK_FORMAT_R64G64B64A64_UINT :: VkFormat + +pattern VK_FORMAT_R64G64B64A64_UINT = VkFormat 119 + +pattern VK_FORMAT_R64G64B64A64_SINT :: VkFormat + +pattern VK_FORMAT_R64G64B64A64_SINT = VkFormat 120 + +pattern VK_FORMAT_R64G64B64A64_SFLOAT :: VkFormat + +pattern VK_FORMAT_R64G64B64A64_SFLOAT = VkFormat 121 + +pattern VK_FORMAT_B10G11R11_UFLOAT_PACK32 :: VkFormat + +pattern VK_FORMAT_B10G11R11_UFLOAT_PACK32 = VkFormat 122 + +pattern VK_FORMAT_E5B9G9R9_UFLOAT_PACK32 :: VkFormat + +pattern VK_FORMAT_E5B9G9R9_UFLOAT_PACK32 = VkFormat 123 + +pattern VK_FORMAT_D16_UNORM :: VkFormat + +pattern VK_FORMAT_D16_UNORM = VkFormat 124 + +pattern VK_FORMAT_X8_D24_UNORM_PACK32 :: VkFormat + +pattern VK_FORMAT_X8_D24_UNORM_PACK32 = VkFormat 125 + +pattern VK_FORMAT_D32_SFLOAT :: VkFormat + +pattern VK_FORMAT_D32_SFLOAT = VkFormat 126 + +pattern VK_FORMAT_S8_UINT :: VkFormat + +pattern VK_FORMAT_S8_UINT = VkFormat 127 + +pattern VK_FORMAT_D16_UNORM_S8_UINT :: VkFormat + +pattern VK_FORMAT_D16_UNORM_S8_UINT = VkFormat 128 + +pattern VK_FORMAT_D24_UNORM_S8_UINT :: VkFormat + +pattern VK_FORMAT_D24_UNORM_S8_UINT = VkFormat 129 + +pattern VK_FORMAT_D32_SFLOAT_S8_UINT :: VkFormat + +pattern VK_FORMAT_D32_SFLOAT_S8_UINT = VkFormat 130 + +pattern VK_FORMAT_BC1_RGB_UNORM_BLOCK :: VkFormat + +pattern VK_FORMAT_BC1_RGB_UNORM_BLOCK = VkFormat 131 + +pattern VK_FORMAT_BC1_RGB_SRGB_BLOCK :: VkFormat + +pattern VK_FORMAT_BC1_RGB_SRGB_BLOCK = VkFormat 132 + +pattern VK_FORMAT_BC1_RGBA_UNORM_BLOCK :: VkFormat + +pattern VK_FORMAT_BC1_RGBA_UNORM_BLOCK = VkFormat 133 + +pattern VK_FORMAT_BC1_RGBA_SRGB_BLOCK :: VkFormat + +pattern VK_FORMAT_BC1_RGBA_SRGB_BLOCK = VkFormat 134 + +pattern VK_FORMAT_BC2_UNORM_BLOCK :: VkFormat + +pattern VK_FORMAT_BC2_UNORM_BLOCK = VkFormat 135 + +pattern VK_FORMAT_BC2_SRGB_BLOCK :: VkFormat + +pattern VK_FORMAT_BC2_SRGB_BLOCK = VkFormat 136 + +pattern VK_FORMAT_BC3_UNORM_BLOCK :: VkFormat + +pattern VK_FORMAT_BC3_UNORM_BLOCK = VkFormat 137 + +pattern VK_FORMAT_BC3_SRGB_BLOCK :: VkFormat + +pattern VK_FORMAT_BC3_SRGB_BLOCK = VkFormat 138 + +pattern VK_FORMAT_BC4_UNORM_BLOCK :: VkFormat + +pattern VK_FORMAT_BC4_UNORM_BLOCK = VkFormat 139 + +pattern VK_FORMAT_BC4_SNORM_BLOCK :: VkFormat + +pattern VK_FORMAT_BC4_SNORM_BLOCK = VkFormat 140 + +pattern VK_FORMAT_BC5_UNORM_BLOCK :: VkFormat + +pattern VK_FORMAT_BC5_UNORM_BLOCK = VkFormat 141 + +pattern VK_FORMAT_BC5_SNORM_BLOCK :: VkFormat + +pattern VK_FORMAT_BC5_SNORM_BLOCK = VkFormat 142 + +pattern VK_FORMAT_BC6H_UFLOAT_BLOCK :: VkFormat + +pattern VK_FORMAT_BC6H_UFLOAT_BLOCK = VkFormat 143 + +pattern VK_FORMAT_BC6H_SFLOAT_BLOCK :: VkFormat + +pattern VK_FORMAT_BC6H_SFLOAT_BLOCK = VkFormat 144 + +pattern VK_FORMAT_BC7_UNORM_BLOCK :: VkFormat + +pattern VK_FORMAT_BC7_UNORM_BLOCK = VkFormat 145 + +pattern VK_FORMAT_BC7_SRGB_BLOCK :: VkFormat + +pattern VK_FORMAT_BC7_SRGB_BLOCK = VkFormat 146 + +pattern VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK :: VkFormat + +pattern VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK = VkFormat 147 + +pattern VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK :: VkFormat + +pattern VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK = VkFormat 148 + +pattern VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK :: VkFormat + +pattern VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK = VkFormat 149 + +pattern VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK :: VkFormat + +pattern VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK = VkFormat 150 + +pattern VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK :: VkFormat + +pattern VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK = VkFormat 151 + +pattern VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK :: VkFormat + +pattern VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK = VkFormat 152 + +pattern VK_FORMAT_EAC_R11_UNORM_BLOCK :: VkFormat + +pattern VK_FORMAT_EAC_R11_UNORM_BLOCK = VkFormat 153 + +pattern VK_FORMAT_EAC_R11_SNORM_BLOCK :: VkFormat + +pattern VK_FORMAT_EAC_R11_SNORM_BLOCK = VkFormat 154 + +pattern VK_FORMAT_EAC_R11G11_UNORM_BLOCK :: VkFormat + +pattern VK_FORMAT_EAC_R11G11_UNORM_BLOCK = VkFormat 155 + +pattern VK_FORMAT_EAC_R11G11_SNORM_BLOCK :: VkFormat + +pattern VK_FORMAT_EAC_R11G11_SNORM_BLOCK = VkFormat 156 + +pattern VK_FORMAT_ASTC_4x4_UNORM_BLOCK :: VkFormat + +pattern VK_FORMAT_ASTC_4x4_UNORM_BLOCK = VkFormat 157 + +pattern VK_FORMAT_ASTC_4x4_SRGB_BLOCK :: VkFormat + +pattern VK_FORMAT_ASTC_4x4_SRGB_BLOCK = VkFormat 158 + +pattern VK_FORMAT_ASTC_5x4_UNORM_BLOCK :: VkFormat + +pattern VK_FORMAT_ASTC_5x4_UNORM_BLOCK = VkFormat 159 + +pattern VK_FORMAT_ASTC_5x4_SRGB_BLOCK :: VkFormat + +pattern VK_FORMAT_ASTC_5x4_SRGB_BLOCK = VkFormat 160 + +pattern VK_FORMAT_ASTC_5x5_UNORM_BLOCK :: VkFormat + +pattern VK_FORMAT_ASTC_5x5_UNORM_BLOCK = VkFormat 161 + +pattern VK_FORMAT_ASTC_5x5_SRGB_BLOCK :: VkFormat + +pattern VK_FORMAT_ASTC_5x5_SRGB_BLOCK = VkFormat 162 + +pattern VK_FORMAT_ASTC_6x5_UNORM_BLOCK :: VkFormat + +pattern VK_FORMAT_ASTC_6x5_UNORM_BLOCK = VkFormat 163 + +pattern VK_FORMAT_ASTC_6x5_SRGB_BLOCK :: VkFormat + +pattern VK_FORMAT_ASTC_6x5_SRGB_BLOCK = VkFormat 164 + +pattern VK_FORMAT_ASTC_6x6_UNORM_BLOCK :: VkFormat + +pattern VK_FORMAT_ASTC_6x6_UNORM_BLOCK = VkFormat 165 + +pattern VK_FORMAT_ASTC_6x6_SRGB_BLOCK :: VkFormat + +pattern VK_FORMAT_ASTC_6x6_SRGB_BLOCK = VkFormat 166 + +pattern VK_FORMAT_ASTC_8x5_UNORM_BLOCK :: VkFormat + +pattern VK_FORMAT_ASTC_8x5_UNORM_BLOCK = VkFormat 167 + +pattern VK_FORMAT_ASTC_8x5_SRGB_BLOCK :: VkFormat + +pattern VK_FORMAT_ASTC_8x5_SRGB_BLOCK = VkFormat 168 + +pattern VK_FORMAT_ASTC_8x6_UNORM_BLOCK :: VkFormat + +pattern VK_FORMAT_ASTC_8x6_UNORM_BLOCK = VkFormat 169 + +pattern VK_FORMAT_ASTC_8x6_SRGB_BLOCK :: VkFormat + +pattern VK_FORMAT_ASTC_8x6_SRGB_BLOCK = VkFormat 170 + +pattern VK_FORMAT_ASTC_8x8_UNORM_BLOCK :: VkFormat + +pattern VK_FORMAT_ASTC_8x8_UNORM_BLOCK = VkFormat 171 + +pattern VK_FORMAT_ASTC_8x8_SRGB_BLOCK :: VkFormat + +pattern VK_FORMAT_ASTC_8x8_SRGB_BLOCK = VkFormat 172 + +pattern VK_FORMAT_ASTC_10x5_UNORM_BLOCK :: VkFormat + +pattern VK_FORMAT_ASTC_10x5_UNORM_BLOCK = VkFormat 173 + +pattern VK_FORMAT_ASTC_10x5_SRGB_BLOCK :: VkFormat + +pattern VK_FORMAT_ASTC_10x5_SRGB_BLOCK = VkFormat 174 + +pattern VK_FORMAT_ASTC_10x6_UNORM_BLOCK :: VkFormat + +pattern VK_FORMAT_ASTC_10x6_UNORM_BLOCK = VkFormat 175 + +pattern VK_FORMAT_ASTC_10x6_SRGB_BLOCK :: VkFormat + +pattern VK_FORMAT_ASTC_10x6_SRGB_BLOCK = VkFormat 176 + +pattern VK_FORMAT_ASTC_10x8_UNORM_BLOCK :: VkFormat + +pattern VK_FORMAT_ASTC_10x8_UNORM_BLOCK = VkFormat 177 + +pattern VK_FORMAT_ASTC_10x8_SRGB_BLOCK :: VkFormat + +pattern VK_FORMAT_ASTC_10x8_SRGB_BLOCK = VkFormat 178 + +pattern VK_FORMAT_ASTC_10x10_UNORM_BLOCK :: VkFormat + +pattern VK_FORMAT_ASTC_10x10_UNORM_BLOCK = VkFormat 179 + +pattern VK_FORMAT_ASTC_10x10_SRGB_BLOCK :: VkFormat + +pattern VK_FORMAT_ASTC_10x10_SRGB_BLOCK = VkFormat 180 + +pattern VK_FORMAT_ASTC_12x10_UNORM_BLOCK :: VkFormat + +pattern VK_FORMAT_ASTC_12x10_UNORM_BLOCK = VkFormat 181 + +pattern VK_FORMAT_ASTC_12x10_SRGB_BLOCK :: VkFormat + +pattern VK_FORMAT_ASTC_12x10_SRGB_BLOCK = VkFormat 182 + +pattern VK_FORMAT_ASTC_12x12_UNORM_BLOCK :: VkFormat + +pattern VK_FORMAT_ASTC_12x12_UNORM_BLOCK = VkFormat 183 + +pattern VK_FORMAT_ASTC_12x12_SRGB_BLOCK :: VkFormat + +pattern VK_FORMAT_ASTC_12x12_SRGB_BLOCK = VkFormat 184 diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkFormatFeatureFlags.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkFormatFeatureFlags.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkFormatFeatureFlags.hs @@ -0,0 +1,251 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE KindSignatures #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE StandaloneDeriving #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeSynonymInstances #-} +module Graphics.Vulkan.Types.Enum.VkFormatFeatureFlags + (VkFormatFeatureBitmask(VkFormatFeatureBitmask, + VkFormatFeatureFlags, VkFormatFeatureFlagBits, + VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT, + VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT, + VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT, + VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT, + VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT, + VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT, + VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT, + VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT, + VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT, + VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT, + VK_FORMAT_FEATURE_BLIT_SRC_BIT, VK_FORMAT_FEATURE_BLIT_DST_BIT, + VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT), + VkFormatFeatureFlags, VkFormatFeatureFlagBits) + where +import Data.Bits (Bits, FiniteBits) +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (FlagBit, FlagMask, FlagType) +import Graphics.Vulkan.Types.BaseTypes (VkFlags (..)) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +newtype VkFormatFeatureBitmask (a :: + FlagType) = VkFormatFeatureBitmask VkFlags + deriving (Eq, Ord, Storable, Data, Generic) + +type VkFormatFeatureFlags = VkFormatFeatureBitmask FlagMask + +type VkFormatFeatureFlagBits = VkFormatFeatureBitmask FlagBit + +pattern VkFormatFeatureFlagBits :: + VkFlags -> VkFormatFeatureBitmask FlagBit + +pattern VkFormatFeatureFlagBits n = VkFormatFeatureBitmask n + +pattern VkFormatFeatureFlags :: + VkFlags -> VkFormatFeatureBitmask FlagMask + +pattern VkFormatFeatureFlags n = VkFormatFeatureBitmask n + +deriving instance Bits (VkFormatFeatureBitmask FlagMask) + +deriving instance FiniteBits (VkFormatFeatureBitmask FlagMask) + +deriving instance Integral (VkFormatFeatureBitmask FlagMask) + +deriving instance Num (VkFormatFeatureBitmask FlagMask) + +deriving instance Bounded (VkFormatFeatureBitmask FlagMask) + +deriving instance Enum (VkFormatFeatureBitmask FlagMask) + +deriving instance Real (VkFormatFeatureBitmask FlagMask) + +instance Show (VkFormatFeatureBitmask a) where + showsPrec _ VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT + = showString "VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT" + showsPrec _ VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT + = showString "VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT" + showsPrec _ VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT + = showString "VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT" + showsPrec _ VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT + = showString "VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT" + showsPrec _ VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT + = showString "VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT" + showsPrec _ VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT + = showString "VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT" + showsPrec _ VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT + = showString "VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT" + showsPrec _ VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT + = showString "VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT" + showsPrec _ VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT + = showString "VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT" + showsPrec _ VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT + = showString "VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT" + showsPrec _ VK_FORMAT_FEATURE_BLIT_SRC_BIT + = showString "VK_FORMAT_FEATURE_BLIT_SRC_BIT" + showsPrec _ VK_FORMAT_FEATURE_BLIT_DST_BIT + = showString "VK_FORMAT_FEATURE_BLIT_DST_BIT" + showsPrec _ VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT + = showString "VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT" + showsPrec p (VkFormatFeatureBitmask x) + = showParen (p >= 11) + (showString "VkFormatFeatureBitmask " . showsPrec 11 x) + +instance Read (VkFormatFeatureBitmask a) where + readPrec + = parens + (choose + [("VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT", + pure VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT), + ("VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT", + pure VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT), + ("VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT", + pure VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT), + ("VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT", + pure VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT), + ("VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT", + pure VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT), + ("VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT", + pure VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT), + ("VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT", + pure VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT), + ("VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT", + pure VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT), + ("VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT", + pure VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT), + ("VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT", + pure VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT), + ("VK_FORMAT_FEATURE_BLIT_SRC_BIT", + pure VK_FORMAT_FEATURE_BLIT_SRC_BIT), + ("VK_FORMAT_FEATURE_BLIT_DST_BIT", + pure VK_FORMAT_FEATURE_BLIT_DST_BIT), + ("VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT", + pure VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT)] + +++ + prec 10 + (expectP (Ident "VkFormatFeatureBitmask") >> + (VkFormatFeatureBitmask <$> step readPrec))) + +-- | Format can be used for sampled images (SAMPLED_IMAGE and COMBINED_IMAGE_SAMPLER descriptor types) +-- +-- bitpos = @0@ +pattern VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT :: + VkFormatFeatureBitmask a + +pattern VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT = + VkFormatFeatureBitmask 1 + +-- | Format can be used for storage images (STORAGE_IMAGE descriptor type) +-- +-- bitpos = @1@ +pattern VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT :: + VkFormatFeatureBitmask a + +pattern VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT = + VkFormatFeatureBitmask 2 + +-- | Format supports atomic operations in case it is used for storage images +-- +-- bitpos = @2@ +pattern VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT :: + VkFormatFeatureBitmask a + +pattern VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT = + VkFormatFeatureBitmask 4 + +-- | Format can be used for uniform texel buffers (TBOs) +-- +-- bitpos = @3@ +pattern VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT :: + VkFormatFeatureBitmask a + +pattern VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT = + VkFormatFeatureBitmask 8 + +-- | Format can be used for storage texel buffers (IBOs) +-- +-- bitpos = @4@ +pattern VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT :: + VkFormatFeatureBitmask a + +pattern VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT = + VkFormatFeatureBitmask 16 + +-- | Format supports atomic operations in case it is used for storage texel buffers +-- +-- bitpos = @5@ +pattern VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT :: + VkFormatFeatureBitmask a + +pattern VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT = + VkFormatFeatureBitmask 32 + +-- | Format can be used for vertex buffers (VBOs) +-- +-- bitpos = @6@ +pattern VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT :: + VkFormatFeatureBitmask a + +pattern VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT = + VkFormatFeatureBitmask 64 + +-- | Format can be used for color attachment images +-- +-- bitpos = @7@ +pattern VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT :: + VkFormatFeatureBitmask a + +pattern VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT = + VkFormatFeatureBitmask 128 + +-- | Format supports blending in case it is used for color attachment images +-- +-- bitpos = @8@ +pattern VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT :: + VkFormatFeatureBitmask a + +pattern VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT = + VkFormatFeatureBitmask 256 + +-- | Format can be used for depth/stencil attachment images +-- +-- bitpos = @9@ +pattern VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT :: + VkFormatFeatureBitmask a + +pattern VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT = + VkFormatFeatureBitmask 512 + +-- | Format can be used as the source image of blits with vkCmdBlitImage +-- +-- bitpos = @10@ +pattern VK_FORMAT_FEATURE_BLIT_SRC_BIT :: VkFormatFeatureBitmask a + +pattern VK_FORMAT_FEATURE_BLIT_SRC_BIT = + VkFormatFeatureBitmask 1024 + +-- | Format can be used as the destination image of blits with vkCmdBlitImage +-- +-- bitpos = @11@ +pattern VK_FORMAT_FEATURE_BLIT_DST_BIT :: VkFormatFeatureBitmask a + +pattern VK_FORMAT_FEATURE_BLIT_DST_BIT = + VkFormatFeatureBitmask 2048 + +-- | Format can be filtered with VK_FILTER_LINEAR when being sampled +-- +-- bitpos = @12@ +pattern VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT :: + VkFormatFeatureBitmask a + +pattern VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT = + VkFormatFeatureBitmask 4096 diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkFramebufferCreateFlagBits.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkFramebufferCreateFlagBits.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkFramebufferCreateFlagBits.hs @@ -0,0 +1,25 @@ +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE Strict #-} +module Graphics.Vulkan.Types.Enum.VkFramebufferCreateFlagBits + (VkFramebufferCreateFlagBits(..)) where +import Data.Bits (Bits, FiniteBits) +import Data.Coerce (coerce) +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import Graphics.Vulkan.Types.BaseTypes (VkFlags) + +newtype VkFramebufferCreateFlagBits = VkFramebufferCreateFlagBits VkFlags + deriving (Eq, Ord, Num, Bounded, Enum, Integral, Bits, + FiniteBits, Storable, Real, Data, Generic) + +instance Show VkFramebufferCreateFlagBits where + {-# INLINE show #-} + show (VkFramebufferCreateFlagBits x) = show x + +instance Read VkFramebufferCreateFlagBits where + {-# INLINE readsPrec #-} + readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags) diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkFrontFace.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkFrontFace.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkFrontFace.hs @@ -0,0 +1,52 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +module Graphics.Vulkan.Types.Enum.VkFrontFace + (VkFrontFace(VkFrontFace, VK_FRONT_FACE_COUNTER_CLOCKWISE, + VK_FRONT_FACE_CLOCKWISE)) + where +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (Int32) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +-- | type = @enum@ +-- +-- +newtype VkFrontFace = VkFrontFace Int32 + deriving (Eq, Ord, Num, Bounded, Storable, Enum, Data, Generic) + +instance Show VkFrontFace where + showsPrec _ VK_FRONT_FACE_COUNTER_CLOCKWISE + = showString "VK_FRONT_FACE_COUNTER_CLOCKWISE" + showsPrec _ VK_FRONT_FACE_CLOCKWISE + = showString "VK_FRONT_FACE_CLOCKWISE" + showsPrec p (VkFrontFace x) + = showParen (p >= 11) (showString "VkFrontFace " . showsPrec 11 x) + +instance Read VkFrontFace where + readPrec + = parens + (choose + [("VK_FRONT_FACE_COUNTER_CLOCKWISE", + pure VK_FRONT_FACE_COUNTER_CLOCKWISE), + ("VK_FRONT_FACE_CLOCKWISE", pure VK_FRONT_FACE_CLOCKWISE)] + +++ + prec 10 + (expectP (Ident "VkFrontFace") >> (VkFrontFace <$> step readPrec))) + +pattern VK_FRONT_FACE_COUNTER_CLOCKWISE :: VkFrontFace + +pattern VK_FRONT_FACE_COUNTER_CLOCKWISE = VkFrontFace 0 + +pattern VK_FRONT_FACE_CLOCKWISE :: VkFrontFace + +pattern VK_FRONT_FACE_CLOCKWISE = VkFrontFace 1 diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkImageAspectFlags.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkImageAspectFlags.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkImageAspectFlags.hs @@ -0,0 +1,107 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE KindSignatures #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE StandaloneDeriving #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeSynonymInstances #-} +module Graphics.Vulkan.Types.Enum.VkImageAspectFlags + (VkImageAspectBitmask(VkImageAspectBitmask, VkImageAspectFlags, + VkImageAspectFlagBits, VK_IMAGE_ASPECT_COLOR_BIT, + VK_IMAGE_ASPECT_DEPTH_BIT, VK_IMAGE_ASPECT_STENCIL_BIT, + VK_IMAGE_ASPECT_METADATA_BIT), + VkImageAspectFlags, VkImageAspectFlagBits) + where +import Data.Bits (Bits, FiniteBits) +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (FlagBit, FlagMask, FlagType) +import Graphics.Vulkan.Types.BaseTypes (VkFlags (..)) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +newtype VkImageAspectBitmask (a :: + FlagType) = VkImageAspectBitmask VkFlags + deriving (Eq, Ord, Storable, Data, Generic) + +type VkImageAspectFlags = VkImageAspectBitmask FlagMask + +type VkImageAspectFlagBits = VkImageAspectBitmask FlagBit + +pattern VkImageAspectFlagBits :: + VkFlags -> VkImageAspectBitmask FlagBit + +pattern VkImageAspectFlagBits n = VkImageAspectBitmask n + +pattern VkImageAspectFlags :: + VkFlags -> VkImageAspectBitmask FlagMask + +pattern VkImageAspectFlags n = VkImageAspectBitmask n + +deriving instance Bits (VkImageAspectBitmask FlagMask) + +deriving instance FiniteBits (VkImageAspectBitmask FlagMask) + +deriving instance Integral (VkImageAspectBitmask FlagMask) + +deriving instance Num (VkImageAspectBitmask FlagMask) + +deriving instance Bounded (VkImageAspectBitmask FlagMask) + +deriving instance Enum (VkImageAspectBitmask FlagMask) + +deriving instance Real (VkImageAspectBitmask FlagMask) + +instance Show (VkImageAspectBitmask a) where + showsPrec _ VK_IMAGE_ASPECT_COLOR_BIT + = showString "VK_IMAGE_ASPECT_COLOR_BIT" + showsPrec _ VK_IMAGE_ASPECT_DEPTH_BIT + = showString "VK_IMAGE_ASPECT_DEPTH_BIT" + showsPrec _ VK_IMAGE_ASPECT_STENCIL_BIT + = showString "VK_IMAGE_ASPECT_STENCIL_BIT" + showsPrec _ VK_IMAGE_ASPECT_METADATA_BIT + = showString "VK_IMAGE_ASPECT_METADATA_BIT" + showsPrec p (VkImageAspectBitmask x) + = showParen (p >= 11) + (showString "VkImageAspectBitmask " . showsPrec 11 x) + +instance Read (VkImageAspectBitmask a) where + readPrec + = parens + (choose + [("VK_IMAGE_ASPECT_COLOR_BIT", pure VK_IMAGE_ASPECT_COLOR_BIT), + ("VK_IMAGE_ASPECT_DEPTH_BIT", pure VK_IMAGE_ASPECT_DEPTH_BIT), + ("VK_IMAGE_ASPECT_STENCIL_BIT", pure VK_IMAGE_ASPECT_STENCIL_BIT), + ("VK_IMAGE_ASPECT_METADATA_BIT", + pure VK_IMAGE_ASPECT_METADATA_BIT)] + +++ + prec 10 + (expectP (Ident "VkImageAspectBitmask") >> + (VkImageAspectBitmask <$> step readPrec))) + +-- | bitpos = @0@ +pattern VK_IMAGE_ASPECT_COLOR_BIT :: VkImageAspectBitmask a + +pattern VK_IMAGE_ASPECT_COLOR_BIT = VkImageAspectBitmask 1 + +-- | bitpos = @1@ +pattern VK_IMAGE_ASPECT_DEPTH_BIT :: VkImageAspectBitmask a + +pattern VK_IMAGE_ASPECT_DEPTH_BIT = VkImageAspectBitmask 2 + +-- | bitpos = @2@ +pattern VK_IMAGE_ASPECT_STENCIL_BIT :: VkImageAspectBitmask a + +pattern VK_IMAGE_ASPECT_STENCIL_BIT = VkImageAspectBitmask 4 + +-- | bitpos = @3@ +pattern VK_IMAGE_ASPECT_METADATA_BIT :: VkImageAspectBitmask a + +pattern VK_IMAGE_ASPECT_METADATA_BIT = VkImageAspectBitmask 8 diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkImageCreateFlags.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkImageCreateFlags.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkImageCreateFlags.hs @@ -0,0 +1,138 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE KindSignatures #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE StandaloneDeriving #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeSynonymInstances #-} +module Graphics.Vulkan.Types.Enum.VkImageCreateFlags + (VkImageCreateBitmask(VkImageCreateBitmask, VkImageCreateFlags, + VkImageCreateFlagBits, VK_IMAGE_CREATE_SPARSE_BINDING_BIT, + VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT, + VK_IMAGE_CREATE_SPARSE_ALIASED_BIT, + VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT, + VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT), + VkImageCreateFlags, VkImageCreateFlagBits) + where +import Data.Bits (Bits, FiniteBits) +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (FlagBit, FlagMask, FlagType) +import Graphics.Vulkan.Types.BaseTypes (VkFlags (..)) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +newtype VkImageCreateBitmask (a :: + FlagType) = VkImageCreateBitmask VkFlags + deriving (Eq, Ord, Storable, Data, Generic) + +type VkImageCreateFlags = VkImageCreateBitmask FlagMask + +type VkImageCreateFlagBits = VkImageCreateBitmask FlagBit + +pattern VkImageCreateFlagBits :: + VkFlags -> VkImageCreateBitmask FlagBit + +pattern VkImageCreateFlagBits n = VkImageCreateBitmask n + +pattern VkImageCreateFlags :: + VkFlags -> VkImageCreateBitmask FlagMask + +pattern VkImageCreateFlags n = VkImageCreateBitmask n + +deriving instance Bits (VkImageCreateBitmask FlagMask) + +deriving instance FiniteBits (VkImageCreateBitmask FlagMask) + +deriving instance Integral (VkImageCreateBitmask FlagMask) + +deriving instance Num (VkImageCreateBitmask FlagMask) + +deriving instance Bounded (VkImageCreateBitmask FlagMask) + +deriving instance Enum (VkImageCreateBitmask FlagMask) + +deriving instance Real (VkImageCreateBitmask FlagMask) + +instance Show (VkImageCreateBitmask a) where + showsPrec _ VK_IMAGE_CREATE_SPARSE_BINDING_BIT + = showString "VK_IMAGE_CREATE_SPARSE_BINDING_BIT" + showsPrec _ VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT + = showString "VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT" + showsPrec _ VK_IMAGE_CREATE_SPARSE_ALIASED_BIT + = showString "VK_IMAGE_CREATE_SPARSE_ALIASED_BIT" + showsPrec _ VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT + = showString "VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT" + showsPrec _ VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT + = showString "VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT" + showsPrec p (VkImageCreateBitmask x) + = showParen (p >= 11) + (showString "VkImageCreateBitmask " . showsPrec 11 x) + +instance Read (VkImageCreateBitmask a) where + readPrec + = parens + (choose + [("VK_IMAGE_CREATE_SPARSE_BINDING_BIT", + pure VK_IMAGE_CREATE_SPARSE_BINDING_BIT), + ("VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT", + pure VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT), + ("VK_IMAGE_CREATE_SPARSE_ALIASED_BIT", + pure VK_IMAGE_CREATE_SPARSE_ALIASED_BIT), + ("VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT", + pure VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT), + ("VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT", + pure VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT)] + +++ + prec 10 + (expectP (Ident "VkImageCreateBitmask") >> + (VkImageCreateBitmask <$> step readPrec))) + +-- | Image should support sparse backing +-- +-- bitpos = @0@ +pattern VK_IMAGE_CREATE_SPARSE_BINDING_BIT :: + VkImageCreateBitmask a + +pattern VK_IMAGE_CREATE_SPARSE_BINDING_BIT = VkImageCreateBitmask 1 + +-- | Image should support sparse backing with partial residency +-- +-- bitpos = @1@ +pattern VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT :: + VkImageCreateBitmask a + +pattern VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT = + VkImageCreateBitmask 2 + +-- | Image should support constent data access to physical memory ranges mapped into multiple locations of sparse images +-- +-- bitpos = @2@ +pattern VK_IMAGE_CREATE_SPARSE_ALIASED_BIT :: + VkImageCreateBitmask a + +pattern VK_IMAGE_CREATE_SPARSE_ALIASED_BIT = VkImageCreateBitmask 4 + +-- | Allows image views to have different format than the base image +-- +-- bitpos = @3@ +pattern VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT :: + VkImageCreateBitmask a + +pattern VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT = VkImageCreateBitmask 8 + +-- | Allows creating image views with cube type from the created image +-- +-- bitpos = @4@ +pattern VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT :: + VkImageCreateBitmask a + +pattern VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT = + VkImageCreateBitmask 16 diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkImageLayout.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkImageLayout.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkImageLayout.hs @@ -0,0 +1,128 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +module Graphics.Vulkan.Types.Enum.VkImageLayout + (VkImageLayout(VkImageLayout, VK_IMAGE_LAYOUT_UNDEFINED, + VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, + VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, + VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL, + VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, + VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, + VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, + VK_IMAGE_LAYOUT_PREINITIALIZED)) + where +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (Int32) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +-- | type = @enum@ +-- +-- +newtype VkImageLayout = VkImageLayout Int32 + deriving (Eq, Ord, Num, Bounded, Storable, Enum, Data, Generic) + +instance Show VkImageLayout where + showsPrec _ VK_IMAGE_LAYOUT_UNDEFINED + = showString "VK_IMAGE_LAYOUT_UNDEFINED" + showsPrec _ VK_IMAGE_LAYOUT_GENERAL + = showString "VK_IMAGE_LAYOUT_GENERAL" + showsPrec _ VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL + = showString "VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL" + showsPrec _ VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL + = showString "VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL" + showsPrec _ VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL + = showString "VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL" + showsPrec _ VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL + = showString "VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL" + showsPrec _ VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL + = showString "VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL" + showsPrec _ VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL + = showString "VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL" + showsPrec _ VK_IMAGE_LAYOUT_PREINITIALIZED + = showString "VK_IMAGE_LAYOUT_PREINITIALIZED" + showsPrec p (VkImageLayout x) + = showParen (p >= 11) + (showString "VkImageLayout " . showsPrec 11 x) + +instance Read VkImageLayout where + readPrec + = parens + (choose + [("VK_IMAGE_LAYOUT_UNDEFINED", pure VK_IMAGE_LAYOUT_UNDEFINED), + ("VK_IMAGE_LAYOUT_GENERAL", pure VK_IMAGE_LAYOUT_GENERAL), + ("VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL", + pure VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL), + ("VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL", + pure VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL), + ("VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL", + pure VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL), + ("VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL", + pure VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL), + ("VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL", + pure VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL), + ("VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL", + pure VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL), + ("VK_IMAGE_LAYOUT_PREINITIALIZED", + pure VK_IMAGE_LAYOUT_PREINITIALIZED)] + +++ + prec 10 + (expectP (Ident "VkImageLayout") >> + (VkImageLayout <$> step readPrec))) + +-- | Implicit layout an image is when its contents are undefined due to various reasons (e.g. right after creation) +pattern VK_IMAGE_LAYOUT_UNDEFINED :: VkImageLayout + +pattern VK_IMAGE_LAYOUT_UNDEFINED = VkImageLayout 0 + +-- | General layout when image can be used for any kind of access +pattern VK_IMAGE_LAYOUT_GENERAL :: VkImageLayout + +pattern VK_IMAGE_LAYOUT_GENERAL = VkImageLayout 1 + +-- | Optimal layout when image is only used for color attachment read/write +pattern VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL :: VkImageLayout + +pattern VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL = VkImageLayout 2 + +-- | Optimal layout when image is only used for depth/stencil attachment read/write +pattern VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL :: + VkImageLayout + +pattern VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL = + VkImageLayout 3 + +-- | Optimal layout when image is used for read only depth/stencil attachment and shader access +pattern VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL :: + VkImageLayout + +pattern VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL = + VkImageLayout 4 + +-- | Optimal layout when image is used for read only shader access +pattern VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL :: VkImageLayout + +pattern VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL = VkImageLayout 5 + +-- | Optimal layout when image is used only as source of transfer operations +pattern VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL :: VkImageLayout + +pattern VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL = VkImageLayout 6 + +-- | Optimal layout when image is used only as destination of transfer operations +pattern VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL :: VkImageLayout + +pattern VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL = VkImageLayout 7 + +-- | Initial layout used when the data is populated by the CPU +pattern VK_IMAGE_LAYOUT_PREINITIALIZED :: VkImageLayout + +pattern VK_IMAGE_LAYOUT_PREINITIALIZED = VkImageLayout 8 diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkImageTiling.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkImageTiling.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkImageTiling.hs @@ -0,0 +1,53 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +module Graphics.Vulkan.Types.Enum.VkImageTiling + (VkImageTiling(VkImageTiling, VK_IMAGE_TILING_OPTIMAL, + VK_IMAGE_TILING_LINEAR)) + where +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (Int32) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +-- | type = @enum@ +-- +-- +newtype VkImageTiling = VkImageTiling Int32 + deriving (Eq, Ord, Num, Bounded, Storable, Enum, Data, Generic) + +instance Show VkImageTiling where + showsPrec _ VK_IMAGE_TILING_OPTIMAL + = showString "VK_IMAGE_TILING_OPTIMAL" + showsPrec _ VK_IMAGE_TILING_LINEAR + = showString "VK_IMAGE_TILING_LINEAR" + showsPrec p (VkImageTiling x) + = showParen (p >= 11) + (showString "VkImageTiling " . showsPrec 11 x) + +instance Read VkImageTiling where + readPrec + = parens + (choose + [("VK_IMAGE_TILING_OPTIMAL", pure VK_IMAGE_TILING_OPTIMAL), + ("VK_IMAGE_TILING_LINEAR", pure VK_IMAGE_TILING_LINEAR)] + +++ + prec 10 + (expectP (Ident "VkImageTiling") >> + (VkImageTiling <$> step readPrec))) + +pattern VK_IMAGE_TILING_OPTIMAL :: VkImageTiling + +pattern VK_IMAGE_TILING_OPTIMAL = VkImageTiling 0 + +pattern VK_IMAGE_TILING_LINEAR :: VkImageTiling + +pattern VK_IMAGE_TILING_LINEAR = VkImageTiling 1 diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkImageType.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkImageType.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkImageType.hs @@ -0,0 +1,55 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +module Graphics.Vulkan.Types.Enum.VkImageType + (VkImageType(VkImageType, VK_IMAGE_TYPE_1D, VK_IMAGE_TYPE_2D, + VK_IMAGE_TYPE_3D)) + where +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (Int32) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +-- | type = @enum@ +-- +-- +newtype VkImageType = VkImageType Int32 + deriving (Eq, Ord, Num, Bounded, Storable, Enum, Data, Generic) + +instance Show VkImageType where + showsPrec _ VK_IMAGE_TYPE_1D = showString "VK_IMAGE_TYPE_1D" + showsPrec _ VK_IMAGE_TYPE_2D = showString "VK_IMAGE_TYPE_2D" + showsPrec _ VK_IMAGE_TYPE_3D = showString "VK_IMAGE_TYPE_3D" + showsPrec p (VkImageType x) + = showParen (p >= 11) (showString "VkImageType " . showsPrec 11 x) + +instance Read VkImageType where + readPrec + = parens + (choose + [("VK_IMAGE_TYPE_1D", pure VK_IMAGE_TYPE_1D), + ("VK_IMAGE_TYPE_2D", pure VK_IMAGE_TYPE_2D), + ("VK_IMAGE_TYPE_3D", pure VK_IMAGE_TYPE_3D)] + +++ + prec 10 + (expectP (Ident "VkImageType") >> (VkImageType <$> step readPrec))) + +pattern VK_IMAGE_TYPE_1D :: VkImageType + +pattern VK_IMAGE_TYPE_1D = VkImageType 0 + +pattern VK_IMAGE_TYPE_2D :: VkImageType + +pattern VK_IMAGE_TYPE_2D = VkImageType 1 + +pattern VK_IMAGE_TYPE_3D :: VkImageType + +pattern VK_IMAGE_TYPE_3D = VkImageType 2 diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkImageUsageFlags.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkImageUsageFlags.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkImageUsageFlags.hs @@ -0,0 +1,171 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE KindSignatures #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE StandaloneDeriving #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeSynonymInstances #-} +module Graphics.Vulkan.Types.Enum.VkImageUsageFlags + (VkImageUsageBitmask(VkImageUsageBitmask, VkImageUsageFlags, + VkImageUsageFlagBits, VK_IMAGE_USAGE_TRANSFER_SRC_BIT, + VK_IMAGE_USAGE_TRANSFER_DST_BIT, VK_IMAGE_USAGE_SAMPLED_BIT, + VK_IMAGE_USAGE_STORAGE_BIT, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, + VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, + VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT, + VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT), + VkImageUsageFlags, VkImageUsageFlagBits) + where +import Data.Bits (Bits, FiniteBits) +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (FlagBit, FlagMask, FlagType) +import Graphics.Vulkan.Types.BaseTypes (VkFlags (..)) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +newtype VkImageUsageBitmask (a :: + FlagType) = VkImageUsageBitmask VkFlags + deriving (Eq, Ord, Storable, Data, Generic) + +type VkImageUsageFlags = VkImageUsageBitmask FlagMask + +type VkImageUsageFlagBits = VkImageUsageBitmask FlagBit + +pattern VkImageUsageFlagBits :: + VkFlags -> VkImageUsageBitmask FlagBit + +pattern VkImageUsageFlagBits n = VkImageUsageBitmask n + +pattern VkImageUsageFlags :: + VkFlags -> VkImageUsageBitmask FlagMask + +pattern VkImageUsageFlags n = VkImageUsageBitmask n + +deriving instance Bits (VkImageUsageBitmask FlagMask) + +deriving instance FiniteBits (VkImageUsageBitmask FlagMask) + +deriving instance Integral (VkImageUsageBitmask FlagMask) + +deriving instance Num (VkImageUsageBitmask FlagMask) + +deriving instance Bounded (VkImageUsageBitmask FlagMask) + +deriving instance Enum (VkImageUsageBitmask FlagMask) + +deriving instance Real (VkImageUsageBitmask FlagMask) + +instance Show (VkImageUsageBitmask a) where + showsPrec _ VK_IMAGE_USAGE_TRANSFER_SRC_BIT + = showString "VK_IMAGE_USAGE_TRANSFER_SRC_BIT" + showsPrec _ VK_IMAGE_USAGE_TRANSFER_DST_BIT + = showString "VK_IMAGE_USAGE_TRANSFER_DST_BIT" + showsPrec _ VK_IMAGE_USAGE_SAMPLED_BIT + = showString "VK_IMAGE_USAGE_SAMPLED_BIT" + showsPrec _ VK_IMAGE_USAGE_STORAGE_BIT + = showString "VK_IMAGE_USAGE_STORAGE_BIT" + showsPrec _ VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT + = showString "VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT" + showsPrec _ VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT + = showString "VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT" + showsPrec _ VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT + = showString "VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT" + showsPrec _ VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT + = showString "VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT" + showsPrec p (VkImageUsageBitmask x) + = showParen (p >= 11) + (showString "VkImageUsageBitmask " . showsPrec 11 x) + +instance Read (VkImageUsageBitmask a) where + readPrec + = parens + (choose + [("VK_IMAGE_USAGE_TRANSFER_SRC_BIT", + pure VK_IMAGE_USAGE_TRANSFER_SRC_BIT), + ("VK_IMAGE_USAGE_TRANSFER_DST_BIT", + pure VK_IMAGE_USAGE_TRANSFER_DST_BIT), + ("VK_IMAGE_USAGE_SAMPLED_BIT", pure VK_IMAGE_USAGE_SAMPLED_BIT), + ("VK_IMAGE_USAGE_STORAGE_BIT", pure VK_IMAGE_USAGE_STORAGE_BIT), + ("VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT", + pure VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT), + ("VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT", + pure VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT), + ("VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT", + pure VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT), + ("VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT", + pure VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT)] + +++ + prec 10 + (expectP (Ident "VkImageUsageBitmask") >> + (VkImageUsageBitmask <$> step readPrec))) + +-- | Can be used as a source of transfer operations +-- +-- bitpos = @0@ +pattern VK_IMAGE_USAGE_TRANSFER_SRC_BIT :: VkImageUsageBitmask a + +pattern VK_IMAGE_USAGE_TRANSFER_SRC_BIT = VkImageUsageBitmask 1 + +-- | Can be used as a destination of transfer operations +-- +-- bitpos = @1@ +pattern VK_IMAGE_USAGE_TRANSFER_DST_BIT :: VkImageUsageBitmask a + +pattern VK_IMAGE_USAGE_TRANSFER_DST_BIT = VkImageUsageBitmask 2 + +-- | Can be sampled from (SAMPLED_IMAGE and COMBINED_IMAGE_SAMPLER descriptor types) +-- +-- bitpos = @2@ +pattern VK_IMAGE_USAGE_SAMPLED_BIT :: VkImageUsageBitmask a + +pattern VK_IMAGE_USAGE_SAMPLED_BIT = VkImageUsageBitmask 4 + +-- | Can be used as storage image (STORAGE_IMAGE descriptor type) +-- +-- bitpos = @3@ +pattern VK_IMAGE_USAGE_STORAGE_BIT :: VkImageUsageBitmask a + +pattern VK_IMAGE_USAGE_STORAGE_BIT = VkImageUsageBitmask 8 + +-- | Can be used as framebuffer color attachment +-- +-- bitpos = @4@ +pattern VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT :: + VkImageUsageBitmask a + +pattern VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT = + VkImageUsageBitmask 16 + +-- | Can be used as framebuffer depth/stencil attachment +-- +-- bitpos = @5@ +pattern VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT :: + VkImageUsageBitmask a + +pattern VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT = + VkImageUsageBitmask 32 + +-- | Image data not needed outside of rendering +-- +-- bitpos = @6@ +pattern VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT :: + VkImageUsageBitmask a + +pattern VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT = + VkImageUsageBitmask 64 + +-- | Can be used as framebuffer input attachment +-- +-- bitpos = @7@ +pattern VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT :: + VkImageUsageBitmask a + +pattern VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT = + VkImageUsageBitmask 128 diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkImageViewType.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkImageViewType.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkImageViewType.hs @@ -0,0 +1,91 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +module Graphics.Vulkan.Types.Enum.VkImageViewType + (VkImageViewType(VkImageViewType, VK_IMAGE_VIEW_TYPE_1D, + VK_IMAGE_VIEW_TYPE_2D, VK_IMAGE_VIEW_TYPE_3D, + VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, + VK_IMAGE_VIEW_TYPE_2D_ARRAY, VK_IMAGE_VIEW_TYPE_CUBE_ARRAY)) + where +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (Int32) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +-- | type = @enum@ +-- +-- +newtype VkImageViewType = VkImageViewType Int32 + deriving (Eq, Ord, Num, Bounded, Storable, Enum, Data, Generic) + +instance Show VkImageViewType where + showsPrec _ VK_IMAGE_VIEW_TYPE_1D + = showString "VK_IMAGE_VIEW_TYPE_1D" + showsPrec _ VK_IMAGE_VIEW_TYPE_2D + = showString "VK_IMAGE_VIEW_TYPE_2D" + showsPrec _ VK_IMAGE_VIEW_TYPE_3D + = showString "VK_IMAGE_VIEW_TYPE_3D" + showsPrec _ VK_IMAGE_VIEW_TYPE_CUBE + = showString "VK_IMAGE_VIEW_TYPE_CUBE" + showsPrec _ VK_IMAGE_VIEW_TYPE_1D_ARRAY + = showString "VK_IMAGE_VIEW_TYPE_1D_ARRAY" + showsPrec _ VK_IMAGE_VIEW_TYPE_2D_ARRAY + = showString "VK_IMAGE_VIEW_TYPE_2D_ARRAY" + showsPrec _ VK_IMAGE_VIEW_TYPE_CUBE_ARRAY + = showString "VK_IMAGE_VIEW_TYPE_CUBE_ARRAY" + showsPrec p (VkImageViewType x) + = showParen (p >= 11) + (showString "VkImageViewType " . showsPrec 11 x) + +instance Read VkImageViewType where + readPrec + = parens + (choose + [("VK_IMAGE_VIEW_TYPE_1D", pure VK_IMAGE_VIEW_TYPE_1D), + ("VK_IMAGE_VIEW_TYPE_2D", pure VK_IMAGE_VIEW_TYPE_2D), + ("VK_IMAGE_VIEW_TYPE_3D", pure VK_IMAGE_VIEW_TYPE_3D), + ("VK_IMAGE_VIEW_TYPE_CUBE", pure VK_IMAGE_VIEW_TYPE_CUBE), + ("VK_IMAGE_VIEW_TYPE_1D_ARRAY", pure VK_IMAGE_VIEW_TYPE_1D_ARRAY), + ("VK_IMAGE_VIEW_TYPE_2D_ARRAY", pure VK_IMAGE_VIEW_TYPE_2D_ARRAY), + ("VK_IMAGE_VIEW_TYPE_CUBE_ARRAY", + pure VK_IMAGE_VIEW_TYPE_CUBE_ARRAY)] + +++ + prec 10 + (expectP (Ident "VkImageViewType") >> + (VkImageViewType <$> step readPrec))) + +pattern VK_IMAGE_VIEW_TYPE_1D :: VkImageViewType + +pattern VK_IMAGE_VIEW_TYPE_1D = VkImageViewType 0 + +pattern VK_IMAGE_VIEW_TYPE_2D :: VkImageViewType + +pattern VK_IMAGE_VIEW_TYPE_2D = VkImageViewType 1 + +pattern VK_IMAGE_VIEW_TYPE_3D :: VkImageViewType + +pattern VK_IMAGE_VIEW_TYPE_3D = VkImageViewType 2 + +pattern VK_IMAGE_VIEW_TYPE_CUBE :: VkImageViewType + +pattern VK_IMAGE_VIEW_TYPE_CUBE = VkImageViewType 3 + +pattern VK_IMAGE_VIEW_TYPE_1D_ARRAY :: VkImageViewType + +pattern VK_IMAGE_VIEW_TYPE_1D_ARRAY = VkImageViewType 4 + +pattern VK_IMAGE_VIEW_TYPE_2D_ARRAY :: VkImageViewType + +pattern VK_IMAGE_VIEW_TYPE_2D_ARRAY = VkImageViewType 5 + +pattern VK_IMAGE_VIEW_TYPE_CUBE_ARRAY :: VkImageViewType + +pattern VK_IMAGE_VIEW_TYPE_CUBE_ARRAY = VkImageViewType 6 diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkIndexType.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkIndexType.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkIndexType.hs @@ -0,0 +1,51 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +module Graphics.Vulkan.Types.Enum.VkIndexType + (VkIndexType(VkIndexType, VK_INDEX_TYPE_UINT16, + VK_INDEX_TYPE_UINT32)) + where +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (Int32) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +-- | type = @enum@ +-- +-- +newtype VkIndexType = VkIndexType Int32 + deriving (Eq, Ord, Num, Bounded, Storable, Enum, Data, Generic) + +instance Show VkIndexType where + showsPrec _ VK_INDEX_TYPE_UINT16 + = showString "VK_INDEX_TYPE_UINT16" + showsPrec _ VK_INDEX_TYPE_UINT32 + = showString "VK_INDEX_TYPE_UINT32" + showsPrec p (VkIndexType x) + = showParen (p >= 11) (showString "VkIndexType " . showsPrec 11 x) + +instance Read VkIndexType where + readPrec + = parens + (choose + [("VK_INDEX_TYPE_UINT16", pure VK_INDEX_TYPE_UINT16), + ("VK_INDEX_TYPE_UINT32", pure VK_INDEX_TYPE_UINT32)] + +++ + prec 10 + (expectP (Ident "VkIndexType") >> (VkIndexType <$> step readPrec))) + +pattern VK_INDEX_TYPE_UINT16 :: VkIndexType + +pattern VK_INDEX_TYPE_UINT16 = VkIndexType 0 + +pattern VK_INDEX_TYPE_UINT32 :: VkIndexType + +pattern VK_INDEX_TYPE_UINT32 = VkIndexType 1 diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkIndirectCommandsLayoutUsageFlagsNVX.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkIndirectCommandsLayoutUsageFlagsNVX.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkIndirectCommandsLayoutUsageFlagsNVX.hs @@ -0,0 +1,144 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE KindSignatures #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE StandaloneDeriving #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeSynonymInstances #-} +module Graphics.Vulkan.Types.Enum.VkIndirectCommandsLayoutUsageFlagsNVX + (VkIndirectCommandsLayoutUsageBitmaskNVX(VkIndirectCommandsLayoutUsageBitmaskNVX, + VkIndirectCommandsLayoutUsageFlagsNVX, + VkIndirectCommandsLayoutUsageFlagBitsNVX, + VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NVX, + VK_INDIRECT_COMMANDS_LAYOUT_USAGE_SPARSE_SEQUENCES_BIT_NVX, + VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EMPTY_EXECUTIONS_BIT_NVX, + VK_INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NVX), + VkIndirectCommandsLayoutUsageFlagsNVX, + VkIndirectCommandsLayoutUsageFlagBitsNVX) + where +import Data.Bits (Bits, FiniteBits) +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (FlagBit, FlagMask, FlagType) +import Graphics.Vulkan.Types.BaseTypes (VkFlags (..)) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +newtype VkIndirectCommandsLayoutUsageBitmaskNVX (a :: + FlagType) = VkIndirectCommandsLayoutUsageBitmaskNVX VkFlags + deriving (Eq, Ord, Storable, Data, + Generic) + +type VkIndirectCommandsLayoutUsageFlagsNVX = + VkIndirectCommandsLayoutUsageBitmaskNVX FlagMask + +type VkIndirectCommandsLayoutUsageFlagBitsNVX = + VkIndirectCommandsLayoutUsageBitmaskNVX FlagBit + +pattern VkIndirectCommandsLayoutUsageFlagBitsNVX :: + VkFlags -> VkIndirectCommandsLayoutUsageBitmaskNVX FlagBit + +pattern VkIndirectCommandsLayoutUsageFlagBitsNVX n = + VkIndirectCommandsLayoutUsageBitmaskNVX n + +pattern VkIndirectCommandsLayoutUsageFlagsNVX :: + VkFlags -> VkIndirectCommandsLayoutUsageBitmaskNVX FlagMask + +pattern VkIndirectCommandsLayoutUsageFlagsNVX n = + VkIndirectCommandsLayoutUsageBitmaskNVX n + +deriving instance + Bits (VkIndirectCommandsLayoutUsageBitmaskNVX FlagMask) + +deriving instance + FiniteBits (VkIndirectCommandsLayoutUsageBitmaskNVX FlagMask) + +deriving instance + Integral (VkIndirectCommandsLayoutUsageBitmaskNVX FlagMask) + +deriving instance + Num (VkIndirectCommandsLayoutUsageBitmaskNVX FlagMask) + +deriving instance + Bounded (VkIndirectCommandsLayoutUsageBitmaskNVX FlagMask) + +deriving instance + Enum (VkIndirectCommandsLayoutUsageBitmaskNVX FlagMask) + +deriving instance + Real (VkIndirectCommandsLayoutUsageBitmaskNVX FlagMask) + +instance Show (VkIndirectCommandsLayoutUsageBitmaskNVX a) where + showsPrec _ + VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NVX + = showString + "VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NVX" + showsPrec _ + VK_INDIRECT_COMMANDS_LAYOUT_USAGE_SPARSE_SEQUENCES_BIT_NVX + = showString + "VK_INDIRECT_COMMANDS_LAYOUT_USAGE_SPARSE_SEQUENCES_BIT_NVX" + showsPrec _ + VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EMPTY_EXECUTIONS_BIT_NVX + = showString + "VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EMPTY_EXECUTIONS_BIT_NVX" + showsPrec _ + VK_INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NVX + = showString + "VK_INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NVX" + showsPrec p (VkIndirectCommandsLayoutUsageBitmaskNVX x) + = showParen (p >= 11) + (showString "VkIndirectCommandsLayoutUsageBitmaskNVX " . + showsPrec 11 x) + +instance Read (VkIndirectCommandsLayoutUsageBitmaskNVX a) where + readPrec + = parens + (choose + [("VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NVX", + pure + VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NVX), + ("VK_INDIRECT_COMMANDS_LAYOUT_USAGE_SPARSE_SEQUENCES_BIT_NVX", + pure VK_INDIRECT_COMMANDS_LAYOUT_USAGE_SPARSE_SEQUENCES_BIT_NVX), + ("VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EMPTY_EXECUTIONS_BIT_NVX", + pure VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EMPTY_EXECUTIONS_BIT_NVX), + ("VK_INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NVX", + pure VK_INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NVX)] + +++ + prec 10 + (expectP (Ident "VkIndirectCommandsLayoutUsageBitmaskNVX") >> + (VkIndirectCommandsLayoutUsageBitmaskNVX <$> step readPrec))) + +-- | bitpos = @0@ +pattern VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NVX + :: VkIndirectCommandsLayoutUsageBitmaskNVX a + +pattern VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NVX + = VkIndirectCommandsLayoutUsageBitmaskNVX 1 + +-- | bitpos = @1@ +pattern VK_INDIRECT_COMMANDS_LAYOUT_USAGE_SPARSE_SEQUENCES_BIT_NVX + :: VkIndirectCommandsLayoutUsageBitmaskNVX a + +pattern VK_INDIRECT_COMMANDS_LAYOUT_USAGE_SPARSE_SEQUENCES_BIT_NVX + = VkIndirectCommandsLayoutUsageBitmaskNVX 2 + +-- | bitpos = @2@ +pattern VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EMPTY_EXECUTIONS_BIT_NVX + :: VkIndirectCommandsLayoutUsageBitmaskNVX a + +pattern VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EMPTY_EXECUTIONS_BIT_NVX + = VkIndirectCommandsLayoutUsageBitmaskNVX 4 + +-- | bitpos = @3@ +pattern VK_INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NVX + :: VkIndirectCommandsLayoutUsageBitmaskNVX a + +pattern VK_INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NVX + = VkIndirectCommandsLayoutUsageBitmaskNVX 8 diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkIndirectCommandsTokenTypeNVX.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkIndirectCommandsTokenTypeNVX.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkIndirectCommandsTokenTypeNVX.hs @@ -0,0 +1,127 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +module Graphics.Vulkan.Types.Enum.VkIndirectCommandsTokenTypeNVX + (VkIndirectCommandsTokenTypeNVX(VkIndirectCommandsTokenTypeNVX, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NVX, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_DESCRIPTOR_SET_NVX, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_NVX, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_NVX, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NVX, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NVX, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NVX, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NVX)) + where +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (Int32) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +-- | type = @enum@ +-- +-- +newtype VkIndirectCommandsTokenTypeNVX = VkIndirectCommandsTokenTypeNVX Int32 + deriving (Eq, Ord, Num, Bounded, Storable, Enum, Data, + Generic) + +instance Show VkIndirectCommandsTokenTypeNVX where + showsPrec _ VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NVX + = showString "VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NVX" + showsPrec _ VK_INDIRECT_COMMANDS_TOKEN_TYPE_DESCRIPTOR_SET_NVX + = showString "VK_INDIRECT_COMMANDS_TOKEN_TYPE_DESCRIPTOR_SET_NVX" + showsPrec _ VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_NVX + = showString "VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_NVX" + showsPrec _ VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_NVX + = showString "VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_NVX" + showsPrec _ VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NVX + = showString "VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NVX" + showsPrec _ VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NVX + = showString "VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NVX" + showsPrec _ VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NVX + = showString "VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NVX" + showsPrec _ VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NVX + = showString "VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NVX" + showsPrec p (VkIndirectCommandsTokenTypeNVX x) + = showParen (p >= 11) + (showString "VkIndirectCommandsTokenTypeNVX " . showsPrec 11 x) + +instance Read VkIndirectCommandsTokenTypeNVX where + readPrec + = parens + (choose + [("VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NVX", + pure VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NVX), + ("VK_INDIRECT_COMMANDS_TOKEN_TYPE_DESCRIPTOR_SET_NVX", + pure VK_INDIRECT_COMMANDS_TOKEN_TYPE_DESCRIPTOR_SET_NVX), + ("VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_NVX", + pure VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_NVX), + ("VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_NVX", + pure VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_NVX), + ("VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NVX", + pure VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NVX), + ("VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NVX", + pure VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NVX), + ("VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NVX", + pure VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NVX), + ("VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NVX", + pure VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NVX)] + +++ + prec 10 + (expectP (Ident "VkIndirectCommandsTokenTypeNVX") >> + (VkIndirectCommandsTokenTypeNVX <$> step readPrec))) + +pattern VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NVX :: + VkIndirectCommandsTokenTypeNVX + +pattern VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NVX = + VkIndirectCommandsTokenTypeNVX 0 + +pattern VK_INDIRECT_COMMANDS_TOKEN_TYPE_DESCRIPTOR_SET_NVX :: + VkIndirectCommandsTokenTypeNVX + +pattern VK_INDIRECT_COMMANDS_TOKEN_TYPE_DESCRIPTOR_SET_NVX = + VkIndirectCommandsTokenTypeNVX 1 + +pattern VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_NVX :: + VkIndirectCommandsTokenTypeNVX + +pattern VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_NVX = + VkIndirectCommandsTokenTypeNVX 2 + +pattern VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_NVX :: + VkIndirectCommandsTokenTypeNVX + +pattern VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_NVX = + VkIndirectCommandsTokenTypeNVX 3 + +pattern VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NVX :: + VkIndirectCommandsTokenTypeNVX + +pattern VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NVX = + VkIndirectCommandsTokenTypeNVX 4 + +pattern VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NVX :: + VkIndirectCommandsTokenTypeNVX + +pattern VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NVX = + VkIndirectCommandsTokenTypeNVX 5 + +pattern VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NVX :: + VkIndirectCommandsTokenTypeNVX + +pattern VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NVX = + VkIndirectCommandsTokenTypeNVX 6 + +pattern VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NVX :: + VkIndirectCommandsTokenTypeNVX + +pattern VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NVX = + VkIndirectCommandsTokenTypeNVX 7 diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkInstanceCreateFlagBits.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkInstanceCreateFlagBits.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkInstanceCreateFlagBits.hs @@ -0,0 +1,25 @@ +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE Strict #-} +module Graphics.Vulkan.Types.Enum.VkInstanceCreateFlagBits + (VkInstanceCreateFlagBits(..)) where +import Data.Bits (Bits, FiniteBits) +import Data.Coerce (coerce) +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import Graphics.Vulkan.Types.BaseTypes (VkFlags) + +newtype VkInstanceCreateFlagBits = VkInstanceCreateFlagBits VkFlags + deriving (Eq, Ord, Num, Bounded, Enum, Integral, Bits, + FiniteBits, Storable, Real, Data, Generic) + +instance Show VkInstanceCreateFlagBits where + {-# INLINE show #-} + show (VkInstanceCreateFlagBits x) = show x + +instance Read VkInstanceCreateFlagBits where + {-# INLINE readsPrec #-} + readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags) diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkInternalAllocationType.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkInternalAllocationType.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkInternalAllocationType.hs @@ -0,0 +1,49 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +module Graphics.Vulkan.Types.Enum.VkInternalAllocationType + (VkInternalAllocationType(VkInternalAllocationType, + VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE)) + where +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (Int32) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +-- | type = @enum@ +-- +-- +newtype VkInternalAllocationType = VkInternalAllocationType Int32 + deriving (Eq, Ord, Num, Bounded, Storable, Enum, Data, Generic) + +instance Show VkInternalAllocationType where + showsPrec _ VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE + = showString "VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE" + showsPrec p (VkInternalAllocationType x) + = showParen (p >= 11) + (showString "VkInternalAllocationType " . showsPrec 11 x) + +instance Read VkInternalAllocationType where + readPrec + = parens + (choose + [("VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE", + pure VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE)] + +++ + prec 10 + (expectP (Ident "VkInternalAllocationType") >> + (VkInternalAllocationType <$> step readPrec))) + +pattern VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE :: + VkInternalAllocationType + +pattern VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE = + VkInternalAllocationType 0 diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkLogicOp.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkLogicOp.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkLogicOp.hs @@ -0,0 +1,144 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +module Graphics.Vulkan.Types.Enum.VkLogicOp + (VkLogicOp(VkLogicOp, VK_LOGIC_OP_CLEAR, VK_LOGIC_OP_AND, + VK_LOGIC_OP_AND_REVERSE, VK_LOGIC_OP_COPY, + VK_LOGIC_OP_AND_INVERTED, VK_LOGIC_OP_NO_OP, VK_LOGIC_OP_XOR, + VK_LOGIC_OP_OR, VK_LOGIC_OP_NOR, VK_LOGIC_OP_EQUIVALENT, + VK_LOGIC_OP_INVERT, VK_LOGIC_OP_OR_REVERSE, + VK_LOGIC_OP_COPY_INVERTED, VK_LOGIC_OP_OR_INVERTED, + VK_LOGIC_OP_NAND, VK_LOGIC_OP_SET)) + where +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (Int32) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +-- | type = @enum@ +-- +-- +newtype VkLogicOp = VkLogicOp Int32 + deriving (Eq, Ord, Num, Bounded, Storable, Enum, Data, Generic) + +instance Show VkLogicOp where + showsPrec _ VK_LOGIC_OP_CLEAR = showString "VK_LOGIC_OP_CLEAR" + showsPrec _ VK_LOGIC_OP_AND = showString "VK_LOGIC_OP_AND" + showsPrec _ VK_LOGIC_OP_AND_REVERSE + = showString "VK_LOGIC_OP_AND_REVERSE" + showsPrec _ VK_LOGIC_OP_COPY = showString "VK_LOGIC_OP_COPY" + showsPrec _ VK_LOGIC_OP_AND_INVERTED + = showString "VK_LOGIC_OP_AND_INVERTED" + showsPrec _ VK_LOGIC_OP_NO_OP = showString "VK_LOGIC_OP_NO_OP" + showsPrec _ VK_LOGIC_OP_XOR = showString "VK_LOGIC_OP_XOR" + showsPrec _ VK_LOGIC_OP_OR = showString "VK_LOGIC_OP_OR" + showsPrec _ VK_LOGIC_OP_NOR = showString "VK_LOGIC_OP_NOR" + showsPrec _ VK_LOGIC_OP_EQUIVALENT + = showString "VK_LOGIC_OP_EQUIVALENT" + showsPrec _ VK_LOGIC_OP_INVERT = showString "VK_LOGIC_OP_INVERT" + showsPrec _ VK_LOGIC_OP_OR_REVERSE + = showString "VK_LOGIC_OP_OR_REVERSE" + showsPrec _ VK_LOGIC_OP_COPY_INVERTED + = showString "VK_LOGIC_OP_COPY_INVERTED" + showsPrec _ VK_LOGIC_OP_OR_INVERTED + = showString "VK_LOGIC_OP_OR_INVERTED" + showsPrec _ VK_LOGIC_OP_NAND = showString "VK_LOGIC_OP_NAND" + showsPrec _ VK_LOGIC_OP_SET = showString "VK_LOGIC_OP_SET" + showsPrec p (VkLogicOp x) + = showParen (p >= 11) (showString "VkLogicOp " . showsPrec 11 x) + +instance Read VkLogicOp where + readPrec + = parens + (choose + [("VK_LOGIC_OP_CLEAR", pure VK_LOGIC_OP_CLEAR), + ("VK_LOGIC_OP_AND", pure VK_LOGIC_OP_AND), + ("VK_LOGIC_OP_AND_REVERSE", pure VK_LOGIC_OP_AND_REVERSE), + ("VK_LOGIC_OP_COPY", pure VK_LOGIC_OP_COPY), + ("VK_LOGIC_OP_AND_INVERTED", pure VK_LOGIC_OP_AND_INVERTED), + ("VK_LOGIC_OP_NO_OP", pure VK_LOGIC_OP_NO_OP), + ("VK_LOGIC_OP_XOR", pure VK_LOGIC_OP_XOR), + ("VK_LOGIC_OP_OR", pure VK_LOGIC_OP_OR), + ("VK_LOGIC_OP_NOR", pure VK_LOGIC_OP_NOR), + ("VK_LOGIC_OP_EQUIVALENT", pure VK_LOGIC_OP_EQUIVALENT), + ("VK_LOGIC_OP_INVERT", pure VK_LOGIC_OP_INVERT), + ("VK_LOGIC_OP_OR_REVERSE", pure VK_LOGIC_OP_OR_REVERSE), + ("VK_LOGIC_OP_COPY_INVERTED", pure VK_LOGIC_OP_COPY_INVERTED), + ("VK_LOGIC_OP_OR_INVERTED", pure VK_LOGIC_OP_OR_INVERTED), + ("VK_LOGIC_OP_NAND", pure VK_LOGIC_OP_NAND), + ("VK_LOGIC_OP_SET", pure VK_LOGIC_OP_SET)] + +++ + prec 10 + (expectP (Ident "VkLogicOp") >> (VkLogicOp <$> step readPrec))) + +pattern VK_LOGIC_OP_CLEAR :: VkLogicOp + +pattern VK_LOGIC_OP_CLEAR = VkLogicOp 0 + +pattern VK_LOGIC_OP_AND :: VkLogicOp + +pattern VK_LOGIC_OP_AND = VkLogicOp 1 + +pattern VK_LOGIC_OP_AND_REVERSE :: VkLogicOp + +pattern VK_LOGIC_OP_AND_REVERSE = VkLogicOp 2 + +pattern VK_LOGIC_OP_COPY :: VkLogicOp + +pattern VK_LOGIC_OP_COPY = VkLogicOp 3 + +pattern VK_LOGIC_OP_AND_INVERTED :: VkLogicOp + +pattern VK_LOGIC_OP_AND_INVERTED = VkLogicOp 4 + +pattern VK_LOGIC_OP_NO_OP :: VkLogicOp + +pattern VK_LOGIC_OP_NO_OP = VkLogicOp 5 + +pattern VK_LOGIC_OP_XOR :: VkLogicOp + +pattern VK_LOGIC_OP_XOR = VkLogicOp 6 + +pattern VK_LOGIC_OP_OR :: VkLogicOp + +pattern VK_LOGIC_OP_OR = VkLogicOp 7 + +pattern VK_LOGIC_OP_NOR :: VkLogicOp + +pattern VK_LOGIC_OP_NOR = VkLogicOp 8 + +pattern VK_LOGIC_OP_EQUIVALENT :: VkLogicOp + +pattern VK_LOGIC_OP_EQUIVALENT = VkLogicOp 9 + +pattern VK_LOGIC_OP_INVERT :: VkLogicOp + +pattern VK_LOGIC_OP_INVERT = VkLogicOp 10 + +pattern VK_LOGIC_OP_OR_REVERSE :: VkLogicOp + +pattern VK_LOGIC_OP_OR_REVERSE = VkLogicOp 11 + +pattern VK_LOGIC_OP_COPY_INVERTED :: VkLogicOp + +pattern VK_LOGIC_OP_COPY_INVERTED = VkLogicOp 12 + +pattern VK_LOGIC_OP_OR_INVERTED :: VkLogicOp + +pattern VK_LOGIC_OP_OR_INVERTED = VkLogicOp 13 + +pattern VK_LOGIC_OP_NAND :: VkLogicOp + +pattern VK_LOGIC_OP_NAND = VkLogicOp 14 + +pattern VK_LOGIC_OP_SET :: VkLogicOp + +pattern VK_LOGIC_OP_SET = VkLogicOp 15 diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkMemoryAllocateFlagsKHX.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkMemoryAllocateFlagsKHX.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkMemoryAllocateFlagsKHX.hs @@ -0,0 +1,88 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE KindSignatures #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE StandaloneDeriving #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeSynonymInstances #-} +module Graphics.Vulkan.Types.Enum.VkMemoryAllocateFlagsKHX + (VkMemoryAllocateBitmaskKHX(VkMemoryAllocateBitmaskKHX, + VkMemoryAllocateFlagsKHX, VkMemoryAllocateFlagBitsKHX, + VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT_KHX), + VkMemoryAllocateFlagsKHX, VkMemoryAllocateFlagBitsKHX) + where +import Data.Bits (Bits, FiniteBits) +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (FlagBit, FlagMask, FlagType) +import Graphics.Vulkan.Types.BaseTypes (VkFlags (..)) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +newtype VkMemoryAllocateBitmaskKHX (a :: + FlagType) = VkMemoryAllocateBitmaskKHX VkFlags + deriving (Eq, Ord, Storable, Data, Generic) + +type VkMemoryAllocateFlagsKHX = VkMemoryAllocateBitmaskKHX FlagMask + +type VkMemoryAllocateFlagBitsKHX = + VkMemoryAllocateBitmaskKHX FlagBit + +pattern VkMemoryAllocateFlagBitsKHX :: + VkFlags -> VkMemoryAllocateBitmaskKHX FlagBit + +pattern VkMemoryAllocateFlagBitsKHX n = + VkMemoryAllocateBitmaskKHX n + +pattern VkMemoryAllocateFlagsKHX :: + VkFlags -> VkMemoryAllocateBitmaskKHX FlagMask + +pattern VkMemoryAllocateFlagsKHX n = VkMemoryAllocateBitmaskKHX n + +deriving instance Bits (VkMemoryAllocateBitmaskKHX FlagMask) + +deriving instance FiniteBits (VkMemoryAllocateBitmaskKHX FlagMask) + +deriving instance Integral (VkMemoryAllocateBitmaskKHX FlagMask) + +deriving instance Num (VkMemoryAllocateBitmaskKHX FlagMask) + +deriving instance Bounded (VkMemoryAllocateBitmaskKHX FlagMask) + +deriving instance Enum (VkMemoryAllocateBitmaskKHX FlagMask) + +deriving instance Real (VkMemoryAllocateBitmaskKHX FlagMask) + +instance Show (VkMemoryAllocateBitmaskKHX a) where + showsPrec _ VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT_KHX + = showString "VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT_KHX" + showsPrec p (VkMemoryAllocateBitmaskKHX x) + = showParen (p >= 11) + (showString "VkMemoryAllocateBitmaskKHX " . showsPrec 11 x) + +instance Read (VkMemoryAllocateBitmaskKHX a) where + readPrec + = parens + (choose + [("VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT_KHX", + pure VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT_KHX)] + +++ + prec 10 + (expectP (Ident "VkMemoryAllocateBitmaskKHX") >> + (VkMemoryAllocateBitmaskKHX <$> step readPrec))) + +-- | Force allocation on specific devices +-- +-- bitpos = @0@ +pattern VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT_KHX :: + VkMemoryAllocateBitmaskKHX a + +pattern VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT_KHX = + VkMemoryAllocateBitmaskKHX 1 diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkMemoryHeapFlags.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkMemoryHeapFlags.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkMemoryHeapFlags.hs @@ -0,0 +1,83 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE KindSignatures #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE StandaloneDeriving #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeSynonymInstances #-} +module Graphics.Vulkan.Types.Enum.VkMemoryHeapFlags + (VkMemoryHeapBitmask(VkMemoryHeapBitmask, VkMemoryHeapFlags, + VkMemoryHeapFlagBits, VK_MEMORY_HEAP_DEVICE_LOCAL_BIT), + VkMemoryHeapFlags, VkMemoryHeapFlagBits) + where +import Data.Bits (Bits, FiniteBits) +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (FlagBit, FlagMask, FlagType) +import Graphics.Vulkan.Types.BaseTypes (VkFlags (..)) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +newtype VkMemoryHeapBitmask (a :: + FlagType) = VkMemoryHeapBitmask VkFlags + deriving (Eq, Ord, Storable, Data, Generic) + +type VkMemoryHeapFlags = VkMemoryHeapBitmask FlagMask + +type VkMemoryHeapFlagBits = VkMemoryHeapBitmask FlagBit + +pattern VkMemoryHeapFlagBits :: + VkFlags -> VkMemoryHeapBitmask FlagBit + +pattern VkMemoryHeapFlagBits n = VkMemoryHeapBitmask n + +pattern VkMemoryHeapFlags :: + VkFlags -> VkMemoryHeapBitmask FlagMask + +pattern VkMemoryHeapFlags n = VkMemoryHeapBitmask n + +deriving instance Bits (VkMemoryHeapBitmask FlagMask) + +deriving instance FiniteBits (VkMemoryHeapBitmask FlagMask) + +deriving instance Integral (VkMemoryHeapBitmask FlagMask) + +deriving instance Num (VkMemoryHeapBitmask FlagMask) + +deriving instance Bounded (VkMemoryHeapBitmask FlagMask) + +deriving instance Enum (VkMemoryHeapBitmask FlagMask) + +deriving instance Real (VkMemoryHeapBitmask FlagMask) + +instance Show (VkMemoryHeapBitmask a) where + showsPrec _ VK_MEMORY_HEAP_DEVICE_LOCAL_BIT + = showString "VK_MEMORY_HEAP_DEVICE_LOCAL_BIT" + showsPrec p (VkMemoryHeapBitmask x) + = showParen (p >= 11) + (showString "VkMemoryHeapBitmask " . showsPrec 11 x) + +instance Read (VkMemoryHeapBitmask a) where + readPrec + = parens + (choose + [("VK_MEMORY_HEAP_DEVICE_LOCAL_BIT", + pure VK_MEMORY_HEAP_DEVICE_LOCAL_BIT)] + +++ + prec 10 + (expectP (Ident "VkMemoryHeapBitmask") >> + (VkMemoryHeapBitmask <$> step readPrec))) + +-- | If set, heap represents device memory +-- +-- bitpos = @0@ +pattern VK_MEMORY_HEAP_DEVICE_LOCAL_BIT :: VkMemoryHeapBitmask a + +pattern VK_MEMORY_HEAP_DEVICE_LOCAL_BIT = VkMemoryHeapBitmask 1 diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkMemoryPropertyFlags.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkMemoryPropertyFlags.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkMemoryPropertyFlags.hs @@ -0,0 +1,142 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE KindSignatures #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE StandaloneDeriving #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeSynonymInstances #-} +module Graphics.Vulkan.Types.Enum.VkMemoryPropertyFlags + (VkMemoryPropertyBitmask(VkMemoryPropertyBitmask, + VkMemoryPropertyFlags, VkMemoryPropertyFlagBits, + VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, + VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT, + VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, + VK_MEMORY_PROPERTY_HOST_CACHED_BIT, + VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT), + VkMemoryPropertyFlags, VkMemoryPropertyFlagBits) + where +import Data.Bits (Bits, FiniteBits) +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (FlagBit, FlagMask, FlagType) +import Graphics.Vulkan.Types.BaseTypes (VkFlags (..)) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +newtype VkMemoryPropertyBitmask (a :: + FlagType) = VkMemoryPropertyBitmask VkFlags + deriving (Eq, Ord, Storable, Data, Generic) + +type VkMemoryPropertyFlags = VkMemoryPropertyBitmask FlagMask + +type VkMemoryPropertyFlagBits = VkMemoryPropertyBitmask FlagBit + +pattern VkMemoryPropertyFlagBits :: + VkFlags -> VkMemoryPropertyBitmask FlagBit + +pattern VkMemoryPropertyFlagBits n = VkMemoryPropertyBitmask n + +pattern VkMemoryPropertyFlags :: + VkFlags -> VkMemoryPropertyBitmask FlagMask + +pattern VkMemoryPropertyFlags n = VkMemoryPropertyBitmask n + +deriving instance Bits (VkMemoryPropertyBitmask FlagMask) + +deriving instance FiniteBits (VkMemoryPropertyBitmask FlagMask) + +deriving instance Integral (VkMemoryPropertyBitmask FlagMask) + +deriving instance Num (VkMemoryPropertyBitmask FlagMask) + +deriving instance Bounded (VkMemoryPropertyBitmask FlagMask) + +deriving instance Enum (VkMemoryPropertyBitmask FlagMask) + +deriving instance Real (VkMemoryPropertyBitmask FlagMask) + +instance Show (VkMemoryPropertyBitmask a) where + showsPrec _ VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT + = showString "VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT" + showsPrec _ VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT + = showString "VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT" + showsPrec _ VK_MEMORY_PROPERTY_HOST_COHERENT_BIT + = showString "VK_MEMORY_PROPERTY_HOST_COHERENT_BIT" + showsPrec _ VK_MEMORY_PROPERTY_HOST_CACHED_BIT + = showString "VK_MEMORY_PROPERTY_HOST_CACHED_BIT" + showsPrec _ VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT + = showString "VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT" + showsPrec p (VkMemoryPropertyBitmask x) + = showParen (p >= 11) + (showString "VkMemoryPropertyBitmask " . showsPrec 11 x) + +instance Read (VkMemoryPropertyBitmask a) where + readPrec + = parens + (choose + [("VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT", + pure VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT), + ("VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT", + pure VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT), + ("VK_MEMORY_PROPERTY_HOST_COHERENT_BIT", + pure VK_MEMORY_PROPERTY_HOST_COHERENT_BIT), + ("VK_MEMORY_PROPERTY_HOST_CACHED_BIT", + pure VK_MEMORY_PROPERTY_HOST_CACHED_BIT), + ("VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT", + pure VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT)] + +++ + prec 10 + (expectP (Ident "VkMemoryPropertyBitmask") >> + (VkMemoryPropertyBitmask <$> step readPrec))) + +-- | If otherwise stated, then allocate memory on device +-- +-- bitpos = @0@ +pattern VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT :: + VkMemoryPropertyBitmask a + +pattern VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT = + VkMemoryPropertyBitmask 1 + +-- | Memory is mappable by host +-- +-- bitpos = @1@ +pattern VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT :: + VkMemoryPropertyBitmask a + +pattern VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT = + VkMemoryPropertyBitmask 2 + +-- | Memory will have i/o coherency. If not set, application may need to use vkFlushMappedMemoryRanges and vkInvalidateMappedMemoryRanges to flush/invalidate host cache +-- +-- bitpos = @2@ +pattern VK_MEMORY_PROPERTY_HOST_COHERENT_BIT :: + VkMemoryPropertyBitmask a + +pattern VK_MEMORY_PROPERTY_HOST_COHERENT_BIT = + VkMemoryPropertyBitmask 4 + +-- | Memory will be cached by the host +-- +-- bitpos = @3@ +pattern VK_MEMORY_PROPERTY_HOST_CACHED_BIT :: + VkMemoryPropertyBitmask a + +pattern VK_MEMORY_PROPERTY_HOST_CACHED_BIT = + VkMemoryPropertyBitmask 8 + +-- | Memory may be allocated by the driver when it is required +-- +-- bitpos = @4@ +pattern VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT :: + VkMemoryPropertyBitmask a + +pattern VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT = + VkMemoryPropertyBitmask 16 diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkObjectEntryTypeNVX.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkObjectEntryTypeNVX.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkObjectEntryTypeNVX.hs @@ -0,0 +1,91 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +module Graphics.Vulkan.Types.Enum.VkObjectEntryTypeNVX + (VkObjectEntryTypeNVX(VkObjectEntryTypeNVX, + VK_OBJECT_ENTRY_TYPE_DESCRIPTOR_SET_NVX, + VK_OBJECT_ENTRY_TYPE_PIPELINE_NVX, + VK_OBJECT_ENTRY_TYPE_INDEX_BUFFER_NVX, + VK_OBJECT_ENTRY_TYPE_VERTEX_BUFFER_NVX, + VK_OBJECT_ENTRY_TYPE_PUSH_CONSTANT_NVX)) + where +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (Int32) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +-- | type = @enum@ +-- +-- +newtype VkObjectEntryTypeNVX = VkObjectEntryTypeNVX Int32 + deriving (Eq, Ord, Num, Bounded, Storable, Enum, Data, Generic) + +instance Show VkObjectEntryTypeNVX where + showsPrec _ VK_OBJECT_ENTRY_TYPE_DESCRIPTOR_SET_NVX + = showString "VK_OBJECT_ENTRY_TYPE_DESCRIPTOR_SET_NVX" + showsPrec _ VK_OBJECT_ENTRY_TYPE_PIPELINE_NVX + = showString "VK_OBJECT_ENTRY_TYPE_PIPELINE_NVX" + showsPrec _ VK_OBJECT_ENTRY_TYPE_INDEX_BUFFER_NVX + = showString "VK_OBJECT_ENTRY_TYPE_INDEX_BUFFER_NVX" + showsPrec _ VK_OBJECT_ENTRY_TYPE_VERTEX_BUFFER_NVX + = showString "VK_OBJECT_ENTRY_TYPE_VERTEX_BUFFER_NVX" + showsPrec _ VK_OBJECT_ENTRY_TYPE_PUSH_CONSTANT_NVX + = showString "VK_OBJECT_ENTRY_TYPE_PUSH_CONSTANT_NVX" + showsPrec p (VkObjectEntryTypeNVX x) + = showParen (p >= 11) + (showString "VkObjectEntryTypeNVX " . showsPrec 11 x) + +instance Read VkObjectEntryTypeNVX where + readPrec + = parens + (choose + [("VK_OBJECT_ENTRY_TYPE_DESCRIPTOR_SET_NVX", + pure VK_OBJECT_ENTRY_TYPE_DESCRIPTOR_SET_NVX), + ("VK_OBJECT_ENTRY_TYPE_PIPELINE_NVX", + pure VK_OBJECT_ENTRY_TYPE_PIPELINE_NVX), + ("VK_OBJECT_ENTRY_TYPE_INDEX_BUFFER_NVX", + pure VK_OBJECT_ENTRY_TYPE_INDEX_BUFFER_NVX), + ("VK_OBJECT_ENTRY_TYPE_VERTEX_BUFFER_NVX", + pure VK_OBJECT_ENTRY_TYPE_VERTEX_BUFFER_NVX), + ("VK_OBJECT_ENTRY_TYPE_PUSH_CONSTANT_NVX", + pure VK_OBJECT_ENTRY_TYPE_PUSH_CONSTANT_NVX)] + +++ + prec 10 + (expectP (Ident "VkObjectEntryTypeNVX") >> + (VkObjectEntryTypeNVX <$> step readPrec))) + +pattern VK_OBJECT_ENTRY_TYPE_DESCRIPTOR_SET_NVX :: + VkObjectEntryTypeNVX + +pattern VK_OBJECT_ENTRY_TYPE_DESCRIPTOR_SET_NVX = + VkObjectEntryTypeNVX 0 + +pattern VK_OBJECT_ENTRY_TYPE_PIPELINE_NVX :: VkObjectEntryTypeNVX + +pattern VK_OBJECT_ENTRY_TYPE_PIPELINE_NVX = VkObjectEntryTypeNVX 1 + +pattern VK_OBJECT_ENTRY_TYPE_INDEX_BUFFER_NVX :: + VkObjectEntryTypeNVX + +pattern VK_OBJECT_ENTRY_TYPE_INDEX_BUFFER_NVX = + VkObjectEntryTypeNVX 2 + +pattern VK_OBJECT_ENTRY_TYPE_VERTEX_BUFFER_NVX :: + VkObjectEntryTypeNVX + +pattern VK_OBJECT_ENTRY_TYPE_VERTEX_BUFFER_NVX = + VkObjectEntryTypeNVX 3 + +pattern VK_OBJECT_ENTRY_TYPE_PUSH_CONSTANT_NVX :: + VkObjectEntryTypeNVX + +pattern VK_OBJECT_ENTRY_TYPE_PUSH_CONSTANT_NVX = + VkObjectEntryTypeNVX 4 diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkObjectEntryUsageFlagsNVX.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkObjectEntryUsageFlagsNVX.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkObjectEntryUsageFlagsNVX.hs @@ -0,0 +1,101 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE KindSignatures #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE StandaloneDeriving #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeSynonymInstances #-} +module Graphics.Vulkan.Types.Enum.VkObjectEntryUsageFlagsNVX + (VkObjectEntryUsageBitmaskNVX(VkObjectEntryUsageBitmaskNVX, + VkObjectEntryUsageFlagsNVX, VkObjectEntryUsageFlagBitsNVX, + VK_OBJECT_ENTRY_USAGE_GRAPHICS_BIT_NVX, + VK_OBJECT_ENTRY_USAGE_COMPUTE_BIT_NVX), + VkObjectEntryUsageFlagsNVX, VkObjectEntryUsageFlagBitsNVX) + where +import Data.Bits (Bits, FiniteBits) +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (FlagBit, FlagMask, FlagType) +import Graphics.Vulkan.Types.BaseTypes (VkFlags (..)) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +newtype VkObjectEntryUsageBitmaskNVX (a :: + FlagType) = VkObjectEntryUsageBitmaskNVX VkFlags + deriving (Eq, Ord, Storable, Data, Generic) + +type VkObjectEntryUsageFlagsNVX = + VkObjectEntryUsageBitmaskNVX FlagMask + +type VkObjectEntryUsageFlagBitsNVX = + VkObjectEntryUsageBitmaskNVX FlagBit + +pattern VkObjectEntryUsageFlagBitsNVX :: + VkFlags -> VkObjectEntryUsageBitmaskNVX FlagBit + +pattern VkObjectEntryUsageFlagBitsNVX n = + VkObjectEntryUsageBitmaskNVX n + +pattern VkObjectEntryUsageFlagsNVX :: + VkFlags -> VkObjectEntryUsageBitmaskNVX FlagMask + +pattern VkObjectEntryUsageFlagsNVX n = + VkObjectEntryUsageBitmaskNVX n + +deriving instance Bits (VkObjectEntryUsageBitmaskNVX FlagMask) + +deriving instance + FiniteBits (VkObjectEntryUsageBitmaskNVX FlagMask) + +deriving instance Integral (VkObjectEntryUsageBitmaskNVX FlagMask) + +deriving instance Num (VkObjectEntryUsageBitmaskNVX FlagMask) + +deriving instance Bounded (VkObjectEntryUsageBitmaskNVX FlagMask) + +deriving instance Enum (VkObjectEntryUsageBitmaskNVX FlagMask) + +deriving instance Real (VkObjectEntryUsageBitmaskNVX FlagMask) + +instance Show (VkObjectEntryUsageBitmaskNVX a) where + showsPrec _ VK_OBJECT_ENTRY_USAGE_GRAPHICS_BIT_NVX + = showString "VK_OBJECT_ENTRY_USAGE_GRAPHICS_BIT_NVX" + showsPrec _ VK_OBJECT_ENTRY_USAGE_COMPUTE_BIT_NVX + = showString "VK_OBJECT_ENTRY_USAGE_COMPUTE_BIT_NVX" + showsPrec p (VkObjectEntryUsageBitmaskNVX x) + = showParen (p >= 11) + (showString "VkObjectEntryUsageBitmaskNVX " . showsPrec 11 x) + +instance Read (VkObjectEntryUsageBitmaskNVX a) where + readPrec + = parens + (choose + [("VK_OBJECT_ENTRY_USAGE_GRAPHICS_BIT_NVX", + pure VK_OBJECT_ENTRY_USAGE_GRAPHICS_BIT_NVX), + ("VK_OBJECT_ENTRY_USAGE_COMPUTE_BIT_NVX", + pure VK_OBJECT_ENTRY_USAGE_COMPUTE_BIT_NVX)] + +++ + prec 10 + (expectP (Ident "VkObjectEntryUsageBitmaskNVX") >> + (VkObjectEntryUsageBitmaskNVX <$> step readPrec))) + +-- | bitpos = @0@ +pattern VK_OBJECT_ENTRY_USAGE_GRAPHICS_BIT_NVX :: + VkObjectEntryUsageBitmaskNVX a + +pattern VK_OBJECT_ENTRY_USAGE_GRAPHICS_BIT_NVX = + VkObjectEntryUsageBitmaskNVX 1 + +-- | bitpos = @1@ +pattern VK_OBJECT_ENTRY_USAGE_COMPUTE_BIT_NVX :: + VkObjectEntryUsageBitmaskNVX a + +pattern VK_OBJECT_ENTRY_USAGE_COMPUTE_BIT_NVX = + VkObjectEntryUsageBitmaskNVX 2 diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkObjectType.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkObjectType.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkObjectType.hs @@ -0,0 +1,268 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +module Graphics.Vulkan.Types.Enum.VkObjectType + (VkObjectType(VkObjectType, VK_OBJECT_TYPE_UNKNOWN, + VK_OBJECT_TYPE_INSTANCE, VK_OBJECT_TYPE_PHYSICAL_DEVICE, + VK_OBJECT_TYPE_DEVICE, VK_OBJECT_TYPE_QUEUE, + VK_OBJECT_TYPE_SEMAPHORE, VK_OBJECT_TYPE_COMMAND_BUFFER, + VK_OBJECT_TYPE_FENCE, VK_OBJECT_TYPE_DEVICE_MEMORY, + VK_OBJECT_TYPE_BUFFER, VK_OBJECT_TYPE_IMAGE, VK_OBJECT_TYPE_EVENT, + VK_OBJECT_TYPE_QUERY_POOL, VK_OBJECT_TYPE_BUFFER_VIEW, + VK_OBJECT_TYPE_IMAGE_VIEW, VK_OBJECT_TYPE_SHADER_MODULE, + VK_OBJECT_TYPE_PIPELINE_CACHE, VK_OBJECT_TYPE_PIPELINE_LAYOUT, + VK_OBJECT_TYPE_RENDER_PASS, VK_OBJECT_TYPE_PIPELINE, + VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT, VK_OBJECT_TYPE_SAMPLER, + VK_OBJECT_TYPE_DESCRIPTOR_POOL, VK_OBJECT_TYPE_DESCRIPTOR_SET, + VK_OBJECT_TYPE_FRAMEBUFFER, VK_OBJECT_TYPE_COMMAND_POOL)) + where +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (Int32) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +-- | Enums to track objects of various types +-- +-- type = @enum@ +-- +-- +-- +newtype VkObjectType = VkObjectType Int32 + deriving (Eq, Ord, Num, Bounded, Storable, Enum, Data, Generic) + +instance Show VkObjectType where + showsPrec _ VK_OBJECT_TYPE_UNKNOWN + = showString "VK_OBJECT_TYPE_UNKNOWN" + showsPrec _ VK_OBJECT_TYPE_INSTANCE + = showString "VK_OBJECT_TYPE_INSTANCE" + showsPrec _ VK_OBJECT_TYPE_PHYSICAL_DEVICE + = showString "VK_OBJECT_TYPE_PHYSICAL_DEVICE" + showsPrec _ VK_OBJECT_TYPE_DEVICE + = showString "VK_OBJECT_TYPE_DEVICE" + showsPrec _ VK_OBJECT_TYPE_QUEUE + = showString "VK_OBJECT_TYPE_QUEUE" + showsPrec _ VK_OBJECT_TYPE_SEMAPHORE + = showString "VK_OBJECT_TYPE_SEMAPHORE" + showsPrec _ VK_OBJECT_TYPE_COMMAND_BUFFER + = showString "VK_OBJECT_TYPE_COMMAND_BUFFER" + showsPrec _ VK_OBJECT_TYPE_FENCE + = showString "VK_OBJECT_TYPE_FENCE" + showsPrec _ VK_OBJECT_TYPE_DEVICE_MEMORY + = showString "VK_OBJECT_TYPE_DEVICE_MEMORY" + showsPrec _ VK_OBJECT_TYPE_BUFFER + = showString "VK_OBJECT_TYPE_BUFFER" + showsPrec _ VK_OBJECT_TYPE_IMAGE + = showString "VK_OBJECT_TYPE_IMAGE" + showsPrec _ VK_OBJECT_TYPE_EVENT + = showString "VK_OBJECT_TYPE_EVENT" + showsPrec _ VK_OBJECT_TYPE_QUERY_POOL + = showString "VK_OBJECT_TYPE_QUERY_POOL" + showsPrec _ VK_OBJECT_TYPE_BUFFER_VIEW + = showString "VK_OBJECT_TYPE_BUFFER_VIEW" + showsPrec _ VK_OBJECT_TYPE_IMAGE_VIEW + = showString "VK_OBJECT_TYPE_IMAGE_VIEW" + showsPrec _ VK_OBJECT_TYPE_SHADER_MODULE + = showString "VK_OBJECT_TYPE_SHADER_MODULE" + showsPrec _ VK_OBJECT_TYPE_PIPELINE_CACHE + = showString "VK_OBJECT_TYPE_PIPELINE_CACHE" + showsPrec _ VK_OBJECT_TYPE_PIPELINE_LAYOUT + = showString "VK_OBJECT_TYPE_PIPELINE_LAYOUT" + showsPrec _ VK_OBJECT_TYPE_RENDER_PASS + = showString "VK_OBJECT_TYPE_RENDER_PASS" + showsPrec _ VK_OBJECT_TYPE_PIPELINE + = showString "VK_OBJECT_TYPE_PIPELINE" + showsPrec _ VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT + = showString "VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT" + showsPrec _ VK_OBJECT_TYPE_SAMPLER + = showString "VK_OBJECT_TYPE_SAMPLER" + showsPrec _ VK_OBJECT_TYPE_DESCRIPTOR_POOL + = showString "VK_OBJECT_TYPE_DESCRIPTOR_POOL" + showsPrec _ VK_OBJECT_TYPE_DESCRIPTOR_SET + = showString "VK_OBJECT_TYPE_DESCRIPTOR_SET" + showsPrec _ VK_OBJECT_TYPE_FRAMEBUFFER + = showString "VK_OBJECT_TYPE_FRAMEBUFFER" + showsPrec _ VK_OBJECT_TYPE_COMMAND_POOL + = showString "VK_OBJECT_TYPE_COMMAND_POOL" + showsPrec p (VkObjectType x) + = showParen (p >= 11) (showString "VkObjectType " . showsPrec 11 x) + +instance Read VkObjectType where + readPrec + = parens + (choose + [("VK_OBJECT_TYPE_UNKNOWN", pure VK_OBJECT_TYPE_UNKNOWN), + ("VK_OBJECT_TYPE_INSTANCE", pure VK_OBJECT_TYPE_INSTANCE), + ("VK_OBJECT_TYPE_PHYSICAL_DEVICE", + pure VK_OBJECT_TYPE_PHYSICAL_DEVICE), + ("VK_OBJECT_TYPE_DEVICE", pure VK_OBJECT_TYPE_DEVICE), + ("VK_OBJECT_TYPE_QUEUE", pure VK_OBJECT_TYPE_QUEUE), + ("VK_OBJECT_TYPE_SEMAPHORE", pure VK_OBJECT_TYPE_SEMAPHORE), + ("VK_OBJECT_TYPE_COMMAND_BUFFER", + pure VK_OBJECT_TYPE_COMMAND_BUFFER), + ("VK_OBJECT_TYPE_FENCE", pure VK_OBJECT_TYPE_FENCE), + ("VK_OBJECT_TYPE_DEVICE_MEMORY", + pure VK_OBJECT_TYPE_DEVICE_MEMORY), + ("VK_OBJECT_TYPE_BUFFER", pure VK_OBJECT_TYPE_BUFFER), + ("VK_OBJECT_TYPE_IMAGE", pure VK_OBJECT_TYPE_IMAGE), + ("VK_OBJECT_TYPE_EVENT", pure VK_OBJECT_TYPE_EVENT), + ("VK_OBJECT_TYPE_QUERY_POOL", pure VK_OBJECT_TYPE_QUERY_POOL), + ("VK_OBJECT_TYPE_BUFFER_VIEW", pure VK_OBJECT_TYPE_BUFFER_VIEW), + ("VK_OBJECT_TYPE_IMAGE_VIEW", pure VK_OBJECT_TYPE_IMAGE_VIEW), + ("VK_OBJECT_TYPE_SHADER_MODULE", + pure VK_OBJECT_TYPE_SHADER_MODULE), + ("VK_OBJECT_TYPE_PIPELINE_CACHE", + pure VK_OBJECT_TYPE_PIPELINE_CACHE), + ("VK_OBJECT_TYPE_PIPELINE_LAYOUT", + pure VK_OBJECT_TYPE_PIPELINE_LAYOUT), + ("VK_OBJECT_TYPE_RENDER_PASS", pure VK_OBJECT_TYPE_RENDER_PASS), + ("VK_OBJECT_TYPE_PIPELINE", pure VK_OBJECT_TYPE_PIPELINE), + ("VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT", + pure VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT), + ("VK_OBJECT_TYPE_SAMPLER", pure VK_OBJECT_TYPE_SAMPLER), + ("VK_OBJECT_TYPE_DESCRIPTOR_POOL", + pure VK_OBJECT_TYPE_DESCRIPTOR_POOL), + ("VK_OBJECT_TYPE_DESCRIPTOR_SET", + pure VK_OBJECT_TYPE_DESCRIPTOR_SET), + ("VK_OBJECT_TYPE_FRAMEBUFFER", pure VK_OBJECT_TYPE_FRAMEBUFFER), + ("VK_OBJECT_TYPE_COMMAND_POOL", pure VK_OBJECT_TYPE_COMMAND_POOL)] + +++ + prec 10 + (expectP (Ident "VkObjectType") >> + (VkObjectType <$> step readPrec))) + +pattern VK_OBJECT_TYPE_UNKNOWN :: VkObjectType + +pattern VK_OBJECT_TYPE_UNKNOWN = VkObjectType 0 + +-- | VkInstance +pattern VK_OBJECT_TYPE_INSTANCE :: VkObjectType + +pattern VK_OBJECT_TYPE_INSTANCE = VkObjectType 1 + +-- | VkPhysicalDevice +pattern VK_OBJECT_TYPE_PHYSICAL_DEVICE :: VkObjectType + +pattern VK_OBJECT_TYPE_PHYSICAL_DEVICE = VkObjectType 2 + +-- | VkDevice +pattern VK_OBJECT_TYPE_DEVICE :: VkObjectType + +pattern VK_OBJECT_TYPE_DEVICE = VkObjectType 3 + +-- | VkQueue +pattern VK_OBJECT_TYPE_QUEUE :: VkObjectType + +pattern VK_OBJECT_TYPE_QUEUE = VkObjectType 4 + +-- | VkSemaphore +pattern VK_OBJECT_TYPE_SEMAPHORE :: VkObjectType + +pattern VK_OBJECT_TYPE_SEMAPHORE = VkObjectType 5 + +-- | VkCommandBuffer +pattern VK_OBJECT_TYPE_COMMAND_BUFFER :: VkObjectType + +pattern VK_OBJECT_TYPE_COMMAND_BUFFER = VkObjectType 6 + +-- | VkFence +pattern VK_OBJECT_TYPE_FENCE :: VkObjectType + +pattern VK_OBJECT_TYPE_FENCE = VkObjectType 7 + +-- | VkDeviceMemory +pattern VK_OBJECT_TYPE_DEVICE_MEMORY :: VkObjectType + +pattern VK_OBJECT_TYPE_DEVICE_MEMORY = VkObjectType 8 + +-- | VkBuffer +pattern VK_OBJECT_TYPE_BUFFER :: VkObjectType + +pattern VK_OBJECT_TYPE_BUFFER = VkObjectType 9 + +-- | VkImage +pattern VK_OBJECT_TYPE_IMAGE :: VkObjectType + +pattern VK_OBJECT_TYPE_IMAGE = VkObjectType 10 + +-- | VkEvent +pattern VK_OBJECT_TYPE_EVENT :: VkObjectType + +pattern VK_OBJECT_TYPE_EVENT = VkObjectType 11 + +-- | VkQueryPool +pattern VK_OBJECT_TYPE_QUERY_POOL :: VkObjectType + +pattern VK_OBJECT_TYPE_QUERY_POOL = VkObjectType 12 + +-- | VkBufferView +pattern VK_OBJECT_TYPE_BUFFER_VIEW :: VkObjectType + +pattern VK_OBJECT_TYPE_BUFFER_VIEW = VkObjectType 13 + +-- | VkImageView +pattern VK_OBJECT_TYPE_IMAGE_VIEW :: VkObjectType + +pattern VK_OBJECT_TYPE_IMAGE_VIEW = VkObjectType 14 + +-- | VkShaderModule +pattern VK_OBJECT_TYPE_SHADER_MODULE :: VkObjectType + +pattern VK_OBJECT_TYPE_SHADER_MODULE = VkObjectType 15 + +-- | VkPipelineCache +pattern VK_OBJECT_TYPE_PIPELINE_CACHE :: VkObjectType + +pattern VK_OBJECT_TYPE_PIPELINE_CACHE = VkObjectType 16 + +-- | VkPipelineLayout +pattern VK_OBJECT_TYPE_PIPELINE_LAYOUT :: VkObjectType + +pattern VK_OBJECT_TYPE_PIPELINE_LAYOUT = VkObjectType 17 + +-- | VkRenderPass +pattern VK_OBJECT_TYPE_RENDER_PASS :: VkObjectType + +pattern VK_OBJECT_TYPE_RENDER_PASS = VkObjectType 18 + +-- | VkPipeline +pattern VK_OBJECT_TYPE_PIPELINE :: VkObjectType + +pattern VK_OBJECT_TYPE_PIPELINE = VkObjectType 19 + +-- | VkDescriptorSetLayout +pattern VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT :: VkObjectType + +pattern VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT = VkObjectType 20 + +-- | VkSampler +pattern VK_OBJECT_TYPE_SAMPLER :: VkObjectType + +pattern VK_OBJECT_TYPE_SAMPLER = VkObjectType 21 + +-- | VkDescriptorPool +pattern VK_OBJECT_TYPE_DESCRIPTOR_POOL :: VkObjectType + +pattern VK_OBJECT_TYPE_DESCRIPTOR_POOL = VkObjectType 22 + +-- | VkDescriptorSet +pattern VK_OBJECT_TYPE_DESCRIPTOR_SET :: VkObjectType + +pattern VK_OBJECT_TYPE_DESCRIPTOR_SET = VkObjectType 23 + +-- | VkFramebuffer +pattern VK_OBJECT_TYPE_FRAMEBUFFER :: VkObjectType + +pattern VK_OBJECT_TYPE_FRAMEBUFFER = VkObjectType 24 + +-- | VkCommandPool +pattern VK_OBJECT_TYPE_COMMAND_POOL :: VkObjectType + +pattern VK_OBJECT_TYPE_COMMAND_POOL = VkObjectType 25 diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkPeerMemoryFeatureFlagsKHX.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkPeerMemoryFeatureFlagsKHX.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkPeerMemoryFeatureFlagsKHX.hs @@ -0,0 +1,133 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE KindSignatures #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE StandaloneDeriving #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeSynonymInstances #-} +module Graphics.Vulkan.Types.Enum.VkPeerMemoryFeatureFlagsKHX + (VkPeerMemoryFeatureBitmaskKHX(VkPeerMemoryFeatureBitmaskKHX, + VkPeerMemoryFeatureFlagsKHX, VkPeerMemoryFeatureFlagBitsKHX, + VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT_KHX, + VK_PEER_MEMORY_FEATURE_COPY_DST_BIT_KHX, + VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT_KHX, + VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT_KHX), + VkPeerMemoryFeatureFlagsKHX, VkPeerMemoryFeatureFlagBitsKHX) + where +import Data.Bits (Bits, FiniteBits) +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (FlagBit, FlagMask, FlagType) +import Graphics.Vulkan.Types.BaseTypes (VkFlags (..)) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +newtype VkPeerMemoryFeatureBitmaskKHX (a :: + FlagType) = VkPeerMemoryFeatureBitmaskKHX VkFlags + deriving (Eq, Ord, Storable, Data, Generic) + +type VkPeerMemoryFeatureFlagsKHX = + VkPeerMemoryFeatureBitmaskKHX FlagMask + +type VkPeerMemoryFeatureFlagBitsKHX = + VkPeerMemoryFeatureBitmaskKHX FlagBit + +pattern VkPeerMemoryFeatureFlagBitsKHX :: + VkFlags -> VkPeerMemoryFeatureBitmaskKHX FlagBit + +pattern VkPeerMemoryFeatureFlagBitsKHX n = + VkPeerMemoryFeatureBitmaskKHX n + +pattern VkPeerMemoryFeatureFlagsKHX :: + VkFlags -> VkPeerMemoryFeatureBitmaskKHX FlagMask + +pattern VkPeerMemoryFeatureFlagsKHX n = + VkPeerMemoryFeatureBitmaskKHX n + +deriving instance Bits (VkPeerMemoryFeatureBitmaskKHX FlagMask) + +deriving instance + FiniteBits (VkPeerMemoryFeatureBitmaskKHX FlagMask) + +deriving instance Integral (VkPeerMemoryFeatureBitmaskKHX FlagMask) + +deriving instance Num (VkPeerMemoryFeatureBitmaskKHX FlagMask) + +deriving instance Bounded (VkPeerMemoryFeatureBitmaskKHX FlagMask) + +deriving instance Enum (VkPeerMemoryFeatureBitmaskKHX FlagMask) + +deriving instance Real (VkPeerMemoryFeatureBitmaskKHX FlagMask) + +instance Show (VkPeerMemoryFeatureBitmaskKHX a) where + showsPrec _ VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT_KHX + = showString "VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT_KHX" + showsPrec _ VK_PEER_MEMORY_FEATURE_COPY_DST_BIT_KHX + = showString "VK_PEER_MEMORY_FEATURE_COPY_DST_BIT_KHX" + showsPrec _ VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT_KHX + = showString "VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT_KHX" + showsPrec _ VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT_KHX + = showString "VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT_KHX" + showsPrec p (VkPeerMemoryFeatureBitmaskKHX x) + = showParen (p >= 11) + (showString "VkPeerMemoryFeatureBitmaskKHX " . showsPrec 11 x) + +instance Read (VkPeerMemoryFeatureBitmaskKHX a) where + readPrec + = parens + (choose + [("VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT_KHX", + pure VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT_KHX), + ("VK_PEER_MEMORY_FEATURE_COPY_DST_BIT_KHX", + pure VK_PEER_MEMORY_FEATURE_COPY_DST_BIT_KHX), + ("VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT_KHX", + pure VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT_KHX), + ("VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT_KHX", + pure VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT_KHX)] + +++ + prec 10 + (expectP (Ident "VkPeerMemoryFeatureBitmaskKHX") >> + (VkPeerMemoryFeatureBitmaskKHX <$> step readPrec))) + +-- | Can read with vkCmdCopy commands +-- +-- bitpos = @0@ +pattern VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT_KHX :: + VkPeerMemoryFeatureBitmaskKHX a + +pattern VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT_KHX = + VkPeerMemoryFeatureBitmaskKHX 1 + +-- | Can write with vkCmdCopy commands +-- +-- bitpos = @1@ +pattern VK_PEER_MEMORY_FEATURE_COPY_DST_BIT_KHX :: + VkPeerMemoryFeatureBitmaskKHX a + +pattern VK_PEER_MEMORY_FEATURE_COPY_DST_BIT_KHX = + VkPeerMemoryFeatureBitmaskKHX 2 + +-- | Can read with any access type/command +-- +-- bitpos = @2@ +pattern VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT_KHX :: + VkPeerMemoryFeatureBitmaskKHX a + +pattern VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT_KHX = + VkPeerMemoryFeatureBitmaskKHX 4 + +-- | Can write with and access type/command +-- +-- bitpos = @3@ +pattern VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT_KHX :: + VkPeerMemoryFeatureBitmaskKHX a + +pattern VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT_KHX = + VkPeerMemoryFeatureBitmaskKHX 8 diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkPhysicalDeviceType.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkPhysicalDeviceType.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkPhysicalDeviceType.hs @@ -0,0 +1,86 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +module Graphics.Vulkan.Types.Enum.VkPhysicalDeviceType + (VkPhysicalDeviceType(VkPhysicalDeviceType, + VK_PHYSICAL_DEVICE_TYPE_OTHER, + VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU, + VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU, + VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU, VK_PHYSICAL_DEVICE_TYPE_CPU)) + where +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (Int32) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +-- | type = @enum@ +-- +-- +newtype VkPhysicalDeviceType = VkPhysicalDeviceType Int32 + deriving (Eq, Ord, Num, Bounded, Storable, Enum, Data, Generic) + +instance Show VkPhysicalDeviceType where + showsPrec _ VK_PHYSICAL_DEVICE_TYPE_OTHER + = showString "VK_PHYSICAL_DEVICE_TYPE_OTHER" + showsPrec _ VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU + = showString "VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU" + showsPrec _ VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU + = showString "VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU" + showsPrec _ VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU + = showString "VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU" + showsPrec _ VK_PHYSICAL_DEVICE_TYPE_CPU + = showString "VK_PHYSICAL_DEVICE_TYPE_CPU" + showsPrec p (VkPhysicalDeviceType x) + = showParen (p >= 11) + (showString "VkPhysicalDeviceType " . showsPrec 11 x) + +instance Read VkPhysicalDeviceType where + readPrec + = parens + (choose + [("VK_PHYSICAL_DEVICE_TYPE_OTHER", + pure VK_PHYSICAL_DEVICE_TYPE_OTHER), + ("VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU", + pure VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU), + ("VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU", + pure VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU), + ("VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU", + pure VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU), + ("VK_PHYSICAL_DEVICE_TYPE_CPU", pure VK_PHYSICAL_DEVICE_TYPE_CPU)] + +++ + prec 10 + (expectP (Ident "VkPhysicalDeviceType") >> + (VkPhysicalDeviceType <$> step readPrec))) + +pattern VK_PHYSICAL_DEVICE_TYPE_OTHER :: VkPhysicalDeviceType + +pattern VK_PHYSICAL_DEVICE_TYPE_OTHER = VkPhysicalDeviceType 0 + +pattern VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU :: + VkPhysicalDeviceType + +pattern VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU = + VkPhysicalDeviceType 1 + +pattern VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU :: + VkPhysicalDeviceType + +pattern VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU = + VkPhysicalDeviceType 2 + +pattern VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU :: VkPhysicalDeviceType + +pattern VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU = + VkPhysicalDeviceType 3 + +pattern VK_PHYSICAL_DEVICE_TYPE_CPU :: VkPhysicalDeviceType + +pattern VK_PHYSICAL_DEVICE_TYPE_CPU = VkPhysicalDeviceType 4 diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkPipelineBindPoint.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkPipelineBindPoint.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkPipelineBindPoint.hs @@ -0,0 +1,55 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +module Graphics.Vulkan.Types.Enum.VkPipelineBindPoint + (VkPipelineBindPoint(VkPipelineBindPoint, + VK_PIPELINE_BIND_POINT_GRAPHICS, VK_PIPELINE_BIND_POINT_COMPUTE)) + where +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (Int32) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +-- | type = @enum@ +-- +-- +newtype VkPipelineBindPoint = VkPipelineBindPoint Int32 + deriving (Eq, Ord, Num, Bounded, Storable, Enum, Data, Generic) + +instance Show VkPipelineBindPoint where + showsPrec _ VK_PIPELINE_BIND_POINT_GRAPHICS + = showString "VK_PIPELINE_BIND_POINT_GRAPHICS" + showsPrec _ VK_PIPELINE_BIND_POINT_COMPUTE + = showString "VK_PIPELINE_BIND_POINT_COMPUTE" + showsPrec p (VkPipelineBindPoint x) + = showParen (p >= 11) + (showString "VkPipelineBindPoint " . showsPrec 11 x) + +instance Read VkPipelineBindPoint where + readPrec + = parens + (choose + [("VK_PIPELINE_BIND_POINT_GRAPHICS", + pure VK_PIPELINE_BIND_POINT_GRAPHICS), + ("VK_PIPELINE_BIND_POINT_COMPUTE", + pure VK_PIPELINE_BIND_POINT_COMPUTE)] + +++ + prec 10 + (expectP (Ident "VkPipelineBindPoint") >> + (VkPipelineBindPoint <$> step readPrec))) + +pattern VK_PIPELINE_BIND_POINT_GRAPHICS :: VkPipelineBindPoint + +pattern VK_PIPELINE_BIND_POINT_GRAPHICS = VkPipelineBindPoint 0 + +pattern VK_PIPELINE_BIND_POINT_COMPUTE :: VkPipelineBindPoint + +pattern VK_PIPELINE_BIND_POINT_COMPUTE = VkPipelineBindPoint 1 diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkPipelineCacheCreateFlagBits.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkPipelineCacheCreateFlagBits.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkPipelineCacheCreateFlagBits.hs @@ -0,0 +1,25 @@ +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE Strict #-} +module Graphics.Vulkan.Types.Enum.VkPipelineCacheCreateFlagBits + (VkPipelineCacheCreateFlagBits(..)) where +import Data.Bits (Bits, FiniteBits) +import Data.Coerce (coerce) +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import Graphics.Vulkan.Types.BaseTypes (VkFlags) + +newtype VkPipelineCacheCreateFlagBits = VkPipelineCacheCreateFlagBits VkFlags + deriving (Eq, Ord, Num, Bounded, Enum, Integral, Bits, + FiniteBits, Storable, Real, Data, Generic) + +instance Show VkPipelineCacheCreateFlagBits where + {-# INLINE show #-} + show (VkPipelineCacheCreateFlagBits x) = show x + +instance Read VkPipelineCacheCreateFlagBits where + {-# INLINE readsPrec #-} + readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags) diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkPipelineCacheHeaderVersion.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkPipelineCacheHeaderVersion.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkPipelineCacheHeaderVersion.hs @@ -0,0 +1,50 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +module Graphics.Vulkan.Types.Enum.VkPipelineCacheHeaderVersion + (VkPipelineCacheHeaderVersion(VkPipelineCacheHeaderVersion, + VK_PIPELINE_CACHE_HEADER_VERSION_ONE)) + where +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (Int32) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +-- | type = @enum@ +-- +-- +newtype VkPipelineCacheHeaderVersion = VkPipelineCacheHeaderVersion Int32 + deriving (Eq, Ord, Num, Bounded, Storable, Enum, Data, + Generic) + +instance Show VkPipelineCacheHeaderVersion where + showsPrec _ VK_PIPELINE_CACHE_HEADER_VERSION_ONE + = showString "VK_PIPELINE_CACHE_HEADER_VERSION_ONE" + showsPrec p (VkPipelineCacheHeaderVersion x) + = showParen (p >= 11) + (showString "VkPipelineCacheHeaderVersion " . showsPrec 11 x) + +instance Read VkPipelineCacheHeaderVersion where + readPrec + = parens + (choose + [("VK_PIPELINE_CACHE_HEADER_VERSION_ONE", + pure VK_PIPELINE_CACHE_HEADER_VERSION_ONE)] + +++ + prec 10 + (expectP (Ident "VkPipelineCacheHeaderVersion") >> + (VkPipelineCacheHeaderVersion <$> step readPrec))) + +pattern VK_PIPELINE_CACHE_HEADER_VERSION_ONE :: + VkPipelineCacheHeaderVersion + +pattern VK_PIPELINE_CACHE_HEADER_VERSION_ONE = + VkPipelineCacheHeaderVersion 1 diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkPipelineColorBlendStateCreateFlagBits.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkPipelineColorBlendStateCreateFlagBits.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkPipelineColorBlendStateCreateFlagBits.hs @@ -0,0 +1,26 @@ +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE Strict #-} +module Graphics.Vulkan.Types.Enum.VkPipelineColorBlendStateCreateFlagBits + (VkPipelineColorBlendStateCreateFlagBits(..)) where +import Data.Bits (Bits, FiniteBits) +import Data.Coerce (coerce) +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import Graphics.Vulkan.Types.BaseTypes (VkFlags) + +newtype VkPipelineColorBlendStateCreateFlagBits = VkPipelineColorBlendStateCreateFlagBits VkFlags + deriving (Eq, Ord, Num, Bounded, Enum, Integral, + Bits, FiniteBits, Storable, Real, + Data, Generic) + +instance Show VkPipelineColorBlendStateCreateFlagBits where + {-# INLINE show #-} + show (VkPipelineColorBlendStateCreateFlagBits x) = show x + +instance Read VkPipelineColorBlendStateCreateFlagBits where + {-# INLINE readsPrec #-} + readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags) diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkPipelineCreateFlags.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkPipelineCreateFlags.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkPipelineCreateFlags.hs @@ -0,0 +1,108 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE KindSignatures #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE StandaloneDeriving #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeSynonymInstances #-} +module Graphics.Vulkan.Types.Enum.VkPipelineCreateFlags + (VkPipelineCreateBitmask(VkPipelineCreateBitmask, + VkPipelineCreateFlags, VkPipelineCreateFlagBits, + VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT, + VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT, + VK_PIPELINE_CREATE_DERIVATIVE_BIT), + VkPipelineCreateFlags, VkPipelineCreateFlagBits) + where +import Data.Bits (Bits, FiniteBits) +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (FlagBit, FlagMask, FlagType) +import Graphics.Vulkan.Types.BaseTypes (VkFlags (..)) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +newtype VkPipelineCreateBitmask (a :: + FlagType) = VkPipelineCreateBitmask VkFlags + deriving (Eq, Ord, Storable, Data, Generic) + +type VkPipelineCreateFlags = VkPipelineCreateBitmask FlagMask + +type VkPipelineCreateFlagBits = VkPipelineCreateBitmask FlagBit + +pattern VkPipelineCreateFlagBits :: + VkFlags -> VkPipelineCreateBitmask FlagBit + +pattern VkPipelineCreateFlagBits n = VkPipelineCreateBitmask n + +pattern VkPipelineCreateFlags :: + VkFlags -> VkPipelineCreateBitmask FlagMask + +pattern VkPipelineCreateFlags n = VkPipelineCreateBitmask n + +deriving instance Bits (VkPipelineCreateBitmask FlagMask) + +deriving instance FiniteBits (VkPipelineCreateBitmask FlagMask) + +deriving instance Integral (VkPipelineCreateBitmask FlagMask) + +deriving instance Num (VkPipelineCreateBitmask FlagMask) + +deriving instance Bounded (VkPipelineCreateBitmask FlagMask) + +deriving instance Enum (VkPipelineCreateBitmask FlagMask) + +deriving instance Real (VkPipelineCreateBitmask FlagMask) + +instance Show (VkPipelineCreateBitmask a) where + showsPrec _ VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT + = showString "VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT" + showsPrec _ VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT + = showString "VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT" + showsPrec _ VK_PIPELINE_CREATE_DERIVATIVE_BIT + = showString "VK_PIPELINE_CREATE_DERIVATIVE_BIT" + showsPrec p (VkPipelineCreateBitmask x) + = showParen (p >= 11) + (showString "VkPipelineCreateBitmask " . showsPrec 11 x) + +instance Read (VkPipelineCreateBitmask a) where + readPrec + = parens + (choose + [("VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT", + pure VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT), + ("VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT", + pure VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT), + ("VK_PIPELINE_CREATE_DERIVATIVE_BIT", + pure VK_PIPELINE_CREATE_DERIVATIVE_BIT)] + +++ + prec 10 + (expectP (Ident "VkPipelineCreateBitmask") >> + (VkPipelineCreateBitmask <$> step readPrec))) + +-- | bitpos = @0@ +pattern VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT :: + VkPipelineCreateBitmask a + +pattern VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = + VkPipelineCreateBitmask 1 + +-- | bitpos = @1@ +pattern VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT :: + VkPipelineCreateBitmask a + +pattern VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = + VkPipelineCreateBitmask 2 + +-- | bitpos = @2@ +pattern VK_PIPELINE_CREATE_DERIVATIVE_BIT :: + VkPipelineCreateBitmask a + +pattern VK_PIPELINE_CREATE_DERIVATIVE_BIT = + VkPipelineCreateBitmask 4 diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkPipelineDepthStencilStateCreateFlagBits.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkPipelineDepthStencilStateCreateFlagBits.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkPipelineDepthStencilStateCreateFlagBits.hs @@ -0,0 +1,26 @@ +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE Strict #-} +module Graphics.Vulkan.Types.Enum.VkPipelineDepthStencilStateCreateFlagBits + (VkPipelineDepthStencilStateCreateFlagBits(..)) where +import Data.Bits (Bits, FiniteBits) +import Data.Coerce (coerce) +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import Graphics.Vulkan.Types.BaseTypes (VkFlags) + +newtype VkPipelineDepthStencilStateCreateFlagBits = VkPipelineDepthStencilStateCreateFlagBits VkFlags + deriving (Eq, Ord, Num, Bounded, Enum, + Integral, Bits, FiniteBits, + Storable, Real, Data, Generic) + +instance Show VkPipelineDepthStencilStateCreateFlagBits where + {-# INLINE show #-} + show (VkPipelineDepthStencilStateCreateFlagBits x) = show x + +instance Read VkPipelineDepthStencilStateCreateFlagBits where + {-# INLINE readsPrec #-} + readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags) diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkPipelineDynamicStateCreateFlagBits.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkPipelineDynamicStateCreateFlagBits.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkPipelineDynamicStateCreateFlagBits.hs @@ -0,0 +1,26 @@ +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE Strict #-} +module Graphics.Vulkan.Types.Enum.VkPipelineDynamicStateCreateFlagBits + (VkPipelineDynamicStateCreateFlagBits(..)) where +import Data.Bits (Bits, FiniteBits) +import Data.Coerce (coerce) +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import Graphics.Vulkan.Types.BaseTypes (VkFlags) + +newtype VkPipelineDynamicStateCreateFlagBits = VkPipelineDynamicStateCreateFlagBits VkFlags + deriving (Eq, Ord, Num, Bounded, Enum, Integral, + Bits, FiniteBits, Storable, Real, Data, + Generic) + +instance Show VkPipelineDynamicStateCreateFlagBits where + {-# INLINE show #-} + show (VkPipelineDynamicStateCreateFlagBits x) = show x + +instance Read VkPipelineDynamicStateCreateFlagBits where + {-# INLINE readsPrec #-} + readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags) diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkPipelineInputAssemblyStateCreateFlagBits.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkPipelineInputAssemblyStateCreateFlagBits.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkPipelineInputAssemblyStateCreateFlagBits.hs @@ -0,0 +1,26 @@ +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE Strict #-} +module Graphics.Vulkan.Types.Enum.VkPipelineInputAssemblyStateCreateFlagBits + (VkPipelineInputAssemblyStateCreateFlagBits(..)) where +import Data.Bits (Bits, FiniteBits) +import Data.Coerce (coerce) +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import Graphics.Vulkan.Types.BaseTypes (VkFlags) + +newtype VkPipelineInputAssemblyStateCreateFlagBits = VkPipelineInputAssemblyStateCreateFlagBits VkFlags + deriving (Eq, Ord, Num, Bounded, Enum, + Integral, Bits, FiniteBits, + Storable, Real, Data, Generic) + +instance Show VkPipelineInputAssemblyStateCreateFlagBits where + {-# INLINE show #-} + show (VkPipelineInputAssemblyStateCreateFlagBits x) = show x + +instance Read VkPipelineInputAssemblyStateCreateFlagBits where + {-# INLINE readsPrec #-} + readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags) diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkPipelineLayoutCreateFlagBits.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkPipelineLayoutCreateFlagBits.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkPipelineLayoutCreateFlagBits.hs @@ -0,0 +1,25 @@ +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE Strict #-} +module Graphics.Vulkan.Types.Enum.VkPipelineLayoutCreateFlagBits + (VkPipelineLayoutCreateFlagBits(..)) where +import Data.Bits (Bits, FiniteBits) +import Data.Coerce (coerce) +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import Graphics.Vulkan.Types.BaseTypes (VkFlags) + +newtype VkPipelineLayoutCreateFlagBits = VkPipelineLayoutCreateFlagBits VkFlags + deriving (Eq, Ord, Num, Bounded, Enum, Integral, Bits, + FiniteBits, Storable, Real, Data, Generic) + +instance Show VkPipelineLayoutCreateFlagBits where + {-# INLINE show #-} + show (VkPipelineLayoutCreateFlagBits x) = show x + +instance Read VkPipelineLayoutCreateFlagBits where + {-# INLINE readsPrec #-} + readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags) diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkPipelineMultisampleStateCreateFlagBits.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkPipelineMultisampleStateCreateFlagBits.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkPipelineMultisampleStateCreateFlagBits.hs @@ -0,0 +1,26 @@ +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE Strict #-} +module Graphics.Vulkan.Types.Enum.VkPipelineMultisampleStateCreateFlagBits + (VkPipelineMultisampleStateCreateFlagBits(..)) where +import Data.Bits (Bits, FiniteBits) +import Data.Coerce (coerce) +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import Graphics.Vulkan.Types.BaseTypes (VkFlags) + +newtype VkPipelineMultisampleStateCreateFlagBits = VkPipelineMultisampleStateCreateFlagBits VkFlags + deriving (Eq, Ord, Num, Bounded, Enum, + Integral, Bits, FiniteBits, Storable, + Real, Data, Generic) + +instance Show VkPipelineMultisampleStateCreateFlagBits where + {-# INLINE show #-} + show (VkPipelineMultisampleStateCreateFlagBits x) = show x + +instance Read VkPipelineMultisampleStateCreateFlagBits where + {-# INLINE readsPrec #-} + readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags) diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkPipelineRasterizationStateCreateFlagBits.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkPipelineRasterizationStateCreateFlagBits.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkPipelineRasterizationStateCreateFlagBits.hs @@ -0,0 +1,26 @@ +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE Strict #-} +module Graphics.Vulkan.Types.Enum.VkPipelineRasterizationStateCreateFlagBits + (VkPipelineRasterizationStateCreateFlagBits(..)) where +import Data.Bits (Bits, FiniteBits) +import Data.Coerce (coerce) +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import Graphics.Vulkan.Types.BaseTypes (VkFlags) + +newtype VkPipelineRasterizationStateCreateFlagBits = VkPipelineRasterizationStateCreateFlagBits VkFlags + deriving (Eq, Ord, Num, Bounded, Enum, + Integral, Bits, FiniteBits, + Storable, Real, Data, Generic) + +instance Show VkPipelineRasterizationStateCreateFlagBits where + {-# INLINE show #-} + show (VkPipelineRasterizationStateCreateFlagBits x) = show x + +instance Read VkPipelineRasterizationStateCreateFlagBits where + {-# INLINE readsPrec #-} + readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags) diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkPipelineShaderStageCreateFlagBits.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkPipelineShaderStageCreateFlagBits.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkPipelineShaderStageCreateFlagBits.hs @@ -0,0 +1,26 @@ +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE Strict #-} +module Graphics.Vulkan.Types.Enum.VkPipelineShaderStageCreateFlagBits + (VkPipelineShaderStageCreateFlagBits(..)) where +import Data.Bits (Bits, FiniteBits) +import Data.Coerce (coerce) +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import Graphics.Vulkan.Types.BaseTypes (VkFlags) + +newtype VkPipelineShaderStageCreateFlagBits = VkPipelineShaderStageCreateFlagBits VkFlags + deriving (Eq, Ord, Num, Bounded, Enum, Integral, + Bits, FiniteBits, Storable, Real, Data, + Generic) + +instance Show VkPipelineShaderStageCreateFlagBits where + {-# INLINE show #-} + show (VkPipelineShaderStageCreateFlagBits x) = show x + +instance Read VkPipelineShaderStageCreateFlagBits where + {-# INLINE readsPrec #-} + readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags) diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkPipelineStageFlags.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkPipelineStageFlags.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkPipelineStageFlags.hs @@ -0,0 +1,305 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE KindSignatures #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE StandaloneDeriving #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeSynonymInstances #-} +module Graphics.Vulkan.Types.Enum.VkPipelineStageFlags + (VkPipelineStageBitmask(VkPipelineStageBitmask, + VkPipelineStageFlags, VkPipelineStageFlagBits, + VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, + VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT, + VK_PIPELINE_STAGE_VERTEX_INPUT_BIT, + VK_PIPELINE_STAGE_VERTEX_SHADER_BIT, + VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT, + VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT, + VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT, + VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, + VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT, + VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT, + VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, + VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, + VK_PIPELINE_STAGE_TRANSFER_BIT, + VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, VK_PIPELINE_STAGE_HOST_BIT, + VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, + VK_PIPELINE_STAGE_ALL_COMMANDS_BIT), + VkPipelineStageFlags, VkPipelineStageFlagBits) + where +import Data.Bits (Bits, FiniteBits) +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (FlagBit, FlagMask, FlagType) +import Graphics.Vulkan.Types.BaseTypes (VkFlags (..)) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +newtype VkPipelineStageBitmask (a :: + FlagType) = VkPipelineStageBitmask VkFlags + deriving (Eq, Ord, Storable, Data, Generic) + +type VkPipelineStageFlags = VkPipelineStageBitmask FlagMask + +type VkPipelineStageFlagBits = VkPipelineStageBitmask FlagBit + +pattern VkPipelineStageFlagBits :: + VkFlags -> VkPipelineStageBitmask FlagBit + +pattern VkPipelineStageFlagBits n = VkPipelineStageBitmask n + +pattern VkPipelineStageFlags :: + VkFlags -> VkPipelineStageBitmask FlagMask + +pattern VkPipelineStageFlags n = VkPipelineStageBitmask n + +deriving instance Bits (VkPipelineStageBitmask FlagMask) + +deriving instance FiniteBits (VkPipelineStageBitmask FlagMask) + +deriving instance Integral (VkPipelineStageBitmask FlagMask) + +deriving instance Num (VkPipelineStageBitmask FlagMask) + +deriving instance Bounded (VkPipelineStageBitmask FlagMask) + +deriving instance Enum (VkPipelineStageBitmask FlagMask) + +deriving instance Real (VkPipelineStageBitmask FlagMask) + +instance Show (VkPipelineStageBitmask a) where + showsPrec _ VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT + = showString "VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT" + showsPrec _ VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT + = showString "VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT" + showsPrec _ VK_PIPELINE_STAGE_VERTEX_INPUT_BIT + = showString "VK_PIPELINE_STAGE_VERTEX_INPUT_BIT" + showsPrec _ VK_PIPELINE_STAGE_VERTEX_SHADER_BIT + = showString "VK_PIPELINE_STAGE_VERTEX_SHADER_BIT" + showsPrec _ VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT + = showString "VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT" + showsPrec _ VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT + = showString "VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT" + showsPrec _ VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT + = showString "VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT" + showsPrec _ VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT + = showString "VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT" + showsPrec _ VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT + = showString "VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT" + showsPrec _ VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT + = showString "VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT" + showsPrec _ VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT + = showString "VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT" + showsPrec _ VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT + = showString "VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT" + showsPrec _ VK_PIPELINE_STAGE_TRANSFER_BIT + = showString "VK_PIPELINE_STAGE_TRANSFER_BIT" + showsPrec _ VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT + = showString "VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT" + showsPrec _ VK_PIPELINE_STAGE_HOST_BIT + = showString "VK_PIPELINE_STAGE_HOST_BIT" + showsPrec _ VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT + = showString "VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT" + showsPrec _ VK_PIPELINE_STAGE_ALL_COMMANDS_BIT + = showString "VK_PIPELINE_STAGE_ALL_COMMANDS_BIT" + showsPrec p (VkPipelineStageBitmask x) + = showParen (p >= 11) + (showString "VkPipelineStageBitmask " . showsPrec 11 x) + +instance Read (VkPipelineStageBitmask a) where + readPrec + = parens + (choose + [("VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT", + pure VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT), + ("VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT", + pure VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT), + ("VK_PIPELINE_STAGE_VERTEX_INPUT_BIT", + pure VK_PIPELINE_STAGE_VERTEX_INPUT_BIT), + ("VK_PIPELINE_STAGE_VERTEX_SHADER_BIT", + pure VK_PIPELINE_STAGE_VERTEX_SHADER_BIT), + ("VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT", + pure VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT), + ("VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT", + pure VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT), + ("VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT", + pure VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT), + ("VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT", + pure VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT), + ("VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT", + pure VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT), + ("VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT", + pure VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT), + ("VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT", + pure VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT), + ("VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT", + pure VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT), + ("VK_PIPELINE_STAGE_TRANSFER_BIT", + pure VK_PIPELINE_STAGE_TRANSFER_BIT), + ("VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT", + pure VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT), + ("VK_PIPELINE_STAGE_HOST_BIT", pure VK_PIPELINE_STAGE_HOST_BIT), + ("VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT", + pure VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT), + ("VK_PIPELINE_STAGE_ALL_COMMANDS_BIT", + pure VK_PIPELINE_STAGE_ALL_COMMANDS_BIT)] + +++ + prec 10 + (expectP (Ident "VkPipelineStageBitmask") >> + (VkPipelineStageBitmask <$> step readPrec))) + +-- | Before subsequent commands are processed +-- +-- bitpos = @0@ +pattern VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT :: + VkPipelineStageBitmask a + +pattern VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT = + VkPipelineStageBitmask 1 + +-- | Draw/DispatchIndirect command fetch +-- +-- bitpos = @1@ +pattern VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT :: + VkPipelineStageBitmask a + +pattern VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT = + VkPipelineStageBitmask 2 + +-- | Vertex/index fetch +-- +-- bitpos = @2@ +pattern VK_PIPELINE_STAGE_VERTEX_INPUT_BIT :: + VkPipelineStageBitmask a + +pattern VK_PIPELINE_STAGE_VERTEX_INPUT_BIT = + VkPipelineStageBitmask 4 + +-- | Vertex shading +-- +-- bitpos = @3@ +pattern VK_PIPELINE_STAGE_VERTEX_SHADER_BIT :: + VkPipelineStageBitmask a + +pattern VK_PIPELINE_STAGE_VERTEX_SHADER_BIT = + VkPipelineStageBitmask 8 + +-- | Tessellation control shading +-- +-- bitpos = @4@ +pattern VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT :: + VkPipelineStageBitmask a + +pattern VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT = + VkPipelineStageBitmask 16 + +-- | Tessellation evaluation shading +-- +-- bitpos = @5@ +pattern VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT :: + VkPipelineStageBitmask a + +pattern VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT = + VkPipelineStageBitmask 32 + +-- | Geometry shading +-- +-- bitpos = @6@ +pattern VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT :: + VkPipelineStageBitmask a + +pattern VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT = + VkPipelineStageBitmask 64 + +-- | Fragment shading +-- +-- bitpos = @7@ +pattern VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT :: + VkPipelineStageBitmask a + +pattern VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT = + VkPipelineStageBitmask 128 + +-- | Early fragment (depth and stencil) tests +-- +-- bitpos = @8@ +pattern VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT :: + VkPipelineStageBitmask a + +pattern VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT = + VkPipelineStageBitmask 256 + +-- | Late fragment (depth and stencil) tests +-- +-- bitpos = @9@ +pattern VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT :: + VkPipelineStageBitmask a + +pattern VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT = + VkPipelineStageBitmask 512 + +-- | Color attachment writes +-- +-- bitpos = @10@ +pattern VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT :: + VkPipelineStageBitmask a + +pattern VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT = + VkPipelineStageBitmask 1024 + +-- | Compute shading +-- +-- bitpos = @11@ +pattern VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT :: + VkPipelineStageBitmask a + +pattern VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT = + VkPipelineStageBitmask 2048 + +-- | Transfer/copy operations +-- +-- bitpos = @12@ +pattern VK_PIPELINE_STAGE_TRANSFER_BIT :: VkPipelineStageBitmask a + +pattern VK_PIPELINE_STAGE_TRANSFER_BIT = + VkPipelineStageBitmask 4096 + +-- | After previous commands have completed +-- +-- bitpos = @13@ +pattern VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT :: + VkPipelineStageBitmask a + +pattern VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT = + VkPipelineStageBitmask 8192 + +-- | Indicates host (CPU) is a source/sink of the dependency +-- +-- bitpos = @14@ +pattern VK_PIPELINE_STAGE_HOST_BIT :: VkPipelineStageBitmask a + +pattern VK_PIPELINE_STAGE_HOST_BIT = VkPipelineStageBitmask 16384 + +-- | All stages of the graphics pipeline +-- +-- bitpos = @15@ +pattern VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT :: + VkPipelineStageBitmask a + +pattern VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT = + VkPipelineStageBitmask 32768 + +-- | All stages supported on the queue +-- +-- bitpos = @16@ +pattern VK_PIPELINE_STAGE_ALL_COMMANDS_BIT :: + VkPipelineStageBitmask a + +pattern VK_PIPELINE_STAGE_ALL_COMMANDS_BIT = + VkPipelineStageBitmask 65536 diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkPipelineTessellationStateCreateFlagBits.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkPipelineTessellationStateCreateFlagBits.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkPipelineTessellationStateCreateFlagBits.hs @@ -0,0 +1,26 @@ +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE Strict #-} +module Graphics.Vulkan.Types.Enum.VkPipelineTessellationStateCreateFlagBits + (VkPipelineTessellationStateCreateFlagBits(..)) where +import Data.Bits (Bits, FiniteBits) +import Data.Coerce (coerce) +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import Graphics.Vulkan.Types.BaseTypes (VkFlags) + +newtype VkPipelineTessellationStateCreateFlagBits = VkPipelineTessellationStateCreateFlagBits VkFlags + deriving (Eq, Ord, Num, Bounded, Enum, + Integral, Bits, FiniteBits, + Storable, Real, Data, Generic) + +instance Show VkPipelineTessellationStateCreateFlagBits where + {-# INLINE show #-} + show (VkPipelineTessellationStateCreateFlagBits x) = show x + +instance Read VkPipelineTessellationStateCreateFlagBits where + {-# INLINE readsPrec #-} + readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags) diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkPipelineVertexInputStateCreateFlagBits.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkPipelineVertexInputStateCreateFlagBits.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkPipelineVertexInputStateCreateFlagBits.hs @@ -0,0 +1,26 @@ +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE Strict #-} +module Graphics.Vulkan.Types.Enum.VkPipelineVertexInputStateCreateFlagBits + (VkPipelineVertexInputStateCreateFlagBits(..)) where +import Data.Bits (Bits, FiniteBits) +import Data.Coerce (coerce) +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import Graphics.Vulkan.Types.BaseTypes (VkFlags) + +newtype VkPipelineVertexInputStateCreateFlagBits = VkPipelineVertexInputStateCreateFlagBits VkFlags + deriving (Eq, Ord, Num, Bounded, Enum, + Integral, Bits, FiniteBits, Storable, + Real, Data, Generic) + +instance Show VkPipelineVertexInputStateCreateFlagBits where + {-# INLINE show #-} + show (VkPipelineVertexInputStateCreateFlagBits x) = show x + +instance Read VkPipelineVertexInputStateCreateFlagBits where + {-# INLINE readsPrec #-} + readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags) diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkPipelineViewportStateCreateFlagBits.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkPipelineViewportStateCreateFlagBits.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkPipelineViewportStateCreateFlagBits.hs @@ -0,0 +1,26 @@ +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE Strict #-} +module Graphics.Vulkan.Types.Enum.VkPipelineViewportStateCreateFlagBits + (VkPipelineViewportStateCreateFlagBits(..)) where +import Data.Bits (Bits, FiniteBits) +import Data.Coerce (coerce) +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import Graphics.Vulkan.Types.BaseTypes (VkFlags) + +newtype VkPipelineViewportStateCreateFlagBits = VkPipelineViewportStateCreateFlagBits VkFlags + deriving (Eq, Ord, Num, Bounded, Enum, Integral, + Bits, FiniteBits, Storable, Real, Data, + Generic) + +instance Show VkPipelineViewportStateCreateFlagBits where + {-# INLINE show #-} + show (VkPipelineViewportStateCreateFlagBits x) = show x + +instance Read VkPipelineViewportStateCreateFlagBits where + {-# INLINE readsPrec #-} + readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags) diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkPointClippingBehaviorKHR.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkPointClippingBehaviorKHR.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkPointClippingBehaviorKHR.hs @@ -0,0 +1,61 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +module Graphics.Vulkan.Types.Enum.VkPointClippingBehaviorKHR + (VkPointClippingBehaviorKHR(VkPointClippingBehaviorKHR, + VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES_KHR, + VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY_KHR)) + where +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (Int32) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +-- | type = @enum@ +-- +-- +newtype VkPointClippingBehaviorKHR = VkPointClippingBehaviorKHR Int32 + deriving (Eq, Ord, Num, Bounded, Storable, Enum, Data, + Generic) + +instance Show VkPointClippingBehaviorKHR where + showsPrec _ VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES_KHR + = showString "VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES_KHR" + showsPrec _ VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY_KHR + = showString "VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY_KHR" + showsPrec p (VkPointClippingBehaviorKHR x) + = showParen (p >= 11) + (showString "VkPointClippingBehaviorKHR " . showsPrec 11 x) + +instance Read VkPointClippingBehaviorKHR where + readPrec + = parens + (choose + [("VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES_KHR", + pure VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES_KHR), + ("VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY_KHR", + pure VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY_KHR)] + +++ + prec 10 + (expectP (Ident "VkPointClippingBehaviorKHR") >> + (VkPointClippingBehaviorKHR <$> step readPrec))) + +pattern VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES_KHR :: + VkPointClippingBehaviorKHR + +pattern VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES_KHR = + VkPointClippingBehaviorKHR 0 + +pattern VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY_KHR :: + VkPointClippingBehaviorKHR + +pattern VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY_KHR = + VkPointClippingBehaviorKHR 1 diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkPolygonMode.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkPolygonMode.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkPolygonMode.hs @@ -0,0 +1,60 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +module Graphics.Vulkan.Types.Enum.VkPolygonMode + (VkPolygonMode(VkPolygonMode, VK_POLYGON_MODE_FILL, + VK_POLYGON_MODE_LINE, VK_POLYGON_MODE_POINT)) + where +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (Int32) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +-- | type = @enum@ +-- +-- +newtype VkPolygonMode = VkPolygonMode Int32 + deriving (Eq, Ord, Num, Bounded, Storable, Enum, Data, Generic) + +instance Show VkPolygonMode where + showsPrec _ VK_POLYGON_MODE_FILL + = showString "VK_POLYGON_MODE_FILL" + showsPrec _ VK_POLYGON_MODE_LINE + = showString "VK_POLYGON_MODE_LINE" + showsPrec _ VK_POLYGON_MODE_POINT + = showString "VK_POLYGON_MODE_POINT" + showsPrec p (VkPolygonMode x) + = showParen (p >= 11) + (showString "VkPolygonMode " . showsPrec 11 x) + +instance Read VkPolygonMode where + readPrec + = parens + (choose + [("VK_POLYGON_MODE_FILL", pure VK_POLYGON_MODE_FILL), + ("VK_POLYGON_MODE_LINE", pure VK_POLYGON_MODE_LINE), + ("VK_POLYGON_MODE_POINT", pure VK_POLYGON_MODE_POINT)] + +++ + prec 10 + (expectP (Ident "VkPolygonMode") >> + (VkPolygonMode <$> step readPrec))) + +pattern VK_POLYGON_MODE_FILL :: VkPolygonMode + +pattern VK_POLYGON_MODE_FILL = VkPolygonMode 0 + +pattern VK_POLYGON_MODE_LINE :: VkPolygonMode + +pattern VK_POLYGON_MODE_LINE = VkPolygonMode 1 + +pattern VK_POLYGON_MODE_POINT :: VkPolygonMode + +pattern VK_POLYGON_MODE_POINT = VkPolygonMode 2 diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkPresentModeKHR.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkPresentModeKHR.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkPresentModeKHR.hs @@ -0,0 +1,70 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +module Graphics.Vulkan.Types.Enum.VkPresentModeKHR + (VkPresentModeKHR(VkPresentModeKHR, VK_PRESENT_MODE_IMMEDIATE_KHR, + VK_PRESENT_MODE_MAILBOX_KHR, VK_PRESENT_MODE_FIFO_KHR, + VK_PRESENT_MODE_FIFO_RELAXED_KHR)) + where +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (Int32) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +-- | type = @enum@ +-- +-- +newtype VkPresentModeKHR = VkPresentModeKHR Int32 + deriving (Eq, Ord, Num, Bounded, Storable, Enum, Data, Generic) + +instance Show VkPresentModeKHR where + showsPrec _ VK_PRESENT_MODE_IMMEDIATE_KHR + = showString "VK_PRESENT_MODE_IMMEDIATE_KHR" + showsPrec _ VK_PRESENT_MODE_MAILBOX_KHR + = showString "VK_PRESENT_MODE_MAILBOX_KHR" + showsPrec _ VK_PRESENT_MODE_FIFO_KHR + = showString "VK_PRESENT_MODE_FIFO_KHR" + showsPrec _ VK_PRESENT_MODE_FIFO_RELAXED_KHR + = showString "VK_PRESENT_MODE_FIFO_RELAXED_KHR" + showsPrec p (VkPresentModeKHR x) + = showParen (p >= 11) + (showString "VkPresentModeKHR " . showsPrec 11 x) + +instance Read VkPresentModeKHR where + readPrec + = parens + (choose + [("VK_PRESENT_MODE_IMMEDIATE_KHR", + pure VK_PRESENT_MODE_IMMEDIATE_KHR), + ("VK_PRESENT_MODE_MAILBOX_KHR", pure VK_PRESENT_MODE_MAILBOX_KHR), + ("VK_PRESENT_MODE_FIFO_KHR", pure VK_PRESENT_MODE_FIFO_KHR), + ("VK_PRESENT_MODE_FIFO_RELAXED_KHR", + pure VK_PRESENT_MODE_FIFO_RELAXED_KHR)] + +++ + prec 10 + (expectP (Ident "VkPresentModeKHR") >> + (VkPresentModeKHR <$> step readPrec))) + +pattern VK_PRESENT_MODE_IMMEDIATE_KHR :: VkPresentModeKHR + +pattern VK_PRESENT_MODE_IMMEDIATE_KHR = VkPresentModeKHR 0 + +pattern VK_PRESENT_MODE_MAILBOX_KHR :: VkPresentModeKHR + +pattern VK_PRESENT_MODE_MAILBOX_KHR = VkPresentModeKHR 1 + +pattern VK_PRESENT_MODE_FIFO_KHR :: VkPresentModeKHR + +pattern VK_PRESENT_MODE_FIFO_KHR = VkPresentModeKHR 2 + +pattern VK_PRESENT_MODE_FIFO_RELAXED_KHR :: VkPresentModeKHR + +pattern VK_PRESENT_MODE_FIFO_RELAXED_KHR = VkPresentModeKHR 3 diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkPrimitiveTopology.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkPrimitiveTopology.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkPrimitiveTopology.hs @@ -0,0 +1,145 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +module Graphics.Vulkan.Types.Enum.VkPrimitiveTopology + (VkPrimitiveTopology(VkPrimitiveTopology, + VK_PRIMITIVE_TOPOLOGY_POINT_LIST, VK_PRIMITIVE_TOPOLOGY_LINE_LIST, + VK_PRIMITIVE_TOPOLOGY_LINE_STRIP, + VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, + VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP, + VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN, + VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY, + VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY, + VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY, + VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY, + VK_PRIMITIVE_TOPOLOGY_PATCH_LIST)) + where +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (Int32) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +-- | type = @enum@ +-- +-- +newtype VkPrimitiveTopology = VkPrimitiveTopology Int32 + deriving (Eq, Ord, Num, Bounded, Storable, Enum, Data, Generic) + +instance Show VkPrimitiveTopology where + showsPrec _ VK_PRIMITIVE_TOPOLOGY_POINT_LIST + = showString "VK_PRIMITIVE_TOPOLOGY_POINT_LIST" + showsPrec _ VK_PRIMITIVE_TOPOLOGY_LINE_LIST + = showString "VK_PRIMITIVE_TOPOLOGY_LINE_LIST" + showsPrec _ VK_PRIMITIVE_TOPOLOGY_LINE_STRIP + = showString "VK_PRIMITIVE_TOPOLOGY_LINE_STRIP" + showsPrec _ VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST + = showString "VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST" + showsPrec _ VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP + = showString "VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP" + showsPrec _ VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN + = showString "VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN" + showsPrec _ VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY + = showString "VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY" + showsPrec _ VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY + = showString "VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY" + showsPrec _ VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY + = showString "VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY" + showsPrec _ VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY + = showString "VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY" + showsPrec _ VK_PRIMITIVE_TOPOLOGY_PATCH_LIST + = showString "VK_PRIMITIVE_TOPOLOGY_PATCH_LIST" + showsPrec p (VkPrimitiveTopology x) + = showParen (p >= 11) + (showString "VkPrimitiveTopology " . showsPrec 11 x) + +instance Read VkPrimitiveTopology where + readPrec + = parens + (choose + [("VK_PRIMITIVE_TOPOLOGY_POINT_LIST", + pure VK_PRIMITIVE_TOPOLOGY_POINT_LIST), + ("VK_PRIMITIVE_TOPOLOGY_LINE_LIST", + pure VK_PRIMITIVE_TOPOLOGY_LINE_LIST), + ("VK_PRIMITIVE_TOPOLOGY_LINE_STRIP", + pure VK_PRIMITIVE_TOPOLOGY_LINE_STRIP), + ("VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST", + pure VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST), + ("VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP", + pure VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP), + ("VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN", + pure VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN), + ("VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY", + pure VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY), + ("VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY", + pure VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY), + ("VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY", + pure VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY), + ("VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY", + pure VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY), + ("VK_PRIMITIVE_TOPOLOGY_PATCH_LIST", + pure VK_PRIMITIVE_TOPOLOGY_PATCH_LIST)] + +++ + prec 10 + (expectP (Ident "VkPrimitiveTopology") >> + (VkPrimitiveTopology <$> step readPrec))) + +pattern VK_PRIMITIVE_TOPOLOGY_POINT_LIST :: VkPrimitiveTopology + +pattern VK_PRIMITIVE_TOPOLOGY_POINT_LIST = VkPrimitiveTopology 0 + +pattern VK_PRIMITIVE_TOPOLOGY_LINE_LIST :: VkPrimitiveTopology + +pattern VK_PRIMITIVE_TOPOLOGY_LINE_LIST = VkPrimitiveTopology 1 + +pattern VK_PRIMITIVE_TOPOLOGY_LINE_STRIP :: VkPrimitiveTopology + +pattern VK_PRIMITIVE_TOPOLOGY_LINE_STRIP = VkPrimitiveTopology 2 + +pattern VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST :: VkPrimitiveTopology + +pattern VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST = VkPrimitiveTopology 3 + +pattern VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP :: VkPrimitiveTopology + +pattern VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP = + VkPrimitiveTopology 4 + +pattern VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN :: VkPrimitiveTopology + +pattern VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN = VkPrimitiveTopology 5 + +pattern VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY :: + VkPrimitiveTopology + +pattern VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY = + VkPrimitiveTopology 6 + +pattern VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY :: + VkPrimitiveTopology + +pattern VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY = + VkPrimitiveTopology 7 + +pattern VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY :: + VkPrimitiveTopology + +pattern VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY = + VkPrimitiveTopology 8 + +pattern VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY :: + VkPrimitiveTopology + +pattern VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY = + VkPrimitiveTopology 9 + +pattern VK_PRIMITIVE_TOPOLOGY_PATCH_LIST :: VkPrimitiveTopology + +pattern VK_PRIMITIVE_TOPOLOGY_PATCH_LIST = VkPrimitiveTopology 10 diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkQueryControlFlags.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkQueryControlFlags.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkQueryControlFlags.hs @@ -0,0 +1,83 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE KindSignatures #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE StandaloneDeriving #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeSynonymInstances #-} +module Graphics.Vulkan.Types.Enum.VkQueryControlFlags + (VkQueryControlBitmask(VkQueryControlBitmask, VkQueryControlFlags, + VkQueryControlFlagBits, VK_QUERY_CONTROL_PRECISE_BIT), + VkQueryControlFlags, VkQueryControlFlagBits) + where +import Data.Bits (Bits, FiniteBits) +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (FlagBit, FlagMask, FlagType) +import Graphics.Vulkan.Types.BaseTypes (VkFlags (..)) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +newtype VkQueryControlBitmask (a :: + FlagType) = VkQueryControlBitmask VkFlags + deriving (Eq, Ord, Storable, Data, Generic) + +type VkQueryControlFlags = VkQueryControlBitmask FlagMask + +type VkQueryControlFlagBits = VkQueryControlBitmask FlagBit + +pattern VkQueryControlFlagBits :: + VkFlags -> VkQueryControlBitmask FlagBit + +pattern VkQueryControlFlagBits n = VkQueryControlBitmask n + +pattern VkQueryControlFlags :: + VkFlags -> VkQueryControlBitmask FlagMask + +pattern VkQueryControlFlags n = VkQueryControlBitmask n + +deriving instance Bits (VkQueryControlBitmask FlagMask) + +deriving instance FiniteBits (VkQueryControlBitmask FlagMask) + +deriving instance Integral (VkQueryControlBitmask FlagMask) + +deriving instance Num (VkQueryControlBitmask FlagMask) + +deriving instance Bounded (VkQueryControlBitmask FlagMask) + +deriving instance Enum (VkQueryControlBitmask FlagMask) + +deriving instance Real (VkQueryControlBitmask FlagMask) + +instance Show (VkQueryControlBitmask a) where + showsPrec _ VK_QUERY_CONTROL_PRECISE_BIT + = showString "VK_QUERY_CONTROL_PRECISE_BIT" + showsPrec p (VkQueryControlBitmask x) + = showParen (p >= 11) + (showString "VkQueryControlBitmask " . showsPrec 11 x) + +instance Read (VkQueryControlBitmask a) where + readPrec + = parens + (choose + [("VK_QUERY_CONTROL_PRECISE_BIT", + pure VK_QUERY_CONTROL_PRECISE_BIT)] + +++ + prec 10 + (expectP (Ident "VkQueryControlBitmask") >> + (VkQueryControlBitmask <$> step readPrec))) + +-- | Require precise results to be collected by the query +-- +-- bitpos = @0@ +pattern VK_QUERY_CONTROL_PRECISE_BIT :: VkQueryControlBitmask a + +pattern VK_QUERY_CONTROL_PRECISE_BIT = VkQueryControlBitmask 1 diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkQueryPipelineStatisticFlags.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkQueryPipelineStatisticFlags.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkQueryPipelineStatisticFlags.hs @@ -0,0 +1,253 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE KindSignatures #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE StandaloneDeriving #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeSynonymInstances #-} +module Graphics.Vulkan.Types.Enum.VkQueryPipelineStatisticFlags + (VkQueryPipelineStatisticBitmask(VkQueryPipelineStatisticBitmask, + VkQueryPipelineStatisticFlags, + VkQueryPipelineStatisticFlagBits, + VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT, + VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT, + VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT, + VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT, + VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT, + VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT, + VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT, + VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT, + VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT, + VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT, + VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT), + VkQueryPipelineStatisticFlags, VkQueryPipelineStatisticFlagBits) + where +import Data.Bits (Bits, FiniteBits) +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (FlagBit, FlagMask, FlagType) +import Graphics.Vulkan.Types.BaseTypes (VkFlags (..)) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +newtype VkQueryPipelineStatisticBitmask (a :: + FlagType) = VkQueryPipelineStatisticBitmask VkFlags + deriving (Eq, Ord, Storable, Data, Generic) + +type VkQueryPipelineStatisticFlags = + VkQueryPipelineStatisticBitmask FlagMask + +type VkQueryPipelineStatisticFlagBits = + VkQueryPipelineStatisticBitmask FlagBit + +pattern VkQueryPipelineStatisticFlagBits :: + VkFlags -> VkQueryPipelineStatisticBitmask FlagBit + +pattern VkQueryPipelineStatisticFlagBits n = + VkQueryPipelineStatisticBitmask n + +pattern VkQueryPipelineStatisticFlags :: + VkFlags -> VkQueryPipelineStatisticBitmask FlagMask + +pattern VkQueryPipelineStatisticFlags n = + VkQueryPipelineStatisticBitmask n + +deriving instance Bits (VkQueryPipelineStatisticBitmask FlagMask) + +deriving instance + FiniteBits (VkQueryPipelineStatisticBitmask FlagMask) + +deriving instance + Integral (VkQueryPipelineStatisticBitmask FlagMask) + +deriving instance Num (VkQueryPipelineStatisticBitmask FlagMask) + +deriving instance + Bounded (VkQueryPipelineStatisticBitmask FlagMask) + +deriving instance Enum (VkQueryPipelineStatisticBitmask FlagMask) + +deriving instance Real (VkQueryPipelineStatisticBitmask FlagMask) + +instance Show (VkQueryPipelineStatisticBitmask a) where + showsPrec _ VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT + = showString + "VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT" + showsPrec _ + VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT + = showString + "VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT" + showsPrec _ + VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT + = showString + "VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT" + showsPrec _ + VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT + = showString + "VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT" + showsPrec _ + VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT + = showString + "VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT" + showsPrec _ VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT + = showString "VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT" + showsPrec _ VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT + = showString "VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT" + showsPrec _ + VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT + = showString + "VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT" + showsPrec _ + VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT + = showString + "VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT" + showsPrec _ + VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT + = showString + "VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT" + showsPrec _ + VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT + = showString + "VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT" + showsPrec p (VkQueryPipelineStatisticBitmask x) + = showParen (p >= 11) + (showString "VkQueryPipelineStatisticBitmask " . showsPrec 11 x) + +instance Read (VkQueryPipelineStatisticBitmask a) where + readPrec + = parens + (choose + [("VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT", + pure VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT), + ("VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT", + pure VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT), + ("VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT", + pure VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT), + ("VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT", + pure VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT), + ("VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT", + pure VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT), + ("VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT", + pure VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT), + ("VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT", + pure VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT), + ("VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT", + pure VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT), + ("VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT", + pure + VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT), + ("VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT", + pure + VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT), + ("VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT", + pure VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT)] + +++ + prec 10 + (expectP (Ident "VkQueryPipelineStatisticBitmask") >> + (VkQueryPipelineStatisticBitmask <$> step readPrec))) + +-- | Optional +-- +-- bitpos = @0@ +pattern VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT :: + VkQueryPipelineStatisticBitmask a + +pattern VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT = + VkQueryPipelineStatisticBitmask 1 + +-- | Optional +-- +-- bitpos = @1@ +pattern VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT + :: VkQueryPipelineStatisticBitmask a + +pattern VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT = + VkQueryPipelineStatisticBitmask 2 + +-- | Optional +-- +-- bitpos = @2@ +pattern VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT + :: VkQueryPipelineStatisticBitmask a + +pattern VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT = + VkQueryPipelineStatisticBitmask 4 + +-- | Optional +-- +-- bitpos = @3@ +pattern VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT + :: VkQueryPipelineStatisticBitmask a + +pattern VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT + = VkQueryPipelineStatisticBitmask 8 + +-- | Optional +-- +-- bitpos = @4@ +pattern VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT + :: VkQueryPipelineStatisticBitmask a + +pattern VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT + = VkQueryPipelineStatisticBitmask 16 + +-- | Optional +-- +-- bitpos = @5@ +pattern VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT :: + VkQueryPipelineStatisticBitmask a + +pattern VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT = + VkQueryPipelineStatisticBitmask 32 + +-- | Optional +-- +-- bitpos = @6@ +pattern VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT :: + VkQueryPipelineStatisticBitmask a + +pattern VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT = + VkQueryPipelineStatisticBitmask 64 + +-- | Optional +-- +-- bitpos = @7@ +pattern VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT + :: VkQueryPipelineStatisticBitmask a + +pattern VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT + = VkQueryPipelineStatisticBitmask 128 + +-- | Optional +-- +-- bitpos = @8@ +pattern VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT + :: VkQueryPipelineStatisticBitmask a + +pattern VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT + = VkQueryPipelineStatisticBitmask 256 + +-- | Optional +-- +-- bitpos = @9@ +pattern VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT + :: VkQueryPipelineStatisticBitmask a + +pattern VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT + = VkQueryPipelineStatisticBitmask 512 + +-- | Optional +-- +-- bitpos = @10@ +pattern VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT + :: VkQueryPipelineStatisticBitmask a + +pattern VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT + = VkQueryPipelineStatisticBitmask 1024 diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkQueryPoolCreateFlagBits.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkQueryPoolCreateFlagBits.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkQueryPoolCreateFlagBits.hs @@ -0,0 +1,25 @@ +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE Strict #-} +module Graphics.Vulkan.Types.Enum.VkQueryPoolCreateFlagBits + (VkQueryPoolCreateFlagBits(..)) where +import Data.Bits (Bits, FiniteBits) +import Data.Coerce (coerce) +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import Graphics.Vulkan.Types.BaseTypes (VkFlags) + +newtype VkQueryPoolCreateFlagBits = VkQueryPoolCreateFlagBits VkFlags + deriving (Eq, Ord, Num, Bounded, Enum, Integral, Bits, + FiniteBits, Storable, Real, Data, Generic) + +instance Show VkQueryPoolCreateFlagBits where + {-# INLINE show #-} + show (VkQueryPoolCreateFlagBits x) = show x + +instance Read VkQueryPoolCreateFlagBits where + {-# INLINE readsPrec #-} + readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags) diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkQueryResultFlags.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkQueryResultFlags.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkQueryResultFlags.hs @@ -0,0 +1,117 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE KindSignatures #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE StandaloneDeriving #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeSynonymInstances #-} +module Graphics.Vulkan.Types.Enum.VkQueryResultFlags + (VkQueryResultBitmask(VkQueryResultBitmask, VkQueryResultFlags, + VkQueryResultFlagBits, VK_QUERY_RESULT_64_BIT, + VK_QUERY_RESULT_WAIT_BIT, VK_QUERY_RESULT_WITH_AVAILABILITY_BIT, + VK_QUERY_RESULT_PARTIAL_BIT), + VkQueryResultFlags, VkQueryResultFlagBits) + where +import Data.Bits (Bits, FiniteBits) +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (FlagBit, FlagMask, FlagType) +import Graphics.Vulkan.Types.BaseTypes (VkFlags (..)) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +newtype VkQueryResultBitmask (a :: + FlagType) = VkQueryResultBitmask VkFlags + deriving (Eq, Ord, Storable, Data, Generic) + +type VkQueryResultFlags = VkQueryResultBitmask FlagMask + +type VkQueryResultFlagBits = VkQueryResultBitmask FlagBit + +pattern VkQueryResultFlagBits :: + VkFlags -> VkQueryResultBitmask FlagBit + +pattern VkQueryResultFlagBits n = VkQueryResultBitmask n + +pattern VkQueryResultFlags :: + VkFlags -> VkQueryResultBitmask FlagMask + +pattern VkQueryResultFlags n = VkQueryResultBitmask n + +deriving instance Bits (VkQueryResultBitmask FlagMask) + +deriving instance FiniteBits (VkQueryResultBitmask FlagMask) + +deriving instance Integral (VkQueryResultBitmask FlagMask) + +deriving instance Num (VkQueryResultBitmask FlagMask) + +deriving instance Bounded (VkQueryResultBitmask FlagMask) + +deriving instance Enum (VkQueryResultBitmask FlagMask) + +deriving instance Real (VkQueryResultBitmask FlagMask) + +instance Show (VkQueryResultBitmask a) where + showsPrec _ VK_QUERY_RESULT_64_BIT + = showString "VK_QUERY_RESULT_64_BIT" + showsPrec _ VK_QUERY_RESULT_WAIT_BIT + = showString "VK_QUERY_RESULT_WAIT_BIT" + showsPrec _ VK_QUERY_RESULT_WITH_AVAILABILITY_BIT + = showString "VK_QUERY_RESULT_WITH_AVAILABILITY_BIT" + showsPrec _ VK_QUERY_RESULT_PARTIAL_BIT + = showString "VK_QUERY_RESULT_PARTIAL_BIT" + showsPrec p (VkQueryResultBitmask x) + = showParen (p >= 11) + (showString "VkQueryResultBitmask " . showsPrec 11 x) + +instance Read (VkQueryResultBitmask a) where + readPrec + = parens + (choose + [("VK_QUERY_RESULT_64_BIT", pure VK_QUERY_RESULT_64_BIT), + ("VK_QUERY_RESULT_WAIT_BIT", pure VK_QUERY_RESULT_WAIT_BIT), + ("VK_QUERY_RESULT_WITH_AVAILABILITY_BIT", + pure VK_QUERY_RESULT_WITH_AVAILABILITY_BIT), + ("VK_QUERY_RESULT_PARTIAL_BIT", pure VK_QUERY_RESULT_PARTIAL_BIT)] + +++ + prec 10 + (expectP (Ident "VkQueryResultBitmask") >> + (VkQueryResultBitmask <$> step readPrec))) + +-- | Results of the queries are written to the destination buffer as 64-bit values +-- +-- bitpos = @0@ +pattern VK_QUERY_RESULT_64_BIT :: VkQueryResultBitmask a + +pattern VK_QUERY_RESULT_64_BIT = VkQueryResultBitmask 1 + +-- | Results of the queries are waited on before proceeding with the result copy +-- +-- bitpos = @1@ +pattern VK_QUERY_RESULT_WAIT_BIT :: VkQueryResultBitmask a + +pattern VK_QUERY_RESULT_WAIT_BIT = VkQueryResultBitmask 2 + +-- | Besides the results of the query, the availability of the results is also written +-- +-- bitpos = @2@ +pattern VK_QUERY_RESULT_WITH_AVAILABILITY_BIT :: + VkQueryResultBitmask a + +pattern VK_QUERY_RESULT_WITH_AVAILABILITY_BIT = + VkQueryResultBitmask 4 + +-- | Copy the partial results of the query even if the final results are not available +-- +-- bitpos = @3@ +pattern VK_QUERY_RESULT_PARTIAL_BIT :: VkQueryResultBitmask a + +pattern VK_QUERY_RESULT_PARTIAL_BIT = VkQueryResultBitmask 8 diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkQueryType.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkQueryType.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkQueryType.hs @@ -0,0 +1,60 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +module Graphics.Vulkan.Types.Enum.VkQueryType + (VkQueryType(VkQueryType, VK_QUERY_TYPE_OCCLUSION, + VK_QUERY_TYPE_PIPELINE_STATISTICS, VK_QUERY_TYPE_TIMESTAMP)) + where +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (Int32) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +-- | type = @enum@ +-- +-- +newtype VkQueryType = VkQueryType Int32 + deriving (Eq, Ord, Num, Bounded, Storable, Enum, Data, Generic) + +instance Show VkQueryType where + showsPrec _ VK_QUERY_TYPE_OCCLUSION + = showString "VK_QUERY_TYPE_OCCLUSION" + showsPrec _ VK_QUERY_TYPE_PIPELINE_STATISTICS + = showString "VK_QUERY_TYPE_PIPELINE_STATISTICS" + showsPrec _ VK_QUERY_TYPE_TIMESTAMP + = showString "VK_QUERY_TYPE_TIMESTAMP" + showsPrec p (VkQueryType x) + = showParen (p >= 11) (showString "VkQueryType " . showsPrec 11 x) + +instance Read VkQueryType where + readPrec + = parens + (choose + [("VK_QUERY_TYPE_OCCLUSION", pure VK_QUERY_TYPE_OCCLUSION), + ("VK_QUERY_TYPE_PIPELINE_STATISTICS", + pure VK_QUERY_TYPE_PIPELINE_STATISTICS), + ("VK_QUERY_TYPE_TIMESTAMP", pure VK_QUERY_TYPE_TIMESTAMP)] + +++ + prec 10 + (expectP (Ident "VkQueryType") >> (VkQueryType <$> step readPrec))) + +pattern VK_QUERY_TYPE_OCCLUSION :: VkQueryType + +pattern VK_QUERY_TYPE_OCCLUSION = VkQueryType 0 + +-- | Optional +pattern VK_QUERY_TYPE_PIPELINE_STATISTICS :: VkQueryType + +pattern VK_QUERY_TYPE_PIPELINE_STATISTICS = VkQueryType 1 + +pattern VK_QUERY_TYPE_TIMESTAMP :: VkQueryType + +pattern VK_QUERY_TYPE_TIMESTAMP = VkQueryType 2 diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkQueueFlags.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkQueueFlags.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkQueueFlags.hs @@ -0,0 +1,110 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE KindSignatures #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE StandaloneDeriving #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeSynonymInstances #-} +module Graphics.Vulkan.Types.Enum.VkQueueFlags + (VkQueueBitmask(VkQueueBitmask, VkQueueFlags, VkQueueFlagBits, + VK_QUEUE_GRAPHICS_BIT, VK_QUEUE_COMPUTE_BIT, VK_QUEUE_TRANSFER_BIT, + VK_QUEUE_SPARSE_BINDING_BIT), + VkQueueFlags, VkQueueFlagBits) + where +import Data.Bits (Bits, FiniteBits) +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (FlagBit, FlagMask, FlagType) +import Graphics.Vulkan.Types.BaseTypes (VkFlags (..)) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +newtype VkQueueBitmask (a :: FlagType) = VkQueueBitmask VkFlags + deriving (Eq, Ord, Storable, Data, Generic) + +type VkQueueFlags = VkQueueBitmask FlagMask + +type VkQueueFlagBits = VkQueueBitmask FlagBit + +pattern VkQueueFlagBits :: VkFlags -> VkQueueBitmask FlagBit + +pattern VkQueueFlagBits n = VkQueueBitmask n + +pattern VkQueueFlags :: VkFlags -> VkQueueBitmask FlagMask + +pattern VkQueueFlags n = VkQueueBitmask n + +deriving instance Bits (VkQueueBitmask FlagMask) + +deriving instance FiniteBits (VkQueueBitmask FlagMask) + +deriving instance Integral (VkQueueBitmask FlagMask) + +deriving instance Num (VkQueueBitmask FlagMask) + +deriving instance Bounded (VkQueueBitmask FlagMask) + +deriving instance Enum (VkQueueBitmask FlagMask) + +deriving instance Real (VkQueueBitmask FlagMask) + +instance Show (VkQueueBitmask a) where + showsPrec _ VK_QUEUE_GRAPHICS_BIT + = showString "VK_QUEUE_GRAPHICS_BIT" + showsPrec _ VK_QUEUE_COMPUTE_BIT + = showString "VK_QUEUE_COMPUTE_BIT" + showsPrec _ VK_QUEUE_TRANSFER_BIT + = showString "VK_QUEUE_TRANSFER_BIT" + showsPrec _ VK_QUEUE_SPARSE_BINDING_BIT + = showString "VK_QUEUE_SPARSE_BINDING_BIT" + showsPrec p (VkQueueBitmask x) + = showParen (p >= 11) + (showString "VkQueueBitmask " . showsPrec 11 x) + +instance Read (VkQueueBitmask a) where + readPrec + = parens + (choose + [("VK_QUEUE_GRAPHICS_BIT", pure VK_QUEUE_GRAPHICS_BIT), + ("VK_QUEUE_COMPUTE_BIT", pure VK_QUEUE_COMPUTE_BIT), + ("VK_QUEUE_TRANSFER_BIT", pure VK_QUEUE_TRANSFER_BIT), + ("VK_QUEUE_SPARSE_BINDING_BIT", pure VK_QUEUE_SPARSE_BINDING_BIT)] + +++ + prec 10 + (expectP (Ident "VkQueueBitmask") >> + (VkQueueBitmask <$> step readPrec))) + +-- | Queue supports graphics operations +-- +-- bitpos = @0@ +pattern VK_QUEUE_GRAPHICS_BIT :: VkQueueBitmask a + +pattern VK_QUEUE_GRAPHICS_BIT = VkQueueBitmask 1 + +-- | Queue supports compute operations +-- +-- bitpos = @1@ +pattern VK_QUEUE_COMPUTE_BIT :: VkQueueBitmask a + +pattern VK_QUEUE_COMPUTE_BIT = VkQueueBitmask 2 + +-- | Queue supports transfer operations +-- +-- bitpos = @2@ +pattern VK_QUEUE_TRANSFER_BIT :: VkQueueBitmask a + +pattern VK_QUEUE_TRANSFER_BIT = VkQueueBitmask 4 + +-- | Queue supports sparse resource memory management operations +-- +-- bitpos = @3@ +pattern VK_QUEUE_SPARSE_BINDING_BIT :: VkQueueBitmask a + +pattern VK_QUEUE_SPARSE_BINDING_BIT = VkQueueBitmask 8 diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkQueueGlobalPriorityEXT.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkQueueGlobalPriorityEXT.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkQueueGlobalPriorityEXT.hs @@ -0,0 +1,82 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +module Graphics.Vulkan.Types.Enum.VkQueueGlobalPriorityEXT + (VkQueueGlobalPriorityEXT(VkQueueGlobalPriorityEXT, + VK_QUEUE_GLOBAL_PRIORITY_LOW_EXT, + VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_EXT, + VK_QUEUE_GLOBAL_PRIORITY_HIGH_EXT, + VK_QUEUE_GLOBAL_PRIORITY_REALTIME_EXT)) + where +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (Int32) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +-- | type = @enum@ +-- +-- +newtype VkQueueGlobalPriorityEXT = VkQueueGlobalPriorityEXT Int32 + deriving (Eq, Ord, Num, Bounded, Storable, Enum, Data, Generic) + +instance Show VkQueueGlobalPriorityEXT where + showsPrec _ VK_QUEUE_GLOBAL_PRIORITY_LOW_EXT + = showString "VK_QUEUE_GLOBAL_PRIORITY_LOW_EXT" + showsPrec _ VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_EXT + = showString "VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_EXT" + showsPrec _ VK_QUEUE_GLOBAL_PRIORITY_HIGH_EXT + = showString "VK_QUEUE_GLOBAL_PRIORITY_HIGH_EXT" + showsPrec _ VK_QUEUE_GLOBAL_PRIORITY_REALTIME_EXT + = showString "VK_QUEUE_GLOBAL_PRIORITY_REALTIME_EXT" + showsPrec p (VkQueueGlobalPriorityEXT x) + = showParen (p >= 11) + (showString "VkQueueGlobalPriorityEXT " . showsPrec 11 x) + +instance Read VkQueueGlobalPriorityEXT where + readPrec + = parens + (choose + [("VK_QUEUE_GLOBAL_PRIORITY_LOW_EXT", + pure VK_QUEUE_GLOBAL_PRIORITY_LOW_EXT), + ("VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_EXT", + pure VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_EXT), + ("VK_QUEUE_GLOBAL_PRIORITY_HIGH_EXT", + pure VK_QUEUE_GLOBAL_PRIORITY_HIGH_EXT), + ("VK_QUEUE_GLOBAL_PRIORITY_REALTIME_EXT", + pure VK_QUEUE_GLOBAL_PRIORITY_REALTIME_EXT)] + +++ + prec 10 + (expectP (Ident "VkQueueGlobalPriorityEXT") >> + (VkQueueGlobalPriorityEXT <$> step readPrec))) + +pattern VK_QUEUE_GLOBAL_PRIORITY_LOW_EXT :: + VkQueueGlobalPriorityEXT + +pattern VK_QUEUE_GLOBAL_PRIORITY_LOW_EXT = + VkQueueGlobalPriorityEXT 128 + +pattern VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_EXT :: + VkQueueGlobalPriorityEXT + +pattern VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_EXT = + VkQueueGlobalPriorityEXT 256 + +pattern VK_QUEUE_GLOBAL_PRIORITY_HIGH_EXT :: + VkQueueGlobalPriorityEXT + +pattern VK_QUEUE_GLOBAL_PRIORITY_HIGH_EXT = + VkQueueGlobalPriorityEXT 512 + +pattern VK_QUEUE_GLOBAL_PRIORITY_REALTIME_EXT :: + VkQueueGlobalPriorityEXT + +pattern VK_QUEUE_GLOBAL_PRIORITY_REALTIME_EXT = + VkQueueGlobalPriorityEXT 1024 diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkRasterizationOrderAMD.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkRasterizationOrderAMD.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkRasterizationOrderAMD.hs @@ -0,0 +1,60 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +module Graphics.Vulkan.Types.Enum.VkRasterizationOrderAMD + (VkRasterizationOrderAMD(VkRasterizationOrderAMD, + VK_RASTERIZATION_ORDER_STRICT_AMD, + VK_RASTERIZATION_ORDER_RELAXED_AMD)) + where +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (Int32) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +-- | type = @enum@ +-- +-- +newtype VkRasterizationOrderAMD = VkRasterizationOrderAMD Int32 + deriving (Eq, Ord, Num, Bounded, Storable, Enum, Data, Generic) + +instance Show VkRasterizationOrderAMD where + showsPrec _ VK_RASTERIZATION_ORDER_STRICT_AMD + = showString "VK_RASTERIZATION_ORDER_STRICT_AMD" + showsPrec _ VK_RASTERIZATION_ORDER_RELAXED_AMD + = showString "VK_RASTERIZATION_ORDER_RELAXED_AMD" + showsPrec p (VkRasterizationOrderAMD x) + = showParen (p >= 11) + (showString "VkRasterizationOrderAMD " . showsPrec 11 x) + +instance Read VkRasterizationOrderAMD where + readPrec + = parens + (choose + [("VK_RASTERIZATION_ORDER_STRICT_AMD", + pure VK_RASTERIZATION_ORDER_STRICT_AMD), + ("VK_RASTERIZATION_ORDER_RELAXED_AMD", + pure VK_RASTERIZATION_ORDER_RELAXED_AMD)] + +++ + prec 10 + (expectP (Ident "VkRasterizationOrderAMD") >> + (VkRasterizationOrderAMD <$> step readPrec))) + +pattern VK_RASTERIZATION_ORDER_STRICT_AMD :: + VkRasterizationOrderAMD + +pattern VK_RASTERIZATION_ORDER_STRICT_AMD = + VkRasterizationOrderAMD 0 + +pattern VK_RASTERIZATION_ORDER_RELAXED_AMD :: + VkRasterizationOrderAMD + +pattern VK_RASTERIZATION_ORDER_RELAXED_AMD = + VkRasterizationOrderAMD 1 diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkRenderPassCreateFlagBits.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkRenderPassCreateFlagBits.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkRenderPassCreateFlagBits.hs @@ -0,0 +1,25 @@ +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE Strict #-} +module Graphics.Vulkan.Types.Enum.VkRenderPassCreateFlagBits + (VkRenderPassCreateFlagBits(..)) where +import Data.Bits (Bits, FiniteBits) +import Data.Coerce (coerce) +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import Graphics.Vulkan.Types.BaseTypes (VkFlags) + +newtype VkRenderPassCreateFlagBits = VkRenderPassCreateFlagBits VkFlags + deriving (Eq, Ord, Num, Bounded, Enum, Integral, Bits, + FiniteBits, Storable, Real, Data, Generic) + +instance Show VkRenderPassCreateFlagBits where + {-# INLINE show #-} + show (VkRenderPassCreateFlagBits x) = show x + +instance Read VkRenderPassCreateFlagBits where + {-# INLINE readsPrec #-} + readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags) diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkResult.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkResult.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkResult.hs @@ -0,0 +1,190 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +module Graphics.Vulkan.Types.Enum.VkResult + (VkResult(VkResult, VK_SUCCESS, VK_NOT_READY, VK_TIMEOUT, + VK_EVENT_SET, VK_EVENT_RESET, VK_INCOMPLETE, + VK_ERROR_OUT_OF_HOST_MEMORY, VK_ERROR_OUT_OF_DEVICE_MEMORY, + VK_ERROR_INITIALIZATION_FAILED, VK_ERROR_DEVICE_LOST, + VK_ERROR_MEMORY_MAP_FAILED, VK_ERROR_LAYER_NOT_PRESENT, + VK_ERROR_EXTENSION_NOT_PRESENT, VK_ERROR_FEATURE_NOT_PRESENT, + VK_ERROR_INCOMPATIBLE_DRIVER, VK_ERROR_TOO_MANY_OBJECTS, + VK_ERROR_FORMAT_NOT_SUPPORTED, VK_ERROR_FRAGMENTED_POOL)) + where +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (Int32) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +-- | API result codes +-- +-- type = @enum@ +-- +-- +-- +newtype VkResult = VkResult Int32 + deriving (Eq, Ord, Num, Bounded, Storable, Enum, Data, Generic) + +instance Show VkResult where + showsPrec _ VK_SUCCESS = showString "VK_SUCCESS" + showsPrec _ VK_NOT_READY = showString "VK_NOT_READY" + showsPrec _ VK_TIMEOUT = showString "VK_TIMEOUT" + showsPrec _ VK_EVENT_SET = showString "VK_EVENT_SET" + showsPrec _ VK_EVENT_RESET = showString "VK_EVENT_RESET" + showsPrec _ VK_INCOMPLETE = showString "VK_INCOMPLETE" + showsPrec _ VK_ERROR_OUT_OF_HOST_MEMORY + = showString "VK_ERROR_OUT_OF_HOST_MEMORY" + showsPrec _ VK_ERROR_OUT_OF_DEVICE_MEMORY + = showString "VK_ERROR_OUT_OF_DEVICE_MEMORY" + showsPrec _ VK_ERROR_INITIALIZATION_FAILED + = showString "VK_ERROR_INITIALIZATION_FAILED" + showsPrec _ VK_ERROR_DEVICE_LOST + = showString "VK_ERROR_DEVICE_LOST" + showsPrec _ VK_ERROR_MEMORY_MAP_FAILED + = showString "VK_ERROR_MEMORY_MAP_FAILED" + showsPrec _ VK_ERROR_LAYER_NOT_PRESENT + = showString "VK_ERROR_LAYER_NOT_PRESENT" + showsPrec _ VK_ERROR_EXTENSION_NOT_PRESENT + = showString "VK_ERROR_EXTENSION_NOT_PRESENT" + showsPrec _ VK_ERROR_FEATURE_NOT_PRESENT + = showString "VK_ERROR_FEATURE_NOT_PRESENT" + showsPrec _ VK_ERROR_INCOMPATIBLE_DRIVER + = showString "VK_ERROR_INCOMPATIBLE_DRIVER" + showsPrec _ VK_ERROR_TOO_MANY_OBJECTS + = showString "VK_ERROR_TOO_MANY_OBJECTS" + showsPrec _ VK_ERROR_FORMAT_NOT_SUPPORTED + = showString "VK_ERROR_FORMAT_NOT_SUPPORTED" + showsPrec _ VK_ERROR_FRAGMENTED_POOL + = showString "VK_ERROR_FRAGMENTED_POOL" + showsPrec p (VkResult x) + = showParen (p >= 11) (showString "VkResult " . showsPrec 11 x) + +instance Read VkResult where + readPrec + = parens + (choose + [("VK_SUCCESS", pure VK_SUCCESS), + ("VK_NOT_READY", pure VK_NOT_READY), + ("VK_TIMEOUT", pure VK_TIMEOUT), + ("VK_EVENT_SET", pure VK_EVENT_SET), + ("VK_EVENT_RESET", pure VK_EVENT_RESET), + ("VK_INCOMPLETE", pure VK_INCOMPLETE), + ("VK_ERROR_OUT_OF_HOST_MEMORY", pure VK_ERROR_OUT_OF_HOST_MEMORY), + ("VK_ERROR_OUT_OF_DEVICE_MEMORY", + pure VK_ERROR_OUT_OF_DEVICE_MEMORY), + ("VK_ERROR_INITIALIZATION_FAILED", + pure VK_ERROR_INITIALIZATION_FAILED), + ("VK_ERROR_DEVICE_LOST", pure VK_ERROR_DEVICE_LOST), + ("VK_ERROR_MEMORY_MAP_FAILED", pure VK_ERROR_MEMORY_MAP_FAILED), + ("VK_ERROR_LAYER_NOT_PRESENT", pure VK_ERROR_LAYER_NOT_PRESENT), + ("VK_ERROR_EXTENSION_NOT_PRESENT", + pure VK_ERROR_EXTENSION_NOT_PRESENT), + ("VK_ERROR_FEATURE_NOT_PRESENT", + pure VK_ERROR_FEATURE_NOT_PRESENT), + ("VK_ERROR_INCOMPATIBLE_DRIVER", + pure VK_ERROR_INCOMPATIBLE_DRIVER), + ("VK_ERROR_TOO_MANY_OBJECTS", pure VK_ERROR_TOO_MANY_OBJECTS), + ("VK_ERROR_FORMAT_NOT_SUPPORTED", + pure VK_ERROR_FORMAT_NOT_SUPPORTED), + ("VK_ERROR_FRAGMENTED_POOL", pure VK_ERROR_FRAGMENTED_POOL)] + +++ + prec 10 + (expectP (Ident "VkResult") >> (VkResult <$> step readPrec))) + +-- | Command completed successfully +pattern VK_SUCCESS :: VkResult + +pattern VK_SUCCESS = VkResult 0 + +-- | A fence or query has not yet completed +pattern VK_NOT_READY :: VkResult + +pattern VK_NOT_READY = VkResult 1 + +-- | A wait operation has not completed in the specified time +pattern VK_TIMEOUT :: VkResult + +pattern VK_TIMEOUT = VkResult 2 + +-- | An event is signaled +pattern VK_EVENT_SET :: VkResult + +pattern VK_EVENT_SET = VkResult 3 + +-- | An event is unsignaled +pattern VK_EVENT_RESET :: VkResult + +pattern VK_EVENT_RESET = VkResult 4 + +-- | A return array was too small for the result +pattern VK_INCOMPLETE :: VkResult + +pattern VK_INCOMPLETE = VkResult 5 + +-- | A host memory allocation has failed +pattern VK_ERROR_OUT_OF_HOST_MEMORY :: VkResult + +pattern VK_ERROR_OUT_OF_HOST_MEMORY = VkResult (-1) + +-- | A device memory allocation has failed +pattern VK_ERROR_OUT_OF_DEVICE_MEMORY :: VkResult + +pattern VK_ERROR_OUT_OF_DEVICE_MEMORY = VkResult (-2) + +-- | Initialization of a object has failed +pattern VK_ERROR_INITIALIZATION_FAILED :: VkResult + +pattern VK_ERROR_INITIALIZATION_FAILED = VkResult (-3) + +-- | The logical device has been lost. See <> +pattern VK_ERROR_DEVICE_LOST :: VkResult + +pattern VK_ERROR_DEVICE_LOST = VkResult (-4) + +-- | Mapping of a memory object has failed +pattern VK_ERROR_MEMORY_MAP_FAILED :: VkResult + +pattern VK_ERROR_MEMORY_MAP_FAILED = VkResult (-5) + +-- | Layer specified does not exist +pattern VK_ERROR_LAYER_NOT_PRESENT :: VkResult + +pattern VK_ERROR_LAYER_NOT_PRESENT = VkResult (-6) + +-- | Extension specified does not exist +pattern VK_ERROR_EXTENSION_NOT_PRESENT :: VkResult + +pattern VK_ERROR_EXTENSION_NOT_PRESENT = VkResult (-7) + +-- | Requested feature is not available on this device +pattern VK_ERROR_FEATURE_NOT_PRESENT :: VkResult + +pattern VK_ERROR_FEATURE_NOT_PRESENT = VkResult (-8) + +-- | Unable to find a Vulkan driver +pattern VK_ERROR_INCOMPATIBLE_DRIVER :: VkResult + +pattern VK_ERROR_INCOMPATIBLE_DRIVER = VkResult (-9) + +-- | Too many objects of the type have already been created +pattern VK_ERROR_TOO_MANY_OBJECTS :: VkResult + +pattern VK_ERROR_TOO_MANY_OBJECTS = VkResult (-10) + +-- | Requested format is not supported on this device +pattern VK_ERROR_FORMAT_NOT_SUPPORTED :: VkResult + +pattern VK_ERROR_FORMAT_NOT_SUPPORTED = VkResult (-11) + +-- | A requested pool allocation has failed due to fragmentation of the pool's memory +pattern VK_ERROR_FRAGMENTED_POOL :: VkResult + +pattern VK_ERROR_FRAGMENTED_POOL = VkResult (-12) diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkSampleCountFlags.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkSampleCountFlags.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkSampleCountFlags.hs @@ -0,0 +1,145 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE KindSignatures #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE StandaloneDeriving #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeSynonymInstances #-} +module Graphics.Vulkan.Types.Enum.VkSampleCountFlags + (VkSampleCountBitmask(VkSampleCountBitmask, VkSampleCountFlags, + VkSampleCountFlagBits, VK_SAMPLE_COUNT_1_BIT, + VK_SAMPLE_COUNT_2_BIT, VK_SAMPLE_COUNT_4_BIT, + VK_SAMPLE_COUNT_8_BIT, VK_SAMPLE_COUNT_16_BIT, + VK_SAMPLE_COUNT_32_BIT, VK_SAMPLE_COUNT_64_BIT), + VkSampleCountFlags, VkSampleCountFlagBits) + where +import Data.Bits (Bits, FiniteBits) +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (FlagBit, FlagMask, FlagType) +import Graphics.Vulkan.Types.BaseTypes (VkFlags (..)) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +newtype VkSampleCountBitmask (a :: + FlagType) = VkSampleCountBitmask VkFlags + deriving (Eq, Ord, Storable, Data, Generic) + +type VkSampleCountFlags = VkSampleCountBitmask FlagMask + +type VkSampleCountFlagBits = VkSampleCountBitmask FlagBit + +pattern VkSampleCountFlagBits :: + VkFlags -> VkSampleCountBitmask FlagBit + +pattern VkSampleCountFlagBits n = VkSampleCountBitmask n + +pattern VkSampleCountFlags :: + VkFlags -> VkSampleCountBitmask FlagMask + +pattern VkSampleCountFlags n = VkSampleCountBitmask n + +deriving instance Bits (VkSampleCountBitmask FlagMask) + +deriving instance FiniteBits (VkSampleCountBitmask FlagMask) + +deriving instance Integral (VkSampleCountBitmask FlagMask) + +deriving instance Num (VkSampleCountBitmask FlagMask) + +deriving instance Bounded (VkSampleCountBitmask FlagMask) + +deriving instance Enum (VkSampleCountBitmask FlagMask) + +deriving instance Real (VkSampleCountBitmask FlagMask) + +instance Show (VkSampleCountBitmask a) where + showsPrec _ VK_SAMPLE_COUNT_1_BIT + = showString "VK_SAMPLE_COUNT_1_BIT" + showsPrec _ VK_SAMPLE_COUNT_2_BIT + = showString "VK_SAMPLE_COUNT_2_BIT" + showsPrec _ VK_SAMPLE_COUNT_4_BIT + = showString "VK_SAMPLE_COUNT_4_BIT" + showsPrec _ VK_SAMPLE_COUNT_8_BIT + = showString "VK_SAMPLE_COUNT_8_BIT" + showsPrec _ VK_SAMPLE_COUNT_16_BIT + = showString "VK_SAMPLE_COUNT_16_BIT" + showsPrec _ VK_SAMPLE_COUNT_32_BIT + = showString "VK_SAMPLE_COUNT_32_BIT" + showsPrec _ VK_SAMPLE_COUNT_64_BIT + = showString "VK_SAMPLE_COUNT_64_BIT" + showsPrec p (VkSampleCountBitmask x) + = showParen (p >= 11) + (showString "VkSampleCountBitmask " . showsPrec 11 x) + +instance Read (VkSampleCountBitmask a) where + readPrec + = parens + (choose + [("VK_SAMPLE_COUNT_1_BIT", pure VK_SAMPLE_COUNT_1_BIT), + ("VK_SAMPLE_COUNT_2_BIT", pure VK_SAMPLE_COUNT_2_BIT), + ("VK_SAMPLE_COUNT_4_BIT", pure VK_SAMPLE_COUNT_4_BIT), + ("VK_SAMPLE_COUNT_8_BIT", pure VK_SAMPLE_COUNT_8_BIT), + ("VK_SAMPLE_COUNT_16_BIT", pure VK_SAMPLE_COUNT_16_BIT), + ("VK_SAMPLE_COUNT_32_BIT", pure VK_SAMPLE_COUNT_32_BIT), + ("VK_SAMPLE_COUNT_64_BIT", pure VK_SAMPLE_COUNT_64_BIT)] + +++ + prec 10 + (expectP (Ident "VkSampleCountBitmask") >> + (VkSampleCountBitmask <$> step readPrec))) + +-- | Sample count 1 supported +-- +-- bitpos = @0@ +pattern VK_SAMPLE_COUNT_1_BIT :: VkSampleCountBitmask a + +pattern VK_SAMPLE_COUNT_1_BIT = VkSampleCountBitmask 1 + +-- | Sample count 2 supported +-- +-- bitpos = @1@ +pattern VK_SAMPLE_COUNT_2_BIT :: VkSampleCountBitmask a + +pattern VK_SAMPLE_COUNT_2_BIT = VkSampleCountBitmask 2 + +-- | Sample count 4 supported +-- +-- bitpos = @2@ +pattern VK_SAMPLE_COUNT_4_BIT :: VkSampleCountBitmask a + +pattern VK_SAMPLE_COUNT_4_BIT = VkSampleCountBitmask 4 + +-- | Sample count 8 supported +-- +-- bitpos = @3@ +pattern VK_SAMPLE_COUNT_8_BIT :: VkSampleCountBitmask a + +pattern VK_SAMPLE_COUNT_8_BIT = VkSampleCountBitmask 8 + +-- | Sample count 16 supported +-- +-- bitpos = @4@ +pattern VK_SAMPLE_COUNT_16_BIT :: VkSampleCountBitmask a + +pattern VK_SAMPLE_COUNT_16_BIT = VkSampleCountBitmask 16 + +-- | Sample count 32 supported +-- +-- bitpos = @5@ +pattern VK_SAMPLE_COUNT_32_BIT :: VkSampleCountBitmask a + +pattern VK_SAMPLE_COUNT_32_BIT = VkSampleCountBitmask 32 + +-- | Sample count 64 supported +-- +-- bitpos = @6@ +pattern VK_SAMPLE_COUNT_64_BIT :: VkSampleCountBitmask a + +pattern VK_SAMPLE_COUNT_64_BIT = VkSampleCountBitmask 64 diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkSamplerAddressMode.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkSamplerAddressMode.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkSamplerAddressMode.hs @@ -0,0 +1,80 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +module Graphics.Vulkan.Types.Enum.VkSamplerAddressMode + (VkSamplerAddressMode(VkSamplerAddressMode, + VK_SAMPLER_ADDRESS_MODE_REPEAT, + VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT, + VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, + VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER)) + where +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (Int32) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +-- | type = @enum@ +-- +-- +newtype VkSamplerAddressMode = VkSamplerAddressMode Int32 + deriving (Eq, Ord, Num, Bounded, Storable, Enum, Data, Generic) + +instance Show VkSamplerAddressMode where + showsPrec _ VK_SAMPLER_ADDRESS_MODE_REPEAT + = showString "VK_SAMPLER_ADDRESS_MODE_REPEAT" + showsPrec _ VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT + = showString "VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT" + showsPrec _ VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE + = showString "VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE" + showsPrec _ VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER + = showString "VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER" + showsPrec p (VkSamplerAddressMode x) + = showParen (p >= 11) + (showString "VkSamplerAddressMode " . showsPrec 11 x) + +instance Read VkSamplerAddressMode where + readPrec + = parens + (choose + [("VK_SAMPLER_ADDRESS_MODE_REPEAT", + pure VK_SAMPLER_ADDRESS_MODE_REPEAT), + ("VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT", + pure VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT), + ("VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE", + pure VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE), + ("VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER", + pure VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER)] + +++ + prec 10 + (expectP (Ident "VkSamplerAddressMode") >> + (VkSamplerAddressMode <$> step readPrec))) + +pattern VK_SAMPLER_ADDRESS_MODE_REPEAT :: VkSamplerAddressMode + +pattern VK_SAMPLER_ADDRESS_MODE_REPEAT = VkSamplerAddressMode 0 + +pattern VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT :: + VkSamplerAddressMode + +pattern VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT = + VkSamplerAddressMode 1 + +pattern VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE :: + VkSamplerAddressMode + +pattern VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE = + VkSamplerAddressMode 2 + +pattern VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER :: + VkSamplerAddressMode + +pattern VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER = + VkSamplerAddressMode 3 diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkSamplerCreateFlagBits.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkSamplerCreateFlagBits.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkSamplerCreateFlagBits.hs @@ -0,0 +1,25 @@ +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE Strict #-} +module Graphics.Vulkan.Types.Enum.VkSamplerCreateFlagBits + (VkSamplerCreateFlagBits(..)) where +import Data.Bits (Bits, FiniteBits) +import Data.Coerce (coerce) +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import Graphics.Vulkan.Types.BaseTypes (VkFlags) + +newtype VkSamplerCreateFlagBits = VkSamplerCreateFlagBits VkFlags + deriving (Eq, Ord, Num, Bounded, Enum, Integral, Bits, + FiniteBits, Storable, Real, Data, Generic) + +instance Show VkSamplerCreateFlagBits where + {-# INLINE show #-} + show (VkSamplerCreateFlagBits x) = show x + +instance Read VkSamplerCreateFlagBits where + {-# INLINE readsPrec #-} + readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags) diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkSamplerMipmapMode.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkSamplerMipmapMode.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkSamplerMipmapMode.hs @@ -0,0 +1,57 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +module Graphics.Vulkan.Types.Enum.VkSamplerMipmapMode + (VkSamplerMipmapMode(VkSamplerMipmapMode, + VK_SAMPLER_MIPMAP_MODE_NEAREST, VK_SAMPLER_MIPMAP_MODE_LINEAR)) + where +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (Int32) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +-- | type = @enum@ +-- +-- +newtype VkSamplerMipmapMode = VkSamplerMipmapMode Int32 + deriving (Eq, Ord, Num, Bounded, Storable, Enum, Data, Generic) + +instance Show VkSamplerMipmapMode where + showsPrec _ VK_SAMPLER_MIPMAP_MODE_NEAREST + = showString "VK_SAMPLER_MIPMAP_MODE_NEAREST" + showsPrec _ VK_SAMPLER_MIPMAP_MODE_LINEAR + = showString "VK_SAMPLER_MIPMAP_MODE_LINEAR" + showsPrec p (VkSamplerMipmapMode x) + = showParen (p >= 11) + (showString "VkSamplerMipmapMode " . showsPrec 11 x) + +instance Read VkSamplerMipmapMode where + readPrec + = parens + (choose + [("VK_SAMPLER_MIPMAP_MODE_NEAREST", + pure VK_SAMPLER_MIPMAP_MODE_NEAREST), + ("VK_SAMPLER_MIPMAP_MODE_LINEAR", + pure VK_SAMPLER_MIPMAP_MODE_LINEAR)] + +++ + prec 10 + (expectP (Ident "VkSamplerMipmapMode") >> + (VkSamplerMipmapMode <$> step readPrec))) + +-- | Choose nearest mip level +pattern VK_SAMPLER_MIPMAP_MODE_NEAREST :: VkSamplerMipmapMode + +pattern VK_SAMPLER_MIPMAP_MODE_NEAREST = VkSamplerMipmapMode 0 + +-- | Linear filter between mip levels +pattern VK_SAMPLER_MIPMAP_MODE_LINEAR :: VkSamplerMipmapMode + +pattern VK_SAMPLER_MIPMAP_MODE_LINEAR = VkSamplerMipmapMode 1 diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkSamplerReductionModeEXT.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkSamplerReductionModeEXT.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkSamplerReductionModeEXT.hs @@ -0,0 +1,72 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +module Graphics.Vulkan.Types.Enum.VkSamplerReductionModeEXT + (VkSamplerReductionModeEXT(VkSamplerReductionModeEXT, + VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT, + VK_SAMPLER_REDUCTION_MODE_MIN_EXT, + VK_SAMPLER_REDUCTION_MODE_MAX_EXT)) + where +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (Int32) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +-- | type = @enum@ +-- +-- +newtype VkSamplerReductionModeEXT = VkSamplerReductionModeEXT Int32 + deriving (Eq, Ord, Num, Bounded, Storable, Enum, Data, + Generic) + +instance Show VkSamplerReductionModeEXT where + showsPrec _ VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT + = showString "VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT" + showsPrec _ VK_SAMPLER_REDUCTION_MODE_MIN_EXT + = showString "VK_SAMPLER_REDUCTION_MODE_MIN_EXT" + showsPrec _ VK_SAMPLER_REDUCTION_MODE_MAX_EXT + = showString "VK_SAMPLER_REDUCTION_MODE_MAX_EXT" + showsPrec p (VkSamplerReductionModeEXT x) + = showParen (p >= 11) + (showString "VkSamplerReductionModeEXT " . showsPrec 11 x) + +instance Read VkSamplerReductionModeEXT where + readPrec + = parens + (choose + [("VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT", + pure VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT), + ("VK_SAMPLER_REDUCTION_MODE_MIN_EXT", + pure VK_SAMPLER_REDUCTION_MODE_MIN_EXT), + ("VK_SAMPLER_REDUCTION_MODE_MAX_EXT", + pure VK_SAMPLER_REDUCTION_MODE_MAX_EXT)] + +++ + prec 10 + (expectP (Ident "VkSamplerReductionModeEXT") >> + (VkSamplerReductionModeEXT <$> step readPrec))) + +pattern VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT :: + VkSamplerReductionModeEXT + +pattern VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT = + VkSamplerReductionModeEXT 0 + +pattern VK_SAMPLER_REDUCTION_MODE_MIN_EXT :: + VkSamplerReductionModeEXT + +pattern VK_SAMPLER_REDUCTION_MODE_MIN_EXT = + VkSamplerReductionModeEXT 1 + +pattern VK_SAMPLER_REDUCTION_MODE_MAX_EXT :: + VkSamplerReductionModeEXT + +pattern VK_SAMPLER_REDUCTION_MODE_MAX_EXT = + VkSamplerReductionModeEXT 2 diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkSamplerYcbcrModelConversionKHR.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkSamplerYcbcrModelConversionKHR.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkSamplerYcbcrModelConversionKHR.hs @@ -0,0 +1,98 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +module Graphics.Vulkan.Types.Enum.VkSamplerYcbcrModelConversionKHR + (VkSamplerYcbcrModelConversionKHR(VkSamplerYcbcrModelConversionKHR, + VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY_KHR, + VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY_KHR, + VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709_KHR, + VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601_KHR, + VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020_KHR)) + where +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (Int32) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +-- | type = @enum@ +-- +-- +newtype VkSamplerYcbcrModelConversionKHR = VkSamplerYcbcrModelConversionKHR Int32 + deriving (Eq, Ord, Num, Bounded, Storable, Enum, Data, + Generic) + +instance Show VkSamplerYcbcrModelConversionKHR where + showsPrec _ VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY_KHR + = showString "VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY_KHR" + showsPrec _ VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY_KHR + = showString "VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY_KHR" + showsPrec _ VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709_KHR + = showString "VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709_KHR" + showsPrec _ VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601_KHR + = showString "VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601_KHR" + showsPrec _ VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020_KHR + = showString "VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020_KHR" + showsPrec p (VkSamplerYcbcrModelConversionKHR x) + = showParen (p >= 11) + (showString "VkSamplerYcbcrModelConversionKHR " . showsPrec 11 x) + +instance Read VkSamplerYcbcrModelConversionKHR where + readPrec + = parens + (choose + [("VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY_KHR", + pure VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY_KHR), + ("VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY_KHR", + pure VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY_KHR), + ("VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709_KHR", + pure VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709_KHR), + ("VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601_KHR", + pure VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601_KHR), + ("VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020_KHR", + pure VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020_KHR)] + +++ + prec 10 + (expectP (Ident "VkSamplerYcbcrModelConversionKHR") >> + (VkSamplerYcbcrModelConversionKHR <$> step readPrec))) + +pattern VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY_KHR :: + VkSamplerYcbcrModelConversionKHR + +pattern VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY_KHR = + VkSamplerYcbcrModelConversionKHR 0 + +-- | just range expansion +pattern VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY_KHR :: + VkSamplerYcbcrModelConversionKHR + +pattern VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY_KHR = + VkSamplerYcbcrModelConversionKHR 1 + +-- | aka HD YUV +pattern VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709_KHR :: + VkSamplerYcbcrModelConversionKHR + +pattern VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709_KHR = + VkSamplerYcbcrModelConversionKHR 2 + +-- | aka SD YUV +pattern VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601_KHR :: + VkSamplerYcbcrModelConversionKHR + +pattern VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601_KHR = + VkSamplerYcbcrModelConversionKHR 3 + +-- | aka UHD YUV +pattern VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020_KHR :: + VkSamplerYcbcrModelConversionKHR + +pattern VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020_KHR = + VkSamplerYcbcrModelConversionKHR 4 diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkSamplerYcbcrRangeKHR.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkSamplerYcbcrRangeKHR.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkSamplerYcbcrRangeKHR.hs @@ -0,0 +1,62 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +module Graphics.Vulkan.Types.Enum.VkSamplerYcbcrRangeKHR + (VkSamplerYcbcrRangeKHR(VkSamplerYcbcrRangeKHR, + VK_SAMPLER_YCBCR_RANGE_ITU_FULL_KHR, + VK_SAMPLER_YCBCR_RANGE_ITU_NARROW_KHR)) + where +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (Int32) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +-- | type = @enum@ +-- +-- +newtype VkSamplerYcbcrRangeKHR = VkSamplerYcbcrRangeKHR Int32 + deriving (Eq, Ord, Num, Bounded, Storable, Enum, Data, Generic) + +instance Show VkSamplerYcbcrRangeKHR where + showsPrec _ VK_SAMPLER_YCBCR_RANGE_ITU_FULL_KHR + = showString "VK_SAMPLER_YCBCR_RANGE_ITU_FULL_KHR" + showsPrec _ VK_SAMPLER_YCBCR_RANGE_ITU_NARROW_KHR + = showString "VK_SAMPLER_YCBCR_RANGE_ITU_NARROW_KHR" + showsPrec p (VkSamplerYcbcrRangeKHR x) + = showParen (p >= 11) + (showString "VkSamplerYcbcrRangeKHR " . showsPrec 11 x) + +instance Read VkSamplerYcbcrRangeKHR where + readPrec + = parens + (choose + [("VK_SAMPLER_YCBCR_RANGE_ITU_FULL_KHR", + pure VK_SAMPLER_YCBCR_RANGE_ITU_FULL_KHR), + ("VK_SAMPLER_YCBCR_RANGE_ITU_NARROW_KHR", + pure VK_SAMPLER_YCBCR_RANGE_ITU_NARROW_KHR)] + +++ + prec 10 + (expectP (Ident "VkSamplerYcbcrRangeKHR") >> + (VkSamplerYcbcrRangeKHR <$> step readPrec))) + +-- | Luma 0..1 maps to 0..255, chroma -0.5..0.5 to 1..255 (clamped) +pattern VK_SAMPLER_YCBCR_RANGE_ITU_FULL_KHR :: + VkSamplerYcbcrRangeKHR + +pattern VK_SAMPLER_YCBCR_RANGE_ITU_FULL_KHR = + VkSamplerYcbcrRangeKHR 0 + +-- | Luma 0..1 maps to 16..235, chroma -0.5..0.5 to 16..240 +pattern VK_SAMPLER_YCBCR_RANGE_ITU_NARROW_KHR :: + VkSamplerYcbcrRangeKHR + +pattern VK_SAMPLER_YCBCR_RANGE_ITU_NARROW_KHR = + VkSamplerYcbcrRangeKHR 1 diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkSemaphoreImportFlagsKHR.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkSemaphoreImportFlagsKHR.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkSemaphoreImportFlagsKHR.hs @@ -0,0 +1,87 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE KindSignatures #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE StandaloneDeriving #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeSynonymInstances #-} +module Graphics.Vulkan.Types.Enum.VkSemaphoreImportFlagsKHR + (VkSemaphoreImportBitmaskKHR(VkSemaphoreImportBitmaskKHR, + VkSemaphoreImportFlagsKHR, VkSemaphoreImportFlagBitsKHR, + VK_SEMAPHORE_IMPORT_TEMPORARY_BIT_KHR), + VkSemaphoreImportFlagsKHR, VkSemaphoreImportFlagBitsKHR) + where +import Data.Bits (Bits, FiniteBits) +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (FlagBit, FlagMask, FlagType) +import Graphics.Vulkan.Types.BaseTypes (VkFlags (..)) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +newtype VkSemaphoreImportBitmaskKHR (a :: + FlagType) = VkSemaphoreImportBitmaskKHR VkFlags + deriving (Eq, Ord, Storable, Data, Generic) + +type VkSemaphoreImportFlagsKHR = + VkSemaphoreImportBitmaskKHR FlagMask + +type VkSemaphoreImportFlagBitsKHR = + VkSemaphoreImportBitmaskKHR FlagBit + +pattern VkSemaphoreImportFlagBitsKHR :: + VkFlags -> VkSemaphoreImportBitmaskKHR FlagBit + +pattern VkSemaphoreImportFlagBitsKHR n = + VkSemaphoreImportBitmaskKHR n + +pattern VkSemaphoreImportFlagsKHR :: + VkFlags -> VkSemaphoreImportBitmaskKHR FlagMask + +pattern VkSemaphoreImportFlagsKHR n = VkSemaphoreImportBitmaskKHR n + +deriving instance Bits (VkSemaphoreImportBitmaskKHR FlagMask) + +deriving instance FiniteBits (VkSemaphoreImportBitmaskKHR FlagMask) + +deriving instance Integral (VkSemaphoreImportBitmaskKHR FlagMask) + +deriving instance Num (VkSemaphoreImportBitmaskKHR FlagMask) + +deriving instance Bounded (VkSemaphoreImportBitmaskKHR FlagMask) + +deriving instance Enum (VkSemaphoreImportBitmaskKHR FlagMask) + +deriving instance Real (VkSemaphoreImportBitmaskKHR FlagMask) + +instance Show (VkSemaphoreImportBitmaskKHR a) where + showsPrec _ VK_SEMAPHORE_IMPORT_TEMPORARY_BIT_KHR + = showString "VK_SEMAPHORE_IMPORT_TEMPORARY_BIT_KHR" + showsPrec p (VkSemaphoreImportBitmaskKHR x) + = showParen (p >= 11) + (showString "VkSemaphoreImportBitmaskKHR " . showsPrec 11 x) + +instance Read (VkSemaphoreImportBitmaskKHR a) where + readPrec + = parens + (choose + [("VK_SEMAPHORE_IMPORT_TEMPORARY_BIT_KHR", + pure VK_SEMAPHORE_IMPORT_TEMPORARY_BIT_KHR)] + +++ + prec 10 + (expectP (Ident "VkSemaphoreImportBitmaskKHR") >> + (VkSemaphoreImportBitmaskKHR <$> step readPrec))) + +-- | bitpos = @0@ +pattern VK_SEMAPHORE_IMPORT_TEMPORARY_BIT_KHR :: + VkSemaphoreImportBitmaskKHR a + +pattern VK_SEMAPHORE_IMPORT_TEMPORARY_BIT_KHR = + VkSemaphoreImportBitmaskKHR 1 diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkShaderInfoTypeAMD.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkShaderInfoTypeAMD.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkShaderInfoTypeAMD.hs @@ -0,0 +1,64 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +module Graphics.Vulkan.Types.Enum.VkShaderInfoTypeAMD + (VkShaderInfoTypeAMD(VkShaderInfoTypeAMD, + VK_SHADER_INFO_TYPE_STATISTICS_AMD, VK_SHADER_INFO_TYPE_BINARY_AMD, + VK_SHADER_INFO_TYPE_DISASSEMBLY_AMD)) + where +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (Int32) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +-- | type = @enum@ +-- +-- +newtype VkShaderInfoTypeAMD = VkShaderInfoTypeAMD Int32 + deriving (Eq, Ord, Num, Bounded, Storable, Enum, Data, Generic) + +instance Show VkShaderInfoTypeAMD where + showsPrec _ VK_SHADER_INFO_TYPE_STATISTICS_AMD + = showString "VK_SHADER_INFO_TYPE_STATISTICS_AMD" + showsPrec _ VK_SHADER_INFO_TYPE_BINARY_AMD + = showString "VK_SHADER_INFO_TYPE_BINARY_AMD" + showsPrec _ VK_SHADER_INFO_TYPE_DISASSEMBLY_AMD + = showString "VK_SHADER_INFO_TYPE_DISASSEMBLY_AMD" + showsPrec p (VkShaderInfoTypeAMD x) + = showParen (p >= 11) + (showString "VkShaderInfoTypeAMD " . showsPrec 11 x) + +instance Read VkShaderInfoTypeAMD where + readPrec + = parens + (choose + [("VK_SHADER_INFO_TYPE_STATISTICS_AMD", + pure VK_SHADER_INFO_TYPE_STATISTICS_AMD), + ("VK_SHADER_INFO_TYPE_BINARY_AMD", + pure VK_SHADER_INFO_TYPE_BINARY_AMD), + ("VK_SHADER_INFO_TYPE_DISASSEMBLY_AMD", + pure VK_SHADER_INFO_TYPE_DISASSEMBLY_AMD)] + +++ + prec 10 + (expectP (Ident "VkShaderInfoTypeAMD") >> + (VkShaderInfoTypeAMD <$> step readPrec))) + +pattern VK_SHADER_INFO_TYPE_STATISTICS_AMD :: VkShaderInfoTypeAMD + +pattern VK_SHADER_INFO_TYPE_STATISTICS_AMD = VkShaderInfoTypeAMD 0 + +pattern VK_SHADER_INFO_TYPE_BINARY_AMD :: VkShaderInfoTypeAMD + +pattern VK_SHADER_INFO_TYPE_BINARY_AMD = VkShaderInfoTypeAMD 1 + +pattern VK_SHADER_INFO_TYPE_DISASSEMBLY_AMD :: VkShaderInfoTypeAMD + +pattern VK_SHADER_INFO_TYPE_DISASSEMBLY_AMD = VkShaderInfoTypeAMD 2 diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkShaderStageFlags.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkShaderStageFlags.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkShaderStageFlags.hs @@ -0,0 +1,147 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE KindSignatures #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE StandaloneDeriving #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeSynonymInstances #-} +module Graphics.Vulkan.Types.Enum.VkShaderStageFlags + (VkShaderStageBitmask(VkShaderStageBitmask, VkShaderStageFlags, + VkShaderStageFlagBits, VK_SHADER_STAGE_VERTEX_BIT, + VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT, + VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT, + VK_SHADER_STAGE_GEOMETRY_BIT, VK_SHADER_STAGE_FRAGMENT_BIT, + VK_SHADER_STAGE_COMPUTE_BIT, VK_SHADER_STAGE_ALL_GRAPHICS, + VK_SHADER_STAGE_ALL), + VkShaderStageFlags, VkShaderStageFlagBits) + where +import Data.Bits (Bits, FiniteBits) +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (FlagBit, FlagMask, FlagType) +import Graphics.Vulkan.Types.BaseTypes (VkFlags (..)) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +newtype VkShaderStageBitmask (a :: + FlagType) = VkShaderStageBitmask VkFlags + deriving (Eq, Ord, Storable, Data, Generic) + +type VkShaderStageFlags = VkShaderStageBitmask FlagMask + +type VkShaderStageFlagBits = VkShaderStageBitmask FlagBit + +pattern VkShaderStageFlagBits :: + VkFlags -> VkShaderStageBitmask FlagBit + +pattern VkShaderStageFlagBits n = VkShaderStageBitmask n + +pattern VkShaderStageFlags :: + VkFlags -> VkShaderStageBitmask FlagMask + +pattern VkShaderStageFlags n = VkShaderStageBitmask n + +deriving instance Bits (VkShaderStageBitmask FlagMask) + +deriving instance FiniteBits (VkShaderStageBitmask FlagMask) + +deriving instance Integral (VkShaderStageBitmask FlagMask) + +deriving instance Num (VkShaderStageBitmask FlagMask) + +deriving instance Bounded (VkShaderStageBitmask FlagMask) + +deriving instance Enum (VkShaderStageBitmask FlagMask) + +deriving instance Real (VkShaderStageBitmask FlagMask) + +instance Show (VkShaderStageBitmask a) where + showsPrec _ VK_SHADER_STAGE_VERTEX_BIT + = showString "VK_SHADER_STAGE_VERTEX_BIT" + showsPrec _ VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT + = showString "VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT" + showsPrec _ VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT + = showString "VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT" + showsPrec _ VK_SHADER_STAGE_GEOMETRY_BIT + = showString "VK_SHADER_STAGE_GEOMETRY_BIT" + showsPrec _ VK_SHADER_STAGE_FRAGMENT_BIT + = showString "VK_SHADER_STAGE_FRAGMENT_BIT" + showsPrec _ VK_SHADER_STAGE_COMPUTE_BIT + = showString "VK_SHADER_STAGE_COMPUTE_BIT" + showsPrec _ VK_SHADER_STAGE_ALL_GRAPHICS + = showString "VK_SHADER_STAGE_ALL_GRAPHICS" + showsPrec _ VK_SHADER_STAGE_ALL = showString "VK_SHADER_STAGE_ALL" + showsPrec p (VkShaderStageBitmask x) + = showParen (p >= 11) + (showString "VkShaderStageBitmask " . showsPrec 11 x) + +instance Read (VkShaderStageBitmask a) where + readPrec + = parens + (choose + [("VK_SHADER_STAGE_VERTEX_BIT", pure VK_SHADER_STAGE_VERTEX_BIT), + ("VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT", + pure VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT), + ("VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT", + pure VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT), + ("VK_SHADER_STAGE_GEOMETRY_BIT", + pure VK_SHADER_STAGE_GEOMETRY_BIT), + ("VK_SHADER_STAGE_FRAGMENT_BIT", + pure VK_SHADER_STAGE_FRAGMENT_BIT), + ("VK_SHADER_STAGE_COMPUTE_BIT", pure VK_SHADER_STAGE_COMPUTE_BIT), + ("VK_SHADER_STAGE_ALL_GRAPHICS", + pure VK_SHADER_STAGE_ALL_GRAPHICS), + ("VK_SHADER_STAGE_ALL", pure VK_SHADER_STAGE_ALL)] + +++ + prec 10 + (expectP (Ident "VkShaderStageBitmask") >> + (VkShaderStageBitmask <$> step readPrec))) + +-- | bitpos = @0@ +pattern VK_SHADER_STAGE_VERTEX_BIT :: VkShaderStageBitmask a + +pattern VK_SHADER_STAGE_VERTEX_BIT = VkShaderStageBitmask 1 + +-- | bitpos = @1@ +pattern VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT :: + VkShaderStageBitmask a + +pattern VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT = + VkShaderStageBitmask 2 + +-- | bitpos = @2@ +pattern VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT :: + VkShaderStageBitmask a + +pattern VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT = + VkShaderStageBitmask 4 + +-- | bitpos = @3@ +pattern VK_SHADER_STAGE_GEOMETRY_BIT :: VkShaderStageBitmask a + +pattern VK_SHADER_STAGE_GEOMETRY_BIT = VkShaderStageBitmask 8 + +-- | bitpos = @4@ +pattern VK_SHADER_STAGE_FRAGMENT_BIT :: VkShaderStageBitmask a + +pattern VK_SHADER_STAGE_FRAGMENT_BIT = VkShaderStageBitmask 16 + +-- | bitpos = @5@ +pattern VK_SHADER_STAGE_COMPUTE_BIT :: VkShaderStageBitmask a + +pattern VK_SHADER_STAGE_COMPUTE_BIT = VkShaderStageBitmask 32 + +pattern VK_SHADER_STAGE_ALL_GRAPHICS :: VkShaderStageBitmask a + +pattern VK_SHADER_STAGE_ALL_GRAPHICS = VkShaderStageBitmask 31 + +pattern VK_SHADER_STAGE_ALL :: VkShaderStageBitmask a + +pattern VK_SHADER_STAGE_ALL = VkShaderStageBitmask 2147483647 diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkSharingMode.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkSharingMode.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkSharingMode.hs @@ -0,0 +1,53 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +module Graphics.Vulkan.Types.Enum.VkSharingMode + (VkSharingMode(VkSharingMode, VK_SHARING_MODE_EXCLUSIVE, + VK_SHARING_MODE_CONCURRENT)) + where +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (Int32) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +-- | type = @enum@ +-- +-- +newtype VkSharingMode = VkSharingMode Int32 + deriving (Eq, Ord, Num, Bounded, Storable, Enum, Data, Generic) + +instance Show VkSharingMode where + showsPrec _ VK_SHARING_MODE_EXCLUSIVE + = showString "VK_SHARING_MODE_EXCLUSIVE" + showsPrec _ VK_SHARING_MODE_CONCURRENT + = showString "VK_SHARING_MODE_CONCURRENT" + showsPrec p (VkSharingMode x) + = showParen (p >= 11) + (showString "VkSharingMode " . showsPrec 11 x) + +instance Read VkSharingMode where + readPrec + = parens + (choose + [("VK_SHARING_MODE_EXCLUSIVE", pure VK_SHARING_MODE_EXCLUSIVE), + ("VK_SHARING_MODE_CONCURRENT", pure VK_SHARING_MODE_CONCURRENT)] + +++ + prec 10 + (expectP (Ident "VkSharingMode") >> + (VkSharingMode <$> step readPrec))) + +pattern VK_SHARING_MODE_EXCLUSIVE :: VkSharingMode + +pattern VK_SHARING_MODE_EXCLUSIVE = VkSharingMode 0 + +pattern VK_SHARING_MODE_CONCURRENT :: VkSharingMode + +pattern VK_SHARING_MODE_CONCURRENT = VkSharingMode 1 diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkSparseImageFormatFlags.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkSparseImageFormatFlags.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkSparseImageFormatFlags.hs @@ -0,0 +1,116 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE KindSignatures #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE StandaloneDeriving #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeSynonymInstances #-} +module Graphics.Vulkan.Types.Enum.VkSparseImageFormatFlags + (VkSparseImageFormatBitmask(VkSparseImageFormatBitmask, + VkSparseImageFormatFlags, VkSparseImageFormatFlagBits, + VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT, + VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT, + VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT), + VkSparseImageFormatFlags, VkSparseImageFormatFlagBits) + where +import Data.Bits (Bits, FiniteBits) +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (FlagBit, FlagMask, FlagType) +import Graphics.Vulkan.Types.BaseTypes (VkFlags (..)) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +newtype VkSparseImageFormatBitmask (a :: + FlagType) = VkSparseImageFormatBitmask VkFlags + deriving (Eq, Ord, Storable, Data, Generic) + +type VkSparseImageFormatFlags = VkSparseImageFormatBitmask FlagMask + +type VkSparseImageFormatFlagBits = + VkSparseImageFormatBitmask FlagBit + +pattern VkSparseImageFormatFlagBits :: + VkFlags -> VkSparseImageFormatBitmask FlagBit + +pattern VkSparseImageFormatFlagBits n = + VkSparseImageFormatBitmask n + +pattern VkSparseImageFormatFlags :: + VkFlags -> VkSparseImageFormatBitmask FlagMask + +pattern VkSparseImageFormatFlags n = VkSparseImageFormatBitmask n + +deriving instance Bits (VkSparseImageFormatBitmask FlagMask) + +deriving instance FiniteBits (VkSparseImageFormatBitmask FlagMask) + +deriving instance Integral (VkSparseImageFormatBitmask FlagMask) + +deriving instance Num (VkSparseImageFormatBitmask FlagMask) + +deriving instance Bounded (VkSparseImageFormatBitmask FlagMask) + +deriving instance Enum (VkSparseImageFormatBitmask FlagMask) + +deriving instance Real (VkSparseImageFormatBitmask FlagMask) + +instance Show (VkSparseImageFormatBitmask a) where + showsPrec _ VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT + = showString "VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT" + showsPrec _ VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT + = showString "VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT" + showsPrec _ VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT + = showString "VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT" + showsPrec p (VkSparseImageFormatBitmask x) + = showParen (p >= 11) + (showString "VkSparseImageFormatBitmask " . showsPrec 11 x) + +instance Read (VkSparseImageFormatBitmask a) where + readPrec + = parens + (choose + [("VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT", + pure VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT), + ("VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT", + pure VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT), + ("VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT", + pure VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT)] + +++ + prec 10 + (expectP (Ident "VkSparseImageFormatBitmask") >> + (VkSparseImageFormatBitmask <$> step readPrec))) + +-- | Image uses a single mip tail region for all array layers +-- +-- bitpos = @0@ +pattern VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT :: + VkSparseImageFormatBitmask a + +pattern VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT = + VkSparseImageFormatBitmask 1 + +-- | Image requires mip level dimensions to be an integer multiple of the sparse image block dimensions for non-tail mip levels. +-- +-- bitpos = @1@ +pattern VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT :: + VkSparseImageFormatBitmask a + +pattern VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT = + VkSparseImageFormatBitmask 2 + +-- | Image uses a non-standard sparse image block dimensions +-- +-- bitpos = @2@ +pattern VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT :: + VkSparseImageFormatBitmask a + +pattern VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT = + VkSparseImageFormatBitmask 4 diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkSparseMemoryBindFlags.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkSparseMemoryBindFlags.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkSparseMemoryBindFlags.hs @@ -0,0 +1,86 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE KindSignatures #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE StandaloneDeriving #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeSynonymInstances #-} +module Graphics.Vulkan.Types.Enum.VkSparseMemoryBindFlags + (VkSparseMemoryBindBitmask(VkSparseMemoryBindBitmask, + VkSparseMemoryBindFlags, VkSparseMemoryBindFlagBits, + VK_SPARSE_MEMORY_BIND_METADATA_BIT), + VkSparseMemoryBindFlags, VkSparseMemoryBindFlagBits) + where +import Data.Bits (Bits, FiniteBits) +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (FlagBit, FlagMask, FlagType) +import Graphics.Vulkan.Types.BaseTypes (VkFlags (..)) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +newtype VkSparseMemoryBindBitmask (a :: + FlagType) = VkSparseMemoryBindBitmask VkFlags + deriving (Eq, Ord, Storable, Data, Generic) + +type VkSparseMemoryBindFlags = VkSparseMemoryBindBitmask FlagMask + +type VkSparseMemoryBindFlagBits = VkSparseMemoryBindBitmask FlagBit + +pattern VkSparseMemoryBindFlagBits :: + VkFlags -> VkSparseMemoryBindBitmask FlagBit + +pattern VkSparseMemoryBindFlagBits n = VkSparseMemoryBindBitmask n + +pattern VkSparseMemoryBindFlags :: + VkFlags -> VkSparseMemoryBindBitmask FlagMask + +pattern VkSparseMemoryBindFlags n = VkSparseMemoryBindBitmask n + +deriving instance Bits (VkSparseMemoryBindBitmask FlagMask) + +deriving instance FiniteBits (VkSparseMemoryBindBitmask FlagMask) + +deriving instance Integral (VkSparseMemoryBindBitmask FlagMask) + +deriving instance Num (VkSparseMemoryBindBitmask FlagMask) + +deriving instance Bounded (VkSparseMemoryBindBitmask FlagMask) + +deriving instance Enum (VkSparseMemoryBindBitmask FlagMask) + +deriving instance Real (VkSparseMemoryBindBitmask FlagMask) + +instance Show (VkSparseMemoryBindBitmask a) where + showsPrec _ VK_SPARSE_MEMORY_BIND_METADATA_BIT + = showString "VK_SPARSE_MEMORY_BIND_METADATA_BIT" + showsPrec p (VkSparseMemoryBindBitmask x) + = showParen (p >= 11) + (showString "VkSparseMemoryBindBitmask " . showsPrec 11 x) + +instance Read (VkSparseMemoryBindBitmask a) where + readPrec + = parens + (choose + [("VK_SPARSE_MEMORY_BIND_METADATA_BIT", + pure VK_SPARSE_MEMORY_BIND_METADATA_BIT)] + +++ + prec 10 + (expectP (Ident "VkSparseMemoryBindBitmask") >> + (VkSparseMemoryBindBitmask <$> step readPrec))) + +-- | Operation binds resource metadata to memory +-- +-- bitpos = @0@ +pattern VK_SPARSE_MEMORY_BIND_METADATA_BIT :: + VkSparseMemoryBindBitmask a + +pattern VK_SPARSE_MEMORY_BIND_METADATA_BIT = + VkSparseMemoryBindBitmask 1 diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkStencilFaceFlags.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkStencilFaceFlags.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkStencilFaceFlags.hs @@ -0,0 +1,101 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE KindSignatures #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE StandaloneDeriving #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeSynonymInstances #-} +module Graphics.Vulkan.Types.Enum.VkStencilFaceFlags + (VkStencilFaceBitmask(VkStencilFaceBitmask, VkStencilFaceFlags, + VkStencilFaceFlagBits, VK_STENCIL_FACE_FRONT_BIT, + VK_STENCIL_FACE_BACK_BIT, VK_STENCIL_FRONT_AND_BACK), + VkStencilFaceFlags, VkStencilFaceFlagBits) + where +import Data.Bits (Bits, FiniteBits) +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (FlagBit, FlagMask, FlagType) +import Graphics.Vulkan.Types.BaseTypes (VkFlags (..)) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +newtype VkStencilFaceBitmask (a :: + FlagType) = VkStencilFaceBitmask VkFlags + deriving (Eq, Ord, Storable, Data, Generic) + +type VkStencilFaceFlags = VkStencilFaceBitmask FlagMask + +type VkStencilFaceFlagBits = VkStencilFaceBitmask FlagBit + +pattern VkStencilFaceFlagBits :: + VkFlags -> VkStencilFaceBitmask FlagBit + +pattern VkStencilFaceFlagBits n = VkStencilFaceBitmask n + +pattern VkStencilFaceFlags :: + VkFlags -> VkStencilFaceBitmask FlagMask + +pattern VkStencilFaceFlags n = VkStencilFaceBitmask n + +deriving instance Bits (VkStencilFaceBitmask FlagMask) + +deriving instance FiniteBits (VkStencilFaceBitmask FlagMask) + +deriving instance Integral (VkStencilFaceBitmask FlagMask) + +deriving instance Num (VkStencilFaceBitmask FlagMask) + +deriving instance Bounded (VkStencilFaceBitmask FlagMask) + +deriving instance Enum (VkStencilFaceBitmask FlagMask) + +deriving instance Real (VkStencilFaceBitmask FlagMask) + +instance Show (VkStencilFaceBitmask a) where + showsPrec _ VK_STENCIL_FACE_FRONT_BIT + = showString "VK_STENCIL_FACE_FRONT_BIT" + showsPrec _ VK_STENCIL_FACE_BACK_BIT + = showString "VK_STENCIL_FACE_BACK_BIT" + showsPrec _ VK_STENCIL_FRONT_AND_BACK + = showString "VK_STENCIL_FRONT_AND_BACK" + showsPrec p (VkStencilFaceBitmask x) + = showParen (p >= 11) + (showString "VkStencilFaceBitmask " . showsPrec 11 x) + +instance Read (VkStencilFaceBitmask a) where + readPrec + = parens + (choose + [("VK_STENCIL_FACE_FRONT_BIT", pure VK_STENCIL_FACE_FRONT_BIT), + ("VK_STENCIL_FACE_BACK_BIT", pure VK_STENCIL_FACE_BACK_BIT), + ("VK_STENCIL_FRONT_AND_BACK", pure VK_STENCIL_FRONT_AND_BACK)] + +++ + prec 10 + (expectP (Ident "VkStencilFaceBitmask") >> + (VkStencilFaceBitmask <$> step readPrec))) + +-- | Front face +-- +-- bitpos = @0@ +pattern VK_STENCIL_FACE_FRONT_BIT :: VkStencilFaceBitmask a + +pattern VK_STENCIL_FACE_FRONT_BIT = VkStencilFaceBitmask 1 + +-- | Back face +-- +-- bitpos = @1@ +pattern VK_STENCIL_FACE_BACK_BIT :: VkStencilFaceBitmask a + +pattern VK_STENCIL_FACE_BACK_BIT = VkStencilFaceBitmask 2 + +-- | Front and back faces +pattern VK_STENCIL_FRONT_AND_BACK :: VkStencilFaceBitmask a + +pattern VK_STENCIL_FRONT_AND_BACK = VkStencilFaceBitmask 3 diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkStencilOp.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkStencilOp.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkStencilOp.hs @@ -0,0 +1,98 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +module Graphics.Vulkan.Types.Enum.VkStencilOp + (VkStencilOp(VkStencilOp, VK_STENCIL_OP_KEEP, VK_STENCIL_OP_ZERO, + VK_STENCIL_OP_REPLACE, VK_STENCIL_OP_INCREMENT_AND_CLAMP, + VK_STENCIL_OP_DECREMENT_AND_CLAMP, VK_STENCIL_OP_INVERT, + VK_STENCIL_OP_INCREMENT_AND_WRAP, + VK_STENCIL_OP_DECREMENT_AND_WRAP)) + where +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (Int32) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +-- | type = @enum@ +-- +-- +newtype VkStencilOp = VkStencilOp Int32 + deriving (Eq, Ord, Num, Bounded, Storable, Enum, Data, Generic) + +instance Show VkStencilOp where + showsPrec _ VK_STENCIL_OP_KEEP = showString "VK_STENCIL_OP_KEEP" + showsPrec _ VK_STENCIL_OP_ZERO = showString "VK_STENCIL_OP_ZERO" + showsPrec _ VK_STENCIL_OP_REPLACE + = showString "VK_STENCIL_OP_REPLACE" + showsPrec _ VK_STENCIL_OP_INCREMENT_AND_CLAMP + = showString "VK_STENCIL_OP_INCREMENT_AND_CLAMP" + showsPrec _ VK_STENCIL_OP_DECREMENT_AND_CLAMP + = showString "VK_STENCIL_OP_DECREMENT_AND_CLAMP" + showsPrec _ VK_STENCIL_OP_INVERT + = showString "VK_STENCIL_OP_INVERT" + showsPrec _ VK_STENCIL_OP_INCREMENT_AND_WRAP + = showString "VK_STENCIL_OP_INCREMENT_AND_WRAP" + showsPrec _ VK_STENCIL_OP_DECREMENT_AND_WRAP + = showString "VK_STENCIL_OP_DECREMENT_AND_WRAP" + showsPrec p (VkStencilOp x) + = showParen (p >= 11) (showString "VkStencilOp " . showsPrec 11 x) + +instance Read VkStencilOp where + readPrec + = parens + (choose + [("VK_STENCIL_OP_KEEP", pure VK_STENCIL_OP_KEEP), + ("VK_STENCIL_OP_ZERO", pure VK_STENCIL_OP_ZERO), + ("VK_STENCIL_OP_REPLACE", pure VK_STENCIL_OP_REPLACE), + ("VK_STENCIL_OP_INCREMENT_AND_CLAMP", + pure VK_STENCIL_OP_INCREMENT_AND_CLAMP), + ("VK_STENCIL_OP_DECREMENT_AND_CLAMP", + pure VK_STENCIL_OP_DECREMENT_AND_CLAMP), + ("VK_STENCIL_OP_INVERT", pure VK_STENCIL_OP_INVERT), + ("VK_STENCIL_OP_INCREMENT_AND_WRAP", + pure VK_STENCIL_OP_INCREMENT_AND_WRAP), + ("VK_STENCIL_OP_DECREMENT_AND_WRAP", + pure VK_STENCIL_OP_DECREMENT_AND_WRAP)] + +++ + prec 10 + (expectP (Ident "VkStencilOp") >> (VkStencilOp <$> step readPrec))) + +pattern VK_STENCIL_OP_KEEP :: VkStencilOp + +pattern VK_STENCIL_OP_KEEP = VkStencilOp 0 + +pattern VK_STENCIL_OP_ZERO :: VkStencilOp + +pattern VK_STENCIL_OP_ZERO = VkStencilOp 1 + +pattern VK_STENCIL_OP_REPLACE :: VkStencilOp + +pattern VK_STENCIL_OP_REPLACE = VkStencilOp 2 + +pattern VK_STENCIL_OP_INCREMENT_AND_CLAMP :: VkStencilOp + +pattern VK_STENCIL_OP_INCREMENT_AND_CLAMP = VkStencilOp 3 + +pattern VK_STENCIL_OP_DECREMENT_AND_CLAMP :: VkStencilOp + +pattern VK_STENCIL_OP_DECREMENT_AND_CLAMP = VkStencilOp 4 + +pattern VK_STENCIL_OP_INVERT :: VkStencilOp + +pattern VK_STENCIL_OP_INVERT = VkStencilOp 5 + +pattern VK_STENCIL_OP_INCREMENT_AND_WRAP :: VkStencilOp + +pattern VK_STENCIL_OP_INCREMENT_AND_WRAP = VkStencilOp 6 + +pattern VK_STENCIL_OP_DECREMENT_AND_WRAP :: VkStencilOp + +pattern VK_STENCIL_OP_DECREMENT_AND_WRAP = VkStencilOp 7 diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkStructureType.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkStructureType.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkStructureType.hs @@ -0,0 +1,559 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +module Graphics.Vulkan.Types.Enum.VkStructureType + (VkStructureType(VkStructureType, + VK_STRUCTURE_TYPE_APPLICATION_INFO, + VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO, + VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO, + VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO, + VK_STRUCTURE_TYPE_SUBMIT_INFO, + VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO, + VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE, + VK_STRUCTURE_TYPE_BIND_SPARSE_INFO, + VK_STRUCTURE_TYPE_FENCE_CREATE_INFO, + VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO, + VK_STRUCTURE_TYPE_EVENT_CREATE_INFO, + VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO, + VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, + VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO, + VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, + VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, + VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO, + VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO, + VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, + VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO, + VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO, + VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO, + VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO, + VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO, + VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO, + VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO, + VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO, + VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO, + VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO, + VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO, + VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, + VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO, + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO, + VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO, + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO, + VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, + VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET, + VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO, + VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO, + VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO, + VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO, + VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO, + VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, + VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO, + VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, + VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, + VK_STRUCTURE_TYPE_MEMORY_BARRIER, + VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO, + VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO)) + where +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (Int32) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +-- | Structure type enumerant +-- +-- type = @enum@ +-- +-- +-- +newtype VkStructureType = VkStructureType Int32 + deriving (Eq, Ord, Num, Bounded, Storable, Enum, Data, Generic) + +instance Show VkStructureType where + showsPrec _ VK_STRUCTURE_TYPE_APPLICATION_INFO + = showString "VK_STRUCTURE_TYPE_APPLICATION_INFO" + showsPrec _ VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO + = showString "VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO" + showsPrec _ VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO + = showString "VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO" + showsPrec _ VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO + = showString "VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO" + showsPrec _ VK_STRUCTURE_TYPE_SUBMIT_INFO + = showString "VK_STRUCTURE_TYPE_SUBMIT_INFO" + showsPrec _ VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO + = showString "VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO" + showsPrec _ VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE + = showString "VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE" + showsPrec _ VK_STRUCTURE_TYPE_BIND_SPARSE_INFO + = showString "VK_STRUCTURE_TYPE_BIND_SPARSE_INFO" + showsPrec _ VK_STRUCTURE_TYPE_FENCE_CREATE_INFO + = showString "VK_STRUCTURE_TYPE_FENCE_CREATE_INFO" + showsPrec _ VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO + = showString "VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO" + showsPrec _ VK_STRUCTURE_TYPE_EVENT_CREATE_INFO + = showString "VK_STRUCTURE_TYPE_EVENT_CREATE_INFO" + showsPrec _ VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO + = showString "VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO" + showsPrec _ VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO + = showString "VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO" + showsPrec _ VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO + = showString "VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO" + showsPrec _ VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO + = showString "VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO" + showsPrec _ VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO + = showString "VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO" + showsPrec _ VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO + = showString "VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO" + showsPrec _ VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO + = showString "VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO" + showsPrec _ VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO + = showString "VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO" + showsPrec _ + VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO + = showString + "VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO" + showsPrec _ + VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO + = showString + "VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO" + showsPrec _ + VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO + = showString + "VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO" + showsPrec _ VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO + = showString + "VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO" + showsPrec _ + VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO + = showString + "VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO" + showsPrec _ + VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO + = showString + "VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO" + showsPrec _ + VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO + = showString + "VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO" + showsPrec _ + VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO + = showString + "VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO" + showsPrec _ VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO + = showString "VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO" + showsPrec _ VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO + = showString "VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO" + showsPrec _ VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO + = showString "VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO" + showsPrec _ VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO + = showString "VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO" + showsPrec _ VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO + = showString "VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO" + showsPrec _ VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO + = showString "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO" + showsPrec _ VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO + = showString "VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO" + showsPrec _ VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO + = showString "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO" + showsPrec _ VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET + = showString "VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET" + showsPrec _ VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET + = showString "VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET" + showsPrec _ VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO + = showString "VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO" + showsPrec _ VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO + = showString "VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO" + showsPrec _ VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO + = showString "VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO" + showsPrec _ VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO + = showString "VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO" + showsPrec _ VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO + = showString "VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO" + showsPrec _ VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO + = showString "VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO" + showsPrec _ VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO + = showString "VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO" + showsPrec _ VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER + = showString "VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER" + showsPrec _ VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER + = showString "VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER" + showsPrec _ VK_STRUCTURE_TYPE_MEMORY_BARRIER + = showString "VK_STRUCTURE_TYPE_MEMORY_BARRIER" + showsPrec _ VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO + = showString "VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO" + showsPrec _ VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO + = showString "VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO" + showsPrec p (VkStructureType x) + = showParen (p >= 11) + (showString "VkStructureType " . showsPrec 11 x) + +instance Read VkStructureType where + readPrec + = parens + (choose + [("VK_STRUCTURE_TYPE_APPLICATION_INFO", + pure VK_STRUCTURE_TYPE_APPLICATION_INFO), + ("VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO", + pure VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO), + ("VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO", + pure VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO), + ("VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO", + pure VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO), + ("VK_STRUCTURE_TYPE_SUBMIT_INFO", + pure VK_STRUCTURE_TYPE_SUBMIT_INFO), + ("VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO", + pure VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO), + ("VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE", + pure VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE), + ("VK_STRUCTURE_TYPE_BIND_SPARSE_INFO", + pure VK_STRUCTURE_TYPE_BIND_SPARSE_INFO), + ("VK_STRUCTURE_TYPE_FENCE_CREATE_INFO", + pure VK_STRUCTURE_TYPE_FENCE_CREATE_INFO), + ("VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO", + pure VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO), + ("VK_STRUCTURE_TYPE_EVENT_CREATE_INFO", + pure VK_STRUCTURE_TYPE_EVENT_CREATE_INFO), + ("VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO", + pure VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO), + ("VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO", + pure VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO), + ("VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO", + pure VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO), + ("VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO", + pure VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO), + ("VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO", + pure VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO), + ("VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO", + pure VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO), + ("VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO", + pure VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO), + ("VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO", + pure VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO), + ("VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO", + pure VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO), + ("VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO", + pure VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO), + ("VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO", + pure VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO), + ("VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO", + pure VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO), + ("VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO", + pure VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO), + ("VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO", + pure VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO), + ("VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO", + pure VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO), + ("VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO", + pure VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO), + ("VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO", + pure VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO), + ("VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO", + pure VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO), + ("VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO", + pure VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO), + ("VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO", + pure VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO), + ("VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO", + pure VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO), + ("VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO", + pure VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO), + ("VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO", + pure VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO), + ("VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO", + pure VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO), + ("VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET", + pure VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET), + ("VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET", + pure VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET), + ("VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO", + pure VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO), + ("VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO", + pure VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO), + ("VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO", + pure VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO), + ("VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO", + pure VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO), + ("VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO", + pure VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO), + ("VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO", + pure VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO), + ("VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO", + pure VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO), + ("VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER", + pure VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER), + ("VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER", + pure VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER), + ("VK_STRUCTURE_TYPE_MEMORY_BARRIER", + pure VK_STRUCTURE_TYPE_MEMORY_BARRIER), + ("VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO", + pure VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO), + ("VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO", + pure VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO)] + +++ + prec 10 + (expectP (Ident "VkStructureType") >> + (VkStructureType <$> step readPrec))) + +pattern VK_STRUCTURE_TYPE_APPLICATION_INFO :: VkStructureType + +pattern VK_STRUCTURE_TYPE_APPLICATION_INFO = VkStructureType 0 + +pattern VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO :: VkStructureType + +pattern VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO = VkStructureType 1 + +pattern VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO = + VkStructureType 2 + +pattern VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO :: VkStructureType + +pattern VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO = VkStructureType 3 + +pattern VK_STRUCTURE_TYPE_SUBMIT_INFO :: VkStructureType + +pattern VK_STRUCTURE_TYPE_SUBMIT_INFO = VkStructureType 4 + +pattern VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO :: VkStructureType + +pattern VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO = VkStructureType 5 + +pattern VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE :: VkStructureType + +pattern VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE = VkStructureType 6 + +pattern VK_STRUCTURE_TYPE_BIND_SPARSE_INFO :: VkStructureType + +pattern VK_STRUCTURE_TYPE_BIND_SPARSE_INFO = VkStructureType 7 + +pattern VK_STRUCTURE_TYPE_FENCE_CREATE_INFO :: VkStructureType + +pattern VK_STRUCTURE_TYPE_FENCE_CREATE_INFO = VkStructureType 8 + +pattern VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO :: VkStructureType + +pattern VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO = VkStructureType 9 + +pattern VK_STRUCTURE_TYPE_EVENT_CREATE_INFO :: VkStructureType + +pattern VK_STRUCTURE_TYPE_EVENT_CREATE_INFO = VkStructureType 10 + +pattern VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO :: VkStructureType + +pattern VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO = + VkStructureType 11 + +pattern VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO :: VkStructureType + +pattern VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO = VkStructureType 12 + +pattern VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO = + VkStructureType 13 + +pattern VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO :: VkStructureType + +pattern VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO = VkStructureType 14 + +pattern VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO :: VkStructureType + +pattern VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO = + VkStructureType 15 + +pattern VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO = + VkStructureType 16 + +pattern VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO = + VkStructureType 17 + +pattern VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO = + VkStructureType 18 + +pattern VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO + :: VkStructureType + +pattern VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO = + VkStructureType 19 + +pattern VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO + :: VkStructureType + +pattern VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO + = VkStructureType 20 + +pattern VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO + :: VkStructureType + +pattern VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO = + VkStructureType 21 + +pattern VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO = + VkStructureType 22 + +pattern VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO + :: VkStructureType + +pattern VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO + = VkStructureType 23 + +pattern VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO = + VkStructureType 24 + +pattern VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO + :: VkStructureType + +pattern VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO + = VkStructureType 25 + +pattern VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO = + VkStructureType 26 + +pattern VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO = + VkStructureType 27 + +pattern VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO = + VkStructureType 28 + +pattern VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO = + VkStructureType 29 + +pattern VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO = + VkStructureType 30 + +pattern VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO :: VkStructureType + +pattern VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO = VkStructureType 31 + +pattern VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO = + VkStructureType 32 + +pattern VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO = + VkStructureType 33 + +pattern VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO = + VkStructureType 34 + +pattern VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET :: VkStructureType + +pattern VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET = VkStructureType 35 + +pattern VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET :: VkStructureType + +pattern VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET = VkStructureType 36 + +pattern VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO = + VkStructureType 37 + +pattern VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO = + VkStructureType 38 + +pattern VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO = + VkStructureType 39 + +pattern VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO = + VkStructureType 40 + +pattern VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO = + VkStructureType 41 + +pattern VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO = + VkStructureType 42 + +pattern VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO :: VkStructureType + +pattern VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO = + VkStructureType 43 + +pattern VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER :: VkStructureType + +pattern VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER = + VkStructureType 44 + +pattern VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER :: VkStructureType + +pattern VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER = VkStructureType 45 + +pattern VK_STRUCTURE_TYPE_MEMORY_BARRIER :: VkStructureType + +pattern VK_STRUCTURE_TYPE_MEMORY_BARRIER = VkStructureType 46 + +-- | Reserved for internal use by the loader, layers, and ICDs +pattern VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO = + VkStructureType 47 + +-- | Reserved for internal use by the loader, layers, and ICDs +pattern VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO :: + VkStructureType + +pattern VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO = + VkStructureType 48 diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkSubpassContents.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkSubpassContents.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkSubpassContents.hs @@ -0,0 +1,56 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +module Graphics.Vulkan.Types.Enum.VkSubpassContents + (VkSubpassContents(VkSubpassContents, VK_SUBPASS_CONTENTS_INLINE, + VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS)) + where +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (Int32) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +-- | type = @enum@ +-- +-- +newtype VkSubpassContents = VkSubpassContents Int32 + deriving (Eq, Ord, Num, Bounded, Storable, Enum, Data, Generic) + +instance Show VkSubpassContents where + showsPrec _ VK_SUBPASS_CONTENTS_INLINE + = showString "VK_SUBPASS_CONTENTS_INLINE" + showsPrec _ VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS + = showString "VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS" + showsPrec p (VkSubpassContents x) + = showParen (p >= 11) + (showString "VkSubpassContents " . showsPrec 11 x) + +instance Read VkSubpassContents where + readPrec + = parens + (choose + [("VK_SUBPASS_CONTENTS_INLINE", pure VK_SUBPASS_CONTENTS_INLINE), + ("VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS", + pure VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS)] + +++ + prec 10 + (expectP (Ident "VkSubpassContents") >> + (VkSubpassContents <$> step readPrec))) + +pattern VK_SUBPASS_CONTENTS_INLINE :: VkSubpassContents + +pattern VK_SUBPASS_CONTENTS_INLINE = VkSubpassContents 0 + +pattern VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS :: + VkSubpassContents + +pattern VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS = + VkSubpassContents 1 diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkSubpassDescriptionFlags.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkSubpassDescriptionFlags.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkSubpassDescriptionFlags.hs @@ -0,0 +1,74 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE KindSignatures #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE StandaloneDeriving #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeSynonymInstances #-} +module Graphics.Vulkan.Types.Enum.VkSubpassDescriptionFlags + (VkSubpassDescriptionBitmask(VkSubpassDescriptionBitmask, + VkSubpassDescriptionFlags, VkSubpassDescriptionFlagBits), + VkSubpassDescriptionFlags, VkSubpassDescriptionFlagBits) + where +import Data.Bits (Bits, FiniteBits) +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (FlagBit, FlagMask, FlagType) +import Graphics.Vulkan.Types.BaseTypes (VkFlags (..)) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +newtype VkSubpassDescriptionBitmask (a :: + FlagType) = VkSubpassDescriptionBitmask VkFlags + deriving (Eq, Ord, Storable, Data, Generic) + +type VkSubpassDescriptionFlags = + VkSubpassDescriptionBitmask FlagMask + +type VkSubpassDescriptionFlagBits = + VkSubpassDescriptionBitmask FlagBit + +pattern VkSubpassDescriptionFlagBits :: + VkFlags -> VkSubpassDescriptionBitmask FlagBit + +pattern VkSubpassDescriptionFlagBits n = + VkSubpassDescriptionBitmask n + +pattern VkSubpassDescriptionFlags :: + VkFlags -> VkSubpassDescriptionBitmask FlagMask + +pattern VkSubpassDescriptionFlags n = VkSubpassDescriptionBitmask n + +deriving instance Bits (VkSubpassDescriptionBitmask FlagMask) + +deriving instance FiniteBits (VkSubpassDescriptionBitmask FlagMask) + +deriving instance Integral (VkSubpassDescriptionBitmask FlagMask) + +deriving instance Num (VkSubpassDescriptionBitmask FlagMask) + +deriving instance Bounded (VkSubpassDescriptionBitmask FlagMask) + +deriving instance Enum (VkSubpassDescriptionBitmask FlagMask) + +deriving instance Real (VkSubpassDescriptionBitmask FlagMask) + +instance Show (VkSubpassDescriptionBitmask a) where + showsPrec p (VkSubpassDescriptionBitmask x) + = showParen (p >= 11) + (showString "VkSubpassDescriptionBitmask " . showsPrec 11 x) + +instance Read (VkSubpassDescriptionBitmask a) where + readPrec + = parens + (choose [] +++ + prec 10 + (expectP (Ident "VkSubpassDescriptionBitmask") >> + (VkSubpassDescriptionBitmask <$> step readPrec))) diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkSurfaceCounterFlagsEXT.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkSurfaceCounterFlagsEXT.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkSurfaceCounterFlagsEXT.hs @@ -0,0 +1,86 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE KindSignatures #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE StandaloneDeriving #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeSynonymInstances #-} +module Graphics.Vulkan.Types.Enum.VkSurfaceCounterFlagsEXT + (VkSurfaceCounterBitmaskEXT(VkSurfaceCounterBitmaskEXT, + VkSurfaceCounterFlagsEXT, VkSurfaceCounterFlagBitsEXT, + VK_SURFACE_COUNTER_VBLANK_EXT), + VkSurfaceCounterFlagsEXT, VkSurfaceCounterFlagBitsEXT) + where +import Data.Bits (Bits, FiniteBits) +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (FlagBit, FlagMask, FlagType) +import Graphics.Vulkan.Types.BaseTypes (VkFlags (..)) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +newtype VkSurfaceCounterBitmaskEXT (a :: + FlagType) = VkSurfaceCounterBitmaskEXT VkFlags + deriving (Eq, Ord, Storable, Data, Generic) + +type VkSurfaceCounterFlagsEXT = VkSurfaceCounterBitmaskEXT FlagMask + +type VkSurfaceCounterFlagBitsEXT = + VkSurfaceCounterBitmaskEXT FlagBit + +pattern VkSurfaceCounterFlagBitsEXT :: + VkFlags -> VkSurfaceCounterBitmaskEXT FlagBit + +pattern VkSurfaceCounterFlagBitsEXT n = + VkSurfaceCounterBitmaskEXT n + +pattern VkSurfaceCounterFlagsEXT :: + VkFlags -> VkSurfaceCounterBitmaskEXT FlagMask + +pattern VkSurfaceCounterFlagsEXT n = VkSurfaceCounterBitmaskEXT n + +deriving instance Bits (VkSurfaceCounterBitmaskEXT FlagMask) + +deriving instance FiniteBits (VkSurfaceCounterBitmaskEXT FlagMask) + +deriving instance Integral (VkSurfaceCounterBitmaskEXT FlagMask) + +deriving instance Num (VkSurfaceCounterBitmaskEXT FlagMask) + +deriving instance Bounded (VkSurfaceCounterBitmaskEXT FlagMask) + +deriving instance Enum (VkSurfaceCounterBitmaskEXT FlagMask) + +deriving instance Real (VkSurfaceCounterBitmaskEXT FlagMask) + +instance Show (VkSurfaceCounterBitmaskEXT a) where + showsPrec _ VK_SURFACE_COUNTER_VBLANK_EXT + = showString "VK_SURFACE_COUNTER_VBLANK_EXT" + showsPrec p (VkSurfaceCounterBitmaskEXT x) + = showParen (p >= 11) + (showString "VkSurfaceCounterBitmaskEXT " . showsPrec 11 x) + +instance Read (VkSurfaceCounterBitmaskEXT a) where + readPrec + = parens + (choose + [("VK_SURFACE_COUNTER_VBLANK_EXT", + pure VK_SURFACE_COUNTER_VBLANK_EXT)] + +++ + prec 10 + (expectP (Ident "VkSurfaceCounterBitmaskEXT") >> + (VkSurfaceCounterBitmaskEXT <$> step readPrec))) + +-- | bitpos = @0@ +pattern VK_SURFACE_COUNTER_VBLANK_EXT :: + VkSurfaceCounterBitmaskEXT a + +pattern VK_SURFACE_COUNTER_VBLANK_EXT = + VkSurfaceCounterBitmaskEXT 1 diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkSurfaceTransformFlagsKHR.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkSurfaceTransformFlagsKHR.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkSurfaceTransformFlagsKHR.hs @@ -0,0 +1,191 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE KindSignatures #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE StandaloneDeriving #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeSynonymInstances #-} +module Graphics.Vulkan.Types.Enum.VkSurfaceTransformFlagsKHR + (VkSurfaceTransformBitmaskKHR(VkSurfaceTransformBitmaskKHR, + VkSurfaceTransformFlagsKHR, VkSurfaceTransformFlagBitsKHR, + VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR, + VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR, + VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR, + VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR, + VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR, + VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR, + VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR, + VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR, + VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR), + VkSurfaceTransformFlagsKHR, VkSurfaceTransformFlagBitsKHR) + where +import Data.Bits (Bits, FiniteBits) +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (FlagBit, FlagMask, FlagType) +import Graphics.Vulkan.Types.BaseTypes (VkFlags (..)) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +newtype VkSurfaceTransformBitmaskKHR (a :: + FlagType) = VkSurfaceTransformBitmaskKHR VkFlags + deriving (Eq, Ord, Storable, Data, Generic) + +type VkSurfaceTransformFlagsKHR = + VkSurfaceTransformBitmaskKHR FlagMask + +type VkSurfaceTransformFlagBitsKHR = + VkSurfaceTransformBitmaskKHR FlagBit + +pattern VkSurfaceTransformFlagBitsKHR :: + VkFlags -> VkSurfaceTransformBitmaskKHR FlagBit + +pattern VkSurfaceTransformFlagBitsKHR n = + VkSurfaceTransformBitmaskKHR n + +pattern VkSurfaceTransformFlagsKHR :: + VkFlags -> VkSurfaceTransformBitmaskKHR FlagMask + +pattern VkSurfaceTransformFlagsKHR n = + VkSurfaceTransformBitmaskKHR n + +deriving instance Bits (VkSurfaceTransformBitmaskKHR FlagMask) + +deriving instance + FiniteBits (VkSurfaceTransformBitmaskKHR FlagMask) + +deriving instance Integral (VkSurfaceTransformBitmaskKHR FlagMask) + +deriving instance Num (VkSurfaceTransformBitmaskKHR FlagMask) + +deriving instance Bounded (VkSurfaceTransformBitmaskKHR FlagMask) + +deriving instance Enum (VkSurfaceTransformBitmaskKHR FlagMask) + +deriving instance Real (VkSurfaceTransformBitmaskKHR FlagMask) + +instance Show (VkSurfaceTransformBitmaskKHR a) where + showsPrec _ VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR + = showString "VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR" + showsPrec _ VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR + = showString "VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR" + showsPrec _ VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR + = showString "VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR" + showsPrec _ VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR + = showString "VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR" + showsPrec _ VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR + = showString "VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR" + showsPrec _ + VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR + = showString + "VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR" + showsPrec _ + VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR + = showString + "VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR" + showsPrec _ + VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR + = showString + "VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR" + showsPrec _ VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR + = showString "VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR" + showsPrec p (VkSurfaceTransformBitmaskKHR x) + = showParen (p >= 11) + (showString "VkSurfaceTransformBitmaskKHR " . showsPrec 11 x) + +instance Read (VkSurfaceTransformBitmaskKHR a) where + readPrec + = parens + (choose + [("VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR", + pure VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR), + ("VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR", + pure VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR), + ("VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR", + pure VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR), + ("VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR", + pure VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR), + ("VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR", + pure VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR), + ("VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR", + pure VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR), + ("VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR", + pure VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR), + ("VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR", + pure VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR), + ("VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR", + pure VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR)] + +++ + prec 10 + (expectP (Ident "VkSurfaceTransformBitmaskKHR") >> + (VkSurfaceTransformBitmaskKHR <$> step readPrec))) + +-- | bitpos = @0@ +pattern VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR :: + VkSurfaceTransformBitmaskKHR a + +pattern VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR = + VkSurfaceTransformBitmaskKHR 1 + +-- | bitpos = @1@ +pattern VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR :: + VkSurfaceTransformBitmaskKHR a + +pattern VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR = + VkSurfaceTransformBitmaskKHR 2 + +-- | bitpos = @2@ +pattern VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR :: + VkSurfaceTransformBitmaskKHR a + +pattern VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR = + VkSurfaceTransformBitmaskKHR 4 + +-- | bitpos = @3@ +pattern VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR :: + VkSurfaceTransformBitmaskKHR a + +pattern VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR = + VkSurfaceTransformBitmaskKHR 8 + +-- | bitpos = @4@ +pattern VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR :: + VkSurfaceTransformBitmaskKHR a + +pattern VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR = + VkSurfaceTransformBitmaskKHR 16 + +-- | bitpos = @5@ +pattern VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR :: + VkSurfaceTransformBitmaskKHR a + +pattern VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR = + VkSurfaceTransformBitmaskKHR 32 + +-- | bitpos = @6@ +pattern VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR + :: VkSurfaceTransformBitmaskKHR a + +pattern VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR = + VkSurfaceTransformBitmaskKHR 64 + +-- | bitpos = @7@ +pattern VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR + :: VkSurfaceTransformBitmaskKHR a + +pattern VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR = + VkSurfaceTransformBitmaskKHR 128 + +-- | bitpos = @8@ +pattern VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR :: + VkSurfaceTransformBitmaskKHR a + +pattern VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR = + VkSurfaceTransformBitmaskKHR 256 diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkSwapchainCreateFlagsKHR.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkSwapchainCreateFlagsKHR.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkSwapchainCreateFlagsKHR.hs @@ -0,0 +1,74 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE KindSignatures #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE StandaloneDeriving #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeSynonymInstances #-} +module Graphics.Vulkan.Types.Enum.VkSwapchainCreateFlagsKHR + (VkSwapchainCreateBitmaskKHR(VkSwapchainCreateBitmaskKHR, + VkSwapchainCreateFlagsKHR, VkSwapchainCreateFlagBitsKHR), + VkSwapchainCreateFlagsKHR, VkSwapchainCreateFlagBitsKHR) + where +import Data.Bits (Bits, FiniteBits) +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (FlagBit, FlagMask, FlagType) +import Graphics.Vulkan.Types.BaseTypes (VkFlags (..)) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +newtype VkSwapchainCreateBitmaskKHR (a :: + FlagType) = VkSwapchainCreateBitmaskKHR VkFlags + deriving (Eq, Ord, Storable, Data, Generic) + +type VkSwapchainCreateFlagsKHR = + VkSwapchainCreateBitmaskKHR FlagMask + +type VkSwapchainCreateFlagBitsKHR = + VkSwapchainCreateBitmaskKHR FlagBit + +pattern VkSwapchainCreateFlagBitsKHR :: + VkFlags -> VkSwapchainCreateBitmaskKHR FlagBit + +pattern VkSwapchainCreateFlagBitsKHR n = + VkSwapchainCreateBitmaskKHR n + +pattern VkSwapchainCreateFlagsKHR :: + VkFlags -> VkSwapchainCreateBitmaskKHR FlagMask + +pattern VkSwapchainCreateFlagsKHR n = VkSwapchainCreateBitmaskKHR n + +deriving instance Bits (VkSwapchainCreateBitmaskKHR FlagMask) + +deriving instance FiniteBits (VkSwapchainCreateBitmaskKHR FlagMask) + +deriving instance Integral (VkSwapchainCreateBitmaskKHR FlagMask) + +deriving instance Num (VkSwapchainCreateBitmaskKHR FlagMask) + +deriving instance Bounded (VkSwapchainCreateBitmaskKHR FlagMask) + +deriving instance Enum (VkSwapchainCreateBitmaskKHR FlagMask) + +deriving instance Real (VkSwapchainCreateBitmaskKHR FlagMask) + +instance Show (VkSwapchainCreateBitmaskKHR a) where + showsPrec p (VkSwapchainCreateBitmaskKHR x) + = showParen (p >= 11) + (showString "VkSwapchainCreateBitmaskKHR " . showsPrec 11 x) + +instance Read (VkSwapchainCreateBitmaskKHR a) where + readPrec + = parens + (choose [] +++ + prec 10 + (expectP (Ident "VkSwapchainCreateBitmaskKHR") >> + (VkSwapchainCreateBitmaskKHR <$> step readPrec))) diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkSystemAllocationScope.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkSystemAllocationScope.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkSystemAllocationScope.hs @@ -0,0 +1,92 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +module Graphics.Vulkan.Types.Enum.VkSystemAllocationScope + (VkSystemAllocationScope(VkSystemAllocationScope, + VK_SYSTEM_ALLOCATION_SCOPE_COMMAND, + VK_SYSTEM_ALLOCATION_SCOPE_OBJECT, + VK_SYSTEM_ALLOCATION_SCOPE_CACHE, + VK_SYSTEM_ALLOCATION_SCOPE_DEVICE, + VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE)) + where +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (Int32) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +-- | type = @enum@ +-- +-- +newtype VkSystemAllocationScope = VkSystemAllocationScope Int32 + deriving (Eq, Ord, Num, Bounded, Storable, Enum, Data, Generic) + +instance Show VkSystemAllocationScope where + showsPrec _ VK_SYSTEM_ALLOCATION_SCOPE_COMMAND + = showString "VK_SYSTEM_ALLOCATION_SCOPE_COMMAND" + showsPrec _ VK_SYSTEM_ALLOCATION_SCOPE_OBJECT + = showString "VK_SYSTEM_ALLOCATION_SCOPE_OBJECT" + showsPrec _ VK_SYSTEM_ALLOCATION_SCOPE_CACHE + = showString "VK_SYSTEM_ALLOCATION_SCOPE_CACHE" + showsPrec _ VK_SYSTEM_ALLOCATION_SCOPE_DEVICE + = showString "VK_SYSTEM_ALLOCATION_SCOPE_DEVICE" + showsPrec _ VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE + = showString "VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE" + showsPrec p (VkSystemAllocationScope x) + = showParen (p >= 11) + (showString "VkSystemAllocationScope " . showsPrec 11 x) + +instance Read VkSystemAllocationScope where + readPrec + = parens + (choose + [("VK_SYSTEM_ALLOCATION_SCOPE_COMMAND", + pure VK_SYSTEM_ALLOCATION_SCOPE_COMMAND), + ("VK_SYSTEM_ALLOCATION_SCOPE_OBJECT", + pure VK_SYSTEM_ALLOCATION_SCOPE_OBJECT), + ("VK_SYSTEM_ALLOCATION_SCOPE_CACHE", + pure VK_SYSTEM_ALLOCATION_SCOPE_CACHE), + ("VK_SYSTEM_ALLOCATION_SCOPE_DEVICE", + pure VK_SYSTEM_ALLOCATION_SCOPE_DEVICE), + ("VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE", + pure VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE)] + +++ + prec 10 + (expectP (Ident "VkSystemAllocationScope") >> + (VkSystemAllocationScope <$> step readPrec))) + +pattern VK_SYSTEM_ALLOCATION_SCOPE_COMMAND :: + VkSystemAllocationScope + +pattern VK_SYSTEM_ALLOCATION_SCOPE_COMMAND = + VkSystemAllocationScope 0 + +pattern VK_SYSTEM_ALLOCATION_SCOPE_OBJECT :: + VkSystemAllocationScope + +pattern VK_SYSTEM_ALLOCATION_SCOPE_OBJECT = + VkSystemAllocationScope 1 + +pattern VK_SYSTEM_ALLOCATION_SCOPE_CACHE :: VkSystemAllocationScope + +pattern VK_SYSTEM_ALLOCATION_SCOPE_CACHE = + VkSystemAllocationScope 2 + +pattern VK_SYSTEM_ALLOCATION_SCOPE_DEVICE :: + VkSystemAllocationScope + +pattern VK_SYSTEM_ALLOCATION_SCOPE_DEVICE = + VkSystemAllocationScope 3 + +pattern VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE :: + VkSystemAllocationScope + +pattern VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE = + VkSystemAllocationScope 4 diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkTessellationDomainOriginKHR.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkTessellationDomainOriginKHR.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkTessellationDomainOriginKHR.hs @@ -0,0 +1,61 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +module Graphics.Vulkan.Types.Enum.VkTessellationDomainOriginKHR + (VkTessellationDomainOriginKHR(VkTessellationDomainOriginKHR, + VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT_KHR, + VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT_KHR)) + where +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (Int32) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +-- | type = @enum@ +-- +-- +newtype VkTessellationDomainOriginKHR = VkTessellationDomainOriginKHR Int32 + deriving (Eq, Ord, Num, Bounded, Storable, Enum, Data, + Generic) + +instance Show VkTessellationDomainOriginKHR where + showsPrec _ VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT_KHR + = showString "VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT_KHR" + showsPrec _ VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT_KHR + = showString "VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT_KHR" + showsPrec p (VkTessellationDomainOriginKHR x) + = showParen (p >= 11) + (showString "VkTessellationDomainOriginKHR " . showsPrec 11 x) + +instance Read VkTessellationDomainOriginKHR where + readPrec + = parens + (choose + [("VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT_KHR", + pure VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT_KHR), + ("VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT_KHR", + pure VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT_KHR)] + +++ + prec 10 + (expectP (Ident "VkTessellationDomainOriginKHR") >> + (VkTessellationDomainOriginKHR <$> step readPrec))) + +pattern VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT_KHR :: + VkTessellationDomainOriginKHR + +pattern VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT_KHR = + VkTessellationDomainOriginKHR 0 + +pattern VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT_KHR :: + VkTessellationDomainOriginKHR + +pattern VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT_KHR = + VkTessellationDomainOriginKHR 1 diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkValidationCacheHeaderVersionEXT.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkValidationCacheHeaderVersionEXT.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkValidationCacheHeaderVersionEXT.hs @@ -0,0 +1,50 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +module Graphics.Vulkan.Types.Enum.VkValidationCacheHeaderVersionEXT + (VkValidationCacheHeaderVersionEXT(VkValidationCacheHeaderVersionEXT, + VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT)) + where +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (Int32) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +-- | type = @enum@ +-- +-- +newtype VkValidationCacheHeaderVersionEXT = VkValidationCacheHeaderVersionEXT Int32 + deriving (Eq, Ord, Num, Bounded, Storable, Enum, Data, + Generic) + +instance Show VkValidationCacheHeaderVersionEXT where + showsPrec _ VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT + = showString "VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT" + showsPrec p (VkValidationCacheHeaderVersionEXT x) + = showParen (p >= 11) + (showString "VkValidationCacheHeaderVersionEXT " . showsPrec 11 x) + +instance Read VkValidationCacheHeaderVersionEXT where + readPrec + = parens + (choose + [("VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT", + pure VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT)] + +++ + prec 10 + (expectP (Ident "VkValidationCacheHeaderVersionEXT") >> + (VkValidationCacheHeaderVersionEXT <$> step readPrec))) + +pattern VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT :: + VkValidationCacheHeaderVersionEXT + +pattern VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT = + VkValidationCacheHeaderVersionEXT 1 diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkValidationCheckEXT.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkValidationCheckEXT.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkValidationCheckEXT.hs @@ -0,0 +1,54 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +module Graphics.Vulkan.Types.Enum.VkValidationCheckEXT + (VkValidationCheckEXT(VkValidationCheckEXT, + VK_VALIDATION_CHECK_ALL_EXT, VK_VALIDATION_CHECK_SHADERS_EXT)) + where +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (Int32) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +-- | type = @enum@ +-- +-- +newtype VkValidationCheckEXT = VkValidationCheckEXT Int32 + deriving (Eq, Ord, Num, Bounded, Storable, Enum, Data, Generic) + +instance Show VkValidationCheckEXT where + showsPrec _ VK_VALIDATION_CHECK_ALL_EXT + = showString "VK_VALIDATION_CHECK_ALL_EXT" + showsPrec _ VK_VALIDATION_CHECK_SHADERS_EXT + = showString "VK_VALIDATION_CHECK_SHADERS_EXT" + showsPrec p (VkValidationCheckEXT x) + = showParen (p >= 11) + (showString "VkValidationCheckEXT " . showsPrec 11 x) + +instance Read VkValidationCheckEXT where + readPrec + = parens + (choose + [("VK_VALIDATION_CHECK_ALL_EXT", pure VK_VALIDATION_CHECK_ALL_EXT), + ("VK_VALIDATION_CHECK_SHADERS_EXT", + pure VK_VALIDATION_CHECK_SHADERS_EXT)] + +++ + prec 10 + (expectP (Ident "VkValidationCheckEXT") >> + (VkValidationCheckEXT <$> step readPrec))) + +pattern VK_VALIDATION_CHECK_ALL_EXT :: VkValidationCheckEXT + +pattern VK_VALIDATION_CHECK_ALL_EXT = VkValidationCheckEXT 0 + +pattern VK_VALIDATION_CHECK_SHADERS_EXT :: VkValidationCheckEXT + +pattern VK_VALIDATION_CHECK_SHADERS_EXT = VkValidationCheckEXT 1 diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkVertexInputRate.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkVertexInputRate.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkVertexInputRate.hs @@ -0,0 +1,54 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +module Graphics.Vulkan.Types.Enum.VkVertexInputRate + (VkVertexInputRate(VkVertexInputRate, VK_VERTEX_INPUT_RATE_VERTEX, + VK_VERTEX_INPUT_RATE_INSTANCE)) + where +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (Int32) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +-- | type = @enum@ +-- +-- +newtype VkVertexInputRate = VkVertexInputRate Int32 + deriving (Eq, Ord, Num, Bounded, Storable, Enum, Data, Generic) + +instance Show VkVertexInputRate where + showsPrec _ VK_VERTEX_INPUT_RATE_VERTEX + = showString "VK_VERTEX_INPUT_RATE_VERTEX" + showsPrec _ VK_VERTEX_INPUT_RATE_INSTANCE + = showString "VK_VERTEX_INPUT_RATE_INSTANCE" + showsPrec p (VkVertexInputRate x) + = showParen (p >= 11) + (showString "VkVertexInputRate " . showsPrec 11 x) + +instance Read VkVertexInputRate where + readPrec + = parens + (choose + [("VK_VERTEX_INPUT_RATE_VERTEX", pure VK_VERTEX_INPUT_RATE_VERTEX), + ("VK_VERTEX_INPUT_RATE_INSTANCE", + pure VK_VERTEX_INPUT_RATE_INSTANCE)] + +++ + prec 10 + (expectP (Ident "VkVertexInputRate") >> + (VkVertexInputRate <$> step readPrec))) + +pattern VK_VERTEX_INPUT_RATE_VERTEX :: VkVertexInputRate + +pattern VK_VERTEX_INPUT_RATE_VERTEX = VkVertexInputRate 0 + +pattern VK_VERTEX_INPUT_RATE_INSTANCE :: VkVertexInputRate + +pattern VK_VERTEX_INPUT_RATE_INSTANCE = VkVertexInputRate 1 diff --git a/src-gen/Graphics/Vulkan/Types/Enum/VkViewportCoordinateSwizzleNV.hs b/src-gen/Graphics/Vulkan/Types/Enum/VkViewportCoordinateSwizzleNV.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Enum/VkViewportCoordinateSwizzleNV.hs @@ -0,0 +1,127 @@ +{-# OPTIONS_HADDOCK ignore-exports#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE Strict #-} +module Graphics.Vulkan.Types.Enum.VkViewportCoordinateSwizzleNV + (VkViewportCoordinateSwizzleNV(VkViewportCoordinateSwizzleNV, + VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV, + VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_X_NV, + VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Y_NV, + VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Y_NV, + VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Z_NV, + VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Z_NV, + VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_W_NV, + VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV)) + where +import Data.Data (Data) +import Foreign.Storable (Storable) +import GHC.Generics (Generic) +import GHC.Read (choose, expectP) +import Graphics.Vulkan.Marshal (Int32) +import Text.ParserCombinators.ReadPrec (prec, step, (+++)) +import Text.Read (Read (..), parens) +import Text.Read.Lex (Lexeme (..)) + +-- | type = @enum@ +-- +-- +newtype VkViewportCoordinateSwizzleNV = VkViewportCoordinateSwizzleNV Int32 + deriving (Eq, Ord, Num, Bounded, Storable, Enum, Data, + Generic) + +instance Show VkViewportCoordinateSwizzleNV where + showsPrec _ VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV + = showString "VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV" + showsPrec _ VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_X_NV + = showString "VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_X_NV" + showsPrec _ VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Y_NV + = showString "VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Y_NV" + showsPrec _ VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Y_NV + = showString "VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Y_NV" + showsPrec _ VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Z_NV + = showString "VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Z_NV" + showsPrec _ VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Z_NV + = showString "VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Z_NV" + showsPrec _ VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_W_NV + = showString "VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_W_NV" + showsPrec _ VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV + = showString "VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV" + showsPrec p (VkViewportCoordinateSwizzleNV x) + = showParen (p >= 11) + (showString "VkViewportCoordinateSwizzleNV " . showsPrec 11 x) + +instance Read VkViewportCoordinateSwizzleNV where + readPrec + = parens + (choose + [("VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV", + pure VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV), + ("VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_X_NV", + pure VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_X_NV), + ("VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Y_NV", + pure VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Y_NV), + ("VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Y_NV", + pure VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Y_NV), + ("VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Z_NV", + pure VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Z_NV), + ("VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Z_NV", + pure VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Z_NV), + ("VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_W_NV", + pure VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_W_NV), + ("VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV", + pure VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV)] + +++ + prec 10 + (expectP (Ident "VkViewportCoordinateSwizzleNV") >> + (VkViewportCoordinateSwizzleNV <$> step readPrec))) + +pattern VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV :: + VkViewportCoordinateSwizzleNV + +pattern VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV = + VkViewportCoordinateSwizzleNV 0 + +pattern VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_X_NV :: + VkViewportCoordinateSwizzleNV + +pattern VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_X_NV = + VkViewportCoordinateSwizzleNV 1 + +pattern VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Y_NV :: + VkViewportCoordinateSwizzleNV + +pattern VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Y_NV = + VkViewportCoordinateSwizzleNV 2 + +pattern VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Y_NV :: + VkViewportCoordinateSwizzleNV + +pattern VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Y_NV = + VkViewportCoordinateSwizzleNV 3 + +pattern VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Z_NV :: + VkViewportCoordinateSwizzleNV + +pattern VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Z_NV = + VkViewportCoordinateSwizzleNV 4 + +pattern VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Z_NV :: + VkViewportCoordinateSwizzleNV + +pattern VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Z_NV = + VkViewportCoordinateSwizzleNV 5 + +pattern VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_W_NV :: + VkViewportCoordinateSwizzleNV + +pattern VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_W_NV = + VkViewportCoordinateSwizzleNV 6 + +pattern VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV :: + VkViewportCoordinateSwizzleNV + +pattern VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV = + VkViewportCoordinateSwizzleNV 7 diff --git a/src-gen/Graphics/Vulkan/Types/Funcpointers.hs b/src-gen/Graphics/Vulkan/Types/Funcpointers.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Funcpointers.hs @@ -0,0 +1,167 @@ +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE Strict #-} +module Graphics.Vulkan.Types.Funcpointers + (PFN_vkAllocationFunction, HS_vkAllocationFunction, + newVkAllocationFunction, unwrapVkAllocationFunction, + PFN_vkDebugReportCallbackEXT, HS_vkDebugReportCallbackEXT, + newVkDebugReportCallbackEXT, unwrapVkDebugReportCallbackEXT, + PFN_vkFreeFunction, HS_vkFreeFunction, newVkFreeFunction, + unwrapVkFreeFunction, PFN_vkInternalAllocationNotification, + HS_vkInternalAllocationNotification, + newVkInternalAllocationNotification, + unwrapVkInternalAllocationNotification, + PFN_vkInternalFreeNotification, HS_vkInternalFreeNotification, + newVkInternalFreeNotification, unwrapVkInternalFreeNotification, + PFN_vkReallocationFunction, HS_vkReallocationFunction, + newVkReallocationFunction, unwrapVkReallocationFunction, + PFN_vkVoidFunction, HS_vkVoidFunction, newVkVoidFunction, + unwrapVkVoidFunction) + where +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Types.BaseTypes (VkBool32 (..), + VkFlags (..)) +import Graphics.Vulkan.Types.Enum.VkDebugReportFlagsEXT (VkDebugReportBitmaskEXT (..), + VkDebugReportFlagsEXT) +import Graphics.Vulkan.Types.Enum.VkDebugReportObjectTypeEXT (VkDebugReportObjectTypeEXT (..)) +import Graphics.Vulkan.Types.Enum.VkInternalAllocationType (VkInternalAllocationType (..)) +import Graphics.Vulkan.Types.Enum.VkSystemAllocationScope (VkSystemAllocationScope (..)) + +type HS_vkAllocationFunction = + Ptr Void -> + CSize -> CSize -> VkSystemAllocationScope -> IO (Ptr Void) + +-- | > typedef void* (VKAPI_PTR *PFN_vkAllocationFunction)( +-- > void* pUserData, +-- > size_t size, +-- > size_t alignment, +-- > VkSystemAllocationScope allocationScope); +type PFN_vkAllocationFunction = FunPtr HS_vkAllocationFunction + +-- | Wrap haskell function into C-callable FunPtr. +-- Note, you need to free resources after using it. +foreign import ccall "wrapper" newVkAllocationFunction :: + HS_vkAllocationFunction -> IO PFN_vkAllocationFunction + +foreign import ccall "dynamic" unwrapVkAllocationFunction :: + PFN_vkAllocationFunction -> HS_vkAllocationFunction + +type HS_vkDebugReportCallbackEXT = + VkDebugReportFlagsEXT -> + VkDebugReportObjectTypeEXT -> + Word64 -> + CSize -> Int32 -> CString -> CString -> Ptr Void -> IO VkBool32 + +-- | > typedef VkBool32 (VKAPI_PTR *PFN_vkDebugReportCallbackEXT)( +-- > VkDebugReportFlagsEXT flags, +-- > VkDebugReportObjectTypeEXT objectType, +-- > uint64_t object, +-- > size_t location, +-- > int32_t messageCode, +-- > const char* pLayerPrefix, +-- > const char* pMessage, +-- > void* pUserData); +type PFN_vkDebugReportCallbackEXT = + FunPtr HS_vkDebugReportCallbackEXT + +-- | Wrap haskell function into C-callable FunPtr. +-- Note, you need to free resources after using it. +foreign import ccall "wrapper" newVkDebugReportCallbackEXT :: + HS_vkDebugReportCallbackEXT -> IO PFN_vkDebugReportCallbackEXT + +foreign import ccall "dynamic" unwrapVkDebugReportCallbackEXT :: + PFN_vkDebugReportCallbackEXT -> HS_vkDebugReportCallbackEXT + +type HS_vkFreeFunction = Ptr Void -> Ptr Void -> IO () + +-- | > typedef void (VKAPI_PTR *PFN_vkFreeFunction)( +-- > void* pUserData, +-- > void* pMemory); +type PFN_vkFreeFunction = FunPtr HS_vkFreeFunction + +-- | Wrap haskell function into C-callable FunPtr. +-- Note, you need to free resources after using it. +foreign import ccall "wrapper" newVkFreeFunction :: + HS_vkFreeFunction -> IO PFN_vkFreeFunction + +foreign import ccall "dynamic" unwrapVkFreeFunction :: + PFN_vkFreeFunction -> HS_vkFreeFunction + +type HS_vkInternalAllocationNotification = + Ptr Void -> + CSize -> + VkInternalAllocationType -> VkSystemAllocationScope -> IO () + +-- | > typedef void (VKAPI_PTR *PFN_vkInternalAllocationNotification)( +-- > void* pUserData, +-- > size_t size, +-- > VkInternalAllocationType allocationType, +-- > VkSystemAllocationScope allocationScope); +type PFN_vkInternalAllocationNotification = + FunPtr HS_vkInternalAllocationNotification + +-- | Wrap haskell function into C-callable FunPtr. +-- Note, you need to free resources after using it. +foreign import ccall "wrapper" newVkInternalAllocationNotification + :: + HS_vkInternalAllocationNotification -> + IO PFN_vkInternalAllocationNotification + +foreign import ccall "dynamic" + unwrapVkInternalAllocationNotification :: + PFN_vkInternalAllocationNotification -> + HS_vkInternalAllocationNotification + +type HS_vkInternalFreeNotification = + Ptr Void -> + CSize -> + VkInternalAllocationType -> VkSystemAllocationScope -> IO () + +-- | > typedef void (VKAPI_PTR *PFN_vkInternalFreeNotification)( +-- > void* pUserData, +-- > size_t size, +-- > VkInternalAllocationType allocationType, +-- > VkSystemAllocationScope allocationScope); +type PFN_vkInternalFreeNotification = + FunPtr HS_vkInternalFreeNotification + +-- | Wrap haskell function into C-callable FunPtr. +-- Note, you need to free resources after using it. +foreign import ccall "wrapper" newVkInternalFreeNotification :: + HS_vkInternalFreeNotification -> IO PFN_vkInternalFreeNotification + +foreign import ccall "dynamic" unwrapVkInternalFreeNotification :: + PFN_vkInternalFreeNotification -> HS_vkInternalFreeNotification + +type HS_vkReallocationFunction = + Ptr Void -> + Ptr Void -> + CSize -> CSize -> VkSystemAllocationScope -> IO (Ptr Void) + +-- | > typedef void* (VKAPI_PTR *PFN_vkReallocationFunction)( +-- > void* pUserData, +-- > void* pOriginal, +-- > size_t size, +-- > size_t alignment, +-- > VkSystemAllocationScope allocationScope); +type PFN_vkReallocationFunction = FunPtr HS_vkReallocationFunction + +-- | Wrap haskell function into C-callable FunPtr. +-- Note, you need to free resources after using it. +foreign import ccall "wrapper" newVkReallocationFunction :: + HS_vkReallocationFunction -> IO PFN_vkReallocationFunction + +foreign import ccall "dynamic" unwrapVkReallocationFunction :: + PFN_vkReallocationFunction -> HS_vkReallocationFunction + +type HS_vkVoidFunction = IO () + +-- | > typedef void (VKAPI_PTR *PFN_vkVoidFunction)(void); +type PFN_vkVoidFunction = FunPtr HS_vkVoidFunction + +-- | Wrap haskell function into C-callable FunPtr. +-- Note, you need to free resources after using it. +foreign import ccall "wrapper" newVkVoidFunction :: + HS_vkVoidFunction -> IO PFN_vkVoidFunction + +foreign import ccall "dynamic" unwrapVkVoidFunction :: + PFN_vkVoidFunction -> HS_vkVoidFunction diff --git a/src-gen/Graphics/Vulkan/Types/Handles.hs b/src-gen/Graphics/Vulkan/Types/Handles.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Handles.hs @@ -0,0 +1,206 @@ +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE EmptyDataDecls #-} +{-# LANGUAGE Strict #-} +module Graphics.Vulkan.Types.Handles + (VkBuffer, VkBuffer_T(), VkBufferView, VkBufferView_T(), + VkCommandBuffer, VkCommandBuffer_T(), VkCommandPool, + VkCommandPool_T(), VkDebugReportCallbackEXT, + VkDebugReportCallbackEXT_T(), VkDescriptorPool, + VkDescriptorPool_T(), VkDescriptorSet, VkDescriptorSet_T(), + VkDescriptorSetLayout, VkDescriptorSetLayout_T(), + VkDescriptorUpdateTemplateKHR, VkDescriptorUpdateTemplateKHR_T(), + VkDevice, VkDevice_T(), VkDeviceMemory, VkDeviceMemory_T(), + VkDisplayKHR, VkDisplayKHR_T(), VkDisplayModeKHR, + VkDisplayModeKHR_T(), VkEvent, VkEvent_T(), VkFence, VkFence_T(), + VkFramebuffer, VkFramebuffer_T(), VkImage, VkImage_T(), + VkImageView, VkImageView_T(), VkIndirectCommandsLayoutNVX, + VkIndirectCommandsLayoutNVX_T(), VkInstance, VkInstance_T(), + VkObjectTableNVX, VkObjectTableNVX_T(), VkPhysicalDevice, + VkPhysicalDevice_T(), VkPipeline, VkPipeline_T(), VkPipelineCache, + VkPipelineCache_T(), VkPipelineLayout, VkPipelineLayout_T(), + VkQueryPool, VkQueryPool_T(), VkQueue, VkQueue_T(), VkRenderPass, + VkRenderPass_T(), VkSampler, VkSampler_T(), + VkSamplerYcbcrConversionKHR, VkSamplerYcbcrConversionKHR_T(), + VkSemaphore, VkSemaphore_T(), VkShaderModule, VkShaderModule_T(), + VkSurfaceKHR, VkSurfaceKHR_T(), VkSwapchainKHR, VkSwapchainKHR_T(), + VkValidationCacheEXT, VkValidationCacheEXT_T()) + where +import Graphics.Vulkan.Marshal (Ptr, VkPtr) + +type VkBuffer = VkPtr VkBuffer_T + +-- | Opaque data type referenced by VkBuffer +data VkBuffer_T + +type VkBufferView = VkPtr VkBufferView_T + +-- | Opaque data type referenced by VkBufferView +data VkBufferView_T + +type VkCommandBuffer = Ptr VkCommandBuffer_T + +-- | Opaque data type referenced by VkCommandBuffer +data VkCommandBuffer_T + +type VkCommandPool = VkPtr VkCommandPool_T + +-- | Opaque data type referenced by VkCommandPool +data VkCommandPool_T + +type VkDebugReportCallbackEXT = VkPtr VkDebugReportCallbackEXT_T + +-- | Opaque data type referenced by VkDebugReportCallbackEXT +data VkDebugReportCallbackEXT_T + +type VkDescriptorPool = VkPtr VkDescriptorPool_T + +-- | Opaque data type referenced by VkDescriptorPool +data VkDescriptorPool_T + +type VkDescriptorSet = VkPtr VkDescriptorSet_T + +-- | Opaque data type referenced by VkDescriptorSet +data VkDescriptorSet_T + +type VkDescriptorSetLayout = VkPtr VkDescriptorSetLayout_T + +-- | Opaque data type referenced by VkDescriptorSetLayout +data VkDescriptorSetLayout_T + +type VkDescriptorUpdateTemplateKHR = + VkPtr VkDescriptorUpdateTemplateKHR_T + +-- | Opaque data type referenced by VkDescriptorUpdateTemplateKHR +data VkDescriptorUpdateTemplateKHR_T + +type VkDevice = Ptr VkDevice_T + +-- | Opaque data type referenced by VkDevice +data VkDevice_T + +type VkDeviceMemory = VkPtr VkDeviceMemory_T + +-- | Opaque data type referenced by VkDeviceMemory +data VkDeviceMemory_T + +type VkDisplayKHR = VkPtr VkDisplayKHR_T + +-- | Opaque data type referenced by VkDisplayKHR +data VkDisplayKHR_T + +type VkDisplayModeKHR = VkPtr VkDisplayModeKHR_T + +-- | Opaque data type referenced by VkDisplayModeKHR +data VkDisplayModeKHR_T + +type VkEvent = VkPtr VkEvent_T + +-- | Opaque data type referenced by VkEvent +data VkEvent_T + +type VkFence = VkPtr VkFence_T + +-- | Opaque data type referenced by VkFence +data VkFence_T + +type VkFramebuffer = VkPtr VkFramebuffer_T + +-- | Opaque data type referenced by VkFramebuffer +data VkFramebuffer_T + +type VkImage = VkPtr VkImage_T + +-- | Opaque data type referenced by VkImage +data VkImage_T + +type VkImageView = VkPtr VkImageView_T + +-- | Opaque data type referenced by VkImageView +data VkImageView_T + +type VkIndirectCommandsLayoutNVX = + VkPtr VkIndirectCommandsLayoutNVX_T + +-- | Opaque data type referenced by VkIndirectCommandsLayoutNVX +data VkIndirectCommandsLayoutNVX_T + +type VkInstance = Ptr VkInstance_T + +-- | Opaque data type referenced by VkInstance +data VkInstance_T + +type VkObjectTableNVX = VkPtr VkObjectTableNVX_T + +-- | Opaque data type referenced by VkObjectTableNVX +data VkObjectTableNVX_T + +type VkPhysicalDevice = Ptr VkPhysicalDevice_T + +-- | Opaque data type referenced by VkPhysicalDevice +data VkPhysicalDevice_T + +type VkPipeline = VkPtr VkPipeline_T + +-- | Opaque data type referenced by VkPipeline +data VkPipeline_T + +type VkPipelineCache = VkPtr VkPipelineCache_T + +-- | Opaque data type referenced by VkPipelineCache +data VkPipelineCache_T + +type VkPipelineLayout = VkPtr VkPipelineLayout_T + +-- | Opaque data type referenced by VkPipelineLayout +data VkPipelineLayout_T + +type VkQueryPool = VkPtr VkQueryPool_T + +-- | Opaque data type referenced by VkQueryPool +data VkQueryPool_T + +type VkQueue = Ptr VkQueue_T + +-- | Opaque data type referenced by VkQueue +data VkQueue_T + +type VkRenderPass = VkPtr VkRenderPass_T + +-- | Opaque data type referenced by VkRenderPass +data VkRenderPass_T + +type VkSampler = VkPtr VkSampler_T + +-- | Opaque data type referenced by VkSampler +data VkSampler_T + +type VkSamplerYcbcrConversionKHR = + VkPtr VkSamplerYcbcrConversionKHR_T + +-- | Opaque data type referenced by VkSamplerYcbcrConversionKHR +data VkSamplerYcbcrConversionKHR_T + +type VkSemaphore = VkPtr VkSemaphore_T + +-- | Opaque data type referenced by VkSemaphore +data VkSemaphore_T + +type VkShaderModule = VkPtr VkShaderModule_T + +-- | Opaque data type referenced by VkShaderModule +data VkShaderModule_T + +type VkSurfaceKHR = VkPtr VkSurfaceKHR_T + +-- | Opaque data type referenced by VkSurfaceKHR +data VkSurfaceKHR_T + +type VkSwapchainKHR = VkPtr VkSwapchainKHR_T + +-- | Opaque data type referenced by VkSwapchainKHR +data VkSwapchainKHR_T + +type VkValidationCacheEXT = VkPtr VkValidationCacheEXT_T + +-- | Opaque data type referenced by VkValidationCacheEXT +data VkValidationCacheEXT_T diff --git a/src-gen/Graphics/Vulkan/Types/Include.hs b/src-gen/Graphics/Vulkan/Types/Include.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Include.hs @@ -0,0 +1,81 @@ +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE EmptyDataDecls #-} +{-# LANGUAGE Strict #-} +module Graphics.Vulkan.Types.Include + (-- > #include "vk_platform.h" + -- + -- > #include + -- + -- > #include + -- + -- > #include + -- + -- > #include + -- + -- > #include "vulkan.h" + -- + -- > #include + -- + -- > #include + -- + -- > #include + ANativeWindow, DWORD, Display, HANDLE, HINSTANCE, HWND, LPCWSTR, + MirConnection, MirSurface, RROutput, SECURITY_ATTRIBUTES, VisualID, + Window, WlDisplay, WlSurface, XcbConnectionT, XcbVisualidT, + XcbWindowT) + where +import Graphics.Vulkan.Marshal (CULong (..), CWchar (..), Ptr, Word32) + +-- | Requires @android/native_window.h@ +data ANativeWindow + +-- | Requires @windows.h@ +type DWORD = Word32 + +-- | Requires @X11/Xlib.h@ +data Display + +-- | Requires @windows.h@ +type HANDLE = Ptr () + +-- | Requires @windows.h@ +type HINSTANCE = Ptr () + +-- | Requires @windows.h@ +type HWND = Ptr () + +-- | Requires @windows.h@ +type LPCWSTR = Ptr CWchar + +-- | Requires @mir_toolkit/client_types.h@ +data MirConnection + +-- | Requires @mir_toolkit/client_types.h@ +data MirSurface + +-- | Requires @X11/extensions/Xrandr.h@ +type RROutput = CULong + +-- | Requires @windows.h@ +data SECURITY_ATTRIBUTES + +-- | Requires @X11/Xlib.h@ +type VisualID = CULong + +-- | Requires @X11/Xlib.h@ +type Window = CULong + +-- | Requires @wayland-client.h@ +data WlDisplay + +-- | Requires @wayland-client.h@ +data WlSurface + +-- | Requires @xcb/xcb.h@ +data XcbConnectionT + +-- | Requires @xcb/xcb.h@ +type XcbVisualidT = CULong + +-- | Requires @xcb/xcb.h@ +type XcbWindowT = CULong diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkAcquireNextImageInfoKHX.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkAcquireNextImageInfoKHX.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkAcquireNextImageInfoKHX.hsc @@ -0,0 +1,435 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkAcquireNextImageInfoKHX + (VkAcquireNextImageInfoKHX(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Handles (VkFence, + VkSemaphore, + VkSwapchainKHR) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkAcquireNextImageInfoKHX { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkSwapchainKHR swapchain; +-- > uint64_t timeout; +-- > VkSemaphore semaphore; +-- > VkFence fence; +-- > uint32_t deviceMask; +-- > } VkAcquireNextImageInfoKHX; +-- +-- +data VkAcquireNextImageInfoKHX = VkAcquireNextImageInfoKHX## Addr## + ByteArray## + +instance Eq VkAcquireNextImageInfoKHX where + (VkAcquireNextImageInfoKHX## a _) == + x@(VkAcquireNextImageInfoKHX## b _) = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkAcquireNextImageInfoKHX where + (VkAcquireNextImageInfoKHX## a _) `compare` + x@(VkAcquireNextImageInfoKHX## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkAcquireNextImageInfoKHX where + sizeOf ~_ = #{size VkAcquireNextImageInfoKHX} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkAcquireNextImageInfoKHX} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkAcquireNextImageInfoKHX where + unsafeAddr (VkAcquireNextImageInfoKHX## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkAcquireNextImageInfoKHX## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkAcquireNextImageInfoKHX## (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkAcquireNextImageInfoKHX where + type StructFields VkAcquireNextImageInfoKHX = + '["sType", "pNext", "swapchain", "timeout", "semaphore", "fence", -- ' closing tick for hsc2hs + "deviceMask"] + type CUnionType VkAcquireNextImageInfoKHX = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkAcquireNextImageInfoKHX = 'False -- ' closing tick for hsc2hs + type StructExtends VkAcquireNextImageInfoKHX = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkSType VkAcquireNextImageInfoKHX + where + type VkSTypeMType VkAcquireNextImageInfoKHX = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkAcquireNextImageInfoKHX, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkAcquireNextImageInfoKHX, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkAcquireNextImageInfoKHX, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkAcquireNextImageInfoKHX, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkAcquireNextImageInfoKHX where + type FieldType "sType" VkAcquireNextImageInfoKHX = VkStructureType + type FieldOptional "sType" VkAcquireNextImageInfoKHX = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkAcquireNextImageInfoKHX = + #{offset VkAcquireNextImageInfoKHX, sType} + type FieldIsArray "sType" VkAcquireNextImageInfoKHX = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkAcquireNextImageInfoKHX, sType} + +instance CanReadField "sType" VkAcquireNextImageInfoKHX where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkAcquireNextImageInfoKHX where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} HasVkPNext VkAcquireNextImageInfoKHX + where + type VkPNextMType VkAcquireNextImageInfoKHX = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkAcquireNextImageInfoKHX, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkAcquireNextImageInfoKHX, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkAcquireNextImageInfoKHX, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkAcquireNextImageInfoKHX, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkAcquireNextImageInfoKHX where + type FieldType "pNext" VkAcquireNextImageInfoKHX = Ptr Void + type FieldOptional "pNext" VkAcquireNextImageInfoKHX = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkAcquireNextImageInfoKHX = + #{offset VkAcquireNextImageInfoKHX, pNext} + type FieldIsArray "pNext" VkAcquireNextImageInfoKHX = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkAcquireNextImageInfoKHX, pNext} + +instance CanReadField "pNext" VkAcquireNextImageInfoKHX where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkAcquireNextImageInfoKHX where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkSwapchain VkAcquireNextImageInfoKHX where + type VkSwapchainMType VkAcquireNextImageInfoKHX = VkSwapchainKHR + + {-# NOINLINE vkSwapchain #-} + vkSwapchain x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkAcquireNextImageInfoKHX, swapchain}) + + {-# INLINE vkSwapchainByteOffset #-} + vkSwapchainByteOffset ~_ + = #{offset VkAcquireNextImageInfoKHX, swapchain} + + {-# INLINE readVkSwapchain #-} + readVkSwapchain p + = peekByteOff p #{offset VkAcquireNextImageInfoKHX, swapchain} + + {-# INLINE writeVkSwapchain #-} + writeVkSwapchain p + = pokeByteOff p #{offset VkAcquireNextImageInfoKHX, swapchain} + +instance {-# OVERLAPPING #-} + HasField "swapchain" VkAcquireNextImageInfoKHX where + type FieldType "swapchain" VkAcquireNextImageInfoKHX = + VkSwapchainKHR + type FieldOptional "swapchain" VkAcquireNextImageInfoKHX = 'False -- ' closing tick for hsc2hs + type FieldOffset "swapchain" VkAcquireNextImageInfoKHX = + #{offset VkAcquireNextImageInfoKHX, swapchain} + type FieldIsArray "swapchain" VkAcquireNextImageInfoKHX = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkAcquireNextImageInfoKHX, swapchain} + +instance CanReadField "swapchain" VkAcquireNextImageInfoKHX where + {-# INLINE getField #-} + getField = vkSwapchain + + {-# INLINE readField #-} + readField = readVkSwapchain + +instance CanWriteField "swapchain" VkAcquireNextImageInfoKHX where + {-# INLINE writeField #-} + writeField = writeVkSwapchain + +instance {-# OVERLAPPING #-} HasVkTimeout VkAcquireNextImageInfoKHX + where + type VkTimeoutMType VkAcquireNextImageInfoKHX = Word64 + + {-# NOINLINE vkTimeout #-} + vkTimeout x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkAcquireNextImageInfoKHX, timeout}) + + {-# INLINE vkTimeoutByteOffset #-} + vkTimeoutByteOffset ~_ + = #{offset VkAcquireNextImageInfoKHX, timeout} + + {-# INLINE readVkTimeout #-} + readVkTimeout p + = peekByteOff p #{offset VkAcquireNextImageInfoKHX, timeout} + + {-# INLINE writeVkTimeout #-} + writeVkTimeout p + = pokeByteOff p #{offset VkAcquireNextImageInfoKHX, timeout} + +instance {-# OVERLAPPING #-} + HasField "timeout" VkAcquireNextImageInfoKHX where + type FieldType "timeout" VkAcquireNextImageInfoKHX = Word64 + type FieldOptional "timeout" VkAcquireNextImageInfoKHX = 'False -- ' closing tick for hsc2hs + type FieldOffset "timeout" VkAcquireNextImageInfoKHX = + #{offset VkAcquireNextImageInfoKHX, timeout} + type FieldIsArray "timeout" VkAcquireNextImageInfoKHX = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkAcquireNextImageInfoKHX, timeout} + +instance CanReadField "timeout" VkAcquireNextImageInfoKHX where + {-# INLINE getField #-} + getField = vkTimeout + + {-# INLINE readField #-} + readField = readVkTimeout + +instance CanWriteField "timeout" VkAcquireNextImageInfoKHX where + {-# INLINE writeField #-} + writeField = writeVkTimeout + +instance {-# OVERLAPPING #-} + HasVkSemaphore VkAcquireNextImageInfoKHX where + type VkSemaphoreMType VkAcquireNextImageInfoKHX = VkSemaphore + + {-# NOINLINE vkSemaphore #-} + vkSemaphore x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkAcquireNextImageInfoKHX, semaphore}) + + {-# INLINE vkSemaphoreByteOffset #-} + vkSemaphoreByteOffset ~_ + = #{offset VkAcquireNextImageInfoKHX, semaphore} + + {-# INLINE readVkSemaphore #-} + readVkSemaphore p + = peekByteOff p #{offset VkAcquireNextImageInfoKHX, semaphore} + + {-# INLINE writeVkSemaphore #-} + writeVkSemaphore p + = pokeByteOff p #{offset VkAcquireNextImageInfoKHX, semaphore} + +instance {-# OVERLAPPING #-} + HasField "semaphore" VkAcquireNextImageInfoKHX where + type FieldType "semaphore" VkAcquireNextImageInfoKHX = VkSemaphore + type FieldOptional "semaphore" VkAcquireNextImageInfoKHX = 'True -- ' closing tick for hsc2hs + type FieldOffset "semaphore" VkAcquireNextImageInfoKHX = + #{offset VkAcquireNextImageInfoKHX, semaphore} + type FieldIsArray "semaphore" VkAcquireNextImageInfoKHX = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkAcquireNextImageInfoKHX, semaphore} + +instance CanReadField "semaphore" VkAcquireNextImageInfoKHX where + {-# INLINE getField #-} + getField = vkSemaphore + + {-# INLINE readField #-} + readField = readVkSemaphore + +instance CanWriteField "semaphore" VkAcquireNextImageInfoKHX where + {-# INLINE writeField #-} + writeField = writeVkSemaphore + +instance {-# OVERLAPPING #-} HasVkFence VkAcquireNextImageInfoKHX + where + type VkFenceMType VkAcquireNextImageInfoKHX = VkFence + + {-# NOINLINE vkFence #-} + vkFence x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkAcquireNextImageInfoKHX, fence}) + + {-# INLINE vkFenceByteOffset #-} + vkFenceByteOffset ~_ + = #{offset VkAcquireNextImageInfoKHX, fence} + + {-# INLINE readVkFence #-} + readVkFence p + = peekByteOff p #{offset VkAcquireNextImageInfoKHX, fence} + + {-# INLINE writeVkFence #-} + writeVkFence p + = pokeByteOff p #{offset VkAcquireNextImageInfoKHX, fence} + +instance {-# OVERLAPPING #-} + HasField "fence" VkAcquireNextImageInfoKHX where + type FieldType "fence" VkAcquireNextImageInfoKHX = VkFence + type FieldOptional "fence" VkAcquireNextImageInfoKHX = 'True -- ' closing tick for hsc2hs + type FieldOffset "fence" VkAcquireNextImageInfoKHX = + #{offset VkAcquireNextImageInfoKHX, fence} + type FieldIsArray "fence" VkAcquireNextImageInfoKHX = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkAcquireNextImageInfoKHX, fence} + +instance CanReadField "fence" VkAcquireNextImageInfoKHX where + {-# INLINE getField #-} + getField = vkFence + + {-# INLINE readField #-} + readField = readVkFence + +instance CanWriteField "fence" VkAcquireNextImageInfoKHX where + {-# INLINE writeField #-} + writeField = writeVkFence + +instance {-# OVERLAPPING #-} + HasVkDeviceMask VkAcquireNextImageInfoKHX where + type VkDeviceMaskMType VkAcquireNextImageInfoKHX = Word32 + + {-# NOINLINE vkDeviceMask #-} + vkDeviceMask x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkAcquireNextImageInfoKHX, deviceMask}) + + {-# INLINE vkDeviceMaskByteOffset #-} + vkDeviceMaskByteOffset ~_ + = #{offset VkAcquireNextImageInfoKHX, deviceMask} + + {-# INLINE readVkDeviceMask #-} + readVkDeviceMask p + = peekByteOff p #{offset VkAcquireNextImageInfoKHX, deviceMask} + + {-# INLINE writeVkDeviceMask #-} + writeVkDeviceMask p + = pokeByteOff p #{offset VkAcquireNextImageInfoKHX, deviceMask} + +instance {-# OVERLAPPING #-} + HasField "deviceMask" VkAcquireNextImageInfoKHX where + type FieldType "deviceMask" VkAcquireNextImageInfoKHX = Word32 + type FieldOptional "deviceMask" VkAcquireNextImageInfoKHX = 'False -- ' closing tick for hsc2hs + type FieldOffset "deviceMask" VkAcquireNextImageInfoKHX = + #{offset VkAcquireNextImageInfoKHX, deviceMask} + type FieldIsArray "deviceMask" VkAcquireNextImageInfoKHX = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkAcquireNextImageInfoKHX, deviceMask} + +instance CanReadField "deviceMask" VkAcquireNextImageInfoKHX where + {-# INLINE getField #-} + getField = vkDeviceMask + + {-# INLINE readField #-} + readField = readVkDeviceMask + +instance CanWriteField "deviceMask" VkAcquireNextImageInfoKHX where + {-# INLINE writeField #-} + writeField = writeVkDeviceMask + +instance Show VkAcquireNextImageInfoKHX where + showsPrec d x + = showString "VkAcquireNextImageInfoKHX {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkSwapchain = " . + showsPrec d (vkSwapchain x) . + showString ", " . + showString "vkTimeout = " . + showsPrec d (vkTimeout x) . + showString ", " . + showString "vkSemaphore = " . + showsPrec d (vkSemaphore x) . + showString ", " . + showString "vkFence = " . + showsPrec d (vkFence x) . + showString ", " . + showString "vkDeviceMask = " . + showsPrec d (vkDeviceMask x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkAllocationCallbacks.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkAllocationCallbacks.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkAllocationCallbacks.hsc @@ -0,0 +1,397 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkAllocationCallbacks + (VkAllocationCallbacks(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Funcpointers (PFN_vkAllocationFunction, + PFN_vkFreeFunction, + PFN_vkInternalAllocationNotification, + PFN_vkInternalFreeNotification, + PFN_vkReallocationFunction) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkAllocationCallbacks { +-- > void* pUserData; +-- > PFN_vkAllocationFunction pfnAllocation; +-- > PFN_vkReallocationFunction pfnReallocation; +-- > PFN_vkFreeFunction pfnFree; +-- > PFN_vkInternalAllocationNotification pfnInternalAllocation; +-- > PFN_vkInternalFreeNotification pfnInternalFree; +-- > } VkAllocationCallbacks; +-- +-- +data VkAllocationCallbacks = VkAllocationCallbacks## Addr## + ByteArray## + +instance Eq VkAllocationCallbacks where + (VkAllocationCallbacks## a _) == x@(VkAllocationCallbacks## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkAllocationCallbacks where + (VkAllocationCallbacks## a _) `compare` + x@(VkAllocationCallbacks## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkAllocationCallbacks where + sizeOf ~_ = #{size VkAllocationCallbacks} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkAllocationCallbacks} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkAllocationCallbacks where + unsafeAddr (VkAllocationCallbacks## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkAllocationCallbacks## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkAllocationCallbacks## (plusAddr## (byteArrayContents## b) off) b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkAllocationCallbacks where + type StructFields VkAllocationCallbacks = + '["pUserData", "pfnAllocation", "pfnReallocation", "pfnFree", -- ' closing tick for hsc2hs + "pfnInternalAllocation", "pfnInternalFree"] + type CUnionType VkAllocationCallbacks = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkAllocationCallbacks = 'False -- ' closing tick for hsc2hs + type StructExtends VkAllocationCallbacks = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkPUserData VkAllocationCallbacks + where + type VkPUserDataMType VkAllocationCallbacks = Ptr Void + + {-# NOINLINE vkPUserData #-} + vkPUserData x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkAllocationCallbacks, pUserData}) + + {-# INLINE vkPUserDataByteOffset #-} + vkPUserDataByteOffset ~_ + = #{offset VkAllocationCallbacks, pUserData} + + {-# INLINE readVkPUserData #-} + readVkPUserData p + = peekByteOff p #{offset VkAllocationCallbacks, pUserData} + + {-# INLINE writeVkPUserData #-} + writeVkPUserData p + = pokeByteOff p #{offset VkAllocationCallbacks, pUserData} + +instance {-# OVERLAPPING #-} + HasField "pUserData" VkAllocationCallbacks where + type FieldType "pUserData" VkAllocationCallbacks = Ptr Void + type FieldOptional "pUserData" VkAllocationCallbacks = 'True -- ' closing tick for hsc2hs + type FieldOffset "pUserData" VkAllocationCallbacks = + #{offset VkAllocationCallbacks, pUserData} + type FieldIsArray "pUserData" VkAllocationCallbacks = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkAllocationCallbacks, pUserData} + +instance CanReadField "pUserData" VkAllocationCallbacks where + {-# INLINE getField #-} + getField = vkPUserData + + {-# INLINE readField #-} + readField = readVkPUserData + +instance CanWriteField "pUserData" VkAllocationCallbacks where + {-# INLINE writeField #-} + writeField = writeVkPUserData + +instance {-# OVERLAPPING #-} + HasVkPfnAllocation VkAllocationCallbacks where + type VkPfnAllocationMType VkAllocationCallbacks = + PFN_vkAllocationFunction + + {-# NOINLINE vkPfnAllocation #-} + vkPfnAllocation x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkAllocationCallbacks, pfnAllocation}) + + {-# INLINE vkPfnAllocationByteOffset #-} + vkPfnAllocationByteOffset ~_ + = #{offset VkAllocationCallbacks, pfnAllocation} + + {-# INLINE readVkPfnAllocation #-} + readVkPfnAllocation p + = peekByteOff p #{offset VkAllocationCallbacks, pfnAllocation} + + {-# INLINE writeVkPfnAllocation #-} + writeVkPfnAllocation p + = pokeByteOff p #{offset VkAllocationCallbacks, pfnAllocation} + +instance {-# OVERLAPPING #-} + HasField "pfnAllocation" VkAllocationCallbacks where + type FieldType "pfnAllocation" VkAllocationCallbacks = + PFN_vkAllocationFunction + type FieldOptional "pfnAllocation" VkAllocationCallbacks = 'False -- ' closing tick for hsc2hs + type FieldOffset "pfnAllocation" VkAllocationCallbacks = + #{offset VkAllocationCallbacks, pfnAllocation} + type FieldIsArray "pfnAllocation" VkAllocationCallbacks = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkAllocationCallbacks, pfnAllocation} + +instance CanReadField "pfnAllocation" VkAllocationCallbacks where + {-# INLINE getField #-} + getField = vkPfnAllocation + + {-# INLINE readField #-} + readField = readVkPfnAllocation + +instance CanWriteField "pfnAllocation" VkAllocationCallbacks where + {-# INLINE writeField #-} + writeField = writeVkPfnAllocation + +instance {-# OVERLAPPING #-} + HasVkPfnReallocation VkAllocationCallbacks where + type VkPfnReallocationMType VkAllocationCallbacks = + PFN_vkReallocationFunction + + {-# NOINLINE vkPfnReallocation #-} + vkPfnReallocation x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkAllocationCallbacks, pfnReallocation}) + + {-# INLINE vkPfnReallocationByteOffset #-} + vkPfnReallocationByteOffset ~_ + = #{offset VkAllocationCallbacks, pfnReallocation} + + {-# INLINE readVkPfnReallocation #-} + readVkPfnReallocation p + = peekByteOff p #{offset VkAllocationCallbacks, pfnReallocation} + + {-# INLINE writeVkPfnReallocation #-} + writeVkPfnReallocation p + = pokeByteOff p #{offset VkAllocationCallbacks, pfnReallocation} + +instance {-# OVERLAPPING #-} + HasField "pfnReallocation" VkAllocationCallbacks where + type FieldType "pfnReallocation" VkAllocationCallbacks = + PFN_vkReallocationFunction + type FieldOptional "pfnReallocation" VkAllocationCallbacks = 'False -- ' closing tick for hsc2hs + type FieldOffset "pfnReallocation" VkAllocationCallbacks = + #{offset VkAllocationCallbacks, pfnReallocation} + type FieldIsArray "pfnReallocation" VkAllocationCallbacks = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkAllocationCallbacks, pfnReallocation} + +instance CanReadField "pfnReallocation" VkAllocationCallbacks where + {-# INLINE getField #-} + getField = vkPfnReallocation + + {-# INLINE readField #-} + readField = readVkPfnReallocation + +instance CanWriteField "pfnReallocation" VkAllocationCallbacks + where + {-# INLINE writeField #-} + writeField = writeVkPfnReallocation + +instance {-# OVERLAPPING #-} HasVkPfnFree VkAllocationCallbacks + where + type VkPfnFreeMType VkAllocationCallbacks = PFN_vkFreeFunction + + {-# NOINLINE vkPfnFree #-} + vkPfnFree x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkAllocationCallbacks, pfnFree}) + + {-# INLINE vkPfnFreeByteOffset #-} + vkPfnFreeByteOffset ~_ + = #{offset VkAllocationCallbacks, pfnFree} + + {-# INLINE readVkPfnFree #-} + readVkPfnFree p + = peekByteOff p #{offset VkAllocationCallbacks, pfnFree} + + {-# INLINE writeVkPfnFree #-} + writeVkPfnFree p + = pokeByteOff p #{offset VkAllocationCallbacks, pfnFree} + +instance {-# OVERLAPPING #-} + HasField "pfnFree" VkAllocationCallbacks where + type FieldType "pfnFree" VkAllocationCallbacks = PFN_vkFreeFunction + type FieldOptional "pfnFree" VkAllocationCallbacks = 'False -- ' closing tick for hsc2hs + type FieldOffset "pfnFree" VkAllocationCallbacks = + #{offset VkAllocationCallbacks, pfnFree} + type FieldIsArray "pfnFree" VkAllocationCallbacks = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkAllocationCallbacks, pfnFree} + +instance CanReadField "pfnFree" VkAllocationCallbacks where + {-# INLINE getField #-} + getField = vkPfnFree + + {-# INLINE readField #-} + readField = readVkPfnFree + +instance CanWriteField "pfnFree" VkAllocationCallbacks where + {-# INLINE writeField #-} + writeField = writeVkPfnFree + +instance {-# OVERLAPPING #-} + HasVkPfnInternalAllocation VkAllocationCallbacks where + type VkPfnInternalAllocationMType VkAllocationCallbacks = + PFN_vkInternalAllocationNotification + + {-# NOINLINE vkPfnInternalAllocation #-} + vkPfnInternalAllocation x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkAllocationCallbacks, pfnInternalAllocation}) + + {-# INLINE vkPfnInternalAllocationByteOffset #-} + vkPfnInternalAllocationByteOffset ~_ + = #{offset VkAllocationCallbacks, pfnInternalAllocation} + + {-# INLINE readVkPfnInternalAllocation #-} + readVkPfnInternalAllocation p + = peekByteOff p #{offset VkAllocationCallbacks, pfnInternalAllocation} + + {-# INLINE writeVkPfnInternalAllocation #-} + writeVkPfnInternalAllocation p + = pokeByteOff p #{offset VkAllocationCallbacks, pfnInternalAllocation} + +instance {-# OVERLAPPING #-} + HasField "pfnInternalAllocation" VkAllocationCallbacks where + type FieldType "pfnInternalAllocation" VkAllocationCallbacks = + PFN_vkInternalAllocationNotification + type FieldOptional "pfnInternalAllocation" VkAllocationCallbacks = + 'True -- ' closing tick for hsc2hs + type FieldOffset "pfnInternalAllocation" VkAllocationCallbacks = + #{offset VkAllocationCallbacks, pfnInternalAllocation} + type FieldIsArray "pfnInternalAllocation" VkAllocationCallbacks = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkAllocationCallbacks, pfnInternalAllocation} + +instance CanReadField "pfnInternalAllocation" VkAllocationCallbacks + where + {-# INLINE getField #-} + getField = vkPfnInternalAllocation + + {-# INLINE readField #-} + readField = readVkPfnInternalAllocation + +instance CanWriteField "pfnInternalAllocation" + VkAllocationCallbacks + where + {-# INLINE writeField #-} + writeField = writeVkPfnInternalAllocation + +instance {-# OVERLAPPING #-} + HasVkPfnInternalFree VkAllocationCallbacks where + type VkPfnInternalFreeMType VkAllocationCallbacks = + PFN_vkInternalFreeNotification + + {-# NOINLINE vkPfnInternalFree #-} + vkPfnInternalFree x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkAllocationCallbacks, pfnInternalFree}) + + {-# INLINE vkPfnInternalFreeByteOffset #-} + vkPfnInternalFreeByteOffset ~_ + = #{offset VkAllocationCallbacks, pfnInternalFree} + + {-# INLINE readVkPfnInternalFree #-} + readVkPfnInternalFree p + = peekByteOff p #{offset VkAllocationCallbacks, pfnInternalFree} + + {-# INLINE writeVkPfnInternalFree #-} + writeVkPfnInternalFree p + = pokeByteOff p #{offset VkAllocationCallbacks, pfnInternalFree} + +instance {-# OVERLAPPING #-} + HasField "pfnInternalFree" VkAllocationCallbacks where + type FieldType "pfnInternalFree" VkAllocationCallbacks = + PFN_vkInternalFreeNotification + type FieldOptional "pfnInternalFree" VkAllocationCallbacks = 'True -- ' closing tick for hsc2hs + type FieldOffset "pfnInternalFree" VkAllocationCallbacks = + #{offset VkAllocationCallbacks, pfnInternalFree} + type FieldIsArray "pfnInternalFree" VkAllocationCallbacks = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkAllocationCallbacks, pfnInternalFree} + +instance CanReadField "pfnInternalFree" VkAllocationCallbacks where + {-# INLINE getField #-} + getField = vkPfnInternalFree + + {-# INLINE readField #-} + readField = readVkPfnInternalFree + +instance CanWriteField "pfnInternalFree" VkAllocationCallbacks + where + {-# INLINE writeField #-} + writeField = writeVkPfnInternalFree + +instance Show VkAllocationCallbacks where + showsPrec d x + = showString "VkAllocationCallbacks {" . + showString "vkPUserData = " . + showsPrec d (vkPUserData x) . + showString ", " . + showString "vkPfnAllocation = " . + showsPrec d (vkPfnAllocation x) . + showString ", " . + showString "vkPfnReallocation = " . + showsPrec d (vkPfnReallocation x) . + showString ", " . + showString "vkPfnFree = " . + showsPrec d (vkPfnFree x) . + showString ", " . + showString "vkPfnInternalAllocation = " . + showsPrec d (vkPfnInternalAllocation x) . + showString ", " . + showString "vkPfnInternalFree = " . + showsPrec d (vkPfnInternalFree x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkAndroidSurfaceCreateInfoKHR.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkAndroidSurfaceCreateInfoKHR.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkAndroidSurfaceCreateInfoKHR.hsc @@ -0,0 +1,286 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkAndroidSurfaceCreateInfoKHR + (VkAndroidSurfaceCreateInfoKHR(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Bitmasks (VkAndroidSurfaceCreateFlagsKHR) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Include (ANativeWindow) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkAndroidSurfaceCreateInfoKHR { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkAndroidSurfaceCreateFlagsKHR flags; +-- > ANativeWindow* window; +-- > } VkAndroidSurfaceCreateInfoKHR; +-- +-- +data VkAndroidSurfaceCreateInfoKHR = VkAndroidSurfaceCreateInfoKHR## Addr## + ByteArray## + +instance Eq VkAndroidSurfaceCreateInfoKHR where + (VkAndroidSurfaceCreateInfoKHR## a _) == + x@(VkAndroidSurfaceCreateInfoKHR## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkAndroidSurfaceCreateInfoKHR where + (VkAndroidSurfaceCreateInfoKHR## a _) `compare` + x@(VkAndroidSurfaceCreateInfoKHR## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkAndroidSurfaceCreateInfoKHR where + sizeOf ~_ = #{size VkAndroidSurfaceCreateInfoKHR} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkAndroidSurfaceCreateInfoKHR} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkAndroidSurfaceCreateInfoKHR where + unsafeAddr (VkAndroidSurfaceCreateInfoKHR## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkAndroidSurfaceCreateInfoKHR## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkAndroidSurfaceCreateInfoKHR## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkAndroidSurfaceCreateInfoKHR where + type StructFields VkAndroidSurfaceCreateInfoKHR = + '["sType", "pNext", "flags", "window"] -- ' closing tick for hsc2hs + type CUnionType VkAndroidSurfaceCreateInfoKHR = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkAndroidSurfaceCreateInfoKHR = 'False -- ' closing tick for hsc2hs + type StructExtends VkAndroidSurfaceCreateInfoKHR = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkAndroidSurfaceCreateInfoKHR where + type VkSTypeMType VkAndroidSurfaceCreateInfoKHR = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkAndroidSurfaceCreateInfoKHR, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkAndroidSurfaceCreateInfoKHR, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkAndroidSurfaceCreateInfoKHR, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkAndroidSurfaceCreateInfoKHR, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkAndroidSurfaceCreateInfoKHR where + type FieldType "sType" VkAndroidSurfaceCreateInfoKHR = + VkStructureType + type FieldOptional "sType" VkAndroidSurfaceCreateInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkAndroidSurfaceCreateInfoKHR = + #{offset VkAndroidSurfaceCreateInfoKHR, sType} + type FieldIsArray "sType" VkAndroidSurfaceCreateInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkAndroidSurfaceCreateInfoKHR, sType} + +instance CanReadField "sType" VkAndroidSurfaceCreateInfoKHR where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkAndroidSurfaceCreateInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkAndroidSurfaceCreateInfoKHR where + type VkPNextMType VkAndroidSurfaceCreateInfoKHR = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkAndroidSurfaceCreateInfoKHR, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkAndroidSurfaceCreateInfoKHR, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkAndroidSurfaceCreateInfoKHR, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkAndroidSurfaceCreateInfoKHR, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkAndroidSurfaceCreateInfoKHR where + type FieldType "pNext" VkAndroidSurfaceCreateInfoKHR = Ptr Void + type FieldOptional "pNext" VkAndroidSurfaceCreateInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkAndroidSurfaceCreateInfoKHR = + #{offset VkAndroidSurfaceCreateInfoKHR, pNext} + type FieldIsArray "pNext" VkAndroidSurfaceCreateInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkAndroidSurfaceCreateInfoKHR, pNext} + +instance CanReadField "pNext" VkAndroidSurfaceCreateInfoKHR where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkAndroidSurfaceCreateInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkFlags VkAndroidSurfaceCreateInfoKHR where + type VkFlagsMType VkAndroidSurfaceCreateInfoKHR = + VkAndroidSurfaceCreateFlagsKHR + + {-# NOINLINE vkFlags #-} + vkFlags x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkAndroidSurfaceCreateInfoKHR, flags}) + + {-# INLINE vkFlagsByteOffset #-} + vkFlagsByteOffset ~_ + = #{offset VkAndroidSurfaceCreateInfoKHR, flags} + + {-# INLINE readVkFlags #-} + readVkFlags p + = peekByteOff p #{offset VkAndroidSurfaceCreateInfoKHR, flags} + + {-# INLINE writeVkFlags #-} + writeVkFlags p + = pokeByteOff p #{offset VkAndroidSurfaceCreateInfoKHR, flags} + +instance {-# OVERLAPPING #-} + HasField "flags" VkAndroidSurfaceCreateInfoKHR where + type FieldType "flags" VkAndroidSurfaceCreateInfoKHR = + VkAndroidSurfaceCreateFlagsKHR + type FieldOptional "flags" VkAndroidSurfaceCreateInfoKHR = 'True -- ' closing tick for hsc2hs + type FieldOffset "flags" VkAndroidSurfaceCreateInfoKHR = + #{offset VkAndroidSurfaceCreateInfoKHR, flags} + type FieldIsArray "flags" VkAndroidSurfaceCreateInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkAndroidSurfaceCreateInfoKHR, flags} + +instance CanReadField "flags" VkAndroidSurfaceCreateInfoKHR where + {-# INLINE getField #-} + getField = vkFlags + + {-# INLINE readField #-} + readField = readVkFlags + +instance CanWriteField "flags" VkAndroidSurfaceCreateInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkFlags + +instance {-# OVERLAPPING #-} + HasVkWindow VkAndroidSurfaceCreateInfoKHR where + type VkWindowMType VkAndroidSurfaceCreateInfoKHR = + Ptr ANativeWindow + + {-# NOINLINE vkWindow #-} + vkWindow x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkAndroidSurfaceCreateInfoKHR, window}) + + {-# INLINE vkWindowByteOffset #-} + vkWindowByteOffset ~_ + = #{offset VkAndroidSurfaceCreateInfoKHR, window} + + {-# INLINE readVkWindow #-} + readVkWindow p + = peekByteOff p #{offset VkAndroidSurfaceCreateInfoKHR, window} + + {-# INLINE writeVkWindow #-} + writeVkWindow p + = pokeByteOff p #{offset VkAndroidSurfaceCreateInfoKHR, window} + +instance {-# OVERLAPPING #-} + HasField "window" VkAndroidSurfaceCreateInfoKHR where + type FieldType "window" VkAndroidSurfaceCreateInfoKHR = + Ptr ANativeWindow + type FieldOptional "window" VkAndroidSurfaceCreateInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "window" VkAndroidSurfaceCreateInfoKHR = + #{offset VkAndroidSurfaceCreateInfoKHR, window} + type FieldIsArray "window" VkAndroidSurfaceCreateInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkAndroidSurfaceCreateInfoKHR, window} + +instance CanReadField "window" VkAndroidSurfaceCreateInfoKHR where + {-# INLINE getField #-} + getField = vkWindow + + {-# INLINE readField #-} + readField = readVkWindow + +instance CanWriteField "window" VkAndroidSurfaceCreateInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkWindow + +instance Show VkAndroidSurfaceCreateInfoKHR where + showsPrec d x + = showString "VkAndroidSurfaceCreateInfoKHR {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkFlags = " . + showsPrec d (vkFlags x) . + showString ", " . + showString "vkWindow = " . showsPrec d (vkWindow x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkApplicationInfo.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkApplicationInfo.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkApplicationInfo.hsc @@ -0,0 +1,423 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkApplicationInfo + (VkApplicationInfo(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkApplicationInfo { +-- > VkStructureType sType; +-- > const void* pNext; +-- > const char* pApplicationName; +-- > uint32_t applicationVersion; +-- > const char* pEngineName; +-- > uint32_t engineVersion; +-- > uint32_t apiVersion; +-- > } VkApplicationInfo; +-- +-- +data VkApplicationInfo = VkApplicationInfo## Addr## ByteArray## + +instance Eq VkApplicationInfo where + (VkApplicationInfo## a _) == x@(VkApplicationInfo## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkApplicationInfo where + (VkApplicationInfo## a _) `compare` x@(VkApplicationInfo## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkApplicationInfo where + sizeOf ~_ = #{size VkApplicationInfo} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkApplicationInfo} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkApplicationInfo where + unsafeAddr (VkApplicationInfo## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkApplicationInfo## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkApplicationInfo## (plusAddr## (byteArrayContents## b) off) b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkApplicationInfo where + type StructFields VkApplicationInfo = + '["sType", "pNext", "pApplicationName", "applicationVersion", -- ' closing tick for hsc2hs + "pEngineName", "engineVersion", "apiVersion"] + type CUnionType VkApplicationInfo = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkApplicationInfo = 'False -- ' closing tick for hsc2hs + type StructExtends VkApplicationInfo = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkSType VkApplicationInfo where + type VkSTypeMType VkApplicationInfo = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkApplicationInfo, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkApplicationInfo, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkApplicationInfo, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkApplicationInfo, sType} + +instance {-# OVERLAPPING #-} HasField "sType" VkApplicationInfo + where + type FieldType "sType" VkApplicationInfo = VkStructureType + type FieldOptional "sType" VkApplicationInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkApplicationInfo = + #{offset VkApplicationInfo, sType} + type FieldIsArray "sType" VkApplicationInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkApplicationInfo, sType} + +instance CanReadField "sType" VkApplicationInfo where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkApplicationInfo where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} HasVkPNext VkApplicationInfo where + type VkPNextMType VkApplicationInfo = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkApplicationInfo, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkApplicationInfo, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkApplicationInfo, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkApplicationInfo, pNext} + +instance {-# OVERLAPPING #-} HasField "pNext" VkApplicationInfo + where + type FieldType "pNext" VkApplicationInfo = Ptr Void + type FieldOptional "pNext" VkApplicationInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkApplicationInfo = + #{offset VkApplicationInfo, pNext} + type FieldIsArray "pNext" VkApplicationInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkApplicationInfo, pNext} + +instance CanReadField "pNext" VkApplicationInfo where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkApplicationInfo where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkPApplicationName VkApplicationInfo where + type VkPApplicationNameMType VkApplicationInfo = CString + + {-# NOINLINE vkPApplicationName #-} + vkPApplicationName x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkApplicationInfo, pApplicationName}) + + {-# INLINE vkPApplicationNameByteOffset #-} + vkPApplicationNameByteOffset ~_ + = #{offset VkApplicationInfo, pApplicationName} + + {-# INLINE readVkPApplicationName #-} + readVkPApplicationName p + = peekByteOff p #{offset VkApplicationInfo, pApplicationName} + + {-# INLINE writeVkPApplicationName #-} + writeVkPApplicationName p + = pokeByteOff p #{offset VkApplicationInfo, pApplicationName} + +instance {-# OVERLAPPING #-} + HasField "pApplicationName" VkApplicationInfo where + type FieldType "pApplicationName" VkApplicationInfo = CString + type FieldOptional "pApplicationName" VkApplicationInfo = 'True -- ' closing tick for hsc2hs + type FieldOffset "pApplicationName" VkApplicationInfo = + #{offset VkApplicationInfo, pApplicationName} + type FieldIsArray "pApplicationName" VkApplicationInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkApplicationInfo, pApplicationName} + +instance CanReadField "pApplicationName" VkApplicationInfo where + {-# INLINE getField #-} + getField = vkPApplicationName + + {-# INLINE readField #-} + readField = readVkPApplicationName + +instance CanWriteField "pApplicationName" VkApplicationInfo where + {-# INLINE writeField #-} + writeField = writeVkPApplicationName + +instance {-# OVERLAPPING #-} + HasVkApplicationVersion VkApplicationInfo where + type VkApplicationVersionMType VkApplicationInfo = Word32 + + {-# NOINLINE vkApplicationVersion #-} + vkApplicationVersion x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkApplicationInfo, applicationVersion}) + + {-# INLINE vkApplicationVersionByteOffset #-} + vkApplicationVersionByteOffset ~_ + = #{offset VkApplicationInfo, applicationVersion} + + {-# INLINE readVkApplicationVersion #-} + readVkApplicationVersion p + = peekByteOff p #{offset VkApplicationInfo, applicationVersion} + + {-# INLINE writeVkApplicationVersion #-} + writeVkApplicationVersion p + = pokeByteOff p #{offset VkApplicationInfo, applicationVersion} + +instance {-# OVERLAPPING #-} + HasField "applicationVersion" VkApplicationInfo where + type FieldType "applicationVersion" VkApplicationInfo = Word32 + type FieldOptional "applicationVersion" VkApplicationInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "applicationVersion" VkApplicationInfo = + #{offset VkApplicationInfo, applicationVersion} + type FieldIsArray "applicationVersion" VkApplicationInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkApplicationInfo, applicationVersion} + +instance CanReadField "applicationVersion" VkApplicationInfo where + {-# INLINE getField #-} + getField = vkApplicationVersion + + {-# INLINE readField #-} + readField = readVkApplicationVersion + +instance CanWriteField "applicationVersion" VkApplicationInfo where + {-# INLINE writeField #-} + writeField = writeVkApplicationVersion + +instance {-# OVERLAPPING #-} HasVkPEngineName VkApplicationInfo + where + type VkPEngineNameMType VkApplicationInfo = CString + + {-# NOINLINE vkPEngineName #-} + vkPEngineName x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkApplicationInfo, pEngineName}) + + {-# INLINE vkPEngineNameByteOffset #-} + vkPEngineNameByteOffset ~_ + = #{offset VkApplicationInfo, pEngineName} + + {-# INLINE readVkPEngineName #-} + readVkPEngineName p + = peekByteOff p #{offset VkApplicationInfo, pEngineName} + + {-# INLINE writeVkPEngineName #-} + writeVkPEngineName p + = pokeByteOff p #{offset VkApplicationInfo, pEngineName} + +instance {-# OVERLAPPING #-} + HasField "pEngineName" VkApplicationInfo where + type FieldType "pEngineName" VkApplicationInfo = CString + type FieldOptional "pEngineName" VkApplicationInfo = 'True -- ' closing tick for hsc2hs + type FieldOffset "pEngineName" VkApplicationInfo = + #{offset VkApplicationInfo, pEngineName} + type FieldIsArray "pEngineName" VkApplicationInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkApplicationInfo, pEngineName} + +instance CanReadField "pEngineName" VkApplicationInfo where + {-# INLINE getField #-} + getField = vkPEngineName + + {-# INLINE readField #-} + readField = readVkPEngineName + +instance CanWriteField "pEngineName" VkApplicationInfo where + {-# INLINE writeField #-} + writeField = writeVkPEngineName + +instance {-# OVERLAPPING #-} HasVkEngineVersion VkApplicationInfo + where + type VkEngineVersionMType VkApplicationInfo = Word32 + + {-# NOINLINE vkEngineVersion #-} + vkEngineVersion x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkApplicationInfo, engineVersion}) + + {-# INLINE vkEngineVersionByteOffset #-} + vkEngineVersionByteOffset ~_ + = #{offset VkApplicationInfo, engineVersion} + + {-# INLINE readVkEngineVersion #-} + readVkEngineVersion p + = peekByteOff p #{offset VkApplicationInfo, engineVersion} + + {-# INLINE writeVkEngineVersion #-} + writeVkEngineVersion p + = pokeByteOff p #{offset VkApplicationInfo, engineVersion} + +instance {-# OVERLAPPING #-} + HasField "engineVersion" VkApplicationInfo where + type FieldType "engineVersion" VkApplicationInfo = Word32 + type FieldOptional "engineVersion" VkApplicationInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "engineVersion" VkApplicationInfo = + #{offset VkApplicationInfo, engineVersion} + type FieldIsArray "engineVersion" VkApplicationInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkApplicationInfo, engineVersion} + +instance CanReadField "engineVersion" VkApplicationInfo where + {-# INLINE getField #-} + getField = vkEngineVersion + + {-# INLINE readField #-} + readField = readVkEngineVersion + +instance CanWriteField "engineVersion" VkApplicationInfo where + {-# INLINE writeField #-} + writeField = writeVkEngineVersion + +instance {-# OVERLAPPING #-} HasVkApiVersion VkApplicationInfo + where + type VkApiVersionMType VkApplicationInfo = Word32 + + {-# NOINLINE vkApiVersion #-} + vkApiVersion x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkApplicationInfo, apiVersion}) + + {-# INLINE vkApiVersionByteOffset #-} + vkApiVersionByteOffset ~_ + = #{offset VkApplicationInfo, apiVersion} + + {-# INLINE readVkApiVersion #-} + readVkApiVersion p + = peekByteOff p #{offset VkApplicationInfo, apiVersion} + + {-# INLINE writeVkApiVersion #-} + writeVkApiVersion p + = pokeByteOff p #{offset VkApplicationInfo, apiVersion} + +instance {-# OVERLAPPING #-} + HasField "apiVersion" VkApplicationInfo where + type FieldType "apiVersion" VkApplicationInfo = Word32 + type FieldOptional "apiVersion" VkApplicationInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "apiVersion" VkApplicationInfo = + #{offset VkApplicationInfo, apiVersion} + type FieldIsArray "apiVersion" VkApplicationInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkApplicationInfo, apiVersion} + +instance CanReadField "apiVersion" VkApplicationInfo where + {-# INLINE getField #-} + getField = vkApiVersion + + {-# INLINE readField #-} + readField = readVkApiVersion + +instance CanWriteField "apiVersion" VkApplicationInfo where + {-# INLINE writeField #-} + writeField = writeVkApiVersion + +instance Show VkApplicationInfo where + showsPrec d x + = showString "VkApplicationInfo {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkPApplicationName = " . + showsPrec d (vkPApplicationName x) . + showString ", " . + showString "vkApplicationVersion = " . + showsPrec d (vkApplicationVersion x) . + showString ", " . + showString "vkPEngineName = " . + showsPrec d (vkPEngineName x) . + showString ", " . + showString "vkEngineVersion = " . + showsPrec d (vkEngineVersion x) . + showString ", " . + showString "vkApiVersion = " . + showsPrec d (vkApiVersion x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkAttachmentDescription.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkAttachmentDescription.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkAttachmentDescription.hsc @@ -0,0 +1,551 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkAttachmentDescription + (VkAttachmentDescription(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkAttachmentDescriptionFlags (VkAttachmentDescriptionFlags) +import Graphics.Vulkan.Types.Enum.VkAttachmentLoadOp (VkAttachmentLoadOp) +import Graphics.Vulkan.Types.Enum.VkAttachmentStoreOp (VkAttachmentStoreOp) +import Graphics.Vulkan.Types.Enum.VkFormat (VkFormat) +import Graphics.Vulkan.Types.Enum.VkImageLayout (VkImageLayout) +import Graphics.Vulkan.Types.Enum.VkSampleCountFlags (VkSampleCountFlagBits) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkAttachmentDescription { +-- > VkAttachmentDescriptionFlags flags; +-- > VkFormat format; +-- > VkSampleCountFlagBits samples; +-- > VkAttachmentLoadOp loadOp; +-- > VkAttachmentStoreOp storeOp; +-- > VkAttachmentLoadOp stencilLoadOp; +-- > VkAttachmentStoreOp stencilStoreOp; +-- > VkImageLayout initialLayout; +-- > VkImageLayout finalLayout; +-- > } VkAttachmentDescription; +-- +-- +data VkAttachmentDescription = VkAttachmentDescription## Addr## + ByteArray## + +instance Eq VkAttachmentDescription where + (VkAttachmentDescription## a _) == x@(VkAttachmentDescription## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkAttachmentDescription where + (VkAttachmentDescription## a _) `compare` + x@(VkAttachmentDescription## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkAttachmentDescription where + sizeOf ~_ = #{size VkAttachmentDescription} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkAttachmentDescription} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkAttachmentDescription where + unsafeAddr (VkAttachmentDescription## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkAttachmentDescription## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkAttachmentDescription## (plusAddr## (byteArrayContents## b) off) b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkAttachmentDescription where + type StructFields VkAttachmentDescription = + '["flags", "format", "samples", "loadOp", "storeOp", -- ' closing tick for hsc2hs + "stencilLoadOp", "stencilStoreOp", "initialLayout", "finalLayout"] + type CUnionType VkAttachmentDescription = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkAttachmentDescription = 'False -- ' closing tick for hsc2hs + type StructExtends VkAttachmentDescription = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkFlags VkAttachmentDescription + where + type VkFlagsMType VkAttachmentDescription = + VkAttachmentDescriptionFlags + + {-# NOINLINE vkFlags #-} + vkFlags x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkAttachmentDescription, flags}) + + {-# INLINE vkFlagsByteOffset #-} + vkFlagsByteOffset ~_ + = #{offset VkAttachmentDescription, flags} + + {-# INLINE readVkFlags #-} + readVkFlags p + = peekByteOff p #{offset VkAttachmentDescription, flags} + + {-# INLINE writeVkFlags #-} + writeVkFlags p + = pokeByteOff p #{offset VkAttachmentDescription, flags} + +instance {-# OVERLAPPING #-} + HasField "flags" VkAttachmentDescription where + type FieldType "flags" VkAttachmentDescription = + VkAttachmentDescriptionFlags + type FieldOptional "flags" VkAttachmentDescription = 'True -- ' closing tick for hsc2hs + type FieldOffset "flags" VkAttachmentDescription = + #{offset VkAttachmentDescription, flags} + type FieldIsArray "flags" VkAttachmentDescription = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkAttachmentDescription, flags} + +instance CanReadField "flags" VkAttachmentDescription where + {-# INLINE getField #-} + getField = vkFlags + + {-# INLINE readField #-} + readField = readVkFlags + +instance CanWriteField "flags" VkAttachmentDescription where + {-# INLINE writeField #-} + writeField = writeVkFlags + +instance {-# OVERLAPPING #-} HasVkFormat VkAttachmentDescription + where + type VkFormatMType VkAttachmentDescription = VkFormat + + {-# NOINLINE vkFormat #-} + vkFormat x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkAttachmentDescription, format}) + + {-# INLINE vkFormatByteOffset #-} + vkFormatByteOffset ~_ + = #{offset VkAttachmentDescription, format} + + {-# INLINE readVkFormat #-} + readVkFormat p + = peekByteOff p #{offset VkAttachmentDescription, format} + + {-# INLINE writeVkFormat #-} + writeVkFormat p + = pokeByteOff p #{offset VkAttachmentDescription, format} + +instance {-# OVERLAPPING #-} + HasField "format" VkAttachmentDescription where + type FieldType "format" VkAttachmentDescription = VkFormat + type FieldOptional "format" VkAttachmentDescription = 'False -- ' closing tick for hsc2hs + type FieldOffset "format" VkAttachmentDescription = + #{offset VkAttachmentDescription, format} + type FieldIsArray "format" VkAttachmentDescription = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkAttachmentDescription, format} + +instance CanReadField "format" VkAttachmentDescription where + {-# INLINE getField #-} + getField = vkFormat + + {-# INLINE readField #-} + readField = readVkFormat + +instance CanWriteField "format" VkAttachmentDescription where + {-# INLINE writeField #-} + writeField = writeVkFormat + +instance {-# OVERLAPPING #-} HasVkSamples VkAttachmentDescription + where + type VkSamplesMType VkAttachmentDescription = VkSampleCountFlagBits + + {-# NOINLINE vkSamples #-} + vkSamples x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkAttachmentDescription, samples}) + + {-# INLINE vkSamplesByteOffset #-} + vkSamplesByteOffset ~_ + = #{offset VkAttachmentDescription, samples} + + {-# INLINE readVkSamples #-} + readVkSamples p + = peekByteOff p #{offset VkAttachmentDescription, samples} + + {-# INLINE writeVkSamples #-} + writeVkSamples p + = pokeByteOff p #{offset VkAttachmentDescription, samples} + +instance {-# OVERLAPPING #-} + HasField "samples" VkAttachmentDescription where + type FieldType "samples" VkAttachmentDescription = + VkSampleCountFlagBits + type FieldOptional "samples" VkAttachmentDescription = 'False -- ' closing tick for hsc2hs + type FieldOffset "samples" VkAttachmentDescription = + #{offset VkAttachmentDescription, samples} + type FieldIsArray "samples" VkAttachmentDescription = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkAttachmentDescription, samples} + +instance CanReadField "samples" VkAttachmentDescription where + {-# INLINE getField #-} + getField = vkSamples + + {-# INLINE readField #-} + readField = readVkSamples + +instance CanWriteField "samples" VkAttachmentDescription where + {-# INLINE writeField #-} + writeField = writeVkSamples + +instance {-# OVERLAPPING #-} HasVkLoadOp VkAttachmentDescription + where + type VkLoadOpMType VkAttachmentDescription = VkAttachmentLoadOp + + {-# NOINLINE vkLoadOp #-} + vkLoadOp x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkAttachmentDescription, loadOp}) + + {-# INLINE vkLoadOpByteOffset #-} + vkLoadOpByteOffset ~_ + = #{offset VkAttachmentDescription, loadOp} + + {-# INLINE readVkLoadOp #-} + readVkLoadOp p + = peekByteOff p #{offset VkAttachmentDescription, loadOp} + + {-# INLINE writeVkLoadOp #-} + writeVkLoadOp p + = pokeByteOff p #{offset VkAttachmentDescription, loadOp} + +instance {-# OVERLAPPING #-} + HasField "loadOp" VkAttachmentDescription where + type FieldType "loadOp" VkAttachmentDescription = + VkAttachmentLoadOp + type FieldOptional "loadOp" VkAttachmentDescription = 'False -- ' closing tick for hsc2hs + type FieldOffset "loadOp" VkAttachmentDescription = + #{offset VkAttachmentDescription, loadOp} + type FieldIsArray "loadOp" VkAttachmentDescription = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkAttachmentDescription, loadOp} + +instance CanReadField "loadOp" VkAttachmentDescription where + {-# INLINE getField #-} + getField = vkLoadOp + + {-# INLINE readField #-} + readField = readVkLoadOp + +instance CanWriteField "loadOp" VkAttachmentDescription where + {-# INLINE writeField #-} + writeField = writeVkLoadOp + +instance {-# OVERLAPPING #-} HasVkStoreOp VkAttachmentDescription + where + type VkStoreOpMType VkAttachmentDescription = VkAttachmentStoreOp + + {-# NOINLINE vkStoreOp #-} + vkStoreOp x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkAttachmentDescription, storeOp}) + + {-# INLINE vkStoreOpByteOffset #-} + vkStoreOpByteOffset ~_ + = #{offset VkAttachmentDescription, storeOp} + + {-# INLINE readVkStoreOp #-} + readVkStoreOp p + = peekByteOff p #{offset VkAttachmentDescription, storeOp} + + {-# INLINE writeVkStoreOp #-} + writeVkStoreOp p + = pokeByteOff p #{offset VkAttachmentDescription, storeOp} + +instance {-# OVERLAPPING #-} + HasField "storeOp" VkAttachmentDescription where + type FieldType "storeOp" VkAttachmentDescription = + VkAttachmentStoreOp + type FieldOptional "storeOp" VkAttachmentDescription = 'False -- ' closing tick for hsc2hs + type FieldOffset "storeOp" VkAttachmentDescription = + #{offset VkAttachmentDescription, storeOp} + type FieldIsArray "storeOp" VkAttachmentDescription = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkAttachmentDescription, storeOp} + +instance CanReadField "storeOp" VkAttachmentDescription where + {-# INLINE getField #-} + getField = vkStoreOp + + {-# INLINE readField #-} + readField = readVkStoreOp + +instance CanWriteField "storeOp" VkAttachmentDescription where + {-# INLINE writeField #-} + writeField = writeVkStoreOp + +instance {-# OVERLAPPING #-} + HasVkStencilLoadOp VkAttachmentDescription where + type VkStencilLoadOpMType VkAttachmentDescription = + VkAttachmentLoadOp + + {-# NOINLINE vkStencilLoadOp #-} + vkStencilLoadOp x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkAttachmentDescription, stencilLoadOp}) + + {-# INLINE vkStencilLoadOpByteOffset #-} + vkStencilLoadOpByteOffset ~_ + = #{offset VkAttachmentDescription, stencilLoadOp} + + {-# INLINE readVkStencilLoadOp #-} + readVkStencilLoadOp p + = peekByteOff p #{offset VkAttachmentDescription, stencilLoadOp} + + {-# INLINE writeVkStencilLoadOp #-} + writeVkStencilLoadOp p + = pokeByteOff p #{offset VkAttachmentDescription, stencilLoadOp} + +instance {-# OVERLAPPING #-} + HasField "stencilLoadOp" VkAttachmentDescription where + type FieldType "stencilLoadOp" VkAttachmentDescription = + VkAttachmentLoadOp + type FieldOptional "stencilLoadOp" VkAttachmentDescription = 'False -- ' closing tick for hsc2hs + type FieldOffset "stencilLoadOp" VkAttachmentDescription = + #{offset VkAttachmentDescription, stencilLoadOp} + type FieldIsArray "stencilLoadOp" VkAttachmentDescription = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkAttachmentDescription, stencilLoadOp} + +instance CanReadField "stencilLoadOp" VkAttachmentDescription where + {-# INLINE getField #-} + getField = vkStencilLoadOp + + {-# INLINE readField #-} + readField = readVkStencilLoadOp + +instance CanWriteField "stencilLoadOp" VkAttachmentDescription + where + {-# INLINE writeField #-} + writeField = writeVkStencilLoadOp + +instance {-# OVERLAPPING #-} + HasVkStencilStoreOp VkAttachmentDescription where + type VkStencilStoreOpMType VkAttachmentDescription = + VkAttachmentStoreOp + + {-# NOINLINE vkStencilStoreOp #-} + vkStencilStoreOp x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkAttachmentDescription, stencilStoreOp}) + + {-# INLINE vkStencilStoreOpByteOffset #-} + vkStencilStoreOpByteOffset ~_ + = #{offset VkAttachmentDescription, stencilStoreOp} + + {-# INLINE readVkStencilStoreOp #-} + readVkStencilStoreOp p + = peekByteOff p #{offset VkAttachmentDescription, stencilStoreOp} + + {-# INLINE writeVkStencilStoreOp #-} + writeVkStencilStoreOp p + = pokeByteOff p #{offset VkAttachmentDescription, stencilStoreOp} + +instance {-# OVERLAPPING #-} + HasField "stencilStoreOp" VkAttachmentDescription where + type FieldType "stencilStoreOp" VkAttachmentDescription = + VkAttachmentStoreOp + type FieldOptional "stencilStoreOp" VkAttachmentDescription = + 'False -- ' closing tick for hsc2hs + type FieldOffset "stencilStoreOp" VkAttachmentDescription = + #{offset VkAttachmentDescription, stencilStoreOp} + type FieldIsArray "stencilStoreOp" VkAttachmentDescription = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkAttachmentDescription, stencilStoreOp} + +instance CanReadField "stencilStoreOp" VkAttachmentDescription + where + {-# INLINE getField #-} + getField = vkStencilStoreOp + + {-# INLINE readField #-} + readField = readVkStencilStoreOp + +instance CanWriteField "stencilStoreOp" VkAttachmentDescription + where + {-# INLINE writeField #-} + writeField = writeVkStencilStoreOp + +instance {-# OVERLAPPING #-} + HasVkInitialLayout VkAttachmentDescription where + type VkInitialLayoutMType VkAttachmentDescription = VkImageLayout + + {-# NOINLINE vkInitialLayout #-} + vkInitialLayout x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkAttachmentDescription, initialLayout}) + + {-# INLINE vkInitialLayoutByteOffset #-} + vkInitialLayoutByteOffset ~_ + = #{offset VkAttachmentDescription, initialLayout} + + {-# INLINE readVkInitialLayout #-} + readVkInitialLayout p + = peekByteOff p #{offset VkAttachmentDescription, initialLayout} + + {-# INLINE writeVkInitialLayout #-} + writeVkInitialLayout p + = pokeByteOff p #{offset VkAttachmentDescription, initialLayout} + +instance {-# OVERLAPPING #-} + HasField "initialLayout" VkAttachmentDescription where + type FieldType "initialLayout" VkAttachmentDescription = + VkImageLayout + type FieldOptional "initialLayout" VkAttachmentDescription = 'False -- ' closing tick for hsc2hs + type FieldOffset "initialLayout" VkAttachmentDescription = + #{offset VkAttachmentDescription, initialLayout} + type FieldIsArray "initialLayout" VkAttachmentDescription = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkAttachmentDescription, initialLayout} + +instance CanReadField "initialLayout" VkAttachmentDescription where + {-# INLINE getField #-} + getField = vkInitialLayout + + {-# INLINE readField #-} + readField = readVkInitialLayout + +instance CanWriteField "initialLayout" VkAttachmentDescription + where + {-# INLINE writeField #-} + writeField = writeVkInitialLayout + +instance {-# OVERLAPPING #-} + HasVkFinalLayout VkAttachmentDescription where + type VkFinalLayoutMType VkAttachmentDescription = VkImageLayout + + {-# NOINLINE vkFinalLayout #-} + vkFinalLayout x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkAttachmentDescription, finalLayout}) + + {-# INLINE vkFinalLayoutByteOffset #-} + vkFinalLayoutByteOffset ~_ + = #{offset VkAttachmentDescription, finalLayout} + + {-# INLINE readVkFinalLayout #-} + readVkFinalLayout p + = peekByteOff p #{offset VkAttachmentDescription, finalLayout} + + {-# INLINE writeVkFinalLayout #-} + writeVkFinalLayout p + = pokeByteOff p #{offset VkAttachmentDescription, finalLayout} + +instance {-# OVERLAPPING #-} + HasField "finalLayout" VkAttachmentDescription where + type FieldType "finalLayout" VkAttachmentDescription = + VkImageLayout + type FieldOptional "finalLayout" VkAttachmentDescription = 'False -- ' closing tick for hsc2hs + type FieldOffset "finalLayout" VkAttachmentDescription = + #{offset VkAttachmentDescription, finalLayout} + type FieldIsArray "finalLayout" VkAttachmentDescription = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkAttachmentDescription, finalLayout} + +instance CanReadField "finalLayout" VkAttachmentDescription where + {-# INLINE getField #-} + getField = vkFinalLayout + + {-# INLINE readField #-} + readField = readVkFinalLayout + +instance CanWriteField "finalLayout" VkAttachmentDescription where + {-# INLINE writeField #-} + writeField = writeVkFinalLayout + +instance Show VkAttachmentDescription where + showsPrec d x + = showString "VkAttachmentDescription {" . + showString "vkFlags = " . + showsPrec d (vkFlags x) . + showString ", " . + showString "vkFormat = " . + showsPrec d (vkFormat x) . + showString ", " . + showString "vkSamples = " . + showsPrec d (vkSamples x) . + showString ", " . + showString "vkLoadOp = " . + showsPrec d (vkLoadOp x) . + showString ", " . + showString "vkStoreOp = " . + showsPrec d (vkStoreOp x) . + showString ", " . + showString "vkStencilLoadOp = " . + showsPrec d (vkStencilLoadOp x) . + showString ", " . + showString "vkStencilStoreOp = " . + showsPrec d (vkStencilStoreOp x) . + showString ", " . + showString "vkInitialLayout = " . + showsPrec d (vkInitialLayout x) . + showString ", " . + showString "vkFinalLayout = " . + showsPrec d (vkFinalLayout x) . + showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkAttachmentReference.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkAttachmentReference.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkAttachmentReference.hsc @@ -0,0 +1,171 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkAttachmentReference + (VkAttachmentReference(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkImageLayout (VkImageLayout) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkAttachmentReference { +-- > uint32_t attachment; +-- > VkImageLayout layout; +-- > } VkAttachmentReference; +-- +-- +data VkAttachmentReference = VkAttachmentReference## Addr## + ByteArray## + +instance Eq VkAttachmentReference where + (VkAttachmentReference## a _) == x@(VkAttachmentReference## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkAttachmentReference where + (VkAttachmentReference## a _) `compare` + x@(VkAttachmentReference## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkAttachmentReference where + sizeOf ~_ = #{size VkAttachmentReference} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkAttachmentReference} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkAttachmentReference where + unsafeAddr (VkAttachmentReference## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkAttachmentReference## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkAttachmentReference## (plusAddr## (byteArrayContents## b) off) b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkAttachmentReference where + type StructFields VkAttachmentReference = '["attachment", "layout"] -- ' closing tick for hsc2hs + type CUnionType VkAttachmentReference = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkAttachmentReference = 'False -- ' closing tick for hsc2hs + type StructExtends VkAttachmentReference = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkAttachment VkAttachmentReference + where + type VkAttachmentMType VkAttachmentReference = Word32 + + {-# NOINLINE vkAttachment #-} + vkAttachment x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkAttachmentReference, attachment}) + + {-# INLINE vkAttachmentByteOffset #-} + vkAttachmentByteOffset ~_ + = #{offset VkAttachmentReference, attachment} + + {-# INLINE readVkAttachment #-} + readVkAttachment p + = peekByteOff p #{offset VkAttachmentReference, attachment} + + {-# INLINE writeVkAttachment #-} + writeVkAttachment p + = pokeByteOff p #{offset VkAttachmentReference, attachment} + +instance {-# OVERLAPPING #-} + HasField "attachment" VkAttachmentReference where + type FieldType "attachment" VkAttachmentReference = Word32 + type FieldOptional "attachment" VkAttachmentReference = 'False -- ' closing tick for hsc2hs + type FieldOffset "attachment" VkAttachmentReference = + #{offset VkAttachmentReference, attachment} + type FieldIsArray "attachment" VkAttachmentReference = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkAttachmentReference, attachment} + +instance CanReadField "attachment" VkAttachmentReference where + {-# INLINE getField #-} + getField = vkAttachment + + {-# INLINE readField #-} + readField = readVkAttachment + +instance CanWriteField "attachment" VkAttachmentReference where + {-# INLINE writeField #-} + writeField = writeVkAttachment + +instance {-# OVERLAPPING #-} HasVkLayout VkAttachmentReference + where + type VkLayoutMType VkAttachmentReference = VkImageLayout + + {-# NOINLINE vkLayout #-} + vkLayout x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkAttachmentReference, layout}) + + {-# INLINE vkLayoutByteOffset #-} + vkLayoutByteOffset ~_ + = #{offset VkAttachmentReference, layout} + + {-# INLINE readVkLayout #-} + readVkLayout p + = peekByteOff p #{offset VkAttachmentReference, layout} + + {-# INLINE writeVkLayout #-} + writeVkLayout p + = pokeByteOff p #{offset VkAttachmentReference, layout} + +instance {-# OVERLAPPING #-} + HasField "layout" VkAttachmentReference where + type FieldType "layout" VkAttachmentReference = VkImageLayout + type FieldOptional "layout" VkAttachmentReference = 'False -- ' closing tick for hsc2hs + type FieldOffset "layout" VkAttachmentReference = + #{offset VkAttachmentReference, layout} + type FieldIsArray "layout" VkAttachmentReference = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkAttachmentReference, layout} + +instance CanReadField "layout" VkAttachmentReference where + {-# INLINE getField #-} + getField = vkLayout + + {-# INLINE readField #-} + readField = readVkLayout + +instance CanWriteField "layout" VkAttachmentReference where + {-# INLINE writeField #-} + writeField = writeVkLayout + +instance Show VkAttachmentReference where + showsPrec d x + = showString "VkAttachmentReference {" . + showString "vkAttachment = " . + showsPrec d (vkAttachment x) . + showString ", " . + showString "vkLayout = " . showsPrec d (vkLayout x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkAttachmentSampleLocationsEXT.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkAttachmentSampleLocationsEXT.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkAttachmentSampleLocationsEXT.hsc @@ -0,0 +1,197 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkAttachmentSampleLocationsEXT + (VkAttachmentSampleLocationsEXT(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Struct.VkSampleLocationsInfoEXT (VkSampleLocationsInfoEXT) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkAttachmentSampleLocationsEXT { +-- > uint32_t attachmentIndex; +-- > VkSampleLocationsInfoEXT sampleLocationsInfo; +-- > } VkAttachmentSampleLocationsEXT; +-- +-- +data VkAttachmentSampleLocationsEXT = VkAttachmentSampleLocationsEXT## Addr## + ByteArray## + +instance Eq VkAttachmentSampleLocationsEXT where + (VkAttachmentSampleLocationsEXT## a _) == + x@(VkAttachmentSampleLocationsEXT## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkAttachmentSampleLocationsEXT where + (VkAttachmentSampleLocationsEXT## a _) `compare` + x@(VkAttachmentSampleLocationsEXT## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkAttachmentSampleLocationsEXT where + sizeOf ~_ = #{size VkAttachmentSampleLocationsEXT} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkAttachmentSampleLocationsEXT} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkAttachmentSampleLocationsEXT where + unsafeAddr (VkAttachmentSampleLocationsEXT## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkAttachmentSampleLocationsEXT## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkAttachmentSampleLocationsEXT## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkAttachmentSampleLocationsEXT where + type StructFields VkAttachmentSampleLocationsEXT = + '["attachmentIndex", "sampleLocationsInfo"] -- ' closing tick for hsc2hs + type CUnionType VkAttachmentSampleLocationsEXT = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkAttachmentSampleLocationsEXT = 'False -- ' closing tick for hsc2hs + type StructExtends VkAttachmentSampleLocationsEXT = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkAttachmentIndex VkAttachmentSampleLocationsEXT where + type VkAttachmentIndexMType VkAttachmentSampleLocationsEXT = Word32 + + {-# NOINLINE vkAttachmentIndex #-} + vkAttachmentIndex x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkAttachmentSampleLocationsEXT, attachmentIndex}) + + {-# INLINE vkAttachmentIndexByteOffset #-} + vkAttachmentIndexByteOffset ~_ + = #{offset VkAttachmentSampleLocationsEXT, attachmentIndex} + + {-# INLINE readVkAttachmentIndex #-} + readVkAttachmentIndex p + = peekByteOff p #{offset VkAttachmentSampleLocationsEXT, attachmentIndex} + + {-# INLINE writeVkAttachmentIndex #-} + writeVkAttachmentIndex p + = pokeByteOff p #{offset VkAttachmentSampleLocationsEXT, attachmentIndex} + +instance {-# OVERLAPPING #-} + HasField "attachmentIndex" VkAttachmentSampleLocationsEXT where + type FieldType "attachmentIndex" VkAttachmentSampleLocationsEXT = + Word32 + type FieldOptional "attachmentIndex" VkAttachmentSampleLocationsEXT + = 'False -- ' closing tick for hsc2hs + type FieldOffset "attachmentIndex" VkAttachmentSampleLocationsEXT = + #{offset VkAttachmentSampleLocationsEXT, attachmentIndex} + type FieldIsArray "attachmentIndex" VkAttachmentSampleLocationsEXT + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkAttachmentSampleLocationsEXT, attachmentIndex} + +instance CanReadField "attachmentIndex" + VkAttachmentSampleLocationsEXT + where + {-# INLINE getField #-} + getField = vkAttachmentIndex + + {-# INLINE readField #-} + readField = readVkAttachmentIndex + +instance CanWriteField "attachmentIndex" + VkAttachmentSampleLocationsEXT + where + {-# INLINE writeField #-} + writeField = writeVkAttachmentIndex + +instance {-# OVERLAPPING #-} + HasVkSampleLocationsInfo VkAttachmentSampleLocationsEXT where + type VkSampleLocationsInfoMType VkAttachmentSampleLocationsEXT = + VkSampleLocationsInfoEXT + + {-# NOINLINE vkSampleLocationsInfo #-} + vkSampleLocationsInfo x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkAttachmentSampleLocationsEXT, sampleLocationsInfo}) + + {-# INLINE vkSampleLocationsInfoByteOffset #-} + vkSampleLocationsInfoByteOffset ~_ + = #{offset VkAttachmentSampleLocationsEXT, sampleLocationsInfo} + + {-# INLINE readVkSampleLocationsInfo #-} + readVkSampleLocationsInfo p + = peekByteOff p #{offset VkAttachmentSampleLocationsEXT, sampleLocationsInfo} + + {-# INLINE writeVkSampleLocationsInfo #-} + writeVkSampleLocationsInfo p + = pokeByteOff p #{offset VkAttachmentSampleLocationsEXT, sampleLocationsInfo} + +instance {-# OVERLAPPING #-} + HasField "sampleLocationsInfo" VkAttachmentSampleLocationsEXT where + type FieldType "sampleLocationsInfo" VkAttachmentSampleLocationsEXT + = VkSampleLocationsInfoEXT + type FieldOptional "sampleLocationsInfo" + VkAttachmentSampleLocationsEXT + = 'False -- ' closing tick for hsc2hs + type FieldOffset "sampleLocationsInfo" + VkAttachmentSampleLocationsEXT + = + #{offset VkAttachmentSampleLocationsEXT, sampleLocationsInfo} + type FieldIsArray "sampleLocationsInfo" + VkAttachmentSampleLocationsEXT + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkAttachmentSampleLocationsEXT, sampleLocationsInfo} + +instance CanReadField "sampleLocationsInfo" + VkAttachmentSampleLocationsEXT + where + {-# INLINE getField #-} + getField = vkSampleLocationsInfo + + {-# INLINE readField #-} + readField = readVkSampleLocationsInfo + +instance CanWriteField "sampleLocationsInfo" + VkAttachmentSampleLocationsEXT + where + {-# INLINE writeField #-} + writeField = writeVkSampleLocationsInfo + +instance Show VkAttachmentSampleLocationsEXT where + showsPrec d x + = showString "VkAttachmentSampleLocationsEXT {" . + showString "vkAttachmentIndex = " . + showsPrec d (vkAttachmentIndex x) . + showString ", " . + showString "vkSampleLocationsInfo = " . + showsPrec d (vkSampleLocationsInfo x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkBindBufferMemoryDeviceGroupInfoKHX.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkBindBufferMemoryDeviceGroupInfoKHX.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkBindBufferMemoryDeviceGroupInfoKHX.hsc @@ -0,0 +1,324 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkBindBufferMemoryDeviceGroupInfoKHX + (VkBindBufferMemoryDeviceGroupInfoKHX(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Struct.VkBindBufferMemoryInfoKHR (VkBindBufferMemoryInfoKHR) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkBindBufferMemoryDeviceGroupInfoKHX { +-- > VkStructureType sType; +-- > const void* pNext; +-- > uint32_t deviceIndexCount; +-- > const uint32_t* pDeviceIndices; +-- > } VkBindBufferMemoryDeviceGroupInfoKHX; +-- +-- +data VkBindBufferMemoryDeviceGroupInfoKHX = VkBindBufferMemoryDeviceGroupInfoKHX## Addr## + ByteArray## + +instance Eq VkBindBufferMemoryDeviceGroupInfoKHX where + (VkBindBufferMemoryDeviceGroupInfoKHX## a _) == + x@(VkBindBufferMemoryDeviceGroupInfoKHX## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkBindBufferMemoryDeviceGroupInfoKHX where + (VkBindBufferMemoryDeviceGroupInfoKHX## a _) `compare` + x@(VkBindBufferMemoryDeviceGroupInfoKHX## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkBindBufferMemoryDeviceGroupInfoKHX where + sizeOf ~_ + = #{size VkBindBufferMemoryDeviceGroupInfoKHX} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkBindBufferMemoryDeviceGroupInfoKHX} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkBindBufferMemoryDeviceGroupInfoKHX + where + unsafeAddr (VkBindBufferMemoryDeviceGroupInfoKHX## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkBindBufferMemoryDeviceGroupInfoKHX## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkBindBufferMemoryDeviceGroupInfoKHX## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkBindBufferMemoryDeviceGroupInfoKHX where + type StructFields VkBindBufferMemoryDeviceGroupInfoKHX = + '["sType", "pNext", "deviceIndexCount", "pDeviceIndices"] -- ' closing tick for hsc2hs + type CUnionType VkBindBufferMemoryDeviceGroupInfoKHX = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkBindBufferMemoryDeviceGroupInfoKHX = 'False -- ' closing tick for hsc2hs + type StructExtends VkBindBufferMemoryDeviceGroupInfoKHX = + '[VkBindBufferMemoryInfoKHR] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkBindBufferMemoryDeviceGroupInfoKHX where + type VkSTypeMType VkBindBufferMemoryDeviceGroupInfoKHX = + VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkBindBufferMemoryDeviceGroupInfoKHX, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkBindBufferMemoryDeviceGroupInfoKHX, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkBindBufferMemoryDeviceGroupInfoKHX, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkBindBufferMemoryDeviceGroupInfoKHX, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkBindBufferMemoryDeviceGroupInfoKHX where + type FieldType "sType" VkBindBufferMemoryDeviceGroupInfoKHX = + VkStructureType + type FieldOptional "sType" VkBindBufferMemoryDeviceGroupInfoKHX = + 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkBindBufferMemoryDeviceGroupInfoKHX = + #{offset VkBindBufferMemoryDeviceGroupInfoKHX, sType} + type FieldIsArray "sType" VkBindBufferMemoryDeviceGroupInfoKHX = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkBindBufferMemoryDeviceGroupInfoKHX, sType} + +instance CanReadField "sType" VkBindBufferMemoryDeviceGroupInfoKHX + where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkBindBufferMemoryDeviceGroupInfoKHX + where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkBindBufferMemoryDeviceGroupInfoKHX where + type VkPNextMType VkBindBufferMemoryDeviceGroupInfoKHX = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkBindBufferMemoryDeviceGroupInfoKHX, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkBindBufferMemoryDeviceGroupInfoKHX, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkBindBufferMemoryDeviceGroupInfoKHX, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkBindBufferMemoryDeviceGroupInfoKHX, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkBindBufferMemoryDeviceGroupInfoKHX where + type FieldType "pNext" VkBindBufferMemoryDeviceGroupInfoKHX = + Ptr Void + type FieldOptional "pNext" VkBindBufferMemoryDeviceGroupInfoKHX = + 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkBindBufferMemoryDeviceGroupInfoKHX = + #{offset VkBindBufferMemoryDeviceGroupInfoKHX, pNext} + type FieldIsArray "pNext" VkBindBufferMemoryDeviceGroupInfoKHX = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkBindBufferMemoryDeviceGroupInfoKHX, pNext} + +instance CanReadField "pNext" VkBindBufferMemoryDeviceGroupInfoKHX + where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkBindBufferMemoryDeviceGroupInfoKHX + where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkDeviceIndexCount VkBindBufferMemoryDeviceGroupInfoKHX where + type VkDeviceIndexCountMType VkBindBufferMemoryDeviceGroupInfoKHX = + Word32 + + {-# NOINLINE vkDeviceIndexCount #-} + vkDeviceIndexCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkBindBufferMemoryDeviceGroupInfoKHX, deviceIndexCount}) + + {-# INLINE vkDeviceIndexCountByteOffset #-} + vkDeviceIndexCountByteOffset ~_ + = #{offset VkBindBufferMemoryDeviceGroupInfoKHX, deviceIndexCount} + + {-# INLINE readVkDeviceIndexCount #-} + readVkDeviceIndexCount p + = peekByteOff p #{offset VkBindBufferMemoryDeviceGroupInfoKHX, deviceIndexCount} + + {-# INLINE writeVkDeviceIndexCount #-} + writeVkDeviceIndexCount p + = pokeByteOff p #{offset VkBindBufferMemoryDeviceGroupInfoKHX, deviceIndexCount} + +instance {-# OVERLAPPING #-} + HasField "deviceIndexCount" VkBindBufferMemoryDeviceGroupInfoKHX + where + type FieldType "deviceIndexCount" + VkBindBufferMemoryDeviceGroupInfoKHX + = Word32 + type FieldOptional "deviceIndexCount" + VkBindBufferMemoryDeviceGroupInfoKHX + = 'True -- ' closing tick for hsc2hs + type FieldOffset "deviceIndexCount" + VkBindBufferMemoryDeviceGroupInfoKHX + = + #{offset VkBindBufferMemoryDeviceGroupInfoKHX, deviceIndexCount} + type FieldIsArray "deviceIndexCount" + VkBindBufferMemoryDeviceGroupInfoKHX + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkBindBufferMemoryDeviceGroupInfoKHX, deviceIndexCount} + +instance CanReadField "deviceIndexCount" + VkBindBufferMemoryDeviceGroupInfoKHX + where + {-# INLINE getField #-} + getField = vkDeviceIndexCount + + {-# INLINE readField #-} + readField = readVkDeviceIndexCount + +instance CanWriteField "deviceIndexCount" + VkBindBufferMemoryDeviceGroupInfoKHX + where + {-# INLINE writeField #-} + writeField = writeVkDeviceIndexCount + +instance {-# OVERLAPPING #-} + HasVkPDeviceIndices VkBindBufferMemoryDeviceGroupInfoKHX where + type VkPDeviceIndicesMType VkBindBufferMemoryDeviceGroupInfoKHX = + Ptr Word32 + + {-# NOINLINE vkPDeviceIndices #-} + vkPDeviceIndices x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkBindBufferMemoryDeviceGroupInfoKHX, pDeviceIndices}) + + {-# INLINE vkPDeviceIndicesByteOffset #-} + vkPDeviceIndicesByteOffset ~_ + = #{offset VkBindBufferMemoryDeviceGroupInfoKHX, pDeviceIndices} + + {-# INLINE readVkPDeviceIndices #-} + readVkPDeviceIndices p + = peekByteOff p #{offset VkBindBufferMemoryDeviceGroupInfoKHX, pDeviceIndices} + + {-# INLINE writeVkPDeviceIndices #-} + writeVkPDeviceIndices p + = pokeByteOff p #{offset VkBindBufferMemoryDeviceGroupInfoKHX, pDeviceIndices} + +instance {-# OVERLAPPING #-} + HasField "pDeviceIndices" VkBindBufferMemoryDeviceGroupInfoKHX + where + type FieldType "pDeviceIndices" + VkBindBufferMemoryDeviceGroupInfoKHX + = Ptr Word32 + type FieldOptional "pDeviceIndices" + VkBindBufferMemoryDeviceGroupInfoKHX + = 'False -- ' closing tick for hsc2hs + type FieldOffset "pDeviceIndices" + VkBindBufferMemoryDeviceGroupInfoKHX + = + #{offset VkBindBufferMemoryDeviceGroupInfoKHX, pDeviceIndices} + type FieldIsArray "pDeviceIndices" + VkBindBufferMemoryDeviceGroupInfoKHX + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkBindBufferMemoryDeviceGroupInfoKHX, pDeviceIndices} + +instance CanReadField "pDeviceIndices" + VkBindBufferMemoryDeviceGroupInfoKHX + where + {-# INLINE getField #-} + getField = vkPDeviceIndices + + {-# INLINE readField #-} + readField = readVkPDeviceIndices + +instance CanWriteField "pDeviceIndices" + VkBindBufferMemoryDeviceGroupInfoKHX + where + {-# INLINE writeField #-} + writeField = writeVkPDeviceIndices + +instance Show VkBindBufferMemoryDeviceGroupInfoKHX where + showsPrec d x + = showString "VkBindBufferMemoryDeviceGroupInfoKHX {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkDeviceIndexCount = " . + showsPrec d (vkDeviceIndexCount x) . + showString ", " . + showString "vkPDeviceIndices = " . + showsPrec d (vkPDeviceIndices x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkBindBufferMemoryInfoKHR.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkBindBufferMemoryInfoKHR.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkBindBufferMemoryInfoKHR.hsc @@ -0,0 +1,335 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkBindBufferMemoryInfoKHR + (VkBindBufferMemoryInfoKHR(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.BaseTypes (VkDeviceSize) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Handles (VkBuffer, + VkDeviceMemory) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkBindBufferMemoryInfoKHR { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkBuffer buffer; +-- > VkDeviceMemory memory; +-- > VkDeviceSize memoryOffset; +-- > } VkBindBufferMemoryInfoKHR; +-- +-- +data VkBindBufferMemoryInfoKHR = VkBindBufferMemoryInfoKHR## Addr## + ByteArray## + +instance Eq VkBindBufferMemoryInfoKHR where + (VkBindBufferMemoryInfoKHR## a _) == + x@(VkBindBufferMemoryInfoKHR## b _) = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkBindBufferMemoryInfoKHR where + (VkBindBufferMemoryInfoKHR## a _) `compare` + x@(VkBindBufferMemoryInfoKHR## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkBindBufferMemoryInfoKHR where + sizeOf ~_ = #{size VkBindBufferMemoryInfoKHR} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkBindBufferMemoryInfoKHR} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkBindBufferMemoryInfoKHR where + unsafeAddr (VkBindBufferMemoryInfoKHR## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkBindBufferMemoryInfoKHR## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkBindBufferMemoryInfoKHR## (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkBindBufferMemoryInfoKHR where + type StructFields VkBindBufferMemoryInfoKHR = + '["sType", "pNext", "buffer", "memory", "memoryOffset"] -- ' closing tick for hsc2hs + type CUnionType VkBindBufferMemoryInfoKHR = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkBindBufferMemoryInfoKHR = 'False -- ' closing tick for hsc2hs + type StructExtends VkBindBufferMemoryInfoKHR = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkSType VkBindBufferMemoryInfoKHR + where + type VkSTypeMType VkBindBufferMemoryInfoKHR = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkBindBufferMemoryInfoKHR, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkBindBufferMemoryInfoKHR, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkBindBufferMemoryInfoKHR, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkBindBufferMemoryInfoKHR, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkBindBufferMemoryInfoKHR where + type FieldType "sType" VkBindBufferMemoryInfoKHR = VkStructureType + type FieldOptional "sType" VkBindBufferMemoryInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkBindBufferMemoryInfoKHR = + #{offset VkBindBufferMemoryInfoKHR, sType} + type FieldIsArray "sType" VkBindBufferMemoryInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkBindBufferMemoryInfoKHR, sType} + +instance CanReadField "sType" VkBindBufferMemoryInfoKHR where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkBindBufferMemoryInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} HasVkPNext VkBindBufferMemoryInfoKHR + where + type VkPNextMType VkBindBufferMemoryInfoKHR = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkBindBufferMemoryInfoKHR, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkBindBufferMemoryInfoKHR, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkBindBufferMemoryInfoKHR, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkBindBufferMemoryInfoKHR, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkBindBufferMemoryInfoKHR where + type FieldType "pNext" VkBindBufferMemoryInfoKHR = Ptr Void + type FieldOptional "pNext" VkBindBufferMemoryInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkBindBufferMemoryInfoKHR = + #{offset VkBindBufferMemoryInfoKHR, pNext} + type FieldIsArray "pNext" VkBindBufferMemoryInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkBindBufferMemoryInfoKHR, pNext} + +instance CanReadField "pNext" VkBindBufferMemoryInfoKHR where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkBindBufferMemoryInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} HasVkBuffer VkBindBufferMemoryInfoKHR + where + type VkBufferMType VkBindBufferMemoryInfoKHR = VkBuffer + + {-# NOINLINE vkBuffer #-} + vkBuffer x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkBindBufferMemoryInfoKHR, buffer}) + + {-# INLINE vkBufferByteOffset #-} + vkBufferByteOffset ~_ + = #{offset VkBindBufferMemoryInfoKHR, buffer} + + {-# INLINE readVkBuffer #-} + readVkBuffer p + = peekByteOff p #{offset VkBindBufferMemoryInfoKHR, buffer} + + {-# INLINE writeVkBuffer #-} + writeVkBuffer p + = pokeByteOff p #{offset VkBindBufferMemoryInfoKHR, buffer} + +instance {-# OVERLAPPING #-} + HasField "buffer" VkBindBufferMemoryInfoKHR where + type FieldType "buffer" VkBindBufferMemoryInfoKHR = VkBuffer + type FieldOptional "buffer" VkBindBufferMemoryInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "buffer" VkBindBufferMemoryInfoKHR = + #{offset VkBindBufferMemoryInfoKHR, buffer} + type FieldIsArray "buffer" VkBindBufferMemoryInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkBindBufferMemoryInfoKHR, buffer} + +instance CanReadField "buffer" VkBindBufferMemoryInfoKHR where + {-# INLINE getField #-} + getField = vkBuffer + + {-# INLINE readField #-} + readField = readVkBuffer + +instance CanWriteField "buffer" VkBindBufferMemoryInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkBuffer + +instance {-# OVERLAPPING #-} HasVkMemory VkBindBufferMemoryInfoKHR + where + type VkMemoryMType VkBindBufferMemoryInfoKHR = VkDeviceMemory + + {-# NOINLINE vkMemory #-} + vkMemory x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkBindBufferMemoryInfoKHR, memory}) + + {-# INLINE vkMemoryByteOffset #-} + vkMemoryByteOffset ~_ + = #{offset VkBindBufferMemoryInfoKHR, memory} + + {-# INLINE readVkMemory #-} + readVkMemory p + = peekByteOff p #{offset VkBindBufferMemoryInfoKHR, memory} + + {-# INLINE writeVkMemory #-} + writeVkMemory p + = pokeByteOff p #{offset VkBindBufferMemoryInfoKHR, memory} + +instance {-# OVERLAPPING #-} + HasField "memory" VkBindBufferMemoryInfoKHR where + type FieldType "memory" VkBindBufferMemoryInfoKHR = VkDeviceMemory + type FieldOptional "memory" VkBindBufferMemoryInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "memory" VkBindBufferMemoryInfoKHR = + #{offset VkBindBufferMemoryInfoKHR, memory} + type FieldIsArray "memory" VkBindBufferMemoryInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkBindBufferMemoryInfoKHR, memory} + +instance CanReadField "memory" VkBindBufferMemoryInfoKHR where + {-# INLINE getField #-} + getField = vkMemory + + {-# INLINE readField #-} + readField = readVkMemory + +instance CanWriteField "memory" VkBindBufferMemoryInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkMemory + +instance {-# OVERLAPPING #-} + HasVkMemoryOffset VkBindBufferMemoryInfoKHR where + type VkMemoryOffsetMType VkBindBufferMemoryInfoKHR = VkDeviceSize + + {-# NOINLINE vkMemoryOffset #-} + vkMemoryOffset x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkBindBufferMemoryInfoKHR, memoryOffset}) + + {-# INLINE vkMemoryOffsetByteOffset #-} + vkMemoryOffsetByteOffset ~_ + = #{offset VkBindBufferMemoryInfoKHR, memoryOffset} + + {-# INLINE readVkMemoryOffset #-} + readVkMemoryOffset p + = peekByteOff p #{offset VkBindBufferMemoryInfoKHR, memoryOffset} + + {-# INLINE writeVkMemoryOffset #-} + writeVkMemoryOffset p + = pokeByteOff p #{offset VkBindBufferMemoryInfoKHR, memoryOffset} + +instance {-# OVERLAPPING #-} + HasField "memoryOffset" VkBindBufferMemoryInfoKHR where + type FieldType "memoryOffset" VkBindBufferMemoryInfoKHR = + VkDeviceSize + type FieldOptional "memoryOffset" VkBindBufferMemoryInfoKHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "memoryOffset" VkBindBufferMemoryInfoKHR = + #{offset VkBindBufferMemoryInfoKHR, memoryOffset} + type FieldIsArray "memoryOffset" VkBindBufferMemoryInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkBindBufferMemoryInfoKHR, memoryOffset} + +instance CanReadField "memoryOffset" VkBindBufferMemoryInfoKHR + where + {-# INLINE getField #-} + getField = vkMemoryOffset + + {-# INLINE readField #-} + readField = readVkMemoryOffset + +instance CanWriteField "memoryOffset" VkBindBufferMemoryInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkMemoryOffset + +instance Show VkBindBufferMemoryInfoKHR where + showsPrec d x + = showString "VkBindBufferMemoryInfoKHR {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkBuffer = " . + showsPrec d (vkBuffer x) . + showString ", " . + showString "vkMemory = " . + showsPrec d (vkMemory x) . + showString ", " . + showString "vkMemoryOffset = " . + showsPrec d (vkMemoryOffset x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkBindImageMemoryDeviceGroupInfoKHX.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkBindImageMemoryDeviceGroupInfoKHX.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkBindImageMemoryDeviceGroupInfoKHX.hsc @@ -0,0 +1,444 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkBindImageMemoryDeviceGroupInfoKHX + (VkBindImageMemoryDeviceGroupInfoKHX(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Struct.VkBindImageMemoryInfoKHR (VkBindImageMemoryInfoKHR) +import Graphics.Vulkan.Types.Struct.VkRect2D (VkRect2D) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkBindImageMemoryDeviceGroupInfoKHX { +-- > VkStructureType sType; +-- > const void* pNext; +-- > uint32_t deviceIndexCount; +-- > const uint32_t* pDeviceIndices; +-- > uint32_t SFRRectCount; +-- > const VkRect2D* pSFRRects; +-- > } VkBindImageMemoryDeviceGroupInfoKHX; +-- +-- +data VkBindImageMemoryDeviceGroupInfoKHX = VkBindImageMemoryDeviceGroupInfoKHX## Addr## + ByteArray## + +instance Eq VkBindImageMemoryDeviceGroupInfoKHX where + (VkBindImageMemoryDeviceGroupInfoKHX## a _) == + x@(VkBindImageMemoryDeviceGroupInfoKHX## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkBindImageMemoryDeviceGroupInfoKHX where + (VkBindImageMemoryDeviceGroupInfoKHX## a _) `compare` + x@(VkBindImageMemoryDeviceGroupInfoKHX## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkBindImageMemoryDeviceGroupInfoKHX where + sizeOf ~_ = #{size VkBindImageMemoryDeviceGroupInfoKHX} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkBindImageMemoryDeviceGroupInfoKHX} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkBindImageMemoryDeviceGroupInfoKHX + where + unsafeAddr (VkBindImageMemoryDeviceGroupInfoKHX## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkBindImageMemoryDeviceGroupInfoKHX## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkBindImageMemoryDeviceGroupInfoKHX## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkBindImageMemoryDeviceGroupInfoKHX where + type StructFields VkBindImageMemoryDeviceGroupInfoKHX = + '["sType", "pNext", "deviceIndexCount", "pDeviceIndices", -- ' closing tick for hsc2hs + "SFRRectCount", "pSFRRects"] + type CUnionType VkBindImageMemoryDeviceGroupInfoKHX = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkBindImageMemoryDeviceGroupInfoKHX = 'False -- ' closing tick for hsc2hs + type StructExtends VkBindImageMemoryDeviceGroupInfoKHX = + '[VkBindImageMemoryInfoKHR] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkBindImageMemoryDeviceGroupInfoKHX where + type VkSTypeMType VkBindImageMemoryDeviceGroupInfoKHX = + VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkBindImageMemoryDeviceGroupInfoKHX, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkBindImageMemoryDeviceGroupInfoKHX, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkBindImageMemoryDeviceGroupInfoKHX, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkBindImageMemoryDeviceGroupInfoKHX, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkBindImageMemoryDeviceGroupInfoKHX where + type FieldType "sType" VkBindImageMemoryDeviceGroupInfoKHX = + VkStructureType + type FieldOptional "sType" VkBindImageMemoryDeviceGroupInfoKHX = + 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkBindImageMemoryDeviceGroupInfoKHX = + #{offset VkBindImageMemoryDeviceGroupInfoKHX, sType} + type FieldIsArray "sType" VkBindImageMemoryDeviceGroupInfoKHX = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkBindImageMemoryDeviceGroupInfoKHX, sType} + +instance CanReadField "sType" VkBindImageMemoryDeviceGroupInfoKHX + where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkBindImageMemoryDeviceGroupInfoKHX + where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkBindImageMemoryDeviceGroupInfoKHX where + type VkPNextMType VkBindImageMemoryDeviceGroupInfoKHX = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkBindImageMemoryDeviceGroupInfoKHX, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkBindImageMemoryDeviceGroupInfoKHX, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkBindImageMemoryDeviceGroupInfoKHX, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkBindImageMemoryDeviceGroupInfoKHX, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkBindImageMemoryDeviceGroupInfoKHX where + type FieldType "pNext" VkBindImageMemoryDeviceGroupInfoKHX = + Ptr Void + type FieldOptional "pNext" VkBindImageMemoryDeviceGroupInfoKHX = + 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkBindImageMemoryDeviceGroupInfoKHX = + #{offset VkBindImageMemoryDeviceGroupInfoKHX, pNext} + type FieldIsArray "pNext" VkBindImageMemoryDeviceGroupInfoKHX = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkBindImageMemoryDeviceGroupInfoKHX, pNext} + +instance CanReadField "pNext" VkBindImageMemoryDeviceGroupInfoKHX + where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkBindImageMemoryDeviceGroupInfoKHX + where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkDeviceIndexCount VkBindImageMemoryDeviceGroupInfoKHX where + type VkDeviceIndexCountMType VkBindImageMemoryDeviceGroupInfoKHX = + Word32 + + {-# NOINLINE vkDeviceIndexCount #-} + vkDeviceIndexCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkBindImageMemoryDeviceGroupInfoKHX, deviceIndexCount}) + + {-# INLINE vkDeviceIndexCountByteOffset #-} + vkDeviceIndexCountByteOffset ~_ + = #{offset VkBindImageMemoryDeviceGroupInfoKHX, deviceIndexCount} + + {-# INLINE readVkDeviceIndexCount #-} + readVkDeviceIndexCount p + = peekByteOff p #{offset VkBindImageMemoryDeviceGroupInfoKHX, deviceIndexCount} + + {-# INLINE writeVkDeviceIndexCount #-} + writeVkDeviceIndexCount p + = pokeByteOff p #{offset VkBindImageMemoryDeviceGroupInfoKHX, deviceIndexCount} + +instance {-# OVERLAPPING #-} + HasField "deviceIndexCount" VkBindImageMemoryDeviceGroupInfoKHX + where + type FieldType "deviceIndexCount" + VkBindImageMemoryDeviceGroupInfoKHX + = Word32 + type FieldOptional "deviceIndexCount" + VkBindImageMemoryDeviceGroupInfoKHX + = 'True -- ' closing tick for hsc2hs + type FieldOffset "deviceIndexCount" + VkBindImageMemoryDeviceGroupInfoKHX + = + #{offset VkBindImageMemoryDeviceGroupInfoKHX, deviceIndexCount} + type FieldIsArray "deviceIndexCount" + VkBindImageMemoryDeviceGroupInfoKHX + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkBindImageMemoryDeviceGroupInfoKHX, deviceIndexCount} + +instance CanReadField "deviceIndexCount" + VkBindImageMemoryDeviceGroupInfoKHX + where + {-# INLINE getField #-} + getField = vkDeviceIndexCount + + {-# INLINE readField #-} + readField = readVkDeviceIndexCount + +instance CanWriteField "deviceIndexCount" + VkBindImageMemoryDeviceGroupInfoKHX + where + {-# INLINE writeField #-} + writeField = writeVkDeviceIndexCount + +instance {-# OVERLAPPING #-} + HasVkPDeviceIndices VkBindImageMemoryDeviceGroupInfoKHX where + type VkPDeviceIndicesMType VkBindImageMemoryDeviceGroupInfoKHX = + Ptr Word32 + + {-# NOINLINE vkPDeviceIndices #-} + vkPDeviceIndices x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkBindImageMemoryDeviceGroupInfoKHX, pDeviceIndices}) + + {-# INLINE vkPDeviceIndicesByteOffset #-} + vkPDeviceIndicesByteOffset ~_ + = #{offset VkBindImageMemoryDeviceGroupInfoKHX, pDeviceIndices} + + {-# INLINE readVkPDeviceIndices #-} + readVkPDeviceIndices p + = peekByteOff p #{offset VkBindImageMemoryDeviceGroupInfoKHX, pDeviceIndices} + + {-# INLINE writeVkPDeviceIndices #-} + writeVkPDeviceIndices p + = pokeByteOff p #{offset VkBindImageMemoryDeviceGroupInfoKHX, pDeviceIndices} + +instance {-# OVERLAPPING #-} + HasField "pDeviceIndices" VkBindImageMemoryDeviceGroupInfoKHX where + type FieldType "pDeviceIndices" VkBindImageMemoryDeviceGroupInfoKHX + = Ptr Word32 + type FieldOptional "pDeviceIndices" + VkBindImageMemoryDeviceGroupInfoKHX + = 'False -- ' closing tick for hsc2hs + type FieldOffset "pDeviceIndices" + VkBindImageMemoryDeviceGroupInfoKHX + = + #{offset VkBindImageMemoryDeviceGroupInfoKHX, pDeviceIndices} + type FieldIsArray "pDeviceIndices" + VkBindImageMemoryDeviceGroupInfoKHX + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkBindImageMemoryDeviceGroupInfoKHX, pDeviceIndices} + +instance CanReadField "pDeviceIndices" + VkBindImageMemoryDeviceGroupInfoKHX + where + {-# INLINE getField #-} + getField = vkPDeviceIndices + + {-# INLINE readField #-} + readField = readVkPDeviceIndices + +instance CanWriteField "pDeviceIndices" + VkBindImageMemoryDeviceGroupInfoKHX + where + {-# INLINE writeField #-} + writeField = writeVkPDeviceIndices + +instance {-# OVERLAPPING #-} + HasVkSFRRectCount VkBindImageMemoryDeviceGroupInfoKHX where + type VkSFRRectCountMType VkBindImageMemoryDeviceGroupInfoKHX = + Word32 + + {-# NOINLINE vkSFRRectCount #-} + vkSFRRectCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkBindImageMemoryDeviceGroupInfoKHX, SFRRectCount}) + + {-# INLINE vkSFRRectCountByteOffset #-} + vkSFRRectCountByteOffset ~_ + = #{offset VkBindImageMemoryDeviceGroupInfoKHX, SFRRectCount} + + {-# INLINE readVkSFRRectCount #-} + readVkSFRRectCount p + = peekByteOff p #{offset VkBindImageMemoryDeviceGroupInfoKHX, SFRRectCount} + + {-# INLINE writeVkSFRRectCount #-} + writeVkSFRRectCount p + = pokeByteOff p #{offset VkBindImageMemoryDeviceGroupInfoKHX, SFRRectCount} + +instance {-# OVERLAPPING #-} + HasField "SFRRectCount" VkBindImageMemoryDeviceGroupInfoKHX where + type FieldType "SFRRectCount" VkBindImageMemoryDeviceGroupInfoKHX = + Word32 + type FieldOptional "SFRRectCount" + VkBindImageMemoryDeviceGroupInfoKHX + = 'True -- ' closing tick for hsc2hs + type FieldOffset "SFRRectCount" VkBindImageMemoryDeviceGroupInfoKHX + = + #{offset VkBindImageMemoryDeviceGroupInfoKHX, SFRRectCount} + type FieldIsArray "SFRRectCount" + VkBindImageMemoryDeviceGroupInfoKHX + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkBindImageMemoryDeviceGroupInfoKHX, SFRRectCount} + +instance CanReadField "SFRRectCount" + VkBindImageMemoryDeviceGroupInfoKHX + where + {-# INLINE getField #-} + getField = vkSFRRectCount + + {-# INLINE readField #-} + readField = readVkSFRRectCount + +instance CanWriteField "SFRRectCount" + VkBindImageMemoryDeviceGroupInfoKHX + where + {-# INLINE writeField #-} + writeField = writeVkSFRRectCount + +instance {-# OVERLAPPING #-} + HasVkPSFRRects VkBindImageMemoryDeviceGroupInfoKHX where + type VkPSFRRectsMType VkBindImageMemoryDeviceGroupInfoKHX = + Ptr VkRect2D + + {-# NOINLINE vkPSFRRects #-} + vkPSFRRects x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkBindImageMemoryDeviceGroupInfoKHX, pSFRRects}) + + {-# INLINE vkPSFRRectsByteOffset #-} + vkPSFRRectsByteOffset ~_ + = #{offset VkBindImageMemoryDeviceGroupInfoKHX, pSFRRects} + + {-# INLINE readVkPSFRRects #-} + readVkPSFRRects p + = peekByteOff p #{offset VkBindImageMemoryDeviceGroupInfoKHX, pSFRRects} + + {-# INLINE writeVkPSFRRects #-} + writeVkPSFRRects p + = pokeByteOff p #{offset VkBindImageMemoryDeviceGroupInfoKHX, pSFRRects} + +instance {-# OVERLAPPING #-} + HasField "pSFRRects" VkBindImageMemoryDeviceGroupInfoKHX where + type FieldType "pSFRRects" VkBindImageMemoryDeviceGroupInfoKHX = + Ptr VkRect2D + type FieldOptional "pSFRRects" VkBindImageMemoryDeviceGroupInfoKHX + = 'False -- ' closing tick for hsc2hs + type FieldOffset "pSFRRects" VkBindImageMemoryDeviceGroupInfoKHX = + #{offset VkBindImageMemoryDeviceGroupInfoKHX, pSFRRects} + type FieldIsArray "pSFRRects" VkBindImageMemoryDeviceGroupInfoKHX = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkBindImageMemoryDeviceGroupInfoKHX, pSFRRects} + +instance CanReadField "pSFRRects" + VkBindImageMemoryDeviceGroupInfoKHX + where + {-# INLINE getField #-} + getField = vkPSFRRects + + {-# INLINE readField #-} + readField = readVkPSFRRects + +instance CanWriteField "pSFRRects" + VkBindImageMemoryDeviceGroupInfoKHX + where + {-# INLINE writeField #-} + writeField = writeVkPSFRRects + +instance Show VkBindImageMemoryDeviceGroupInfoKHX where + showsPrec d x + = showString "VkBindImageMemoryDeviceGroupInfoKHX {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkDeviceIndexCount = " . + showsPrec d (vkDeviceIndexCount x) . + showString ", " . + showString "vkPDeviceIndices = " . + showsPrec d (vkPDeviceIndices x) . + showString ", " . + showString "vkSFRRectCount = " . + showsPrec d (vkSFRRectCount x) . + showString ", " . + showString "vkPSFRRects = " . + showsPrec d (vkPSFRRects x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkBindImageMemoryInfoKHR.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkBindImageMemoryInfoKHR.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkBindImageMemoryInfoKHR.hsc @@ -0,0 +1,330 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkBindImageMemoryInfoKHR + (VkBindImageMemoryInfoKHR(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.BaseTypes (VkDeviceSize) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Handles (VkDeviceMemory, + VkImage) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkBindImageMemoryInfoKHR { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkImage image; +-- > VkDeviceMemory memory; +-- > VkDeviceSize memoryOffset; +-- > } VkBindImageMemoryInfoKHR; +-- +-- +data VkBindImageMemoryInfoKHR = VkBindImageMemoryInfoKHR## Addr## + ByteArray## + +instance Eq VkBindImageMemoryInfoKHR where + (VkBindImageMemoryInfoKHR## a _) == + x@(VkBindImageMemoryInfoKHR## b _) = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkBindImageMemoryInfoKHR where + (VkBindImageMemoryInfoKHR## a _) `compare` + x@(VkBindImageMemoryInfoKHR## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkBindImageMemoryInfoKHR where + sizeOf ~_ = #{size VkBindImageMemoryInfoKHR} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkBindImageMemoryInfoKHR} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkBindImageMemoryInfoKHR where + unsafeAddr (VkBindImageMemoryInfoKHR## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkBindImageMemoryInfoKHR## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkBindImageMemoryInfoKHR## (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkBindImageMemoryInfoKHR where + type StructFields VkBindImageMemoryInfoKHR = + '["sType", "pNext", "image", "memory", "memoryOffset"] -- ' closing tick for hsc2hs + type CUnionType VkBindImageMemoryInfoKHR = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkBindImageMemoryInfoKHR = 'False -- ' closing tick for hsc2hs + type StructExtends VkBindImageMemoryInfoKHR = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkSType VkBindImageMemoryInfoKHR + where + type VkSTypeMType VkBindImageMemoryInfoKHR = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkBindImageMemoryInfoKHR, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkBindImageMemoryInfoKHR, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkBindImageMemoryInfoKHR, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkBindImageMemoryInfoKHR, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkBindImageMemoryInfoKHR where + type FieldType "sType" VkBindImageMemoryInfoKHR = VkStructureType + type FieldOptional "sType" VkBindImageMemoryInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkBindImageMemoryInfoKHR = + #{offset VkBindImageMemoryInfoKHR, sType} + type FieldIsArray "sType" VkBindImageMemoryInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkBindImageMemoryInfoKHR, sType} + +instance CanReadField "sType" VkBindImageMemoryInfoKHR where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkBindImageMemoryInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} HasVkPNext VkBindImageMemoryInfoKHR + where + type VkPNextMType VkBindImageMemoryInfoKHR = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkBindImageMemoryInfoKHR, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkBindImageMemoryInfoKHR, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkBindImageMemoryInfoKHR, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkBindImageMemoryInfoKHR, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkBindImageMemoryInfoKHR where + type FieldType "pNext" VkBindImageMemoryInfoKHR = Ptr Void + type FieldOptional "pNext" VkBindImageMemoryInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkBindImageMemoryInfoKHR = + #{offset VkBindImageMemoryInfoKHR, pNext} + type FieldIsArray "pNext" VkBindImageMemoryInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkBindImageMemoryInfoKHR, pNext} + +instance CanReadField "pNext" VkBindImageMemoryInfoKHR where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkBindImageMemoryInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} HasVkImage VkBindImageMemoryInfoKHR + where + type VkImageMType VkBindImageMemoryInfoKHR = VkImage + + {-# NOINLINE vkImage #-} + vkImage x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkBindImageMemoryInfoKHR, image}) + + {-# INLINE vkImageByteOffset #-} + vkImageByteOffset ~_ + = #{offset VkBindImageMemoryInfoKHR, image} + + {-# INLINE readVkImage #-} + readVkImage p + = peekByteOff p #{offset VkBindImageMemoryInfoKHR, image} + + {-# INLINE writeVkImage #-} + writeVkImage p + = pokeByteOff p #{offset VkBindImageMemoryInfoKHR, image} + +instance {-# OVERLAPPING #-} + HasField "image" VkBindImageMemoryInfoKHR where + type FieldType "image" VkBindImageMemoryInfoKHR = VkImage + type FieldOptional "image" VkBindImageMemoryInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "image" VkBindImageMemoryInfoKHR = + #{offset VkBindImageMemoryInfoKHR, image} + type FieldIsArray "image" VkBindImageMemoryInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkBindImageMemoryInfoKHR, image} + +instance CanReadField "image" VkBindImageMemoryInfoKHR where + {-# INLINE getField #-} + getField = vkImage + + {-# INLINE readField #-} + readField = readVkImage + +instance CanWriteField "image" VkBindImageMemoryInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkImage + +instance {-# OVERLAPPING #-} HasVkMemory VkBindImageMemoryInfoKHR + where + type VkMemoryMType VkBindImageMemoryInfoKHR = VkDeviceMemory + + {-# NOINLINE vkMemory #-} + vkMemory x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkBindImageMemoryInfoKHR, memory}) + + {-# INLINE vkMemoryByteOffset #-} + vkMemoryByteOffset ~_ + = #{offset VkBindImageMemoryInfoKHR, memory} + + {-# INLINE readVkMemory #-} + readVkMemory p + = peekByteOff p #{offset VkBindImageMemoryInfoKHR, memory} + + {-# INLINE writeVkMemory #-} + writeVkMemory p + = pokeByteOff p #{offset VkBindImageMemoryInfoKHR, memory} + +instance {-# OVERLAPPING #-} + HasField "memory" VkBindImageMemoryInfoKHR where + type FieldType "memory" VkBindImageMemoryInfoKHR = VkDeviceMemory + type FieldOptional "memory" VkBindImageMemoryInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "memory" VkBindImageMemoryInfoKHR = + #{offset VkBindImageMemoryInfoKHR, memory} + type FieldIsArray "memory" VkBindImageMemoryInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkBindImageMemoryInfoKHR, memory} + +instance CanReadField "memory" VkBindImageMemoryInfoKHR where + {-# INLINE getField #-} + getField = vkMemory + + {-# INLINE readField #-} + readField = readVkMemory + +instance CanWriteField "memory" VkBindImageMemoryInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkMemory + +instance {-# OVERLAPPING #-} + HasVkMemoryOffset VkBindImageMemoryInfoKHR where + type VkMemoryOffsetMType VkBindImageMemoryInfoKHR = VkDeviceSize + + {-# NOINLINE vkMemoryOffset #-} + vkMemoryOffset x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkBindImageMemoryInfoKHR, memoryOffset}) + + {-# INLINE vkMemoryOffsetByteOffset #-} + vkMemoryOffsetByteOffset ~_ + = #{offset VkBindImageMemoryInfoKHR, memoryOffset} + + {-# INLINE readVkMemoryOffset #-} + readVkMemoryOffset p + = peekByteOff p #{offset VkBindImageMemoryInfoKHR, memoryOffset} + + {-# INLINE writeVkMemoryOffset #-} + writeVkMemoryOffset p + = pokeByteOff p #{offset VkBindImageMemoryInfoKHR, memoryOffset} + +instance {-# OVERLAPPING #-} + HasField "memoryOffset" VkBindImageMemoryInfoKHR where + type FieldType "memoryOffset" VkBindImageMemoryInfoKHR = + VkDeviceSize + type FieldOptional "memoryOffset" VkBindImageMemoryInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "memoryOffset" VkBindImageMemoryInfoKHR = + #{offset VkBindImageMemoryInfoKHR, memoryOffset} + type FieldIsArray "memoryOffset" VkBindImageMemoryInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkBindImageMemoryInfoKHR, memoryOffset} + +instance CanReadField "memoryOffset" VkBindImageMemoryInfoKHR where + {-# INLINE getField #-} + getField = vkMemoryOffset + + {-# INLINE readField #-} + readField = readVkMemoryOffset + +instance CanWriteField "memoryOffset" VkBindImageMemoryInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkMemoryOffset + +instance Show VkBindImageMemoryInfoKHR where + showsPrec d x + = showString "VkBindImageMemoryInfoKHR {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkImage = " . + showsPrec d (vkImage x) . + showString ", " . + showString "vkMemory = " . + showsPrec d (vkMemory x) . + showString ", " . + showString "vkMemoryOffset = " . + showsPrec d (vkMemoryOffset x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkBindImageMemorySwapchainInfoKHX.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkBindImageMemorySwapchainInfoKHX.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkBindImageMemorySwapchainInfoKHX.hsc @@ -0,0 +1,308 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkBindImageMemorySwapchainInfoKHX + (VkBindImageMemorySwapchainInfoKHX(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Handles (VkSwapchainKHR) +import Graphics.Vulkan.Types.Struct.VkBindImageMemoryInfoKHR (VkBindImageMemoryInfoKHR) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkBindImageMemorySwapchainInfoKHX { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkSwapchainKHR swapchain; +-- > uint32_t imageIndex; +-- > } VkBindImageMemorySwapchainInfoKHX; +-- +-- +data VkBindImageMemorySwapchainInfoKHX = VkBindImageMemorySwapchainInfoKHX## Addr## + ByteArray## + +instance Eq VkBindImageMemorySwapchainInfoKHX where + (VkBindImageMemorySwapchainInfoKHX## a _) == + x@(VkBindImageMemorySwapchainInfoKHX## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkBindImageMemorySwapchainInfoKHX where + (VkBindImageMemorySwapchainInfoKHX## a _) `compare` + x@(VkBindImageMemorySwapchainInfoKHX## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkBindImageMemorySwapchainInfoKHX where + sizeOf ~_ = #{size VkBindImageMemorySwapchainInfoKHX} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkBindImageMemorySwapchainInfoKHX} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkBindImageMemorySwapchainInfoKHX where + unsafeAddr (VkBindImageMemorySwapchainInfoKHX## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkBindImageMemorySwapchainInfoKHX## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkBindImageMemorySwapchainInfoKHX## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkBindImageMemorySwapchainInfoKHX where + type StructFields VkBindImageMemorySwapchainInfoKHX = + '["sType", "pNext", "swapchain", "imageIndex"] -- ' closing tick for hsc2hs + type CUnionType VkBindImageMemorySwapchainInfoKHX = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkBindImageMemorySwapchainInfoKHX = 'False -- ' closing tick for hsc2hs + type StructExtends VkBindImageMemorySwapchainInfoKHX = + '[VkBindImageMemoryInfoKHR] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkBindImageMemorySwapchainInfoKHX where + type VkSTypeMType VkBindImageMemorySwapchainInfoKHX = + VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkBindImageMemorySwapchainInfoKHX, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkBindImageMemorySwapchainInfoKHX, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkBindImageMemorySwapchainInfoKHX, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkBindImageMemorySwapchainInfoKHX, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkBindImageMemorySwapchainInfoKHX where + type FieldType "sType" VkBindImageMemorySwapchainInfoKHX = + VkStructureType + type FieldOptional "sType" VkBindImageMemorySwapchainInfoKHX = + 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkBindImageMemorySwapchainInfoKHX = + #{offset VkBindImageMemorySwapchainInfoKHX, sType} + type FieldIsArray "sType" VkBindImageMemorySwapchainInfoKHX = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkBindImageMemorySwapchainInfoKHX, sType} + +instance CanReadField "sType" VkBindImageMemorySwapchainInfoKHX + where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkBindImageMemorySwapchainInfoKHX + where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkBindImageMemorySwapchainInfoKHX where + type VkPNextMType VkBindImageMemorySwapchainInfoKHX = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkBindImageMemorySwapchainInfoKHX, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkBindImageMemorySwapchainInfoKHX, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkBindImageMemorySwapchainInfoKHX, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkBindImageMemorySwapchainInfoKHX, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkBindImageMemorySwapchainInfoKHX where + type FieldType "pNext" VkBindImageMemorySwapchainInfoKHX = Ptr Void + type FieldOptional "pNext" VkBindImageMemorySwapchainInfoKHX = + 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkBindImageMemorySwapchainInfoKHX = + #{offset VkBindImageMemorySwapchainInfoKHX, pNext} + type FieldIsArray "pNext" VkBindImageMemorySwapchainInfoKHX = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkBindImageMemorySwapchainInfoKHX, pNext} + +instance CanReadField "pNext" VkBindImageMemorySwapchainInfoKHX + where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkBindImageMemorySwapchainInfoKHX + where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkSwapchain VkBindImageMemorySwapchainInfoKHX where + type VkSwapchainMType VkBindImageMemorySwapchainInfoKHX = + VkSwapchainKHR + + {-# NOINLINE vkSwapchain #-} + vkSwapchain x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkBindImageMemorySwapchainInfoKHX, swapchain}) + + {-# INLINE vkSwapchainByteOffset #-} + vkSwapchainByteOffset ~_ + = #{offset VkBindImageMemorySwapchainInfoKHX, swapchain} + + {-# INLINE readVkSwapchain #-} + readVkSwapchain p + = peekByteOff p #{offset VkBindImageMemorySwapchainInfoKHX, swapchain} + + {-# INLINE writeVkSwapchain #-} + writeVkSwapchain p + = pokeByteOff p #{offset VkBindImageMemorySwapchainInfoKHX, swapchain} + +instance {-# OVERLAPPING #-} + HasField "swapchain" VkBindImageMemorySwapchainInfoKHX where + type FieldType "swapchain" VkBindImageMemorySwapchainInfoKHX = + VkSwapchainKHR + type FieldOptional "swapchain" VkBindImageMemorySwapchainInfoKHX = + 'False -- ' closing tick for hsc2hs + type FieldOffset "swapchain" VkBindImageMemorySwapchainInfoKHX = + #{offset VkBindImageMemorySwapchainInfoKHX, swapchain} + type FieldIsArray "swapchain" VkBindImageMemorySwapchainInfoKHX = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkBindImageMemorySwapchainInfoKHX, swapchain} + +instance CanReadField "swapchain" VkBindImageMemorySwapchainInfoKHX + where + {-# INLINE getField #-} + getField = vkSwapchain + + {-# INLINE readField #-} + readField = readVkSwapchain + +instance CanWriteField "swapchain" + VkBindImageMemorySwapchainInfoKHX + where + {-# INLINE writeField #-} + writeField = writeVkSwapchain + +instance {-# OVERLAPPING #-} + HasVkImageIndex VkBindImageMemorySwapchainInfoKHX where + type VkImageIndexMType VkBindImageMemorySwapchainInfoKHX = Word32 + + {-# NOINLINE vkImageIndex #-} + vkImageIndex x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkBindImageMemorySwapchainInfoKHX, imageIndex}) + + {-# INLINE vkImageIndexByteOffset #-} + vkImageIndexByteOffset ~_ + = #{offset VkBindImageMemorySwapchainInfoKHX, imageIndex} + + {-# INLINE readVkImageIndex #-} + readVkImageIndex p + = peekByteOff p #{offset VkBindImageMemorySwapchainInfoKHX, imageIndex} + + {-# INLINE writeVkImageIndex #-} + writeVkImageIndex p + = pokeByteOff p #{offset VkBindImageMemorySwapchainInfoKHX, imageIndex} + +instance {-# OVERLAPPING #-} + HasField "imageIndex" VkBindImageMemorySwapchainInfoKHX where + type FieldType "imageIndex" VkBindImageMemorySwapchainInfoKHX = + Word32 + type FieldOptional "imageIndex" VkBindImageMemorySwapchainInfoKHX = + 'False -- ' closing tick for hsc2hs + type FieldOffset "imageIndex" VkBindImageMemorySwapchainInfoKHX = + #{offset VkBindImageMemorySwapchainInfoKHX, imageIndex} + type FieldIsArray "imageIndex" VkBindImageMemorySwapchainInfoKHX = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkBindImageMemorySwapchainInfoKHX, imageIndex} + +instance CanReadField "imageIndex" + VkBindImageMemorySwapchainInfoKHX + where + {-# INLINE getField #-} + getField = vkImageIndex + + {-# INLINE readField #-} + readField = readVkImageIndex + +instance CanWriteField "imageIndex" + VkBindImageMemorySwapchainInfoKHX + where + {-# INLINE writeField #-} + writeField = writeVkImageIndex + +instance Show VkBindImageMemorySwapchainInfoKHX where + showsPrec d x + = showString "VkBindImageMemorySwapchainInfoKHX {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkSwapchain = " . + showsPrec d (vkSwapchain x) . + showString ", " . + showString "vkImageIndex = " . + showsPrec d (vkImageIndex x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkBindImagePlaneMemoryInfoKHR.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkBindImagePlaneMemoryInfoKHR.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkBindImagePlaneMemoryInfoKHR.hsc @@ -0,0 +1,239 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkBindImagePlaneMemoryInfoKHR + (VkBindImagePlaneMemoryInfoKHR(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkImageAspectFlags (VkImageAspectFlagBits) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Struct.VkBindImageMemoryInfoKHR (VkBindImageMemoryInfoKHR) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkBindImagePlaneMemoryInfoKHR { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkImageAspectFlagBits planeAspect; +-- > } VkBindImagePlaneMemoryInfoKHR; +-- +-- +data VkBindImagePlaneMemoryInfoKHR = VkBindImagePlaneMemoryInfoKHR## Addr## + ByteArray## + +instance Eq VkBindImagePlaneMemoryInfoKHR where + (VkBindImagePlaneMemoryInfoKHR## a _) == + x@(VkBindImagePlaneMemoryInfoKHR## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkBindImagePlaneMemoryInfoKHR where + (VkBindImagePlaneMemoryInfoKHR## a _) `compare` + x@(VkBindImagePlaneMemoryInfoKHR## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkBindImagePlaneMemoryInfoKHR where + sizeOf ~_ = #{size VkBindImagePlaneMemoryInfoKHR} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkBindImagePlaneMemoryInfoKHR} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkBindImagePlaneMemoryInfoKHR where + unsafeAddr (VkBindImagePlaneMemoryInfoKHR## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkBindImagePlaneMemoryInfoKHR## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkBindImagePlaneMemoryInfoKHR## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkBindImagePlaneMemoryInfoKHR where + type StructFields VkBindImagePlaneMemoryInfoKHR = + '["sType", "pNext", "planeAspect"] -- ' closing tick for hsc2hs + type CUnionType VkBindImagePlaneMemoryInfoKHR = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkBindImagePlaneMemoryInfoKHR = 'False -- ' closing tick for hsc2hs + type StructExtends VkBindImagePlaneMemoryInfoKHR = + '[VkBindImageMemoryInfoKHR] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkBindImagePlaneMemoryInfoKHR where + type VkSTypeMType VkBindImagePlaneMemoryInfoKHR = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkBindImagePlaneMemoryInfoKHR, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkBindImagePlaneMemoryInfoKHR, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkBindImagePlaneMemoryInfoKHR, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkBindImagePlaneMemoryInfoKHR, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkBindImagePlaneMemoryInfoKHR where + type FieldType "sType" VkBindImagePlaneMemoryInfoKHR = + VkStructureType + type FieldOptional "sType" VkBindImagePlaneMemoryInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkBindImagePlaneMemoryInfoKHR = + #{offset VkBindImagePlaneMemoryInfoKHR, sType} + type FieldIsArray "sType" VkBindImagePlaneMemoryInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkBindImagePlaneMemoryInfoKHR, sType} + +instance CanReadField "sType" VkBindImagePlaneMemoryInfoKHR where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkBindImagePlaneMemoryInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkBindImagePlaneMemoryInfoKHR where + type VkPNextMType VkBindImagePlaneMemoryInfoKHR = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkBindImagePlaneMemoryInfoKHR, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkBindImagePlaneMemoryInfoKHR, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkBindImagePlaneMemoryInfoKHR, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkBindImagePlaneMemoryInfoKHR, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkBindImagePlaneMemoryInfoKHR where + type FieldType "pNext" VkBindImagePlaneMemoryInfoKHR = Ptr Void + type FieldOptional "pNext" VkBindImagePlaneMemoryInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkBindImagePlaneMemoryInfoKHR = + #{offset VkBindImagePlaneMemoryInfoKHR, pNext} + type FieldIsArray "pNext" VkBindImagePlaneMemoryInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkBindImagePlaneMemoryInfoKHR, pNext} + +instance CanReadField "pNext" VkBindImagePlaneMemoryInfoKHR where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkBindImagePlaneMemoryInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkPlaneAspect VkBindImagePlaneMemoryInfoKHR where + type VkPlaneAspectMType VkBindImagePlaneMemoryInfoKHR = + VkImageAspectFlagBits + + {-# NOINLINE vkPlaneAspect #-} + vkPlaneAspect x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkBindImagePlaneMemoryInfoKHR, planeAspect}) + + {-# INLINE vkPlaneAspectByteOffset #-} + vkPlaneAspectByteOffset ~_ + = #{offset VkBindImagePlaneMemoryInfoKHR, planeAspect} + + {-# INLINE readVkPlaneAspect #-} + readVkPlaneAspect p + = peekByteOff p #{offset VkBindImagePlaneMemoryInfoKHR, planeAspect} + + {-# INLINE writeVkPlaneAspect #-} + writeVkPlaneAspect p + = pokeByteOff p #{offset VkBindImagePlaneMemoryInfoKHR, planeAspect} + +instance {-# OVERLAPPING #-} + HasField "planeAspect" VkBindImagePlaneMemoryInfoKHR where + type FieldType "planeAspect" VkBindImagePlaneMemoryInfoKHR = + VkImageAspectFlagBits + type FieldOptional "planeAspect" VkBindImagePlaneMemoryInfoKHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "planeAspect" VkBindImagePlaneMemoryInfoKHR = + #{offset VkBindImagePlaneMemoryInfoKHR, planeAspect} + type FieldIsArray "planeAspect" VkBindImagePlaneMemoryInfoKHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkBindImagePlaneMemoryInfoKHR, planeAspect} + +instance CanReadField "planeAspect" VkBindImagePlaneMemoryInfoKHR + where + {-# INLINE getField #-} + getField = vkPlaneAspect + + {-# INLINE readField #-} + readField = readVkPlaneAspect + +instance CanWriteField "planeAspect" VkBindImagePlaneMemoryInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkPlaneAspect + +instance Show VkBindImagePlaneMemoryInfoKHR where + showsPrec d x + = showString "VkBindImagePlaneMemoryInfoKHR {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkPlaneAspect = " . + showsPrec d (vkPlaneAspect x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkBindSparseInfo.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkBindSparseInfo.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkBindSparseInfo.hsc @@ -0,0 +1,704 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkBindSparseInfo + (VkBindSparseInfo(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Handles (VkSemaphore) +import Graphics.Vulkan.Types.Struct.VkSparseBufferMemoryBindInfo (VkSparseBufferMemoryBindInfo) +import Graphics.Vulkan.Types.Struct.VkSparseImageMemoryBindInfo (VkSparseImageMemoryBindInfo) +import Graphics.Vulkan.Types.Struct.VkSparseImageOpaqueMemoryBindInfo (VkSparseImageOpaqueMemoryBindInfo) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkBindSparseInfo { +-- > VkStructureType sType; +-- > const void* pNext; +-- > uint32_t waitSemaphoreCount; +-- > const VkSemaphore* pWaitSemaphores; +-- > uint32_t bufferBindCount; +-- > const VkSparseBufferMemoryBindInfo* pBufferBinds; +-- > uint32_t imageOpaqueBindCount; +-- > const VkSparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds; +-- > uint32_t imageBindCount; +-- > const VkSparseImageMemoryBindInfo* pImageBinds; +-- > uint32_t signalSemaphoreCount; +-- > const VkSemaphore* pSignalSemaphores; +-- > } VkBindSparseInfo; +-- +-- +data VkBindSparseInfo = VkBindSparseInfo## Addr## ByteArray## + +instance Eq VkBindSparseInfo where + (VkBindSparseInfo## a _) == x@(VkBindSparseInfo## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkBindSparseInfo where + (VkBindSparseInfo## a _) `compare` x@(VkBindSparseInfo## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkBindSparseInfo where + sizeOf ~_ = #{size VkBindSparseInfo} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkBindSparseInfo} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkBindSparseInfo where + unsafeAddr (VkBindSparseInfo## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkBindSparseInfo## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkBindSparseInfo## (plusAddr## (byteArrayContents## b) off) b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkBindSparseInfo where + type StructFields VkBindSparseInfo = + '["sType", "pNext", "waitSemaphoreCount", "pWaitSemaphores", -- ' closing tick for hsc2hs + "bufferBindCount", "pBufferBinds", "imageOpaqueBindCount", + "pImageOpaqueBinds", "imageBindCount", "pImageBinds", + "signalSemaphoreCount", "pSignalSemaphores"] + type CUnionType VkBindSparseInfo = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkBindSparseInfo = 'False -- ' closing tick for hsc2hs + type StructExtends VkBindSparseInfo = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkSType VkBindSparseInfo where + type VkSTypeMType VkBindSparseInfo = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkBindSparseInfo, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkBindSparseInfo, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkBindSparseInfo, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkBindSparseInfo, sType} + +instance {-# OVERLAPPING #-} HasField "sType" VkBindSparseInfo + where + type FieldType "sType" VkBindSparseInfo = VkStructureType + type FieldOptional "sType" VkBindSparseInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkBindSparseInfo = + #{offset VkBindSparseInfo, sType} + type FieldIsArray "sType" VkBindSparseInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkBindSparseInfo, sType} + +instance CanReadField "sType" VkBindSparseInfo where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkBindSparseInfo where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} HasVkPNext VkBindSparseInfo where + type VkPNextMType VkBindSparseInfo = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkBindSparseInfo, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkBindSparseInfo, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkBindSparseInfo, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkBindSparseInfo, pNext} + +instance {-# OVERLAPPING #-} HasField "pNext" VkBindSparseInfo + where + type FieldType "pNext" VkBindSparseInfo = Ptr Void + type FieldOptional "pNext" VkBindSparseInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkBindSparseInfo = + #{offset VkBindSparseInfo, pNext} + type FieldIsArray "pNext" VkBindSparseInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkBindSparseInfo, pNext} + +instance CanReadField "pNext" VkBindSparseInfo where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkBindSparseInfo where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkWaitSemaphoreCount VkBindSparseInfo where + type VkWaitSemaphoreCountMType VkBindSparseInfo = Word32 + + {-# NOINLINE vkWaitSemaphoreCount #-} + vkWaitSemaphoreCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkBindSparseInfo, waitSemaphoreCount}) + + {-# INLINE vkWaitSemaphoreCountByteOffset #-} + vkWaitSemaphoreCountByteOffset ~_ + = #{offset VkBindSparseInfo, waitSemaphoreCount} + + {-# INLINE readVkWaitSemaphoreCount #-} + readVkWaitSemaphoreCount p + = peekByteOff p #{offset VkBindSparseInfo, waitSemaphoreCount} + + {-# INLINE writeVkWaitSemaphoreCount #-} + writeVkWaitSemaphoreCount p + = pokeByteOff p #{offset VkBindSparseInfo, waitSemaphoreCount} + +instance {-# OVERLAPPING #-} + HasField "waitSemaphoreCount" VkBindSparseInfo where + type FieldType "waitSemaphoreCount" VkBindSparseInfo = Word32 + type FieldOptional "waitSemaphoreCount" VkBindSparseInfo = 'True -- ' closing tick for hsc2hs + type FieldOffset "waitSemaphoreCount" VkBindSparseInfo = + #{offset VkBindSparseInfo, waitSemaphoreCount} + type FieldIsArray "waitSemaphoreCount" VkBindSparseInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkBindSparseInfo, waitSemaphoreCount} + +instance CanReadField "waitSemaphoreCount" VkBindSparseInfo where + {-# INLINE getField #-} + getField = vkWaitSemaphoreCount + + {-# INLINE readField #-} + readField = readVkWaitSemaphoreCount + +instance CanWriteField "waitSemaphoreCount" VkBindSparseInfo where + {-# INLINE writeField #-} + writeField = writeVkWaitSemaphoreCount + +instance {-# OVERLAPPING #-} HasVkPWaitSemaphores VkBindSparseInfo + where + type VkPWaitSemaphoresMType VkBindSparseInfo = Ptr VkSemaphore + + {-# NOINLINE vkPWaitSemaphores #-} + vkPWaitSemaphores x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkBindSparseInfo, pWaitSemaphores}) + + {-# INLINE vkPWaitSemaphoresByteOffset #-} + vkPWaitSemaphoresByteOffset ~_ + = #{offset VkBindSparseInfo, pWaitSemaphores} + + {-# INLINE readVkPWaitSemaphores #-} + readVkPWaitSemaphores p + = peekByteOff p #{offset VkBindSparseInfo, pWaitSemaphores} + + {-# INLINE writeVkPWaitSemaphores #-} + writeVkPWaitSemaphores p + = pokeByteOff p #{offset VkBindSparseInfo, pWaitSemaphores} + +instance {-# OVERLAPPING #-} + HasField "pWaitSemaphores" VkBindSparseInfo where + type FieldType "pWaitSemaphores" VkBindSparseInfo = Ptr VkSemaphore + type FieldOptional "pWaitSemaphores" VkBindSparseInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "pWaitSemaphores" VkBindSparseInfo = + #{offset VkBindSparseInfo, pWaitSemaphores} + type FieldIsArray "pWaitSemaphores" VkBindSparseInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkBindSparseInfo, pWaitSemaphores} + +instance CanReadField "pWaitSemaphores" VkBindSparseInfo where + {-# INLINE getField #-} + getField = vkPWaitSemaphores + + {-# INLINE readField #-} + readField = readVkPWaitSemaphores + +instance CanWriteField "pWaitSemaphores" VkBindSparseInfo where + {-# INLINE writeField #-} + writeField = writeVkPWaitSemaphores + +instance {-# OVERLAPPING #-} HasVkBufferBindCount VkBindSparseInfo + where + type VkBufferBindCountMType VkBindSparseInfo = Word32 + + {-# NOINLINE vkBufferBindCount #-} + vkBufferBindCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkBindSparseInfo, bufferBindCount}) + + {-# INLINE vkBufferBindCountByteOffset #-} + vkBufferBindCountByteOffset ~_ + = #{offset VkBindSparseInfo, bufferBindCount} + + {-# INLINE readVkBufferBindCount #-} + readVkBufferBindCount p + = peekByteOff p #{offset VkBindSparseInfo, bufferBindCount} + + {-# INLINE writeVkBufferBindCount #-} + writeVkBufferBindCount p + = pokeByteOff p #{offset VkBindSparseInfo, bufferBindCount} + +instance {-# OVERLAPPING #-} + HasField "bufferBindCount" VkBindSparseInfo where + type FieldType "bufferBindCount" VkBindSparseInfo = Word32 + type FieldOptional "bufferBindCount" VkBindSparseInfo = 'True -- ' closing tick for hsc2hs + type FieldOffset "bufferBindCount" VkBindSparseInfo = + #{offset VkBindSparseInfo, bufferBindCount} + type FieldIsArray "bufferBindCount" VkBindSparseInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkBindSparseInfo, bufferBindCount} + +instance CanReadField "bufferBindCount" VkBindSparseInfo where + {-# INLINE getField #-} + getField = vkBufferBindCount + + {-# INLINE readField #-} + readField = readVkBufferBindCount + +instance CanWriteField "bufferBindCount" VkBindSparseInfo where + {-# INLINE writeField #-} + writeField = writeVkBufferBindCount + +instance {-# OVERLAPPING #-} HasVkPBufferBinds VkBindSparseInfo + where + type VkPBufferBindsMType VkBindSparseInfo = + Ptr VkSparseBufferMemoryBindInfo + + {-# NOINLINE vkPBufferBinds #-} + vkPBufferBinds x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkBindSparseInfo, pBufferBinds}) + + {-# INLINE vkPBufferBindsByteOffset #-} + vkPBufferBindsByteOffset ~_ + = #{offset VkBindSparseInfo, pBufferBinds} + + {-# INLINE readVkPBufferBinds #-} + readVkPBufferBinds p + = peekByteOff p #{offset VkBindSparseInfo, pBufferBinds} + + {-# INLINE writeVkPBufferBinds #-} + writeVkPBufferBinds p + = pokeByteOff p #{offset VkBindSparseInfo, pBufferBinds} + +instance {-# OVERLAPPING #-} + HasField "pBufferBinds" VkBindSparseInfo where + type FieldType "pBufferBinds" VkBindSparseInfo = + Ptr VkSparseBufferMemoryBindInfo + type FieldOptional "pBufferBinds" VkBindSparseInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "pBufferBinds" VkBindSparseInfo = + #{offset VkBindSparseInfo, pBufferBinds} + type FieldIsArray "pBufferBinds" VkBindSparseInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkBindSparseInfo, pBufferBinds} + +instance CanReadField "pBufferBinds" VkBindSparseInfo where + {-# INLINE getField #-} + getField = vkPBufferBinds + + {-# INLINE readField #-} + readField = readVkPBufferBinds + +instance CanWriteField "pBufferBinds" VkBindSparseInfo where + {-# INLINE writeField #-} + writeField = writeVkPBufferBinds + +instance {-# OVERLAPPING #-} + HasVkImageOpaqueBindCount VkBindSparseInfo where + type VkImageOpaqueBindCountMType VkBindSparseInfo = Word32 + + {-# NOINLINE vkImageOpaqueBindCount #-} + vkImageOpaqueBindCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkBindSparseInfo, imageOpaqueBindCount}) + + {-# INLINE vkImageOpaqueBindCountByteOffset #-} + vkImageOpaqueBindCountByteOffset ~_ + = #{offset VkBindSparseInfo, imageOpaqueBindCount} + + {-# INLINE readVkImageOpaqueBindCount #-} + readVkImageOpaqueBindCount p + = peekByteOff p #{offset VkBindSparseInfo, imageOpaqueBindCount} + + {-# INLINE writeVkImageOpaqueBindCount #-} + writeVkImageOpaqueBindCount p + = pokeByteOff p #{offset VkBindSparseInfo, imageOpaqueBindCount} + +instance {-# OVERLAPPING #-} + HasField "imageOpaqueBindCount" VkBindSparseInfo where + type FieldType "imageOpaqueBindCount" VkBindSparseInfo = Word32 + type FieldOptional "imageOpaqueBindCount" VkBindSparseInfo = 'True -- ' closing tick for hsc2hs + type FieldOffset "imageOpaqueBindCount" VkBindSparseInfo = + #{offset VkBindSparseInfo, imageOpaqueBindCount} + type FieldIsArray "imageOpaqueBindCount" VkBindSparseInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkBindSparseInfo, imageOpaqueBindCount} + +instance CanReadField "imageOpaqueBindCount" VkBindSparseInfo where + {-# INLINE getField #-} + getField = vkImageOpaqueBindCount + + {-# INLINE readField #-} + readField = readVkImageOpaqueBindCount + +instance CanWriteField "imageOpaqueBindCount" VkBindSparseInfo + where + {-# INLINE writeField #-} + writeField = writeVkImageOpaqueBindCount + +instance {-# OVERLAPPING #-} + HasVkPImageOpaqueBinds VkBindSparseInfo where + type VkPImageOpaqueBindsMType VkBindSparseInfo = + Ptr VkSparseImageOpaqueMemoryBindInfo + + {-# NOINLINE vkPImageOpaqueBinds #-} + vkPImageOpaqueBinds x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkBindSparseInfo, pImageOpaqueBinds}) + + {-# INLINE vkPImageOpaqueBindsByteOffset #-} + vkPImageOpaqueBindsByteOffset ~_ + = #{offset VkBindSparseInfo, pImageOpaqueBinds} + + {-# INLINE readVkPImageOpaqueBinds #-} + readVkPImageOpaqueBinds p + = peekByteOff p #{offset VkBindSparseInfo, pImageOpaqueBinds} + + {-# INLINE writeVkPImageOpaqueBinds #-} + writeVkPImageOpaqueBinds p + = pokeByteOff p #{offset VkBindSparseInfo, pImageOpaqueBinds} + +instance {-# OVERLAPPING #-} + HasField "pImageOpaqueBinds" VkBindSparseInfo where + type FieldType "pImageOpaqueBinds" VkBindSparseInfo = + Ptr VkSparseImageOpaqueMemoryBindInfo + type FieldOptional "pImageOpaqueBinds" VkBindSparseInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "pImageOpaqueBinds" VkBindSparseInfo = + #{offset VkBindSparseInfo, pImageOpaqueBinds} + type FieldIsArray "pImageOpaqueBinds" VkBindSparseInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkBindSparseInfo, pImageOpaqueBinds} + +instance CanReadField "pImageOpaqueBinds" VkBindSparseInfo where + {-# INLINE getField #-} + getField = vkPImageOpaqueBinds + + {-# INLINE readField #-} + readField = readVkPImageOpaqueBinds + +instance CanWriteField "pImageOpaqueBinds" VkBindSparseInfo where + {-# INLINE writeField #-} + writeField = writeVkPImageOpaqueBinds + +instance {-# OVERLAPPING #-} HasVkImageBindCount VkBindSparseInfo + where + type VkImageBindCountMType VkBindSparseInfo = Word32 + + {-# NOINLINE vkImageBindCount #-} + vkImageBindCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkBindSparseInfo, imageBindCount}) + + {-# INLINE vkImageBindCountByteOffset #-} + vkImageBindCountByteOffset ~_ + = #{offset VkBindSparseInfo, imageBindCount} + + {-# INLINE readVkImageBindCount #-} + readVkImageBindCount p + = peekByteOff p #{offset VkBindSparseInfo, imageBindCount} + + {-# INLINE writeVkImageBindCount #-} + writeVkImageBindCount p + = pokeByteOff p #{offset VkBindSparseInfo, imageBindCount} + +instance {-# OVERLAPPING #-} + HasField "imageBindCount" VkBindSparseInfo where + type FieldType "imageBindCount" VkBindSparseInfo = Word32 + type FieldOptional "imageBindCount" VkBindSparseInfo = 'True -- ' closing tick for hsc2hs + type FieldOffset "imageBindCount" VkBindSparseInfo = + #{offset VkBindSparseInfo, imageBindCount} + type FieldIsArray "imageBindCount" VkBindSparseInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkBindSparseInfo, imageBindCount} + +instance CanReadField "imageBindCount" VkBindSparseInfo where + {-# INLINE getField #-} + getField = vkImageBindCount + + {-# INLINE readField #-} + readField = readVkImageBindCount + +instance CanWriteField "imageBindCount" VkBindSparseInfo where + {-# INLINE writeField #-} + writeField = writeVkImageBindCount + +instance {-# OVERLAPPING #-} HasVkPImageBinds VkBindSparseInfo + where + type VkPImageBindsMType VkBindSparseInfo = + Ptr VkSparseImageMemoryBindInfo + + {-# NOINLINE vkPImageBinds #-} + vkPImageBinds x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkBindSparseInfo, pImageBinds}) + + {-# INLINE vkPImageBindsByteOffset #-} + vkPImageBindsByteOffset ~_ + = #{offset VkBindSparseInfo, pImageBinds} + + {-# INLINE readVkPImageBinds #-} + readVkPImageBinds p + = peekByteOff p #{offset VkBindSparseInfo, pImageBinds} + + {-# INLINE writeVkPImageBinds #-} + writeVkPImageBinds p + = pokeByteOff p #{offset VkBindSparseInfo, pImageBinds} + +instance {-# OVERLAPPING #-} + HasField "pImageBinds" VkBindSparseInfo where + type FieldType "pImageBinds" VkBindSparseInfo = + Ptr VkSparseImageMemoryBindInfo + type FieldOptional "pImageBinds" VkBindSparseInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "pImageBinds" VkBindSparseInfo = + #{offset VkBindSparseInfo, pImageBinds} + type FieldIsArray "pImageBinds" VkBindSparseInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkBindSparseInfo, pImageBinds} + +instance CanReadField "pImageBinds" VkBindSparseInfo where + {-# INLINE getField #-} + getField = vkPImageBinds + + {-# INLINE readField #-} + readField = readVkPImageBinds + +instance CanWriteField "pImageBinds" VkBindSparseInfo where + {-# INLINE writeField #-} + writeField = writeVkPImageBinds + +instance {-# OVERLAPPING #-} + HasVkSignalSemaphoreCount VkBindSparseInfo where + type VkSignalSemaphoreCountMType VkBindSparseInfo = Word32 + + {-# NOINLINE vkSignalSemaphoreCount #-} + vkSignalSemaphoreCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkBindSparseInfo, signalSemaphoreCount}) + + {-# INLINE vkSignalSemaphoreCountByteOffset #-} + vkSignalSemaphoreCountByteOffset ~_ + = #{offset VkBindSparseInfo, signalSemaphoreCount} + + {-# INLINE readVkSignalSemaphoreCount #-} + readVkSignalSemaphoreCount p + = peekByteOff p #{offset VkBindSparseInfo, signalSemaphoreCount} + + {-# INLINE writeVkSignalSemaphoreCount #-} + writeVkSignalSemaphoreCount p + = pokeByteOff p #{offset VkBindSparseInfo, signalSemaphoreCount} + +instance {-# OVERLAPPING #-} + HasField "signalSemaphoreCount" VkBindSparseInfo where + type FieldType "signalSemaphoreCount" VkBindSparseInfo = Word32 + type FieldOptional "signalSemaphoreCount" VkBindSparseInfo = 'True -- ' closing tick for hsc2hs + type FieldOffset "signalSemaphoreCount" VkBindSparseInfo = + #{offset VkBindSparseInfo, signalSemaphoreCount} + type FieldIsArray "signalSemaphoreCount" VkBindSparseInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkBindSparseInfo, signalSemaphoreCount} + +instance CanReadField "signalSemaphoreCount" VkBindSparseInfo where + {-# INLINE getField #-} + getField = vkSignalSemaphoreCount + + {-# INLINE readField #-} + readField = readVkSignalSemaphoreCount + +instance CanWriteField "signalSemaphoreCount" VkBindSparseInfo + where + {-# INLINE writeField #-} + writeField = writeVkSignalSemaphoreCount + +instance {-# OVERLAPPING #-} + HasVkPSignalSemaphores VkBindSparseInfo where + type VkPSignalSemaphoresMType VkBindSparseInfo = Ptr VkSemaphore + + {-# NOINLINE vkPSignalSemaphores #-} + vkPSignalSemaphores x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkBindSparseInfo, pSignalSemaphores}) + + {-# INLINE vkPSignalSemaphoresByteOffset #-} + vkPSignalSemaphoresByteOffset ~_ + = #{offset VkBindSparseInfo, pSignalSemaphores} + + {-# INLINE readVkPSignalSemaphores #-} + readVkPSignalSemaphores p + = peekByteOff p #{offset VkBindSparseInfo, pSignalSemaphores} + + {-# INLINE writeVkPSignalSemaphores #-} + writeVkPSignalSemaphores p + = pokeByteOff p #{offset VkBindSparseInfo, pSignalSemaphores} + +instance {-# OVERLAPPING #-} + HasField "pSignalSemaphores" VkBindSparseInfo where + type FieldType "pSignalSemaphores" VkBindSparseInfo = + Ptr VkSemaphore + type FieldOptional "pSignalSemaphores" VkBindSparseInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "pSignalSemaphores" VkBindSparseInfo = + #{offset VkBindSparseInfo, pSignalSemaphores} + type FieldIsArray "pSignalSemaphores" VkBindSparseInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkBindSparseInfo, pSignalSemaphores} + +instance CanReadField "pSignalSemaphores" VkBindSparseInfo where + {-# INLINE getField #-} + getField = vkPSignalSemaphores + + {-# INLINE readField #-} + readField = readVkPSignalSemaphores + +instance CanWriteField "pSignalSemaphores" VkBindSparseInfo where + {-# INLINE writeField #-} + writeField = writeVkPSignalSemaphores + +instance Show VkBindSparseInfo where + showsPrec d x + = showString "VkBindSparseInfo {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkWaitSemaphoreCount = " . + showsPrec d (vkWaitSemaphoreCount x) . + showString ", " . + showString "vkPWaitSemaphores = " . + showsPrec d (vkPWaitSemaphores x) . + showString ", " . + showString "vkBufferBindCount = " . + showsPrec d (vkBufferBindCount x) . + showString ", " . + showString "vkPBufferBinds = " . + showsPrec d (vkPBufferBinds x) . + showString ", " . + showString "vkImageOpaqueBindCount = " . + showsPrec d (vkImageOpaqueBindCount x) . + showString ", " . + showString "vkPImageOpaqueBinds = " . + showsPrec d (vkPImageOpaqueBinds x) . + showString ", " . + showString "vkImageBindCount = " . + showsPrec d (vkImageBindCount x) . + showString ", " . + showString "vkPImageBinds = " . + showsPrec d (vkPImageBinds x) + . + showString ", " . + showString + "vkSignalSemaphoreCount = " + . + showsPrec d + (vkSignalSemaphoreCount + x) + . + showString ", " . + showString + "vkPSignalSemaphores = " + . + showsPrec d + (vkPSignalSemaphores + x) + . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkBufferCopy.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkBufferCopy.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkBufferCopy.hsc @@ -0,0 +1,215 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkBufferCopy (VkBufferCopy(..)) + where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.BaseTypes (VkDeviceSize) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkBufferCopy { +-- > VkDeviceSize srcOffset; +-- > VkDeviceSize dstOffset; +-- > VkDeviceSize size; +-- > } VkBufferCopy; +-- +-- +data VkBufferCopy = VkBufferCopy## Addr## ByteArray## + +instance Eq VkBufferCopy where + (VkBufferCopy## a _) == x@(VkBufferCopy## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkBufferCopy where + (VkBufferCopy## a _) `compare` x@(VkBufferCopy## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkBufferCopy where + sizeOf ~_ = #{size VkBufferCopy} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkBufferCopy} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkBufferCopy where + unsafeAddr (VkBufferCopy## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkBufferCopy## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkBufferCopy## (plusAddr## (byteArrayContents## b) off) b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkBufferCopy where + type StructFields VkBufferCopy = + '["srcOffset", "dstOffset", "size"] -- ' closing tick for hsc2hs + type CUnionType VkBufferCopy = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkBufferCopy = 'False -- ' closing tick for hsc2hs + type StructExtends VkBufferCopy = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkSrcOffset VkBufferCopy where + type VkSrcOffsetMType VkBufferCopy = VkDeviceSize + + {-# NOINLINE vkSrcOffset #-} + vkSrcOffset x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkBufferCopy, srcOffset}) + + {-# INLINE vkSrcOffsetByteOffset #-} + vkSrcOffsetByteOffset ~_ + = #{offset VkBufferCopy, srcOffset} + + {-# INLINE readVkSrcOffset #-} + readVkSrcOffset p + = peekByteOff p #{offset VkBufferCopy, srcOffset} + + {-# INLINE writeVkSrcOffset #-} + writeVkSrcOffset p + = pokeByteOff p #{offset VkBufferCopy, srcOffset} + +instance {-# OVERLAPPING #-} HasField "srcOffset" VkBufferCopy + where + type FieldType "srcOffset" VkBufferCopy = VkDeviceSize + type FieldOptional "srcOffset" VkBufferCopy = 'False -- ' closing tick for hsc2hs + type FieldOffset "srcOffset" VkBufferCopy = + #{offset VkBufferCopy, srcOffset} + type FieldIsArray "srcOffset" VkBufferCopy = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkBufferCopy, srcOffset} + +instance CanReadField "srcOffset" VkBufferCopy where + {-# INLINE getField #-} + getField = vkSrcOffset + + {-# INLINE readField #-} + readField = readVkSrcOffset + +instance CanWriteField "srcOffset" VkBufferCopy where + {-# INLINE writeField #-} + writeField = writeVkSrcOffset + +instance {-# OVERLAPPING #-} HasVkDstOffset VkBufferCopy where + type VkDstOffsetMType VkBufferCopy = VkDeviceSize + + {-# NOINLINE vkDstOffset #-} + vkDstOffset x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkBufferCopy, dstOffset}) + + {-# INLINE vkDstOffsetByteOffset #-} + vkDstOffsetByteOffset ~_ + = #{offset VkBufferCopy, dstOffset} + + {-# INLINE readVkDstOffset #-} + readVkDstOffset p + = peekByteOff p #{offset VkBufferCopy, dstOffset} + + {-# INLINE writeVkDstOffset #-} + writeVkDstOffset p + = pokeByteOff p #{offset VkBufferCopy, dstOffset} + +instance {-# OVERLAPPING #-} HasField "dstOffset" VkBufferCopy + where + type FieldType "dstOffset" VkBufferCopy = VkDeviceSize + type FieldOptional "dstOffset" VkBufferCopy = 'False -- ' closing tick for hsc2hs + type FieldOffset "dstOffset" VkBufferCopy = + #{offset VkBufferCopy, dstOffset} + type FieldIsArray "dstOffset" VkBufferCopy = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkBufferCopy, dstOffset} + +instance CanReadField "dstOffset" VkBufferCopy where + {-# INLINE getField #-} + getField = vkDstOffset + + {-# INLINE readField #-} + readField = readVkDstOffset + +instance CanWriteField "dstOffset" VkBufferCopy where + {-# INLINE writeField #-} + writeField = writeVkDstOffset + +instance {-# OVERLAPPING #-} HasVkSize VkBufferCopy where + type VkSizeMType VkBufferCopy = VkDeviceSize + + {-# NOINLINE vkSize #-} + vkSize x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkBufferCopy, size}) + + {-# INLINE vkSizeByteOffset #-} + vkSizeByteOffset ~_ = #{offset VkBufferCopy, size} + + {-# INLINE readVkSize #-} + readVkSize p + = peekByteOff p #{offset VkBufferCopy, size} + + {-# INLINE writeVkSize #-} + writeVkSize p + = pokeByteOff p #{offset VkBufferCopy, size} + +instance {-# OVERLAPPING #-} HasField "size" VkBufferCopy where + type FieldType "size" VkBufferCopy = VkDeviceSize + type FieldOptional "size" VkBufferCopy = 'False -- ' closing tick for hsc2hs + type FieldOffset "size" VkBufferCopy = + #{offset VkBufferCopy, size} + type FieldIsArray "size" VkBufferCopy = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkBufferCopy, size} + +instance CanReadField "size" VkBufferCopy where + {-# INLINE getField #-} + getField = vkSize + + {-# INLINE readField #-} + readField = readVkSize + +instance CanWriteField "size" VkBufferCopy where + {-# INLINE writeField #-} + writeField = writeVkSize + +instance Show VkBufferCopy where + showsPrec d x + = showString "VkBufferCopy {" . + showString "vkSrcOffset = " . + showsPrec d (vkSrcOffset x) . + showString ", " . + showString "vkDstOffset = " . + showsPrec d (vkDstOffset x) . + showString ", " . + showString "vkSize = " . showsPrec d (vkSize x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkBufferCreateInfo.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkBufferCreateInfo.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkBufferCreateInfo.hsc @@ -0,0 +1,482 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkBufferCreateInfo + (VkBufferCreateInfo(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.BaseTypes (VkDeviceSize) +import Graphics.Vulkan.Types.Enum.VkBufferCreateFlags (VkBufferCreateFlags) +import Graphics.Vulkan.Types.Enum.VkBufferUsageFlags (VkBufferUsageFlags) +import Graphics.Vulkan.Types.Enum.VkSharingMode (VkSharingMode) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkBufferCreateInfo { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkBufferCreateFlags flags; +-- > VkDeviceSize size; +-- > VkBufferUsageFlags usage; +-- > VkSharingMode sharingMode; +-- > uint32_t queueFamilyIndexCount; +-- > const uint32_t* pQueueFamilyIndices; +-- > } VkBufferCreateInfo; +-- +-- +data VkBufferCreateInfo = VkBufferCreateInfo## Addr## ByteArray## + +instance Eq VkBufferCreateInfo where + (VkBufferCreateInfo## a _) == x@(VkBufferCreateInfo## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkBufferCreateInfo where + (VkBufferCreateInfo## a _) `compare` x@(VkBufferCreateInfo## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkBufferCreateInfo where + sizeOf ~_ = #{size VkBufferCreateInfo} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkBufferCreateInfo} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkBufferCreateInfo where + unsafeAddr (VkBufferCreateInfo## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkBufferCreateInfo## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkBufferCreateInfo## (plusAddr## (byteArrayContents## b) off) b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkBufferCreateInfo where + type StructFields VkBufferCreateInfo = + '["sType", "pNext", "flags", "size", "usage", "sharingMode", -- ' closing tick for hsc2hs + "queueFamilyIndexCount", "pQueueFamilyIndices"] + type CUnionType VkBufferCreateInfo = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkBufferCreateInfo = 'False -- ' closing tick for hsc2hs + type StructExtends VkBufferCreateInfo = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkSType VkBufferCreateInfo where + type VkSTypeMType VkBufferCreateInfo = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkBufferCreateInfo, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkBufferCreateInfo, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkBufferCreateInfo, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkBufferCreateInfo, sType} + +instance {-# OVERLAPPING #-} HasField "sType" VkBufferCreateInfo + where + type FieldType "sType" VkBufferCreateInfo = VkStructureType + type FieldOptional "sType" VkBufferCreateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkBufferCreateInfo = + #{offset VkBufferCreateInfo, sType} + type FieldIsArray "sType" VkBufferCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkBufferCreateInfo, sType} + +instance CanReadField "sType" VkBufferCreateInfo where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkBufferCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} HasVkPNext VkBufferCreateInfo where + type VkPNextMType VkBufferCreateInfo = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkBufferCreateInfo, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkBufferCreateInfo, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkBufferCreateInfo, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkBufferCreateInfo, pNext} + +instance {-# OVERLAPPING #-} HasField "pNext" VkBufferCreateInfo + where + type FieldType "pNext" VkBufferCreateInfo = Ptr Void + type FieldOptional "pNext" VkBufferCreateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkBufferCreateInfo = + #{offset VkBufferCreateInfo, pNext} + type FieldIsArray "pNext" VkBufferCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkBufferCreateInfo, pNext} + +instance CanReadField "pNext" VkBufferCreateInfo where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkBufferCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} HasVkFlags VkBufferCreateInfo where + type VkFlagsMType VkBufferCreateInfo = VkBufferCreateFlags + + {-# NOINLINE vkFlags #-} + vkFlags x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkBufferCreateInfo, flags}) + + {-# INLINE vkFlagsByteOffset #-} + vkFlagsByteOffset ~_ + = #{offset VkBufferCreateInfo, flags} + + {-# INLINE readVkFlags #-} + readVkFlags p + = peekByteOff p #{offset VkBufferCreateInfo, flags} + + {-# INLINE writeVkFlags #-} + writeVkFlags p + = pokeByteOff p #{offset VkBufferCreateInfo, flags} + +instance {-# OVERLAPPING #-} HasField "flags" VkBufferCreateInfo + where + type FieldType "flags" VkBufferCreateInfo = VkBufferCreateFlags + type FieldOptional "flags" VkBufferCreateInfo = 'True -- ' closing tick for hsc2hs + type FieldOffset "flags" VkBufferCreateInfo = + #{offset VkBufferCreateInfo, flags} + type FieldIsArray "flags" VkBufferCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkBufferCreateInfo, flags} + +instance CanReadField "flags" VkBufferCreateInfo where + {-# INLINE getField #-} + getField = vkFlags + + {-# INLINE readField #-} + readField = readVkFlags + +instance CanWriteField "flags" VkBufferCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkFlags + +instance {-# OVERLAPPING #-} HasVkSize VkBufferCreateInfo where + type VkSizeMType VkBufferCreateInfo = VkDeviceSize + + {-# NOINLINE vkSize #-} + vkSize x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkBufferCreateInfo, size}) + + {-# INLINE vkSizeByteOffset #-} + vkSizeByteOffset ~_ + = #{offset VkBufferCreateInfo, size} + + {-# INLINE readVkSize #-} + readVkSize p + = peekByteOff p #{offset VkBufferCreateInfo, size} + + {-# INLINE writeVkSize #-} + writeVkSize p + = pokeByteOff p #{offset VkBufferCreateInfo, size} + +instance {-# OVERLAPPING #-} HasField "size" VkBufferCreateInfo + where + type FieldType "size" VkBufferCreateInfo = VkDeviceSize + type FieldOptional "size" VkBufferCreateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "size" VkBufferCreateInfo = + #{offset VkBufferCreateInfo, size} + type FieldIsArray "size" VkBufferCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkBufferCreateInfo, size} + +instance CanReadField "size" VkBufferCreateInfo where + {-# INLINE getField #-} + getField = vkSize + + {-# INLINE readField #-} + readField = readVkSize + +instance CanWriteField "size" VkBufferCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkSize + +instance {-# OVERLAPPING #-} HasVkUsage VkBufferCreateInfo where + type VkUsageMType VkBufferCreateInfo = VkBufferUsageFlags + + {-# NOINLINE vkUsage #-} + vkUsage x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkBufferCreateInfo, usage}) + + {-# INLINE vkUsageByteOffset #-} + vkUsageByteOffset ~_ + = #{offset VkBufferCreateInfo, usage} + + {-# INLINE readVkUsage #-} + readVkUsage p + = peekByteOff p #{offset VkBufferCreateInfo, usage} + + {-# INLINE writeVkUsage #-} + writeVkUsage p + = pokeByteOff p #{offset VkBufferCreateInfo, usage} + +instance {-# OVERLAPPING #-} HasField "usage" VkBufferCreateInfo + where + type FieldType "usage" VkBufferCreateInfo = VkBufferUsageFlags + type FieldOptional "usage" VkBufferCreateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "usage" VkBufferCreateInfo = + #{offset VkBufferCreateInfo, usage} + type FieldIsArray "usage" VkBufferCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkBufferCreateInfo, usage} + +instance CanReadField "usage" VkBufferCreateInfo where + {-# INLINE getField #-} + getField = vkUsage + + {-# INLINE readField #-} + readField = readVkUsage + +instance CanWriteField "usage" VkBufferCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkUsage + +instance {-# OVERLAPPING #-} HasVkSharingMode VkBufferCreateInfo + where + type VkSharingModeMType VkBufferCreateInfo = VkSharingMode + + {-# NOINLINE vkSharingMode #-} + vkSharingMode x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkBufferCreateInfo, sharingMode}) + + {-# INLINE vkSharingModeByteOffset #-} + vkSharingModeByteOffset ~_ + = #{offset VkBufferCreateInfo, sharingMode} + + {-# INLINE readVkSharingMode #-} + readVkSharingMode p + = peekByteOff p #{offset VkBufferCreateInfo, sharingMode} + + {-# INLINE writeVkSharingMode #-} + writeVkSharingMode p + = pokeByteOff p #{offset VkBufferCreateInfo, sharingMode} + +instance {-# OVERLAPPING #-} + HasField "sharingMode" VkBufferCreateInfo where + type FieldType "sharingMode" VkBufferCreateInfo = VkSharingMode + type FieldOptional "sharingMode" VkBufferCreateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "sharingMode" VkBufferCreateInfo = + #{offset VkBufferCreateInfo, sharingMode} + type FieldIsArray "sharingMode" VkBufferCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkBufferCreateInfo, sharingMode} + +instance CanReadField "sharingMode" VkBufferCreateInfo where + {-# INLINE getField #-} + getField = vkSharingMode + + {-# INLINE readField #-} + readField = readVkSharingMode + +instance CanWriteField "sharingMode" VkBufferCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkSharingMode + +instance {-# OVERLAPPING #-} + HasVkQueueFamilyIndexCount VkBufferCreateInfo where + type VkQueueFamilyIndexCountMType VkBufferCreateInfo = Word32 + + {-# NOINLINE vkQueueFamilyIndexCount #-} + vkQueueFamilyIndexCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkBufferCreateInfo, queueFamilyIndexCount}) + + {-# INLINE vkQueueFamilyIndexCountByteOffset #-} + vkQueueFamilyIndexCountByteOffset ~_ + = #{offset VkBufferCreateInfo, queueFamilyIndexCount} + + {-# INLINE readVkQueueFamilyIndexCount #-} + readVkQueueFamilyIndexCount p + = peekByteOff p #{offset VkBufferCreateInfo, queueFamilyIndexCount} + + {-# INLINE writeVkQueueFamilyIndexCount #-} + writeVkQueueFamilyIndexCount p + = pokeByteOff p #{offset VkBufferCreateInfo, queueFamilyIndexCount} + +instance {-# OVERLAPPING #-} + HasField "queueFamilyIndexCount" VkBufferCreateInfo where + type FieldType "queueFamilyIndexCount" VkBufferCreateInfo = Word32 + type FieldOptional "queueFamilyIndexCount" VkBufferCreateInfo = + 'True -- ' closing tick for hsc2hs + type FieldOffset "queueFamilyIndexCount" VkBufferCreateInfo = + #{offset VkBufferCreateInfo, queueFamilyIndexCount} + type FieldIsArray "queueFamilyIndexCount" VkBufferCreateInfo = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkBufferCreateInfo, queueFamilyIndexCount} + +instance CanReadField "queueFamilyIndexCount" VkBufferCreateInfo + where + {-# INLINE getField #-} + getField = vkQueueFamilyIndexCount + + {-# INLINE readField #-} + readField = readVkQueueFamilyIndexCount + +instance CanWriteField "queueFamilyIndexCount" VkBufferCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkQueueFamilyIndexCount + +instance {-# OVERLAPPING #-} + HasVkPQueueFamilyIndices VkBufferCreateInfo where + type VkPQueueFamilyIndicesMType VkBufferCreateInfo = Ptr Word32 + + {-# NOINLINE vkPQueueFamilyIndices #-} + vkPQueueFamilyIndices x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkBufferCreateInfo, pQueueFamilyIndices}) + + {-# INLINE vkPQueueFamilyIndicesByteOffset #-} + vkPQueueFamilyIndicesByteOffset ~_ + = #{offset VkBufferCreateInfo, pQueueFamilyIndices} + + {-# INLINE readVkPQueueFamilyIndices #-} + readVkPQueueFamilyIndices p + = peekByteOff p #{offset VkBufferCreateInfo, pQueueFamilyIndices} + + {-# INLINE writeVkPQueueFamilyIndices #-} + writeVkPQueueFamilyIndices p + = pokeByteOff p #{offset VkBufferCreateInfo, pQueueFamilyIndices} + +instance {-# OVERLAPPING #-} + HasField "pQueueFamilyIndices" VkBufferCreateInfo where + type FieldType "pQueueFamilyIndices" VkBufferCreateInfo = + Ptr Word32 + type FieldOptional "pQueueFamilyIndices" VkBufferCreateInfo = + 'False -- ' closing tick for hsc2hs + type FieldOffset "pQueueFamilyIndices" VkBufferCreateInfo = + #{offset VkBufferCreateInfo, pQueueFamilyIndices} + type FieldIsArray "pQueueFamilyIndices" VkBufferCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkBufferCreateInfo, pQueueFamilyIndices} + +instance CanReadField "pQueueFamilyIndices" VkBufferCreateInfo + where + {-# INLINE getField #-} + getField = vkPQueueFamilyIndices + + {-# INLINE readField #-} + readField = readVkPQueueFamilyIndices + +instance CanWriteField "pQueueFamilyIndices" VkBufferCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkPQueueFamilyIndices + +instance Show VkBufferCreateInfo where + showsPrec d x + = showString "VkBufferCreateInfo {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkFlags = " . + showsPrec d (vkFlags x) . + showString ", " . + showString "vkSize = " . + showsPrec d (vkSize x) . + showString ", " . + showString "vkUsage = " . + showsPrec d (vkUsage x) . + showString ", " . + showString "vkSharingMode = " . + showsPrec d (vkSharingMode x) . + showString ", " . + showString "vkQueueFamilyIndexCount = " . + showsPrec d (vkQueueFamilyIndexCount x) . + showString ", " . + showString "vkPQueueFamilyIndices = " . + showsPrec d (vkPQueueFamilyIndices x) . + showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkBufferImageCopy.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkBufferImageCopy.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkBufferImageCopy.hsc @@ -0,0 +1,380 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkBufferImageCopy + (VkBufferImageCopy(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.BaseTypes (VkDeviceSize) +import Graphics.Vulkan.Types.Struct.VkExtent3D (VkExtent3D) +import Graphics.Vulkan.Types.Struct.VkImageSubresourceLayers (VkImageSubresourceLayers) +import Graphics.Vulkan.Types.Struct.VkOffset3D (VkOffset3D) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkBufferImageCopy { +-- > VkDeviceSize bufferOffset; +-- > uint32_t bufferRowLength; +-- > uint32_t bufferImageHeight; +-- > VkImageSubresourceLayers imageSubresource; +-- > VkOffset3D imageOffset; +-- > VkExtent3D imageExtent; +-- > } VkBufferImageCopy; +-- +-- +data VkBufferImageCopy = VkBufferImageCopy## Addr## ByteArray## + +instance Eq VkBufferImageCopy where + (VkBufferImageCopy## a _) == x@(VkBufferImageCopy## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkBufferImageCopy where + (VkBufferImageCopy## a _) `compare` x@(VkBufferImageCopy## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkBufferImageCopy where + sizeOf ~_ = #{size VkBufferImageCopy} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkBufferImageCopy} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkBufferImageCopy where + unsafeAddr (VkBufferImageCopy## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkBufferImageCopy## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkBufferImageCopy## (plusAddr## (byteArrayContents## b) off) b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkBufferImageCopy where + type StructFields VkBufferImageCopy = + '["bufferOffset", "bufferRowLength", "bufferImageHeight", -- ' closing tick for hsc2hs + "imageSubresource", "imageOffset", "imageExtent"] + type CUnionType VkBufferImageCopy = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkBufferImageCopy = 'False -- ' closing tick for hsc2hs + type StructExtends VkBufferImageCopy = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkBufferOffset VkBufferImageCopy + where + type VkBufferOffsetMType VkBufferImageCopy = VkDeviceSize + + {-# NOINLINE vkBufferOffset #-} + vkBufferOffset x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkBufferImageCopy, bufferOffset}) + + {-# INLINE vkBufferOffsetByteOffset #-} + vkBufferOffsetByteOffset ~_ + = #{offset VkBufferImageCopy, bufferOffset} + + {-# INLINE readVkBufferOffset #-} + readVkBufferOffset p + = peekByteOff p #{offset VkBufferImageCopy, bufferOffset} + + {-# INLINE writeVkBufferOffset #-} + writeVkBufferOffset p + = pokeByteOff p #{offset VkBufferImageCopy, bufferOffset} + +instance {-# OVERLAPPING #-} + HasField "bufferOffset" VkBufferImageCopy where + type FieldType "bufferOffset" VkBufferImageCopy = VkDeviceSize + type FieldOptional "bufferOffset" VkBufferImageCopy = 'False -- ' closing tick for hsc2hs + type FieldOffset "bufferOffset" VkBufferImageCopy = + #{offset VkBufferImageCopy, bufferOffset} + type FieldIsArray "bufferOffset" VkBufferImageCopy = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkBufferImageCopy, bufferOffset} + +instance CanReadField "bufferOffset" VkBufferImageCopy where + {-# INLINE getField #-} + getField = vkBufferOffset + + {-# INLINE readField #-} + readField = readVkBufferOffset + +instance CanWriteField "bufferOffset" VkBufferImageCopy where + {-# INLINE writeField #-} + writeField = writeVkBufferOffset + +instance {-# OVERLAPPING #-} HasVkBufferRowLength VkBufferImageCopy + where + type VkBufferRowLengthMType VkBufferImageCopy = Word32 + + {-# NOINLINE vkBufferRowLength #-} + vkBufferRowLength x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkBufferImageCopy, bufferRowLength}) + + {-# INLINE vkBufferRowLengthByteOffset #-} + vkBufferRowLengthByteOffset ~_ + = #{offset VkBufferImageCopy, bufferRowLength} + + {-# INLINE readVkBufferRowLength #-} + readVkBufferRowLength p + = peekByteOff p #{offset VkBufferImageCopy, bufferRowLength} + + {-# INLINE writeVkBufferRowLength #-} + writeVkBufferRowLength p + = pokeByteOff p #{offset VkBufferImageCopy, bufferRowLength} + +instance {-# OVERLAPPING #-} + HasField "bufferRowLength" VkBufferImageCopy where + type FieldType "bufferRowLength" VkBufferImageCopy = Word32 + type FieldOptional "bufferRowLength" VkBufferImageCopy = 'False -- ' closing tick for hsc2hs + type FieldOffset "bufferRowLength" VkBufferImageCopy = + #{offset VkBufferImageCopy, bufferRowLength} + type FieldIsArray "bufferRowLength" VkBufferImageCopy = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkBufferImageCopy, bufferRowLength} + +instance CanReadField "bufferRowLength" VkBufferImageCopy where + {-# INLINE getField #-} + getField = vkBufferRowLength + + {-# INLINE readField #-} + readField = readVkBufferRowLength + +instance CanWriteField "bufferRowLength" VkBufferImageCopy where + {-# INLINE writeField #-} + writeField = writeVkBufferRowLength + +instance {-# OVERLAPPING #-} + HasVkBufferImageHeight VkBufferImageCopy where + type VkBufferImageHeightMType VkBufferImageCopy = Word32 + + {-# NOINLINE vkBufferImageHeight #-} + vkBufferImageHeight x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkBufferImageCopy, bufferImageHeight}) + + {-# INLINE vkBufferImageHeightByteOffset #-} + vkBufferImageHeightByteOffset ~_ + = #{offset VkBufferImageCopy, bufferImageHeight} + + {-# INLINE readVkBufferImageHeight #-} + readVkBufferImageHeight p + = peekByteOff p #{offset VkBufferImageCopy, bufferImageHeight} + + {-# INLINE writeVkBufferImageHeight #-} + writeVkBufferImageHeight p + = pokeByteOff p #{offset VkBufferImageCopy, bufferImageHeight} + +instance {-# OVERLAPPING #-} + HasField "bufferImageHeight" VkBufferImageCopy where + type FieldType "bufferImageHeight" VkBufferImageCopy = Word32 + type FieldOptional "bufferImageHeight" VkBufferImageCopy = 'False -- ' closing tick for hsc2hs + type FieldOffset "bufferImageHeight" VkBufferImageCopy = + #{offset VkBufferImageCopy, bufferImageHeight} + type FieldIsArray "bufferImageHeight" VkBufferImageCopy = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkBufferImageCopy, bufferImageHeight} + +instance CanReadField "bufferImageHeight" VkBufferImageCopy where + {-# INLINE getField #-} + getField = vkBufferImageHeight + + {-# INLINE readField #-} + readField = readVkBufferImageHeight + +instance CanWriteField "bufferImageHeight" VkBufferImageCopy where + {-# INLINE writeField #-} + writeField = writeVkBufferImageHeight + +instance {-# OVERLAPPING #-} + HasVkImageSubresource VkBufferImageCopy where + type VkImageSubresourceMType VkBufferImageCopy = + VkImageSubresourceLayers + + {-# NOINLINE vkImageSubresource #-} + vkImageSubresource x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkBufferImageCopy, imageSubresource}) + + {-# INLINE vkImageSubresourceByteOffset #-} + vkImageSubresourceByteOffset ~_ + = #{offset VkBufferImageCopy, imageSubresource} + + {-# INLINE readVkImageSubresource #-} + readVkImageSubresource p + = peekByteOff p #{offset VkBufferImageCopy, imageSubresource} + + {-# INLINE writeVkImageSubresource #-} + writeVkImageSubresource p + = pokeByteOff p #{offset VkBufferImageCopy, imageSubresource} + +instance {-# OVERLAPPING #-} + HasField "imageSubresource" VkBufferImageCopy where + type FieldType "imageSubresource" VkBufferImageCopy = + VkImageSubresourceLayers + type FieldOptional "imageSubresource" VkBufferImageCopy = 'False -- ' closing tick for hsc2hs + type FieldOffset "imageSubresource" VkBufferImageCopy = + #{offset VkBufferImageCopy, imageSubresource} + type FieldIsArray "imageSubresource" VkBufferImageCopy = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkBufferImageCopy, imageSubresource} + +instance CanReadField "imageSubresource" VkBufferImageCopy where + {-# INLINE getField #-} + getField = vkImageSubresource + + {-# INLINE readField #-} + readField = readVkImageSubresource + +instance CanWriteField "imageSubresource" VkBufferImageCopy where + {-# INLINE writeField #-} + writeField = writeVkImageSubresource + +instance {-# OVERLAPPING #-} HasVkImageOffset VkBufferImageCopy + where + type VkImageOffsetMType VkBufferImageCopy = VkOffset3D + + {-# NOINLINE vkImageOffset #-} + vkImageOffset x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkBufferImageCopy, imageOffset}) + + {-# INLINE vkImageOffsetByteOffset #-} + vkImageOffsetByteOffset ~_ + = #{offset VkBufferImageCopy, imageOffset} + + {-# INLINE readVkImageOffset #-} + readVkImageOffset p + = peekByteOff p #{offset VkBufferImageCopy, imageOffset} + + {-# INLINE writeVkImageOffset #-} + writeVkImageOffset p + = pokeByteOff p #{offset VkBufferImageCopy, imageOffset} + +instance {-# OVERLAPPING #-} + HasField "imageOffset" VkBufferImageCopy where + type FieldType "imageOffset" VkBufferImageCopy = VkOffset3D + type FieldOptional "imageOffset" VkBufferImageCopy = 'False -- ' closing tick for hsc2hs + type FieldOffset "imageOffset" VkBufferImageCopy = + #{offset VkBufferImageCopy, imageOffset} + type FieldIsArray "imageOffset" VkBufferImageCopy = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkBufferImageCopy, imageOffset} + +instance CanReadField "imageOffset" VkBufferImageCopy where + {-# INLINE getField #-} + getField = vkImageOffset + + {-# INLINE readField #-} + readField = readVkImageOffset + +instance CanWriteField "imageOffset" VkBufferImageCopy where + {-# INLINE writeField #-} + writeField = writeVkImageOffset + +instance {-# OVERLAPPING #-} HasVkImageExtent VkBufferImageCopy + where + type VkImageExtentMType VkBufferImageCopy = VkExtent3D + + {-# NOINLINE vkImageExtent #-} + vkImageExtent x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkBufferImageCopy, imageExtent}) + + {-# INLINE vkImageExtentByteOffset #-} + vkImageExtentByteOffset ~_ + = #{offset VkBufferImageCopy, imageExtent} + + {-# INLINE readVkImageExtent #-} + readVkImageExtent p + = peekByteOff p #{offset VkBufferImageCopy, imageExtent} + + {-# INLINE writeVkImageExtent #-} + writeVkImageExtent p + = pokeByteOff p #{offset VkBufferImageCopy, imageExtent} + +instance {-# OVERLAPPING #-} + HasField "imageExtent" VkBufferImageCopy where + type FieldType "imageExtent" VkBufferImageCopy = VkExtent3D + type FieldOptional "imageExtent" VkBufferImageCopy = 'False -- ' closing tick for hsc2hs + type FieldOffset "imageExtent" VkBufferImageCopy = + #{offset VkBufferImageCopy, imageExtent} + type FieldIsArray "imageExtent" VkBufferImageCopy = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkBufferImageCopy, imageExtent} + +instance CanReadField "imageExtent" VkBufferImageCopy where + {-# INLINE getField #-} + getField = vkImageExtent + + {-# INLINE readField #-} + readField = readVkImageExtent + +instance CanWriteField "imageExtent" VkBufferImageCopy where + {-# INLINE writeField #-} + writeField = writeVkImageExtent + +instance Show VkBufferImageCopy where + showsPrec d x + = showString "VkBufferImageCopy {" . + showString "vkBufferOffset = " . + showsPrec d (vkBufferOffset x) . + showString ", " . + showString "vkBufferRowLength = " . + showsPrec d (vkBufferRowLength x) . + showString ", " . + showString "vkBufferImageHeight = " . + showsPrec d (vkBufferImageHeight x) . + showString ", " . + showString "vkImageSubresource = " . + showsPrec d (vkImageSubresource x) . + showString ", " . + showString "vkImageOffset = " . + showsPrec d (vkImageOffset x) . + showString ", " . + showString "vkImageExtent = " . + showsPrec d (vkImageExtent x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkBufferMemoryBarrier.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkBufferMemoryBarrier.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkBufferMemoryBarrier.hsc @@ -0,0 +1,539 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkBufferMemoryBarrier + (VkBufferMemoryBarrier(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.BaseTypes (VkDeviceSize) +import Graphics.Vulkan.Types.Enum.VkAccessFlags (VkAccessFlags) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Handles (VkBuffer) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkBufferMemoryBarrier { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkAccessFlags srcAccessMask; +-- > VkAccessFlags dstAccessMask; +-- > uint32_t srcQueueFamilyIndex; +-- > uint32_t dstQueueFamilyIndex; +-- > VkBuffer buffer; +-- > VkDeviceSize offset; +-- > VkDeviceSize size; +-- > } VkBufferMemoryBarrier; +-- +-- +data VkBufferMemoryBarrier = VkBufferMemoryBarrier## Addr## + ByteArray## + +instance Eq VkBufferMemoryBarrier where + (VkBufferMemoryBarrier## a _) == x@(VkBufferMemoryBarrier## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkBufferMemoryBarrier where + (VkBufferMemoryBarrier## a _) `compare` + x@(VkBufferMemoryBarrier## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkBufferMemoryBarrier where + sizeOf ~_ = #{size VkBufferMemoryBarrier} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkBufferMemoryBarrier} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkBufferMemoryBarrier where + unsafeAddr (VkBufferMemoryBarrier## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkBufferMemoryBarrier## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkBufferMemoryBarrier## (plusAddr## (byteArrayContents## b) off) b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkBufferMemoryBarrier where + type StructFields VkBufferMemoryBarrier = + '["sType", "pNext", "srcAccessMask", "dstAccessMask", -- ' closing tick for hsc2hs + "srcQueueFamilyIndex", "dstQueueFamilyIndex", "buffer", "offset", + "size"] + type CUnionType VkBufferMemoryBarrier = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkBufferMemoryBarrier = 'False -- ' closing tick for hsc2hs + type StructExtends VkBufferMemoryBarrier = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkSType VkBufferMemoryBarrier where + type VkSTypeMType VkBufferMemoryBarrier = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkBufferMemoryBarrier, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkBufferMemoryBarrier, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkBufferMemoryBarrier, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkBufferMemoryBarrier, sType} + +instance {-# OVERLAPPING #-} HasField "sType" VkBufferMemoryBarrier + where + type FieldType "sType" VkBufferMemoryBarrier = VkStructureType + type FieldOptional "sType" VkBufferMemoryBarrier = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkBufferMemoryBarrier = + #{offset VkBufferMemoryBarrier, sType} + type FieldIsArray "sType" VkBufferMemoryBarrier = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkBufferMemoryBarrier, sType} + +instance CanReadField "sType" VkBufferMemoryBarrier where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkBufferMemoryBarrier where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} HasVkPNext VkBufferMemoryBarrier where + type VkPNextMType VkBufferMemoryBarrier = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkBufferMemoryBarrier, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkBufferMemoryBarrier, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkBufferMemoryBarrier, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkBufferMemoryBarrier, pNext} + +instance {-# OVERLAPPING #-} HasField "pNext" VkBufferMemoryBarrier + where + type FieldType "pNext" VkBufferMemoryBarrier = Ptr Void + type FieldOptional "pNext" VkBufferMemoryBarrier = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkBufferMemoryBarrier = + #{offset VkBufferMemoryBarrier, pNext} + type FieldIsArray "pNext" VkBufferMemoryBarrier = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkBufferMemoryBarrier, pNext} + +instance CanReadField "pNext" VkBufferMemoryBarrier where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkBufferMemoryBarrier where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkSrcAccessMask VkBufferMemoryBarrier where + type VkSrcAccessMaskMType VkBufferMemoryBarrier = VkAccessFlags + + {-# NOINLINE vkSrcAccessMask #-} + vkSrcAccessMask x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkBufferMemoryBarrier, srcAccessMask}) + + {-# INLINE vkSrcAccessMaskByteOffset #-} + vkSrcAccessMaskByteOffset ~_ + = #{offset VkBufferMemoryBarrier, srcAccessMask} + + {-# INLINE readVkSrcAccessMask #-} + readVkSrcAccessMask p + = peekByteOff p #{offset VkBufferMemoryBarrier, srcAccessMask} + + {-# INLINE writeVkSrcAccessMask #-} + writeVkSrcAccessMask p + = pokeByteOff p #{offset VkBufferMemoryBarrier, srcAccessMask} + +instance {-# OVERLAPPING #-} + HasField "srcAccessMask" VkBufferMemoryBarrier where + type FieldType "srcAccessMask" VkBufferMemoryBarrier = + VkAccessFlags + type FieldOptional "srcAccessMask" VkBufferMemoryBarrier = 'True -- ' closing tick for hsc2hs + type FieldOffset "srcAccessMask" VkBufferMemoryBarrier = + #{offset VkBufferMemoryBarrier, srcAccessMask} + type FieldIsArray "srcAccessMask" VkBufferMemoryBarrier = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkBufferMemoryBarrier, srcAccessMask} + +instance CanReadField "srcAccessMask" VkBufferMemoryBarrier where + {-# INLINE getField #-} + getField = vkSrcAccessMask + + {-# INLINE readField #-} + readField = readVkSrcAccessMask + +instance CanWriteField "srcAccessMask" VkBufferMemoryBarrier where + {-# INLINE writeField #-} + writeField = writeVkSrcAccessMask + +instance {-# OVERLAPPING #-} + HasVkDstAccessMask VkBufferMemoryBarrier where + type VkDstAccessMaskMType VkBufferMemoryBarrier = VkAccessFlags + + {-# NOINLINE vkDstAccessMask #-} + vkDstAccessMask x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkBufferMemoryBarrier, dstAccessMask}) + + {-# INLINE vkDstAccessMaskByteOffset #-} + vkDstAccessMaskByteOffset ~_ + = #{offset VkBufferMemoryBarrier, dstAccessMask} + + {-# INLINE readVkDstAccessMask #-} + readVkDstAccessMask p + = peekByteOff p #{offset VkBufferMemoryBarrier, dstAccessMask} + + {-# INLINE writeVkDstAccessMask #-} + writeVkDstAccessMask p + = pokeByteOff p #{offset VkBufferMemoryBarrier, dstAccessMask} + +instance {-# OVERLAPPING #-} + HasField "dstAccessMask" VkBufferMemoryBarrier where + type FieldType "dstAccessMask" VkBufferMemoryBarrier = + VkAccessFlags + type FieldOptional "dstAccessMask" VkBufferMemoryBarrier = 'True -- ' closing tick for hsc2hs + type FieldOffset "dstAccessMask" VkBufferMemoryBarrier = + #{offset VkBufferMemoryBarrier, dstAccessMask} + type FieldIsArray "dstAccessMask" VkBufferMemoryBarrier = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkBufferMemoryBarrier, dstAccessMask} + +instance CanReadField "dstAccessMask" VkBufferMemoryBarrier where + {-# INLINE getField #-} + getField = vkDstAccessMask + + {-# INLINE readField #-} + readField = readVkDstAccessMask + +instance CanWriteField "dstAccessMask" VkBufferMemoryBarrier where + {-# INLINE writeField #-} + writeField = writeVkDstAccessMask + +instance {-# OVERLAPPING #-} + HasVkSrcQueueFamilyIndex VkBufferMemoryBarrier where + type VkSrcQueueFamilyIndexMType VkBufferMemoryBarrier = Word32 + + {-# NOINLINE vkSrcQueueFamilyIndex #-} + vkSrcQueueFamilyIndex x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkBufferMemoryBarrier, srcQueueFamilyIndex}) + + {-# INLINE vkSrcQueueFamilyIndexByteOffset #-} + vkSrcQueueFamilyIndexByteOffset ~_ + = #{offset VkBufferMemoryBarrier, srcQueueFamilyIndex} + + {-# INLINE readVkSrcQueueFamilyIndex #-} + readVkSrcQueueFamilyIndex p + = peekByteOff p #{offset VkBufferMemoryBarrier, srcQueueFamilyIndex} + + {-# INLINE writeVkSrcQueueFamilyIndex #-} + writeVkSrcQueueFamilyIndex p + = pokeByteOff p #{offset VkBufferMemoryBarrier, srcQueueFamilyIndex} + +instance {-# OVERLAPPING #-} + HasField "srcQueueFamilyIndex" VkBufferMemoryBarrier where + type FieldType "srcQueueFamilyIndex" VkBufferMemoryBarrier = Word32 + type FieldOptional "srcQueueFamilyIndex" VkBufferMemoryBarrier = + 'False -- ' closing tick for hsc2hs + type FieldOffset "srcQueueFamilyIndex" VkBufferMemoryBarrier = + #{offset VkBufferMemoryBarrier, srcQueueFamilyIndex} + type FieldIsArray "srcQueueFamilyIndex" VkBufferMemoryBarrier = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkBufferMemoryBarrier, srcQueueFamilyIndex} + +instance CanReadField "srcQueueFamilyIndex" VkBufferMemoryBarrier + where + {-# INLINE getField #-} + getField = vkSrcQueueFamilyIndex + + {-# INLINE readField #-} + readField = readVkSrcQueueFamilyIndex + +instance CanWriteField "srcQueueFamilyIndex" VkBufferMemoryBarrier + where + {-# INLINE writeField #-} + writeField = writeVkSrcQueueFamilyIndex + +instance {-# OVERLAPPING #-} + HasVkDstQueueFamilyIndex VkBufferMemoryBarrier where + type VkDstQueueFamilyIndexMType VkBufferMemoryBarrier = Word32 + + {-# NOINLINE vkDstQueueFamilyIndex #-} + vkDstQueueFamilyIndex x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkBufferMemoryBarrier, dstQueueFamilyIndex}) + + {-# INLINE vkDstQueueFamilyIndexByteOffset #-} + vkDstQueueFamilyIndexByteOffset ~_ + = #{offset VkBufferMemoryBarrier, dstQueueFamilyIndex} + + {-# INLINE readVkDstQueueFamilyIndex #-} + readVkDstQueueFamilyIndex p + = peekByteOff p #{offset VkBufferMemoryBarrier, dstQueueFamilyIndex} + + {-# INLINE writeVkDstQueueFamilyIndex #-} + writeVkDstQueueFamilyIndex p + = pokeByteOff p #{offset VkBufferMemoryBarrier, dstQueueFamilyIndex} + +instance {-# OVERLAPPING #-} + HasField "dstQueueFamilyIndex" VkBufferMemoryBarrier where + type FieldType "dstQueueFamilyIndex" VkBufferMemoryBarrier = Word32 + type FieldOptional "dstQueueFamilyIndex" VkBufferMemoryBarrier = + 'False -- ' closing tick for hsc2hs + type FieldOffset "dstQueueFamilyIndex" VkBufferMemoryBarrier = + #{offset VkBufferMemoryBarrier, dstQueueFamilyIndex} + type FieldIsArray "dstQueueFamilyIndex" VkBufferMemoryBarrier = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkBufferMemoryBarrier, dstQueueFamilyIndex} + +instance CanReadField "dstQueueFamilyIndex" VkBufferMemoryBarrier + where + {-# INLINE getField #-} + getField = vkDstQueueFamilyIndex + + {-# INLINE readField #-} + readField = readVkDstQueueFamilyIndex + +instance CanWriteField "dstQueueFamilyIndex" VkBufferMemoryBarrier + where + {-# INLINE writeField #-} + writeField = writeVkDstQueueFamilyIndex + +instance {-# OVERLAPPING #-} HasVkBuffer VkBufferMemoryBarrier + where + type VkBufferMType VkBufferMemoryBarrier = VkBuffer + + {-# NOINLINE vkBuffer #-} + vkBuffer x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkBufferMemoryBarrier, buffer}) + + {-# INLINE vkBufferByteOffset #-} + vkBufferByteOffset ~_ + = #{offset VkBufferMemoryBarrier, buffer} + + {-# INLINE readVkBuffer #-} + readVkBuffer p + = peekByteOff p #{offset VkBufferMemoryBarrier, buffer} + + {-# INLINE writeVkBuffer #-} + writeVkBuffer p + = pokeByteOff p #{offset VkBufferMemoryBarrier, buffer} + +instance {-# OVERLAPPING #-} + HasField "buffer" VkBufferMemoryBarrier where + type FieldType "buffer" VkBufferMemoryBarrier = VkBuffer + type FieldOptional "buffer" VkBufferMemoryBarrier = 'False -- ' closing tick for hsc2hs + type FieldOffset "buffer" VkBufferMemoryBarrier = + #{offset VkBufferMemoryBarrier, buffer} + type FieldIsArray "buffer" VkBufferMemoryBarrier = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkBufferMemoryBarrier, buffer} + +instance CanReadField "buffer" VkBufferMemoryBarrier where + {-# INLINE getField #-} + getField = vkBuffer + + {-# INLINE readField #-} + readField = readVkBuffer + +instance CanWriteField "buffer" VkBufferMemoryBarrier where + {-# INLINE writeField #-} + writeField = writeVkBuffer + +instance {-# OVERLAPPING #-} HasVkOffset VkBufferMemoryBarrier + where + type VkOffsetMType VkBufferMemoryBarrier = VkDeviceSize + + {-# NOINLINE vkOffset #-} + vkOffset x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkBufferMemoryBarrier, offset}) + + {-# INLINE vkOffsetByteOffset #-} + vkOffsetByteOffset ~_ + = #{offset VkBufferMemoryBarrier, offset} + + {-# INLINE readVkOffset #-} + readVkOffset p + = peekByteOff p #{offset VkBufferMemoryBarrier, offset} + + {-# INLINE writeVkOffset #-} + writeVkOffset p + = pokeByteOff p #{offset VkBufferMemoryBarrier, offset} + +instance {-# OVERLAPPING #-} + HasField "offset" VkBufferMemoryBarrier where + type FieldType "offset" VkBufferMemoryBarrier = VkDeviceSize + type FieldOptional "offset" VkBufferMemoryBarrier = 'False -- ' closing tick for hsc2hs + type FieldOffset "offset" VkBufferMemoryBarrier = + #{offset VkBufferMemoryBarrier, offset} + type FieldIsArray "offset" VkBufferMemoryBarrier = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkBufferMemoryBarrier, offset} + +instance CanReadField "offset" VkBufferMemoryBarrier where + {-# INLINE getField #-} + getField = vkOffset + + {-# INLINE readField #-} + readField = readVkOffset + +instance CanWriteField "offset" VkBufferMemoryBarrier where + {-# INLINE writeField #-} + writeField = writeVkOffset + +instance {-# OVERLAPPING #-} HasVkSize VkBufferMemoryBarrier where + type VkSizeMType VkBufferMemoryBarrier = VkDeviceSize + + {-# NOINLINE vkSize #-} + vkSize x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkBufferMemoryBarrier, size}) + + {-# INLINE vkSizeByteOffset #-} + vkSizeByteOffset ~_ + = #{offset VkBufferMemoryBarrier, size} + + {-# INLINE readVkSize #-} + readVkSize p + = peekByteOff p #{offset VkBufferMemoryBarrier, size} + + {-# INLINE writeVkSize #-} + writeVkSize p + = pokeByteOff p #{offset VkBufferMemoryBarrier, size} + +instance {-# OVERLAPPING #-} HasField "size" VkBufferMemoryBarrier + where + type FieldType "size" VkBufferMemoryBarrier = VkDeviceSize + type FieldOptional "size" VkBufferMemoryBarrier = 'False -- ' closing tick for hsc2hs + type FieldOffset "size" VkBufferMemoryBarrier = + #{offset VkBufferMemoryBarrier, size} + type FieldIsArray "size" VkBufferMemoryBarrier = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkBufferMemoryBarrier, size} + +instance CanReadField "size" VkBufferMemoryBarrier where + {-# INLINE getField #-} + getField = vkSize + + {-# INLINE readField #-} + readField = readVkSize + +instance CanWriteField "size" VkBufferMemoryBarrier where + {-# INLINE writeField #-} + writeField = writeVkSize + +instance Show VkBufferMemoryBarrier where + showsPrec d x + = showString "VkBufferMemoryBarrier {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkSrcAccessMask = " . + showsPrec d (vkSrcAccessMask x) . + showString ", " . + showString "vkDstAccessMask = " . + showsPrec d (vkDstAccessMask x) . + showString ", " . + showString "vkSrcQueueFamilyIndex = " . + showsPrec d (vkSrcQueueFamilyIndex x) . + showString ", " . + showString "vkDstQueueFamilyIndex = " . + showsPrec d (vkDstQueueFamilyIndex x) . + showString ", " . + showString "vkBuffer = " . + showsPrec d (vkBuffer x) . + showString ", " . + showString "vkOffset = " . + showsPrec d (vkOffset x) . + showString ", " . + showString "vkSize = " . + showsPrec d (vkSize x) . + showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkBufferMemoryRequirementsInfo2KHR.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkBufferMemoryRequirementsInfo2KHR.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkBufferMemoryRequirementsInfo2KHR.hsc @@ -0,0 +1,246 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkBufferMemoryRequirementsInfo2KHR + (VkBufferMemoryRequirementsInfo2KHR(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Handles (VkBuffer) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkBufferMemoryRequirementsInfo2KHR { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkBuffer buffer; +-- > } VkBufferMemoryRequirementsInfo2KHR; +-- +-- +data VkBufferMemoryRequirementsInfo2KHR = VkBufferMemoryRequirementsInfo2KHR## Addr## + ByteArray## + +instance Eq VkBufferMemoryRequirementsInfo2KHR where + (VkBufferMemoryRequirementsInfo2KHR## a _) == + x@(VkBufferMemoryRequirementsInfo2KHR## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkBufferMemoryRequirementsInfo2KHR where + (VkBufferMemoryRequirementsInfo2KHR## a _) `compare` + x@(VkBufferMemoryRequirementsInfo2KHR## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkBufferMemoryRequirementsInfo2KHR where + sizeOf ~_ = #{size VkBufferMemoryRequirementsInfo2KHR} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkBufferMemoryRequirementsInfo2KHR} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkBufferMemoryRequirementsInfo2KHR where + unsafeAddr (VkBufferMemoryRequirementsInfo2KHR## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkBufferMemoryRequirementsInfo2KHR## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkBufferMemoryRequirementsInfo2KHR## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkBufferMemoryRequirementsInfo2KHR where + type StructFields VkBufferMemoryRequirementsInfo2KHR = + '["sType", "pNext", "buffer"] -- ' closing tick for hsc2hs + type CUnionType VkBufferMemoryRequirementsInfo2KHR = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkBufferMemoryRequirementsInfo2KHR = 'False -- ' closing tick for hsc2hs + type StructExtends VkBufferMemoryRequirementsInfo2KHR = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkBufferMemoryRequirementsInfo2KHR where + type VkSTypeMType VkBufferMemoryRequirementsInfo2KHR = + VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkBufferMemoryRequirementsInfo2KHR, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkBufferMemoryRequirementsInfo2KHR, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkBufferMemoryRequirementsInfo2KHR, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkBufferMemoryRequirementsInfo2KHR, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkBufferMemoryRequirementsInfo2KHR where + type FieldType "sType" VkBufferMemoryRequirementsInfo2KHR = + VkStructureType + type FieldOptional "sType" VkBufferMemoryRequirementsInfo2KHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkBufferMemoryRequirementsInfo2KHR = + #{offset VkBufferMemoryRequirementsInfo2KHR, sType} + type FieldIsArray "sType" VkBufferMemoryRequirementsInfo2KHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkBufferMemoryRequirementsInfo2KHR, sType} + +instance CanReadField "sType" VkBufferMemoryRequirementsInfo2KHR + where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkBufferMemoryRequirementsInfo2KHR + where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkBufferMemoryRequirementsInfo2KHR where + type VkPNextMType VkBufferMemoryRequirementsInfo2KHR = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkBufferMemoryRequirementsInfo2KHR, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkBufferMemoryRequirementsInfo2KHR, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkBufferMemoryRequirementsInfo2KHR, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkBufferMemoryRequirementsInfo2KHR, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkBufferMemoryRequirementsInfo2KHR where + type FieldType "pNext" VkBufferMemoryRequirementsInfo2KHR = + Ptr Void + type FieldOptional "pNext" VkBufferMemoryRequirementsInfo2KHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkBufferMemoryRequirementsInfo2KHR = + #{offset VkBufferMemoryRequirementsInfo2KHR, pNext} + type FieldIsArray "pNext" VkBufferMemoryRequirementsInfo2KHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkBufferMemoryRequirementsInfo2KHR, pNext} + +instance CanReadField "pNext" VkBufferMemoryRequirementsInfo2KHR + where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkBufferMemoryRequirementsInfo2KHR + where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkBuffer VkBufferMemoryRequirementsInfo2KHR where + type VkBufferMType VkBufferMemoryRequirementsInfo2KHR = VkBuffer + + {-# NOINLINE vkBuffer #-} + vkBuffer x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkBufferMemoryRequirementsInfo2KHR, buffer}) + + {-# INLINE vkBufferByteOffset #-} + vkBufferByteOffset ~_ + = #{offset VkBufferMemoryRequirementsInfo2KHR, buffer} + + {-# INLINE readVkBuffer #-} + readVkBuffer p + = peekByteOff p #{offset VkBufferMemoryRequirementsInfo2KHR, buffer} + + {-# INLINE writeVkBuffer #-} + writeVkBuffer p + = pokeByteOff p #{offset VkBufferMemoryRequirementsInfo2KHR, buffer} + +instance {-# OVERLAPPING #-} + HasField "buffer" VkBufferMemoryRequirementsInfo2KHR where + type FieldType "buffer" VkBufferMemoryRequirementsInfo2KHR = + VkBuffer + type FieldOptional "buffer" VkBufferMemoryRequirementsInfo2KHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "buffer" VkBufferMemoryRequirementsInfo2KHR = + #{offset VkBufferMemoryRequirementsInfo2KHR, buffer} + type FieldIsArray "buffer" VkBufferMemoryRequirementsInfo2KHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkBufferMemoryRequirementsInfo2KHR, buffer} + +instance CanReadField "buffer" VkBufferMemoryRequirementsInfo2KHR + where + {-# INLINE getField #-} + getField = vkBuffer + + {-# INLINE readField #-} + readField = readVkBuffer + +instance CanWriteField "buffer" VkBufferMemoryRequirementsInfo2KHR + where + {-# INLINE writeField #-} + writeField = writeVkBuffer + +instance Show VkBufferMemoryRequirementsInfo2KHR where + showsPrec d x + = showString "VkBufferMemoryRequirementsInfo2KHR {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkBuffer = " . showsPrec d (vkBuffer x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkBufferViewCreateInfo.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkBufferViewCreateInfo.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkBufferViewCreateInfo.hsc @@ -0,0 +1,427 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkBufferViewCreateInfo + (VkBufferViewCreateInfo(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.BaseTypes (VkDeviceSize) +import Graphics.Vulkan.Types.Bitmasks (VkBufferViewCreateFlags) +import Graphics.Vulkan.Types.Enum.VkFormat (VkFormat) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Handles (VkBuffer) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkBufferViewCreateInfo { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkBufferViewCreateFlagsflags; +-- > VkBuffer buffer; +-- > VkFormat format; +-- > VkDeviceSize offset; +-- > VkDeviceSize range; +-- > } VkBufferViewCreateInfo; +-- +-- +data VkBufferViewCreateInfo = VkBufferViewCreateInfo## Addr## + ByteArray## + +instance Eq VkBufferViewCreateInfo where + (VkBufferViewCreateInfo## a _) == x@(VkBufferViewCreateInfo## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkBufferViewCreateInfo where + (VkBufferViewCreateInfo## a _) `compare` + x@(VkBufferViewCreateInfo## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkBufferViewCreateInfo where + sizeOf ~_ = #{size VkBufferViewCreateInfo} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkBufferViewCreateInfo} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkBufferViewCreateInfo where + unsafeAddr (VkBufferViewCreateInfo## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkBufferViewCreateInfo## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkBufferViewCreateInfo## (plusAddr## (byteArrayContents## b) off) b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkBufferViewCreateInfo where + type StructFields VkBufferViewCreateInfo = + '["sType", "pNext", "flags", "buffer", "format", "offset", "range"] -- ' closing tick for hsc2hs + type CUnionType VkBufferViewCreateInfo = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkBufferViewCreateInfo = 'False -- ' closing tick for hsc2hs + type StructExtends VkBufferViewCreateInfo = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkSType VkBufferViewCreateInfo + where + type VkSTypeMType VkBufferViewCreateInfo = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkBufferViewCreateInfo, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkBufferViewCreateInfo, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkBufferViewCreateInfo, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkBufferViewCreateInfo, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkBufferViewCreateInfo where + type FieldType "sType" VkBufferViewCreateInfo = VkStructureType + type FieldOptional "sType" VkBufferViewCreateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkBufferViewCreateInfo = + #{offset VkBufferViewCreateInfo, sType} + type FieldIsArray "sType" VkBufferViewCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkBufferViewCreateInfo, sType} + +instance CanReadField "sType" VkBufferViewCreateInfo where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkBufferViewCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} HasVkPNext VkBufferViewCreateInfo + where + type VkPNextMType VkBufferViewCreateInfo = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkBufferViewCreateInfo, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkBufferViewCreateInfo, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkBufferViewCreateInfo, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkBufferViewCreateInfo, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkBufferViewCreateInfo where + type FieldType "pNext" VkBufferViewCreateInfo = Ptr Void + type FieldOptional "pNext" VkBufferViewCreateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkBufferViewCreateInfo = + #{offset VkBufferViewCreateInfo, pNext} + type FieldIsArray "pNext" VkBufferViewCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkBufferViewCreateInfo, pNext} + +instance CanReadField "pNext" VkBufferViewCreateInfo where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkBufferViewCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} HasVkFlags VkBufferViewCreateInfo + where + type VkFlagsMType VkBufferViewCreateInfo = VkBufferViewCreateFlags + + {-# NOINLINE vkFlags #-} + vkFlags x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkBufferViewCreateInfo, flags}) + + {-# INLINE vkFlagsByteOffset #-} + vkFlagsByteOffset ~_ + = #{offset VkBufferViewCreateInfo, flags} + + {-# INLINE readVkFlags #-} + readVkFlags p + = peekByteOff p #{offset VkBufferViewCreateInfo, flags} + + {-# INLINE writeVkFlags #-} + writeVkFlags p + = pokeByteOff p #{offset VkBufferViewCreateInfo, flags} + +instance {-# OVERLAPPING #-} + HasField "flags" VkBufferViewCreateInfo where + type FieldType "flags" VkBufferViewCreateInfo = + VkBufferViewCreateFlags + type FieldOptional "flags" VkBufferViewCreateInfo = 'True -- ' closing tick for hsc2hs + type FieldOffset "flags" VkBufferViewCreateInfo = + #{offset VkBufferViewCreateInfo, flags} + type FieldIsArray "flags" VkBufferViewCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkBufferViewCreateInfo, flags} + +instance CanReadField "flags" VkBufferViewCreateInfo where + {-# INLINE getField #-} + getField = vkFlags + + {-# INLINE readField #-} + readField = readVkFlags + +instance CanWriteField "flags" VkBufferViewCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkFlags + +instance {-# OVERLAPPING #-} HasVkBuffer VkBufferViewCreateInfo + where + type VkBufferMType VkBufferViewCreateInfo = VkBuffer + + {-# NOINLINE vkBuffer #-} + vkBuffer x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkBufferViewCreateInfo, buffer}) + + {-# INLINE vkBufferByteOffset #-} + vkBufferByteOffset ~_ + = #{offset VkBufferViewCreateInfo, buffer} + + {-# INLINE readVkBuffer #-} + readVkBuffer p + = peekByteOff p #{offset VkBufferViewCreateInfo, buffer} + + {-# INLINE writeVkBuffer #-} + writeVkBuffer p + = pokeByteOff p #{offset VkBufferViewCreateInfo, buffer} + +instance {-# OVERLAPPING #-} + HasField "buffer" VkBufferViewCreateInfo where + type FieldType "buffer" VkBufferViewCreateInfo = VkBuffer + type FieldOptional "buffer" VkBufferViewCreateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "buffer" VkBufferViewCreateInfo = + #{offset VkBufferViewCreateInfo, buffer} + type FieldIsArray "buffer" VkBufferViewCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkBufferViewCreateInfo, buffer} + +instance CanReadField "buffer" VkBufferViewCreateInfo where + {-# INLINE getField #-} + getField = vkBuffer + + {-# INLINE readField #-} + readField = readVkBuffer + +instance CanWriteField "buffer" VkBufferViewCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkBuffer + +instance {-# OVERLAPPING #-} HasVkFormat VkBufferViewCreateInfo + where + type VkFormatMType VkBufferViewCreateInfo = VkFormat + + {-# NOINLINE vkFormat #-} + vkFormat x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkBufferViewCreateInfo, format}) + + {-# INLINE vkFormatByteOffset #-} + vkFormatByteOffset ~_ + = #{offset VkBufferViewCreateInfo, format} + + {-# INLINE readVkFormat #-} + readVkFormat p + = peekByteOff p #{offset VkBufferViewCreateInfo, format} + + {-# INLINE writeVkFormat #-} + writeVkFormat p + = pokeByteOff p #{offset VkBufferViewCreateInfo, format} + +instance {-# OVERLAPPING #-} + HasField "format" VkBufferViewCreateInfo where + type FieldType "format" VkBufferViewCreateInfo = VkFormat + type FieldOptional "format" VkBufferViewCreateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "format" VkBufferViewCreateInfo = + #{offset VkBufferViewCreateInfo, format} + type FieldIsArray "format" VkBufferViewCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkBufferViewCreateInfo, format} + +instance CanReadField "format" VkBufferViewCreateInfo where + {-# INLINE getField #-} + getField = vkFormat + + {-# INLINE readField #-} + readField = readVkFormat + +instance CanWriteField "format" VkBufferViewCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkFormat + +instance {-# OVERLAPPING #-} HasVkOffset VkBufferViewCreateInfo + where + type VkOffsetMType VkBufferViewCreateInfo = VkDeviceSize + + {-# NOINLINE vkOffset #-} + vkOffset x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkBufferViewCreateInfo, offset}) + + {-# INLINE vkOffsetByteOffset #-} + vkOffsetByteOffset ~_ + = #{offset VkBufferViewCreateInfo, offset} + + {-# INLINE readVkOffset #-} + readVkOffset p + = peekByteOff p #{offset VkBufferViewCreateInfo, offset} + + {-# INLINE writeVkOffset #-} + writeVkOffset p + = pokeByteOff p #{offset VkBufferViewCreateInfo, offset} + +instance {-# OVERLAPPING #-} + HasField "offset" VkBufferViewCreateInfo where + type FieldType "offset" VkBufferViewCreateInfo = VkDeviceSize + type FieldOptional "offset" VkBufferViewCreateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "offset" VkBufferViewCreateInfo = + #{offset VkBufferViewCreateInfo, offset} + type FieldIsArray "offset" VkBufferViewCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkBufferViewCreateInfo, offset} + +instance CanReadField "offset" VkBufferViewCreateInfo where + {-# INLINE getField #-} + getField = vkOffset + + {-# INLINE readField #-} + readField = readVkOffset + +instance CanWriteField "offset" VkBufferViewCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkOffset + +instance {-# OVERLAPPING #-} HasVkRange VkBufferViewCreateInfo + where + type VkRangeMType VkBufferViewCreateInfo = VkDeviceSize + + {-# NOINLINE vkRange #-} + vkRange x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkBufferViewCreateInfo, range}) + + {-# INLINE vkRangeByteOffset #-} + vkRangeByteOffset ~_ + = #{offset VkBufferViewCreateInfo, range} + + {-# INLINE readVkRange #-} + readVkRange p + = peekByteOff p #{offset VkBufferViewCreateInfo, range} + + {-# INLINE writeVkRange #-} + writeVkRange p + = pokeByteOff p #{offset VkBufferViewCreateInfo, range} + +instance {-# OVERLAPPING #-} + HasField "range" VkBufferViewCreateInfo where + type FieldType "range" VkBufferViewCreateInfo = VkDeviceSize + type FieldOptional "range" VkBufferViewCreateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "range" VkBufferViewCreateInfo = + #{offset VkBufferViewCreateInfo, range} + type FieldIsArray "range" VkBufferViewCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkBufferViewCreateInfo, range} + +instance CanReadField "range" VkBufferViewCreateInfo where + {-# INLINE getField #-} + getField = vkRange + + {-# INLINE readField #-} + readField = readVkRange + +instance CanWriteField "range" VkBufferViewCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkRange + +instance Show VkBufferViewCreateInfo where + showsPrec d x + = showString "VkBufferViewCreateInfo {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkFlags = " . + showsPrec d (vkFlags x) . + showString ", " . + showString "vkBuffer = " . + showsPrec d (vkBuffer x) . + showString ", " . + showString "vkFormat = " . + showsPrec d (vkFormat x) . + showString ", " . + showString "vkOffset = " . + showsPrec d (vkOffset x) . + showString ", " . + showString "vkRange = " . + showsPrec d (vkRange x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkClearAttachment.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkClearAttachment.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkClearAttachment.hsc @@ -0,0 +1,223 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkClearAttachment + (VkClearAttachment(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkImageAspectFlags (VkImageAspectFlags) +import Graphics.Vulkan.Types.Struct.VkClearValue (VkClearValue) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkClearAttachment { +-- > VkImageAspectFlags aspectMask; +-- > uint32_t colorAttachment; +-- > VkClearValue clearValue; +-- > } VkClearAttachment; +-- +-- +data VkClearAttachment = VkClearAttachment## Addr## ByteArray## + +instance Eq VkClearAttachment where + (VkClearAttachment## a _) == x@(VkClearAttachment## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkClearAttachment where + (VkClearAttachment## a _) `compare` x@(VkClearAttachment## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkClearAttachment where + sizeOf ~_ = #{size VkClearAttachment} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkClearAttachment} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkClearAttachment where + unsafeAddr (VkClearAttachment## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkClearAttachment## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkClearAttachment## (plusAddr## (byteArrayContents## b) off) b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkClearAttachment where + type StructFields VkClearAttachment = + '["aspectMask", "colorAttachment", "clearValue"] -- ' closing tick for hsc2hs + type CUnionType VkClearAttachment = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkClearAttachment = 'False -- ' closing tick for hsc2hs + type StructExtends VkClearAttachment = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkAspectMask VkClearAttachment + where + type VkAspectMaskMType VkClearAttachment = VkImageAspectFlags + + {-# NOINLINE vkAspectMask #-} + vkAspectMask x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkClearAttachment, aspectMask}) + + {-# INLINE vkAspectMaskByteOffset #-} + vkAspectMaskByteOffset ~_ + = #{offset VkClearAttachment, aspectMask} + + {-# INLINE readVkAspectMask #-} + readVkAspectMask p + = peekByteOff p #{offset VkClearAttachment, aspectMask} + + {-# INLINE writeVkAspectMask #-} + writeVkAspectMask p + = pokeByteOff p #{offset VkClearAttachment, aspectMask} + +instance {-# OVERLAPPING #-} + HasField "aspectMask" VkClearAttachment where + type FieldType "aspectMask" VkClearAttachment = VkImageAspectFlags + type FieldOptional "aspectMask" VkClearAttachment = 'False -- ' closing tick for hsc2hs + type FieldOffset "aspectMask" VkClearAttachment = + #{offset VkClearAttachment, aspectMask} + type FieldIsArray "aspectMask" VkClearAttachment = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkClearAttachment, aspectMask} + +instance CanReadField "aspectMask" VkClearAttachment where + {-# INLINE getField #-} + getField = vkAspectMask + + {-# INLINE readField #-} + readField = readVkAspectMask + +instance CanWriteField "aspectMask" VkClearAttachment where + {-# INLINE writeField #-} + writeField = writeVkAspectMask + +instance {-# OVERLAPPING #-} HasVkColorAttachment VkClearAttachment + where + type VkColorAttachmentMType VkClearAttachment = Word32 + + {-# NOINLINE vkColorAttachment #-} + vkColorAttachment x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkClearAttachment, colorAttachment}) + + {-# INLINE vkColorAttachmentByteOffset #-} + vkColorAttachmentByteOffset ~_ + = #{offset VkClearAttachment, colorAttachment} + + {-# INLINE readVkColorAttachment #-} + readVkColorAttachment p + = peekByteOff p #{offset VkClearAttachment, colorAttachment} + + {-# INLINE writeVkColorAttachment #-} + writeVkColorAttachment p + = pokeByteOff p #{offset VkClearAttachment, colorAttachment} + +instance {-# OVERLAPPING #-} + HasField "colorAttachment" VkClearAttachment where + type FieldType "colorAttachment" VkClearAttachment = Word32 + type FieldOptional "colorAttachment" VkClearAttachment = 'False -- ' closing tick for hsc2hs + type FieldOffset "colorAttachment" VkClearAttachment = + #{offset VkClearAttachment, colorAttachment} + type FieldIsArray "colorAttachment" VkClearAttachment = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkClearAttachment, colorAttachment} + +instance CanReadField "colorAttachment" VkClearAttachment where + {-# INLINE getField #-} + getField = vkColorAttachment + + {-# INLINE readField #-} + readField = readVkColorAttachment + +instance CanWriteField "colorAttachment" VkClearAttachment where + {-# INLINE writeField #-} + writeField = writeVkColorAttachment + +instance {-# OVERLAPPING #-} HasVkClearValue VkClearAttachment + where + type VkClearValueMType VkClearAttachment = VkClearValue + + {-# NOINLINE vkClearValue #-} + vkClearValue x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkClearAttachment, clearValue}) + + {-# INLINE vkClearValueByteOffset #-} + vkClearValueByteOffset ~_ + = #{offset VkClearAttachment, clearValue} + + {-# INLINE readVkClearValue #-} + readVkClearValue p + = peekByteOff p #{offset VkClearAttachment, clearValue} + + {-# INLINE writeVkClearValue #-} + writeVkClearValue p + = pokeByteOff p #{offset VkClearAttachment, clearValue} + +instance {-# OVERLAPPING #-} + HasField "clearValue" VkClearAttachment where + type FieldType "clearValue" VkClearAttachment = VkClearValue + type FieldOptional "clearValue" VkClearAttachment = 'False -- ' closing tick for hsc2hs + type FieldOffset "clearValue" VkClearAttachment = + #{offset VkClearAttachment, clearValue} + type FieldIsArray "clearValue" VkClearAttachment = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkClearAttachment, clearValue} + +instance CanReadField "clearValue" VkClearAttachment where + {-# INLINE getField #-} + getField = vkClearValue + + {-# INLINE readField #-} + readField = readVkClearValue + +instance CanWriteField "clearValue" VkClearAttachment where + {-# INLINE writeField #-} + writeField = writeVkClearValue + +instance Show VkClearAttachment where + showsPrec d x + = showString "VkClearAttachment {" . + showString "vkAspectMask = " . + showsPrec d (vkAspectMask x) . + showString ", " . + showString "vkColorAttachment = " . + showsPrec d (vkColorAttachment x) . + showString ", " . + showString "vkClearValue = " . + showsPrec d (vkClearValue x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkClearColorValue.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkClearColorValue.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkClearColorValue.hsc @@ -0,0 +1,366 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleContexts #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE ScopedTypeVariables #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +{-# LANGUAGE UndecidableInstances #-} +module Graphics.Vulkan.Types.Struct.VkClearColorValue + (VkClearColorValue(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import GHC.TypeLits (KnownNat, natVal') -- ' closing tick for hsc2hs +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | // Union allowing specification of floating point, integer, or unsigned integer color data. Actual value selected is based on image/attachment being cleared. +-- +-- > typedef union VkClearColorValue { +-- > float float32[4]; +-- > int32_t int32[4]; +-- > uint32_t uint32[4]; +-- > } VkClearColorValue; +-- +-- +data VkClearColorValue = VkClearColorValue## Addr## ByteArray## + +instance Eq VkClearColorValue where + (VkClearColorValue## a _) == x@(VkClearColorValue## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkClearColorValue where + (VkClearColorValue## a _) `compare` x@(VkClearColorValue## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkClearColorValue where + sizeOf ~_ = #{size VkClearColorValue} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkClearColorValue} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkClearColorValue where + unsafeAddr (VkClearColorValue## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkClearColorValue## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkClearColorValue## (plusAddr## (byteArrayContents## b) off) b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkClearColorValue where + type StructFields VkClearColorValue = + '["float32", "int32", "uint32"] -- ' closing tick for hsc2hs + type CUnionType VkClearColorValue = 'True -- ' closing tick for hsc2hs + type ReturnedOnly VkClearColorValue = 'False -- ' closing tick for hsc2hs + type StructExtends VkClearColorValue = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkFloat32Array VkClearColorValue + where + type VkFloat32ArrayMType VkClearColorValue = + #{type float} + + {-# NOINLINE vkFloat32Array #-} + vkFloat32Array x idx + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) + (idx * sizeOf (undefined :: #{type float}) + + #{offset VkClearColorValue, float32})) + + {-# INLINE vkFloat32ArrayByteOffset #-} + vkFloat32ArrayByteOffset ~_ + = #{offset VkClearColorValue, float32} + + {-# INLINE readVkFloat32Array #-} + readVkFloat32Array p idx + = peekByteOff p + (idx * sizeOf (undefined :: #{type float}) + + #{offset VkClearColorValue, float32}) + + {-# INLINE writeVkFloat32Array #-} + writeVkFloat32Array p idx + = pokeByteOff p + (idx * sizeOf (undefined :: #{type float}) + + #{offset VkClearColorValue, float32}) + +instance {-# OVERLAPPING #-} HasField "float32" VkClearColorValue + where + type FieldType "float32" VkClearColorValue = + #{type float} + type FieldOptional "float32" VkClearColorValue = 'False -- ' closing tick for hsc2hs + type FieldOffset "float32" VkClearColorValue = + #{offset VkClearColorValue, float32} + type FieldIsArray "float32" VkClearColorValue = 'True -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkClearColorValue, float32} + +instance (KnownNat idx, + IndexInBounds "float32" idx VkClearColorValue) => + CanReadFieldArray "float32" idx VkClearColorValue + where + {-# SPECIALISE instance + CanReadFieldArray "float32" 0 VkClearColorValue #-} + + {-# SPECIALISE instance + CanReadFieldArray "float32" 1 VkClearColorValue #-} + + {-# SPECIALISE instance + CanReadFieldArray "float32" 2 VkClearColorValue #-} + + {-# SPECIALISE instance + CanReadFieldArray "float32" 3 VkClearColorValue #-} + type FieldArrayLength "float32" VkClearColorValue = 4 + + {-# INLINE fieldArrayLength #-} + fieldArrayLength = 4 + + {-# INLINE getFieldArray #-} + getFieldArray x + = vkFloat32Array x (fromInteger $ natVal' (proxy## :: Proxy## idx)) -- ' closing tick for hsc2hs + + {-# INLINE readFieldArray #-} + readFieldArray x + = readVkFloat32Array x + (fromInteger $ natVal' (proxy## :: Proxy## idx)) -- ' closing tick for hsc2hs + +instance (KnownNat idx, + IndexInBounds "float32" idx VkClearColorValue) => + CanWriteFieldArray "float32" idx VkClearColorValue + where + {-# SPECIALISE instance + CanWriteFieldArray "float32" 0 VkClearColorValue #-} + + {-# SPECIALISE instance + CanWriteFieldArray "float32" 1 VkClearColorValue #-} + + {-# SPECIALISE instance + CanWriteFieldArray "float32" 2 VkClearColorValue #-} + + {-# SPECIALISE instance + CanWriteFieldArray "float32" 3 VkClearColorValue #-} + + {-# INLINE writeFieldArray #-} + writeFieldArray x + = writeVkFloat32Array x + (fromInteger $ natVal' (proxy## :: Proxy## idx)) -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkInt32Array VkClearColorValue + where + type VkInt32ArrayMType VkClearColorValue = Int32 + + {-# NOINLINE vkInt32Array #-} + vkInt32Array x idx + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) + (idx * sizeOf (undefined :: Int32) + + #{offset VkClearColorValue, int32})) + + {-# INLINE vkInt32ArrayByteOffset #-} + vkInt32ArrayByteOffset ~_ + = #{offset VkClearColorValue, int32} + + {-# INLINE readVkInt32Array #-} + readVkInt32Array p idx + = peekByteOff p + (idx * sizeOf (undefined :: Int32) + + #{offset VkClearColorValue, int32}) + + {-# INLINE writeVkInt32Array #-} + writeVkInt32Array p idx + = pokeByteOff p + (idx * sizeOf (undefined :: Int32) + + #{offset VkClearColorValue, int32}) + +instance {-# OVERLAPPING #-} HasField "int32" VkClearColorValue + where + type FieldType "int32" VkClearColorValue = Int32 + type FieldOptional "int32" VkClearColorValue = 'False -- ' closing tick for hsc2hs + type FieldOffset "int32" VkClearColorValue = + #{offset VkClearColorValue, int32} + type FieldIsArray "int32" VkClearColorValue = 'True -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkClearColorValue, int32} + +instance (KnownNat idx, + IndexInBounds "int32" idx VkClearColorValue) => + CanReadFieldArray "int32" idx VkClearColorValue + where + {-# SPECIALISE instance + CanReadFieldArray "int32" 0 VkClearColorValue #-} + + {-# SPECIALISE instance + CanReadFieldArray "int32" 1 VkClearColorValue #-} + + {-# SPECIALISE instance + CanReadFieldArray "int32" 2 VkClearColorValue #-} + + {-# SPECIALISE instance + CanReadFieldArray "int32" 3 VkClearColorValue #-} + type FieldArrayLength "int32" VkClearColorValue = 4 + + {-# INLINE fieldArrayLength #-} + fieldArrayLength = 4 + + {-# INLINE getFieldArray #-} + getFieldArray x + = vkInt32Array x (fromInteger $ natVal' (proxy## :: Proxy## idx)) -- ' closing tick for hsc2hs + + {-# INLINE readFieldArray #-} + readFieldArray x + = readVkInt32Array x (fromInteger $ natVal' (proxy## :: Proxy## idx)) -- ' closing tick for hsc2hs + +instance (KnownNat idx, + IndexInBounds "int32" idx VkClearColorValue) => + CanWriteFieldArray "int32" idx VkClearColorValue + where + {-# SPECIALISE instance + CanWriteFieldArray "int32" 0 VkClearColorValue #-} + + {-# SPECIALISE instance + CanWriteFieldArray "int32" 1 VkClearColorValue #-} + + {-# SPECIALISE instance + CanWriteFieldArray "int32" 2 VkClearColorValue #-} + + {-# SPECIALISE instance + CanWriteFieldArray "int32" 3 VkClearColorValue #-} + + {-# INLINE writeFieldArray #-} + writeFieldArray x + = writeVkInt32Array x + (fromInteger $ natVal' (proxy## :: Proxy## idx)) -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkUint32Array VkClearColorValue + where + type VkUint32ArrayMType VkClearColorValue = Word32 + + {-# NOINLINE vkUint32Array #-} + vkUint32Array x idx + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) + (idx * sizeOf (undefined :: Word32) + + #{offset VkClearColorValue, uint32})) + + {-# INLINE vkUint32ArrayByteOffset #-} + vkUint32ArrayByteOffset ~_ + = #{offset VkClearColorValue, uint32} + + {-# INLINE readVkUint32Array #-} + readVkUint32Array p idx + = peekByteOff p + (idx * sizeOf (undefined :: Word32) + + #{offset VkClearColorValue, uint32}) + + {-# INLINE writeVkUint32Array #-} + writeVkUint32Array p idx + = pokeByteOff p + (idx * sizeOf (undefined :: Word32) + + #{offset VkClearColorValue, uint32}) + +instance {-# OVERLAPPING #-} HasField "uint32" VkClearColorValue + where + type FieldType "uint32" VkClearColorValue = Word32 + type FieldOptional "uint32" VkClearColorValue = 'False -- ' closing tick for hsc2hs + type FieldOffset "uint32" VkClearColorValue = + #{offset VkClearColorValue, uint32} + type FieldIsArray "uint32" VkClearColorValue = 'True -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkClearColorValue, uint32} + +instance (KnownNat idx, + IndexInBounds "uint32" idx VkClearColorValue) => + CanReadFieldArray "uint32" idx VkClearColorValue + where + {-# SPECIALISE instance + CanReadFieldArray "uint32" 0 VkClearColorValue #-} + + {-# SPECIALISE instance + CanReadFieldArray "uint32" 1 VkClearColorValue #-} + + {-# SPECIALISE instance + CanReadFieldArray "uint32" 2 VkClearColorValue #-} + + {-# SPECIALISE instance + CanReadFieldArray "uint32" 3 VkClearColorValue #-} + type FieldArrayLength "uint32" VkClearColorValue = 4 + + {-# INLINE fieldArrayLength #-} + fieldArrayLength = 4 + + {-# INLINE getFieldArray #-} + getFieldArray x + = vkUint32Array x (fromInteger $ natVal' (proxy## :: Proxy## idx)) -- ' closing tick for hsc2hs + + {-# INLINE readFieldArray #-} + readFieldArray x + = readVkUint32Array x + (fromInteger $ natVal' (proxy## :: Proxy## idx)) -- ' closing tick for hsc2hs + +instance (KnownNat idx, + IndexInBounds "uint32" idx VkClearColorValue) => + CanWriteFieldArray "uint32" idx VkClearColorValue + where + {-# SPECIALISE instance + CanWriteFieldArray "uint32" 0 VkClearColorValue #-} + + {-# SPECIALISE instance + CanWriteFieldArray "uint32" 1 VkClearColorValue #-} + + {-# SPECIALISE instance + CanWriteFieldArray "uint32" 2 VkClearColorValue #-} + + {-# SPECIALISE instance + CanWriteFieldArray "uint32" 3 VkClearColorValue #-} + + {-# INLINE writeFieldArray #-} + writeFieldArray x + = writeVkUint32Array x + (fromInteger $ natVal' (proxy## :: Proxy## idx)) -- ' closing tick for hsc2hs + +instance Show VkClearColorValue where + showsPrec d x + = showString "VkClearColorValue {" . + showString "vkFloat32Array = [" . + showsPrec d (map (vkFloat32Array x) [1 .. 4]) . + showChar ']' . + showString ", " . + showString "vkInt32Array = [" . + showsPrec d (map (vkInt32Array x) [1 .. 4]) . + showChar ']' . + showString ", " . + showString "vkUint32Array = [" . + showsPrec d (map (vkUint32Array x) [1 .. 4]) . + showChar ']' . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkClearDepthStencilValue.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkClearDepthStencilValue.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkClearDepthStencilValue.hsc @@ -0,0 +1,174 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkClearDepthStencilValue + (VkClearDepthStencilValue(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkClearDepthStencilValue { +-- > float depth; +-- > uint32_t stencil; +-- > } VkClearDepthStencilValue; +-- +-- +data VkClearDepthStencilValue = VkClearDepthStencilValue## Addr## + ByteArray## + +instance Eq VkClearDepthStencilValue where + (VkClearDepthStencilValue## a _) == + x@(VkClearDepthStencilValue## b _) = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkClearDepthStencilValue where + (VkClearDepthStencilValue## a _) `compare` + x@(VkClearDepthStencilValue## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkClearDepthStencilValue where + sizeOf ~_ = #{size VkClearDepthStencilValue} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkClearDepthStencilValue} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkClearDepthStencilValue where + unsafeAddr (VkClearDepthStencilValue## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkClearDepthStencilValue## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkClearDepthStencilValue## (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkClearDepthStencilValue where + type StructFields VkClearDepthStencilValue = '["depth", "stencil"] -- ' closing tick for hsc2hs + type CUnionType VkClearDepthStencilValue = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkClearDepthStencilValue = 'False -- ' closing tick for hsc2hs + type StructExtends VkClearDepthStencilValue = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkDepth VkClearDepthStencilValue + where + type VkDepthMType VkClearDepthStencilValue = + #{type float} + + {-# NOINLINE vkDepth #-} + vkDepth x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkClearDepthStencilValue, depth}) + + {-# INLINE vkDepthByteOffset #-} + vkDepthByteOffset ~_ + = #{offset VkClearDepthStencilValue, depth} + + {-# INLINE readVkDepth #-} + readVkDepth p + = peekByteOff p #{offset VkClearDepthStencilValue, depth} + + {-# INLINE writeVkDepth #-} + writeVkDepth p + = pokeByteOff p #{offset VkClearDepthStencilValue, depth} + +instance {-# OVERLAPPING #-} + HasField "depth" VkClearDepthStencilValue where + type FieldType "depth" VkClearDepthStencilValue = + #{type float} + type FieldOptional "depth" VkClearDepthStencilValue = 'False -- ' closing tick for hsc2hs + type FieldOffset "depth" VkClearDepthStencilValue = + #{offset VkClearDepthStencilValue, depth} + type FieldIsArray "depth" VkClearDepthStencilValue = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkClearDepthStencilValue, depth} + +instance CanReadField "depth" VkClearDepthStencilValue where + {-# INLINE getField #-} + getField = vkDepth + + {-# INLINE readField #-} + readField = readVkDepth + +instance CanWriteField "depth" VkClearDepthStencilValue where + {-# INLINE writeField #-} + writeField = writeVkDepth + +instance {-# OVERLAPPING #-} HasVkStencil VkClearDepthStencilValue + where + type VkStencilMType VkClearDepthStencilValue = Word32 + + {-# NOINLINE vkStencil #-} + vkStencil x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkClearDepthStencilValue, stencil}) + + {-# INLINE vkStencilByteOffset #-} + vkStencilByteOffset ~_ + = #{offset VkClearDepthStencilValue, stencil} + + {-# INLINE readVkStencil #-} + readVkStencil p + = peekByteOff p #{offset VkClearDepthStencilValue, stencil} + + {-# INLINE writeVkStencil #-} + writeVkStencil p + = pokeByteOff p #{offset VkClearDepthStencilValue, stencil} + +instance {-# OVERLAPPING #-} + HasField "stencil" VkClearDepthStencilValue where + type FieldType "stencil" VkClearDepthStencilValue = Word32 + type FieldOptional "stencil" VkClearDepthStencilValue = 'False -- ' closing tick for hsc2hs + type FieldOffset "stencil" VkClearDepthStencilValue = + #{offset VkClearDepthStencilValue, stencil} + type FieldIsArray "stencil" VkClearDepthStencilValue = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkClearDepthStencilValue, stencil} + +instance CanReadField "stencil" VkClearDepthStencilValue where + {-# INLINE getField #-} + getField = vkStencil + + {-# INLINE readField #-} + readField = readVkStencil + +instance CanWriteField "stencil" VkClearDepthStencilValue where + {-# INLINE writeField #-} + writeField = writeVkStencil + +instance Show VkClearDepthStencilValue where + showsPrec d x + = showString "VkClearDepthStencilValue {" . + showString "vkDepth = " . + showsPrec d (vkDepth x) . + showString ", " . + showString "vkStencil = " . + showsPrec d (vkStencil x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkClearRect.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkClearRect.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkClearRect.hsc @@ -0,0 +1,216 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkClearRect (VkClearRect(..)) + where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Struct.VkRect2D (VkRect2D) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkClearRect { +-- > VkRect2D rect; +-- > uint32_t baseArrayLayer; +-- > uint32_t layerCount; +-- > } VkClearRect; +-- +-- +data VkClearRect = VkClearRect## Addr## ByteArray## + +instance Eq VkClearRect where + (VkClearRect## a _) == x@(VkClearRect## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkClearRect where + (VkClearRect## a _) `compare` x@(VkClearRect## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkClearRect where + sizeOf ~_ = #{size VkClearRect} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkClearRect} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkClearRect where + unsafeAddr (VkClearRect## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkClearRect## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkClearRect## (plusAddr## (byteArrayContents## b) off) b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkClearRect where + type StructFields VkClearRect = + '["rect", "baseArrayLayer", "layerCount"] -- ' closing tick for hsc2hs + type CUnionType VkClearRect = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkClearRect = 'False -- ' closing tick for hsc2hs + type StructExtends VkClearRect = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkRect VkClearRect where + type VkRectMType VkClearRect = VkRect2D + + {-# NOINLINE vkRect #-} + vkRect x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkClearRect, rect}) + + {-# INLINE vkRectByteOffset #-} + vkRectByteOffset ~_ = #{offset VkClearRect, rect} + + {-# INLINE readVkRect #-} + readVkRect p + = peekByteOff p #{offset VkClearRect, rect} + + {-# INLINE writeVkRect #-} + writeVkRect p + = pokeByteOff p #{offset VkClearRect, rect} + +instance {-# OVERLAPPING #-} HasField "rect" VkClearRect where + type FieldType "rect" VkClearRect = VkRect2D + type FieldOptional "rect" VkClearRect = 'False -- ' closing tick for hsc2hs + type FieldOffset "rect" VkClearRect = + #{offset VkClearRect, rect} + type FieldIsArray "rect" VkClearRect = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkClearRect, rect} + +instance CanReadField "rect" VkClearRect where + {-# INLINE getField #-} + getField = vkRect + + {-# INLINE readField #-} + readField = readVkRect + +instance CanWriteField "rect" VkClearRect where + {-# INLINE writeField #-} + writeField = writeVkRect + +instance {-# OVERLAPPING #-} HasVkBaseArrayLayer VkClearRect where + type VkBaseArrayLayerMType VkClearRect = Word32 + + {-# NOINLINE vkBaseArrayLayer #-} + vkBaseArrayLayer x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkClearRect, baseArrayLayer}) + + {-# INLINE vkBaseArrayLayerByteOffset #-} + vkBaseArrayLayerByteOffset ~_ + = #{offset VkClearRect, baseArrayLayer} + + {-# INLINE readVkBaseArrayLayer #-} + readVkBaseArrayLayer p + = peekByteOff p #{offset VkClearRect, baseArrayLayer} + + {-# INLINE writeVkBaseArrayLayer #-} + writeVkBaseArrayLayer p + = pokeByteOff p #{offset VkClearRect, baseArrayLayer} + +instance {-# OVERLAPPING #-} HasField "baseArrayLayer" VkClearRect + where + type FieldType "baseArrayLayer" VkClearRect = Word32 + type FieldOptional "baseArrayLayer" VkClearRect = 'False -- ' closing tick for hsc2hs + type FieldOffset "baseArrayLayer" VkClearRect = + #{offset VkClearRect, baseArrayLayer} + type FieldIsArray "baseArrayLayer" VkClearRect = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkClearRect, baseArrayLayer} + +instance CanReadField "baseArrayLayer" VkClearRect where + {-# INLINE getField #-} + getField = vkBaseArrayLayer + + {-# INLINE readField #-} + readField = readVkBaseArrayLayer + +instance CanWriteField "baseArrayLayer" VkClearRect where + {-# INLINE writeField #-} + writeField = writeVkBaseArrayLayer + +instance {-# OVERLAPPING #-} HasVkLayerCount VkClearRect where + type VkLayerCountMType VkClearRect = Word32 + + {-# NOINLINE vkLayerCount #-} + vkLayerCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkClearRect, layerCount}) + + {-# INLINE vkLayerCountByteOffset #-} + vkLayerCountByteOffset ~_ + = #{offset VkClearRect, layerCount} + + {-# INLINE readVkLayerCount #-} + readVkLayerCount p + = peekByteOff p #{offset VkClearRect, layerCount} + + {-# INLINE writeVkLayerCount #-} + writeVkLayerCount p + = pokeByteOff p #{offset VkClearRect, layerCount} + +instance {-# OVERLAPPING #-} HasField "layerCount" VkClearRect + where + type FieldType "layerCount" VkClearRect = Word32 + type FieldOptional "layerCount" VkClearRect = 'False -- ' closing tick for hsc2hs + type FieldOffset "layerCount" VkClearRect = + #{offset VkClearRect, layerCount} + type FieldIsArray "layerCount" VkClearRect = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkClearRect, layerCount} + +instance CanReadField "layerCount" VkClearRect where + {-# INLINE getField #-} + getField = vkLayerCount + + {-# INLINE readField #-} + readField = readVkLayerCount + +instance CanWriteField "layerCount" VkClearRect where + {-# INLINE writeField #-} + writeField = writeVkLayerCount + +instance Show VkClearRect where + showsPrec d x + = showString "VkClearRect {" . + showString "vkRect = " . + showsPrec d (vkRect x) . + showString ", " . + showString "vkBaseArrayLayer = " . + showsPrec d (vkBaseArrayLayer x) . + showString ", " . + showString "vkLayerCount = " . + showsPrec d (vkLayerCount x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkClearValue.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkClearValue.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkClearValue.hsc @@ -0,0 +1,170 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkClearValue (VkClearValue(..)) + where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Struct.VkClearColorValue (VkClearColorValue) +import Graphics.Vulkan.Types.Struct.VkClearDepthStencilValue (VkClearDepthStencilValue) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | // Union allowing specification of color or depth and stencil values. Actual value selected is based on attachment being cleared. +-- +-- > typedef union VkClearValue { +-- > VkClearColorValue color; +-- > VkClearDepthStencilValue depthStencil; +-- > } VkClearValue; +-- +-- +data VkClearValue = VkClearValue## Addr## ByteArray## + +instance Eq VkClearValue where + (VkClearValue## a _) == x@(VkClearValue## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkClearValue where + (VkClearValue## a _) `compare` x@(VkClearValue## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkClearValue where + sizeOf ~_ = #{size VkClearValue} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkClearValue} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkClearValue where + unsafeAddr (VkClearValue## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkClearValue## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkClearValue## (plusAddr## (byteArrayContents## b) off) b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkClearValue where + type StructFields VkClearValue = '["color", "depthStencil"] -- ' closing tick for hsc2hs + type CUnionType VkClearValue = 'True -- ' closing tick for hsc2hs + type ReturnedOnly VkClearValue = 'False -- ' closing tick for hsc2hs + type StructExtends VkClearValue = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkColor VkClearValue where + type VkColorMType VkClearValue = VkClearColorValue + + {-# NOINLINE vkColor #-} + vkColor x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkClearValue, color}) + + {-# INLINE vkColorByteOffset #-} + vkColorByteOffset ~_ = #{offset VkClearValue, color} + + {-# INLINE readVkColor #-} + readVkColor p + = peekByteOff p #{offset VkClearValue, color} + + {-# INLINE writeVkColor #-} + writeVkColor p + = pokeByteOff p #{offset VkClearValue, color} + +instance {-# OVERLAPPING #-} HasField "color" VkClearValue where + type FieldType "color" VkClearValue = VkClearColorValue + type FieldOptional "color" VkClearValue = 'False -- ' closing tick for hsc2hs + type FieldOffset "color" VkClearValue = + #{offset VkClearValue, color} + type FieldIsArray "color" VkClearValue = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkClearValue, color} + +instance CanReadField "color" VkClearValue where + {-# INLINE getField #-} + getField = vkColor + + {-# INLINE readField #-} + readField = readVkColor + +instance CanWriteField "color" VkClearValue where + {-# INLINE writeField #-} + writeField = writeVkColor + +instance {-# OVERLAPPING #-} HasVkDepthStencil VkClearValue where + type VkDepthStencilMType VkClearValue = VkClearDepthStencilValue + + {-# NOINLINE vkDepthStencil #-} + vkDepthStencil x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkClearValue, depthStencil}) + + {-# INLINE vkDepthStencilByteOffset #-} + vkDepthStencilByteOffset ~_ + = #{offset VkClearValue, depthStencil} + + {-# INLINE readVkDepthStencil #-} + readVkDepthStencil p + = peekByteOff p #{offset VkClearValue, depthStencil} + + {-# INLINE writeVkDepthStencil #-} + writeVkDepthStencil p + = pokeByteOff p #{offset VkClearValue, depthStencil} + +instance {-# OVERLAPPING #-} HasField "depthStencil" VkClearValue + where + type FieldType "depthStencil" VkClearValue = + VkClearDepthStencilValue + type FieldOptional "depthStencil" VkClearValue = 'False -- ' closing tick for hsc2hs + type FieldOffset "depthStencil" VkClearValue = + #{offset VkClearValue, depthStencil} + type FieldIsArray "depthStencil" VkClearValue = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkClearValue, depthStencil} + +instance CanReadField "depthStencil" VkClearValue where + {-# INLINE getField #-} + getField = vkDepthStencil + + {-# INLINE readField #-} + readField = readVkDepthStencil + +instance CanWriteField "depthStencil" VkClearValue where + {-# INLINE writeField #-} + writeField = writeVkDepthStencil + +instance Show VkClearValue where + showsPrec d x + = showString "VkClearValue {" . + showString "vkColor = " . + showsPrec d (vkColor x) . + showString ", " . + showString "vkDepthStencil = " . + showsPrec d (vkDepthStencil x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkCmdProcessCommandsInfoNVX.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkCmdProcessCommandsInfoNVX.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkCmdProcessCommandsInfoNVX.hsc @@ -0,0 +1,822 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkCmdProcessCommandsInfoNVX + (VkCmdProcessCommandsInfoNVX(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.BaseTypes (VkDeviceSize) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Handles (VkBuffer, + VkCommandBuffer, + VkIndirectCommandsLayoutNVX, + VkObjectTableNVX) +import Graphics.Vulkan.Types.Struct.VkIndirectCommandsTokenNVX (VkIndirectCommandsTokenNVX) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkCmdProcessCommandsInfoNVX { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkObjectTableNVX objectTable; +-- > VkIndirectCommandsLayoutNVX indirectCommandsLayout; +-- > uint32_t indirectCommandsTokenCount; +-- > const VkIndirectCommandsTokenNVX* pIndirectCommandsTokens; +-- > uint32_t maxSequencesCount; +-- > VkCommandBuffer targetCommandBuffer; +-- > VkBuffer sequencesCountBuffer; +-- > VkDeviceSize sequencesCountOffset; +-- > VkBuffer sequencesIndexBuffer; +-- > VkDeviceSize sequencesIndexOffset; +-- > } VkCmdProcessCommandsInfoNVX; +-- +-- +data VkCmdProcessCommandsInfoNVX = VkCmdProcessCommandsInfoNVX## Addr## + ByteArray## + +instance Eq VkCmdProcessCommandsInfoNVX where + (VkCmdProcessCommandsInfoNVX## a _) == + x@(VkCmdProcessCommandsInfoNVX## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkCmdProcessCommandsInfoNVX where + (VkCmdProcessCommandsInfoNVX## a _) `compare` + x@(VkCmdProcessCommandsInfoNVX## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkCmdProcessCommandsInfoNVX where + sizeOf ~_ = #{size VkCmdProcessCommandsInfoNVX} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkCmdProcessCommandsInfoNVX} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkCmdProcessCommandsInfoNVX where + unsafeAddr (VkCmdProcessCommandsInfoNVX## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkCmdProcessCommandsInfoNVX## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkCmdProcessCommandsInfoNVX## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkCmdProcessCommandsInfoNVX where + type StructFields VkCmdProcessCommandsInfoNVX = + '["sType", "pNext", "objectTable", "indirectCommandsLayout", -- ' closing tick for hsc2hs + "indirectCommandsTokenCount", "pIndirectCommandsTokens", + "maxSequencesCount", "targetCommandBuffer", "sequencesCountBuffer", + "sequencesCountOffset", "sequencesIndexBuffer", + "sequencesIndexOffset"] + type CUnionType VkCmdProcessCommandsInfoNVX = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkCmdProcessCommandsInfoNVX = 'False -- ' closing tick for hsc2hs + type StructExtends VkCmdProcessCommandsInfoNVX = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkSType VkCmdProcessCommandsInfoNVX + where + type VkSTypeMType VkCmdProcessCommandsInfoNVX = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkCmdProcessCommandsInfoNVX, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkCmdProcessCommandsInfoNVX, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkCmdProcessCommandsInfoNVX, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkCmdProcessCommandsInfoNVX, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkCmdProcessCommandsInfoNVX where + type FieldType "sType" VkCmdProcessCommandsInfoNVX = + VkStructureType + type FieldOptional "sType" VkCmdProcessCommandsInfoNVX = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkCmdProcessCommandsInfoNVX = + #{offset VkCmdProcessCommandsInfoNVX, sType} + type FieldIsArray "sType" VkCmdProcessCommandsInfoNVX = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkCmdProcessCommandsInfoNVX, sType} + +instance CanReadField "sType" VkCmdProcessCommandsInfoNVX where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkCmdProcessCommandsInfoNVX where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} HasVkPNext VkCmdProcessCommandsInfoNVX + where + type VkPNextMType VkCmdProcessCommandsInfoNVX = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkCmdProcessCommandsInfoNVX, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkCmdProcessCommandsInfoNVX, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkCmdProcessCommandsInfoNVX, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkCmdProcessCommandsInfoNVX, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkCmdProcessCommandsInfoNVX where + type FieldType "pNext" VkCmdProcessCommandsInfoNVX = Ptr Void + type FieldOptional "pNext" VkCmdProcessCommandsInfoNVX = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkCmdProcessCommandsInfoNVX = + #{offset VkCmdProcessCommandsInfoNVX, pNext} + type FieldIsArray "pNext" VkCmdProcessCommandsInfoNVX = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkCmdProcessCommandsInfoNVX, pNext} + +instance CanReadField "pNext" VkCmdProcessCommandsInfoNVX where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkCmdProcessCommandsInfoNVX where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkObjectTable VkCmdProcessCommandsInfoNVX where + type VkObjectTableMType VkCmdProcessCommandsInfoNVX = + VkObjectTableNVX + + {-# NOINLINE vkObjectTable #-} + vkObjectTable x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkCmdProcessCommandsInfoNVX, objectTable}) + + {-# INLINE vkObjectTableByteOffset #-} + vkObjectTableByteOffset ~_ + = #{offset VkCmdProcessCommandsInfoNVX, objectTable} + + {-# INLINE readVkObjectTable #-} + readVkObjectTable p + = peekByteOff p #{offset VkCmdProcessCommandsInfoNVX, objectTable} + + {-# INLINE writeVkObjectTable #-} + writeVkObjectTable p + = pokeByteOff p #{offset VkCmdProcessCommandsInfoNVX, objectTable} + +instance {-# OVERLAPPING #-} + HasField "objectTable" VkCmdProcessCommandsInfoNVX where + type FieldType "objectTable" VkCmdProcessCommandsInfoNVX = + VkObjectTableNVX + type FieldOptional "objectTable" VkCmdProcessCommandsInfoNVX = + 'False -- ' closing tick for hsc2hs + type FieldOffset "objectTable" VkCmdProcessCommandsInfoNVX = + #{offset VkCmdProcessCommandsInfoNVX, objectTable} + type FieldIsArray "objectTable" VkCmdProcessCommandsInfoNVX = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkCmdProcessCommandsInfoNVX, objectTable} + +instance CanReadField "objectTable" VkCmdProcessCommandsInfoNVX + where + {-# INLINE getField #-} + getField = vkObjectTable + + {-# INLINE readField #-} + readField = readVkObjectTable + +instance CanWriteField "objectTable" VkCmdProcessCommandsInfoNVX + where + {-# INLINE writeField #-} + writeField = writeVkObjectTable + +instance {-# OVERLAPPING #-} + HasVkIndirectCommandsLayout VkCmdProcessCommandsInfoNVX where + type VkIndirectCommandsLayoutMType VkCmdProcessCommandsInfoNVX = + VkIndirectCommandsLayoutNVX + + {-# NOINLINE vkIndirectCommandsLayout #-} + vkIndirectCommandsLayout x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkCmdProcessCommandsInfoNVX, indirectCommandsLayout}) + + {-# INLINE vkIndirectCommandsLayoutByteOffset #-} + vkIndirectCommandsLayoutByteOffset ~_ + = #{offset VkCmdProcessCommandsInfoNVX, indirectCommandsLayout} + + {-# INLINE readVkIndirectCommandsLayout #-} + readVkIndirectCommandsLayout p + = peekByteOff p #{offset VkCmdProcessCommandsInfoNVX, indirectCommandsLayout} + + {-# INLINE writeVkIndirectCommandsLayout #-} + writeVkIndirectCommandsLayout p + = pokeByteOff p #{offset VkCmdProcessCommandsInfoNVX, indirectCommandsLayout} + +instance {-# OVERLAPPING #-} + HasField "indirectCommandsLayout" VkCmdProcessCommandsInfoNVX where + type FieldType "indirectCommandsLayout" VkCmdProcessCommandsInfoNVX + = VkIndirectCommandsLayoutNVX + type FieldOptional "indirectCommandsLayout" + VkCmdProcessCommandsInfoNVX + = 'False -- ' closing tick for hsc2hs + type FieldOffset "indirectCommandsLayout" + VkCmdProcessCommandsInfoNVX + = + #{offset VkCmdProcessCommandsInfoNVX, indirectCommandsLayout} + type FieldIsArray "indirectCommandsLayout" + VkCmdProcessCommandsInfoNVX + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkCmdProcessCommandsInfoNVX, indirectCommandsLayout} + +instance CanReadField "indirectCommandsLayout" + VkCmdProcessCommandsInfoNVX + where + {-# INLINE getField #-} + getField = vkIndirectCommandsLayout + + {-# INLINE readField #-} + readField = readVkIndirectCommandsLayout + +instance CanWriteField "indirectCommandsLayout" + VkCmdProcessCommandsInfoNVX + where + {-# INLINE writeField #-} + writeField = writeVkIndirectCommandsLayout + +instance {-# OVERLAPPING #-} + HasVkIndirectCommandsTokenCount VkCmdProcessCommandsInfoNVX where + type VkIndirectCommandsTokenCountMType VkCmdProcessCommandsInfoNVX + = Word32 + + {-# NOINLINE vkIndirectCommandsTokenCount #-} + vkIndirectCommandsTokenCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkCmdProcessCommandsInfoNVX, indirectCommandsTokenCount}) + + {-# INLINE vkIndirectCommandsTokenCountByteOffset #-} + vkIndirectCommandsTokenCountByteOffset ~_ + = #{offset VkCmdProcessCommandsInfoNVX, indirectCommandsTokenCount} + + {-# INLINE readVkIndirectCommandsTokenCount #-} + readVkIndirectCommandsTokenCount p + = peekByteOff p #{offset VkCmdProcessCommandsInfoNVX, indirectCommandsTokenCount} + + {-# INLINE writeVkIndirectCommandsTokenCount #-} + writeVkIndirectCommandsTokenCount p + = pokeByteOff p #{offset VkCmdProcessCommandsInfoNVX, indirectCommandsTokenCount} + +instance {-# OVERLAPPING #-} + HasField "indirectCommandsTokenCount" VkCmdProcessCommandsInfoNVX + where + type FieldType "indirectCommandsTokenCount" + VkCmdProcessCommandsInfoNVX + = Word32 + type FieldOptional "indirectCommandsTokenCount" + VkCmdProcessCommandsInfoNVX + = 'False -- ' closing tick for hsc2hs + type FieldOffset "indirectCommandsTokenCount" + VkCmdProcessCommandsInfoNVX + = + #{offset VkCmdProcessCommandsInfoNVX, indirectCommandsTokenCount} + type FieldIsArray "indirectCommandsTokenCount" + VkCmdProcessCommandsInfoNVX + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkCmdProcessCommandsInfoNVX, indirectCommandsTokenCount} + +instance CanReadField "indirectCommandsTokenCount" + VkCmdProcessCommandsInfoNVX + where + {-# INLINE getField #-} + getField = vkIndirectCommandsTokenCount + + {-# INLINE readField #-} + readField = readVkIndirectCommandsTokenCount + +instance CanWriteField "indirectCommandsTokenCount" + VkCmdProcessCommandsInfoNVX + where + {-# INLINE writeField #-} + writeField = writeVkIndirectCommandsTokenCount + +instance {-# OVERLAPPING #-} + HasVkPIndirectCommandsTokens VkCmdProcessCommandsInfoNVX where + type VkPIndirectCommandsTokensMType VkCmdProcessCommandsInfoNVX = + Ptr VkIndirectCommandsTokenNVX + + {-# NOINLINE vkPIndirectCommandsTokens #-} + vkPIndirectCommandsTokens x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkCmdProcessCommandsInfoNVX, pIndirectCommandsTokens}) + + {-# INLINE vkPIndirectCommandsTokensByteOffset #-} + vkPIndirectCommandsTokensByteOffset ~_ + = #{offset VkCmdProcessCommandsInfoNVX, pIndirectCommandsTokens} + + {-# INLINE readVkPIndirectCommandsTokens #-} + readVkPIndirectCommandsTokens p + = peekByteOff p #{offset VkCmdProcessCommandsInfoNVX, pIndirectCommandsTokens} + + {-# INLINE writeVkPIndirectCommandsTokens #-} + writeVkPIndirectCommandsTokens p + = pokeByteOff p #{offset VkCmdProcessCommandsInfoNVX, pIndirectCommandsTokens} + +instance {-# OVERLAPPING #-} + HasField "pIndirectCommandsTokens" VkCmdProcessCommandsInfoNVX + where + type FieldType "pIndirectCommandsTokens" + VkCmdProcessCommandsInfoNVX + = Ptr VkIndirectCommandsTokenNVX + type FieldOptional "pIndirectCommandsTokens" + VkCmdProcessCommandsInfoNVX + = 'False -- ' closing tick for hsc2hs + type FieldOffset "pIndirectCommandsTokens" + VkCmdProcessCommandsInfoNVX + = + #{offset VkCmdProcessCommandsInfoNVX, pIndirectCommandsTokens} + type FieldIsArray "pIndirectCommandsTokens" + VkCmdProcessCommandsInfoNVX + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkCmdProcessCommandsInfoNVX, pIndirectCommandsTokens} + +instance CanReadField "pIndirectCommandsTokens" + VkCmdProcessCommandsInfoNVX + where + {-# INLINE getField #-} + getField = vkPIndirectCommandsTokens + + {-# INLINE readField #-} + readField = readVkPIndirectCommandsTokens + +instance CanWriteField "pIndirectCommandsTokens" + VkCmdProcessCommandsInfoNVX + where + {-# INLINE writeField #-} + writeField = writeVkPIndirectCommandsTokens + +instance {-# OVERLAPPING #-} + HasVkMaxSequencesCount VkCmdProcessCommandsInfoNVX where + type VkMaxSequencesCountMType VkCmdProcessCommandsInfoNVX = Word32 + + {-# NOINLINE vkMaxSequencesCount #-} + vkMaxSequencesCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkCmdProcessCommandsInfoNVX, maxSequencesCount}) + + {-# INLINE vkMaxSequencesCountByteOffset #-} + vkMaxSequencesCountByteOffset ~_ + = #{offset VkCmdProcessCommandsInfoNVX, maxSequencesCount} + + {-# INLINE readVkMaxSequencesCount #-} + readVkMaxSequencesCount p + = peekByteOff p #{offset VkCmdProcessCommandsInfoNVX, maxSequencesCount} + + {-# INLINE writeVkMaxSequencesCount #-} + writeVkMaxSequencesCount p + = pokeByteOff p #{offset VkCmdProcessCommandsInfoNVX, maxSequencesCount} + +instance {-# OVERLAPPING #-} + HasField "maxSequencesCount" VkCmdProcessCommandsInfoNVX where + type FieldType "maxSequencesCount" VkCmdProcessCommandsInfoNVX = + Word32 + type FieldOptional "maxSequencesCount" VkCmdProcessCommandsInfoNVX + = 'False -- ' closing tick for hsc2hs + type FieldOffset "maxSequencesCount" VkCmdProcessCommandsInfoNVX = + #{offset VkCmdProcessCommandsInfoNVX, maxSequencesCount} + type FieldIsArray "maxSequencesCount" VkCmdProcessCommandsInfoNVX = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkCmdProcessCommandsInfoNVX, maxSequencesCount} + +instance CanReadField "maxSequencesCount" + VkCmdProcessCommandsInfoNVX + where + {-# INLINE getField #-} + getField = vkMaxSequencesCount + + {-# INLINE readField #-} + readField = readVkMaxSequencesCount + +instance CanWriteField "maxSequencesCount" + VkCmdProcessCommandsInfoNVX + where + {-# INLINE writeField #-} + writeField = writeVkMaxSequencesCount + +instance {-# OVERLAPPING #-} + HasVkTargetCommandBuffer VkCmdProcessCommandsInfoNVX where + type VkTargetCommandBufferMType VkCmdProcessCommandsInfoNVX = + VkCommandBuffer + + {-# NOINLINE vkTargetCommandBuffer #-} + vkTargetCommandBuffer x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkCmdProcessCommandsInfoNVX, targetCommandBuffer}) + + {-# INLINE vkTargetCommandBufferByteOffset #-} + vkTargetCommandBufferByteOffset ~_ + = #{offset VkCmdProcessCommandsInfoNVX, targetCommandBuffer} + + {-# INLINE readVkTargetCommandBuffer #-} + readVkTargetCommandBuffer p + = peekByteOff p #{offset VkCmdProcessCommandsInfoNVX, targetCommandBuffer} + + {-# INLINE writeVkTargetCommandBuffer #-} + writeVkTargetCommandBuffer p + = pokeByteOff p #{offset VkCmdProcessCommandsInfoNVX, targetCommandBuffer} + +instance {-# OVERLAPPING #-} + HasField "targetCommandBuffer" VkCmdProcessCommandsInfoNVX where + type FieldType "targetCommandBuffer" VkCmdProcessCommandsInfoNVX = + VkCommandBuffer + type FieldOptional "targetCommandBuffer" + VkCmdProcessCommandsInfoNVX + = 'True -- ' closing tick for hsc2hs + type FieldOffset "targetCommandBuffer" VkCmdProcessCommandsInfoNVX + = + #{offset VkCmdProcessCommandsInfoNVX, targetCommandBuffer} + type FieldIsArray "targetCommandBuffer" VkCmdProcessCommandsInfoNVX + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkCmdProcessCommandsInfoNVX, targetCommandBuffer} + +instance CanReadField "targetCommandBuffer" + VkCmdProcessCommandsInfoNVX + where + {-# INLINE getField #-} + getField = vkTargetCommandBuffer + + {-# INLINE readField #-} + readField = readVkTargetCommandBuffer + +instance CanWriteField "targetCommandBuffer" + VkCmdProcessCommandsInfoNVX + where + {-# INLINE writeField #-} + writeField = writeVkTargetCommandBuffer + +instance {-# OVERLAPPING #-} + HasVkSequencesCountBuffer VkCmdProcessCommandsInfoNVX where + type VkSequencesCountBufferMType VkCmdProcessCommandsInfoNVX = + VkBuffer + + {-# NOINLINE vkSequencesCountBuffer #-} + vkSequencesCountBuffer x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkCmdProcessCommandsInfoNVX, sequencesCountBuffer}) + + {-# INLINE vkSequencesCountBufferByteOffset #-} + vkSequencesCountBufferByteOffset ~_ + = #{offset VkCmdProcessCommandsInfoNVX, sequencesCountBuffer} + + {-# INLINE readVkSequencesCountBuffer #-} + readVkSequencesCountBuffer p + = peekByteOff p #{offset VkCmdProcessCommandsInfoNVX, sequencesCountBuffer} + + {-# INLINE writeVkSequencesCountBuffer #-} + writeVkSequencesCountBuffer p + = pokeByteOff p #{offset VkCmdProcessCommandsInfoNVX, sequencesCountBuffer} + +instance {-# OVERLAPPING #-} + HasField "sequencesCountBuffer" VkCmdProcessCommandsInfoNVX where + type FieldType "sequencesCountBuffer" VkCmdProcessCommandsInfoNVX = + VkBuffer + type FieldOptional "sequencesCountBuffer" + VkCmdProcessCommandsInfoNVX + = 'True -- ' closing tick for hsc2hs + type FieldOffset "sequencesCountBuffer" VkCmdProcessCommandsInfoNVX + = + #{offset VkCmdProcessCommandsInfoNVX, sequencesCountBuffer} + type FieldIsArray "sequencesCountBuffer" + VkCmdProcessCommandsInfoNVX + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkCmdProcessCommandsInfoNVX, sequencesCountBuffer} + +instance CanReadField "sequencesCountBuffer" + VkCmdProcessCommandsInfoNVX + where + {-# INLINE getField #-} + getField = vkSequencesCountBuffer + + {-# INLINE readField #-} + readField = readVkSequencesCountBuffer + +instance CanWriteField "sequencesCountBuffer" + VkCmdProcessCommandsInfoNVX + where + {-# INLINE writeField #-} + writeField = writeVkSequencesCountBuffer + +instance {-# OVERLAPPING #-} + HasVkSequencesCountOffset VkCmdProcessCommandsInfoNVX where + type VkSequencesCountOffsetMType VkCmdProcessCommandsInfoNVX = + VkDeviceSize + + {-# NOINLINE vkSequencesCountOffset #-} + vkSequencesCountOffset x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkCmdProcessCommandsInfoNVX, sequencesCountOffset}) + + {-# INLINE vkSequencesCountOffsetByteOffset #-} + vkSequencesCountOffsetByteOffset ~_ + = #{offset VkCmdProcessCommandsInfoNVX, sequencesCountOffset} + + {-# INLINE readVkSequencesCountOffset #-} + readVkSequencesCountOffset p + = peekByteOff p #{offset VkCmdProcessCommandsInfoNVX, sequencesCountOffset} + + {-# INLINE writeVkSequencesCountOffset #-} + writeVkSequencesCountOffset p + = pokeByteOff p #{offset VkCmdProcessCommandsInfoNVX, sequencesCountOffset} + +instance {-# OVERLAPPING #-} + HasField "sequencesCountOffset" VkCmdProcessCommandsInfoNVX where + type FieldType "sequencesCountOffset" VkCmdProcessCommandsInfoNVX = + VkDeviceSize + type FieldOptional "sequencesCountOffset" + VkCmdProcessCommandsInfoNVX + = 'True -- ' closing tick for hsc2hs + type FieldOffset "sequencesCountOffset" VkCmdProcessCommandsInfoNVX + = + #{offset VkCmdProcessCommandsInfoNVX, sequencesCountOffset} + type FieldIsArray "sequencesCountOffset" + VkCmdProcessCommandsInfoNVX + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkCmdProcessCommandsInfoNVX, sequencesCountOffset} + +instance CanReadField "sequencesCountOffset" + VkCmdProcessCommandsInfoNVX + where + {-# INLINE getField #-} + getField = vkSequencesCountOffset + + {-# INLINE readField #-} + readField = readVkSequencesCountOffset + +instance CanWriteField "sequencesCountOffset" + VkCmdProcessCommandsInfoNVX + where + {-# INLINE writeField #-} + writeField = writeVkSequencesCountOffset + +instance {-# OVERLAPPING #-} + HasVkSequencesIndexBuffer VkCmdProcessCommandsInfoNVX where + type VkSequencesIndexBufferMType VkCmdProcessCommandsInfoNVX = + VkBuffer + + {-# NOINLINE vkSequencesIndexBuffer #-} + vkSequencesIndexBuffer x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkCmdProcessCommandsInfoNVX, sequencesIndexBuffer}) + + {-# INLINE vkSequencesIndexBufferByteOffset #-} + vkSequencesIndexBufferByteOffset ~_ + = #{offset VkCmdProcessCommandsInfoNVX, sequencesIndexBuffer} + + {-# INLINE readVkSequencesIndexBuffer #-} + readVkSequencesIndexBuffer p + = peekByteOff p #{offset VkCmdProcessCommandsInfoNVX, sequencesIndexBuffer} + + {-# INLINE writeVkSequencesIndexBuffer #-} + writeVkSequencesIndexBuffer p + = pokeByteOff p #{offset VkCmdProcessCommandsInfoNVX, sequencesIndexBuffer} + +instance {-# OVERLAPPING #-} + HasField "sequencesIndexBuffer" VkCmdProcessCommandsInfoNVX where + type FieldType "sequencesIndexBuffer" VkCmdProcessCommandsInfoNVX = + VkBuffer + type FieldOptional "sequencesIndexBuffer" + VkCmdProcessCommandsInfoNVX + = 'True -- ' closing tick for hsc2hs + type FieldOffset "sequencesIndexBuffer" VkCmdProcessCommandsInfoNVX + = + #{offset VkCmdProcessCommandsInfoNVX, sequencesIndexBuffer} + type FieldIsArray "sequencesIndexBuffer" + VkCmdProcessCommandsInfoNVX + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkCmdProcessCommandsInfoNVX, sequencesIndexBuffer} + +instance CanReadField "sequencesIndexBuffer" + VkCmdProcessCommandsInfoNVX + where + {-# INLINE getField #-} + getField = vkSequencesIndexBuffer + + {-# INLINE readField #-} + readField = readVkSequencesIndexBuffer + +instance CanWriteField "sequencesIndexBuffer" + VkCmdProcessCommandsInfoNVX + where + {-# INLINE writeField #-} + writeField = writeVkSequencesIndexBuffer + +instance {-# OVERLAPPING #-} + HasVkSequencesIndexOffset VkCmdProcessCommandsInfoNVX where + type VkSequencesIndexOffsetMType VkCmdProcessCommandsInfoNVX = + VkDeviceSize + + {-# NOINLINE vkSequencesIndexOffset #-} + vkSequencesIndexOffset x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkCmdProcessCommandsInfoNVX, sequencesIndexOffset}) + + {-# INLINE vkSequencesIndexOffsetByteOffset #-} + vkSequencesIndexOffsetByteOffset ~_ + = #{offset VkCmdProcessCommandsInfoNVX, sequencesIndexOffset} + + {-# INLINE readVkSequencesIndexOffset #-} + readVkSequencesIndexOffset p + = peekByteOff p #{offset VkCmdProcessCommandsInfoNVX, sequencesIndexOffset} + + {-# INLINE writeVkSequencesIndexOffset #-} + writeVkSequencesIndexOffset p + = pokeByteOff p #{offset VkCmdProcessCommandsInfoNVX, sequencesIndexOffset} + +instance {-# OVERLAPPING #-} + HasField "sequencesIndexOffset" VkCmdProcessCommandsInfoNVX where + type FieldType "sequencesIndexOffset" VkCmdProcessCommandsInfoNVX = + VkDeviceSize + type FieldOptional "sequencesIndexOffset" + VkCmdProcessCommandsInfoNVX + = 'True -- ' closing tick for hsc2hs + type FieldOffset "sequencesIndexOffset" VkCmdProcessCommandsInfoNVX + = + #{offset VkCmdProcessCommandsInfoNVX, sequencesIndexOffset} + type FieldIsArray "sequencesIndexOffset" + VkCmdProcessCommandsInfoNVX + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkCmdProcessCommandsInfoNVX, sequencesIndexOffset} + +instance CanReadField "sequencesIndexOffset" + VkCmdProcessCommandsInfoNVX + where + {-# INLINE getField #-} + getField = vkSequencesIndexOffset + + {-# INLINE readField #-} + readField = readVkSequencesIndexOffset + +instance CanWriteField "sequencesIndexOffset" + VkCmdProcessCommandsInfoNVX + where + {-# INLINE writeField #-} + writeField = writeVkSequencesIndexOffset + +instance Show VkCmdProcessCommandsInfoNVX where + showsPrec d x + = showString "VkCmdProcessCommandsInfoNVX {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkObjectTable = " . + showsPrec d (vkObjectTable x) . + showString ", " . + showString "vkIndirectCommandsLayout = " . + showsPrec d (vkIndirectCommandsLayout x) . + showString ", " . + showString "vkIndirectCommandsTokenCount = " . + showsPrec d (vkIndirectCommandsTokenCount x) . + showString ", " . + showString "vkPIndirectCommandsTokens = " . + showsPrec d (vkPIndirectCommandsTokens x) . + showString ", " . + showString "vkMaxSequencesCount = " . + showsPrec d (vkMaxSequencesCount x) . + showString ", " . + showString "vkTargetCommandBuffer = " . + showsPrec d (vkTargetCommandBuffer x) . + showString ", " . + showString "vkSequencesCountBuffer = " + . + showsPrec d + (vkSequencesCountBuffer x) + . + showString ", " . + showString + "vkSequencesCountOffset = " + . + showsPrec d + (vkSequencesCountOffset x) + . + showString ", " . + showString + "vkSequencesIndexBuffer = " + . + showsPrec d + (vkSequencesIndexBuffer + x) + . + showString ", " . + showString + "vkSequencesIndexOffset = " + . + showsPrec d + (vkSequencesIndexOffset + x) + . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkCmdReserveSpaceForCommandsInfoNVX.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkCmdReserveSpaceForCommandsInfoNVX.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkCmdReserveSpaceForCommandsInfoNVX.hsc @@ -0,0 +1,388 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkCmdReserveSpaceForCommandsInfoNVX + (VkCmdReserveSpaceForCommandsInfoNVX(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Handles (VkIndirectCommandsLayoutNVX, + VkObjectTableNVX) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkCmdReserveSpaceForCommandsInfoNVX { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkObjectTableNVX objectTable; +-- > VkIndirectCommandsLayoutNVX indirectCommandsLayout; +-- > uint32_t maxSequencesCount; +-- > } VkCmdReserveSpaceForCommandsInfoNVX; +-- +-- +data VkCmdReserveSpaceForCommandsInfoNVX = VkCmdReserveSpaceForCommandsInfoNVX## Addr## + ByteArray## + +instance Eq VkCmdReserveSpaceForCommandsInfoNVX where + (VkCmdReserveSpaceForCommandsInfoNVX## a _) == + x@(VkCmdReserveSpaceForCommandsInfoNVX## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkCmdReserveSpaceForCommandsInfoNVX where + (VkCmdReserveSpaceForCommandsInfoNVX## a _) `compare` + x@(VkCmdReserveSpaceForCommandsInfoNVX## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkCmdReserveSpaceForCommandsInfoNVX where + sizeOf ~_ = #{size VkCmdReserveSpaceForCommandsInfoNVX} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkCmdReserveSpaceForCommandsInfoNVX} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkCmdReserveSpaceForCommandsInfoNVX + where + unsafeAddr (VkCmdReserveSpaceForCommandsInfoNVX## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkCmdReserveSpaceForCommandsInfoNVX## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkCmdReserveSpaceForCommandsInfoNVX## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkCmdReserveSpaceForCommandsInfoNVX where + type StructFields VkCmdReserveSpaceForCommandsInfoNVX = + '["sType", "pNext", "objectTable", "indirectCommandsLayout", -- ' closing tick for hsc2hs + "maxSequencesCount"] + type CUnionType VkCmdReserveSpaceForCommandsInfoNVX = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkCmdReserveSpaceForCommandsInfoNVX = 'False -- ' closing tick for hsc2hs + type StructExtends VkCmdReserveSpaceForCommandsInfoNVX = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkCmdReserveSpaceForCommandsInfoNVX where + type VkSTypeMType VkCmdReserveSpaceForCommandsInfoNVX = + VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkCmdReserveSpaceForCommandsInfoNVX, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkCmdReserveSpaceForCommandsInfoNVX, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkCmdReserveSpaceForCommandsInfoNVX, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkCmdReserveSpaceForCommandsInfoNVX, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkCmdReserveSpaceForCommandsInfoNVX where + type FieldType "sType" VkCmdReserveSpaceForCommandsInfoNVX = + VkStructureType + type FieldOptional "sType" VkCmdReserveSpaceForCommandsInfoNVX = + 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkCmdReserveSpaceForCommandsInfoNVX = + #{offset VkCmdReserveSpaceForCommandsInfoNVX, sType} + type FieldIsArray "sType" VkCmdReserveSpaceForCommandsInfoNVX = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkCmdReserveSpaceForCommandsInfoNVX, sType} + +instance CanReadField "sType" VkCmdReserveSpaceForCommandsInfoNVX + where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkCmdReserveSpaceForCommandsInfoNVX + where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkCmdReserveSpaceForCommandsInfoNVX where + type VkPNextMType VkCmdReserveSpaceForCommandsInfoNVX = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkCmdReserveSpaceForCommandsInfoNVX, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkCmdReserveSpaceForCommandsInfoNVX, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkCmdReserveSpaceForCommandsInfoNVX, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkCmdReserveSpaceForCommandsInfoNVX, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkCmdReserveSpaceForCommandsInfoNVX where + type FieldType "pNext" VkCmdReserveSpaceForCommandsInfoNVX = + Ptr Void + type FieldOptional "pNext" VkCmdReserveSpaceForCommandsInfoNVX = + 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkCmdReserveSpaceForCommandsInfoNVX = + #{offset VkCmdReserveSpaceForCommandsInfoNVX, pNext} + type FieldIsArray "pNext" VkCmdReserveSpaceForCommandsInfoNVX = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkCmdReserveSpaceForCommandsInfoNVX, pNext} + +instance CanReadField "pNext" VkCmdReserveSpaceForCommandsInfoNVX + where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkCmdReserveSpaceForCommandsInfoNVX + where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkObjectTable VkCmdReserveSpaceForCommandsInfoNVX where + type VkObjectTableMType VkCmdReserveSpaceForCommandsInfoNVX = + VkObjectTableNVX + + {-# NOINLINE vkObjectTable #-} + vkObjectTable x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkCmdReserveSpaceForCommandsInfoNVX, objectTable}) + + {-# INLINE vkObjectTableByteOffset #-} + vkObjectTableByteOffset ~_ + = #{offset VkCmdReserveSpaceForCommandsInfoNVX, objectTable} + + {-# INLINE readVkObjectTable #-} + readVkObjectTable p + = peekByteOff p #{offset VkCmdReserveSpaceForCommandsInfoNVX, objectTable} + + {-# INLINE writeVkObjectTable #-} + writeVkObjectTable p + = pokeByteOff p #{offset VkCmdReserveSpaceForCommandsInfoNVX, objectTable} + +instance {-# OVERLAPPING #-} + HasField "objectTable" VkCmdReserveSpaceForCommandsInfoNVX where + type FieldType "objectTable" VkCmdReserveSpaceForCommandsInfoNVX = + VkObjectTableNVX + type FieldOptional "objectTable" + VkCmdReserveSpaceForCommandsInfoNVX + = 'False -- ' closing tick for hsc2hs + type FieldOffset "objectTable" VkCmdReserveSpaceForCommandsInfoNVX + = + #{offset VkCmdReserveSpaceForCommandsInfoNVX, objectTable} + type FieldIsArray "objectTable" VkCmdReserveSpaceForCommandsInfoNVX + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkCmdReserveSpaceForCommandsInfoNVX, objectTable} + +instance CanReadField "objectTable" + VkCmdReserveSpaceForCommandsInfoNVX + where + {-# INLINE getField #-} + getField = vkObjectTable + + {-# INLINE readField #-} + readField = readVkObjectTable + +instance CanWriteField "objectTable" + VkCmdReserveSpaceForCommandsInfoNVX + where + {-# INLINE writeField #-} + writeField = writeVkObjectTable + +instance {-# OVERLAPPING #-} + HasVkIndirectCommandsLayout VkCmdReserveSpaceForCommandsInfoNVX + where + type VkIndirectCommandsLayoutMType + VkCmdReserveSpaceForCommandsInfoNVX + = VkIndirectCommandsLayoutNVX + + {-# NOINLINE vkIndirectCommandsLayout #-} + vkIndirectCommandsLayout x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkCmdReserveSpaceForCommandsInfoNVX, indirectCommandsLayout}) + + {-# INLINE vkIndirectCommandsLayoutByteOffset #-} + vkIndirectCommandsLayoutByteOffset ~_ + = #{offset VkCmdReserveSpaceForCommandsInfoNVX, indirectCommandsLayout} + + {-# INLINE readVkIndirectCommandsLayout #-} + readVkIndirectCommandsLayout p + = peekByteOff p #{offset VkCmdReserveSpaceForCommandsInfoNVX, indirectCommandsLayout} + + {-# INLINE writeVkIndirectCommandsLayout #-} + writeVkIndirectCommandsLayout p + = pokeByteOff p #{offset VkCmdReserveSpaceForCommandsInfoNVX, indirectCommandsLayout} + +instance {-# OVERLAPPING #-} + HasField "indirectCommandsLayout" + VkCmdReserveSpaceForCommandsInfoNVX + where + type FieldType "indirectCommandsLayout" + VkCmdReserveSpaceForCommandsInfoNVX + = VkIndirectCommandsLayoutNVX + type FieldOptional "indirectCommandsLayout" + VkCmdReserveSpaceForCommandsInfoNVX + = 'False -- ' closing tick for hsc2hs + type FieldOffset "indirectCommandsLayout" + VkCmdReserveSpaceForCommandsInfoNVX + = + #{offset VkCmdReserveSpaceForCommandsInfoNVX, indirectCommandsLayout} + type FieldIsArray "indirectCommandsLayout" + VkCmdReserveSpaceForCommandsInfoNVX + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkCmdReserveSpaceForCommandsInfoNVX, indirectCommandsLayout} + +instance CanReadField "indirectCommandsLayout" + VkCmdReserveSpaceForCommandsInfoNVX + where + {-# INLINE getField #-} + getField = vkIndirectCommandsLayout + + {-# INLINE readField #-} + readField = readVkIndirectCommandsLayout + +instance CanWriteField "indirectCommandsLayout" + VkCmdReserveSpaceForCommandsInfoNVX + where + {-# INLINE writeField #-} + writeField = writeVkIndirectCommandsLayout + +instance {-# OVERLAPPING #-} + HasVkMaxSequencesCount VkCmdReserveSpaceForCommandsInfoNVX where + type VkMaxSequencesCountMType VkCmdReserveSpaceForCommandsInfoNVX = + Word32 + + {-# NOINLINE vkMaxSequencesCount #-} + vkMaxSequencesCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkCmdReserveSpaceForCommandsInfoNVX, maxSequencesCount}) + + {-# INLINE vkMaxSequencesCountByteOffset #-} + vkMaxSequencesCountByteOffset ~_ + = #{offset VkCmdReserveSpaceForCommandsInfoNVX, maxSequencesCount} + + {-# INLINE readVkMaxSequencesCount #-} + readVkMaxSequencesCount p + = peekByteOff p #{offset VkCmdReserveSpaceForCommandsInfoNVX, maxSequencesCount} + + {-# INLINE writeVkMaxSequencesCount #-} + writeVkMaxSequencesCount p + = pokeByteOff p #{offset VkCmdReserveSpaceForCommandsInfoNVX, maxSequencesCount} + +instance {-# OVERLAPPING #-} + HasField "maxSequencesCount" VkCmdReserveSpaceForCommandsInfoNVX + where + type FieldType "maxSequencesCount" + VkCmdReserveSpaceForCommandsInfoNVX + = Word32 + type FieldOptional "maxSequencesCount" + VkCmdReserveSpaceForCommandsInfoNVX + = 'False -- ' closing tick for hsc2hs + type FieldOffset "maxSequencesCount" + VkCmdReserveSpaceForCommandsInfoNVX + = + #{offset VkCmdReserveSpaceForCommandsInfoNVX, maxSequencesCount} + type FieldIsArray "maxSequencesCount" + VkCmdReserveSpaceForCommandsInfoNVX + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkCmdReserveSpaceForCommandsInfoNVX, maxSequencesCount} + +instance CanReadField "maxSequencesCount" + VkCmdReserveSpaceForCommandsInfoNVX + where + {-# INLINE getField #-} + getField = vkMaxSequencesCount + + {-# INLINE readField #-} + readField = readVkMaxSequencesCount + +instance CanWriteField "maxSequencesCount" + VkCmdReserveSpaceForCommandsInfoNVX + where + {-# INLINE writeField #-} + writeField = writeVkMaxSequencesCount + +instance Show VkCmdReserveSpaceForCommandsInfoNVX where + showsPrec d x + = showString "VkCmdReserveSpaceForCommandsInfoNVX {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkObjectTable = " . + showsPrec d (vkObjectTable x) . + showString ", " . + showString "vkIndirectCommandsLayout = " . + showsPrec d (vkIndirectCommandsLayout x) . + showString ", " . + showString "vkMaxSequencesCount = " . + showsPrec d (vkMaxSequencesCount x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkCommandBufferAllocateInfo.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkCommandBufferAllocateInfo.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkCommandBufferAllocateInfo.hsc @@ -0,0 +1,347 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkCommandBufferAllocateInfo + (VkCommandBufferAllocateInfo(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkCommandBufferLevel (VkCommandBufferLevel) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Handles (VkCommandPool) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkCommandBufferAllocateInfo { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkCommandPool commandPool; +-- > VkCommandBufferLevel level; +-- > uint32_t commandBufferCount; +-- > } VkCommandBufferAllocateInfo; +-- +-- +data VkCommandBufferAllocateInfo = VkCommandBufferAllocateInfo## Addr## + ByteArray## + +instance Eq VkCommandBufferAllocateInfo where + (VkCommandBufferAllocateInfo## a _) == + x@(VkCommandBufferAllocateInfo## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkCommandBufferAllocateInfo where + (VkCommandBufferAllocateInfo## a _) `compare` + x@(VkCommandBufferAllocateInfo## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkCommandBufferAllocateInfo where + sizeOf ~_ = #{size VkCommandBufferAllocateInfo} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkCommandBufferAllocateInfo} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkCommandBufferAllocateInfo where + unsafeAddr (VkCommandBufferAllocateInfo## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkCommandBufferAllocateInfo## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkCommandBufferAllocateInfo## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkCommandBufferAllocateInfo where + type StructFields VkCommandBufferAllocateInfo = + '["sType", "pNext", "commandPool", "level", "commandBufferCount"] -- ' closing tick for hsc2hs + type CUnionType VkCommandBufferAllocateInfo = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkCommandBufferAllocateInfo = 'False -- ' closing tick for hsc2hs + type StructExtends VkCommandBufferAllocateInfo = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkSType VkCommandBufferAllocateInfo + where + type VkSTypeMType VkCommandBufferAllocateInfo = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkCommandBufferAllocateInfo, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkCommandBufferAllocateInfo, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkCommandBufferAllocateInfo, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkCommandBufferAllocateInfo, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkCommandBufferAllocateInfo where + type FieldType "sType" VkCommandBufferAllocateInfo = + VkStructureType + type FieldOptional "sType" VkCommandBufferAllocateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkCommandBufferAllocateInfo = + #{offset VkCommandBufferAllocateInfo, sType} + type FieldIsArray "sType" VkCommandBufferAllocateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkCommandBufferAllocateInfo, sType} + +instance CanReadField "sType" VkCommandBufferAllocateInfo where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkCommandBufferAllocateInfo where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} HasVkPNext VkCommandBufferAllocateInfo + where + type VkPNextMType VkCommandBufferAllocateInfo = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkCommandBufferAllocateInfo, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkCommandBufferAllocateInfo, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkCommandBufferAllocateInfo, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkCommandBufferAllocateInfo, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkCommandBufferAllocateInfo where + type FieldType "pNext" VkCommandBufferAllocateInfo = Ptr Void + type FieldOptional "pNext" VkCommandBufferAllocateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkCommandBufferAllocateInfo = + #{offset VkCommandBufferAllocateInfo, pNext} + type FieldIsArray "pNext" VkCommandBufferAllocateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkCommandBufferAllocateInfo, pNext} + +instance CanReadField "pNext" VkCommandBufferAllocateInfo where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkCommandBufferAllocateInfo where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkCommandPool VkCommandBufferAllocateInfo where + type VkCommandPoolMType VkCommandBufferAllocateInfo = VkCommandPool + + {-# NOINLINE vkCommandPool #-} + vkCommandPool x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkCommandBufferAllocateInfo, commandPool}) + + {-# INLINE vkCommandPoolByteOffset #-} + vkCommandPoolByteOffset ~_ + = #{offset VkCommandBufferAllocateInfo, commandPool} + + {-# INLINE readVkCommandPool #-} + readVkCommandPool p + = peekByteOff p #{offset VkCommandBufferAllocateInfo, commandPool} + + {-# INLINE writeVkCommandPool #-} + writeVkCommandPool p + = pokeByteOff p #{offset VkCommandBufferAllocateInfo, commandPool} + +instance {-# OVERLAPPING #-} + HasField "commandPool" VkCommandBufferAllocateInfo where + type FieldType "commandPool" VkCommandBufferAllocateInfo = + VkCommandPool + type FieldOptional "commandPool" VkCommandBufferAllocateInfo = + 'False -- ' closing tick for hsc2hs + type FieldOffset "commandPool" VkCommandBufferAllocateInfo = + #{offset VkCommandBufferAllocateInfo, commandPool} + type FieldIsArray "commandPool" VkCommandBufferAllocateInfo = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkCommandBufferAllocateInfo, commandPool} + +instance CanReadField "commandPool" VkCommandBufferAllocateInfo + where + {-# INLINE getField #-} + getField = vkCommandPool + + {-# INLINE readField #-} + readField = readVkCommandPool + +instance CanWriteField "commandPool" VkCommandBufferAllocateInfo + where + {-# INLINE writeField #-} + writeField = writeVkCommandPool + +instance {-# OVERLAPPING #-} HasVkLevel VkCommandBufferAllocateInfo + where + type VkLevelMType VkCommandBufferAllocateInfo = + VkCommandBufferLevel + + {-# NOINLINE vkLevel #-} + vkLevel x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkCommandBufferAllocateInfo, level}) + + {-# INLINE vkLevelByteOffset #-} + vkLevelByteOffset ~_ + = #{offset VkCommandBufferAllocateInfo, level} + + {-# INLINE readVkLevel #-} + readVkLevel p + = peekByteOff p #{offset VkCommandBufferAllocateInfo, level} + + {-# INLINE writeVkLevel #-} + writeVkLevel p + = pokeByteOff p #{offset VkCommandBufferAllocateInfo, level} + +instance {-# OVERLAPPING #-} + HasField "level" VkCommandBufferAllocateInfo where + type FieldType "level" VkCommandBufferAllocateInfo = + VkCommandBufferLevel + type FieldOptional "level" VkCommandBufferAllocateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "level" VkCommandBufferAllocateInfo = + #{offset VkCommandBufferAllocateInfo, level} + type FieldIsArray "level" VkCommandBufferAllocateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkCommandBufferAllocateInfo, level} + +instance CanReadField "level" VkCommandBufferAllocateInfo where + {-# INLINE getField #-} + getField = vkLevel + + {-# INLINE readField #-} + readField = readVkLevel + +instance CanWriteField "level" VkCommandBufferAllocateInfo where + {-# INLINE writeField #-} + writeField = writeVkLevel + +instance {-# OVERLAPPING #-} + HasVkCommandBufferCount VkCommandBufferAllocateInfo where + type VkCommandBufferCountMType VkCommandBufferAllocateInfo = Word32 + + {-# NOINLINE vkCommandBufferCount #-} + vkCommandBufferCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkCommandBufferAllocateInfo, commandBufferCount}) + + {-# INLINE vkCommandBufferCountByteOffset #-} + vkCommandBufferCountByteOffset ~_ + = #{offset VkCommandBufferAllocateInfo, commandBufferCount} + + {-# INLINE readVkCommandBufferCount #-} + readVkCommandBufferCount p + = peekByteOff p #{offset VkCommandBufferAllocateInfo, commandBufferCount} + + {-# INLINE writeVkCommandBufferCount #-} + writeVkCommandBufferCount p + = pokeByteOff p #{offset VkCommandBufferAllocateInfo, commandBufferCount} + +instance {-# OVERLAPPING #-} + HasField "commandBufferCount" VkCommandBufferAllocateInfo where + type FieldType "commandBufferCount" VkCommandBufferAllocateInfo = + Word32 + type FieldOptional "commandBufferCount" VkCommandBufferAllocateInfo + = 'False -- ' closing tick for hsc2hs + type FieldOffset "commandBufferCount" VkCommandBufferAllocateInfo = + #{offset VkCommandBufferAllocateInfo, commandBufferCount} + type FieldIsArray "commandBufferCount" VkCommandBufferAllocateInfo + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkCommandBufferAllocateInfo, commandBufferCount} + +instance CanReadField "commandBufferCount" + VkCommandBufferAllocateInfo + where + {-# INLINE getField #-} + getField = vkCommandBufferCount + + {-# INLINE readField #-} + readField = readVkCommandBufferCount + +instance CanWriteField "commandBufferCount" + VkCommandBufferAllocateInfo + where + {-# INLINE writeField #-} + writeField = writeVkCommandBufferCount + +instance Show VkCommandBufferAllocateInfo where + showsPrec d x + = showString "VkCommandBufferAllocateInfo {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkCommandPool = " . + showsPrec d (vkCommandPool x) . + showString ", " . + showString "vkLevel = " . + showsPrec d (vkLevel x) . + showString ", " . + showString "vkCommandBufferCount = " . + showsPrec d (vkCommandBufferCount x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkCommandBufferBeginInfo.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkCommandBufferBeginInfo.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkCommandBufferBeginInfo.hsc @@ -0,0 +1,284 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkCommandBufferBeginInfo + (VkCommandBufferBeginInfo(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkCommandBufferUsageFlags (VkCommandBufferUsageFlags) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Struct.VkCommandBufferInheritanceInfo (VkCommandBufferInheritanceInfo) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkCommandBufferBeginInfo { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkCommandBufferUsageFlags flags; +-- > const VkCommandBufferInheritanceInfo* pInheritanceInfo; +-- > } VkCommandBufferBeginInfo; +-- +-- +data VkCommandBufferBeginInfo = VkCommandBufferBeginInfo## Addr## + ByteArray## + +instance Eq VkCommandBufferBeginInfo where + (VkCommandBufferBeginInfo## a _) == + x@(VkCommandBufferBeginInfo## b _) = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkCommandBufferBeginInfo where + (VkCommandBufferBeginInfo## a _) `compare` + x@(VkCommandBufferBeginInfo## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkCommandBufferBeginInfo where + sizeOf ~_ = #{size VkCommandBufferBeginInfo} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkCommandBufferBeginInfo} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkCommandBufferBeginInfo where + unsafeAddr (VkCommandBufferBeginInfo## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkCommandBufferBeginInfo## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkCommandBufferBeginInfo## (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkCommandBufferBeginInfo where + type StructFields VkCommandBufferBeginInfo = + '["sType", "pNext", "flags", "pInheritanceInfo"] -- ' closing tick for hsc2hs + type CUnionType VkCommandBufferBeginInfo = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkCommandBufferBeginInfo = 'False -- ' closing tick for hsc2hs + type StructExtends VkCommandBufferBeginInfo = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkSType VkCommandBufferBeginInfo + where + type VkSTypeMType VkCommandBufferBeginInfo = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkCommandBufferBeginInfo, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkCommandBufferBeginInfo, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkCommandBufferBeginInfo, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkCommandBufferBeginInfo, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkCommandBufferBeginInfo where + type FieldType "sType" VkCommandBufferBeginInfo = VkStructureType + type FieldOptional "sType" VkCommandBufferBeginInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkCommandBufferBeginInfo = + #{offset VkCommandBufferBeginInfo, sType} + type FieldIsArray "sType" VkCommandBufferBeginInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkCommandBufferBeginInfo, sType} + +instance CanReadField "sType" VkCommandBufferBeginInfo where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkCommandBufferBeginInfo where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} HasVkPNext VkCommandBufferBeginInfo + where + type VkPNextMType VkCommandBufferBeginInfo = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkCommandBufferBeginInfo, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkCommandBufferBeginInfo, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkCommandBufferBeginInfo, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkCommandBufferBeginInfo, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkCommandBufferBeginInfo where + type FieldType "pNext" VkCommandBufferBeginInfo = Ptr Void + type FieldOptional "pNext" VkCommandBufferBeginInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkCommandBufferBeginInfo = + #{offset VkCommandBufferBeginInfo, pNext} + type FieldIsArray "pNext" VkCommandBufferBeginInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkCommandBufferBeginInfo, pNext} + +instance CanReadField "pNext" VkCommandBufferBeginInfo where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkCommandBufferBeginInfo where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} HasVkFlags VkCommandBufferBeginInfo + where + type VkFlagsMType VkCommandBufferBeginInfo = + VkCommandBufferUsageFlags + + {-# NOINLINE vkFlags #-} + vkFlags x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkCommandBufferBeginInfo, flags}) + + {-# INLINE vkFlagsByteOffset #-} + vkFlagsByteOffset ~_ + = #{offset VkCommandBufferBeginInfo, flags} + + {-# INLINE readVkFlags #-} + readVkFlags p + = peekByteOff p #{offset VkCommandBufferBeginInfo, flags} + + {-# INLINE writeVkFlags #-} + writeVkFlags p + = pokeByteOff p #{offset VkCommandBufferBeginInfo, flags} + +instance {-# OVERLAPPING #-} + HasField "flags" VkCommandBufferBeginInfo where + type FieldType "flags" VkCommandBufferBeginInfo = + VkCommandBufferUsageFlags + type FieldOptional "flags" VkCommandBufferBeginInfo = 'True -- ' closing tick for hsc2hs + type FieldOffset "flags" VkCommandBufferBeginInfo = + #{offset VkCommandBufferBeginInfo, flags} + type FieldIsArray "flags" VkCommandBufferBeginInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkCommandBufferBeginInfo, flags} + +instance CanReadField "flags" VkCommandBufferBeginInfo where + {-# INLINE getField #-} + getField = vkFlags + + {-# INLINE readField #-} + readField = readVkFlags + +instance CanWriteField "flags" VkCommandBufferBeginInfo where + {-# INLINE writeField #-} + writeField = writeVkFlags + +instance {-# OVERLAPPING #-} + HasVkPInheritanceInfo VkCommandBufferBeginInfo where + type VkPInheritanceInfoMType VkCommandBufferBeginInfo = + Ptr VkCommandBufferInheritanceInfo + + {-# NOINLINE vkPInheritanceInfo #-} + vkPInheritanceInfo x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkCommandBufferBeginInfo, pInheritanceInfo}) + + {-# INLINE vkPInheritanceInfoByteOffset #-} + vkPInheritanceInfoByteOffset ~_ + = #{offset VkCommandBufferBeginInfo, pInheritanceInfo} + + {-# INLINE readVkPInheritanceInfo #-} + readVkPInheritanceInfo p + = peekByteOff p #{offset VkCommandBufferBeginInfo, pInheritanceInfo} + + {-# INLINE writeVkPInheritanceInfo #-} + writeVkPInheritanceInfo p + = pokeByteOff p #{offset VkCommandBufferBeginInfo, pInheritanceInfo} + +instance {-# OVERLAPPING #-} + HasField "pInheritanceInfo" VkCommandBufferBeginInfo where + type FieldType "pInheritanceInfo" VkCommandBufferBeginInfo = + Ptr VkCommandBufferInheritanceInfo + type FieldOptional "pInheritanceInfo" VkCommandBufferBeginInfo = + 'True -- ' closing tick for hsc2hs + type FieldOffset "pInheritanceInfo" VkCommandBufferBeginInfo = + #{offset VkCommandBufferBeginInfo, pInheritanceInfo} + type FieldIsArray "pInheritanceInfo" VkCommandBufferBeginInfo = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkCommandBufferBeginInfo, pInheritanceInfo} + +instance CanReadField "pInheritanceInfo" VkCommandBufferBeginInfo + where + {-# INLINE getField #-} + getField = vkPInheritanceInfo + + {-# INLINE readField #-} + readField = readVkPInheritanceInfo + +instance CanWriteField "pInheritanceInfo" VkCommandBufferBeginInfo + where + {-# INLINE writeField #-} + writeField = writeVkPInheritanceInfo + +instance Show VkCommandBufferBeginInfo where + showsPrec d x + = showString "VkCommandBufferBeginInfo {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkFlags = " . + showsPrec d (vkFlags x) . + showString ", " . + showString "vkPInheritanceInfo = " . + showsPrec d (vkPInheritanceInfo x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkCommandBufferInheritanceInfo.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkCommandBufferInheritanceInfo.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkCommandBufferInheritanceInfo.hsc @@ -0,0 +1,539 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkCommandBufferInheritanceInfo + (VkCommandBufferInheritanceInfo(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.BaseTypes (VkBool32) +import Graphics.Vulkan.Types.Enum.VkQueryControlFlags (VkQueryControlFlags) +import Graphics.Vulkan.Types.Enum.VkQueryPipelineStatisticFlags (VkQueryPipelineStatisticFlags) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Handles (VkFramebuffer, + VkRenderPass) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkCommandBufferInheritanceInfo { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkRenderPass renderPass; +-- > uint32_t subpass; +-- > VkFramebuffer framebuffer; +-- > VkBool32 occlusionQueryEnable; +-- > VkQueryControlFlags queryFlags; +-- > VkQueryPipelineStatisticFlags pipelineStatistics; +-- > } VkCommandBufferInheritanceInfo; +-- +-- +data VkCommandBufferInheritanceInfo = VkCommandBufferInheritanceInfo## Addr## + ByteArray## + +instance Eq VkCommandBufferInheritanceInfo where + (VkCommandBufferInheritanceInfo## a _) == + x@(VkCommandBufferInheritanceInfo## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkCommandBufferInheritanceInfo where + (VkCommandBufferInheritanceInfo## a _) `compare` + x@(VkCommandBufferInheritanceInfo## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkCommandBufferInheritanceInfo where + sizeOf ~_ = #{size VkCommandBufferInheritanceInfo} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkCommandBufferInheritanceInfo} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkCommandBufferInheritanceInfo where + unsafeAddr (VkCommandBufferInheritanceInfo## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkCommandBufferInheritanceInfo## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkCommandBufferInheritanceInfo## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkCommandBufferInheritanceInfo where + type StructFields VkCommandBufferInheritanceInfo = + '["sType", "pNext", "renderPass", "subpass", "framebuffer", -- ' closing tick for hsc2hs + "occlusionQueryEnable", "queryFlags", "pipelineStatistics"] + type CUnionType VkCommandBufferInheritanceInfo = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkCommandBufferInheritanceInfo = 'False -- ' closing tick for hsc2hs + type StructExtends VkCommandBufferInheritanceInfo = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkCommandBufferInheritanceInfo where + type VkSTypeMType VkCommandBufferInheritanceInfo = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkCommandBufferInheritanceInfo, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkCommandBufferInheritanceInfo, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkCommandBufferInheritanceInfo, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkCommandBufferInheritanceInfo, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkCommandBufferInheritanceInfo where + type FieldType "sType" VkCommandBufferInheritanceInfo = + VkStructureType + type FieldOptional "sType" VkCommandBufferInheritanceInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkCommandBufferInheritanceInfo = + #{offset VkCommandBufferInheritanceInfo, sType} + type FieldIsArray "sType" VkCommandBufferInheritanceInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkCommandBufferInheritanceInfo, sType} + +instance CanReadField "sType" VkCommandBufferInheritanceInfo where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkCommandBufferInheritanceInfo where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkCommandBufferInheritanceInfo where + type VkPNextMType VkCommandBufferInheritanceInfo = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkCommandBufferInheritanceInfo, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkCommandBufferInheritanceInfo, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkCommandBufferInheritanceInfo, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkCommandBufferInheritanceInfo, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkCommandBufferInheritanceInfo where + type FieldType "pNext" VkCommandBufferInheritanceInfo = Ptr Void + type FieldOptional "pNext" VkCommandBufferInheritanceInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkCommandBufferInheritanceInfo = + #{offset VkCommandBufferInheritanceInfo, pNext} + type FieldIsArray "pNext" VkCommandBufferInheritanceInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkCommandBufferInheritanceInfo, pNext} + +instance CanReadField "pNext" VkCommandBufferInheritanceInfo where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkCommandBufferInheritanceInfo where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkRenderPass VkCommandBufferInheritanceInfo where + type VkRenderPassMType VkCommandBufferInheritanceInfo = + VkRenderPass + + {-# NOINLINE vkRenderPass #-} + vkRenderPass x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkCommandBufferInheritanceInfo, renderPass}) + + {-# INLINE vkRenderPassByteOffset #-} + vkRenderPassByteOffset ~_ + = #{offset VkCommandBufferInheritanceInfo, renderPass} + + {-# INLINE readVkRenderPass #-} + readVkRenderPass p + = peekByteOff p #{offset VkCommandBufferInheritanceInfo, renderPass} + + {-# INLINE writeVkRenderPass #-} + writeVkRenderPass p + = pokeByteOff p #{offset VkCommandBufferInheritanceInfo, renderPass} + +instance {-# OVERLAPPING #-} + HasField "renderPass" VkCommandBufferInheritanceInfo where + type FieldType "renderPass" VkCommandBufferInheritanceInfo = + VkRenderPass + type FieldOptional "renderPass" VkCommandBufferInheritanceInfo = + 'True -- ' closing tick for hsc2hs + type FieldOffset "renderPass" VkCommandBufferInheritanceInfo = + #{offset VkCommandBufferInheritanceInfo, renderPass} + type FieldIsArray "renderPass" VkCommandBufferInheritanceInfo = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkCommandBufferInheritanceInfo, renderPass} + +instance CanReadField "renderPass" VkCommandBufferInheritanceInfo + where + {-# INLINE getField #-} + getField = vkRenderPass + + {-# INLINE readField #-} + readField = readVkRenderPass + +instance CanWriteField "renderPass" VkCommandBufferInheritanceInfo + where + {-# INLINE writeField #-} + writeField = writeVkRenderPass + +instance {-# OVERLAPPING #-} + HasVkSubpass VkCommandBufferInheritanceInfo where + type VkSubpassMType VkCommandBufferInheritanceInfo = Word32 + + {-# NOINLINE vkSubpass #-} + vkSubpass x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkCommandBufferInheritanceInfo, subpass}) + + {-# INLINE vkSubpassByteOffset #-} + vkSubpassByteOffset ~_ + = #{offset VkCommandBufferInheritanceInfo, subpass} + + {-# INLINE readVkSubpass #-} + readVkSubpass p + = peekByteOff p #{offset VkCommandBufferInheritanceInfo, subpass} + + {-# INLINE writeVkSubpass #-} + writeVkSubpass p + = pokeByteOff p #{offset VkCommandBufferInheritanceInfo, subpass} + +instance {-# OVERLAPPING #-} + HasField "subpass" VkCommandBufferInheritanceInfo where + type FieldType "subpass" VkCommandBufferInheritanceInfo = Word32 + type FieldOptional "subpass" VkCommandBufferInheritanceInfo = + 'False -- ' closing tick for hsc2hs + type FieldOffset "subpass" VkCommandBufferInheritanceInfo = + #{offset VkCommandBufferInheritanceInfo, subpass} + type FieldIsArray "subpass" VkCommandBufferInheritanceInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkCommandBufferInheritanceInfo, subpass} + +instance CanReadField "subpass" VkCommandBufferInheritanceInfo + where + {-# INLINE getField #-} + getField = vkSubpass + + {-# INLINE readField #-} + readField = readVkSubpass + +instance CanWriteField "subpass" VkCommandBufferInheritanceInfo + where + {-# INLINE writeField #-} + writeField = writeVkSubpass + +instance {-# OVERLAPPING #-} + HasVkFramebuffer VkCommandBufferInheritanceInfo where + type VkFramebufferMType VkCommandBufferInheritanceInfo = + VkFramebuffer + + {-# NOINLINE vkFramebuffer #-} + vkFramebuffer x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkCommandBufferInheritanceInfo, framebuffer}) + + {-# INLINE vkFramebufferByteOffset #-} + vkFramebufferByteOffset ~_ + = #{offset VkCommandBufferInheritanceInfo, framebuffer} + + {-# INLINE readVkFramebuffer #-} + readVkFramebuffer p + = peekByteOff p #{offset VkCommandBufferInheritanceInfo, framebuffer} + + {-# INLINE writeVkFramebuffer #-} + writeVkFramebuffer p + = pokeByteOff p #{offset VkCommandBufferInheritanceInfo, framebuffer} + +instance {-# OVERLAPPING #-} + HasField "framebuffer" VkCommandBufferInheritanceInfo where + type FieldType "framebuffer" VkCommandBufferInheritanceInfo = + VkFramebuffer + type FieldOptional "framebuffer" VkCommandBufferInheritanceInfo = + 'True -- ' closing tick for hsc2hs + type FieldOffset "framebuffer" VkCommandBufferInheritanceInfo = + #{offset VkCommandBufferInheritanceInfo, framebuffer} + type FieldIsArray "framebuffer" VkCommandBufferInheritanceInfo = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkCommandBufferInheritanceInfo, framebuffer} + +instance CanReadField "framebuffer" VkCommandBufferInheritanceInfo + where + {-# INLINE getField #-} + getField = vkFramebuffer + + {-# INLINE readField #-} + readField = readVkFramebuffer + +instance CanWriteField "framebuffer" VkCommandBufferInheritanceInfo + where + {-# INLINE writeField #-} + writeField = writeVkFramebuffer + +instance {-# OVERLAPPING #-} + HasVkOcclusionQueryEnable VkCommandBufferInheritanceInfo where + type VkOcclusionQueryEnableMType VkCommandBufferInheritanceInfo = + VkBool32 + + {-# NOINLINE vkOcclusionQueryEnable #-} + vkOcclusionQueryEnable x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkCommandBufferInheritanceInfo, occlusionQueryEnable}) + + {-# INLINE vkOcclusionQueryEnableByteOffset #-} + vkOcclusionQueryEnableByteOffset ~_ + = #{offset VkCommandBufferInheritanceInfo, occlusionQueryEnable} + + {-# INLINE readVkOcclusionQueryEnable #-} + readVkOcclusionQueryEnable p + = peekByteOff p #{offset VkCommandBufferInheritanceInfo, occlusionQueryEnable} + + {-# INLINE writeVkOcclusionQueryEnable #-} + writeVkOcclusionQueryEnable p + = pokeByteOff p #{offset VkCommandBufferInheritanceInfo, occlusionQueryEnable} + +instance {-# OVERLAPPING #-} + HasField "occlusionQueryEnable" VkCommandBufferInheritanceInfo + where + type FieldType "occlusionQueryEnable" + VkCommandBufferInheritanceInfo + = VkBool32 + type FieldOptional "occlusionQueryEnable" + VkCommandBufferInheritanceInfo + = 'False -- ' closing tick for hsc2hs + type FieldOffset "occlusionQueryEnable" + VkCommandBufferInheritanceInfo + = + #{offset VkCommandBufferInheritanceInfo, occlusionQueryEnable} + type FieldIsArray "occlusionQueryEnable" + VkCommandBufferInheritanceInfo + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkCommandBufferInheritanceInfo, occlusionQueryEnable} + +instance CanReadField "occlusionQueryEnable" + VkCommandBufferInheritanceInfo + where + {-# INLINE getField #-} + getField = vkOcclusionQueryEnable + + {-# INLINE readField #-} + readField = readVkOcclusionQueryEnable + +instance CanWriteField "occlusionQueryEnable" + VkCommandBufferInheritanceInfo + where + {-# INLINE writeField #-} + writeField = writeVkOcclusionQueryEnable + +instance {-# OVERLAPPING #-} + HasVkQueryFlags VkCommandBufferInheritanceInfo where + type VkQueryFlagsMType VkCommandBufferInheritanceInfo = + VkQueryControlFlags + + {-# NOINLINE vkQueryFlags #-} + vkQueryFlags x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkCommandBufferInheritanceInfo, queryFlags}) + + {-# INLINE vkQueryFlagsByteOffset #-} + vkQueryFlagsByteOffset ~_ + = #{offset VkCommandBufferInheritanceInfo, queryFlags} + + {-# INLINE readVkQueryFlags #-} + readVkQueryFlags p + = peekByteOff p #{offset VkCommandBufferInheritanceInfo, queryFlags} + + {-# INLINE writeVkQueryFlags #-} + writeVkQueryFlags p + = pokeByteOff p #{offset VkCommandBufferInheritanceInfo, queryFlags} + +instance {-# OVERLAPPING #-} + HasField "queryFlags" VkCommandBufferInheritanceInfo where + type FieldType "queryFlags" VkCommandBufferInheritanceInfo = + VkQueryControlFlags + type FieldOptional "queryFlags" VkCommandBufferInheritanceInfo = + 'True -- ' closing tick for hsc2hs + type FieldOffset "queryFlags" VkCommandBufferInheritanceInfo = + #{offset VkCommandBufferInheritanceInfo, queryFlags} + type FieldIsArray "queryFlags" VkCommandBufferInheritanceInfo = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkCommandBufferInheritanceInfo, queryFlags} + +instance CanReadField "queryFlags" VkCommandBufferInheritanceInfo + where + {-# INLINE getField #-} + getField = vkQueryFlags + + {-# INLINE readField #-} + readField = readVkQueryFlags + +instance CanWriteField "queryFlags" VkCommandBufferInheritanceInfo + where + {-# INLINE writeField #-} + writeField = writeVkQueryFlags + +instance {-# OVERLAPPING #-} + HasVkPipelineStatistics VkCommandBufferInheritanceInfo where + type VkPipelineStatisticsMType VkCommandBufferInheritanceInfo = + VkQueryPipelineStatisticFlags + + {-# NOINLINE vkPipelineStatistics #-} + vkPipelineStatistics x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkCommandBufferInheritanceInfo, pipelineStatistics}) + + {-# INLINE vkPipelineStatisticsByteOffset #-} + vkPipelineStatisticsByteOffset ~_ + = #{offset VkCommandBufferInheritanceInfo, pipelineStatistics} + + {-# INLINE readVkPipelineStatistics #-} + readVkPipelineStatistics p + = peekByteOff p #{offset VkCommandBufferInheritanceInfo, pipelineStatistics} + + {-# INLINE writeVkPipelineStatistics #-} + writeVkPipelineStatistics p + = pokeByteOff p #{offset VkCommandBufferInheritanceInfo, pipelineStatistics} + +instance {-# OVERLAPPING #-} + HasField "pipelineStatistics" VkCommandBufferInheritanceInfo where + type FieldType "pipelineStatistics" VkCommandBufferInheritanceInfo + = VkQueryPipelineStatisticFlags + type FieldOptional "pipelineStatistics" + VkCommandBufferInheritanceInfo + = 'True -- ' closing tick for hsc2hs + type FieldOffset "pipelineStatistics" + VkCommandBufferInheritanceInfo + = + #{offset VkCommandBufferInheritanceInfo, pipelineStatistics} + type FieldIsArray "pipelineStatistics" + VkCommandBufferInheritanceInfo + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkCommandBufferInheritanceInfo, pipelineStatistics} + +instance CanReadField "pipelineStatistics" + VkCommandBufferInheritanceInfo + where + {-# INLINE getField #-} + getField = vkPipelineStatistics + + {-# INLINE readField #-} + readField = readVkPipelineStatistics + +instance CanWriteField "pipelineStatistics" + VkCommandBufferInheritanceInfo + where + {-# INLINE writeField #-} + writeField = writeVkPipelineStatistics + +instance Show VkCommandBufferInheritanceInfo where + showsPrec d x + = showString "VkCommandBufferInheritanceInfo {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkRenderPass = " . + showsPrec d (vkRenderPass x) . + showString ", " . + showString "vkSubpass = " . + showsPrec d (vkSubpass x) . + showString ", " . + showString "vkFramebuffer = " . + showsPrec d (vkFramebuffer x) . + showString ", " . + showString "vkOcclusionQueryEnable = " . + showsPrec d (vkOcclusionQueryEnable x) . + showString ", " . + showString "vkQueryFlags = " . + showsPrec d (vkQueryFlags x) . + showString ", " . + showString "vkPipelineStatistics = " . + showsPrec d (vkPipelineStatistics x) . + showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkCommandPoolCreateInfo.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkCommandPoolCreateInfo.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkCommandPoolCreateInfo.hsc @@ -0,0 +1,280 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkCommandPoolCreateInfo + (VkCommandPoolCreateInfo(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkCommandPoolCreateFlags (VkCommandPoolCreateFlags) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkCommandPoolCreateInfo { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkCommandPoolCreateFlags flags; +-- > uint32_t queueFamilyIndex; +-- > } VkCommandPoolCreateInfo; +-- +-- +data VkCommandPoolCreateInfo = VkCommandPoolCreateInfo## Addr## + ByteArray## + +instance Eq VkCommandPoolCreateInfo where + (VkCommandPoolCreateInfo## a _) == x@(VkCommandPoolCreateInfo## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkCommandPoolCreateInfo where + (VkCommandPoolCreateInfo## a _) `compare` + x@(VkCommandPoolCreateInfo## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkCommandPoolCreateInfo where + sizeOf ~_ = #{size VkCommandPoolCreateInfo} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkCommandPoolCreateInfo} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkCommandPoolCreateInfo where + unsafeAddr (VkCommandPoolCreateInfo## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkCommandPoolCreateInfo## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkCommandPoolCreateInfo## (plusAddr## (byteArrayContents## b) off) b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkCommandPoolCreateInfo where + type StructFields VkCommandPoolCreateInfo = + '["sType", "pNext", "flags", "queueFamilyIndex"] -- ' closing tick for hsc2hs + type CUnionType VkCommandPoolCreateInfo = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkCommandPoolCreateInfo = 'False -- ' closing tick for hsc2hs + type StructExtends VkCommandPoolCreateInfo = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkSType VkCommandPoolCreateInfo + where + type VkSTypeMType VkCommandPoolCreateInfo = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkCommandPoolCreateInfo, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkCommandPoolCreateInfo, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkCommandPoolCreateInfo, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkCommandPoolCreateInfo, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkCommandPoolCreateInfo where + type FieldType "sType" VkCommandPoolCreateInfo = VkStructureType + type FieldOptional "sType" VkCommandPoolCreateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkCommandPoolCreateInfo = + #{offset VkCommandPoolCreateInfo, sType} + type FieldIsArray "sType" VkCommandPoolCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkCommandPoolCreateInfo, sType} + +instance CanReadField "sType" VkCommandPoolCreateInfo where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkCommandPoolCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} HasVkPNext VkCommandPoolCreateInfo + where + type VkPNextMType VkCommandPoolCreateInfo = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkCommandPoolCreateInfo, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkCommandPoolCreateInfo, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkCommandPoolCreateInfo, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkCommandPoolCreateInfo, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkCommandPoolCreateInfo where + type FieldType "pNext" VkCommandPoolCreateInfo = Ptr Void + type FieldOptional "pNext" VkCommandPoolCreateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkCommandPoolCreateInfo = + #{offset VkCommandPoolCreateInfo, pNext} + type FieldIsArray "pNext" VkCommandPoolCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkCommandPoolCreateInfo, pNext} + +instance CanReadField "pNext" VkCommandPoolCreateInfo where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkCommandPoolCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} HasVkFlags VkCommandPoolCreateInfo + where + type VkFlagsMType VkCommandPoolCreateInfo = + VkCommandPoolCreateFlags + + {-# NOINLINE vkFlags #-} + vkFlags x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkCommandPoolCreateInfo, flags}) + + {-# INLINE vkFlagsByteOffset #-} + vkFlagsByteOffset ~_ + = #{offset VkCommandPoolCreateInfo, flags} + + {-# INLINE readVkFlags #-} + readVkFlags p + = peekByteOff p #{offset VkCommandPoolCreateInfo, flags} + + {-# INLINE writeVkFlags #-} + writeVkFlags p + = pokeByteOff p #{offset VkCommandPoolCreateInfo, flags} + +instance {-# OVERLAPPING #-} + HasField "flags" VkCommandPoolCreateInfo where + type FieldType "flags" VkCommandPoolCreateInfo = + VkCommandPoolCreateFlags + type FieldOptional "flags" VkCommandPoolCreateInfo = 'True -- ' closing tick for hsc2hs + type FieldOffset "flags" VkCommandPoolCreateInfo = + #{offset VkCommandPoolCreateInfo, flags} + type FieldIsArray "flags" VkCommandPoolCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkCommandPoolCreateInfo, flags} + +instance CanReadField "flags" VkCommandPoolCreateInfo where + {-# INLINE getField #-} + getField = vkFlags + + {-# INLINE readField #-} + readField = readVkFlags + +instance CanWriteField "flags" VkCommandPoolCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkFlags + +instance {-# OVERLAPPING #-} + HasVkQueueFamilyIndex VkCommandPoolCreateInfo where + type VkQueueFamilyIndexMType VkCommandPoolCreateInfo = Word32 + + {-# NOINLINE vkQueueFamilyIndex #-} + vkQueueFamilyIndex x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkCommandPoolCreateInfo, queueFamilyIndex}) + + {-# INLINE vkQueueFamilyIndexByteOffset #-} + vkQueueFamilyIndexByteOffset ~_ + = #{offset VkCommandPoolCreateInfo, queueFamilyIndex} + + {-# INLINE readVkQueueFamilyIndex #-} + readVkQueueFamilyIndex p + = peekByteOff p #{offset VkCommandPoolCreateInfo, queueFamilyIndex} + + {-# INLINE writeVkQueueFamilyIndex #-} + writeVkQueueFamilyIndex p + = pokeByteOff p #{offset VkCommandPoolCreateInfo, queueFamilyIndex} + +instance {-# OVERLAPPING #-} + HasField "queueFamilyIndex" VkCommandPoolCreateInfo where + type FieldType "queueFamilyIndex" VkCommandPoolCreateInfo = Word32 + type FieldOptional "queueFamilyIndex" VkCommandPoolCreateInfo = + 'False -- ' closing tick for hsc2hs + type FieldOffset "queueFamilyIndex" VkCommandPoolCreateInfo = + #{offset VkCommandPoolCreateInfo, queueFamilyIndex} + type FieldIsArray "queueFamilyIndex" VkCommandPoolCreateInfo = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkCommandPoolCreateInfo, queueFamilyIndex} + +instance CanReadField "queueFamilyIndex" VkCommandPoolCreateInfo + where + {-# INLINE getField #-} + getField = vkQueueFamilyIndex + + {-# INLINE readField #-} + readField = readVkQueueFamilyIndex + +instance CanWriteField "queueFamilyIndex" VkCommandPoolCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkQueueFamilyIndex + +instance Show VkCommandPoolCreateInfo where + showsPrec d x + = showString "VkCommandPoolCreateInfo {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkFlags = " . + showsPrec d (vkFlags x) . + showString ", " . + showString "vkQueueFamilyIndex = " . + showsPrec d (vkQueueFamilyIndex x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkComponentMapping.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkComponentMapping.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkComponentMapping.hsc @@ -0,0 +1,257 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkComponentMapping + (VkComponentMapping(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkComponentSwizzle (VkComponentSwizzle) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkComponentMapping { +-- > VkComponentSwizzle r; +-- > VkComponentSwizzle g; +-- > VkComponentSwizzle b; +-- > VkComponentSwizzle a; +-- > } VkComponentMapping; +-- +-- +data VkComponentMapping = VkComponentMapping## Addr## ByteArray## + +instance Eq VkComponentMapping where + (VkComponentMapping## a _) == x@(VkComponentMapping## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkComponentMapping where + (VkComponentMapping## a _) `compare` x@(VkComponentMapping## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkComponentMapping where + sizeOf ~_ = #{size VkComponentMapping} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkComponentMapping} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkComponentMapping where + unsafeAddr (VkComponentMapping## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkComponentMapping## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkComponentMapping## (plusAddr## (byteArrayContents## b) off) b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkComponentMapping where + type StructFields VkComponentMapping = '["r", "g", "b", "a"] -- ' closing tick for hsc2hs + type CUnionType VkComponentMapping = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkComponentMapping = 'False -- ' closing tick for hsc2hs + type StructExtends VkComponentMapping = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkR VkComponentMapping where + type VkRMType VkComponentMapping = VkComponentSwizzle + + {-# NOINLINE vkR #-} + vkR x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkComponentMapping, r}) + + {-# INLINE vkRByteOffset #-} + vkRByteOffset ~_ = #{offset VkComponentMapping, r} + + {-# INLINE readVkR #-} + readVkR p + = peekByteOff p #{offset VkComponentMapping, r} + + {-# INLINE writeVkR #-} + writeVkR p + = pokeByteOff p #{offset VkComponentMapping, r} + +instance {-# OVERLAPPING #-} HasField "r" VkComponentMapping where + type FieldType "r" VkComponentMapping = VkComponentSwizzle + type FieldOptional "r" VkComponentMapping = 'False -- ' closing tick for hsc2hs + type FieldOffset "r" VkComponentMapping = + #{offset VkComponentMapping, r} + type FieldIsArray "r" VkComponentMapping = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkComponentMapping, r} + +instance CanReadField "r" VkComponentMapping where + {-# INLINE getField #-} + getField = vkR + + {-# INLINE readField #-} + readField = readVkR + +instance CanWriteField "r" VkComponentMapping where + {-# INLINE writeField #-} + writeField = writeVkR + +instance {-# OVERLAPPING #-} HasVkG VkComponentMapping where + type VkGMType VkComponentMapping = VkComponentSwizzle + + {-# NOINLINE vkG #-} + vkG x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkComponentMapping, g}) + + {-# INLINE vkGByteOffset #-} + vkGByteOffset ~_ = #{offset VkComponentMapping, g} + + {-# INLINE readVkG #-} + readVkG p + = peekByteOff p #{offset VkComponentMapping, g} + + {-# INLINE writeVkG #-} + writeVkG p + = pokeByteOff p #{offset VkComponentMapping, g} + +instance {-# OVERLAPPING #-} HasField "g" VkComponentMapping where + type FieldType "g" VkComponentMapping = VkComponentSwizzle + type FieldOptional "g" VkComponentMapping = 'False -- ' closing tick for hsc2hs + type FieldOffset "g" VkComponentMapping = + #{offset VkComponentMapping, g} + type FieldIsArray "g" VkComponentMapping = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkComponentMapping, g} + +instance CanReadField "g" VkComponentMapping where + {-# INLINE getField #-} + getField = vkG + + {-# INLINE readField #-} + readField = readVkG + +instance CanWriteField "g" VkComponentMapping where + {-# INLINE writeField #-} + writeField = writeVkG + +instance {-# OVERLAPPING #-} HasVkB VkComponentMapping where + type VkBMType VkComponentMapping = VkComponentSwizzle + + {-# NOINLINE vkB #-} + vkB x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkComponentMapping, b}) + + {-# INLINE vkBByteOffset #-} + vkBByteOffset ~_ = #{offset VkComponentMapping, b} + + {-# INLINE readVkB #-} + readVkB p + = peekByteOff p #{offset VkComponentMapping, b} + + {-# INLINE writeVkB #-} + writeVkB p + = pokeByteOff p #{offset VkComponentMapping, b} + +instance {-# OVERLAPPING #-} HasField "b" VkComponentMapping where + type FieldType "b" VkComponentMapping = VkComponentSwizzle + type FieldOptional "b" VkComponentMapping = 'False -- ' closing tick for hsc2hs + type FieldOffset "b" VkComponentMapping = + #{offset VkComponentMapping, b} + type FieldIsArray "b" VkComponentMapping = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkComponentMapping, b} + +instance CanReadField "b" VkComponentMapping where + {-# INLINE getField #-} + getField = vkB + + {-# INLINE readField #-} + readField = readVkB + +instance CanWriteField "b" VkComponentMapping where + {-# INLINE writeField #-} + writeField = writeVkB + +instance {-# OVERLAPPING #-} HasVkA VkComponentMapping where + type VkAMType VkComponentMapping = VkComponentSwizzle + + {-# NOINLINE vkA #-} + vkA x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkComponentMapping, a}) + + {-# INLINE vkAByteOffset #-} + vkAByteOffset ~_ = #{offset VkComponentMapping, a} + + {-# INLINE readVkA #-} + readVkA p + = peekByteOff p #{offset VkComponentMapping, a} + + {-# INLINE writeVkA #-} + writeVkA p + = pokeByteOff p #{offset VkComponentMapping, a} + +instance {-# OVERLAPPING #-} HasField "a" VkComponentMapping where + type FieldType "a" VkComponentMapping = VkComponentSwizzle + type FieldOptional "a" VkComponentMapping = 'False -- ' closing tick for hsc2hs + type FieldOffset "a" VkComponentMapping = + #{offset VkComponentMapping, a} + type FieldIsArray "a" VkComponentMapping = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkComponentMapping, a} + +instance CanReadField "a" VkComponentMapping where + {-# INLINE getField #-} + getField = vkA + + {-# INLINE readField #-} + readField = readVkA + +instance CanWriteField "a" VkComponentMapping where + {-# INLINE writeField #-} + writeField = writeVkA + +instance Show VkComponentMapping where + showsPrec d x + = showString "VkComponentMapping {" . + showString "vkR = " . + showsPrec d (vkR x) . + showString ", " . + showString "vkG = " . + showsPrec d (vkG x) . + showString ", " . + showString "vkB = " . + showsPrec d (vkB x) . + showString ", " . + showString "vkA = " . showsPrec d (vkA x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkComputePipelineCreateInfo.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkComputePipelineCreateInfo.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkComputePipelineCreateInfo.hsc @@ -0,0 +1,459 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkComputePipelineCreateInfo + (VkComputePipelineCreateInfo(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkPipelineCreateFlags (VkPipelineCreateFlags) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Handles (VkPipeline, + VkPipelineLayout) +import Graphics.Vulkan.Types.Struct.VkPipelineShaderStageCreateInfo (VkPipelineShaderStageCreateInfo) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkComputePipelineCreateInfo { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkPipelineCreateFlags flags; +-- > VkPipelineShaderStageCreateInfo stage; +-- > VkPipelineLayout layout; +-- > VkPipeline basePipelineHandle; +-- > int32_t basePipelineIndex; +-- > } VkComputePipelineCreateInfo; +-- +-- +data VkComputePipelineCreateInfo = VkComputePipelineCreateInfo## Addr## + ByteArray## + +instance Eq VkComputePipelineCreateInfo where + (VkComputePipelineCreateInfo## a _) == + x@(VkComputePipelineCreateInfo## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkComputePipelineCreateInfo where + (VkComputePipelineCreateInfo## a _) `compare` + x@(VkComputePipelineCreateInfo## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkComputePipelineCreateInfo where + sizeOf ~_ = #{size VkComputePipelineCreateInfo} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkComputePipelineCreateInfo} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkComputePipelineCreateInfo where + unsafeAddr (VkComputePipelineCreateInfo## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkComputePipelineCreateInfo## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkComputePipelineCreateInfo## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkComputePipelineCreateInfo where + type StructFields VkComputePipelineCreateInfo = + '["sType", "pNext", "flags", "stage", "layout", -- ' closing tick for hsc2hs + "basePipelineHandle", "basePipelineIndex"] + type CUnionType VkComputePipelineCreateInfo = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkComputePipelineCreateInfo = 'False -- ' closing tick for hsc2hs + type StructExtends VkComputePipelineCreateInfo = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkSType VkComputePipelineCreateInfo + where + type VkSTypeMType VkComputePipelineCreateInfo = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkComputePipelineCreateInfo, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkComputePipelineCreateInfo, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkComputePipelineCreateInfo, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkComputePipelineCreateInfo, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkComputePipelineCreateInfo where + type FieldType "sType" VkComputePipelineCreateInfo = + VkStructureType + type FieldOptional "sType" VkComputePipelineCreateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkComputePipelineCreateInfo = + #{offset VkComputePipelineCreateInfo, sType} + type FieldIsArray "sType" VkComputePipelineCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkComputePipelineCreateInfo, sType} + +instance CanReadField "sType" VkComputePipelineCreateInfo where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkComputePipelineCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} HasVkPNext VkComputePipelineCreateInfo + where + type VkPNextMType VkComputePipelineCreateInfo = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkComputePipelineCreateInfo, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkComputePipelineCreateInfo, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkComputePipelineCreateInfo, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkComputePipelineCreateInfo, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkComputePipelineCreateInfo where + type FieldType "pNext" VkComputePipelineCreateInfo = Ptr Void + type FieldOptional "pNext" VkComputePipelineCreateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkComputePipelineCreateInfo = + #{offset VkComputePipelineCreateInfo, pNext} + type FieldIsArray "pNext" VkComputePipelineCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkComputePipelineCreateInfo, pNext} + +instance CanReadField "pNext" VkComputePipelineCreateInfo where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkComputePipelineCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} HasVkFlags VkComputePipelineCreateInfo + where + type VkFlagsMType VkComputePipelineCreateInfo = + VkPipelineCreateFlags + + {-# NOINLINE vkFlags #-} + vkFlags x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkComputePipelineCreateInfo, flags}) + + {-# INLINE vkFlagsByteOffset #-} + vkFlagsByteOffset ~_ + = #{offset VkComputePipelineCreateInfo, flags} + + {-# INLINE readVkFlags #-} + readVkFlags p + = peekByteOff p #{offset VkComputePipelineCreateInfo, flags} + + {-# INLINE writeVkFlags #-} + writeVkFlags p + = pokeByteOff p #{offset VkComputePipelineCreateInfo, flags} + +instance {-# OVERLAPPING #-} + HasField "flags" VkComputePipelineCreateInfo where + type FieldType "flags" VkComputePipelineCreateInfo = + VkPipelineCreateFlags + type FieldOptional "flags" VkComputePipelineCreateInfo = 'True -- ' closing tick for hsc2hs + type FieldOffset "flags" VkComputePipelineCreateInfo = + #{offset VkComputePipelineCreateInfo, flags} + type FieldIsArray "flags" VkComputePipelineCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkComputePipelineCreateInfo, flags} + +instance CanReadField "flags" VkComputePipelineCreateInfo where + {-# INLINE getField #-} + getField = vkFlags + + {-# INLINE readField #-} + readField = readVkFlags + +instance CanWriteField "flags" VkComputePipelineCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkFlags + +instance {-# OVERLAPPING #-} HasVkStage VkComputePipelineCreateInfo + where + type VkStageMType VkComputePipelineCreateInfo = + VkPipelineShaderStageCreateInfo + + {-# NOINLINE vkStage #-} + vkStage x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkComputePipelineCreateInfo, stage}) + + {-# INLINE vkStageByteOffset #-} + vkStageByteOffset ~_ + = #{offset VkComputePipelineCreateInfo, stage} + + {-# INLINE readVkStage #-} + readVkStage p + = peekByteOff p #{offset VkComputePipelineCreateInfo, stage} + + {-# INLINE writeVkStage #-} + writeVkStage p + = pokeByteOff p #{offset VkComputePipelineCreateInfo, stage} + +instance {-# OVERLAPPING #-} + HasField "stage" VkComputePipelineCreateInfo where + type FieldType "stage" VkComputePipelineCreateInfo = + VkPipelineShaderStageCreateInfo + type FieldOptional "stage" VkComputePipelineCreateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "stage" VkComputePipelineCreateInfo = + #{offset VkComputePipelineCreateInfo, stage} + type FieldIsArray "stage" VkComputePipelineCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkComputePipelineCreateInfo, stage} + +instance CanReadField "stage" VkComputePipelineCreateInfo where + {-# INLINE getField #-} + getField = vkStage + + {-# INLINE readField #-} + readField = readVkStage + +instance CanWriteField "stage" VkComputePipelineCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkStage + +instance {-# OVERLAPPING #-} + HasVkLayout VkComputePipelineCreateInfo where + type VkLayoutMType VkComputePipelineCreateInfo = VkPipelineLayout + + {-# NOINLINE vkLayout #-} + vkLayout x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkComputePipelineCreateInfo, layout}) + + {-# INLINE vkLayoutByteOffset #-} + vkLayoutByteOffset ~_ + = #{offset VkComputePipelineCreateInfo, layout} + + {-# INLINE readVkLayout #-} + readVkLayout p + = peekByteOff p #{offset VkComputePipelineCreateInfo, layout} + + {-# INLINE writeVkLayout #-} + writeVkLayout p + = pokeByteOff p #{offset VkComputePipelineCreateInfo, layout} + +instance {-# OVERLAPPING #-} + HasField "layout" VkComputePipelineCreateInfo where + type FieldType "layout" VkComputePipelineCreateInfo = + VkPipelineLayout + type FieldOptional "layout" VkComputePipelineCreateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "layout" VkComputePipelineCreateInfo = + #{offset VkComputePipelineCreateInfo, layout} + type FieldIsArray "layout" VkComputePipelineCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkComputePipelineCreateInfo, layout} + +instance CanReadField "layout" VkComputePipelineCreateInfo where + {-# INLINE getField #-} + getField = vkLayout + + {-# INLINE readField #-} + readField = readVkLayout + +instance CanWriteField "layout" VkComputePipelineCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkLayout + +instance {-# OVERLAPPING #-} + HasVkBasePipelineHandle VkComputePipelineCreateInfo where + type VkBasePipelineHandleMType VkComputePipelineCreateInfo = + VkPipeline + + {-# NOINLINE vkBasePipelineHandle #-} + vkBasePipelineHandle x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkComputePipelineCreateInfo, basePipelineHandle}) + + {-# INLINE vkBasePipelineHandleByteOffset #-} + vkBasePipelineHandleByteOffset ~_ + = #{offset VkComputePipelineCreateInfo, basePipelineHandle} + + {-# INLINE readVkBasePipelineHandle #-} + readVkBasePipelineHandle p + = peekByteOff p #{offset VkComputePipelineCreateInfo, basePipelineHandle} + + {-# INLINE writeVkBasePipelineHandle #-} + writeVkBasePipelineHandle p + = pokeByteOff p #{offset VkComputePipelineCreateInfo, basePipelineHandle} + +instance {-# OVERLAPPING #-} + HasField "basePipelineHandle" VkComputePipelineCreateInfo where + type FieldType "basePipelineHandle" VkComputePipelineCreateInfo = + VkPipeline + type FieldOptional "basePipelineHandle" VkComputePipelineCreateInfo + = 'True -- ' closing tick for hsc2hs + type FieldOffset "basePipelineHandle" VkComputePipelineCreateInfo = + #{offset VkComputePipelineCreateInfo, basePipelineHandle} + type FieldIsArray "basePipelineHandle" VkComputePipelineCreateInfo + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkComputePipelineCreateInfo, basePipelineHandle} + +instance CanReadField "basePipelineHandle" + VkComputePipelineCreateInfo + where + {-# INLINE getField #-} + getField = vkBasePipelineHandle + + {-# INLINE readField #-} + readField = readVkBasePipelineHandle + +instance CanWriteField "basePipelineHandle" + VkComputePipelineCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkBasePipelineHandle + +instance {-# OVERLAPPING #-} + HasVkBasePipelineIndex VkComputePipelineCreateInfo where + type VkBasePipelineIndexMType VkComputePipelineCreateInfo = Int32 + + {-# NOINLINE vkBasePipelineIndex #-} + vkBasePipelineIndex x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkComputePipelineCreateInfo, basePipelineIndex}) + + {-# INLINE vkBasePipelineIndexByteOffset #-} + vkBasePipelineIndexByteOffset ~_ + = #{offset VkComputePipelineCreateInfo, basePipelineIndex} + + {-# INLINE readVkBasePipelineIndex #-} + readVkBasePipelineIndex p + = peekByteOff p #{offset VkComputePipelineCreateInfo, basePipelineIndex} + + {-# INLINE writeVkBasePipelineIndex #-} + writeVkBasePipelineIndex p + = pokeByteOff p #{offset VkComputePipelineCreateInfo, basePipelineIndex} + +instance {-# OVERLAPPING #-} + HasField "basePipelineIndex" VkComputePipelineCreateInfo where + type FieldType "basePipelineIndex" VkComputePipelineCreateInfo = + Int32 + type FieldOptional "basePipelineIndex" VkComputePipelineCreateInfo + = 'False -- ' closing tick for hsc2hs + type FieldOffset "basePipelineIndex" VkComputePipelineCreateInfo = + #{offset VkComputePipelineCreateInfo, basePipelineIndex} + type FieldIsArray "basePipelineIndex" VkComputePipelineCreateInfo = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkComputePipelineCreateInfo, basePipelineIndex} + +instance CanReadField "basePipelineIndex" + VkComputePipelineCreateInfo + where + {-# INLINE getField #-} + getField = vkBasePipelineIndex + + {-# INLINE readField #-} + readField = readVkBasePipelineIndex + +instance CanWriteField "basePipelineIndex" + VkComputePipelineCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkBasePipelineIndex + +instance Show VkComputePipelineCreateInfo where + showsPrec d x + = showString "VkComputePipelineCreateInfo {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkFlags = " . + showsPrec d (vkFlags x) . + showString ", " . + showString "vkStage = " . + showsPrec d (vkStage x) . + showString ", " . + showString "vkLayout = " . + showsPrec d (vkLayout x) . + showString ", " . + showString "vkBasePipelineHandle = " . + showsPrec d (vkBasePipelineHandle x) . + showString ", " . + showString "vkBasePipelineIndex = " . + showsPrec d (vkBasePipelineIndex x) . + showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkCopyDescriptorSet.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkCopyDescriptorSet.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkCopyDescriptorSet.hsc @@ -0,0 +1,523 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkCopyDescriptorSet + (VkCopyDescriptorSet(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Handles (VkDescriptorSet) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkCopyDescriptorSet { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkDescriptorSet srcSet; +-- > uint32_t srcBinding; +-- > uint32_t srcArrayElement; +-- > VkDescriptorSet dstSet; +-- > uint32_t dstBinding; +-- > uint32_t dstArrayElement; +-- > uint32_t descriptorCount; +-- > } VkCopyDescriptorSet; +-- +-- +data VkCopyDescriptorSet = VkCopyDescriptorSet## Addr## ByteArray## + +instance Eq VkCopyDescriptorSet where + (VkCopyDescriptorSet## a _) == x@(VkCopyDescriptorSet## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkCopyDescriptorSet where + (VkCopyDescriptorSet## a _) `compare` x@(VkCopyDescriptorSet## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkCopyDescriptorSet where + sizeOf ~_ = #{size VkCopyDescriptorSet} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkCopyDescriptorSet} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkCopyDescriptorSet where + unsafeAddr (VkCopyDescriptorSet## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkCopyDescriptorSet## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkCopyDescriptorSet## (plusAddr## (byteArrayContents## b) off) b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkCopyDescriptorSet where + type StructFields VkCopyDescriptorSet = + '["sType", "pNext", "srcSet", "srcBinding", "srcArrayElement", -- ' closing tick for hsc2hs + "dstSet", "dstBinding", "dstArrayElement", "descriptorCount"] + type CUnionType VkCopyDescriptorSet = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkCopyDescriptorSet = 'False -- ' closing tick for hsc2hs + type StructExtends VkCopyDescriptorSet = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkSType VkCopyDescriptorSet where + type VkSTypeMType VkCopyDescriptorSet = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkCopyDescriptorSet, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkCopyDescriptorSet, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkCopyDescriptorSet, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkCopyDescriptorSet, sType} + +instance {-# OVERLAPPING #-} HasField "sType" VkCopyDescriptorSet + where + type FieldType "sType" VkCopyDescriptorSet = VkStructureType + type FieldOptional "sType" VkCopyDescriptorSet = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkCopyDescriptorSet = + #{offset VkCopyDescriptorSet, sType} + type FieldIsArray "sType" VkCopyDescriptorSet = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkCopyDescriptorSet, sType} + +instance CanReadField "sType" VkCopyDescriptorSet where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkCopyDescriptorSet where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} HasVkPNext VkCopyDescriptorSet where + type VkPNextMType VkCopyDescriptorSet = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkCopyDescriptorSet, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkCopyDescriptorSet, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkCopyDescriptorSet, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkCopyDescriptorSet, pNext} + +instance {-# OVERLAPPING #-} HasField "pNext" VkCopyDescriptorSet + where + type FieldType "pNext" VkCopyDescriptorSet = Ptr Void + type FieldOptional "pNext" VkCopyDescriptorSet = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkCopyDescriptorSet = + #{offset VkCopyDescriptorSet, pNext} + type FieldIsArray "pNext" VkCopyDescriptorSet = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkCopyDescriptorSet, pNext} + +instance CanReadField "pNext" VkCopyDescriptorSet where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkCopyDescriptorSet where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} HasVkSrcSet VkCopyDescriptorSet where + type VkSrcSetMType VkCopyDescriptorSet = VkDescriptorSet + + {-# NOINLINE vkSrcSet #-} + vkSrcSet x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkCopyDescriptorSet, srcSet}) + + {-# INLINE vkSrcSetByteOffset #-} + vkSrcSetByteOffset ~_ + = #{offset VkCopyDescriptorSet, srcSet} + + {-# INLINE readVkSrcSet #-} + readVkSrcSet p + = peekByteOff p #{offset VkCopyDescriptorSet, srcSet} + + {-# INLINE writeVkSrcSet #-} + writeVkSrcSet p + = pokeByteOff p #{offset VkCopyDescriptorSet, srcSet} + +instance {-# OVERLAPPING #-} HasField "srcSet" VkCopyDescriptorSet + where + type FieldType "srcSet" VkCopyDescriptorSet = VkDescriptorSet + type FieldOptional "srcSet" VkCopyDescriptorSet = 'False -- ' closing tick for hsc2hs + type FieldOffset "srcSet" VkCopyDescriptorSet = + #{offset VkCopyDescriptorSet, srcSet} + type FieldIsArray "srcSet" VkCopyDescriptorSet = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkCopyDescriptorSet, srcSet} + +instance CanReadField "srcSet" VkCopyDescriptorSet where + {-# INLINE getField #-} + getField = vkSrcSet + + {-# INLINE readField #-} + readField = readVkSrcSet + +instance CanWriteField "srcSet" VkCopyDescriptorSet where + {-# INLINE writeField #-} + writeField = writeVkSrcSet + +instance {-# OVERLAPPING #-} HasVkSrcBinding VkCopyDescriptorSet + where + type VkSrcBindingMType VkCopyDescriptorSet = Word32 + + {-# NOINLINE vkSrcBinding #-} + vkSrcBinding x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkCopyDescriptorSet, srcBinding}) + + {-# INLINE vkSrcBindingByteOffset #-} + vkSrcBindingByteOffset ~_ + = #{offset VkCopyDescriptorSet, srcBinding} + + {-# INLINE readVkSrcBinding #-} + readVkSrcBinding p + = peekByteOff p #{offset VkCopyDescriptorSet, srcBinding} + + {-# INLINE writeVkSrcBinding #-} + writeVkSrcBinding p + = pokeByteOff p #{offset VkCopyDescriptorSet, srcBinding} + +instance {-# OVERLAPPING #-} + HasField "srcBinding" VkCopyDescriptorSet where + type FieldType "srcBinding" VkCopyDescriptorSet = Word32 + type FieldOptional "srcBinding" VkCopyDescriptorSet = 'False -- ' closing tick for hsc2hs + type FieldOffset "srcBinding" VkCopyDescriptorSet = + #{offset VkCopyDescriptorSet, srcBinding} + type FieldIsArray "srcBinding" VkCopyDescriptorSet = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkCopyDescriptorSet, srcBinding} + +instance CanReadField "srcBinding" VkCopyDescriptorSet where + {-# INLINE getField #-} + getField = vkSrcBinding + + {-# INLINE readField #-} + readField = readVkSrcBinding + +instance CanWriteField "srcBinding" VkCopyDescriptorSet where + {-# INLINE writeField #-} + writeField = writeVkSrcBinding + +instance {-# OVERLAPPING #-} + HasVkSrcArrayElement VkCopyDescriptorSet where + type VkSrcArrayElementMType VkCopyDescriptorSet = Word32 + + {-# NOINLINE vkSrcArrayElement #-} + vkSrcArrayElement x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkCopyDescriptorSet, srcArrayElement}) + + {-# INLINE vkSrcArrayElementByteOffset #-} + vkSrcArrayElementByteOffset ~_ + = #{offset VkCopyDescriptorSet, srcArrayElement} + + {-# INLINE readVkSrcArrayElement #-} + readVkSrcArrayElement p + = peekByteOff p #{offset VkCopyDescriptorSet, srcArrayElement} + + {-# INLINE writeVkSrcArrayElement #-} + writeVkSrcArrayElement p + = pokeByteOff p #{offset VkCopyDescriptorSet, srcArrayElement} + +instance {-# OVERLAPPING #-} + HasField "srcArrayElement" VkCopyDescriptorSet where + type FieldType "srcArrayElement" VkCopyDescriptorSet = Word32 + type FieldOptional "srcArrayElement" VkCopyDescriptorSet = 'False -- ' closing tick for hsc2hs + type FieldOffset "srcArrayElement" VkCopyDescriptorSet = + #{offset VkCopyDescriptorSet, srcArrayElement} + type FieldIsArray "srcArrayElement" VkCopyDescriptorSet = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkCopyDescriptorSet, srcArrayElement} + +instance CanReadField "srcArrayElement" VkCopyDescriptorSet where + {-# INLINE getField #-} + getField = vkSrcArrayElement + + {-# INLINE readField #-} + readField = readVkSrcArrayElement + +instance CanWriteField "srcArrayElement" VkCopyDescriptorSet where + {-# INLINE writeField #-} + writeField = writeVkSrcArrayElement + +instance {-# OVERLAPPING #-} HasVkDstSet VkCopyDescriptorSet where + type VkDstSetMType VkCopyDescriptorSet = VkDescriptorSet + + {-# NOINLINE vkDstSet #-} + vkDstSet x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkCopyDescriptorSet, dstSet}) + + {-# INLINE vkDstSetByteOffset #-} + vkDstSetByteOffset ~_ + = #{offset VkCopyDescriptorSet, dstSet} + + {-# INLINE readVkDstSet #-} + readVkDstSet p + = peekByteOff p #{offset VkCopyDescriptorSet, dstSet} + + {-# INLINE writeVkDstSet #-} + writeVkDstSet p + = pokeByteOff p #{offset VkCopyDescriptorSet, dstSet} + +instance {-# OVERLAPPING #-} HasField "dstSet" VkCopyDescriptorSet + where + type FieldType "dstSet" VkCopyDescriptorSet = VkDescriptorSet + type FieldOptional "dstSet" VkCopyDescriptorSet = 'False -- ' closing tick for hsc2hs + type FieldOffset "dstSet" VkCopyDescriptorSet = + #{offset VkCopyDescriptorSet, dstSet} + type FieldIsArray "dstSet" VkCopyDescriptorSet = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkCopyDescriptorSet, dstSet} + +instance CanReadField "dstSet" VkCopyDescriptorSet where + {-# INLINE getField #-} + getField = vkDstSet + + {-# INLINE readField #-} + readField = readVkDstSet + +instance CanWriteField "dstSet" VkCopyDescriptorSet where + {-# INLINE writeField #-} + writeField = writeVkDstSet + +instance {-# OVERLAPPING #-} HasVkDstBinding VkCopyDescriptorSet + where + type VkDstBindingMType VkCopyDescriptorSet = Word32 + + {-# NOINLINE vkDstBinding #-} + vkDstBinding x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkCopyDescriptorSet, dstBinding}) + + {-# INLINE vkDstBindingByteOffset #-} + vkDstBindingByteOffset ~_ + = #{offset VkCopyDescriptorSet, dstBinding} + + {-# INLINE readVkDstBinding #-} + readVkDstBinding p + = peekByteOff p #{offset VkCopyDescriptorSet, dstBinding} + + {-# INLINE writeVkDstBinding #-} + writeVkDstBinding p + = pokeByteOff p #{offset VkCopyDescriptorSet, dstBinding} + +instance {-# OVERLAPPING #-} + HasField "dstBinding" VkCopyDescriptorSet where + type FieldType "dstBinding" VkCopyDescriptorSet = Word32 + type FieldOptional "dstBinding" VkCopyDescriptorSet = 'False -- ' closing tick for hsc2hs + type FieldOffset "dstBinding" VkCopyDescriptorSet = + #{offset VkCopyDescriptorSet, dstBinding} + type FieldIsArray "dstBinding" VkCopyDescriptorSet = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkCopyDescriptorSet, dstBinding} + +instance CanReadField "dstBinding" VkCopyDescriptorSet where + {-# INLINE getField #-} + getField = vkDstBinding + + {-# INLINE readField #-} + readField = readVkDstBinding + +instance CanWriteField "dstBinding" VkCopyDescriptorSet where + {-# INLINE writeField #-} + writeField = writeVkDstBinding + +instance {-# OVERLAPPING #-} + HasVkDstArrayElement VkCopyDescriptorSet where + type VkDstArrayElementMType VkCopyDescriptorSet = Word32 + + {-# NOINLINE vkDstArrayElement #-} + vkDstArrayElement x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkCopyDescriptorSet, dstArrayElement}) + + {-# INLINE vkDstArrayElementByteOffset #-} + vkDstArrayElementByteOffset ~_ + = #{offset VkCopyDescriptorSet, dstArrayElement} + + {-# INLINE readVkDstArrayElement #-} + readVkDstArrayElement p + = peekByteOff p #{offset VkCopyDescriptorSet, dstArrayElement} + + {-# INLINE writeVkDstArrayElement #-} + writeVkDstArrayElement p + = pokeByteOff p #{offset VkCopyDescriptorSet, dstArrayElement} + +instance {-# OVERLAPPING #-} + HasField "dstArrayElement" VkCopyDescriptorSet where + type FieldType "dstArrayElement" VkCopyDescriptorSet = Word32 + type FieldOptional "dstArrayElement" VkCopyDescriptorSet = 'False -- ' closing tick for hsc2hs + type FieldOffset "dstArrayElement" VkCopyDescriptorSet = + #{offset VkCopyDescriptorSet, dstArrayElement} + type FieldIsArray "dstArrayElement" VkCopyDescriptorSet = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkCopyDescriptorSet, dstArrayElement} + +instance CanReadField "dstArrayElement" VkCopyDescriptorSet where + {-# INLINE getField #-} + getField = vkDstArrayElement + + {-# INLINE readField #-} + readField = readVkDstArrayElement + +instance CanWriteField "dstArrayElement" VkCopyDescriptorSet where + {-# INLINE writeField #-} + writeField = writeVkDstArrayElement + +instance {-# OVERLAPPING #-} + HasVkDescriptorCount VkCopyDescriptorSet where + type VkDescriptorCountMType VkCopyDescriptorSet = Word32 + + {-# NOINLINE vkDescriptorCount #-} + vkDescriptorCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkCopyDescriptorSet, descriptorCount}) + + {-# INLINE vkDescriptorCountByteOffset #-} + vkDescriptorCountByteOffset ~_ + = #{offset VkCopyDescriptorSet, descriptorCount} + + {-# INLINE readVkDescriptorCount #-} + readVkDescriptorCount p + = peekByteOff p #{offset VkCopyDescriptorSet, descriptorCount} + + {-# INLINE writeVkDescriptorCount #-} + writeVkDescriptorCount p + = pokeByteOff p #{offset VkCopyDescriptorSet, descriptorCount} + +instance {-# OVERLAPPING #-} + HasField "descriptorCount" VkCopyDescriptorSet where + type FieldType "descriptorCount" VkCopyDescriptorSet = Word32 + type FieldOptional "descriptorCount" VkCopyDescriptorSet = 'False -- ' closing tick for hsc2hs + type FieldOffset "descriptorCount" VkCopyDescriptorSet = + #{offset VkCopyDescriptorSet, descriptorCount} + type FieldIsArray "descriptorCount" VkCopyDescriptorSet = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkCopyDescriptorSet, descriptorCount} + +instance CanReadField "descriptorCount" VkCopyDescriptorSet where + {-# INLINE getField #-} + getField = vkDescriptorCount + + {-# INLINE readField #-} + readField = readVkDescriptorCount + +instance CanWriteField "descriptorCount" VkCopyDescriptorSet where + {-# INLINE writeField #-} + writeField = writeVkDescriptorCount + +instance Show VkCopyDescriptorSet where + showsPrec d x + = showString "VkCopyDescriptorSet {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkSrcSet = " . + showsPrec d (vkSrcSet x) . + showString ", " . + showString "vkSrcBinding = " . + showsPrec d (vkSrcBinding x) . + showString ", " . + showString "vkSrcArrayElement = " . + showsPrec d (vkSrcArrayElement x) . + showString ", " . + showString "vkDstSet = " . + showsPrec d (vkDstSet x) . + showString ", " . + showString "vkDstBinding = " . + showsPrec d (vkDstBinding x) . + showString ", " . + showString "vkDstArrayElement = " . + showsPrec d (vkDstArrayElement x) . + showString ", " . + showString "vkDescriptorCount = " . + showsPrec d (vkDescriptorCount x) . + showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkD3D12FenceSubmitInfoKHR.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkD3D12FenceSubmitInfoKHR.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkD3D12FenceSubmitInfoKHR.hsc @@ -0,0 +1,428 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkD3D12FenceSubmitInfoKHR + (VkD3D12FenceSubmitInfoKHR(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Struct.VkSubmitInfo (VkSubmitInfo) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkD3D12FenceSubmitInfoKHR { +-- > VkStructureType sType; +-- > const void* pNext; +-- > uint32_t waitSemaphoreValuesCount; +-- > const uint64_t* pWaitSemaphoreValues; +-- > uint32_t signalSemaphoreValuesCount; +-- > const uint64_t* pSignalSemaphoreValues; +-- > } VkD3D12FenceSubmitInfoKHR; +-- +-- +data VkD3D12FenceSubmitInfoKHR = VkD3D12FenceSubmitInfoKHR## Addr## + ByteArray## + +instance Eq VkD3D12FenceSubmitInfoKHR where + (VkD3D12FenceSubmitInfoKHR## a _) == + x@(VkD3D12FenceSubmitInfoKHR## b _) = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkD3D12FenceSubmitInfoKHR where + (VkD3D12FenceSubmitInfoKHR## a _) `compare` + x@(VkD3D12FenceSubmitInfoKHR## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkD3D12FenceSubmitInfoKHR where + sizeOf ~_ = #{size VkD3D12FenceSubmitInfoKHR} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkD3D12FenceSubmitInfoKHR} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkD3D12FenceSubmitInfoKHR where + unsafeAddr (VkD3D12FenceSubmitInfoKHR## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkD3D12FenceSubmitInfoKHR## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkD3D12FenceSubmitInfoKHR## (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkD3D12FenceSubmitInfoKHR where + type StructFields VkD3D12FenceSubmitInfoKHR = + '["sType", "pNext", "waitSemaphoreValuesCount", -- ' closing tick for hsc2hs + "pWaitSemaphoreValues", "signalSemaphoreValuesCount", + "pSignalSemaphoreValues"] + type CUnionType VkD3D12FenceSubmitInfoKHR = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkD3D12FenceSubmitInfoKHR = 'False -- ' closing tick for hsc2hs + type StructExtends VkD3D12FenceSubmitInfoKHR = '[VkSubmitInfo] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkSType VkD3D12FenceSubmitInfoKHR + where + type VkSTypeMType VkD3D12FenceSubmitInfoKHR = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkD3D12FenceSubmitInfoKHR, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkD3D12FenceSubmitInfoKHR, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkD3D12FenceSubmitInfoKHR, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkD3D12FenceSubmitInfoKHR, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkD3D12FenceSubmitInfoKHR where + type FieldType "sType" VkD3D12FenceSubmitInfoKHR = VkStructureType + type FieldOptional "sType" VkD3D12FenceSubmitInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkD3D12FenceSubmitInfoKHR = + #{offset VkD3D12FenceSubmitInfoKHR, sType} + type FieldIsArray "sType" VkD3D12FenceSubmitInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkD3D12FenceSubmitInfoKHR, sType} + +instance CanReadField "sType" VkD3D12FenceSubmitInfoKHR where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkD3D12FenceSubmitInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} HasVkPNext VkD3D12FenceSubmitInfoKHR + where + type VkPNextMType VkD3D12FenceSubmitInfoKHR = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkD3D12FenceSubmitInfoKHR, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkD3D12FenceSubmitInfoKHR, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkD3D12FenceSubmitInfoKHR, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkD3D12FenceSubmitInfoKHR, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkD3D12FenceSubmitInfoKHR where + type FieldType "pNext" VkD3D12FenceSubmitInfoKHR = Ptr Void + type FieldOptional "pNext" VkD3D12FenceSubmitInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkD3D12FenceSubmitInfoKHR = + #{offset VkD3D12FenceSubmitInfoKHR, pNext} + type FieldIsArray "pNext" VkD3D12FenceSubmitInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkD3D12FenceSubmitInfoKHR, pNext} + +instance CanReadField "pNext" VkD3D12FenceSubmitInfoKHR where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkD3D12FenceSubmitInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkWaitSemaphoreValuesCount VkD3D12FenceSubmitInfoKHR where + type VkWaitSemaphoreValuesCountMType VkD3D12FenceSubmitInfoKHR = + Word32 + + {-# NOINLINE vkWaitSemaphoreValuesCount #-} + vkWaitSemaphoreValuesCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkD3D12FenceSubmitInfoKHR, waitSemaphoreValuesCount}) + + {-# INLINE vkWaitSemaphoreValuesCountByteOffset #-} + vkWaitSemaphoreValuesCountByteOffset ~_ + = #{offset VkD3D12FenceSubmitInfoKHR, waitSemaphoreValuesCount} + + {-# INLINE readVkWaitSemaphoreValuesCount #-} + readVkWaitSemaphoreValuesCount p + = peekByteOff p #{offset VkD3D12FenceSubmitInfoKHR, waitSemaphoreValuesCount} + + {-# INLINE writeVkWaitSemaphoreValuesCount #-} + writeVkWaitSemaphoreValuesCount p + = pokeByteOff p #{offset VkD3D12FenceSubmitInfoKHR, waitSemaphoreValuesCount} + +instance {-# OVERLAPPING #-} + HasField "waitSemaphoreValuesCount" VkD3D12FenceSubmitInfoKHR where + type FieldType "waitSemaphoreValuesCount" VkD3D12FenceSubmitInfoKHR + = Word32 + type FieldOptional "waitSemaphoreValuesCount" + VkD3D12FenceSubmitInfoKHR + = 'True -- ' closing tick for hsc2hs + type FieldOffset "waitSemaphoreValuesCount" + VkD3D12FenceSubmitInfoKHR + = + #{offset VkD3D12FenceSubmitInfoKHR, waitSemaphoreValuesCount} + type FieldIsArray "waitSemaphoreValuesCount" + VkD3D12FenceSubmitInfoKHR + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkD3D12FenceSubmitInfoKHR, waitSemaphoreValuesCount} + +instance CanReadField "waitSemaphoreValuesCount" + VkD3D12FenceSubmitInfoKHR + where + {-# INLINE getField #-} + getField = vkWaitSemaphoreValuesCount + + {-# INLINE readField #-} + readField = readVkWaitSemaphoreValuesCount + +instance CanWriteField "waitSemaphoreValuesCount" + VkD3D12FenceSubmitInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkWaitSemaphoreValuesCount + +instance {-# OVERLAPPING #-} + HasVkPWaitSemaphoreValues VkD3D12FenceSubmitInfoKHR where + type VkPWaitSemaphoreValuesMType VkD3D12FenceSubmitInfoKHR = + Ptr Word64 + + {-# NOINLINE vkPWaitSemaphoreValues #-} + vkPWaitSemaphoreValues x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkD3D12FenceSubmitInfoKHR, pWaitSemaphoreValues}) + + {-# INLINE vkPWaitSemaphoreValuesByteOffset #-} + vkPWaitSemaphoreValuesByteOffset ~_ + = #{offset VkD3D12FenceSubmitInfoKHR, pWaitSemaphoreValues} + + {-# INLINE readVkPWaitSemaphoreValues #-} + readVkPWaitSemaphoreValues p + = peekByteOff p #{offset VkD3D12FenceSubmitInfoKHR, pWaitSemaphoreValues} + + {-# INLINE writeVkPWaitSemaphoreValues #-} + writeVkPWaitSemaphoreValues p + = pokeByteOff p #{offset VkD3D12FenceSubmitInfoKHR, pWaitSemaphoreValues} + +instance {-# OVERLAPPING #-} + HasField "pWaitSemaphoreValues" VkD3D12FenceSubmitInfoKHR where + type FieldType "pWaitSemaphoreValues" VkD3D12FenceSubmitInfoKHR = + Ptr Word64 + type FieldOptional "pWaitSemaphoreValues" VkD3D12FenceSubmitInfoKHR + = 'True -- ' closing tick for hsc2hs + type FieldOffset "pWaitSemaphoreValues" VkD3D12FenceSubmitInfoKHR = + #{offset VkD3D12FenceSubmitInfoKHR, pWaitSemaphoreValues} + type FieldIsArray "pWaitSemaphoreValues" VkD3D12FenceSubmitInfoKHR + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkD3D12FenceSubmitInfoKHR, pWaitSemaphoreValues} + +instance CanReadField "pWaitSemaphoreValues" + VkD3D12FenceSubmitInfoKHR + where + {-# INLINE getField #-} + getField = vkPWaitSemaphoreValues + + {-# INLINE readField #-} + readField = readVkPWaitSemaphoreValues + +instance CanWriteField "pWaitSemaphoreValues" + VkD3D12FenceSubmitInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkPWaitSemaphoreValues + +instance {-# OVERLAPPING #-} + HasVkSignalSemaphoreValuesCount VkD3D12FenceSubmitInfoKHR where + type VkSignalSemaphoreValuesCountMType VkD3D12FenceSubmitInfoKHR = + Word32 + + {-# NOINLINE vkSignalSemaphoreValuesCount #-} + vkSignalSemaphoreValuesCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkD3D12FenceSubmitInfoKHR, signalSemaphoreValuesCount}) + + {-# INLINE vkSignalSemaphoreValuesCountByteOffset #-} + vkSignalSemaphoreValuesCountByteOffset ~_ + = #{offset VkD3D12FenceSubmitInfoKHR, signalSemaphoreValuesCount} + + {-# INLINE readVkSignalSemaphoreValuesCount #-} + readVkSignalSemaphoreValuesCount p + = peekByteOff p #{offset VkD3D12FenceSubmitInfoKHR, signalSemaphoreValuesCount} + + {-# INLINE writeVkSignalSemaphoreValuesCount #-} + writeVkSignalSemaphoreValuesCount p + = pokeByteOff p #{offset VkD3D12FenceSubmitInfoKHR, signalSemaphoreValuesCount} + +instance {-# OVERLAPPING #-} + HasField "signalSemaphoreValuesCount" VkD3D12FenceSubmitInfoKHR + where + type FieldType "signalSemaphoreValuesCount" + VkD3D12FenceSubmitInfoKHR + = Word32 + type FieldOptional "signalSemaphoreValuesCount" + VkD3D12FenceSubmitInfoKHR + = 'True -- ' closing tick for hsc2hs + type FieldOffset "signalSemaphoreValuesCount" + VkD3D12FenceSubmitInfoKHR + = + #{offset VkD3D12FenceSubmitInfoKHR, signalSemaphoreValuesCount} + type FieldIsArray "signalSemaphoreValuesCount" + VkD3D12FenceSubmitInfoKHR + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkD3D12FenceSubmitInfoKHR, signalSemaphoreValuesCount} + +instance CanReadField "signalSemaphoreValuesCount" + VkD3D12FenceSubmitInfoKHR + where + {-# INLINE getField #-} + getField = vkSignalSemaphoreValuesCount + + {-# INLINE readField #-} + readField = readVkSignalSemaphoreValuesCount + +instance CanWriteField "signalSemaphoreValuesCount" + VkD3D12FenceSubmitInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkSignalSemaphoreValuesCount + +instance {-# OVERLAPPING #-} + HasVkPSignalSemaphoreValues VkD3D12FenceSubmitInfoKHR where + type VkPSignalSemaphoreValuesMType VkD3D12FenceSubmitInfoKHR = + Ptr Word64 + + {-# NOINLINE vkPSignalSemaphoreValues #-} + vkPSignalSemaphoreValues x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkD3D12FenceSubmitInfoKHR, pSignalSemaphoreValues}) + + {-# INLINE vkPSignalSemaphoreValuesByteOffset #-} + vkPSignalSemaphoreValuesByteOffset ~_ + = #{offset VkD3D12FenceSubmitInfoKHR, pSignalSemaphoreValues} + + {-# INLINE readVkPSignalSemaphoreValues #-} + readVkPSignalSemaphoreValues p + = peekByteOff p #{offset VkD3D12FenceSubmitInfoKHR, pSignalSemaphoreValues} + + {-# INLINE writeVkPSignalSemaphoreValues #-} + writeVkPSignalSemaphoreValues p + = pokeByteOff p #{offset VkD3D12FenceSubmitInfoKHR, pSignalSemaphoreValues} + +instance {-# OVERLAPPING #-} + HasField "pSignalSemaphoreValues" VkD3D12FenceSubmitInfoKHR where + type FieldType "pSignalSemaphoreValues" VkD3D12FenceSubmitInfoKHR = + Ptr Word64 + type FieldOptional "pSignalSemaphoreValues" + VkD3D12FenceSubmitInfoKHR + = 'True -- ' closing tick for hsc2hs + type FieldOffset "pSignalSemaphoreValues" VkD3D12FenceSubmitInfoKHR + = + #{offset VkD3D12FenceSubmitInfoKHR, pSignalSemaphoreValues} + type FieldIsArray "pSignalSemaphoreValues" + VkD3D12FenceSubmitInfoKHR + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkD3D12FenceSubmitInfoKHR, pSignalSemaphoreValues} + +instance CanReadField "pSignalSemaphoreValues" + VkD3D12FenceSubmitInfoKHR + where + {-# INLINE getField #-} + getField = vkPSignalSemaphoreValues + + {-# INLINE readField #-} + readField = readVkPSignalSemaphoreValues + +instance CanWriteField "pSignalSemaphoreValues" + VkD3D12FenceSubmitInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkPSignalSemaphoreValues + +instance Show VkD3D12FenceSubmitInfoKHR where + showsPrec d x + = showString "VkD3D12FenceSubmitInfoKHR {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkWaitSemaphoreValuesCount = " . + showsPrec d (vkWaitSemaphoreValuesCount x) . + showString ", " . + showString "vkPWaitSemaphoreValues = " . + showsPrec d (vkPWaitSemaphoreValues x) . + showString ", " . + showString "vkSignalSemaphoreValuesCount = " . + showsPrec d (vkSignalSemaphoreValuesCount x) . + showString ", " . + showString "vkPSignalSemaphoreValues = " . + showsPrec d (vkPSignalSemaphoreValues x) . + showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkDebugMarkerMarkerInfoEXT.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkDebugMarkerMarkerInfoEXT.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkDebugMarkerMarkerInfoEXT.hsc @@ -0,0 +1,334 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleContexts #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE ScopedTypeVariables #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +{-# LANGUAGE UndecidableInstances #-} +module Graphics.Vulkan.Types.Struct.VkDebugMarkerMarkerInfoEXT + (VkDebugMarkerMarkerInfoEXT(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import GHC.TypeLits (KnownNat, natVal') -- ' closing tick for hsc2hs +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkDebugMarkerMarkerInfoEXT { +-- > VkStructureType sType; +-- > const void* pNext; +-- > const char* pMarkerName; +-- > float color[4]; +-- > } VkDebugMarkerMarkerInfoEXT; +-- +-- +data VkDebugMarkerMarkerInfoEXT = VkDebugMarkerMarkerInfoEXT## Addr## + ByteArray## + +instance Eq VkDebugMarkerMarkerInfoEXT where + (VkDebugMarkerMarkerInfoEXT## a _) == + x@(VkDebugMarkerMarkerInfoEXT## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkDebugMarkerMarkerInfoEXT where + (VkDebugMarkerMarkerInfoEXT## a _) `compare` + x@(VkDebugMarkerMarkerInfoEXT## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkDebugMarkerMarkerInfoEXT where + sizeOf ~_ = #{size VkDebugMarkerMarkerInfoEXT} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkDebugMarkerMarkerInfoEXT} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkDebugMarkerMarkerInfoEXT where + unsafeAddr (VkDebugMarkerMarkerInfoEXT## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkDebugMarkerMarkerInfoEXT## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkDebugMarkerMarkerInfoEXT## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkDebugMarkerMarkerInfoEXT where + type StructFields VkDebugMarkerMarkerInfoEXT = + '["sType", "pNext", "pMarkerName", "color"] -- ' closing tick for hsc2hs + type CUnionType VkDebugMarkerMarkerInfoEXT = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkDebugMarkerMarkerInfoEXT = 'False -- ' closing tick for hsc2hs + type StructExtends VkDebugMarkerMarkerInfoEXT = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkSType VkDebugMarkerMarkerInfoEXT + where + type VkSTypeMType VkDebugMarkerMarkerInfoEXT = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDebugMarkerMarkerInfoEXT, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkDebugMarkerMarkerInfoEXT, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkDebugMarkerMarkerInfoEXT, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkDebugMarkerMarkerInfoEXT, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkDebugMarkerMarkerInfoEXT where + type FieldType "sType" VkDebugMarkerMarkerInfoEXT = VkStructureType + type FieldOptional "sType" VkDebugMarkerMarkerInfoEXT = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkDebugMarkerMarkerInfoEXT = + #{offset VkDebugMarkerMarkerInfoEXT, sType} + type FieldIsArray "sType" VkDebugMarkerMarkerInfoEXT = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDebugMarkerMarkerInfoEXT, sType} + +instance CanReadField "sType" VkDebugMarkerMarkerInfoEXT where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkDebugMarkerMarkerInfoEXT where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} HasVkPNext VkDebugMarkerMarkerInfoEXT + where + type VkPNextMType VkDebugMarkerMarkerInfoEXT = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDebugMarkerMarkerInfoEXT, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkDebugMarkerMarkerInfoEXT, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkDebugMarkerMarkerInfoEXT, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkDebugMarkerMarkerInfoEXT, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkDebugMarkerMarkerInfoEXT where + type FieldType "pNext" VkDebugMarkerMarkerInfoEXT = Ptr Void + type FieldOptional "pNext" VkDebugMarkerMarkerInfoEXT = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkDebugMarkerMarkerInfoEXT = + #{offset VkDebugMarkerMarkerInfoEXT, pNext} + type FieldIsArray "pNext" VkDebugMarkerMarkerInfoEXT = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDebugMarkerMarkerInfoEXT, pNext} + +instance CanReadField "pNext" VkDebugMarkerMarkerInfoEXT where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkDebugMarkerMarkerInfoEXT where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkPMarkerName VkDebugMarkerMarkerInfoEXT where + type VkPMarkerNameMType VkDebugMarkerMarkerInfoEXT = CString + + {-# NOINLINE vkPMarkerName #-} + vkPMarkerName x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDebugMarkerMarkerInfoEXT, pMarkerName}) + + {-# INLINE vkPMarkerNameByteOffset #-} + vkPMarkerNameByteOffset ~_ + = #{offset VkDebugMarkerMarkerInfoEXT, pMarkerName} + + {-# INLINE readVkPMarkerName #-} + readVkPMarkerName p + = peekByteOff p #{offset VkDebugMarkerMarkerInfoEXT, pMarkerName} + + {-# INLINE writeVkPMarkerName #-} + writeVkPMarkerName p + = pokeByteOff p #{offset VkDebugMarkerMarkerInfoEXT, pMarkerName} + +instance {-# OVERLAPPING #-} + HasField "pMarkerName" VkDebugMarkerMarkerInfoEXT where + type FieldType "pMarkerName" VkDebugMarkerMarkerInfoEXT = CString + type FieldOptional "pMarkerName" VkDebugMarkerMarkerInfoEXT = + 'False -- ' closing tick for hsc2hs + type FieldOffset "pMarkerName" VkDebugMarkerMarkerInfoEXT = + #{offset VkDebugMarkerMarkerInfoEXT, pMarkerName} + type FieldIsArray "pMarkerName" VkDebugMarkerMarkerInfoEXT = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDebugMarkerMarkerInfoEXT, pMarkerName} + +instance CanReadField "pMarkerName" VkDebugMarkerMarkerInfoEXT + where + {-# INLINE getField #-} + getField = vkPMarkerName + + {-# INLINE readField #-} + readField = readVkPMarkerName + +instance CanWriteField "pMarkerName" VkDebugMarkerMarkerInfoEXT + where + {-# INLINE writeField #-} + writeField = writeVkPMarkerName + +instance {-# OVERLAPPING #-} + HasVkColorArray VkDebugMarkerMarkerInfoEXT where + type VkColorArrayMType VkDebugMarkerMarkerInfoEXT = + #{type float} + + {-# NOINLINE vkColorArray #-} + vkColorArray x idx + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) + (idx * sizeOf (undefined :: #{type float}) + + #{offset VkDebugMarkerMarkerInfoEXT, color})) + + {-# INLINE vkColorArrayByteOffset #-} + vkColorArrayByteOffset ~_ + = #{offset VkDebugMarkerMarkerInfoEXT, color} + + {-# INLINE readVkColorArray #-} + readVkColorArray p idx + = peekByteOff p + (idx * sizeOf (undefined :: #{type float}) + + #{offset VkDebugMarkerMarkerInfoEXT, color}) + + {-# INLINE writeVkColorArray #-} + writeVkColorArray p idx + = pokeByteOff p + (idx * sizeOf (undefined :: #{type float}) + + #{offset VkDebugMarkerMarkerInfoEXT, color}) + +instance {-# OVERLAPPING #-} + HasField "color" VkDebugMarkerMarkerInfoEXT where + type FieldType "color" VkDebugMarkerMarkerInfoEXT = + #{type float} + type FieldOptional "color" VkDebugMarkerMarkerInfoEXT = 'True -- ' closing tick for hsc2hs + type FieldOffset "color" VkDebugMarkerMarkerInfoEXT = + #{offset VkDebugMarkerMarkerInfoEXT, color} + type FieldIsArray "color" VkDebugMarkerMarkerInfoEXT = 'True -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDebugMarkerMarkerInfoEXT, color} + +instance (KnownNat idx, + IndexInBounds "color" idx VkDebugMarkerMarkerInfoEXT) => + CanReadFieldArray "color" idx VkDebugMarkerMarkerInfoEXT + where + {-# SPECIALISE instance + CanReadFieldArray "color" 0 VkDebugMarkerMarkerInfoEXT #-} + + {-# SPECIALISE instance + CanReadFieldArray "color" 1 VkDebugMarkerMarkerInfoEXT #-} + + {-# SPECIALISE instance + CanReadFieldArray "color" 2 VkDebugMarkerMarkerInfoEXT #-} + + {-# SPECIALISE instance + CanReadFieldArray "color" 3 VkDebugMarkerMarkerInfoEXT #-} + type FieldArrayLength "color" VkDebugMarkerMarkerInfoEXT = 4 + + {-# INLINE fieldArrayLength #-} + fieldArrayLength = 4 + + {-# INLINE getFieldArray #-} + getFieldArray x + = vkColorArray x (fromInteger $ natVal' (proxy## :: Proxy## idx)) -- ' closing tick for hsc2hs + + {-# INLINE readFieldArray #-} + readFieldArray x + = readVkColorArray x (fromInteger $ natVal' (proxy## :: Proxy## idx)) -- ' closing tick for hsc2hs + +instance (KnownNat idx, + IndexInBounds "color" idx VkDebugMarkerMarkerInfoEXT) => + CanWriteFieldArray "color" idx VkDebugMarkerMarkerInfoEXT + where + {-# SPECIALISE instance + CanWriteFieldArray "color" 0 VkDebugMarkerMarkerInfoEXT #-} + + {-# SPECIALISE instance + CanWriteFieldArray "color" 1 VkDebugMarkerMarkerInfoEXT #-} + + {-# SPECIALISE instance + CanWriteFieldArray "color" 2 VkDebugMarkerMarkerInfoEXT #-} + + {-# SPECIALISE instance + CanWriteFieldArray "color" 3 VkDebugMarkerMarkerInfoEXT #-} + + {-# INLINE writeFieldArray #-} + writeFieldArray x + = writeVkColorArray x + (fromInteger $ natVal' (proxy## :: Proxy## idx)) -- ' closing tick for hsc2hs + +instance Show VkDebugMarkerMarkerInfoEXT where + showsPrec d x + = showString "VkDebugMarkerMarkerInfoEXT {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkPMarkerName = " . + showsPrec d (vkPMarkerName x) . + showString ", " . + showString "vkColorArray = [" . + showsPrec d (map (vkColorArray x) [1 .. 4]) . + showChar ']' . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkDebugMarkerObjectNameInfoEXT.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkDebugMarkerObjectNameInfoEXT.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkDebugMarkerObjectNameInfoEXT.hsc @@ -0,0 +1,345 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkDebugMarkerObjectNameInfoEXT + (VkDebugMarkerObjectNameInfoEXT(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkDebugReportObjectTypeEXT (VkDebugReportObjectTypeEXT) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkDebugMarkerObjectNameInfoEXT { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkDebugReportObjectTypeEXT objectType; +-- > uint64_t object; +-- > const char* pObjectName; +-- > } VkDebugMarkerObjectNameInfoEXT; +-- +-- +data VkDebugMarkerObjectNameInfoEXT = VkDebugMarkerObjectNameInfoEXT## Addr## + ByteArray## + +instance Eq VkDebugMarkerObjectNameInfoEXT where + (VkDebugMarkerObjectNameInfoEXT## a _) == + x@(VkDebugMarkerObjectNameInfoEXT## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkDebugMarkerObjectNameInfoEXT where + (VkDebugMarkerObjectNameInfoEXT## a _) `compare` + x@(VkDebugMarkerObjectNameInfoEXT## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkDebugMarkerObjectNameInfoEXT where + sizeOf ~_ = #{size VkDebugMarkerObjectNameInfoEXT} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkDebugMarkerObjectNameInfoEXT} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkDebugMarkerObjectNameInfoEXT where + unsafeAddr (VkDebugMarkerObjectNameInfoEXT## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkDebugMarkerObjectNameInfoEXT## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkDebugMarkerObjectNameInfoEXT## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkDebugMarkerObjectNameInfoEXT where + type StructFields VkDebugMarkerObjectNameInfoEXT = + '["sType", "pNext", "objectType", "object", "pObjectName"] -- ' closing tick for hsc2hs + type CUnionType VkDebugMarkerObjectNameInfoEXT = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkDebugMarkerObjectNameInfoEXT = 'False -- ' closing tick for hsc2hs + type StructExtends VkDebugMarkerObjectNameInfoEXT = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkDebugMarkerObjectNameInfoEXT where + type VkSTypeMType VkDebugMarkerObjectNameInfoEXT = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDebugMarkerObjectNameInfoEXT, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkDebugMarkerObjectNameInfoEXT, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkDebugMarkerObjectNameInfoEXT, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkDebugMarkerObjectNameInfoEXT, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkDebugMarkerObjectNameInfoEXT where + type FieldType "sType" VkDebugMarkerObjectNameInfoEXT = + VkStructureType + type FieldOptional "sType" VkDebugMarkerObjectNameInfoEXT = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkDebugMarkerObjectNameInfoEXT = + #{offset VkDebugMarkerObjectNameInfoEXT, sType} + type FieldIsArray "sType" VkDebugMarkerObjectNameInfoEXT = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDebugMarkerObjectNameInfoEXT, sType} + +instance CanReadField "sType" VkDebugMarkerObjectNameInfoEXT where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkDebugMarkerObjectNameInfoEXT where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkDebugMarkerObjectNameInfoEXT where + type VkPNextMType VkDebugMarkerObjectNameInfoEXT = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDebugMarkerObjectNameInfoEXT, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkDebugMarkerObjectNameInfoEXT, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkDebugMarkerObjectNameInfoEXT, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkDebugMarkerObjectNameInfoEXT, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkDebugMarkerObjectNameInfoEXT where + type FieldType "pNext" VkDebugMarkerObjectNameInfoEXT = Ptr Void + type FieldOptional "pNext" VkDebugMarkerObjectNameInfoEXT = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkDebugMarkerObjectNameInfoEXT = + #{offset VkDebugMarkerObjectNameInfoEXT, pNext} + type FieldIsArray "pNext" VkDebugMarkerObjectNameInfoEXT = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDebugMarkerObjectNameInfoEXT, pNext} + +instance CanReadField "pNext" VkDebugMarkerObjectNameInfoEXT where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkDebugMarkerObjectNameInfoEXT where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkObjectType VkDebugMarkerObjectNameInfoEXT where + type VkObjectTypeMType VkDebugMarkerObjectNameInfoEXT = + VkDebugReportObjectTypeEXT + + {-# NOINLINE vkObjectType #-} + vkObjectType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDebugMarkerObjectNameInfoEXT, objectType}) + + {-# INLINE vkObjectTypeByteOffset #-} + vkObjectTypeByteOffset ~_ + = #{offset VkDebugMarkerObjectNameInfoEXT, objectType} + + {-# INLINE readVkObjectType #-} + readVkObjectType p + = peekByteOff p #{offset VkDebugMarkerObjectNameInfoEXT, objectType} + + {-# INLINE writeVkObjectType #-} + writeVkObjectType p + = pokeByteOff p #{offset VkDebugMarkerObjectNameInfoEXT, objectType} + +instance {-# OVERLAPPING #-} + HasField "objectType" VkDebugMarkerObjectNameInfoEXT where + type FieldType "objectType" VkDebugMarkerObjectNameInfoEXT = + VkDebugReportObjectTypeEXT + type FieldOptional "objectType" VkDebugMarkerObjectNameInfoEXT = + 'False -- ' closing tick for hsc2hs + type FieldOffset "objectType" VkDebugMarkerObjectNameInfoEXT = + #{offset VkDebugMarkerObjectNameInfoEXT, objectType} + type FieldIsArray "objectType" VkDebugMarkerObjectNameInfoEXT = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDebugMarkerObjectNameInfoEXT, objectType} + +instance CanReadField "objectType" VkDebugMarkerObjectNameInfoEXT + where + {-# INLINE getField #-} + getField = vkObjectType + + {-# INLINE readField #-} + readField = readVkObjectType + +instance CanWriteField "objectType" VkDebugMarkerObjectNameInfoEXT + where + {-# INLINE writeField #-} + writeField = writeVkObjectType + +instance {-# OVERLAPPING #-} + HasVkObject VkDebugMarkerObjectNameInfoEXT where + type VkObjectMType VkDebugMarkerObjectNameInfoEXT = Word64 + + {-# NOINLINE vkObject #-} + vkObject x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDebugMarkerObjectNameInfoEXT, object}) + + {-# INLINE vkObjectByteOffset #-} + vkObjectByteOffset ~_ + = #{offset VkDebugMarkerObjectNameInfoEXT, object} + + {-# INLINE readVkObject #-} + readVkObject p + = peekByteOff p #{offset VkDebugMarkerObjectNameInfoEXT, object} + + {-# INLINE writeVkObject #-} + writeVkObject p + = pokeByteOff p #{offset VkDebugMarkerObjectNameInfoEXT, object} + +instance {-# OVERLAPPING #-} + HasField "object" VkDebugMarkerObjectNameInfoEXT where + type FieldType "object" VkDebugMarkerObjectNameInfoEXT = Word64 + type FieldOptional "object" VkDebugMarkerObjectNameInfoEXT = 'False -- ' closing tick for hsc2hs + type FieldOffset "object" VkDebugMarkerObjectNameInfoEXT = + #{offset VkDebugMarkerObjectNameInfoEXT, object} + type FieldIsArray "object" VkDebugMarkerObjectNameInfoEXT = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDebugMarkerObjectNameInfoEXT, object} + +instance CanReadField "object" VkDebugMarkerObjectNameInfoEXT where + {-# INLINE getField #-} + getField = vkObject + + {-# INLINE readField #-} + readField = readVkObject + +instance CanWriteField "object" VkDebugMarkerObjectNameInfoEXT + where + {-# INLINE writeField #-} + writeField = writeVkObject + +instance {-# OVERLAPPING #-} + HasVkPObjectName VkDebugMarkerObjectNameInfoEXT where + type VkPObjectNameMType VkDebugMarkerObjectNameInfoEXT = CString + + {-# NOINLINE vkPObjectName #-} + vkPObjectName x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDebugMarkerObjectNameInfoEXT, pObjectName}) + + {-# INLINE vkPObjectNameByteOffset #-} + vkPObjectNameByteOffset ~_ + = #{offset VkDebugMarkerObjectNameInfoEXT, pObjectName} + + {-# INLINE readVkPObjectName #-} + readVkPObjectName p + = peekByteOff p #{offset VkDebugMarkerObjectNameInfoEXT, pObjectName} + + {-# INLINE writeVkPObjectName #-} + writeVkPObjectName p + = pokeByteOff p #{offset VkDebugMarkerObjectNameInfoEXT, pObjectName} + +instance {-# OVERLAPPING #-} + HasField "pObjectName" VkDebugMarkerObjectNameInfoEXT where + type FieldType "pObjectName" VkDebugMarkerObjectNameInfoEXT = + CString + type FieldOptional "pObjectName" VkDebugMarkerObjectNameInfoEXT = + 'False -- ' closing tick for hsc2hs + type FieldOffset "pObjectName" VkDebugMarkerObjectNameInfoEXT = + #{offset VkDebugMarkerObjectNameInfoEXT, pObjectName} + type FieldIsArray "pObjectName" VkDebugMarkerObjectNameInfoEXT = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDebugMarkerObjectNameInfoEXT, pObjectName} + +instance CanReadField "pObjectName" VkDebugMarkerObjectNameInfoEXT + where + {-# INLINE getField #-} + getField = vkPObjectName + + {-# INLINE readField #-} + readField = readVkPObjectName + +instance CanWriteField "pObjectName" VkDebugMarkerObjectNameInfoEXT + where + {-# INLINE writeField #-} + writeField = writeVkPObjectName + +instance Show VkDebugMarkerObjectNameInfoEXT where + showsPrec d x + = showString "VkDebugMarkerObjectNameInfoEXT {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkObjectType = " . + showsPrec d (vkObjectType x) . + showString ", " . + showString "vkObject = " . + showsPrec d (vkObject x) . + showString ", " . + showString "vkPObjectName = " . + showsPrec d (vkPObjectName x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkDebugMarkerObjectTagInfoEXT.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkDebugMarkerObjectTagInfoEXT.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkDebugMarkerObjectTagInfoEXT.hsc @@ -0,0 +1,444 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkDebugMarkerObjectTagInfoEXT + (VkDebugMarkerObjectTagInfoEXT(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkDebugReportObjectTypeEXT (VkDebugReportObjectTypeEXT) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkDebugMarkerObjectTagInfoEXT { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkDebugReportObjectTypeEXT objectType; +-- > uint64_t object; +-- > uint64_t tagName; +-- > size_t tagSize; +-- > const void* pTag; +-- > } VkDebugMarkerObjectTagInfoEXT; +-- +-- +data VkDebugMarkerObjectTagInfoEXT = VkDebugMarkerObjectTagInfoEXT## Addr## + ByteArray## + +instance Eq VkDebugMarkerObjectTagInfoEXT where + (VkDebugMarkerObjectTagInfoEXT## a _) == + x@(VkDebugMarkerObjectTagInfoEXT## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkDebugMarkerObjectTagInfoEXT where + (VkDebugMarkerObjectTagInfoEXT## a _) `compare` + x@(VkDebugMarkerObjectTagInfoEXT## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkDebugMarkerObjectTagInfoEXT where + sizeOf ~_ = #{size VkDebugMarkerObjectTagInfoEXT} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkDebugMarkerObjectTagInfoEXT} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkDebugMarkerObjectTagInfoEXT where + unsafeAddr (VkDebugMarkerObjectTagInfoEXT## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkDebugMarkerObjectTagInfoEXT## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkDebugMarkerObjectTagInfoEXT## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkDebugMarkerObjectTagInfoEXT where + type StructFields VkDebugMarkerObjectTagInfoEXT = + '["sType", "pNext", "objectType", "object", "tagName", "tagSize", -- ' closing tick for hsc2hs + "pTag"] + type CUnionType VkDebugMarkerObjectTagInfoEXT = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkDebugMarkerObjectTagInfoEXT = 'False -- ' closing tick for hsc2hs + type StructExtends VkDebugMarkerObjectTagInfoEXT = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkDebugMarkerObjectTagInfoEXT where + type VkSTypeMType VkDebugMarkerObjectTagInfoEXT = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDebugMarkerObjectTagInfoEXT, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkDebugMarkerObjectTagInfoEXT, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkDebugMarkerObjectTagInfoEXT, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkDebugMarkerObjectTagInfoEXT, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkDebugMarkerObjectTagInfoEXT where + type FieldType "sType" VkDebugMarkerObjectTagInfoEXT = + VkStructureType + type FieldOptional "sType" VkDebugMarkerObjectTagInfoEXT = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkDebugMarkerObjectTagInfoEXT = + #{offset VkDebugMarkerObjectTagInfoEXT, sType} + type FieldIsArray "sType" VkDebugMarkerObjectTagInfoEXT = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDebugMarkerObjectTagInfoEXT, sType} + +instance CanReadField "sType" VkDebugMarkerObjectTagInfoEXT where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkDebugMarkerObjectTagInfoEXT where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkDebugMarkerObjectTagInfoEXT where + type VkPNextMType VkDebugMarkerObjectTagInfoEXT = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDebugMarkerObjectTagInfoEXT, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkDebugMarkerObjectTagInfoEXT, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkDebugMarkerObjectTagInfoEXT, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkDebugMarkerObjectTagInfoEXT, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkDebugMarkerObjectTagInfoEXT where + type FieldType "pNext" VkDebugMarkerObjectTagInfoEXT = Ptr Void + type FieldOptional "pNext" VkDebugMarkerObjectTagInfoEXT = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkDebugMarkerObjectTagInfoEXT = + #{offset VkDebugMarkerObjectTagInfoEXT, pNext} + type FieldIsArray "pNext" VkDebugMarkerObjectTagInfoEXT = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDebugMarkerObjectTagInfoEXT, pNext} + +instance CanReadField "pNext" VkDebugMarkerObjectTagInfoEXT where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkDebugMarkerObjectTagInfoEXT where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkObjectType VkDebugMarkerObjectTagInfoEXT where + type VkObjectTypeMType VkDebugMarkerObjectTagInfoEXT = + VkDebugReportObjectTypeEXT + + {-# NOINLINE vkObjectType #-} + vkObjectType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDebugMarkerObjectTagInfoEXT, objectType}) + + {-# INLINE vkObjectTypeByteOffset #-} + vkObjectTypeByteOffset ~_ + = #{offset VkDebugMarkerObjectTagInfoEXT, objectType} + + {-# INLINE readVkObjectType #-} + readVkObjectType p + = peekByteOff p #{offset VkDebugMarkerObjectTagInfoEXT, objectType} + + {-# INLINE writeVkObjectType #-} + writeVkObjectType p + = pokeByteOff p #{offset VkDebugMarkerObjectTagInfoEXT, objectType} + +instance {-# OVERLAPPING #-} + HasField "objectType" VkDebugMarkerObjectTagInfoEXT where + type FieldType "objectType" VkDebugMarkerObjectTagInfoEXT = + VkDebugReportObjectTypeEXT + type FieldOptional "objectType" VkDebugMarkerObjectTagInfoEXT = + 'False -- ' closing tick for hsc2hs + type FieldOffset "objectType" VkDebugMarkerObjectTagInfoEXT = + #{offset VkDebugMarkerObjectTagInfoEXT, objectType} + type FieldIsArray "objectType" VkDebugMarkerObjectTagInfoEXT = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDebugMarkerObjectTagInfoEXT, objectType} + +instance CanReadField "objectType" VkDebugMarkerObjectTagInfoEXT + where + {-# INLINE getField #-} + getField = vkObjectType + + {-# INLINE readField #-} + readField = readVkObjectType + +instance CanWriteField "objectType" VkDebugMarkerObjectTagInfoEXT + where + {-# INLINE writeField #-} + writeField = writeVkObjectType + +instance {-# OVERLAPPING #-} + HasVkObject VkDebugMarkerObjectTagInfoEXT where + type VkObjectMType VkDebugMarkerObjectTagInfoEXT = Word64 + + {-# NOINLINE vkObject #-} + vkObject x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDebugMarkerObjectTagInfoEXT, object}) + + {-# INLINE vkObjectByteOffset #-} + vkObjectByteOffset ~_ + = #{offset VkDebugMarkerObjectTagInfoEXT, object} + + {-# INLINE readVkObject #-} + readVkObject p + = peekByteOff p #{offset VkDebugMarkerObjectTagInfoEXT, object} + + {-# INLINE writeVkObject #-} + writeVkObject p + = pokeByteOff p #{offset VkDebugMarkerObjectTagInfoEXT, object} + +instance {-# OVERLAPPING #-} + HasField "object" VkDebugMarkerObjectTagInfoEXT where + type FieldType "object" VkDebugMarkerObjectTagInfoEXT = Word64 + type FieldOptional "object" VkDebugMarkerObjectTagInfoEXT = 'False -- ' closing tick for hsc2hs + type FieldOffset "object" VkDebugMarkerObjectTagInfoEXT = + #{offset VkDebugMarkerObjectTagInfoEXT, object} + type FieldIsArray "object" VkDebugMarkerObjectTagInfoEXT = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDebugMarkerObjectTagInfoEXT, object} + +instance CanReadField "object" VkDebugMarkerObjectTagInfoEXT where + {-# INLINE getField #-} + getField = vkObject + + {-# INLINE readField #-} + readField = readVkObject + +instance CanWriteField "object" VkDebugMarkerObjectTagInfoEXT where + {-# INLINE writeField #-} + writeField = writeVkObject + +instance {-# OVERLAPPING #-} + HasVkTagName VkDebugMarkerObjectTagInfoEXT where + type VkTagNameMType VkDebugMarkerObjectTagInfoEXT = Word64 + + {-# NOINLINE vkTagName #-} + vkTagName x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDebugMarkerObjectTagInfoEXT, tagName}) + + {-# INLINE vkTagNameByteOffset #-} + vkTagNameByteOffset ~_ + = #{offset VkDebugMarkerObjectTagInfoEXT, tagName} + + {-# INLINE readVkTagName #-} + readVkTagName p + = peekByteOff p #{offset VkDebugMarkerObjectTagInfoEXT, tagName} + + {-# INLINE writeVkTagName #-} + writeVkTagName p + = pokeByteOff p #{offset VkDebugMarkerObjectTagInfoEXT, tagName} + +instance {-# OVERLAPPING #-} + HasField "tagName" VkDebugMarkerObjectTagInfoEXT where + type FieldType "tagName" VkDebugMarkerObjectTagInfoEXT = Word64 + type FieldOptional "tagName" VkDebugMarkerObjectTagInfoEXT = 'False -- ' closing tick for hsc2hs + type FieldOffset "tagName" VkDebugMarkerObjectTagInfoEXT = + #{offset VkDebugMarkerObjectTagInfoEXT, tagName} + type FieldIsArray "tagName" VkDebugMarkerObjectTagInfoEXT = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDebugMarkerObjectTagInfoEXT, tagName} + +instance CanReadField "tagName" VkDebugMarkerObjectTagInfoEXT where + {-# INLINE getField #-} + getField = vkTagName + + {-# INLINE readField #-} + readField = readVkTagName + +instance CanWriteField "tagName" VkDebugMarkerObjectTagInfoEXT + where + {-# INLINE writeField #-} + writeField = writeVkTagName + +instance {-# OVERLAPPING #-} + HasVkTagSize VkDebugMarkerObjectTagInfoEXT where + type VkTagSizeMType VkDebugMarkerObjectTagInfoEXT = CSize + + {-# NOINLINE vkTagSize #-} + vkTagSize x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDebugMarkerObjectTagInfoEXT, tagSize}) + + {-# INLINE vkTagSizeByteOffset #-} + vkTagSizeByteOffset ~_ + = #{offset VkDebugMarkerObjectTagInfoEXT, tagSize} + + {-# INLINE readVkTagSize #-} + readVkTagSize p + = peekByteOff p #{offset VkDebugMarkerObjectTagInfoEXT, tagSize} + + {-# INLINE writeVkTagSize #-} + writeVkTagSize p + = pokeByteOff p #{offset VkDebugMarkerObjectTagInfoEXT, tagSize} + +instance {-# OVERLAPPING #-} + HasField "tagSize" VkDebugMarkerObjectTagInfoEXT where + type FieldType "tagSize" VkDebugMarkerObjectTagInfoEXT = CSize + type FieldOptional "tagSize" VkDebugMarkerObjectTagInfoEXT = 'False -- ' closing tick for hsc2hs + type FieldOffset "tagSize" VkDebugMarkerObjectTagInfoEXT = + #{offset VkDebugMarkerObjectTagInfoEXT, tagSize} + type FieldIsArray "tagSize" VkDebugMarkerObjectTagInfoEXT = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDebugMarkerObjectTagInfoEXT, tagSize} + +instance CanReadField "tagSize" VkDebugMarkerObjectTagInfoEXT where + {-# INLINE getField #-} + getField = vkTagSize + + {-# INLINE readField #-} + readField = readVkTagSize + +instance CanWriteField "tagSize" VkDebugMarkerObjectTagInfoEXT + where + {-# INLINE writeField #-} + writeField = writeVkTagSize + +instance {-# OVERLAPPING #-} + HasVkPTag VkDebugMarkerObjectTagInfoEXT where + type VkPTagMType VkDebugMarkerObjectTagInfoEXT = Ptr Void + + {-# NOINLINE vkPTag #-} + vkPTag x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDebugMarkerObjectTagInfoEXT, pTag}) + + {-# INLINE vkPTagByteOffset #-} + vkPTagByteOffset ~_ + = #{offset VkDebugMarkerObjectTagInfoEXT, pTag} + + {-# INLINE readVkPTag #-} + readVkPTag p + = peekByteOff p #{offset VkDebugMarkerObjectTagInfoEXT, pTag} + + {-# INLINE writeVkPTag #-} + writeVkPTag p + = pokeByteOff p #{offset VkDebugMarkerObjectTagInfoEXT, pTag} + +instance {-# OVERLAPPING #-} + HasField "pTag" VkDebugMarkerObjectTagInfoEXT where + type FieldType "pTag" VkDebugMarkerObjectTagInfoEXT = Ptr Void + type FieldOptional "pTag" VkDebugMarkerObjectTagInfoEXT = 'False -- ' closing tick for hsc2hs + type FieldOffset "pTag" VkDebugMarkerObjectTagInfoEXT = + #{offset VkDebugMarkerObjectTagInfoEXT, pTag} + type FieldIsArray "pTag" VkDebugMarkerObjectTagInfoEXT = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDebugMarkerObjectTagInfoEXT, pTag} + +instance CanReadField "pTag" VkDebugMarkerObjectTagInfoEXT where + {-# INLINE getField #-} + getField = vkPTag + + {-# INLINE readField #-} + readField = readVkPTag + +instance CanWriteField "pTag" VkDebugMarkerObjectTagInfoEXT where + {-# INLINE writeField #-} + writeField = writeVkPTag + +instance Show VkDebugMarkerObjectTagInfoEXT where + showsPrec d x + = showString "VkDebugMarkerObjectTagInfoEXT {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkObjectType = " . + showsPrec d (vkObjectType x) . + showString ", " . + showString "vkObject = " . + showsPrec d (vkObject x) . + showString ", " . + showString "vkTagName = " . + showsPrec d (vkTagName x) . + showString ", " . + showString "vkTagSize = " . + showsPrec d (vkTagSize x) . + showString ", " . + showString "vkPTag = " . + showsPrec d (vkPTag x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkDebugReportCallbackCreateInfoEXT.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkDebugReportCallbackCreateInfoEXT.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkDebugReportCallbackCreateInfoEXT.hsc @@ -0,0 +1,368 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkDebugReportCallbackCreateInfoEXT + (VkDebugReportCallbackCreateInfoEXT(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkDebugReportFlagsEXT (VkDebugReportFlagsEXT) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Funcpointers (PFN_vkDebugReportCallbackEXT) +import Graphics.Vulkan.Types.Struct.VkInstanceCreateInfo (VkInstanceCreateInfo) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkDebugReportCallbackCreateInfoEXT { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkDebugReportFlagsEXT flags; +-- > PFN_vkDebugReportCallbackEXT pfnCallback; +-- > void* pUserData; +-- > } VkDebugReportCallbackCreateInfoEXT; +-- +-- +data VkDebugReportCallbackCreateInfoEXT = VkDebugReportCallbackCreateInfoEXT## Addr## + ByteArray## + +instance Eq VkDebugReportCallbackCreateInfoEXT where + (VkDebugReportCallbackCreateInfoEXT## a _) == + x@(VkDebugReportCallbackCreateInfoEXT## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkDebugReportCallbackCreateInfoEXT where + (VkDebugReportCallbackCreateInfoEXT## a _) `compare` + x@(VkDebugReportCallbackCreateInfoEXT## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkDebugReportCallbackCreateInfoEXT where + sizeOf ~_ = #{size VkDebugReportCallbackCreateInfoEXT} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkDebugReportCallbackCreateInfoEXT} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkDebugReportCallbackCreateInfoEXT where + unsafeAddr (VkDebugReportCallbackCreateInfoEXT## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkDebugReportCallbackCreateInfoEXT## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkDebugReportCallbackCreateInfoEXT## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkDebugReportCallbackCreateInfoEXT where + type StructFields VkDebugReportCallbackCreateInfoEXT = + '["sType", "pNext", "flags", "pfnCallback", "pUserData"] -- ' closing tick for hsc2hs + type CUnionType VkDebugReportCallbackCreateInfoEXT = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkDebugReportCallbackCreateInfoEXT = 'False -- ' closing tick for hsc2hs + type StructExtends VkDebugReportCallbackCreateInfoEXT = + '[VkInstanceCreateInfo] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkDebugReportCallbackCreateInfoEXT where + type VkSTypeMType VkDebugReportCallbackCreateInfoEXT = + VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDebugReportCallbackCreateInfoEXT, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkDebugReportCallbackCreateInfoEXT, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkDebugReportCallbackCreateInfoEXT, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkDebugReportCallbackCreateInfoEXT, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkDebugReportCallbackCreateInfoEXT where + type FieldType "sType" VkDebugReportCallbackCreateInfoEXT = + VkStructureType + type FieldOptional "sType" VkDebugReportCallbackCreateInfoEXT = + 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkDebugReportCallbackCreateInfoEXT = + #{offset VkDebugReportCallbackCreateInfoEXT, sType} + type FieldIsArray "sType" VkDebugReportCallbackCreateInfoEXT = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDebugReportCallbackCreateInfoEXT, sType} + +instance CanReadField "sType" VkDebugReportCallbackCreateInfoEXT + where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkDebugReportCallbackCreateInfoEXT + where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkDebugReportCallbackCreateInfoEXT where + type VkPNextMType VkDebugReportCallbackCreateInfoEXT = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDebugReportCallbackCreateInfoEXT, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkDebugReportCallbackCreateInfoEXT, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkDebugReportCallbackCreateInfoEXT, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkDebugReportCallbackCreateInfoEXT, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkDebugReportCallbackCreateInfoEXT where + type FieldType "pNext" VkDebugReportCallbackCreateInfoEXT = + Ptr Void + type FieldOptional "pNext" VkDebugReportCallbackCreateInfoEXT = + 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkDebugReportCallbackCreateInfoEXT = + #{offset VkDebugReportCallbackCreateInfoEXT, pNext} + type FieldIsArray "pNext" VkDebugReportCallbackCreateInfoEXT = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDebugReportCallbackCreateInfoEXT, pNext} + +instance CanReadField "pNext" VkDebugReportCallbackCreateInfoEXT + where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkDebugReportCallbackCreateInfoEXT + where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkFlags VkDebugReportCallbackCreateInfoEXT where + type VkFlagsMType VkDebugReportCallbackCreateInfoEXT = + VkDebugReportFlagsEXT + + {-# NOINLINE vkFlags #-} + vkFlags x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDebugReportCallbackCreateInfoEXT, flags}) + + {-# INLINE vkFlagsByteOffset #-} + vkFlagsByteOffset ~_ + = #{offset VkDebugReportCallbackCreateInfoEXT, flags} + + {-# INLINE readVkFlags #-} + readVkFlags p + = peekByteOff p #{offset VkDebugReportCallbackCreateInfoEXT, flags} + + {-# INLINE writeVkFlags #-} + writeVkFlags p + = pokeByteOff p #{offset VkDebugReportCallbackCreateInfoEXT, flags} + +instance {-# OVERLAPPING #-} + HasField "flags" VkDebugReportCallbackCreateInfoEXT where + type FieldType "flags" VkDebugReportCallbackCreateInfoEXT = + VkDebugReportFlagsEXT + type FieldOptional "flags" VkDebugReportCallbackCreateInfoEXT = + 'True -- ' closing tick for hsc2hs + type FieldOffset "flags" VkDebugReportCallbackCreateInfoEXT = + #{offset VkDebugReportCallbackCreateInfoEXT, flags} + type FieldIsArray "flags" VkDebugReportCallbackCreateInfoEXT = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDebugReportCallbackCreateInfoEXT, flags} + +instance CanReadField "flags" VkDebugReportCallbackCreateInfoEXT + where + {-# INLINE getField #-} + getField = vkFlags + + {-# INLINE readField #-} + readField = readVkFlags + +instance CanWriteField "flags" VkDebugReportCallbackCreateInfoEXT + where + {-# INLINE writeField #-} + writeField = writeVkFlags + +instance {-# OVERLAPPING #-} + HasVkPfnCallback VkDebugReportCallbackCreateInfoEXT where + type VkPfnCallbackMType VkDebugReportCallbackCreateInfoEXT = + PFN_vkDebugReportCallbackEXT + + {-# NOINLINE vkPfnCallback #-} + vkPfnCallback x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDebugReportCallbackCreateInfoEXT, pfnCallback}) + + {-# INLINE vkPfnCallbackByteOffset #-} + vkPfnCallbackByteOffset ~_ + = #{offset VkDebugReportCallbackCreateInfoEXT, pfnCallback} + + {-# INLINE readVkPfnCallback #-} + readVkPfnCallback p + = peekByteOff p #{offset VkDebugReportCallbackCreateInfoEXT, pfnCallback} + + {-# INLINE writeVkPfnCallback #-} + writeVkPfnCallback p + = pokeByteOff p #{offset VkDebugReportCallbackCreateInfoEXT, pfnCallback} + +instance {-# OVERLAPPING #-} + HasField "pfnCallback" VkDebugReportCallbackCreateInfoEXT where + type FieldType "pfnCallback" VkDebugReportCallbackCreateInfoEXT = + PFN_vkDebugReportCallbackEXT + type FieldOptional "pfnCallback" VkDebugReportCallbackCreateInfoEXT + = 'False -- ' closing tick for hsc2hs + type FieldOffset "pfnCallback" VkDebugReportCallbackCreateInfoEXT = + #{offset VkDebugReportCallbackCreateInfoEXT, pfnCallback} + type FieldIsArray "pfnCallback" VkDebugReportCallbackCreateInfoEXT + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDebugReportCallbackCreateInfoEXT, pfnCallback} + +instance CanReadField "pfnCallback" + VkDebugReportCallbackCreateInfoEXT + where + {-# INLINE getField #-} + getField = vkPfnCallback + + {-# INLINE readField #-} + readField = readVkPfnCallback + +instance CanWriteField "pfnCallback" + VkDebugReportCallbackCreateInfoEXT + where + {-# INLINE writeField #-} + writeField = writeVkPfnCallback + +instance {-# OVERLAPPING #-} + HasVkPUserData VkDebugReportCallbackCreateInfoEXT where + type VkPUserDataMType VkDebugReportCallbackCreateInfoEXT = Ptr Void + + {-# NOINLINE vkPUserData #-} + vkPUserData x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDebugReportCallbackCreateInfoEXT, pUserData}) + + {-# INLINE vkPUserDataByteOffset #-} + vkPUserDataByteOffset ~_ + = #{offset VkDebugReportCallbackCreateInfoEXT, pUserData} + + {-# INLINE readVkPUserData #-} + readVkPUserData p + = peekByteOff p #{offset VkDebugReportCallbackCreateInfoEXT, pUserData} + + {-# INLINE writeVkPUserData #-} + writeVkPUserData p + = pokeByteOff p #{offset VkDebugReportCallbackCreateInfoEXT, pUserData} + +instance {-# OVERLAPPING #-} + HasField "pUserData" VkDebugReportCallbackCreateInfoEXT where + type FieldType "pUserData" VkDebugReportCallbackCreateInfoEXT = + Ptr Void + type FieldOptional "pUserData" VkDebugReportCallbackCreateInfoEXT = + 'True -- ' closing tick for hsc2hs + type FieldOffset "pUserData" VkDebugReportCallbackCreateInfoEXT = + #{offset VkDebugReportCallbackCreateInfoEXT, pUserData} + type FieldIsArray "pUserData" VkDebugReportCallbackCreateInfoEXT = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDebugReportCallbackCreateInfoEXT, pUserData} + +instance CanReadField "pUserData" + VkDebugReportCallbackCreateInfoEXT + where + {-# INLINE getField #-} + getField = vkPUserData + + {-# INLINE readField #-} + readField = readVkPUserData + +instance CanWriteField "pUserData" + VkDebugReportCallbackCreateInfoEXT + where + {-# INLINE writeField #-} + writeField = writeVkPUserData + +instance Show VkDebugReportCallbackCreateInfoEXT where + showsPrec d x + = showString "VkDebugReportCallbackCreateInfoEXT {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkFlags = " . + showsPrec d (vkFlags x) . + showString ", " . + showString "vkPfnCallback = " . + showsPrec d (vkPfnCallback x) . + showString ", " . + showString "vkPUserData = " . + showsPrec d (vkPUserData x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkDedicatedAllocationBufferCreateInfoNV.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkDedicatedAllocationBufferCreateInfoNV.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkDedicatedAllocationBufferCreateInfoNV.hsc @@ -0,0 +1,269 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkDedicatedAllocationBufferCreateInfoNV + (VkDedicatedAllocationBufferCreateInfoNV(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.BaseTypes (VkBool32) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Struct.VkBufferCreateInfo (VkBufferCreateInfo) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkDedicatedAllocationBufferCreateInfoNV { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkBool32 dedicatedAllocation; +-- > } VkDedicatedAllocationBufferCreateInfoNV; +-- +-- +data VkDedicatedAllocationBufferCreateInfoNV = VkDedicatedAllocationBufferCreateInfoNV## Addr## + ByteArray## + +instance Eq VkDedicatedAllocationBufferCreateInfoNV where + (VkDedicatedAllocationBufferCreateInfoNV## a _) == + x@(VkDedicatedAllocationBufferCreateInfoNV## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkDedicatedAllocationBufferCreateInfoNV where + (VkDedicatedAllocationBufferCreateInfoNV## a _) `compare` + x@(VkDedicatedAllocationBufferCreateInfoNV## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkDedicatedAllocationBufferCreateInfoNV where + sizeOf ~_ + = #{size VkDedicatedAllocationBufferCreateInfoNV} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkDedicatedAllocationBufferCreateInfoNV} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkDedicatedAllocationBufferCreateInfoNV + where + unsafeAddr (VkDedicatedAllocationBufferCreateInfoNV## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkDedicatedAllocationBufferCreateInfoNV## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkDedicatedAllocationBufferCreateInfoNV## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkDedicatedAllocationBufferCreateInfoNV + where + type StructFields VkDedicatedAllocationBufferCreateInfoNV = + '["sType", "pNext", "dedicatedAllocation"] -- ' closing tick for hsc2hs + type CUnionType VkDedicatedAllocationBufferCreateInfoNV = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkDedicatedAllocationBufferCreateInfoNV = 'False -- ' closing tick for hsc2hs + type StructExtends VkDedicatedAllocationBufferCreateInfoNV = + '[VkBufferCreateInfo] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkDedicatedAllocationBufferCreateInfoNV where + type VkSTypeMType VkDedicatedAllocationBufferCreateInfoNV = + VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDedicatedAllocationBufferCreateInfoNV, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkDedicatedAllocationBufferCreateInfoNV, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkDedicatedAllocationBufferCreateInfoNV, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkDedicatedAllocationBufferCreateInfoNV, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkDedicatedAllocationBufferCreateInfoNV where + type FieldType "sType" VkDedicatedAllocationBufferCreateInfoNV = + VkStructureType + type FieldOptional "sType" VkDedicatedAllocationBufferCreateInfoNV + = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkDedicatedAllocationBufferCreateInfoNV = + #{offset VkDedicatedAllocationBufferCreateInfoNV, sType} + type FieldIsArray "sType" VkDedicatedAllocationBufferCreateInfoNV = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDedicatedAllocationBufferCreateInfoNV, sType} + +instance CanReadField "sType" + VkDedicatedAllocationBufferCreateInfoNV + where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" + VkDedicatedAllocationBufferCreateInfoNV + where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkDedicatedAllocationBufferCreateInfoNV where + type VkPNextMType VkDedicatedAllocationBufferCreateInfoNV = + Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDedicatedAllocationBufferCreateInfoNV, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkDedicatedAllocationBufferCreateInfoNV, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkDedicatedAllocationBufferCreateInfoNV, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkDedicatedAllocationBufferCreateInfoNV, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkDedicatedAllocationBufferCreateInfoNV where + type FieldType "pNext" VkDedicatedAllocationBufferCreateInfoNV = + Ptr Void + type FieldOptional "pNext" VkDedicatedAllocationBufferCreateInfoNV + = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkDedicatedAllocationBufferCreateInfoNV = + #{offset VkDedicatedAllocationBufferCreateInfoNV, pNext} + type FieldIsArray "pNext" VkDedicatedAllocationBufferCreateInfoNV = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDedicatedAllocationBufferCreateInfoNV, pNext} + +instance CanReadField "pNext" + VkDedicatedAllocationBufferCreateInfoNV + where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" + VkDedicatedAllocationBufferCreateInfoNV + where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkDedicatedAllocation VkDedicatedAllocationBufferCreateInfoNV + where + type VkDedicatedAllocationMType + VkDedicatedAllocationBufferCreateInfoNV + = VkBool32 + + {-# NOINLINE vkDedicatedAllocation #-} + vkDedicatedAllocation x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDedicatedAllocationBufferCreateInfoNV, dedicatedAllocation}) + + {-# INLINE vkDedicatedAllocationByteOffset #-} + vkDedicatedAllocationByteOffset ~_ + = #{offset VkDedicatedAllocationBufferCreateInfoNV, dedicatedAllocation} + + {-# INLINE readVkDedicatedAllocation #-} + readVkDedicatedAllocation p + = peekByteOff p #{offset VkDedicatedAllocationBufferCreateInfoNV, dedicatedAllocation} + + {-# INLINE writeVkDedicatedAllocation #-} + writeVkDedicatedAllocation p + = pokeByteOff p #{offset VkDedicatedAllocationBufferCreateInfoNV, dedicatedAllocation} + +instance {-# OVERLAPPING #-} + HasField "dedicatedAllocation" + VkDedicatedAllocationBufferCreateInfoNV + where + type FieldType "dedicatedAllocation" + VkDedicatedAllocationBufferCreateInfoNV + = VkBool32 + type FieldOptional "dedicatedAllocation" + VkDedicatedAllocationBufferCreateInfoNV + = 'False -- ' closing tick for hsc2hs + type FieldOffset "dedicatedAllocation" + VkDedicatedAllocationBufferCreateInfoNV + = + #{offset VkDedicatedAllocationBufferCreateInfoNV, dedicatedAllocation} + type FieldIsArray "dedicatedAllocation" + VkDedicatedAllocationBufferCreateInfoNV + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDedicatedAllocationBufferCreateInfoNV, dedicatedAllocation} + +instance CanReadField "dedicatedAllocation" + VkDedicatedAllocationBufferCreateInfoNV + where + {-# INLINE getField #-} + getField = vkDedicatedAllocation + + {-# INLINE readField #-} + readField = readVkDedicatedAllocation + +instance CanWriteField "dedicatedAllocation" + VkDedicatedAllocationBufferCreateInfoNV + where + {-# INLINE writeField #-} + writeField = writeVkDedicatedAllocation + +instance Show VkDedicatedAllocationBufferCreateInfoNV where + showsPrec d x + = showString "VkDedicatedAllocationBufferCreateInfoNV {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkDedicatedAllocation = " . + showsPrec d (vkDedicatedAllocation x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkDedicatedAllocationImageCreateInfoNV.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkDedicatedAllocationImageCreateInfoNV.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkDedicatedAllocationImageCreateInfoNV.hsc @@ -0,0 +1,267 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkDedicatedAllocationImageCreateInfoNV + (VkDedicatedAllocationImageCreateInfoNV(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.BaseTypes (VkBool32) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Struct.VkImageCreateInfo (VkImageCreateInfo) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkDedicatedAllocationImageCreateInfoNV { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkBool32 dedicatedAllocation; +-- > } VkDedicatedAllocationImageCreateInfoNV; +-- +-- +data VkDedicatedAllocationImageCreateInfoNV = VkDedicatedAllocationImageCreateInfoNV## Addr## + ByteArray## + +instance Eq VkDedicatedAllocationImageCreateInfoNV where + (VkDedicatedAllocationImageCreateInfoNV## a _) == + x@(VkDedicatedAllocationImageCreateInfoNV## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkDedicatedAllocationImageCreateInfoNV where + (VkDedicatedAllocationImageCreateInfoNV## a _) `compare` + x@(VkDedicatedAllocationImageCreateInfoNV## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkDedicatedAllocationImageCreateInfoNV where + sizeOf ~_ + = #{size VkDedicatedAllocationImageCreateInfoNV} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkDedicatedAllocationImageCreateInfoNV} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkDedicatedAllocationImageCreateInfoNV + where + unsafeAddr (VkDedicatedAllocationImageCreateInfoNV## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkDedicatedAllocationImageCreateInfoNV## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkDedicatedAllocationImageCreateInfoNV## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkDedicatedAllocationImageCreateInfoNV where + type StructFields VkDedicatedAllocationImageCreateInfoNV = + '["sType", "pNext", "dedicatedAllocation"] -- ' closing tick for hsc2hs + type CUnionType VkDedicatedAllocationImageCreateInfoNV = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkDedicatedAllocationImageCreateInfoNV = 'False -- ' closing tick for hsc2hs + type StructExtends VkDedicatedAllocationImageCreateInfoNV = + '[VkImageCreateInfo] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkDedicatedAllocationImageCreateInfoNV where + type VkSTypeMType VkDedicatedAllocationImageCreateInfoNV = + VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDedicatedAllocationImageCreateInfoNV, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkDedicatedAllocationImageCreateInfoNV, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkDedicatedAllocationImageCreateInfoNV, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkDedicatedAllocationImageCreateInfoNV, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkDedicatedAllocationImageCreateInfoNV where + type FieldType "sType" VkDedicatedAllocationImageCreateInfoNV = + VkStructureType + type FieldOptional "sType" VkDedicatedAllocationImageCreateInfoNV = + 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkDedicatedAllocationImageCreateInfoNV = + #{offset VkDedicatedAllocationImageCreateInfoNV, sType} + type FieldIsArray "sType" VkDedicatedAllocationImageCreateInfoNV = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDedicatedAllocationImageCreateInfoNV, sType} + +instance CanReadField "sType" + VkDedicatedAllocationImageCreateInfoNV + where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" + VkDedicatedAllocationImageCreateInfoNV + where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkDedicatedAllocationImageCreateInfoNV where + type VkPNextMType VkDedicatedAllocationImageCreateInfoNV = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDedicatedAllocationImageCreateInfoNV, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkDedicatedAllocationImageCreateInfoNV, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkDedicatedAllocationImageCreateInfoNV, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkDedicatedAllocationImageCreateInfoNV, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkDedicatedAllocationImageCreateInfoNV where + type FieldType "pNext" VkDedicatedAllocationImageCreateInfoNV = + Ptr Void + type FieldOptional "pNext" VkDedicatedAllocationImageCreateInfoNV = + 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkDedicatedAllocationImageCreateInfoNV = + #{offset VkDedicatedAllocationImageCreateInfoNV, pNext} + type FieldIsArray "pNext" VkDedicatedAllocationImageCreateInfoNV = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDedicatedAllocationImageCreateInfoNV, pNext} + +instance CanReadField "pNext" + VkDedicatedAllocationImageCreateInfoNV + where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" + VkDedicatedAllocationImageCreateInfoNV + where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkDedicatedAllocation VkDedicatedAllocationImageCreateInfoNV + where + type VkDedicatedAllocationMType + VkDedicatedAllocationImageCreateInfoNV + = VkBool32 + + {-# NOINLINE vkDedicatedAllocation #-} + vkDedicatedAllocation x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDedicatedAllocationImageCreateInfoNV, dedicatedAllocation}) + + {-# INLINE vkDedicatedAllocationByteOffset #-} + vkDedicatedAllocationByteOffset ~_ + = #{offset VkDedicatedAllocationImageCreateInfoNV, dedicatedAllocation} + + {-# INLINE readVkDedicatedAllocation #-} + readVkDedicatedAllocation p + = peekByteOff p #{offset VkDedicatedAllocationImageCreateInfoNV, dedicatedAllocation} + + {-# INLINE writeVkDedicatedAllocation #-} + writeVkDedicatedAllocation p + = pokeByteOff p #{offset VkDedicatedAllocationImageCreateInfoNV, dedicatedAllocation} + +instance {-# OVERLAPPING #-} + HasField "dedicatedAllocation" + VkDedicatedAllocationImageCreateInfoNV + where + type FieldType "dedicatedAllocation" + VkDedicatedAllocationImageCreateInfoNV + = VkBool32 + type FieldOptional "dedicatedAllocation" + VkDedicatedAllocationImageCreateInfoNV + = 'False -- ' closing tick for hsc2hs + type FieldOffset "dedicatedAllocation" + VkDedicatedAllocationImageCreateInfoNV + = + #{offset VkDedicatedAllocationImageCreateInfoNV, dedicatedAllocation} + type FieldIsArray "dedicatedAllocation" + VkDedicatedAllocationImageCreateInfoNV + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDedicatedAllocationImageCreateInfoNV, dedicatedAllocation} + +instance CanReadField "dedicatedAllocation" + VkDedicatedAllocationImageCreateInfoNV + where + {-# INLINE getField #-} + getField = vkDedicatedAllocation + + {-# INLINE readField #-} + readField = readVkDedicatedAllocation + +instance CanWriteField "dedicatedAllocation" + VkDedicatedAllocationImageCreateInfoNV + where + {-# INLINE writeField #-} + writeField = writeVkDedicatedAllocation + +instance Show VkDedicatedAllocationImageCreateInfoNV where + showsPrec d x + = showString "VkDedicatedAllocationImageCreateInfoNV {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkDedicatedAllocation = " . + showsPrec d (vkDedicatedAllocation x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkDedicatedAllocationMemoryAllocateInfoNV.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkDedicatedAllocationMemoryAllocateInfoNV.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkDedicatedAllocationMemoryAllocateInfoNV.hsc @@ -0,0 +1,331 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkDedicatedAllocationMemoryAllocateInfoNV + (VkDedicatedAllocationMemoryAllocateInfoNV(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Handles (VkBuffer, + VkImage) +import Graphics.Vulkan.Types.Struct.VkMemoryAllocateInfo (VkMemoryAllocateInfo) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkDedicatedAllocationMemoryAllocateInfoNV { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkImage image; +-- > VkBuffer buffer; +-- > } VkDedicatedAllocationMemoryAllocateInfoNV; +-- +-- +data VkDedicatedAllocationMemoryAllocateInfoNV = VkDedicatedAllocationMemoryAllocateInfoNV## Addr## + ByteArray## + +instance Eq VkDedicatedAllocationMemoryAllocateInfoNV where + (VkDedicatedAllocationMemoryAllocateInfoNV## a _) == + x@(VkDedicatedAllocationMemoryAllocateInfoNV## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkDedicatedAllocationMemoryAllocateInfoNV where + (VkDedicatedAllocationMemoryAllocateInfoNV## a _) `compare` + x@(VkDedicatedAllocationMemoryAllocateInfoNV## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkDedicatedAllocationMemoryAllocateInfoNV where + sizeOf ~_ + = #{size VkDedicatedAllocationMemoryAllocateInfoNV} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkDedicatedAllocationMemoryAllocateInfoNV} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim + VkDedicatedAllocationMemoryAllocateInfoNV + where + unsafeAddr (VkDedicatedAllocationMemoryAllocateInfoNV## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkDedicatedAllocationMemoryAllocateInfoNV## _ b) + = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkDedicatedAllocationMemoryAllocateInfoNV## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkDedicatedAllocationMemoryAllocateInfoNV + where + type StructFields VkDedicatedAllocationMemoryAllocateInfoNV = + '["sType", "pNext", "image", "buffer"] -- ' closing tick for hsc2hs + type CUnionType VkDedicatedAllocationMemoryAllocateInfoNV = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkDedicatedAllocationMemoryAllocateInfoNV = + 'False -- ' closing tick for hsc2hs + type StructExtends VkDedicatedAllocationMemoryAllocateInfoNV = + '[VkMemoryAllocateInfo] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkDedicatedAllocationMemoryAllocateInfoNV where + type VkSTypeMType VkDedicatedAllocationMemoryAllocateInfoNV = + VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDedicatedAllocationMemoryAllocateInfoNV, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkDedicatedAllocationMemoryAllocateInfoNV, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkDedicatedAllocationMemoryAllocateInfoNV, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkDedicatedAllocationMemoryAllocateInfoNV, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkDedicatedAllocationMemoryAllocateInfoNV where + type FieldType "sType" VkDedicatedAllocationMemoryAllocateInfoNV = + VkStructureType + type FieldOptional "sType" + VkDedicatedAllocationMemoryAllocateInfoNV + = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkDedicatedAllocationMemoryAllocateInfoNV + = + #{offset VkDedicatedAllocationMemoryAllocateInfoNV, sType} + type FieldIsArray "sType" VkDedicatedAllocationMemoryAllocateInfoNV + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDedicatedAllocationMemoryAllocateInfoNV, sType} + +instance CanReadField "sType" + VkDedicatedAllocationMemoryAllocateInfoNV + where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" + VkDedicatedAllocationMemoryAllocateInfoNV + where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkDedicatedAllocationMemoryAllocateInfoNV where + type VkPNextMType VkDedicatedAllocationMemoryAllocateInfoNV = + Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDedicatedAllocationMemoryAllocateInfoNV, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkDedicatedAllocationMemoryAllocateInfoNV, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkDedicatedAllocationMemoryAllocateInfoNV, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkDedicatedAllocationMemoryAllocateInfoNV, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkDedicatedAllocationMemoryAllocateInfoNV where + type FieldType "pNext" VkDedicatedAllocationMemoryAllocateInfoNV = + Ptr Void + type FieldOptional "pNext" + VkDedicatedAllocationMemoryAllocateInfoNV + = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkDedicatedAllocationMemoryAllocateInfoNV + = + #{offset VkDedicatedAllocationMemoryAllocateInfoNV, pNext} + type FieldIsArray "pNext" VkDedicatedAllocationMemoryAllocateInfoNV + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDedicatedAllocationMemoryAllocateInfoNV, pNext} + +instance CanReadField "pNext" + VkDedicatedAllocationMemoryAllocateInfoNV + where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" + VkDedicatedAllocationMemoryAllocateInfoNV + where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkImage VkDedicatedAllocationMemoryAllocateInfoNV where + type VkImageMType VkDedicatedAllocationMemoryAllocateInfoNV = + VkImage + + {-# NOINLINE vkImage #-} + vkImage x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDedicatedAllocationMemoryAllocateInfoNV, image}) + + {-# INLINE vkImageByteOffset #-} + vkImageByteOffset ~_ + = #{offset VkDedicatedAllocationMemoryAllocateInfoNV, image} + + {-# INLINE readVkImage #-} + readVkImage p + = peekByteOff p #{offset VkDedicatedAllocationMemoryAllocateInfoNV, image} + + {-# INLINE writeVkImage #-} + writeVkImage p + = pokeByteOff p #{offset VkDedicatedAllocationMemoryAllocateInfoNV, image} + +instance {-# OVERLAPPING #-} + HasField "image" VkDedicatedAllocationMemoryAllocateInfoNV where + type FieldType "image" VkDedicatedAllocationMemoryAllocateInfoNV = + VkImage + type FieldOptional "image" + VkDedicatedAllocationMemoryAllocateInfoNV + = 'True -- ' closing tick for hsc2hs + type FieldOffset "image" VkDedicatedAllocationMemoryAllocateInfoNV + = + #{offset VkDedicatedAllocationMemoryAllocateInfoNV, image} + type FieldIsArray "image" VkDedicatedAllocationMemoryAllocateInfoNV + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDedicatedAllocationMemoryAllocateInfoNV, image} + +instance CanReadField "image" + VkDedicatedAllocationMemoryAllocateInfoNV + where + {-# INLINE getField #-} + getField = vkImage + + {-# INLINE readField #-} + readField = readVkImage + +instance CanWriteField "image" + VkDedicatedAllocationMemoryAllocateInfoNV + where + {-# INLINE writeField #-} + writeField = writeVkImage + +instance {-# OVERLAPPING #-} + HasVkBuffer VkDedicatedAllocationMemoryAllocateInfoNV where + type VkBufferMType VkDedicatedAllocationMemoryAllocateInfoNV = + VkBuffer + + {-# NOINLINE vkBuffer #-} + vkBuffer x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDedicatedAllocationMemoryAllocateInfoNV, buffer}) + + {-# INLINE vkBufferByteOffset #-} + vkBufferByteOffset ~_ + = #{offset VkDedicatedAllocationMemoryAllocateInfoNV, buffer} + + {-# INLINE readVkBuffer #-} + readVkBuffer p + = peekByteOff p #{offset VkDedicatedAllocationMemoryAllocateInfoNV, buffer} + + {-# INLINE writeVkBuffer #-} + writeVkBuffer p + = pokeByteOff p #{offset VkDedicatedAllocationMemoryAllocateInfoNV, buffer} + +instance {-# OVERLAPPING #-} + HasField "buffer" VkDedicatedAllocationMemoryAllocateInfoNV where + type FieldType "buffer" VkDedicatedAllocationMemoryAllocateInfoNV = + VkBuffer + type FieldOptional "buffer" + VkDedicatedAllocationMemoryAllocateInfoNV + = 'True -- ' closing tick for hsc2hs + type FieldOffset "buffer" VkDedicatedAllocationMemoryAllocateInfoNV + = + #{offset VkDedicatedAllocationMemoryAllocateInfoNV, buffer} + type FieldIsArray "buffer" + VkDedicatedAllocationMemoryAllocateInfoNV + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDedicatedAllocationMemoryAllocateInfoNV, buffer} + +instance CanReadField "buffer" + VkDedicatedAllocationMemoryAllocateInfoNV + where + {-# INLINE getField #-} + getField = vkBuffer + + {-# INLINE readField #-} + readField = readVkBuffer + +instance CanWriteField "buffer" + VkDedicatedAllocationMemoryAllocateInfoNV + where + {-# INLINE writeField #-} + writeField = writeVkBuffer + +instance Show VkDedicatedAllocationMemoryAllocateInfoNV where + showsPrec d x + = showString "VkDedicatedAllocationMemoryAllocateInfoNV {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkImage = " . + showsPrec d (vkImage x) . + showString ", " . + showString "vkBuffer = " . showsPrec d (vkBuffer x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkDescriptorBufferInfo.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkDescriptorBufferInfo.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkDescriptorBufferInfo.hsc @@ -0,0 +1,222 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkDescriptorBufferInfo + (VkDescriptorBufferInfo(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.BaseTypes (VkDeviceSize) +import Graphics.Vulkan.Types.Handles (VkBuffer) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkDescriptorBufferInfo { +-- > VkBuffer buffer; +-- > VkDeviceSize offset; +-- > VkDeviceSize range; +-- > } VkDescriptorBufferInfo; +-- +-- +data VkDescriptorBufferInfo = VkDescriptorBufferInfo## Addr## + ByteArray## + +instance Eq VkDescriptorBufferInfo where + (VkDescriptorBufferInfo## a _) == x@(VkDescriptorBufferInfo## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkDescriptorBufferInfo where + (VkDescriptorBufferInfo## a _) `compare` + x@(VkDescriptorBufferInfo## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkDescriptorBufferInfo where + sizeOf ~_ = #{size VkDescriptorBufferInfo} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkDescriptorBufferInfo} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkDescriptorBufferInfo where + unsafeAddr (VkDescriptorBufferInfo## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkDescriptorBufferInfo## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkDescriptorBufferInfo## (plusAddr## (byteArrayContents## b) off) b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkDescriptorBufferInfo where + type StructFields VkDescriptorBufferInfo = + '["buffer", "offset", "range"] -- ' closing tick for hsc2hs + type CUnionType VkDescriptorBufferInfo = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkDescriptorBufferInfo = 'False -- ' closing tick for hsc2hs + type StructExtends VkDescriptorBufferInfo = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkBuffer VkDescriptorBufferInfo + where + type VkBufferMType VkDescriptorBufferInfo = VkBuffer + + {-# NOINLINE vkBuffer #-} + vkBuffer x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDescriptorBufferInfo, buffer}) + + {-# INLINE vkBufferByteOffset #-} + vkBufferByteOffset ~_ + = #{offset VkDescriptorBufferInfo, buffer} + + {-# INLINE readVkBuffer #-} + readVkBuffer p + = peekByteOff p #{offset VkDescriptorBufferInfo, buffer} + + {-# INLINE writeVkBuffer #-} + writeVkBuffer p + = pokeByteOff p #{offset VkDescriptorBufferInfo, buffer} + +instance {-# OVERLAPPING #-} + HasField "buffer" VkDescriptorBufferInfo where + type FieldType "buffer" VkDescriptorBufferInfo = VkBuffer + type FieldOptional "buffer" VkDescriptorBufferInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "buffer" VkDescriptorBufferInfo = + #{offset VkDescriptorBufferInfo, buffer} + type FieldIsArray "buffer" VkDescriptorBufferInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkDescriptorBufferInfo, buffer} + +instance CanReadField "buffer" VkDescriptorBufferInfo where + {-# INLINE getField #-} + getField = vkBuffer + + {-# INLINE readField #-} + readField = readVkBuffer + +instance CanWriteField "buffer" VkDescriptorBufferInfo where + {-# INLINE writeField #-} + writeField = writeVkBuffer + +instance {-# OVERLAPPING #-} HasVkOffset VkDescriptorBufferInfo + where + type VkOffsetMType VkDescriptorBufferInfo = VkDeviceSize + + {-# NOINLINE vkOffset #-} + vkOffset x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDescriptorBufferInfo, offset}) + + {-# INLINE vkOffsetByteOffset #-} + vkOffsetByteOffset ~_ + = #{offset VkDescriptorBufferInfo, offset} + + {-# INLINE readVkOffset #-} + readVkOffset p + = peekByteOff p #{offset VkDescriptorBufferInfo, offset} + + {-# INLINE writeVkOffset #-} + writeVkOffset p + = pokeByteOff p #{offset VkDescriptorBufferInfo, offset} + +instance {-# OVERLAPPING #-} + HasField "offset" VkDescriptorBufferInfo where + type FieldType "offset" VkDescriptorBufferInfo = VkDeviceSize + type FieldOptional "offset" VkDescriptorBufferInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "offset" VkDescriptorBufferInfo = + #{offset VkDescriptorBufferInfo, offset} + type FieldIsArray "offset" VkDescriptorBufferInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkDescriptorBufferInfo, offset} + +instance CanReadField "offset" VkDescriptorBufferInfo where + {-# INLINE getField #-} + getField = vkOffset + + {-# INLINE readField #-} + readField = readVkOffset + +instance CanWriteField "offset" VkDescriptorBufferInfo where + {-# INLINE writeField #-} + writeField = writeVkOffset + +instance {-# OVERLAPPING #-} HasVkRange VkDescriptorBufferInfo + where + type VkRangeMType VkDescriptorBufferInfo = VkDeviceSize + + {-# NOINLINE vkRange #-} + vkRange x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDescriptorBufferInfo, range}) + + {-# INLINE vkRangeByteOffset #-} + vkRangeByteOffset ~_ + = #{offset VkDescriptorBufferInfo, range} + + {-# INLINE readVkRange #-} + readVkRange p + = peekByteOff p #{offset VkDescriptorBufferInfo, range} + + {-# INLINE writeVkRange #-} + writeVkRange p + = pokeByteOff p #{offset VkDescriptorBufferInfo, range} + +instance {-# OVERLAPPING #-} + HasField "range" VkDescriptorBufferInfo where + type FieldType "range" VkDescriptorBufferInfo = VkDeviceSize + type FieldOptional "range" VkDescriptorBufferInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "range" VkDescriptorBufferInfo = + #{offset VkDescriptorBufferInfo, range} + type FieldIsArray "range" VkDescriptorBufferInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkDescriptorBufferInfo, range} + +instance CanReadField "range" VkDescriptorBufferInfo where + {-# INLINE getField #-} + getField = vkRange + + {-# INLINE readField #-} + readField = readVkRange + +instance CanWriteField "range" VkDescriptorBufferInfo where + {-# INLINE writeField #-} + writeField = writeVkRange + +instance Show VkDescriptorBufferInfo where + showsPrec d x + = showString "VkDescriptorBufferInfo {" . + showString "vkBuffer = " . + showsPrec d (vkBuffer x) . + showString ", " . + showString "vkOffset = " . + showsPrec d (vkOffset x) . + showString ", " . + showString "vkRange = " . showsPrec d (vkRange x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkDescriptorImageInfo.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkDescriptorImageInfo.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkDescriptorImageInfo.hsc @@ -0,0 +1,226 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkDescriptorImageInfo + (VkDescriptorImageInfo(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkImageLayout (VkImageLayout) +import Graphics.Vulkan.Types.Handles (VkImageView, + VkSampler) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkDescriptorImageInfo { +-- > VkSampler sampler; +-- > VkImageView imageView; +-- > VkImageLayout imageLayout; +-- > } VkDescriptorImageInfo; +-- +-- +data VkDescriptorImageInfo = VkDescriptorImageInfo## Addr## + ByteArray## + +instance Eq VkDescriptorImageInfo where + (VkDescriptorImageInfo## a _) == x@(VkDescriptorImageInfo## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkDescriptorImageInfo where + (VkDescriptorImageInfo## a _) `compare` + x@(VkDescriptorImageInfo## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkDescriptorImageInfo where + sizeOf ~_ = #{size VkDescriptorImageInfo} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkDescriptorImageInfo} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkDescriptorImageInfo where + unsafeAddr (VkDescriptorImageInfo## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkDescriptorImageInfo## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkDescriptorImageInfo## (plusAddr## (byteArrayContents## b) off) b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkDescriptorImageInfo where + type StructFields VkDescriptorImageInfo = + '["sampler", "imageView", "imageLayout"] -- ' closing tick for hsc2hs + type CUnionType VkDescriptorImageInfo = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkDescriptorImageInfo = 'False -- ' closing tick for hsc2hs + type StructExtends VkDescriptorImageInfo = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkSampler VkDescriptorImageInfo + where + type VkSamplerMType VkDescriptorImageInfo = VkSampler + + {-# NOINLINE vkSampler #-} + vkSampler x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDescriptorImageInfo, sampler}) + + {-# INLINE vkSamplerByteOffset #-} + vkSamplerByteOffset ~_ + = #{offset VkDescriptorImageInfo, sampler} + + {-# INLINE readVkSampler #-} + readVkSampler p + = peekByteOff p #{offset VkDescriptorImageInfo, sampler} + + {-# INLINE writeVkSampler #-} + writeVkSampler p + = pokeByteOff p #{offset VkDescriptorImageInfo, sampler} + +instance {-# OVERLAPPING #-} + HasField "sampler" VkDescriptorImageInfo where + type FieldType "sampler" VkDescriptorImageInfo = VkSampler + type FieldOptional "sampler" VkDescriptorImageInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "sampler" VkDescriptorImageInfo = + #{offset VkDescriptorImageInfo, sampler} + type FieldIsArray "sampler" VkDescriptorImageInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkDescriptorImageInfo, sampler} + +instance CanReadField "sampler" VkDescriptorImageInfo where + {-# INLINE getField #-} + getField = vkSampler + + {-# INLINE readField #-} + readField = readVkSampler + +instance CanWriteField "sampler" VkDescriptorImageInfo where + {-# INLINE writeField #-} + writeField = writeVkSampler + +instance {-# OVERLAPPING #-} HasVkImageView VkDescriptorImageInfo + where + type VkImageViewMType VkDescriptorImageInfo = VkImageView + + {-# NOINLINE vkImageView #-} + vkImageView x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDescriptorImageInfo, imageView}) + + {-# INLINE vkImageViewByteOffset #-} + vkImageViewByteOffset ~_ + = #{offset VkDescriptorImageInfo, imageView} + + {-# INLINE readVkImageView #-} + readVkImageView p + = peekByteOff p #{offset VkDescriptorImageInfo, imageView} + + {-# INLINE writeVkImageView #-} + writeVkImageView p + = pokeByteOff p #{offset VkDescriptorImageInfo, imageView} + +instance {-# OVERLAPPING #-} + HasField "imageView" VkDescriptorImageInfo where + type FieldType "imageView" VkDescriptorImageInfo = VkImageView + type FieldOptional "imageView" VkDescriptorImageInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "imageView" VkDescriptorImageInfo = + #{offset VkDescriptorImageInfo, imageView} + type FieldIsArray "imageView" VkDescriptorImageInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDescriptorImageInfo, imageView} + +instance CanReadField "imageView" VkDescriptorImageInfo where + {-# INLINE getField #-} + getField = vkImageView + + {-# INLINE readField #-} + readField = readVkImageView + +instance CanWriteField "imageView" VkDescriptorImageInfo where + {-# INLINE writeField #-} + writeField = writeVkImageView + +instance {-# OVERLAPPING #-} HasVkImageLayout VkDescriptorImageInfo + where + type VkImageLayoutMType VkDescriptorImageInfo = VkImageLayout + + {-# NOINLINE vkImageLayout #-} + vkImageLayout x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDescriptorImageInfo, imageLayout}) + + {-# INLINE vkImageLayoutByteOffset #-} + vkImageLayoutByteOffset ~_ + = #{offset VkDescriptorImageInfo, imageLayout} + + {-# INLINE readVkImageLayout #-} + readVkImageLayout p + = peekByteOff p #{offset VkDescriptorImageInfo, imageLayout} + + {-# INLINE writeVkImageLayout #-} + writeVkImageLayout p + = pokeByteOff p #{offset VkDescriptorImageInfo, imageLayout} + +instance {-# OVERLAPPING #-} + HasField "imageLayout" VkDescriptorImageInfo where + type FieldType "imageLayout" VkDescriptorImageInfo = VkImageLayout + type FieldOptional "imageLayout" VkDescriptorImageInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "imageLayout" VkDescriptorImageInfo = + #{offset VkDescriptorImageInfo, imageLayout} + type FieldIsArray "imageLayout" VkDescriptorImageInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDescriptorImageInfo, imageLayout} + +instance CanReadField "imageLayout" VkDescriptorImageInfo where + {-# INLINE getField #-} + getField = vkImageLayout + + {-# INLINE readField #-} + readField = readVkImageLayout + +instance CanWriteField "imageLayout" VkDescriptorImageInfo where + {-# INLINE writeField #-} + writeField = writeVkImageLayout + +instance Show VkDescriptorImageInfo where + showsPrec d x + = showString "VkDescriptorImageInfo {" . + showString "vkSampler = " . + showsPrec d (vkSampler x) . + showString ", " . + showString "vkImageView = " . + showsPrec d (vkImageView x) . + showString ", " . + showString "vkImageLayout = " . + showsPrec d (vkImageLayout x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkDescriptorPoolCreateInfo.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkDescriptorPoolCreateInfo.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkDescriptorPoolCreateInfo.hsc @@ -0,0 +1,393 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkDescriptorPoolCreateInfo + (VkDescriptorPoolCreateInfo(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkDescriptorPoolCreateFlags (VkDescriptorPoolCreateFlags) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Struct.VkDescriptorPoolSize (VkDescriptorPoolSize) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkDescriptorPoolCreateInfo { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkDescriptorPoolCreateFlags flags; +-- > uint32_t maxSets; +-- > uint32_t poolSizeCount; +-- > const VkDescriptorPoolSize* pPoolSizes; +-- > } VkDescriptorPoolCreateInfo; +-- +-- +data VkDescriptorPoolCreateInfo = VkDescriptorPoolCreateInfo## Addr## + ByteArray## + +instance Eq VkDescriptorPoolCreateInfo where + (VkDescriptorPoolCreateInfo## a _) == + x@(VkDescriptorPoolCreateInfo## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkDescriptorPoolCreateInfo where + (VkDescriptorPoolCreateInfo## a _) `compare` + x@(VkDescriptorPoolCreateInfo## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkDescriptorPoolCreateInfo where + sizeOf ~_ = #{size VkDescriptorPoolCreateInfo} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkDescriptorPoolCreateInfo} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkDescriptorPoolCreateInfo where + unsafeAddr (VkDescriptorPoolCreateInfo## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkDescriptorPoolCreateInfo## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkDescriptorPoolCreateInfo## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkDescriptorPoolCreateInfo where + type StructFields VkDescriptorPoolCreateInfo = + '["sType", "pNext", "flags", "maxSets", "poolSizeCount", -- ' closing tick for hsc2hs + "pPoolSizes"] + type CUnionType VkDescriptorPoolCreateInfo = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkDescriptorPoolCreateInfo = 'False -- ' closing tick for hsc2hs + type StructExtends VkDescriptorPoolCreateInfo = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkSType VkDescriptorPoolCreateInfo + where + type VkSTypeMType VkDescriptorPoolCreateInfo = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDescriptorPoolCreateInfo, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkDescriptorPoolCreateInfo, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkDescriptorPoolCreateInfo, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkDescriptorPoolCreateInfo, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkDescriptorPoolCreateInfo where + type FieldType "sType" VkDescriptorPoolCreateInfo = VkStructureType + type FieldOptional "sType" VkDescriptorPoolCreateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkDescriptorPoolCreateInfo = + #{offset VkDescriptorPoolCreateInfo, sType} + type FieldIsArray "sType" VkDescriptorPoolCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDescriptorPoolCreateInfo, sType} + +instance CanReadField "sType" VkDescriptorPoolCreateInfo where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkDescriptorPoolCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} HasVkPNext VkDescriptorPoolCreateInfo + where + type VkPNextMType VkDescriptorPoolCreateInfo = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDescriptorPoolCreateInfo, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkDescriptorPoolCreateInfo, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkDescriptorPoolCreateInfo, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkDescriptorPoolCreateInfo, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkDescriptorPoolCreateInfo where + type FieldType "pNext" VkDescriptorPoolCreateInfo = Ptr Void + type FieldOptional "pNext" VkDescriptorPoolCreateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkDescriptorPoolCreateInfo = + #{offset VkDescriptorPoolCreateInfo, pNext} + type FieldIsArray "pNext" VkDescriptorPoolCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDescriptorPoolCreateInfo, pNext} + +instance CanReadField "pNext" VkDescriptorPoolCreateInfo where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkDescriptorPoolCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} HasVkFlags VkDescriptorPoolCreateInfo + where + type VkFlagsMType VkDescriptorPoolCreateInfo = + VkDescriptorPoolCreateFlags + + {-# NOINLINE vkFlags #-} + vkFlags x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDescriptorPoolCreateInfo, flags}) + + {-# INLINE vkFlagsByteOffset #-} + vkFlagsByteOffset ~_ + = #{offset VkDescriptorPoolCreateInfo, flags} + + {-# INLINE readVkFlags #-} + readVkFlags p + = peekByteOff p #{offset VkDescriptorPoolCreateInfo, flags} + + {-# INLINE writeVkFlags #-} + writeVkFlags p + = pokeByteOff p #{offset VkDescriptorPoolCreateInfo, flags} + +instance {-# OVERLAPPING #-} + HasField "flags" VkDescriptorPoolCreateInfo where + type FieldType "flags" VkDescriptorPoolCreateInfo = + VkDescriptorPoolCreateFlags + type FieldOptional "flags" VkDescriptorPoolCreateInfo = 'True -- ' closing tick for hsc2hs + type FieldOffset "flags" VkDescriptorPoolCreateInfo = + #{offset VkDescriptorPoolCreateInfo, flags} + type FieldIsArray "flags" VkDescriptorPoolCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDescriptorPoolCreateInfo, flags} + +instance CanReadField "flags" VkDescriptorPoolCreateInfo where + {-# INLINE getField #-} + getField = vkFlags + + {-# INLINE readField #-} + readField = readVkFlags + +instance CanWriteField "flags" VkDescriptorPoolCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkFlags + +instance {-# OVERLAPPING #-} + HasVkMaxSets VkDescriptorPoolCreateInfo where + type VkMaxSetsMType VkDescriptorPoolCreateInfo = Word32 + + {-# NOINLINE vkMaxSets #-} + vkMaxSets x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDescriptorPoolCreateInfo, maxSets}) + + {-# INLINE vkMaxSetsByteOffset #-} + vkMaxSetsByteOffset ~_ + = #{offset VkDescriptorPoolCreateInfo, maxSets} + + {-# INLINE readVkMaxSets #-} + readVkMaxSets p + = peekByteOff p #{offset VkDescriptorPoolCreateInfo, maxSets} + + {-# INLINE writeVkMaxSets #-} + writeVkMaxSets p + = pokeByteOff p #{offset VkDescriptorPoolCreateInfo, maxSets} + +instance {-# OVERLAPPING #-} + HasField "maxSets" VkDescriptorPoolCreateInfo where + type FieldType "maxSets" VkDescriptorPoolCreateInfo = Word32 + type FieldOptional "maxSets" VkDescriptorPoolCreateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "maxSets" VkDescriptorPoolCreateInfo = + #{offset VkDescriptorPoolCreateInfo, maxSets} + type FieldIsArray "maxSets" VkDescriptorPoolCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDescriptorPoolCreateInfo, maxSets} + +instance CanReadField "maxSets" VkDescriptorPoolCreateInfo where + {-# INLINE getField #-} + getField = vkMaxSets + + {-# INLINE readField #-} + readField = readVkMaxSets + +instance CanWriteField "maxSets" VkDescriptorPoolCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkMaxSets + +instance {-# OVERLAPPING #-} + HasVkPoolSizeCount VkDescriptorPoolCreateInfo where + type VkPoolSizeCountMType VkDescriptorPoolCreateInfo = Word32 + + {-# NOINLINE vkPoolSizeCount #-} + vkPoolSizeCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDescriptorPoolCreateInfo, poolSizeCount}) + + {-# INLINE vkPoolSizeCountByteOffset #-} + vkPoolSizeCountByteOffset ~_ + = #{offset VkDescriptorPoolCreateInfo, poolSizeCount} + + {-# INLINE readVkPoolSizeCount #-} + readVkPoolSizeCount p + = peekByteOff p #{offset VkDescriptorPoolCreateInfo, poolSizeCount} + + {-# INLINE writeVkPoolSizeCount #-} + writeVkPoolSizeCount p + = pokeByteOff p #{offset VkDescriptorPoolCreateInfo, poolSizeCount} + +instance {-# OVERLAPPING #-} + HasField "poolSizeCount" VkDescriptorPoolCreateInfo where + type FieldType "poolSizeCount" VkDescriptorPoolCreateInfo = Word32 + type FieldOptional "poolSizeCount" VkDescriptorPoolCreateInfo = + 'False -- ' closing tick for hsc2hs + type FieldOffset "poolSizeCount" VkDescriptorPoolCreateInfo = + #{offset VkDescriptorPoolCreateInfo, poolSizeCount} + type FieldIsArray "poolSizeCount" VkDescriptorPoolCreateInfo = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDescriptorPoolCreateInfo, poolSizeCount} + +instance CanReadField "poolSizeCount" VkDescriptorPoolCreateInfo + where + {-# INLINE getField #-} + getField = vkPoolSizeCount + + {-# INLINE readField #-} + readField = readVkPoolSizeCount + +instance CanWriteField "poolSizeCount" VkDescriptorPoolCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkPoolSizeCount + +instance {-# OVERLAPPING #-} + HasVkPPoolSizes VkDescriptorPoolCreateInfo where + type VkPPoolSizesMType VkDescriptorPoolCreateInfo = + Ptr VkDescriptorPoolSize + + {-# NOINLINE vkPPoolSizes #-} + vkPPoolSizes x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDescriptorPoolCreateInfo, pPoolSizes}) + + {-# INLINE vkPPoolSizesByteOffset #-} + vkPPoolSizesByteOffset ~_ + = #{offset VkDescriptorPoolCreateInfo, pPoolSizes} + + {-# INLINE readVkPPoolSizes #-} + readVkPPoolSizes p + = peekByteOff p #{offset VkDescriptorPoolCreateInfo, pPoolSizes} + + {-# INLINE writeVkPPoolSizes #-} + writeVkPPoolSizes p + = pokeByteOff p #{offset VkDescriptorPoolCreateInfo, pPoolSizes} + +instance {-# OVERLAPPING #-} + HasField "pPoolSizes" VkDescriptorPoolCreateInfo where + type FieldType "pPoolSizes" VkDescriptorPoolCreateInfo = + Ptr VkDescriptorPoolSize + type FieldOptional "pPoolSizes" VkDescriptorPoolCreateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "pPoolSizes" VkDescriptorPoolCreateInfo = + #{offset VkDescriptorPoolCreateInfo, pPoolSizes} + type FieldIsArray "pPoolSizes" VkDescriptorPoolCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDescriptorPoolCreateInfo, pPoolSizes} + +instance CanReadField "pPoolSizes" VkDescriptorPoolCreateInfo where + {-# INLINE getField #-} + getField = vkPPoolSizes + + {-# INLINE readField #-} + readField = readVkPPoolSizes + +instance CanWriteField "pPoolSizes" VkDescriptorPoolCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkPPoolSizes + +instance Show VkDescriptorPoolCreateInfo where + showsPrec d x + = showString "VkDescriptorPoolCreateInfo {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkFlags = " . + showsPrec d (vkFlags x) . + showString ", " . + showString "vkMaxSets = " . + showsPrec d (vkMaxSets x) . + showString ", " . + showString "vkPoolSizeCount = " . + showsPrec d (vkPoolSizeCount x) . + showString ", " . + showString "vkPPoolSizes = " . + showsPrec d (vkPPoolSizes x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkDescriptorPoolSize.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkDescriptorPoolSize.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkDescriptorPoolSize.hsc @@ -0,0 +1,171 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkDescriptorPoolSize + (VkDescriptorPoolSize(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkDescriptorType (VkDescriptorType) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkDescriptorPoolSize { +-- > VkDescriptorType type; +-- > uint32_t descriptorCount; +-- > } VkDescriptorPoolSize; +-- +-- +data VkDescriptorPoolSize = VkDescriptorPoolSize## Addr## ByteArray## + +instance Eq VkDescriptorPoolSize where + (VkDescriptorPoolSize## a _) == x@(VkDescriptorPoolSize## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkDescriptorPoolSize where + (VkDescriptorPoolSize## a _) `compare` x@(VkDescriptorPoolSize## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkDescriptorPoolSize where + sizeOf ~_ = #{size VkDescriptorPoolSize} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkDescriptorPoolSize} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkDescriptorPoolSize where + unsafeAddr (VkDescriptorPoolSize## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkDescriptorPoolSize## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkDescriptorPoolSize## (plusAddr## (byteArrayContents## b) off) b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkDescriptorPoolSize where + type StructFields VkDescriptorPoolSize = + '["type", "descriptorCount"] -- ' closing tick for hsc2hs + type CUnionType VkDescriptorPoolSize = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkDescriptorPoolSize = 'False -- ' closing tick for hsc2hs + type StructExtends VkDescriptorPoolSize = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkType VkDescriptorPoolSize where + type VkTypeMType VkDescriptorPoolSize = VkDescriptorType + + {-# NOINLINE vkType #-} + vkType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDescriptorPoolSize, type}) + + {-# INLINE vkTypeByteOffset #-} + vkTypeByteOffset ~_ + = #{offset VkDescriptorPoolSize, type} + + {-# INLINE readVkType #-} + readVkType p + = peekByteOff p #{offset VkDescriptorPoolSize, type} + + {-# INLINE writeVkType #-} + writeVkType p + = pokeByteOff p #{offset VkDescriptorPoolSize, type} + +instance {-# OVERLAPPING #-} HasField "type" VkDescriptorPoolSize + where + type FieldType "type" VkDescriptorPoolSize = VkDescriptorType + type FieldOptional "type" VkDescriptorPoolSize = 'False -- ' closing tick for hsc2hs + type FieldOffset "type" VkDescriptorPoolSize = + #{offset VkDescriptorPoolSize, type} + type FieldIsArray "type" VkDescriptorPoolSize = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkDescriptorPoolSize, type} + +instance CanReadField "type" VkDescriptorPoolSize where + {-# INLINE getField #-} + getField = vkType + + {-# INLINE readField #-} + readField = readVkType + +instance CanWriteField "type" VkDescriptorPoolSize where + {-# INLINE writeField #-} + writeField = writeVkType + +instance {-# OVERLAPPING #-} + HasVkDescriptorCount VkDescriptorPoolSize where + type VkDescriptorCountMType VkDescriptorPoolSize = Word32 + + {-# NOINLINE vkDescriptorCount #-} + vkDescriptorCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDescriptorPoolSize, descriptorCount}) + + {-# INLINE vkDescriptorCountByteOffset #-} + vkDescriptorCountByteOffset ~_ + = #{offset VkDescriptorPoolSize, descriptorCount} + + {-# INLINE readVkDescriptorCount #-} + readVkDescriptorCount p + = peekByteOff p #{offset VkDescriptorPoolSize, descriptorCount} + + {-# INLINE writeVkDescriptorCount #-} + writeVkDescriptorCount p + = pokeByteOff p #{offset VkDescriptorPoolSize, descriptorCount} + +instance {-# OVERLAPPING #-} + HasField "descriptorCount" VkDescriptorPoolSize where + type FieldType "descriptorCount" VkDescriptorPoolSize = Word32 + type FieldOptional "descriptorCount" VkDescriptorPoolSize = 'False -- ' closing tick for hsc2hs + type FieldOffset "descriptorCount" VkDescriptorPoolSize = + #{offset VkDescriptorPoolSize, descriptorCount} + type FieldIsArray "descriptorCount" VkDescriptorPoolSize = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDescriptorPoolSize, descriptorCount} + +instance CanReadField "descriptorCount" VkDescriptorPoolSize where + {-# INLINE getField #-} + getField = vkDescriptorCount + + {-# INLINE readField #-} + readField = readVkDescriptorCount + +instance CanWriteField "descriptorCount" VkDescriptorPoolSize where + {-# INLINE writeField #-} + writeField = writeVkDescriptorCount + +instance Show VkDescriptorPoolSize where + showsPrec d x + = showString "VkDescriptorPoolSize {" . + showString "vkType = " . + showsPrec d (vkType x) . + showString ", " . + showString "vkDescriptorCount = " . + showsPrec d (vkDescriptorCount x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkDescriptorSetAllocateInfo.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkDescriptorSetAllocateInfo.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkDescriptorSetAllocateInfo.hsc @@ -0,0 +1,352 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkDescriptorSetAllocateInfo + (VkDescriptorSetAllocateInfo(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Handles (VkDescriptorPool, VkDescriptorSetLayout) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkDescriptorSetAllocateInfo { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkDescriptorPool descriptorPool; +-- > uint32_t descriptorSetCount; +-- > const VkDescriptorSetLayout* pSetLayouts; +-- > } VkDescriptorSetAllocateInfo; +-- +-- +data VkDescriptorSetAllocateInfo = VkDescriptorSetAllocateInfo## Addr## + ByteArray## + +instance Eq VkDescriptorSetAllocateInfo where + (VkDescriptorSetAllocateInfo## a _) == + x@(VkDescriptorSetAllocateInfo## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkDescriptorSetAllocateInfo where + (VkDescriptorSetAllocateInfo## a _) `compare` + x@(VkDescriptorSetAllocateInfo## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkDescriptorSetAllocateInfo where + sizeOf ~_ = #{size VkDescriptorSetAllocateInfo} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkDescriptorSetAllocateInfo} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkDescriptorSetAllocateInfo where + unsafeAddr (VkDescriptorSetAllocateInfo## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkDescriptorSetAllocateInfo## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkDescriptorSetAllocateInfo## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkDescriptorSetAllocateInfo where + type StructFields VkDescriptorSetAllocateInfo = + '["sType", "pNext", "descriptorPool", "descriptorSetCount", -- ' closing tick for hsc2hs + "pSetLayouts"] + type CUnionType VkDescriptorSetAllocateInfo = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkDescriptorSetAllocateInfo = 'False -- ' closing tick for hsc2hs + type StructExtends VkDescriptorSetAllocateInfo = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkSType VkDescriptorSetAllocateInfo + where + type VkSTypeMType VkDescriptorSetAllocateInfo = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDescriptorSetAllocateInfo, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkDescriptorSetAllocateInfo, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkDescriptorSetAllocateInfo, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkDescriptorSetAllocateInfo, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkDescriptorSetAllocateInfo where + type FieldType "sType" VkDescriptorSetAllocateInfo = + VkStructureType + type FieldOptional "sType" VkDescriptorSetAllocateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkDescriptorSetAllocateInfo = + #{offset VkDescriptorSetAllocateInfo, sType} + type FieldIsArray "sType" VkDescriptorSetAllocateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDescriptorSetAllocateInfo, sType} + +instance CanReadField "sType" VkDescriptorSetAllocateInfo where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkDescriptorSetAllocateInfo where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} HasVkPNext VkDescriptorSetAllocateInfo + where + type VkPNextMType VkDescriptorSetAllocateInfo = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDescriptorSetAllocateInfo, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkDescriptorSetAllocateInfo, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkDescriptorSetAllocateInfo, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkDescriptorSetAllocateInfo, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkDescriptorSetAllocateInfo where + type FieldType "pNext" VkDescriptorSetAllocateInfo = Ptr Void + type FieldOptional "pNext" VkDescriptorSetAllocateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkDescriptorSetAllocateInfo = + #{offset VkDescriptorSetAllocateInfo, pNext} + type FieldIsArray "pNext" VkDescriptorSetAllocateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDescriptorSetAllocateInfo, pNext} + +instance CanReadField "pNext" VkDescriptorSetAllocateInfo where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkDescriptorSetAllocateInfo where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkDescriptorPool VkDescriptorSetAllocateInfo where + type VkDescriptorPoolMType VkDescriptorSetAllocateInfo = + VkDescriptorPool + + {-# NOINLINE vkDescriptorPool #-} + vkDescriptorPool x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDescriptorSetAllocateInfo, descriptorPool}) + + {-# INLINE vkDescriptorPoolByteOffset #-} + vkDescriptorPoolByteOffset ~_ + = #{offset VkDescriptorSetAllocateInfo, descriptorPool} + + {-# INLINE readVkDescriptorPool #-} + readVkDescriptorPool p + = peekByteOff p #{offset VkDescriptorSetAllocateInfo, descriptorPool} + + {-# INLINE writeVkDescriptorPool #-} + writeVkDescriptorPool p + = pokeByteOff p #{offset VkDescriptorSetAllocateInfo, descriptorPool} + +instance {-# OVERLAPPING #-} + HasField "descriptorPool" VkDescriptorSetAllocateInfo where + type FieldType "descriptorPool" VkDescriptorSetAllocateInfo = + VkDescriptorPool + type FieldOptional "descriptorPool" VkDescriptorSetAllocateInfo = + 'False -- ' closing tick for hsc2hs + type FieldOffset "descriptorPool" VkDescriptorSetAllocateInfo = + #{offset VkDescriptorSetAllocateInfo, descriptorPool} + type FieldIsArray "descriptorPool" VkDescriptorSetAllocateInfo = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDescriptorSetAllocateInfo, descriptorPool} + +instance CanReadField "descriptorPool" VkDescriptorSetAllocateInfo + where + {-# INLINE getField #-} + getField = vkDescriptorPool + + {-# INLINE readField #-} + readField = readVkDescriptorPool + +instance CanWriteField "descriptorPool" VkDescriptorSetAllocateInfo + where + {-# INLINE writeField #-} + writeField = writeVkDescriptorPool + +instance {-# OVERLAPPING #-} + HasVkDescriptorSetCount VkDescriptorSetAllocateInfo where + type VkDescriptorSetCountMType VkDescriptorSetAllocateInfo = Word32 + + {-# NOINLINE vkDescriptorSetCount #-} + vkDescriptorSetCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDescriptorSetAllocateInfo, descriptorSetCount}) + + {-# INLINE vkDescriptorSetCountByteOffset #-} + vkDescriptorSetCountByteOffset ~_ + = #{offset VkDescriptorSetAllocateInfo, descriptorSetCount} + + {-# INLINE readVkDescriptorSetCount #-} + readVkDescriptorSetCount p + = peekByteOff p #{offset VkDescriptorSetAllocateInfo, descriptorSetCount} + + {-# INLINE writeVkDescriptorSetCount #-} + writeVkDescriptorSetCount p + = pokeByteOff p #{offset VkDescriptorSetAllocateInfo, descriptorSetCount} + +instance {-# OVERLAPPING #-} + HasField "descriptorSetCount" VkDescriptorSetAllocateInfo where + type FieldType "descriptorSetCount" VkDescriptorSetAllocateInfo = + Word32 + type FieldOptional "descriptorSetCount" VkDescriptorSetAllocateInfo + = 'False -- ' closing tick for hsc2hs + type FieldOffset "descriptorSetCount" VkDescriptorSetAllocateInfo = + #{offset VkDescriptorSetAllocateInfo, descriptorSetCount} + type FieldIsArray "descriptorSetCount" VkDescriptorSetAllocateInfo + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDescriptorSetAllocateInfo, descriptorSetCount} + +instance CanReadField "descriptorSetCount" + VkDescriptorSetAllocateInfo + where + {-# INLINE getField #-} + getField = vkDescriptorSetCount + + {-# INLINE readField #-} + readField = readVkDescriptorSetCount + +instance CanWriteField "descriptorSetCount" + VkDescriptorSetAllocateInfo + where + {-# INLINE writeField #-} + writeField = writeVkDescriptorSetCount + +instance {-# OVERLAPPING #-} + HasVkPSetLayouts VkDescriptorSetAllocateInfo where + type VkPSetLayoutsMType VkDescriptorSetAllocateInfo = + Ptr VkDescriptorSetLayout + + {-# NOINLINE vkPSetLayouts #-} + vkPSetLayouts x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDescriptorSetAllocateInfo, pSetLayouts}) + + {-# INLINE vkPSetLayoutsByteOffset #-} + vkPSetLayoutsByteOffset ~_ + = #{offset VkDescriptorSetAllocateInfo, pSetLayouts} + + {-# INLINE readVkPSetLayouts #-} + readVkPSetLayouts p + = peekByteOff p #{offset VkDescriptorSetAllocateInfo, pSetLayouts} + + {-# INLINE writeVkPSetLayouts #-} + writeVkPSetLayouts p + = pokeByteOff p #{offset VkDescriptorSetAllocateInfo, pSetLayouts} + +instance {-# OVERLAPPING #-} + HasField "pSetLayouts" VkDescriptorSetAllocateInfo where + type FieldType "pSetLayouts" VkDescriptorSetAllocateInfo = + Ptr VkDescriptorSetLayout + type FieldOptional "pSetLayouts" VkDescriptorSetAllocateInfo = + 'False -- ' closing tick for hsc2hs + type FieldOffset "pSetLayouts" VkDescriptorSetAllocateInfo = + #{offset VkDescriptorSetAllocateInfo, pSetLayouts} + type FieldIsArray "pSetLayouts" VkDescriptorSetAllocateInfo = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDescriptorSetAllocateInfo, pSetLayouts} + +instance CanReadField "pSetLayouts" VkDescriptorSetAllocateInfo + where + {-# INLINE getField #-} + getField = vkPSetLayouts + + {-# INLINE readField #-} + readField = readVkPSetLayouts + +instance CanWriteField "pSetLayouts" VkDescriptorSetAllocateInfo + where + {-# INLINE writeField #-} + writeField = writeVkPSetLayouts + +instance Show VkDescriptorSetAllocateInfo where + showsPrec d x + = showString "VkDescriptorSetAllocateInfo {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkDescriptorPool = " . + showsPrec d (vkDescriptorPool x) . + showString ", " . + showString "vkDescriptorSetCount = " . + showsPrec d (vkDescriptorSetCount x) . + showString ", " . + showString "vkPSetLayouts = " . + showsPrec d (vkPSetLayouts x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkDescriptorSetLayoutBinding.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkDescriptorSetLayoutBinding.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkDescriptorSetLayoutBinding.hsc @@ -0,0 +1,364 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkDescriptorSetLayoutBinding + (VkDescriptorSetLayoutBinding(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkDescriptorType (VkDescriptorType) +import Graphics.Vulkan.Types.Enum.VkShaderStageFlags (VkShaderStageFlags) +import Graphics.Vulkan.Types.Handles (VkSampler) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkDescriptorSetLayoutBinding { +-- > uint32_t binding; +-- > VkDescriptorType descriptorType; +-- > uint32_t descriptorCount; +-- > VkShaderStageFlags stageFlags; +-- > const VkSampler* pImmutableSamplers; +-- > } VkDescriptorSetLayoutBinding; +-- +-- +data VkDescriptorSetLayoutBinding = VkDescriptorSetLayoutBinding## Addr## + ByteArray## + +instance Eq VkDescriptorSetLayoutBinding where + (VkDescriptorSetLayoutBinding## a _) == + x@(VkDescriptorSetLayoutBinding## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkDescriptorSetLayoutBinding where + (VkDescriptorSetLayoutBinding## a _) `compare` + x@(VkDescriptorSetLayoutBinding## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkDescriptorSetLayoutBinding where + sizeOf ~_ = #{size VkDescriptorSetLayoutBinding} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkDescriptorSetLayoutBinding} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkDescriptorSetLayoutBinding where + unsafeAddr (VkDescriptorSetLayoutBinding## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkDescriptorSetLayoutBinding## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkDescriptorSetLayoutBinding## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkDescriptorSetLayoutBinding where + type StructFields VkDescriptorSetLayoutBinding = + '["binding", "descriptorType", "descriptorCount", "stageFlags", -- ' closing tick for hsc2hs + "pImmutableSamplers"] + type CUnionType VkDescriptorSetLayoutBinding = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkDescriptorSetLayoutBinding = 'False -- ' closing tick for hsc2hs + type StructExtends VkDescriptorSetLayoutBinding = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkBinding VkDescriptorSetLayoutBinding where + type VkBindingMType VkDescriptorSetLayoutBinding = Word32 + + {-# NOINLINE vkBinding #-} + vkBinding x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDescriptorSetLayoutBinding, binding}) + + {-# INLINE vkBindingByteOffset #-} + vkBindingByteOffset ~_ + = #{offset VkDescriptorSetLayoutBinding, binding} + + {-# INLINE readVkBinding #-} + readVkBinding p + = peekByteOff p #{offset VkDescriptorSetLayoutBinding, binding} + + {-# INLINE writeVkBinding #-} + writeVkBinding p + = pokeByteOff p #{offset VkDescriptorSetLayoutBinding, binding} + +instance {-# OVERLAPPING #-} + HasField "binding" VkDescriptorSetLayoutBinding where + type FieldType "binding" VkDescriptorSetLayoutBinding = Word32 + type FieldOptional "binding" VkDescriptorSetLayoutBinding = 'False -- ' closing tick for hsc2hs + type FieldOffset "binding" VkDescriptorSetLayoutBinding = + #{offset VkDescriptorSetLayoutBinding, binding} + type FieldIsArray "binding" VkDescriptorSetLayoutBinding = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDescriptorSetLayoutBinding, binding} + +instance CanReadField "binding" VkDescriptorSetLayoutBinding where + {-# INLINE getField #-} + getField = vkBinding + + {-# INLINE readField #-} + readField = readVkBinding + +instance CanWriteField "binding" VkDescriptorSetLayoutBinding where + {-# INLINE writeField #-} + writeField = writeVkBinding + +instance {-# OVERLAPPING #-} + HasVkDescriptorType VkDescriptorSetLayoutBinding where + type VkDescriptorTypeMType VkDescriptorSetLayoutBinding = + VkDescriptorType + + {-# NOINLINE vkDescriptorType #-} + vkDescriptorType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDescriptorSetLayoutBinding, descriptorType}) + + {-# INLINE vkDescriptorTypeByteOffset #-} + vkDescriptorTypeByteOffset ~_ + = #{offset VkDescriptorSetLayoutBinding, descriptorType} + + {-# INLINE readVkDescriptorType #-} + readVkDescriptorType p + = peekByteOff p #{offset VkDescriptorSetLayoutBinding, descriptorType} + + {-# INLINE writeVkDescriptorType #-} + writeVkDescriptorType p + = pokeByteOff p #{offset VkDescriptorSetLayoutBinding, descriptorType} + +instance {-# OVERLAPPING #-} + HasField "descriptorType" VkDescriptorSetLayoutBinding where + type FieldType "descriptorType" VkDescriptorSetLayoutBinding = + VkDescriptorType + type FieldOptional "descriptorType" VkDescriptorSetLayoutBinding = + 'False -- ' closing tick for hsc2hs + type FieldOffset "descriptorType" VkDescriptorSetLayoutBinding = + #{offset VkDescriptorSetLayoutBinding, descriptorType} + type FieldIsArray "descriptorType" VkDescriptorSetLayoutBinding = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDescriptorSetLayoutBinding, descriptorType} + +instance CanReadField "descriptorType" VkDescriptorSetLayoutBinding + where + {-# INLINE getField #-} + getField = vkDescriptorType + + {-# INLINE readField #-} + readField = readVkDescriptorType + +instance CanWriteField "descriptorType" + VkDescriptorSetLayoutBinding + where + {-# INLINE writeField #-} + writeField = writeVkDescriptorType + +instance {-# OVERLAPPING #-} + HasVkDescriptorCount VkDescriptorSetLayoutBinding where + type VkDescriptorCountMType VkDescriptorSetLayoutBinding = Word32 + + {-# NOINLINE vkDescriptorCount #-} + vkDescriptorCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDescriptorSetLayoutBinding, descriptorCount}) + + {-# INLINE vkDescriptorCountByteOffset #-} + vkDescriptorCountByteOffset ~_ + = #{offset VkDescriptorSetLayoutBinding, descriptorCount} + + {-# INLINE readVkDescriptorCount #-} + readVkDescriptorCount p + = peekByteOff p #{offset VkDescriptorSetLayoutBinding, descriptorCount} + + {-# INLINE writeVkDescriptorCount #-} + writeVkDescriptorCount p + = pokeByteOff p #{offset VkDescriptorSetLayoutBinding, descriptorCount} + +instance {-# OVERLAPPING #-} + HasField "descriptorCount" VkDescriptorSetLayoutBinding where + type FieldType "descriptorCount" VkDescriptorSetLayoutBinding = + Word32 + type FieldOptional "descriptorCount" VkDescriptorSetLayoutBinding = + 'True -- ' closing tick for hsc2hs + type FieldOffset "descriptorCount" VkDescriptorSetLayoutBinding = + #{offset VkDescriptorSetLayoutBinding, descriptorCount} + type FieldIsArray "descriptorCount" VkDescriptorSetLayoutBinding = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDescriptorSetLayoutBinding, descriptorCount} + +instance CanReadField "descriptorCount" + VkDescriptorSetLayoutBinding + where + {-# INLINE getField #-} + getField = vkDescriptorCount + + {-# INLINE readField #-} + readField = readVkDescriptorCount + +instance CanWriteField "descriptorCount" + VkDescriptorSetLayoutBinding + where + {-# INLINE writeField #-} + writeField = writeVkDescriptorCount + +instance {-# OVERLAPPING #-} + HasVkStageFlags VkDescriptorSetLayoutBinding where + type VkStageFlagsMType VkDescriptorSetLayoutBinding = + VkShaderStageFlags + + {-# NOINLINE vkStageFlags #-} + vkStageFlags x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDescriptorSetLayoutBinding, stageFlags}) + + {-# INLINE vkStageFlagsByteOffset #-} + vkStageFlagsByteOffset ~_ + = #{offset VkDescriptorSetLayoutBinding, stageFlags} + + {-# INLINE readVkStageFlags #-} + readVkStageFlags p + = peekByteOff p #{offset VkDescriptorSetLayoutBinding, stageFlags} + + {-# INLINE writeVkStageFlags #-} + writeVkStageFlags p + = pokeByteOff p #{offset VkDescriptorSetLayoutBinding, stageFlags} + +instance {-# OVERLAPPING #-} + HasField "stageFlags" VkDescriptorSetLayoutBinding where + type FieldType "stageFlags" VkDescriptorSetLayoutBinding = + VkShaderStageFlags + type FieldOptional "stageFlags" VkDescriptorSetLayoutBinding = + 'False -- ' closing tick for hsc2hs + type FieldOffset "stageFlags" VkDescriptorSetLayoutBinding = + #{offset VkDescriptorSetLayoutBinding, stageFlags} + type FieldIsArray "stageFlags" VkDescriptorSetLayoutBinding = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDescriptorSetLayoutBinding, stageFlags} + +instance CanReadField "stageFlags" VkDescriptorSetLayoutBinding + where + {-# INLINE getField #-} + getField = vkStageFlags + + {-# INLINE readField #-} + readField = readVkStageFlags + +instance CanWriteField "stageFlags" VkDescriptorSetLayoutBinding + where + {-# INLINE writeField #-} + writeField = writeVkStageFlags + +instance {-# OVERLAPPING #-} + HasVkPImmutableSamplers VkDescriptorSetLayoutBinding where + type VkPImmutableSamplersMType VkDescriptorSetLayoutBinding = + Ptr VkSampler + + {-# NOINLINE vkPImmutableSamplers #-} + vkPImmutableSamplers x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDescriptorSetLayoutBinding, pImmutableSamplers}) + + {-# INLINE vkPImmutableSamplersByteOffset #-} + vkPImmutableSamplersByteOffset ~_ + = #{offset VkDescriptorSetLayoutBinding, pImmutableSamplers} + + {-# INLINE readVkPImmutableSamplers #-} + readVkPImmutableSamplers p + = peekByteOff p #{offset VkDescriptorSetLayoutBinding, pImmutableSamplers} + + {-# INLINE writeVkPImmutableSamplers #-} + writeVkPImmutableSamplers p + = pokeByteOff p #{offset VkDescriptorSetLayoutBinding, pImmutableSamplers} + +instance {-# OVERLAPPING #-} + HasField "pImmutableSamplers" VkDescriptorSetLayoutBinding where + type FieldType "pImmutableSamplers" VkDescriptorSetLayoutBinding = + Ptr VkSampler + type FieldOptional "pImmutableSamplers" + VkDescriptorSetLayoutBinding + = 'True -- ' closing tick for hsc2hs + type FieldOffset "pImmutableSamplers" VkDescriptorSetLayoutBinding + = + #{offset VkDescriptorSetLayoutBinding, pImmutableSamplers} + type FieldIsArray "pImmutableSamplers" VkDescriptorSetLayoutBinding + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDescriptorSetLayoutBinding, pImmutableSamplers} + +instance CanReadField "pImmutableSamplers" + VkDescriptorSetLayoutBinding + where + {-# INLINE getField #-} + getField = vkPImmutableSamplers + + {-# INLINE readField #-} + readField = readVkPImmutableSamplers + +instance CanWriteField "pImmutableSamplers" + VkDescriptorSetLayoutBinding + where + {-# INLINE writeField #-} + writeField = writeVkPImmutableSamplers + +instance Show VkDescriptorSetLayoutBinding where + showsPrec d x + = showString "VkDescriptorSetLayoutBinding {" . + showString "vkBinding = " . + showsPrec d (vkBinding x) . + showString ", " . + showString "vkDescriptorType = " . + showsPrec d (vkDescriptorType x) . + showString ", " . + showString "vkDescriptorCount = " . + showsPrec d (vkDescriptorCount x) . + showString ", " . + showString "vkStageFlags = " . + showsPrec d (vkStageFlags x) . + showString ", " . + showString "vkPImmutableSamplers = " . + showsPrec d (vkPImmutableSamplers x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkDescriptorSetLayoutCreateInfo.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkDescriptorSetLayoutCreateInfo.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkDescriptorSetLayoutCreateInfo.hsc @@ -0,0 +1,352 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkDescriptorSetLayoutCreateInfo + (VkDescriptorSetLayoutCreateInfo(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkDescriptorSetLayoutCreateFlags (VkDescriptorSetLayoutCreateFlags) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Struct.VkDescriptorSetLayoutBinding (VkDescriptorSetLayoutBinding) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkDescriptorSetLayoutCreateInfo { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkDescriptorSetLayoutCreateFlags flags; +-- > uint32_t bindingCount; +-- > const VkDescriptorSetLayoutBinding* pBindings; +-- > } VkDescriptorSetLayoutCreateInfo; +-- +-- +data VkDescriptorSetLayoutCreateInfo = VkDescriptorSetLayoutCreateInfo## Addr## + ByteArray## + +instance Eq VkDescriptorSetLayoutCreateInfo where + (VkDescriptorSetLayoutCreateInfo## a _) == + x@(VkDescriptorSetLayoutCreateInfo## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkDescriptorSetLayoutCreateInfo where + (VkDescriptorSetLayoutCreateInfo## a _) `compare` + x@(VkDescriptorSetLayoutCreateInfo## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkDescriptorSetLayoutCreateInfo where + sizeOf ~_ = #{size VkDescriptorSetLayoutCreateInfo} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkDescriptorSetLayoutCreateInfo} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkDescriptorSetLayoutCreateInfo where + unsafeAddr (VkDescriptorSetLayoutCreateInfo## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkDescriptorSetLayoutCreateInfo## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkDescriptorSetLayoutCreateInfo## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkDescriptorSetLayoutCreateInfo where + type StructFields VkDescriptorSetLayoutCreateInfo = + '["sType", "pNext", "flags", "bindingCount", "pBindings"] -- ' closing tick for hsc2hs + type CUnionType VkDescriptorSetLayoutCreateInfo = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkDescriptorSetLayoutCreateInfo = 'False -- ' closing tick for hsc2hs + type StructExtends VkDescriptorSetLayoutCreateInfo = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkDescriptorSetLayoutCreateInfo where + type VkSTypeMType VkDescriptorSetLayoutCreateInfo = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDescriptorSetLayoutCreateInfo, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkDescriptorSetLayoutCreateInfo, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkDescriptorSetLayoutCreateInfo, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkDescriptorSetLayoutCreateInfo, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkDescriptorSetLayoutCreateInfo where + type FieldType "sType" VkDescriptorSetLayoutCreateInfo = + VkStructureType + type FieldOptional "sType" VkDescriptorSetLayoutCreateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkDescriptorSetLayoutCreateInfo = + #{offset VkDescriptorSetLayoutCreateInfo, sType} + type FieldIsArray "sType" VkDescriptorSetLayoutCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDescriptorSetLayoutCreateInfo, sType} + +instance CanReadField "sType" VkDescriptorSetLayoutCreateInfo where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkDescriptorSetLayoutCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkDescriptorSetLayoutCreateInfo where + type VkPNextMType VkDescriptorSetLayoutCreateInfo = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDescriptorSetLayoutCreateInfo, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkDescriptorSetLayoutCreateInfo, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkDescriptorSetLayoutCreateInfo, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkDescriptorSetLayoutCreateInfo, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkDescriptorSetLayoutCreateInfo where + type FieldType "pNext" VkDescriptorSetLayoutCreateInfo = Ptr Void + type FieldOptional "pNext" VkDescriptorSetLayoutCreateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkDescriptorSetLayoutCreateInfo = + #{offset VkDescriptorSetLayoutCreateInfo, pNext} + type FieldIsArray "pNext" VkDescriptorSetLayoutCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDescriptorSetLayoutCreateInfo, pNext} + +instance CanReadField "pNext" VkDescriptorSetLayoutCreateInfo where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkDescriptorSetLayoutCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkFlags VkDescriptorSetLayoutCreateInfo where + type VkFlagsMType VkDescriptorSetLayoutCreateInfo = + VkDescriptorSetLayoutCreateFlags + + {-# NOINLINE vkFlags #-} + vkFlags x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDescriptorSetLayoutCreateInfo, flags}) + + {-# INLINE vkFlagsByteOffset #-} + vkFlagsByteOffset ~_ + = #{offset VkDescriptorSetLayoutCreateInfo, flags} + + {-# INLINE readVkFlags #-} + readVkFlags p + = peekByteOff p #{offset VkDescriptorSetLayoutCreateInfo, flags} + + {-# INLINE writeVkFlags #-} + writeVkFlags p + = pokeByteOff p #{offset VkDescriptorSetLayoutCreateInfo, flags} + +instance {-# OVERLAPPING #-} + HasField "flags" VkDescriptorSetLayoutCreateInfo where + type FieldType "flags" VkDescriptorSetLayoutCreateInfo = + VkDescriptorSetLayoutCreateFlags + type FieldOptional "flags" VkDescriptorSetLayoutCreateInfo = 'True -- ' closing tick for hsc2hs + type FieldOffset "flags" VkDescriptorSetLayoutCreateInfo = + #{offset VkDescriptorSetLayoutCreateInfo, flags} + type FieldIsArray "flags" VkDescriptorSetLayoutCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDescriptorSetLayoutCreateInfo, flags} + +instance CanReadField "flags" VkDescriptorSetLayoutCreateInfo where + {-# INLINE getField #-} + getField = vkFlags + + {-# INLINE readField #-} + readField = readVkFlags + +instance CanWriteField "flags" VkDescriptorSetLayoutCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkFlags + +instance {-# OVERLAPPING #-} + HasVkBindingCount VkDescriptorSetLayoutCreateInfo where + type VkBindingCountMType VkDescriptorSetLayoutCreateInfo = Word32 + + {-# NOINLINE vkBindingCount #-} + vkBindingCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDescriptorSetLayoutCreateInfo, bindingCount}) + + {-# INLINE vkBindingCountByteOffset #-} + vkBindingCountByteOffset ~_ + = #{offset VkDescriptorSetLayoutCreateInfo, bindingCount} + + {-# INLINE readVkBindingCount #-} + readVkBindingCount p + = peekByteOff p #{offset VkDescriptorSetLayoutCreateInfo, bindingCount} + + {-# INLINE writeVkBindingCount #-} + writeVkBindingCount p + = pokeByteOff p #{offset VkDescriptorSetLayoutCreateInfo, bindingCount} + +instance {-# OVERLAPPING #-} + HasField "bindingCount" VkDescriptorSetLayoutCreateInfo where + type FieldType "bindingCount" VkDescriptorSetLayoutCreateInfo = + Word32 + type FieldOptional "bindingCount" VkDescriptorSetLayoutCreateInfo = + 'True -- ' closing tick for hsc2hs + type FieldOffset "bindingCount" VkDescriptorSetLayoutCreateInfo = + #{offset VkDescriptorSetLayoutCreateInfo, bindingCount} + type FieldIsArray "bindingCount" VkDescriptorSetLayoutCreateInfo = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDescriptorSetLayoutCreateInfo, bindingCount} + +instance CanReadField "bindingCount" + VkDescriptorSetLayoutCreateInfo + where + {-# INLINE getField #-} + getField = vkBindingCount + + {-# INLINE readField #-} + readField = readVkBindingCount + +instance CanWriteField "bindingCount" + VkDescriptorSetLayoutCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkBindingCount + +instance {-# OVERLAPPING #-} + HasVkPBindings VkDescriptorSetLayoutCreateInfo where + type VkPBindingsMType VkDescriptorSetLayoutCreateInfo = + Ptr VkDescriptorSetLayoutBinding + + {-# NOINLINE vkPBindings #-} + vkPBindings x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDescriptorSetLayoutCreateInfo, pBindings}) + + {-# INLINE vkPBindingsByteOffset #-} + vkPBindingsByteOffset ~_ + = #{offset VkDescriptorSetLayoutCreateInfo, pBindings} + + {-# INLINE readVkPBindings #-} + readVkPBindings p + = peekByteOff p #{offset VkDescriptorSetLayoutCreateInfo, pBindings} + + {-# INLINE writeVkPBindings #-} + writeVkPBindings p + = pokeByteOff p #{offset VkDescriptorSetLayoutCreateInfo, pBindings} + +instance {-# OVERLAPPING #-} + HasField "pBindings" VkDescriptorSetLayoutCreateInfo where + type FieldType "pBindings" VkDescriptorSetLayoutCreateInfo = + Ptr VkDescriptorSetLayoutBinding + type FieldOptional "pBindings" VkDescriptorSetLayoutCreateInfo = + 'False -- ' closing tick for hsc2hs + type FieldOffset "pBindings" VkDescriptorSetLayoutCreateInfo = + #{offset VkDescriptorSetLayoutCreateInfo, pBindings} + type FieldIsArray "pBindings" VkDescriptorSetLayoutCreateInfo = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDescriptorSetLayoutCreateInfo, pBindings} + +instance CanReadField "pBindings" VkDescriptorSetLayoutCreateInfo + where + {-# INLINE getField #-} + getField = vkPBindings + + {-# INLINE readField #-} + readField = readVkPBindings + +instance CanWriteField "pBindings" VkDescriptorSetLayoutCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkPBindings + +instance Show VkDescriptorSetLayoutCreateInfo where + showsPrec d x + = showString "VkDescriptorSetLayoutCreateInfo {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkFlags = " . + showsPrec d (vkFlags x) . + showString ", " . + showString "vkBindingCount = " . + showsPrec d (vkBindingCount x) . + showString ", " . + showString "vkPBindings = " . + showsPrec d (vkPBindings x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkDescriptorUpdateTemplateCreateInfoKHR.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkDescriptorUpdateTemplateCreateInfoKHR.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkDescriptorUpdateTemplateCreateInfoKHR.hsc @@ -0,0 +1,727 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkDescriptorUpdateTemplateCreateInfoKHR + (VkDescriptorUpdateTemplateCreateInfoKHR(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Bitmasks (VkDescriptorUpdateTemplateCreateFlagsKHR) +import Graphics.Vulkan.Types.Enum.VkDescriptorUpdateTemplateTypeKHR (VkDescriptorUpdateTemplateTypeKHR) +import Graphics.Vulkan.Types.Enum.VkPipelineBindPoint (VkPipelineBindPoint) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Handles (VkDescriptorSetLayout, + VkPipelineLayout) +import Graphics.Vulkan.Types.Struct.VkDescriptorUpdateTemplateEntryKHR (VkDescriptorUpdateTemplateEntryKHR) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkDescriptorUpdateTemplateCreateInfoKHR { +-- > VkStructureType sType; +-- > void* pNext; +-- > VkDescriptorUpdateTemplateCreateFlagsKHR flags; +-- > uint32_t descriptorUpdateEntryCount; +-- > const VkDescriptorUpdateTemplateEntryKHR* pDescriptorUpdateEntries; +-- > VkDescriptorUpdateTemplateTypeKHR templateType; +-- > VkDescriptorSetLayout descriptorSetLayout; +-- > VkPipelineBindPoint pipelineBindPoint; +-- > VkPipelineLayoutpipelineLayout; +-- > uint32_t set; +-- > } VkDescriptorUpdateTemplateCreateInfoKHR; +-- +-- +data VkDescriptorUpdateTemplateCreateInfoKHR = VkDescriptorUpdateTemplateCreateInfoKHR## Addr## + ByteArray## + +instance Eq VkDescriptorUpdateTemplateCreateInfoKHR where + (VkDescriptorUpdateTemplateCreateInfoKHR## a _) == + x@(VkDescriptorUpdateTemplateCreateInfoKHR## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkDescriptorUpdateTemplateCreateInfoKHR where + (VkDescriptorUpdateTemplateCreateInfoKHR## a _) `compare` + x@(VkDescriptorUpdateTemplateCreateInfoKHR## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkDescriptorUpdateTemplateCreateInfoKHR where + sizeOf ~_ + = #{size VkDescriptorUpdateTemplateCreateInfoKHR} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkDescriptorUpdateTemplateCreateInfoKHR} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkDescriptorUpdateTemplateCreateInfoKHR + where + unsafeAddr (VkDescriptorUpdateTemplateCreateInfoKHR## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkDescriptorUpdateTemplateCreateInfoKHR## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkDescriptorUpdateTemplateCreateInfoKHR## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkDescriptorUpdateTemplateCreateInfoKHR + where + type StructFields VkDescriptorUpdateTemplateCreateInfoKHR = + '["sType", "pNext", "flags", "descriptorUpdateEntryCount", -- ' closing tick for hsc2hs + "pDescriptorUpdateEntries", "templateType", "descriptorSetLayout", + "pipelineBindPoint", "pipelineLayout", "set"] + type CUnionType VkDescriptorUpdateTemplateCreateInfoKHR = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkDescriptorUpdateTemplateCreateInfoKHR = 'False -- ' closing tick for hsc2hs + type StructExtends VkDescriptorUpdateTemplateCreateInfoKHR = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkDescriptorUpdateTemplateCreateInfoKHR where + type VkSTypeMType VkDescriptorUpdateTemplateCreateInfoKHR = + VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDescriptorUpdateTemplateCreateInfoKHR, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkDescriptorUpdateTemplateCreateInfoKHR, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkDescriptorUpdateTemplateCreateInfoKHR, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkDescriptorUpdateTemplateCreateInfoKHR, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkDescriptorUpdateTemplateCreateInfoKHR where + type FieldType "sType" VkDescriptorUpdateTemplateCreateInfoKHR = + VkStructureType + type FieldOptional "sType" VkDescriptorUpdateTemplateCreateInfoKHR + = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkDescriptorUpdateTemplateCreateInfoKHR = + #{offset VkDescriptorUpdateTemplateCreateInfoKHR, sType} + type FieldIsArray "sType" VkDescriptorUpdateTemplateCreateInfoKHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDescriptorUpdateTemplateCreateInfoKHR, sType} + +instance CanReadField "sType" + VkDescriptorUpdateTemplateCreateInfoKHR + where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" + VkDescriptorUpdateTemplateCreateInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkDescriptorUpdateTemplateCreateInfoKHR where + type VkPNextMType VkDescriptorUpdateTemplateCreateInfoKHR = + Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDescriptorUpdateTemplateCreateInfoKHR, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkDescriptorUpdateTemplateCreateInfoKHR, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkDescriptorUpdateTemplateCreateInfoKHR, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkDescriptorUpdateTemplateCreateInfoKHR, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkDescriptorUpdateTemplateCreateInfoKHR where + type FieldType "pNext" VkDescriptorUpdateTemplateCreateInfoKHR = + Ptr Void + type FieldOptional "pNext" VkDescriptorUpdateTemplateCreateInfoKHR + = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkDescriptorUpdateTemplateCreateInfoKHR = + #{offset VkDescriptorUpdateTemplateCreateInfoKHR, pNext} + type FieldIsArray "pNext" VkDescriptorUpdateTemplateCreateInfoKHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDescriptorUpdateTemplateCreateInfoKHR, pNext} + +instance CanReadField "pNext" + VkDescriptorUpdateTemplateCreateInfoKHR + where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" + VkDescriptorUpdateTemplateCreateInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkFlags VkDescriptorUpdateTemplateCreateInfoKHR where + type VkFlagsMType VkDescriptorUpdateTemplateCreateInfoKHR = + VkDescriptorUpdateTemplateCreateFlagsKHR + + {-# NOINLINE vkFlags #-} + vkFlags x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDescriptorUpdateTemplateCreateInfoKHR, flags}) + + {-# INLINE vkFlagsByteOffset #-} + vkFlagsByteOffset ~_ + = #{offset VkDescriptorUpdateTemplateCreateInfoKHR, flags} + + {-# INLINE readVkFlags #-} + readVkFlags p + = peekByteOff p #{offset VkDescriptorUpdateTemplateCreateInfoKHR, flags} + + {-# INLINE writeVkFlags #-} + writeVkFlags p + = pokeByteOff p #{offset VkDescriptorUpdateTemplateCreateInfoKHR, flags} + +instance {-# OVERLAPPING #-} + HasField "flags" VkDescriptorUpdateTemplateCreateInfoKHR where + type FieldType "flags" VkDescriptorUpdateTemplateCreateInfoKHR = + VkDescriptorUpdateTemplateCreateFlagsKHR + type FieldOptional "flags" VkDescriptorUpdateTemplateCreateInfoKHR + = 'True -- ' closing tick for hsc2hs + type FieldOffset "flags" VkDescriptorUpdateTemplateCreateInfoKHR = + #{offset VkDescriptorUpdateTemplateCreateInfoKHR, flags} + type FieldIsArray "flags" VkDescriptorUpdateTemplateCreateInfoKHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDescriptorUpdateTemplateCreateInfoKHR, flags} + +instance CanReadField "flags" + VkDescriptorUpdateTemplateCreateInfoKHR + where + {-# INLINE getField #-} + getField = vkFlags + + {-# INLINE readField #-} + readField = readVkFlags + +instance CanWriteField "flags" + VkDescriptorUpdateTemplateCreateInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkFlags + +instance {-# OVERLAPPING #-} + HasVkDescriptorUpdateEntryCount + VkDescriptorUpdateTemplateCreateInfoKHR + where + type VkDescriptorUpdateEntryCountMType + VkDescriptorUpdateTemplateCreateInfoKHR + = Word32 + + {-# NOINLINE vkDescriptorUpdateEntryCount #-} + vkDescriptorUpdateEntryCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDescriptorUpdateTemplateCreateInfoKHR, descriptorUpdateEntryCount}) + + {-# INLINE vkDescriptorUpdateEntryCountByteOffset #-} + vkDescriptorUpdateEntryCountByteOffset ~_ + = #{offset VkDescriptorUpdateTemplateCreateInfoKHR, descriptorUpdateEntryCount} + + {-# INLINE readVkDescriptorUpdateEntryCount #-} + readVkDescriptorUpdateEntryCount p + = peekByteOff p #{offset VkDescriptorUpdateTemplateCreateInfoKHR, descriptorUpdateEntryCount} + + {-# INLINE writeVkDescriptorUpdateEntryCount #-} + writeVkDescriptorUpdateEntryCount p + = pokeByteOff p #{offset VkDescriptorUpdateTemplateCreateInfoKHR, descriptorUpdateEntryCount} + +instance {-# OVERLAPPING #-} + HasField "descriptorUpdateEntryCount" + VkDescriptorUpdateTemplateCreateInfoKHR + where + type FieldType "descriptorUpdateEntryCount" + VkDescriptorUpdateTemplateCreateInfoKHR + = Word32 + type FieldOptional "descriptorUpdateEntryCount" + VkDescriptorUpdateTemplateCreateInfoKHR + = 'False -- ' closing tick for hsc2hs + type FieldOffset "descriptorUpdateEntryCount" + VkDescriptorUpdateTemplateCreateInfoKHR + = + #{offset VkDescriptorUpdateTemplateCreateInfoKHR, descriptorUpdateEntryCount} + type FieldIsArray "descriptorUpdateEntryCount" + VkDescriptorUpdateTemplateCreateInfoKHR + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDescriptorUpdateTemplateCreateInfoKHR, descriptorUpdateEntryCount} + +instance CanReadField "descriptorUpdateEntryCount" + VkDescriptorUpdateTemplateCreateInfoKHR + where + {-# INLINE getField #-} + getField = vkDescriptorUpdateEntryCount + + {-# INLINE readField #-} + readField = readVkDescriptorUpdateEntryCount + +instance CanWriteField "descriptorUpdateEntryCount" + VkDescriptorUpdateTemplateCreateInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkDescriptorUpdateEntryCount + +instance {-# OVERLAPPING #-} + HasVkPDescriptorUpdateEntries + VkDescriptorUpdateTemplateCreateInfoKHR + where + type VkPDescriptorUpdateEntriesMType + VkDescriptorUpdateTemplateCreateInfoKHR + = Ptr VkDescriptorUpdateTemplateEntryKHR + + {-# NOINLINE vkPDescriptorUpdateEntries #-} + vkPDescriptorUpdateEntries x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDescriptorUpdateTemplateCreateInfoKHR, pDescriptorUpdateEntries}) + + {-# INLINE vkPDescriptorUpdateEntriesByteOffset #-} + vkPDescriptorUpdateEntriesByteOffset ~_ + = #{offset VkDescriptorUpdateTemplateCreateInfoKHR, pDescriptorUpdateEntries} + + {-# INLINE readVkPDescriptorUpdateEntries #-} + readVkPDescriptorUpdateEntries p + = peekByteOff p #{offset VkDescriptorUpdateTemplateCreateInfoKHR, pDescriptorUpdateEntries} + + {-# INLINE writeVkPDescriptorUpdateEntries #-} + writeVkPDescriptorUpdateEntries p + = pokeByteOff p #{offset VkDescriptorUpdateTemplateCreateInfoKHR, pDescriptorUpdateEntries} + +instance {-# OVERLAPPING #-} + HasField "pDescriptorUpdateEntries" + VkDescriptorUpdateTemplateCreateInfoKHR + where + type FieldType "pDescriptorUpdateEntries" + VkDescriptorUpdateTemplateCreateInfoKHR + = Ptr VkDescriptorUpdateTemplateEntryKHR + type FieldOptional "pDescriptorUpdateEntries" + VkDescriptorUpdateTemplateCreateInfoKHR + = 'False -- ' closing tick for hsc2hs + type FieldOffset "pDescriptorUpdateEntries" + VkDescriptorUpdateTemplateCreateInfoKHR + = + #{offset VkDescriptorUpdateTemplateCreateInfoKHR, pDescriptorUpdateEntries} + type FieldIsArray "pDescriptorUpdateEntries" + VkDescriptorUpdateTemplateCreateInfoKHR + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDescriptorUpdateTemplateCreateInfoKHR, pDescriptorUpdateEntries} + +instance CanReadField "pDescriptorUpdateEntries" + VkDescriptorUpdateTemplateCreateInfoKHR + where + {-# INLINE getField #-} + getField = vkPDescriptorUpdateEntries + + {-# INLINE readField #-} + readField = readVkPDescriptorUpdateEntries + +instance CanWriteField "pDescriptorUpdateEntries" + VkDescriptorUpdateTemplateCreateInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkPDescriptorUpdateEntries + +instance {-# OVERLAPPING #-} + HasVkTemplateType VkDescriptorUpdateTemplateCreateInfoKHR where + type VkTemplateTypeMType VkDescriptorUpdateTemplateCreateInfoKHR = + VkDescriptorUpdateTemplateTypeKHR + + {-# NOINLINE vkTemplateType #-} + vkTemplateType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDescriptorUpdateTemplateCreateInfoKHR, templateType}) + + {-# INLINE vkTemplateTypeByteOffset #-} + vkTemplateTypeByteOffset ~_ + = #{offset VkDescriptorUpdateTemplateCreateInfoKHR, templateType} + + {-# INLINE readVkTemplateType #-} + readVkTemplateType p + = peekByteOff p #{offset VkDescriptorUpdateTemplateCreateInfoKHR, templateType} + + {-# INLINE writeVkTemplateType #-} + writeVkTemplateType p + = pokeByteOff p #{offset VkDescriptorUpdateTemplateCreateInfoKHR, templateType} + +instance {-# OVERLAPPING #-} + HasField "templateType" VkDescriptorUpdateTemplateCreateInfoKHR + where + type FieldType "templateType" + VkDescriptorUpdateTemplateCreateInfoKHR + = VkDescriptorUpdateTemplateTypeKHR + type FieldOptional "templateType" + VkDescriptorUpdateTemplateCreateInfoKHR + = 'False -- ' closing tick for hsc2hs + type FieldOffset "templateType" + VkDescriptorUpdateTemplateCreateInfoKHR + = + #{offset VkDescriptorUpdateTemplateCreateInfoKHR, templateType} + type FieldIsArray "templateType" + VkDescriptorUpdateTemplateCreateInfoKHR + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDescriptorUpdateTemplateCreateInfoKHR, templateType} + +instance CanReadField "templateType" + VkDescriptorUpdateTemplateCreateInfoKHR + where + {-# INLINE getField #-} + getField = vkTemplateType + + {-# INLINE readField #-} + readField = readVkTemplateType + +instance CanWriteField "templateType" + VkDescriptorUpdateTemplateCreateInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkTemplateType + +instance {-# OVERLAPPING #-} + HasVkDescriptorSetLayout VkDescriptorUpdateTemplateCreateInfoKHR + where + type VkDescriptorSetLayoutMType + VkDescriptorUpdateTemplateCreateInfoKHR + = VkDescriptorSetLayout + + {-# NOINLINE vkDescriptorSetLayout #-} + vkDescriptorSetLayout x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDescriptorUpdateTemplateCreateInfoKHR, descriptorSetLayout}) + + {-# INLINE vkDescriptorSetLayoutByteOffset #-} + vkDescriptorSetLayoutByteOffset ~_ + = #{offset VkDescriptorUpdateTemplateCreateInfoKHR, descriptorSetLayout} + + {-# INLINE readVkDescriptorSetLayout #-} + readVkDescriptorSetLayout p + = peekByteOff p #{offset VkDescriptorUpdateTemplateCreateInfoKHR, descriptorSetLayout} + + {-# INLINE writeVkDescriptorSetLayout #-} + writeVkDescriptorSetLayout p + = pokeByteOff p #{offset VkDescriptorUpdateTemplateCreateInfoKHR, descriptorSetLayout} + +instance {-# OVERLAPPING #-} + HasField "descriptorSetLayout" + VkDescriptorUpdateTemplateCreateInfoKHR + where + type FieldType "descriptorSetLayout" + VkDescriptorUpdateTemplateCreateInfoKHR + = VkDescriptorSetLayout + type FieldOptional "descriptorSetLayout" + VkDescriptorUpdateTemplateCreateInfoKHR + = 'True -- ' closing tick for hsc2hs + type FieldOffset "descriptorSetLayout" + VkDescriptorUpdateTemplateCreateInfoKHR + = + #{offset VkDescriptorUpdateTemplateCreateInfoKHR, descriptorSetLayout} + type FieldIsArray "descriptorSetLayout" + VkDescriptorUpdateTemplateCreateInfoKHR + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDescriptorUpdateTemplateCreateInfoKHR, descriptorSetLayout} + +instance CanReadField "descriptorSetLayout" + VkDescriptorUpdateTemplateCreateInfoKHR + where + {-# INLINE getField #-} + getField = vkDescriptorSetLayout + + {-# INLINE readField #-} + readField = readVkDescriptorSetLayout + +instance CanWriteField "descriptorSetLayout" + VkDescriptorUpdateTemplateCreateInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkDescriptorSetLayout + +instance {-# OVERLAPPING #-} + HasVkPipelineBindPoint VkDescriptorUpdateTemplateCreateInfoKHR + where + type VkPipelineBindPointMType + VkDescriptorUpdateTemplateCreateInfoKHR + = VkPipelineBindPoint + + {-# NOINLINE vkPipelineBindPoint #-} + vkPipelineBindPoint x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDescriptorUpdateTemplateCreateInfoKHR, pipelineBindPoint}) + + {-# INLINE vkPipelineBindPointByteOffset #-} + vkPipelineBindPointByteOffset ~_ + = #{offset VkDescriptorUpdateTemplateCreateInfoKHR, pipelineBindPoint} + + {-# INLINE readVkPipelineBindPoint #-} + readVkPipelineBindPoint p + = peekByteOff p #{offset VkDescriptorUpdateTemplateCreateInfoKHR, pipelineBindPoint} + + {-# INLINE writeVkPipelineBindPoint #-} + writeVkPipelineBindPoint p + = pokeByteOff p #{offset VkDescriptorUpdateTemplateCreateInfoKHR, pipelineBindPoint} + +instance {-# OVERLAPPING #-} + HasField "pipelineBindPoint" + VkDescriptorUpdateTemplateCreateInfoKHR + where + type FieldType "pipelineBindPoint" + VkDescriptorUpdateTemplateCreateInfoKHR + = VkPipelineBindPoint + type FieldOptional "pipelineBindPoint" + VkDescriptorUpdateTemplateCreateInfoKHR + = 'True -- ' closing tick for hsc2hs + type FieldOffset "pipelineBindPoint" + VkDescriptorUpdateTemplateCreateInfoKHR + = + #{offset VkDescriptorUpdateTemplateCreateInfoKHR, pipelineBindPoint} + type FieldIsArray "pipelineBindPoint" + VkDescriptorUpdateTemplateCreateInfoKHR + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDescriptorUpdateTemplateCreateInfoKHR, pipelineBindPoint} + +instance CanReadField "pipelineBindPoint" + VkDescriptorUpdateTemplateCreateInfoKHR + where + {-# INLINE getField #-} + getField = vkPipelineBindPoint + + {-# INLINE readField #-} + readField = readVkPipelineBindPoint + +instance CanWriteField "pipelineBindPoint" + VkDescriptorUpdateTemplateCreateInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkPipelineBindPoint + +instance {-# OVERLAPPING #-} + HasVkPipelineLayout VkDescriptorUpdateTemplateCreateInfoKHR where + type VkPipelineLayoutMType VkDescriptorUpdateTemplateCreateInfoKHR + = VkPipelineLayout + + {-# NOINLINE vkPipelineLayout #-} + vkPipelineLayout x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDescriptorUpdateTemplateCreateInfoKHR, pipelineLayout}) + + {-# INLINE vkPipelineLayoutByteOffset #-} + vkPipelineLayoutByteOffset ~_ + = #{offset VkDescriptorUpdateTemplateCreateInfoKHR, pipelineLayout} + + {-# INLINE readVkPipelineLayout #-} + readVkPipelineLayout p + = peekByteOff p #{offset VkDescriptorUpdateTemplateCreateInfoKHR, pipelineLayout} + + {-# INLINE writeVkPipelineLayout #-} + writeVkPipelineLayout p + = pokeByteOff p #{offset VkDescriptorUpdateTemplateCreateInfoKHR, pipelineLayout} + +instance {-# OVERLAPPING #-} + HasField "pipelineLayout" VkDescriptorUpdateTemplateCreateInfoKHR + where + type FieldType "pipelineLayout" + VkDescriptorUpdateTemplateCreateInfoKHR + = VkPipelineLayout + type FieldOptional "pipelineLayout" + VkDescriptorUpdateTemplateCreateInfoKHR + = 'True -- ' closing tick for hsc2hs + type FieldOffset "pipelineLayout" + VkDescriptorUpdateTemplateCreateInfoKHR + = + #{offset VkDescriptorUpdateTemplateCreateInfoKHR, pipelineLayout} + type FieldIsArray "pipelineLayout" + VkDescriptorUpdateTemplateCreateInfoKHR + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDescriptorUpdateTemplateCreateInfoKHR, pipelineLayout} + +instance CanReadField "pipelineLayout" + VkDescriptorUpdateTemplateCreateInfoKHR + where + {-# INLINE getField #-} + getField = vkPipelineLayout + + {-# INLINE readField #-} + readField = readVkPipelineLayout + +instance CanWriteField "pipelineLayout" + VkDescriptorUpdateTemplateCreateInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkPipelineLayout + +instance {-# OVERLAPPING #-} + HasVkSet VkDescriptorUpdateTemplateCreateInfoKHR where + type VkSetMType VkDescriptorUpdateTemplateCreateInfoKHR = Word32 + + {-# NOINLINE vkSet #-} + vkSet x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDescriptorUpdateTemplateCreateInfoKHR, set}) + + {-# INLINE vkSetByteOffset #-} + vkSetByteOffset ~_ + = #{offset VkDescriptorUpdateTemplateCreateInfoKHR, set} + + {-# INLINE readVkSet #-} + readVkSet p + = peekByteOff p #{offset VkDescriptorUpdateTemplateCreateInfoKHR, set} + + {-# INLINE writeVkSet #-} + writeVkSet p + = pokeByteOff p #{offset VkDescriptorUpdateTemplateCreateInfoKHR, set} + +instance {-# OVERLAPPING #-} + HasField "set" VkDescriptorUpdateTemplateCreateInfoKHR where + type FieldType "set" VkDescriptorUpdateTemplateCreateInfoKHR = + Word32 + type FieldOptional "set" VkDescriptorUpdateTemplateCreateInfoKHR = + 'True -- ' closing tick for hsc2hs + type FieldOffset "set" VkDescriptorUpdateTemplateCreateInfoKHR = + #{offset VkDescriptorUpdateTemplateCreateInfoKHR, set} + type FieldIsArray "set" VkDescriptorUpdateTemplateCreateInfoKHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDescriptorUpdateTemplateCreateInfoKHR, set} + +instance CanReadField "set" VkDescriptorUpdateTemplateCreateInfoKHR + where + {-# INLINE getField #-} + getField = vkSet + + {-# INLINE readField #-} + readField = readVkSet + +instance CanWriteField "set" + VkDescriptorUpdateTemplateCreateInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkSet + +instance Show VkDescriptorUpdateTemplateCreateInfoKHR where + showsPrec d x + = showString "VkDescriptorUpdateTemplateCreateInfoKHR {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkFlags = " . + showsPrec d (vkFlags x) . + showString ", " . + showString "vkDescriptorUpdateEntryCount = " . + showsPrec d (vkDescriptorUpdateEntryCount x) . + showString ", " . + showString "vkPDescriptorUpdateEntries = " . + showsPrec d (vkPDescriptorUpdateEntries x) . + showString ", " . + showString "vkTemplateType = " . + showsPrec d (vkTemplateType x) . + showString ", " . + showString "vkDescriptorSetLayout = " . + showsPrec d (vkDescriptorSetLayout x) . + showString ", " . + showString "vkPipelineBindPoint = " . + showsPrec d (vkPipelineBindPoint x) . + showString ", " . + showString "vkPipelineLayout = " . + showsPrec d (vkPipelineLayout x) . + showString ", " . + showString "vkSet = " . + showsPrec d (vkSet x) . + showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkDescriptorUpdateTemplateEntryKHR.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkDescriptorUpdateTemplateEntryKHR.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkDescriptorUpdateTemplateEntryKHR.hsc @@ -0,0 +1,435 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkDescriptorUpdateTemplateEntryKHR + (VkDescriptorUpdateTemplateEntryKHR(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkDescriptorType (VkDescriptorType) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkDescriptorUpdateTemplateEntryKHR { +-- > uint32_t dstBinding; +-- > uint32_t dstArrayElement; +-- > uint32_t descriptorCount; +-- > VkDescriptorType descriptorType; +-- > size_t offset; +-- > size_t stride; +-- > } VkDescriptorUpdateTemplateEntryKHR; +-- +-- +data VkDescriptorUpdateTemplateEntryKHR = VkDescriptorUpdateTemplateEntryKHR## Addr## + ByteArray## + +instance Eq VkDescriptorUpdateTemplateEntryKHR where + (VkDescriptorUpdateTemplateEntryKHR## a _) == + x@(VkDescriptorUpdateTemplateEntryKHR## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkDescriptorUpdateTemplateEntryKHR where + (VkDescriptorUpdateTemplateEntryKHR## a _) `compare` + x@(VkDescriptorUpdateTemplateEntryKHR## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkDescriptorUpdateTemplateEntryKHR where + sizeOf ~_ = #{size VkDescriptorUpdateTemplateEntryKHR} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkDescriptorUpdateTemplateEntryKHR} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkDescriptorUpdateTemplateEntryKHR where + unsafeAddr (VkDescriptorUpdateTemplateEntryKHR## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkDescriptorUpdateTemplateEntryKHR## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkDescriptorUpdateTemplateEntryKHR## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkDescriptorUpdateTemplateEntryKHR where + type StructFields VkDescriptorUpdateTemplateEntryKHR = + '["dstBinding", "dstArrayElement", "descriptorCount", -- ' closing tick for hsc2hs + "descriptorType", "offset", "stride"] + type CUnionType VkDescriptorUpdateTemplateEntryKHR = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkDescriptorUpdateTemplateEntryKHR = 'False -- ' closing tick for hsc2hs + type StructExtends VkDescriptorUpdateTemplateEntryKHR = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkDstBinding VkDescriptorUpdateTemplateEntryKHR where + type VkDstBindingMType VkDescriptorUpdateTemplateEntryKHR = Word32 + + {-# NOINLINE vkDstBinding #-} + vkDstBinding x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDescriptorUpdateTemplateEntryKHR, dstBinding}) + + {-# INLINE vkDstBindingByteOffset #-} + vkDstBindingByteOffset ~_ + = #{offset VkDescriptorUpdateTemplateEntryKHR, dstBinding} + + {-# INLINE readVkDstBinding #-} + readVkDstBinding p + = peekByteOff p #{offset VkDescriptorUpdateTemplateEntryKHR, dstBinding} + + {-# INLINE writeVkDstBinding #-} + writeVkDstBinding p + = pokeByteOff p #{offset VkDescriptorUpdateTemplateEntryKHR, dstBinding} + +instance {-# OVERLAPPING #-} + HasField "dstBinding" VkDescriptorUpdateTemplateEntryKHR where + type FieldType "dstBinding" VkDescriptorUpdateTemplateEntryKHR = + Word32 + type FieldOptional "dstBinding" VkDescriptorUpdateTemplateEntryKHR + = 'False -- ' closing tick for hsc2hs + type FieldOffset "dstBinding" VkDescriptorUpdateTemplateEntryKHR = + #{offset VkDescriptorUpdateTemplateEntryKHR, dstBinding} + type FieldIsArray "dstBinding" VkDescriptorUpdateTemplateEntryKHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDescriptorUpdateTemplateEntryKHR, dstBinding} + +instance CanReadField "dstBinding" + VkDescriptorUpdateTemplateEntryKHR + where + {-# INLINE getField #-} + getField = vkDstBinding + + {-# INLINE readField #-} + readField = readVkDstBinding + +instance CanWriteField "dstBinding" + VkDescriptorUpdateTemplateEntryKHR + where + {-# INLINE writeField #-} + writeField = writeVkDstBinding + +instance {-# OVERLAPPING #-} + HasVkDstArrayElement VkDescriptorUpdateTemplateEntryKHR where + type VkDstArrayElementMType VkDescriptorUpdateTemplateEntryKHR = + Word32 + + {-# NOINLINE vkDstArrayElement #-} + vkDstArrayElement x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDescriptorUpdateTemplateEntryKHR, dstArrayElement}) + + {-# INLINE vkDstArrayElementByteOffset #-} + vkDstArrayElementByteOffset ~_ + = #{offset VkDescriptorUpdateTemplateEntryKHR, dstArrayElement} + + {-# INLINE readVkDstArrayElement #-} + readVkDstArrayElement p + = peekByteOff p #{offset VkDescriptorUpdateTemplateEntryKHR, dstArrayElement} + + {-# INLINE writeVkDstArrayElement #-} + writeVkDstArrayElement p + = pokeByteOff p #{offset VkDescriptorUpdateTemplateEntryKHR, dstArrayElement} + +instance {-# OVERLAPPING #-} + HasField "dstArrayElement" VkDescriptorUpdateTemplateEntryKHR where + type FieldType "dstArrayElement" VkDescriptorUpdateTemplateEntryKHR + = Word32 + type FieldOptional "dstArrayElement" + VkDescriptorUpdateTemplateEntryKHR + = 'False -- ' closing tick for hsc2hs + type FieldOffset "dstArrayElement" + VkDescriptorUpdateTemplateEntryKHR + = + #{offset VkDescriptorUpdateTemplateEntryKHR, dstArrayElement} + type FieldIsArray "dstArrayElement" + VkDescriptorUpdateTemplateEntryKHR + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDescriptorUpdateTemplateEntryKHR, dstArrayElement} + +instance CanReadField "dstArrayElement" + VkDescriptorUpdateTemplateEntryKHR + where + {-# INLINE getField #-} + getField = vkDstArrayElement + + {-# INLINE readField #-} + readField = readVkDstArrayElement + +instance CanWriteField "dstArrayElement" + VkDescriptorUpdateTemplateEntryKHR + where + {-# INLINE writeField #-} + writeField = writeVkDstArrayElement + +instance {-# OVERLAPPING #-} + HasVkDescriptorCount VkDescriptorUpdateTemplateEntryKHR where + type VkDescriptorCountMType VkDescriptorUpdateTemplateEntryKHR = + Word32 + + {-# NOINLINE vkDescriptorCount #-} + vkDescriptorCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDescriptorUpdateTemplateEntryKHR, descriptorCount}) + + {-# INLINE vkDescriptorCountByteOffset #-} + vkDescriptorCountByteOffset ~_ + = #{offset VkDescriptorUpdateTemplateEntryKHR, descriptorCount} + + {-# INLINE readVkDescriptorCount #-} + readVkDescriptorCount p + = peekByteOff p #{offset VkDescriptorUpdateTemplateEntryKHR, descriptorCount} + + {-# INLINE writeVkDescriptorCount #-} + writeVkDescriptorCount p + = pokeByteOff p #{offset VkDescriptorUpdateTemplateEntryKHR, descriptorCount} + +instance {-# OVERLAPPING #-} + HasField "descriptorCount" VkDescriptorUpdateTemplateEntryKHR where + type FieldType "descriptorCount" VkDescriptorUpdateTemplateEntryKHR + = Word32 + type FieldOptional "descriptorCount" + VkDescriptorUpdateTemplateEntryKHR + = 'False -- ' closing tick for hsc2hs + type FieldOffset "descriptorCount" + VkDescriptorUpdateTemplateEntryKHR + = + #{offset VkDescriptorUpdateTemplateEntryKHR, descriptorCount} + type FieldIsArray "descriptorCount" + VkDescriptorUpdateTemplateEntryKHR + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDescriptorUpdateTemplateEntryKHR, descriptorCount} + +instance CanReadField "descriptorCount" + VkDescriptorUpdateTemplateEntryKHR + where + {-# INLINE getField #-} + getField = vkDescriptorCount + + {-# INLINE readField #-} + readField = readVkDescriptorCount + +instance CanWriteField "descriptorCount" + VkDescriptorUpdateTemplateEntryKHR + where + {-# INLINE writeField #-} + writeField = writeVkDescriptorCount + +instance {-# OVERLAPPING #-} + HasVkDescriptorType VkDescriptorUpdateTemplateEntryKHR where + type VkDescriptorTypeMType VkDescriptorUpdateTemplateEntryKHR = + VkDescriptorType + + {-# NOINLINE vkDescriptorType #-} + vkDescriptorType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDescriptorUpdateTemplateEntryKHR, descriptorType}) + + {-# INLINE vkDescriptorTypeByteOffset #-} + vkDescriptorTypeByteOffset ~_ + = #{offset VkDescriptorUpdateTemplateEntryKHR, descriptorType} + + {-# INLINE readVkDescriptorType #-} + readVkDescriptorType p + = peekByteOff p #{offset VkDescriptorUpdateTemplateEntryKHR, descriptorType} + + {-# INLINE writeVkDescriptorType #-} + writeVkDescriptorType p + = pokeByteOff p #{offset VkDescriptorUpdateTemplateEntryKHR, descriptorType} + +instance {-# OVERLAPPING #-} + HasField "descriptorType" VkDescriptorUpdateTemplateEntryKHR where + type FieldType "descriptorType" VkDescriptorUpdateTemplateEntryKHR + = VkDescriptorType + type FieldOptional "descriptorType" + VkDescriptorUpdateTemplateEntryKHR + = 'False -- ' closing tick for hsc2hs + type FieldOffset "descriptorType" + VkDescriptorUpdateTemplateEntryKHR + = + #{offset VkDescriptorUpdateTemplateEntryKHR, descriptorType} + type FieldIsArray "descriptorType" + VkDescriptorUpdateTemplateEntryKHR + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDescriptorUpdateTemplateEntryKHR, descriptorType} + +instance CanReadField "descriptorType" + VkDescriptorUpdateTemplateEntryKHR + where + {-# INLINE getField #-} + getField = vkDescriptorType + + {-# INLINE readField #-} + readField = readVkDescriptorType + +instance CanWriteField "descriptorType" + VkDescriptorUpdateTemplateEntryKHR + where + {-# INLINE writeField #-} + writeField = writeVkDescriptorType + +instance {-# OVERLAPPING #-} + HasVkOffset VkDescriptorUpdateTemplateEntryKHR where + type VkOffsetMType VkDescriptorUpdateTemplateEntryKHR = CSize + + {-# NOINLINE vkOffset #-} + vkOffset x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDescriptorUpdateTemplateEntryKHR, offset}) + + {-# INLINE vkOffsetByteOffset #-} + vkOffsetByteOffset ~_ + = #{offset VkDescriptorUpdateTemplateEntryKHR, offset} + + {-# INLINE readVkOffset #-} + readVkOffset p + = peekByteOff p #{offset VkDescriptorUpdateTemplateEntryKHR, offset} + + {-# INLINE writeVkOffset #-} + writeVkOffset p + = pokeByteOff p #{offset VkDescriptorUpdateTemplateEntryKHR, offset} + +instance {-# OVERLAPPING #-} + HasField "offset" VkDescriptorUpdateTemplateEntryKHR where + type FieldType "offset" VkDescriptorUpdateTemplateEntryKHR = CSize + type FieldOptional "offset" VkDescriptorUpdateTemplateEntryKHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "offset" VkDescriptorUpdateTemplateEntryKHR = + #{offset VkDescriptorUpdateTemplateEntryKHR, offset} + type FieldIsArray "offset" VkDescriptorUpdateTemplateEntryKHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDescriptorUpdateTemplateEntryKHR, offset} + +instance CanReadField "offset" VkDescriptorUpdateTemplateEntryKHR + where + {-# INLINE getField #-} + getField = vkOffset + + {-# INLINE readField #-} + readField = readVkOffset + +instance CanWriteField "offset" VkDescriptorUpdateTemplateEntryKHR + where + {-# INLINE writeField #-} + writeField = writeVkOffset + +instance {-# OVERLAPPING #-} + HasVkStride VkDescriptorUpdateTemplateEntryKHR where + type VkStrideMType VkDescriptorUpdateTemplateEntryKHR = CSize + + {-# NOINLINE vkStride #-} + vkStride x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDescriptorUpdateTemplateEntryKHR, stride}) + + {-# INLINE vkStrideByteOffset #-} + vkStrideByteOffset ~_ + = #{offset VkDescriptorUpdateTemplateEntryKHR, stride} + + {-# INLINE readVkStride #-} + readVkStride p + = peekByteOff p #{offset VkDescriptorUpdateTemplateEntryKHR, stride} + + {-# INLINE writeVkStride #-} + writeVkStride p + = pokeByteOff p #{offset VkDescriptorUpdateTemplateEntryKHR, stride} + +instance {-# OVERLAPPING #-} + HasField "stride" VkDescriptorUpdateTemplateEntryKHR where + type FieldType "stride" VkDescriptorUpdateTemplateEntryKHR = CSize + type FieldOptional "stride" VkDescriptorUpdateTemplateEntryKHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "stride" VkDescriptorUpdateTemplateEntryKHR = + #{offset VkDescriptorUpdateTemplateEntryKHR, stride} + type FieldIsArray "stride" VkDescriptorUpdateTemplateEntryKHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDescriptorUpdateTemplateEntryKHR, stride} + +instance CanReadField "stride" VkDescriptorUpdateTemplateEntryKHR + where + {-# INLINE getField #-} + getField = vkStride + + {-# INLINE readField #-} + readField = readVkStride + +instance CanWriteField "stride" VkDescriptorUpdateTemplateEntryKHR + where + {-# INLINE writeField #-} + writeField = writeVkStride + +instance Show VkDescriptorUpdateTemplateEntryKHR where + showsPrec d x + = showString "VkDescriptorUpdateTemplateEntryKHR {" . + showString "vkDstBinding = " . + showsPrec d (vkDstBinding x) . + showString ", " . + showString "vkDstArrayElement = " . + showsPrec d (vkDstArrayElement x) . + showString ", " . + showString "vkDescriptorCount = " . + showsPrec d (vkDescriptorCount x) . + showString ", " . + showString "vkDescriptorType = " . + showsPrec d (vkDescriptorType x) . + showString ", " . + showString "vkOffset = " . + showsPrec d (vkOffset x) . + showString ", " . + showString "vkStride = " . + showsPrec d (vkStride x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkDeviceCreateInfo.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkDeviceCreateInfo.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkDeviceCreateInfo.hsc @@ -0,0 +1,611 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkDeviceCreateInfo + (VkDeviceCreateInfo(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Bitmasks (VkDeviceCreateFlags) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Struct.VkDeviceQueueCreateInfo (VkDeviceQueueCreateInfo) +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceFeatures (VkPhysicalDeviceFeatures) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkDeviceCreateInfo { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkDeviceCreateFlags flags; +-- > uint32_t queueCreateInfoCount; +-- > const VkDeviceQueueCreateInfo* pQueueCreateInfos; +-- > uint32_t enabledLayerCount; +-- > const char* const* ppEnabledLayerNames; +-- > uint32_t enabledExtensionCount; +-- > const char* const* ppEnabledExtensionNames; +-- > const VkPhysicalDeviceFeatures* pEnabledFeatures; +-- > } VkDeviceCreateInfo; +-- +-- +data VkDeviceCreateInfo = VkDeviceCreateInfo## Addr## ByteArray## + +instance Eq VkDeviceCreateInfo where + (VkDeviceCreateInfo## a _) == x@(VkDeviceCreateInfo## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkDeviceCreateInfo where + (VkDeviceCreateInfo## a _) `compare` x@(VkDeviceCreateInfo## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkDeviceCreateInfo where + sizeOf ~_ = #{size VkDeviceCreateInfo} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkDeviceCreateInfo} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkDeviceCreateInfo where + unsafeAddr (VkDeviceCreateInfo## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkDeviceCreateInfo## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkDeviceCreateInfo## (plusAddr## (byteArrayContents## b) off) b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkDeviceCreateInfo where + type StructFields VkDeviceCreateInfo = + '["sType", "pNext", "flags", "queueCreateInfoCount", -- ' closing tick for hsc2hs + "pQueueCreateInfos", "enabledLayerCount", "ppEnabledLayerNames", + "enabledExtensionCount", "ppEnabledExtensionNames", + "pEnabledFeatures"] + type CUnionType VkDeviceCreateInfo = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkDeviceCreateInfo = 'False -- ' closing tick for hsc2hs + type StructExtends VkDeviceCreateInfo = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkSType VkDeviceCreateInfo where + type VkSTypeMType VkDeviceCreateInfo = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDeviceCreateInfo, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkDeviceCreateInfo, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkDeviceCreateInfo, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkDeviceCreateInfo, sType} + +instance {-# OVERLAPPING #-} HasField "sType" VkDeviceCreateInfo + where + type FieldType "sType" VkDeviceCreateInfo = VkStructureType + type FieldOptional "sType" VkDeviceCreateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkDeviceCreateInfo = + #{offset VkDeviceCreateInfo, sType} + type FieldIsArray "sType" VkDeviceCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkDeviceCreateInfo, sType} + +instance CanReadField "sType" VkDeviceCreateInfo where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkDeviceCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} HasVkPNext VkDeviceCreateInfo where + type VkPNextMType VkDeviceCreateInfo = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDeviceCreateInfo, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkDeviceCreateInfo, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkDeviceCreateInfo, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkDeviceCreateInfo, pNext} + +instance {-# OVERLAPPING #-} HasField "pNext" VkDeviceCreateInfo + where + type FieldType "pNext" VkDeviceCreateInfo = Ptr Void + type FieldOptional "pNext" VkDeviceCreateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkDeviceCreateInfo = + #{offset VkDeviceCreateInfo, pNext} + type FieldIsArray "pNext" VkDeviceCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkDeviceCreateInfo, pNext} + +instance CanReadField "pNext" VkDeviceCreateInfo where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkDeviceCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} HasVkFlags VkDeviceCreateInfo where + type VkFlagsMType VkDeviceCreateInfo = VkDeviceCreateFlags + + {-# NOINLINE vkFlags #-} + vkFlags x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDeviceCreateInfo, flags}) + + {-# INLINE vkFlagsByteOffset #-} + vkFlagsByteOffset ~_ + = #{offset VkDeviceCreateInfo, flags} + + {-# INLINE readVkFlags #-} + readVkFlags p + = peekByteOff p #{offset VkDeviceCreateInfo, flags} + + {-# INLINE writeVkFlags #-} + writeVkFlags p + = pokeByteOff p #{offset VkDeviceCreateInfo, flags} + +instance {-# OVERLAPPING #-} HasField "flags" VkDeviceCreateInfo + where + type FieldType "flags" VkDeviceCreateInfo = VkDeviceCreateFlags + type FieldOptional "flags" VkDeviceCreateInfo = 'True -- ' closing tick for hsc2hs + type FieldOffset "flags" VkDeviceCreateInfo = + #{offset VkDeviceCreateInfo, flags} + type FieldIsArray "flags" VkDeviceCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkDeviceCreateInfo, flags} + +instance CanReadField "flags" VkDeviceCreateInfo where + {-# INLINE getField #-} + getField = vkFlags + + {-# INLINE readField #-} + readField = readVkFlags + +instance CanWriteField "flags" VkDeviceCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkFlags + +instance {-# OVERLAPPING #-} + HasVkQueueCreateInfoCount VkDeviceCreateInfo where + type VkQueueCreateInfoCountMType VkDeviceCreateInfo = Word32 + + {-# NOINLINE vkQueueCreateInfoCount #-} + vkQueueCreateInfoCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDeviceCreateInfo, queueCreateInfoCount}) + + {-# INLINE vkQueueCreateInfoCountByteOffset #-} + vkQueueCreateInfoCountByteOffset ~_ + = #{offset VkDeviceCreateInfo, queueCreateInfoCount} + + {-# INLINE readVkQueueCreateInfoCount #-} + readVkQueueCreateInfoCount p + = peekByteOff p #{offset VkDeviceCreateInfo, queueCreateInfoCount} + + {-# INLINE writeVkQueueCreateInfoCount #-} + writeVkQueueCreateInfoCount p + = pokeByteOff p #{offset VkDeviceCreateInfo, queueCreateInfoCount} + +instance {-# OVERLAPPING #-} + HasField "queueCreateInfoCount" VkDeviceCreateInfo where + type FieldType "queueCreateInfoCount" VkDeviceCreateInfo = Word32 + type FieldOptional "queueCreateInfoCount" VkDeviceCreateInfo = + 'False -- ' closing tick for hsc2hs + type FieldOffset "queueCreateInfoCount" VkDeviceCreateInfo = + #{offset VkDeviceCreateInfo, queueCreateInfoCount} + type FieldIsArray "queueCreateInfoCount" VkDeviceCreateInfo = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDeviceCreateInfo, queueCreateInfoCount} + +instance CanReadField "queueCreateInfoCount" VkDeviceCreateInfo + where + {-# INLINE getField #-} + getField = vkQueueCreateInfoCount + + {-# INLINE readField #-} + readField = readVkQueueCreateInfoCount + +instance CanWriteField "queueCreateInfoCount" VkDeviceCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkQueueCreateInfoCount + +instance {-# OVERLAPPING #-} + HasVkPQueueCreateInfos VkDeviceCreateInfo where + type VkPQueueCreateInfosMType VkDeviceCreateInfo = + Ptr VkDeviceQueueCreateInfo + + {-# NOINLINE vkPQueueCreateInfos #-} + vkPQueueCreateInfos x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDeviceCreateInfo, pQueueCreateInfos}) + + {-# INLINE vkPQueueCreateInfosByteOffset #-} + vkPQueueCreateInfosByteOffset ~_ + = #{offset VkDeviceCreateInfo, pQueueCreateInfos} + + {-# INLINE readVkPQueueCreateInfos #-} + readVkPQueueCreateInfos p + = peekByteOff p #{offset VkDeviceCreateInfo, pQueueCreateInfos} + + {-# INLINE writeVkPQueueCreateInfos #-} + writeVkPQueueCreateInfos p + = pokeByteOff p #{offset VkDeviceCreateInfo, pQueueCreateInfos} + +instance {-# OVERLAPPING #-} + HasField "pQueueCreateInfos" VkDeviceCreateInfo where + type FieldType "pQueueCreateInfos" VkDeviceCreateInfo = + Ptr VkDeviceQueueCreateInfo + type FieldOptional "pQueueCreateInfos" VkDeviceCreateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "pQueueCreateInfos" VkDeviceCreateInfo = + #{offset VkDeviceCreateInfo, pQueueCreateInfos} + type FieldIsArray "pQueueCreateInfos" VkDeviceCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDeviceCreateInfo, pQueueCreateInfos} + +instance CanReadField "pQueueCreateInfos" VkDeviceCreateInfo where + {-# INLINE getField #-} + getField = vkPQueueCreateInfos + + {-# INLINE readField #-} + readField = readVkPQueueCreateInfos + +instance CanWriteField "pQueueCreateInfos" VkDeviceCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkPQueueCreateInfos + +instance {-# OVERLAPPING #-} + HasVkEnabledLayerCount VkDeviceCreateInfo where + type VkEnabledLayerCountMType VkDeviceCreateInfo = Word32 + + {-# NOINLINE vkEnabledLayerCount #-} + vkEnabledLayerCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDeviceCreateInfo, enabledLayerCount}) + + {-# INLINE vkEnabledLayerCountByteOffset #-} + vkEnabledLayerCountByteOffset ~_ + = #{offset VkDeviceCreateInfo, enabledLayerCount} + + {-# INLINE readVkEnabledLayerCount #-} + readVkEnabledLayerCount p + = peekByteOff p #{offset VkDeviceCreateInfo, enabledLayerCount} + + {-# INLINE writeVkEnabledLayerCount #-} + writeVkEnabledLayerCount p + = pokeByteOff p #{offset VkDeviceCreateInfo, enabledLayerCount} + +instance {-# OVERLAPPING #-} + HasField "enabledLayerCount" VkDeviceCreateInfo where + type FieldType "enabledLayerCount" VkDeviceCreateInfo = Word32 + type FieldOptional "enabledLayerCount" VkDeviceCreateInfo = 'True -- ' closing tick for hsc2hs + type FieldOffset "enabledLayerCount" VkDeviceCreateInfo = + #{offset VkDeviceCreateInfo, enabledLayerCount} + type FieldIsArray "enabledLayerCount" VkDeviceCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDeviceCreateInfo, enabledLayerCount} + +instance CanReadField "enabledLayerCount" VkDeviceCreateInfo where + {-# INLINE getField #-} + getField = vkEnabledLayerCount + + {-# INLINE readField #-} + readField = readVkEnabledLayerCount + +instance CanWriteField "enabledLayerCount" VkDeviceCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkEnabledLayerCount + +instance {-# OVERLAPPING #-} + HasVkPpEnabledLayerNames VkDeviceCreateInfo where + type VkPpEnabledLayerNamesMType VkDeviceCreateInfo = Ptr CString + + {-# NOINLINE vkPpEnabledLayerNames #-} + vkPpEnabledLayerNames x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDeviceCreateInfo, ppEnabledLayerNames}) + + {-# INLINE vkPpEnabledLayerNamesByteOffset #-} + vkPpEnabledLayerNamesByteOffset ~_ + = #{offset VkDeviceCreateInfo, ppEnabledLayerNames} + + {-# INLINE readVkPpEnabledLayerNames #-} + readVkPpEnabledLayerNames p + = peekByteOff p #{offset VkDeviceCreateInfo, ppEnabledLayerNames} + + {-# INLINE writeVkPpEnabledLayerNames #-} + writeVkPpEnabledLayerNames p + = pokeByteOff p #{offset VkDeviceCreateInfo, ppEnabledLayerNames} + +instance {-# OVERLAPPING #-} + HasField "ppEnabledLayerNames" VkDeviceCreateInfo where + type FieldType "ppEnabledLayerNames" VkDeviceCreateInfo = + Ptr CString + type FieldOptional "ppEnabledLayerNames" VkDeviceCreateInfo = + 'False -- ' closing tick for hsc2hs + type FieldOffset "ppEnabledLayerNames" VkDeviceCreateInfo = + #{offset VkDeviceCreateInfo, ppEnabledLayerNames} + type FieldIsArray "ppEnabledLayerNames" VkDeviceCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDeviceCreateInfo, ppEnabledLayerNames} + +instance CanReadField "ppEnabledLayerNames" VkDeviceCreateInfo + where + {-# INLINE getField #-} + getField = vkPpEnabledLayerNames + + {-# INLINE readField #-} + readField = readVkPpEnabledLayerNames + +instance CanWriteField "ppEnabledLayerNames" VkDeviceCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkPpEnabledLayerNames + +instance {-# OVERLAPPING #-} + HasVkEnabledExtensionCount VkDeviceCreateInfo where + type VkEnabledExtensionCountMType VkDeviceCreateInfo = Word32 + + {-# NOINLINE vkEnabledExtensionCount #-} + vkEnabledExtensionCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDeviceCreateInfo, enabledExtensionCount}) + + {-# INLINE vkEnabledExtensionCountByteOffset #-} + vkEnabledExtensionCountByteOffset ~_ + = #{offset VkDeviceCreateInfo, enabledExtensionCount} + + {-# INLINE readVkEnabledExtensionCount #-} + readVkEnabledExtensionCount p + = peekByteOff p #{offset VkDeviceCreateInfo, enabledExtensionCount} + + {-# INLINE writeVkEnabledExtensionCount #-} + writeVkEnabledExtensionCount p + = pokeByteOff p #{offset VkDeviceCreateInfo, enabledExtensionCount} + +instance {-# OVERLAPPING #-} + HasField "enabledExtensionCount" VkDeviceCreateInfo where + type FieldType "enabledExtensionCount" VkDeviceCreateInfo = Word32 + type FieldOptional "enabledExtensionCount" VkDeviceCreateInfo = + 'True -- ' closing tick for hsc2hs + type FieldOffset "enabledExtensionCount" VkDeviceCreateInfo = + #{offset VkDeviceCreateInfo, enabledExtensionCount} + type FieldIsArray "enabledExtensionCount" VkDeviceCreateInfo = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDeviceCreateInfo, enabledExtensionCount} + +instance CanReadField "enabledExtensionCount" VkDeviceCreateInfo + where + {-# INLINE getField #-} + getField = vkEnabledExtensionCount + + {-# INLINE readField #-} + readField = readVkEnabledExtensionCount + +instance CanWriteField "enabledExtensionCount" VkDeviceCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkEnabledExtensionCount + +instance {-# OVERLAPPING #-} + HasVkPpEnabledExtensionNames VkDeviceCreateInfo where + type VkPpEnabledExtensionNamesMType VkDeviceCreateInfo = + Ptr CString + + {-# NOINLINE vkPpEnabledExtensionNames #-} + vkPpEnabledExtensionNames x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDeviceCreateInfo, ppEnabledExtensionNames}) + + {-# INLINE vkPpEnabledExtensionNamesByteOffset #-} + vkPpEnabledExtensionNamesByteOffset ~_ + = #{offset VkDeviceCreateInfo, ppEnabledExtensionNames} + + {-# INLINE readVkPpEnabledExtensionNames #-} + readVkPpEnabledExtensionNames p + = peekByteOff p #{offset VkDeviceCreateInfo, ppEnabledExtensionNames} + + {-# INLINE writeVkPpEnabledExtensionNames #-} + writeVkPpEnabledExtensionNames p + = pokeByteOff p #{offset VkDeviceCreateInfo, ppEnabledExtensionNames} + +instance {-# OVERLAPPING #-} + HasField "ppEnabledExtensionNames" VkDeviceCreateInfo where + type FieldType "ppEnabledExtensionNames" VkDeviceCreateInfo = + Ptr CString + type FieldOptional "ppEnabledExtensionNames" VkDeviceCreateInfo = + 'False -- ' closing tick for hsc2hs + type FieldOffset "ppEnabledExtensionNames" VkDeviceCreateInfo = + #{offset VkDeviceCreateInfo, ppEnabledExtensionNames} + type FieldIsArray "ppEnabledExtensionNames" VkDeviceCreateInfo = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDeviceCreateInfo, ppEnabledExtensionNames} + +instance CanReadField "ppEnabledExtensionNames" VkDeviceCreateInfo + where + {-# INLINE getField #-} + getField = vkPpEnabledExtensionNames + + {-# INLINE readField #-} + readField = readVkPpEnabledExtensionNames + +instance CanWriteField "ppEnabledExtensionNames" VkDeviceCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkPpEnabledExtensionNames + +instance {-# OVERLAPPING #-} + HasVkPEnabledFeatures VkDeviceCreateInfo where + type VkPEnabledFeaturesMType VkDeviceCreateInfo = + Ptr VkPhysicalDeviceFeatures + + {-# NOINLINE vkPEnabledFeatures #-} + vkPEnabledFeatures x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDeviceCreateInfo, pEnabledFeatures}) + + {-# INLINE vkPEnabledFeaturesByteOffset #-} + vkPEnabledFeaturesByteOffset ~_ + = #{offset VkDeviceCreateInfo, pEnabledFeatures} + + {-# INLINE readVkPEnabledFeatures #-} + readVkPEnabledFeatures p + = peekByteOff p #{offset VkDeviceCreateInfo, pEnabledFeatures} + + {-# INLINE writeVkPEnabledFeatures #-} + writeVkPEnabledFeatures p + = pokeByteOff p #{offset VkDeviceCreateInfo, pEnabledFeatures} + +instance {-# OVERLAPPING #-} + HasField "pEnabledFeatures" VkDeviceCreateInfo where + type FieldType "pEnabledFeatures" VkDeviceCreateInfo = + Ptr VkPhysicalDeviceFeatures + type FieldOptional "pEnabledFeatures" VkDeviceCreateInfo = 'True -- ' closing tick for hsc2hs + type FieldOffset "pEnabledFeatures" VkDeviceCreateInfo = + #{offset VkDeviceCreateInfo, pEnabledFeatures} + type FieldIsArray "pEnabledFeatures" VkDeviceCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDeviceCreateInfo, pEnabledFeatures} + +instance CanReadField "pEnabledFeatures" VkDeviceCreateInfo where + {-# INLINE getField #-} + getField = vkPEnabledFeatures + + {-# INLINE readField #-} + readField = readVkPEnabledFeatures + +instance CanWriteField "pEnabledFeatures" VkDeviceCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkPEnabledFeatures + +instance Show VkDeviceCreateInfo where + showsPrec d x + = showString "VkDeviceCreateInfo {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkFlags = " . + showsPrec d (vkFlags x) . + showString ", " . + showString "vkQueueCreateInfoCount = " . + showsPrec d (vkQueueCreateInfoCount x) . + showString ", " . + showString "vkPQueueCreateInfos = " . + showsPrec d (vkPQueueCreateInfos x) . + showString ", " . + showString "vkEnabledLayerCount = " . + showsPrec d (vkEnabledLayerCount x) . + showString ", " . + showString "vkPpEnabledLayerNames = " . + showsPrec d (vkPpEnabledLayerNames x) . + showString ", " . + showString "vkEnabledExtensionCount = " . + showsPrec d (vkEnabledExtensionCount x) . + showString ", " . + showString + "vkPpEnabledExtensionNames = " + . + showsPrec d + (vkPpEnabledExtensionNames x) + . + showString ", " . + showString + "vkPEnabledFeatures = " + . + showsPrec d + (vkPEnabledFeatures x) + . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkDeviceEventInfoEXT.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkDeviceEventInfoEXT.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkDeviceEventInfoEXT.hsc @@ -0,0 +1,222 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkDeviceEventInfoEXT + (VkDeviceEventInfoEXT(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkDeviceEventTypeEXT (VkDeviceEventTypeEXT) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkDeviceEventInfoEXT { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkDeviceEventTypeEXT deviceEvent; +-- > } VkDeviceEventInfoEXT; +-- +-- +data VkDeviceEventInfoEXT = VkDeviceEventInfoEXT## Addr## ByteArray## + +instance Eq VkDeviceEventInfoEXT where + (VkDeviceEventInfoEXT## a _) == x@(VkDeviceEventInfoEXT## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkDeviceEventInfoEXT where + (VkDeviceEventInfoEXT## a _) `compare` x@(VkDeviceEventInfoEXT## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkDeviceEventInfoEXT where + sizeOf ~_ = #{size VkDeviceEventInfoEXT} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkDeviceEventInfoEXT} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkDeviceEventInfoEXT where + unsafeAddr (VkDeviceEventInfoEXT## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkDeviceEventInfoEXT## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkDeviceEventInfoEXT## (plusAddr## (byteArrayContents## b) off) b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkDeviceEventInfoEXT where + type StructFields VkDeviceEventInfoEXT = + '["sType", "pNext", "deviceEvent"] -- ' closing tick for hsc2hs + type CUnionType VkDeviceEventInfoEXT = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkDeviceEventInfoEXT = 'False -- ' closing tick for hsc2hs + type StructExtends VkDeviceEventInfoEXT = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkSType VkDeviceEventInfoEXT where + type VkSTypeMType VkDeviceEventInfoEXT = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDeviceEventInfoEXT, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkDeviceEventInfoEXT, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkDeviceEventInfoEXT, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkDeviceEventInfoEXT, sType} + +instance {-# OVERLAPPING #-} HasField "sType" VkDeviceEventInfoEXT + where + type FieldType "sType" VkDeviceEventInfoEXT = VkStructureType + type FieldOptional "sType" VkDeviceEventInfoEXT = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkDeviceEventInfoEXT = + #{offset VkDeviceEventInfoEXT, sType} + type FieldIsArray "sType" VkDeviceEventInfoEXT = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkDeviceEventInfoEXT, sType} + +instance CanReadField "sType" VkDeviceEventInfoEXT where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkDeviceEventInfoEXT where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} HasVkPNext VkDeviceEventInfoEXT where + type VkPNextMType VkDeviceEventInfoEXT = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDeviceEventInfoEXT, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkDeviceEventInfoEXT, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkDeviceEventInfoEXT, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkDeviceEventInfoEXT, pNext} + +instance {-# OVERLAPPING #-} HasField "pNext" VkDeviceEventInfoEXT + where + type FieldType "pNext" VkDeviceEventInfoEXT = Ptr Void + type FieldOptional "pNext" VkDeviceEventInfoEXT = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkDeviceEventInfoEXT = + #{offset VkDeviceEventInfoEXT, pNext} + type FieldIsArray "pNext" VkDeviceEventInfoEXT = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkDeviceEventInfoEXT, pNext} + +instance CanReadField "pNext" VkDeviceEventInfoEXT where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkDeviceEventInfoEXT where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} HasVkDeviceEvent VkDeviceEventInfoEXT + where + type VkDeviceEventMType VkDeviceEventInfoEXT = VkDeviceEventTypeEXT + + {-# NOINLINE vkDeviceEvent #-} + vkDeviceEvent x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDeviceEventInfoEXT, deviceEvent}) + + {-# INLINE vkDeviceEventByteOffset #-} + vkDeviceEventByteOffset ~_ + = #{offset VkDeviceEventInfoEXT, deviceEvent} + + {-# INLINE readVkDeviceEvent #-} + readVkDeviceEvent p + = peekByteOff p #{offset VkDeviceEventInfoEXT, deviceEvent} + + {-# INLINE writeVkDeviceEvent #-} + writeVkDeviceEvent p + = pokeByteOff p #{offset VkDeviceEventInfoEXT, deviceEvent} + +instance {-# OVERLAPPING #-} + HasField "deviceEvent" VkDeviceEventInfoEXT where + type FieldType "deviceEvent" VkDeviceEventInfoEXT = + VkDeviceEventTypeEXT + type FieldOptional "deviceEvent" VkDeviceEventInfoEXT = 'False -- ' closing tick for hsc2hs + type FieldOffset "deviceEvent" VkDeviceEventInfoEXT = + #{offset VkDeviceEventInfoEXT, deviceEvent} + type FieldIsArray "deviceEvent" VkDeviceEventInfoEXT = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDeviceEventInfoEXT, deviceEvent} + +instance CanReadField "deviceEvent" VkDeviceEventInfoEXT where + {-# INLINE getField #-} + getField = vkDeviceEvent + + {-# INLINE readField #-} + readField = readVkDeviceEvent + +instance CanWriteField "deviceEvent" VkDeviceEventInfoEXT where + {-# INLINE writeField #-} + writeField = writeVkDeviceEvent + +instance Show VkDeviceEventInfoEXT where + showsPrec d x + = showString "VkDeviceEventInfoEXT {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkDeviceEvent = " . + showsPrec d (vkDeviceEvent x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkDeviceGeneratedCommandsFeaturesNVX.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkDeviceGeneratedCommandsFeaturesNVX.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkDeviceGeneratedCommandsFeaturesNVX.hsc @@ -0,0 +1,262 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkDeviceGeneratedCommandsFeaturesNVX + (VkDeviceGeneratedCommandsFeaturesNVX(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.BaseTypes (VkBool32) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkDeviceGeneratedCommandsFeaturesNVX { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkBool32 computeBindingPointSupport; +-- > } VkDeviceGeneratedCommandsFeaturesNVX; +-- +-- +data VkDeviceGeneratedCommandsFeaturesNVX = VkDeviceGeneratedCommandsFeaturesNVX## Addr## + ByteArray## + +instance Eq VkDeviceGeneratedCommandsFeaturesNVX where + (VkDeviceGeneratedCommandsFeaturesNVX## a _) == + x@(VkDeviceGeneratedCommandsFeaturesNVX## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkDeviceGeneratedCommandsFeaturesNVX where + (VkDeviceGeneratedCommandsFeaturesNVX## a _) `compare` + x@(VkDeviceGeneratedCommandsFeaturesNVX## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkDeviceGeneratedCommandsFeaturesNVX where + sizeOf ~_ + = #{size VkDeviceGeneratedCommandsFeaturesNVX} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkDeviceGeneratedCommandsFeaturesNVX} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkDeviceGeneratedCommandsFeaturesNVX + where + unsafeAddr (VkDeviceGeneratedCommandsFeaturesNVX## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkDeviceGeneratedCommandsFeaturesNVX## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkDeviceGeneratedCommandsFeaturesNVX## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkDeviceGeneratedCommandsFeaturesNVX where + type StructFields VkDeviceGeneratedCommandsFeaturesNVX = + '["sType", "pNext", "computeBindingPointSupport"] -- ' closing tick for hsc2hs + type CUnionType VkDeviceGeneratedCommandsFeaturesNVX = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkDeviceGeneratedCommandsFeaturesNVX = 'False -- ' closing tick for hsc2hs + type StructExtends VkDeviceGeneratedCommandsFeaturesNVX = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkDeviceGeneratedCommandsFeaturesNVX where + type VkSTypeMType VkDeviceGeneratedCommandsFeaturesNVX = + VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDeviceGeneratedCommandsFeaturesNVX, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkDeviceGeneratedCommandsFeaturesNVX, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkDeviceGeneratedCommandsFeaturesNVX, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkDeviceGeneratedCommandsFeaturesNVX, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkDeviceGeneratedCommandsFeaturesNVX where + type FieldType "sType" VkDeviceGeneratedCommandsFeaturesNVX = + VkStructureType + type FieldOptional "sType" VkDeviceGeneratedCommandsFeaturesNVX = + 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkDeviceGeneratedCommandsFeaturesNVX = + #{offset VkDeviceGeneratedCommandsFeaturesNVX, sType} + type FieldIsArray "sType" VkDeviceGeneratedCommandsFeaturesNVX = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDeviceGeneratedCommandsFeaturesNVX, sType} + +instance CanReadField "sType" VkDeviceGeneratedCommandsFeaturesNVX + where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkDeviceGeneratedCommandsFeaturesNVX + where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkDeviceGeneratedCommandsFeaturesNVX where + type VkPNextMType VkDeviceGeneratedCommandsFeaturesNVX = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDeviceGeneratedCommandsFeaturesNVX, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkDeviceGeneratedCommandsFeaturesNVX, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkDeviceGeneratedCommandsFeaturesNVX, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkDeviceGeneratedCommandsFeaturesNVX, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkDeviceGeneratedCommandsFeaturesNVX where + type FieldType "pNext" VkDeviceGeneratedCommandsFeaturesNVX = + Ptr Void + type FieldOptional "pNext" VkDeviceGeneratedCommandsFeaturesNVX = + 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkDeviceGeneratedCommandsFeaturesNVX = + #{offset VkDeviceGeneratedCommandsFeaturesNVX, pNext} + type FieldIsArray "pNext" VkDeviceGeneratedCommandsFeaturesNVX = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDeviceGeneratedCommandsFeaturesNVX, pNext} + +instance CanReadField "pNext" VkDeviceGeneratedCommandsFeaturesNVX + where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkDeviceGeneratedCommandsFeaturesNVX + where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkComputeBindingPointSupport + VkDeviceGeneratedCommandsFeaturesNVX + where + type VkComputeBindingPointSupportMType + VkDeviceGeneratedCommandsFeaturesNVX + = VkBool32 + + {-# NOINLINE vkComputeBindingPointSupport #-} + vkComputeBindingPointSupport x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDeviceGeneratedCommandsFeaturesNVX, computeBindingPointSupport}) + + {-# INLINE vkComputeBindingPointSupportByteOffset #-} + vkComputeBindingPointSupportByteOffset ~_ + = #{offset VkDeviceGeneratedCommandsFeaturesNVX, computeBindingPointSupport} + + {-# INLINE readVkComputeBindingPointSupport #-} + readVkComputeBindingPointSupport p + = peekByteOff p #{offset VkDeviceGeneratedCommandsFeaturesNVX, computeBindingPointSupport} + + {-# INLINE writeVkComputeBindingPointSupport #-} + writeVkComputeBindingPointSupport p + = pokeByteOff p #{offset VkDeviceGeneratedCommandsFeaturesNVX, computeBindingPointSupport} + +instance {-# OVERLAPPING #-} + HasField "computeBindingPointSupport" + VkDeviceGeneratedCommandsFeaturesNVX + where + type FieldType "computeBindingPointSupport" + VkDeviceGeneratedCommandsFeaturesNVX + = VkBool32 + type FieldOptional "computeBindingPointSupport" + VkDeviceGeneratedCommandsFeaturesNVX + = 'False -- ' closing tick for hsc2hs + type FieldOffset "computeBindingPointSupport" + VkDeviceGeneratedCommandsFeaturesNVX + = + #{offset VkDeviceGeneratedCommandsFeaturesNVX, computeBindingPointSupport} + type FieldIsArray "computeBindingPointSupport" + VkDeviceGeneratedCommandsFeaturesNVX + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDeviceGeneratedCommandsFeaturesNVX, computeBindingPointSupport} + +instance CanReadField "computeBindingPointSupport" + VkDeviceGeneratedCommandsFeaturesNVX + where + {-# INLINE getField #-} + getField = vkComputeBindingPointSupport + + {-# INLINE readField #-} + readField = readVkComputeBindingPointSupport + +instance CanWriteField "computeBindingPointSupport" + VkDeviceGeneratedCommandsFeaturesNVX + where + {-# INLINE writeField #-} + writeField = writeVkComputeBindingPointSupport + +instance Show VkDeviceGeneratedCommandsFeaturesNVX where + showsPrec d x + = showString "VkDeviceGeneratedCommandsFeaturesNVX {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkComputeBindingPointSupport = " . + showsPrec d (vkComputeBindingPointSupport x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkDeviceGeneratedCommandsLimitsNVX.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkDeviceGeneratedCommandsLimitsNVX.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkDeviceGeneratedCommandsLimitsNVX.hsc @@ -0,0 +1,541 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkDeviceGeneratedCommandsLimitsNVX + (VkDeviceGeneratedCommandsLimitsNVX(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkDeviceGeneratedCommandsLimitsNVX { +-- > VkStructureType sType; +-- > const void* pNext; +-- > uint32_t maxIndirectCommandsLayoutTokenCount; +-- > uint32_t maxObjectEntryCounts; +-- > uint32_t minSequenceCountBufferOffsetAlignment; +-- > uint32_t minSequenceIndexBufferOffsetAlignment; +-- > uint32_t minCommandsTokenBufferOffsetAlignment; +-- > } VkDeviceGeneratedCommandsLimitsNVX; +-- +-- +data VkDeviceGeneratedCommandsLimitsNVX = VkDeviceGeneratedCommandsLimitsNVX## Addr## + ByteArray## + +instance Eq VkDeviceGeneratedCommandsLimitsNVX where + (VkDeviceGeneratedCommandsLimitsNVX## a _) == + x@(VkDeviceGeneratedCommandsLimitsNVX## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkDeviceGeneratedCommandsLimitsNVX where + (VkDeviceGeneratedCommandsLimitsNVX## a _) `compare` + x@(VkDeviceGeneratedCommandsLimitsNVX## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkDeviceGeneratedCommandsLimitsNVX where + sizeOf ~_ = #{size VkDeviceGeneratedCommandsLimitsNVX} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkDeviceGeneratedCommandsLimitsNVX} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkDeviceGeneratedCommandsLimitsNVX where + unsafeAddr (VkDeviceGeneratedCommandsLimitsNVX## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkDeviceGeneratedCommandsLimitsNVX## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkDeviceGeneratedCommandsLimitsNVX## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkDeviceGeneratedCommandsLimitsNVX where + type StructFields VkDeviceGeneratedCommandsLimitsNVX = + '["sType", "pNext", "maxIndirectCommandsLayoutTokenCount", -- ' closing tick for hsc2hs + "maxObjectEntryCounts", "minSequenceCountBufferOffsetAlignment", + "minSequenceIndexBufferOffsetAlignment", + "minCommandsTokenBufferOffsetAlignment"] + type CUnionType VkDeviceGeneratedCommandsLimitsNVX = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkDeviceGeneratedCommandsLimitsNVX = 'False -- ' closing tick for hsc2hs + type StructExtends VkDeviceGeneratedCommandsLimitsNVX = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkDeviceGeneratedCommandsLimitsNVX where + type VkSTypeMType VkDeviceGeneratedCommandsLimitsNVX = + VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDeviceGeneratedCommandsLimitsNVX, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkDeviceGeneratedCommandsLimitsNVX, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkDeviceGeneratedCommandsLimitsNVX, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkDeviceGeneratedCommandsLimitsNVX, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkDeviceGeneratedCommandsLimitsNVX where + type FieldType "sType" VkDeviceGeneratedCommandsLimitsNVX = + VkStructureType + type FieldOptional "sType" VkDeviceGeneratedCommandsLimitsNVX = + 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkDeviceGeneratedCommandsLimitsNVX = + #{offset VkDeviceGeneratedCommandsLimitsNVX, sType} + type FieldIsArray "sType" VkDeviceGeneratedCommandsLimitsNVX = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDeviceGeneratedCommandsLimitsNVX, sType} + +instance CanReadField "sType" VkDeviceGeneratedCommandsLimitsNVX + where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkDeviceGeneratedCommandsLimitsNVX + where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkDeviceGeneratedCommandsLimitsNVX where + type VkPNextMType VkDeviceGeneratedCommandsLimitsNVX = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDeviceGeneratedCommandsLimitsNVX, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkDeviceGeneratedCommandsLimitsNVX, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkDeviceGeneratedCommandsLimitsNVX, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkDeviceGeneratedCommandsLimitsNVX, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkDeviceGeneratedCommandsLimitsNVX where + type FieldType "pNext" VkDeviceGeneratedCommandsLimitsNVX = + Ptr Void + type FieldOptional "pNext" VkDeviceGeneratedCommandsLimitsNVX = + 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkDeviceGeneratedCommandsLimitsNVX = + #{offset VkDeviceGeneratedCommandsLimitsNVX, pNext} + type FieldIsArray "pNext" VkDeviceGeneratedCommandsLimitsNVX = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDeviceGeneratedCommandsLimitsNVX, pNext} + +instance CanReadField "pNext" VkDeviceGeneratedCommandsLimitsNVX + where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkDeviceGeneratedCommandsLimitsNVX + where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkMaxIndirectCommandsLayoutTokenCount + VkDeviceGeneratedCommandsLimitsNVX + where + type VkMaxIndirectCommandsLayoutTokenCountMType + VkDeviceGeneratedCommandsLimitsNVX + = Word32 + + {-# NOINLINE vkMaxIndirectCommandsLayoutTokenCount #-} + vkMaxIndirectCommandsLayoutTokenCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDeviceGeneratedCommandsLimitsNVX, maxIndirectCommandsLayoutTokenCount}) + + {-# INLINE vkMaxIndirectCommandsLayoutTokenCountByteOffset #-} + vkMaxIndirectCommandsLayoutTokenCountByteOffset ~_ + = #{offset VkDeviceGeneratedCommandsLimitsNVX, maxIndirectCommandsLayoutTokenCount} + + {-# INLINE readVkMaxIndirectCommandsLayoutTokenCount #-} + readVkMaxIndirectCommandsLayoutTokenCount p + = peekByteOff p #{offset VkDeviceGeneratedCommandsLimitsNVX, maxIndirectCommandsLayoutTokenCount} + + {-# INLINE writeVkMaxIndirectCommandsLayoutTokenCount #-} + writeVkMaxIndirectCommandsLayoutTokenCount p + = pokeByteOff p #{offset VkDeviceGeneratedCommandsLimitsNVX, maxIndirectCommandsLayoutTokenCount} + +instance {-# OVERLAPPING #-} + HasField "maxIndirectCommandsLayoutTokenCount" + VkDeviceGeneratedCommandsLimitsNVX + where + type FieldType "maxIndirectCommandsLayoutTokenCount" + VkDeviceGeneratedCommandsLimitsNVX + = Word32 + type FieldOptional "maxIndirectCommandsLayoutTokenCount" + VkDeviceGeneratedCommandsLimitsNVX + = 'False -- ' closing tick for hsc2hs + type FieldOffset "maxIndirectCommandsLayoutTokenCount" + VkDeviceGeneratedCommandsLimitsNVX + = + #{offset VkDeviceGeneratedCommandsLimitsNVX, maxIndirectCommandsLayoutTokenCount} + type FieldIsArray "maxIndirectCommandsLayoutTokenCount" + VkDeviceGeneratedCommandsLimitsNVX + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDeviceGeneratedCommandsLimitsNVX, maxIndirectCommandsLayoutTokenCount} + +instance CanReadField "maxIndirectCommandsLayoutTokenCount" + VkDeviceGeneratedCommandsLimitsNVX + where + {-# INLINE getField #-} + getField = vkMaxIndirectCommandsLayoutTokenCount + + {-# INLINE readField #-} + readField = readVkMaxIndirectCommandsLayoutTokenCount + +instance CanWriteField "maxIndirectCommandsLayoutTokenCount" + VkDeviceGeneratedCommandsLimitsNVX + where + {-# INLINE writeField #-} + writeField = writeVkMaxIndirectCommandsLayoutTokenCount + +instance {-# OVERLAPPING #-} + HasVkMaxObjectEntryCounts VkDeviceGeneratedCommandsLimitsNVX where + type VkMaxObjectEntryCountsMType VkDeviceGeneratedCommandsLimitsNVX + = Word32 + + {-# NOINLINE vkMaxObjectEntryCounts #-} + vkMaxObjectEntryCounts x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDeviceGeneratedCommandsLimitsNVX, maxObjectEntryCounts}) + + {-# INLINE vkMaxObjectEntryCountsByteOffset #-} + vkMaxObjectEntryCountsByteOffset ~_ + = #{offset VkDeviceGeneratedCommandsLimitsNVX, maxObjectEntryCounts} + + {-# INLINE readVkMaxObjectEntryCounts #-} + readVkMaxObjectEntryCounts p + = peekByteOff p #{offset VkDeviceGeneratedCommandsLimitsNVX, maxObjectEntryCounts} + + {-# INLINE writeVkMaxObjectEntryCounts #-} + writeVkMaxObjectEntryCounts p + = pokeByteOff p #{offset VkDeviceGeneratedCommandsLimitsNVX, maxObjectEntryCounts} + +instance {-# OVERLAPPING #-} + HasField "maxObjectEntryCounts" VkDeviceGeneratedCommandsLimitsNVX + where + type FieldType "maxObjectEntryCounts" + VkDeviceGeneratedCommandsLimitsNVX + = Word32 + type FieldOptional "maxObjectEntryCounts" + VkDeviceGeneratedCommandsLimitsNVX + = 'False -- ' closing tick for hsc2hs + type FieldOffset "maxObjectEntryCounts" + VkDeviceGeneratedCommandsLimitsNVX + = + #{offset VkDeviceGeneratedCommandsLimitsNVX, maxObjectEntryCounts} + type FieldIsArray "maxObjectEntryCounts" + VkDeviceGeneratedCommandsLimitsNVX + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDeviceGeneratedCommandsLimitsNVX, maxObjectEntryCounts} + +instance CanReadField "maxObjectEntryCounts" + VkDeviceGeneratedCommandsLimitsNVX + where + {-# INLINE getField #-} + getField = vkMaxObjectEntryCounts + + {-# INLINE readField #-} + readField = readVkMaxObjectEntryCounts + +instance CanWriteField "maxObjectEntryCounts" + VkDeviceGeneratedCommandsLimitsNVX + where + {-# INLINE writeField #-} + writeField = writeVkMaxObjectEntryCounts + +instance {-# OVERLAPPING #-} + HasVkMinSequenceCountBufferOffsetAlignment + VkDeviceGeneratedCommandsLimitsNVX + where + type VkMinSequenceCountBufferOffsetAlignmentMType + VkDeviceGeneratedCommandsLimitsNVX + = Word32 + + {-# NOINLINE vkMinSequenceCountBufferOffsetAlignment #-} + vkMinSequenceCountBufferOffsetAlignment x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDeviceGeneratedCommandsLimitsNVX, minSequenceCountBufferOffsetAlignment}) + + {-# INLINE vkMinSequenceCountBufferOffsetAlignmentByteOffset #-} + vkMinSequenceCountBufferOffsetAlignmentByteOffset ~_ + = #{offset VkDeviceGeneratedCommandsLimitsNVX, minSequenceCountBufferOffsetAlignment} + + {-# INLINE readVkMinSequenceCountBufferOffsetAlignment #-} + readVkMinSequenceCountBufferOffsetAlignment p + = peekByteOff p #{offset VkDeviceGeneratedCommandsLimitsNVX, minSequenceCountBufferOffsetAlignment} + + {-# INLINE writeVkMinSequenceCountBufferOffsetAlignment #-} + writeVkMinSequenceCountBufferOffsetAlignment p + = pokeByteOff p #{offset VkDeviceGeneratedCommandsLimitsNVX, minSequenceCountBufferOffsetAlignment} + +instance {-# OVERLAPPING #-} + HasField "minSequenceCountBufferOffsetAlignment" + VkDeviceGeneratedCommandsLimitsNVX + where + type FieldType "minSequenceCountBufferOffsetAlignment" + VkDeviceGeneratedCommandsLimitsNVX + = Word32 + type FieldOptional "minSequenceCountBufferOffsetAlignment" + VkDeviceGeneratedCommandsLimitsNVX + = 'False -- ' closing tick for hsc2hs + type FieldOffset "minSequenceCountBufferOffsetAlignment" + VkDeviceGeneratedCommandsLimitsNVX + = + #{offset VkDeviceGeneratedCommandsLimitsNVX, minSequenceCountBufferOffsetAlignment} + type FieldIsArray "minSequenceCountBufferOffsetAlignment" + VkDeviceGeneratedCommandsLimitsNVX + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDeviceGeneratedCommandsLimitsNVX, minSequenceCountBufferOffsetAlignment} + +instance CanReadField "minSequenceCountBufferOffsetAlignment" + VkDeviceGeneratedCommandsLimitsNVX + where + {-# INLINE getField #-} + getField = vkMinSequenceCountBufferOffsetAlignment + + {-# INLINE readField #-} + readField = readVkMinSequenceCountBufferOffsetAlignment + +instance CanWriteField "minSequenceCountBufferOffsetAlignment" + VkDeviceGeneratedCommandsLimitsNVX + where + {-# INLINE writeField #-} + writeField = writeVkMinSequenceCountBufferOffsetAlignment + +instance {-# OVERLAPPING #-} + HasVkMinSequenceIndexBufferOffsetAlignment + VkDeviceGeneratedCommandsLimitsNVX + where + type VkMinSequenceIndexBufferOffsetAlignmentMType + VkDeviceGeneratedCommandsLimitsNVX + = Word32 + + {-# NOINLINE vkMinSequenceIndexBufferOffsetAlignment #-} + vkMinSequenceIndexBufferOffsetAlignment x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDeviceGeneratedCommandsLimitsNVX, minSequenceIndexBufferOffsetAlignment}) + + {-# INLINE vkMinSequenceIndexBufferOffsetAlignmentByteOffset #-} + vkMinSequenceIndexBufferOffsetAlignmentByteOffset ~_ + = #{offset VkDeviceGeneratedCommandsLimitsNVX, minSequenceIndexBufferOffsetAlignment} + + {-# INLINE readVkMinSequenceIndexBufferOffsetAlignment #-} + readVkMinSequenceIndexBufferOffsetAlignment p + = peekByteOff p #{offset VkDeviceGeneratedCommandsLimitsNVX, minSequenceIndexBufferOffsetAlignment} + + {-# INLINE writeVkMinSequenceIndexBufferOffsetAlignment #-} + writeVkMinSequenceIndexBufferOffsetAlignment p + = pokeByteOff p #{offset VkDeviceGeneratedCommandsLimitsNVX, minSequenceIndexBufferOffsetAlignment} + +instance {-# OVERLAPPING #-} + HasField "minSequenceIndexBufferOffsetAlignment" + VkDeviceGeneratedCommandsLimitsNVX + where + type FieldType "minSequenceIndexBufferOffsetAlignment" + VkDeviceGeneratedCommandsLimitsNVX + = Word32 + type FieldOptional "minSequenceIndexBufferOffsetAlignment" + VkDeviceGeneratedCommandsLimitsNVX + = 'False -- ' closing tick for hsc2hs + type FieldOffset "minSequenceIndexBufferOffsetAlignment" + VkDeviceGeneratedCommandsLimitsNVX + = + #{offset VkDeviceGeneratedCommandsLimitsNVX, minSequenceIndexBufferOffsetAlignment} + type FieldIsArray "minSequenceIndexBufferOffsetAlignment" + VkDeviceGeneratedCommandsLimitsNVX + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDeviceGeneratedCommandsLimitsNVX, minSequenceIndexBufferOffsetAlignment} + +instance CanReadField "minSequenceIndexBufferOffsetAlignment" + VkDeviceGeneratedCommandsLimitsNVX + where + {-# INLINE getField #-} + getField = vkMinSequenceIndexBufferOffsetAlignment + + {-# INLINE readField #-} + readField = readVkMinSequenceIndexBufferOffsetAlignment + +instance CanWriteField "minSequenceIndexBufferOffsetAlignment" + VkDeviceGeneratedCommandsLimitsNVX + where + {-# INLINE writeField #-} + writeField = writeVkMinSequenceIndexBufferOffsetAlignment + +instance {-# OVERLAPPING #-} + HasVkMinCommandsTokenBufferOffsetAlignment + VkDeviceGeneratedCommandsLimitsNVX + where + type VkMinCommandsTokenBufferOffsetAlignmentMType + VkDeviceGeneratedCommandsLimitsNVX + = Word32 + + {-# NOINLINE vkMinCommandsTokenBufferOffsetAlignment #-} + vkMinCommandsTokenBufferOffsetAlignment x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDeviceGeneratedCommandsLimitsNVX, minCommandsTokenBufferOffsetAlignment}) + + {-# INLINE vkMinCommandsTokenBufferOffsetAlignmentByteOffset #-} + vkMinCommandsTokenBufferOffsetAlignmentByteOffset ~_ + = #{offset VkDeviceGeneratedCommandsLimitsNVX, minCommandsTokenBufferOffsetAlignment} + + {-# INLINE readVkMinCommandsTokenBufferOffsetAlignment #-} + readVkMinCommandsTokenBufferOffsetAlignment p + = peekByteOff p #{offset VkDeviceGeneratedCommandsLimitsNVX, minCommandsTokenBufferOffsetAlignment} + + {-# INLINE writeVkMinCommandsTokenBufferOffsetAlignment #-} + writeVkMinCommandsTokenBufferOffsetAlignment p + = pokeByteOff p #{offset VkDeviceGeneratedCommandsLimitsNVX, minCommandsTokenBufferOffsetAlignment} + +instance {-# OVERLAPPING #-} + HasField "minCommandsTokenBufferOffsetAlignment" + VkDeviceGeneratedCommandsLimitsNVX + where + type FieldType "minCommandsTokenBufferOffsetAlignment" + VkDeviceGeneratedCommandsLimitsNVX + = Word32 + type FieldOptional "minCommandsTokenBufferOffsetAlignment" + VkDeviceGeneratedCommandsLimitsNVX + = 'False -- ' closing tick for hsc2hs + type FieldOffset "minCommandsTokenBufferOffsetAlignment" + VkDeviceGeneratedCommandsLimitsNVX + = + #{offset VkDeviceGeneratedCommandsLimitsNVX, minCommandsTokenBufferOffsetAlignment} + type FieldIsArray "minCommandsTokenBufferOffsetAlignment" + VkDeviceGeneratedCommandsLimitsNVX + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDeviceGeneratedCommandsLimitsNVX, minCommandsTokenBufferOffsetAlignment} + +instance CanReadField "minCommandsTokenBufferOffsetAlignment" + VkDeviceGeneratedCommandsLimitsNVX + where + {-# INLINE getField #-} + getField = vkMinCommandsTokenBufferOffsetAlignment + + {-# INLINE readField #-} + readField = readVkMinCommandsTokenBufferOffsetAlignment + +instance CanWriteField "minCommandsTokenBufferOffsetAlignment" + VkDeviceGeneratedCommandsLimitsNVX + where + {-# INLINE writeField #-} + writeField = writeVkMinCommandsTokenBufferOffsetAlignment + +instance Show VkDeviceGeneratedCommandsLimitsNVX where + showsPrec d x + = showString "VkDeviceGeneratedCommandsLimitsNVX {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkMaxIndirectCommandsLayoutTokenCount = " . + showsPrec d (vkMaxIndirectCommandsLayoutTokenCount x) . + showString ", " . + showString "vkMaxObjectEntryCounts = " . + showsPrec d (vkMaxObjectEntryCounts x) . + showString ", " . + showString "vkMinSequenceCountBufferOffsetAlignment = " . + showsPrec d (vkMinSequenceCountBufferOffsetAlignment x) . + showString ", " . + showString "vkMinSequenceIndexBufferOffsetAlignment = " + . + showsPrec d + (vkMinSequenceIndexBufferOffsetAlignment x) + . + showString ", " . + showString + "vkMinCommandsTokenBufferOffsetAlignment = " + . + showsPrec d + (vkMinCommandsTokenBufferOffsetAlignment x) + . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkDeviceGroupBindSparseInfoKHX.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkDeviceGroupBindSparseInfoKHX.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkDeviceGroupBindSparseInfoKHX.hsc @@ -0,0 +1,306 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkDeviceGroupBindSparseInfoKHX + (VkDeviceGroupBindSparseInfoKHX(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Struct.VkBindSparseInfo (VkBindSparseInfo) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkDeviceGroupBindSparseInfoKHX { +-- > VkStructureType sType; +-- > const void* pNext; +-- > uint32_t resourceDeviceIndex; +-- > uint32_t memoryDeviceIndex; +-- > } VkDeviceGroupBindSparseInfoKHX; +-- +-- +data VkDeviceGroupBindSparseInfoKHX = VkDeviceGroupBindSparseInfoKHX## Addr## + ByteArray## + +instance Eq VkDeviceGroupBindSparseInfoKHX where + (VkDeviceGroupBindSparseInfoKHX## a _) == + x@(VkDeviceGroupBindSparseInfoKHX## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkDeviceGroupBindSparseInfoKHX where + (VkDeviceGroupBindSparseInfoKHX## a _) `compare` + x@(VkDeviceGroupBindSparseInfoKHX## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkDeviceGroupBindSparseInfoKHX where + sizeOf ~_ = #{size VkDeviceGroupBindSparseInfoKHX} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkDeviceGroupBindSparseInfoKHX} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkDeviceGroupBindSparseInfoKHX where + unsafeAddr (VkDeviceGroupBindSparseInfoKHX## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkDeviceGroupBindSparseInfoKHX## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkDeviceGroupBindSparseInfoKHX## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkDeviceGroupBindSparseInfoKHX where + type StructFields VkDeviceGroupBindSparseInfoKHX = + '["sType", "pNext", "resourceDeviceIndex", "memoryDeviceIndex"] -- ' closing tick for hsc2hs + type CUnionType VkDeviceGroupBindSparseInfoKHX = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkDeviceGroupBindSparseInfoKHX = 'False -- ' closing tick for hsc2hs + type StructExtends VkDeviceGroupBindSparseInfoKHX = + '[VkBindSparseInfo] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkDeviceGroupBindSparseInfoKHX where + type VkSTypeMType VkDeviceGroupBindSparseInfoKHX = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDeviceGroupBindSparseInfoKHX, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkDeviceGroupBindSparseInfoKHX, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkDeviceGroupBindSparseInfoKHX, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkDeviceGroupBindSparseInfoKHX, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkDeviceGroupBindSparseInfoKHX where + type FieldType "sType" VkDeviceGroupBindSparseInfoKHX = + VkStructureType + type FieldOptional "sType" VkDeviceGroupBindSparseInfoKHX = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkDeviceGroupBindSparseInfoKHX = + #{offset VkDeviceGroupBindSparseInfoKHX, sType} + type FieldIsArray "sType" VkDeviceGroupBindSparseInfoKHX = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDeviceGroupBindSparseInfoKHX, sType} + +instance CanReadField "sType" VkDeviceGroupBindSparseInfoKHX where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkDeviceGroupBindSparseInfoKHX where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkDeviceGroupBindSparseInfoKHX where + type VkPNextMType VkDeviceGroupBindSparseInfoKHX = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDeviceGroupBindSparseInfoKHX, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkDeviceGroupBindSparseInfoKHX, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkDeviceGroupBindSparseInfoKHX, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkDeviceGroupBindSparseInfoKHX, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkDeviceGroupBindSparseInfoKHX where + type FieldType "pNext" VkDeviceGroupBindSparseInfoKHX = Ptr Void + type FieldOptional "pNext" VkDeviceGroupBindSparseInfoKHX = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkDeviceGroupBindSparseInfoKHX = + #{offset VkDeviceGroupBindSparseInfoKHX, pNext} + type FieldIsArray "pNext" VkDeviceGroupBindSparseInfoKHX = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDeviceGroupBindSparseInfoKHX, pNext} + +instance CanReadField "pNext" VkDeviceGroupBindSparseInfoKHX where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkDeviceGroupBindSparseInfoKHX where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkResourceDeviceIndex VkDeviceGroupBindSparseInfoKHX where + type VkResourceDeviceIndexMType VkDeviceGroupBindSparseInfoKHX = + Word32 + + {-# NOINLINE vkResourceDeviceIndex #-} + vkResourceDeviceIndex x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDeviceGroupBindSparseInfoKHX, resourceDeviceIndex}) + + {-# INLINE vkResourceDeviceIndexByteOffset #-} + vkResourceDeviceIndexByteOffset ~_ + = #{offset VkDeviceGroupBindSparseInfoKHX, resourceDeviceIndex} + + {-# INLINE readVkResourceDeviceIndex #-} + readVkResourceDeviceIndex p + = peekByteOff p #{offset VkDeviceGroupBindSparseInfoKHX, resourceDeviceIndex} + + {-# INLINE writeVkResourceDeviceIndex #-} + writeVkResourceDeviceIndex p + = pokeByteOff p #{offset VkDeviceGroupBindSparseInfoKHX, resourceDeviceIndex} + +instance {-# OVERLAPPING #-} + HasField "resourceDeviceIndex" VkDeviceGroupBindSparseInfoKHX where + type FieldType "resourceDeviceIndex" VkDeviceGroupBindSparseInfoKHX + = Word32 + type FieldOptional "resourceDeviceIndex" + VkDeviceGroupBindSparseInfoKHX + = 'False -- ' closing tick for hsc2hs + type FieldOffset "resourceDeviceIndex" + VkDeviceGroupBindSparseInfoKHX + = + #{offset VkDeviceGroupBindSparseInfoKHX, resourceDeviceIndex} + type FieldIsArray "resourceDeviceIndex" + VkDeviceGroupBindSparseInfoKHX + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDeviceGroupBindSparseInfoKHX, resourceDeviceIndex} + +instance CanReadField "resourceDeviceIndex" + VkDeviceGroupBindSparseInfoKHX + where + {-# INLINE getField #-} + getField = vkResourceDeviceIndex + + {-# INLINE readField #-} + readField = readVkResourceDeviceIndex + +instance CanWriteField "resourceDeviceIndex" + VkDeviceGroupBindSparseInfoKHX + where + {-# INLINE writeField #-} + writeField = writeVkResourceDeviceIndex + +instance {-# OVERLAPPING #-} + HasVkMemoryDeviceIndex VkDeviceGroupBindSparseInfoKHX where + type VkMemoryDeviceIndexMType VkDeviceGroupBindSparseInfoKHX = + Word32 + + {-# NOINLINE vkMemoryDeviceIndex #-} + vkMemoryDeviceIndex x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDeviceGroupBindSparseInfoKHX, memoryDeviceIndex}) + + {-# INLINE vkMemoryDeviceIndexByteOffset #-} + vkMemoryDeviceIndexByteOffset ~_ + = #{offset VkDeviceGroupBindSparseInfoKHX, memoryDeviceIndex} + + {-# INLINE readVkMemoryDeviceIndex #-} + readVkMemoryDeviceIndex p + = peekByteOff p #{offset VkDeviceGroupBindSparseInfoKHX, memoryDeviceIndex} + + {-# INLINE writeVkMemoryDeviceIndex #-} + writeVkMemoryDeviceIndex p + = pokeByteOff p #{offset VkDeviceGroupBindSparseInfoKHX, memoryDeviceIndex} + +instance {-# OVERLAPPING #-} + HasField "memoryDeviceIndex" VkDeviceGroupBindSparseInfoKHX where + type FieldType "memoryDeviceIndex" VkDeviceGroupBindSparseInfoKHX = + Word32 + type FieldOptional "memoryDeviceIndex" + VkDeviceGroupBindSparseInfoKHX + = 'False -- ' closing tick for hsc2hs + type FieldOffset "memoryDeviceIndex" VkDeviceGroupBindSparseInfoKHX + = + #{offset VkDeviceGroupBindSparseInfoKHX, memoryDeviceIndex} + type FieldIsArray "memoryDeviceIndex" + VkDeviceGroupBindSparseInfoKHX + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDeviceGroupBindSparseInfoKHX, memoryDeviceIndex} + +instance CanReadField "memoryDeviceIndex" + VkDeviceGroupBindSparseInfoKHX + where + {-# INLINE getField #-} + getField = vkMemoryDeviceIndex + + {-# INLINE readField #-} + readField = readVkMemoryDeviceIndex + +instance CanWriteField "memoryDeviceIndex" + VkDeviceGroupBindSparseInfoKHX + where + {-# INLINE writeField #-} + writeField = writeVkMemoryDeviceIndex + +instance Show VkDeviceGroupBindSparseInfoKHX where + showsPrec d x + = showString "VkDeviceGroupBindSparseInfoKHX {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkResourceDeviceIndex = " . + showsPrec d (vkResourceDeviceIndex x) . + showString ", " . + showString "vkMemoryDeviceIndex = " . + showsPrec d (vkMemoryDeviceIndex x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkDeviceGroupCommandBufferBeginInfoKHX.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkDeviceGroupCommandBufferBeginInfoKHX.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkDeviceGroupCommandBufferBeginInfoKHX.hsc @@ -0,0 +1,261 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkDeviceGroupCommandBufferBeginInfoKHX + (VkDeviceGroupCommandBufferBeginInfoKHX(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Struct.VkCommandBufferBeginInfo (VkCommandBufferBeginInfo) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkDeviceGroupCommandBufferBeginInfoKHX { +-- > VkStructureType sType; +-- > const void* pNext; +-- > uint32_t deviceMask; +-- > } VkDeviceGroupCommandBufferBeginInfoKHX; +-- +-- +data VkDeviceGroupCommandBufferBeginInfoKHX = VkDeviceGroupCommandBufferBeginInfoKHX## Addr## + ByteArray## + +instance Eq VkDeviceGroupCommandBufferBeginInfoKHX where + (VkDeviceGroupCommandBufferBeginInfoKHX## a _) == + x@(VkDeviceGroupCommandBufferBeginInfoKHX## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkDeviceGroupCommandBufferBeginInfoKHX where + (VkDeviceGroupCommandBufferBeginInfoKHX## a _) `compare` + x@(VkDeviceGroupCommandBufferBeginInfoKHX## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkDeviceGroupCommandBufferBeginInfoKHX where + sizeOf ~_ + = #{size VkDeviceGroupCommandBufferBeginInfoKHX} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkDeviceGroupCommandBufferBeginInfoKHX} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkDeviceGroupCommandBufferBeginInfoKHX + where + unsafeAddr (VkDeviceGroupCommandBufferBeginInfoKHX## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkDeviceGroupCommandBufferBeginInfoKHX## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkDeviceGroupCommandBufferBeginInfoKHX## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkDeviceGroupCommandBufferBeginInfoKHX where + type StructFields VkDeviceGroupCommandBufferBeginInfoKHX = + '["sType", "pNext", "deviceMask"] -- ' closing tick for hsc2hs + type CUnionType VkDeviceGroupCommandBufferBeginInfoKHX = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkDeviceGroupCommandBufferBeginInfoKHX = 'False -- ' closing tick for hsc2hs + type StructExtends VkDeviceGroupCommandBufferBeginInfoKHX = + '[VkCommandBufferBeginInfo] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkDeviceGroupCommandBufferBeginInfoKHX where + type VkSTypeMType VkDeviceGroupCommandBufferBeginInfoKHX = + VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDeviceGroupCommandBufferBeginInfoKHX, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkDeviceGroupCommandBufferBeginInfoKHX, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkDeviceGroupCommandBufferBeginInfoKHX, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkDeviceGroupCommandBufferBeginInfoKHX, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkDeviceGroupCommandBufferBeginInfoKHX where + type FieldType "sType" VkDeviceGroupCommandBufferBeginInfoKHX = + VkStructureType + type FieldOptional "sType" VkDeviceGroupCommandBufferBeginInfoKHX = + 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkDeviceGroupCommandBufferBeginInfoKHX = + #{offset VkDeviceGroupCommandBufferBeginInfoKHX, sType} + type FieldIsArray "sType" VkDeviceGroupCommandBufferBeginInfoKHX = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDeviceGroupCommandBufferBeginInfoKHX, sType} + +instance CanReadField "sType" + VkDeviceGroupCommandBufferBeginInfoKHX + where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" + VkDeviceGroupCommandBufferBeginInfoKHX + where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkDeviceGroupCommandBufferBeginInfoKHX where + type VkPNextMType VkDeviceGroupCommandBufferBeginInfoKHX = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDeviceGroupCommandBufferBeginInfoKHX, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkDeviceGroupCommandBufferBeginInfoKHX, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkDeviceGroupCommandBufferBeginInfoKHX, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkDeviceGroupCommandBufferBeginInfoKHX, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkDeviceGroupCommandBufferBeginInfoKHX where + type FieldType "pNext" VkDeviceGroupCommandBufferBeginInfoKHX = + Ptr Void + type FieldOptional "pNext" VkDeviceGroupCommandBufferBeginInfoKHX = + 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkDeviceGroupCommandBufferBeginInfoKHX = + #{offset VkDeviceGroupCommandBufferBeginInfoKHX, pNext} + type FieldIsArray "pNext" VkDeviceGroupCommandBufferBeginInfoKHX = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDeviceGroupCommandBufferBeginInfoKHX, pNext} + +instance CanReadField "pNext" + VkDeviceGroupCommandBufferBeginInfoKHX + where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" + VkDeviceGroupCommandBufferBeginInfoKHX + where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkDeviceMask VkDeviceGroupCommandBufferBeginInfoKHX where + type VkDeviceMaskMType VkDeviceGroupCommandBufferBeginInfoKHX = + Word32 + + {-# NOINLINE vkDeviceMask #-} + vkDeviceMask x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDeviceGroupCommandBufferBeginInfoKHX, deviceMask}) + + {-# INLINE vkDeviceMaskByteOffset #-} + vkDeviceMaskByteOffset ~_ + = #{offset VkDeviceGroupCommandBufferBeginInfoKHX, deviceMask} + + {-# INLINE readVkDeviceMask #-} + readVkDeviceMask p + = peekByteOff p #{offset VkDeviceGroupCommandBufferBeginInfoKHX, deviceMask} + + {-# INLINE writeVkDeviceMask #-} + writeVkDeviceMask p + = pokeByteOff p #{offset VkDeviceGroupCommandBufferBeginInfoKHX, deviceMask} + +instance {-# OVERLAPPING #-} + HasField "deviceMask" VkDeviceGroupCommandBufferBeginInfoKHX where + type FieldType "deviceMask" VkDeviceGroupCommandBufferBeginInfoKHX + = Word32 + type FieldOptional "deviceMask" + VkDeviceGroupCommandBufferBeginInfoKHX + = 'False -- ' closing tick for hsc2hs + type FieldOffset "deviceMask" + VkDeviceGroupCommandBufferBeginInfoKHX + = + #{offset VkDeviceGroupCommandBufferBeginInfoKHX, deviceMask} + type FieldIsArray "deviceMask" + VkDeviceGroupCommandBufferBeginInfoKHX + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDeviceGroupCommandBufferBeginInfoKHX, deviceMask} + +instance CanReadField "deviceMask" + VkDeviceGroupCommandBufferBeginInfoKHX + where + {-# INLINE getField #-} + getField = vkDeviceMask + + {-# INLINE readField #-} + readField = readVkDeviceMask + +instance CanWriteField "deviceMask" + VkDeviceGroupCommandBufferBeginInfoKHX + where + {-# INLINE writeField #-} + writeField = writeVkDeviceMask + +instance Show VkDeviceGroupCommandBufferBeginInfoKHX where + showsPrec d x + = showString "VkDeviceGroupCommandBufferBeginInfoKHX {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkDeviceMask = " . + showsPrec d (vkDeviceMask x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkDeviceGroupDeviceCreateInfoKHX.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkDeviceGroupDeviceCreateInfoKHX.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkDeviceGroupDeviceCreateInfoKHX.hsc @@ -0,0 +1,318 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkDeviceGroupDeviceCreateInfoKHX + (VkDeviceGroupDeviceCreateInfoKHX(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Handles (VkPhysicalDevice) +import Graphics.Vulkan.Types.Struct.VkDeviceCreateInfo (VkDeviceCreateInfo) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkDeviceGroupDeviceCreateInfoKHX { +-- > VkStructureType sType; +-- > const void* pNext; +-- > uint32_t physicalDeviceCount; +-- > const VkPhysicalDevice* pPhysicalDevices; +-- > } VkDeviceGroupDeviceCreateInfoKHX; +-- +-- +data VkDeviceGroupDeviceCreateInfoKHX = VkDeviceGroupDeviceCreateInfoKHX## Addr## + ByteArray## + +instance Eq VkDeviceGroupDeviceCreateInfoKHX where + (VkDeviceGroupDeviceCreateInfoKHX## a _) == + x@(VkDeviceGroupDeviceCreateInfoKHX## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkDeviceGroupDeviceCreateInfoKHX where + (VkDeviceGroupDeviceCreateInfoKHX## a _) `compare` + x@(VkDeviceGroupDeviceCreateInfoKHX## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkDeviceGroupDeviceCreateInfoKHX where + sizeOf ~_ = #{size VkDeviceGroupDeviceCreateInfoKHX} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkDeviceGroupDeviceCreateInfoKHX} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkDeviceGroupDeviceCreateInfoKHX where + unsafeAddr (VkDeviceGroupDeviceCreateInfoKHX## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkDeviceGroupDeviceCreateInfoKHX## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkDeviceGroupDeviceCreateInfoKHX## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkDeviceGroupDeviceCreateInfoKHX where + type StructFields VkDeviceGroupDeviceCreateInfoKHX = + '["sType", "pNext", "physicalDeviceCount", "pPhysicalDevices"] -- ' closing tick for hsc2hs + type CUnionType VkDeviceGroupDeviceCreateInfoKHX = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkDeviceGroupDeviceCreateInfoKHX = 'False -- ' closing tick for hsc2hs + type StructExtends VkDeviceGroupDeviceCreateInfoKHX = + '[VkDeviceCreateInfo] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkDeviceGroupDeviceCreateInfoKHX where + type VkSTypeMType VkDeviceGroupDeviceCreateInfoKHX = + VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDeviceGroupDeviceCreateInfoKHX, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkDeviceGroupDeviceCreateInfoKHX, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkDeviceGroupDeviceCreateInfoKHX, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkDeviceGroupDeviceCreateInfoKHX, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkDeviceGroupDeviceCreateInfoKHX where + type FieldType "sType" VkDeviceGroupDeviceCreateInfoKHX = + VkStructureType + type FieldOptional "sType" VkDeviceGroupDeviceCreateInfoKHX = + 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkDeviceGroupDeviceCreateInfoKHX = + #{offset VkDeviceGroupDeviceCreateInfoKHX, sType} + type FieldIsArray "sType" VkDeviceGroupDeviceCreateInfoKHX = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDeviceGroupDeviceCreateInfoKHX, sType} + +instance CanReadField "sType" VkDeviceGroupDeviceCreateInfoKHX + where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkDeviceGroupDeviceCreateInfoKHX + where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkDeviceGroupDeviceCreateInfoKHX where + type VkPNextMType VkDeviceGroupDeviceCreateInfoKHX = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDeviceGroupDeviceCreateInfoKHX, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkDeviceGroupDeviceCreateInfoKHX, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkDeviceGroupDeviceCreateInfoKHX, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkDeviceGroupDeviceCreateInfoKHX, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkDeviceGroupDeviceCreateInfoKHX where + type FieldType "pNext" VkDeviceGroupDeviceCreateInfoKHX = Ptr Void + type FieldOptional "pNext" VkDeviceGroupDeviceCreateInfoKHX = + 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkDeviceGroupDeviceCreateInfoKHX = + #{offset VkDeviceGroupDeviceCreateInfoKHX, pNext} + type FieldIsArray "pNext" VkDeviceGroupDeviceCreateInfoKHX = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDeviceGroupDeviceCreateInfoKHX, pNext} + +instance CanReadField "pNext" VkDeviceGroupDeviceCreateInfoKHX + where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkDeviceGroupDeviceCreateInfoKHX + where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkPhysicalDeviceCount VkDeviceGroupDeviceCreateInfoKHX where + type VkPhysicalDeviceCountMType VkDeviceGroupDeviceCreateInfoKHX = + Word32 + + {-# NOINLINE vkPhysicalDeviceCount #-} + vkPhysicalDeviceCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDeviceGroupDeviceCreateInfoKHX, physicalDeviceCount}) + + {-# INLINE vkPhysicalDeviceCountByteOffset #-} + vkPhysicalDeviceCountByteOffset ~_ + = #{offset VkDeviceGroupDeviceCreateInfoKHX, physicalDeviceCount} + + {-# INLINE readVkPhysicalDeviceCount #-} + readVkPhysicalDeviceCount p + = peekByteOff p #{offset VkDeviceGroupDeviceCreateInfoKHX, physicalDeviceCount} + + {-# INLINE writeVkPhysicalDeviceCount #-} + writeVkPhysicalDeviceCount p + = pokeByteOff p #{offset VkDeviceGroupDeviceCreateInfoKHX, physicalDeviceCount} + +instance {-# OVERLAPPING #-} + HasField "physicalDeviceCount" VkDeviceGroupDeviceCreateInfoKHX + where + type FieldType "physicalDeviceCount" + VkDeviceGroupDeviceCreateInfoKHX + = Word32 + type FieldOptional "physicalDeviceCount" + VkDeviceGroupDeviceCreateInfoKHX + = 'True -- ' closing tick for hsc2hs + type FieldOffset "physicalDeviceCount" + VkDeviceGroupDeviceCreateInfoKHX + = + #{offset VkDeviceGroupDeviceCreateInfoKHX, physicalDeviceCount} + type FieldIsArray "physicalDeviceCount" + VkDeviceGroupDeviceCreateInfoKHX + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDeviceGroupDeviceCreateInfoKHX, physicalDeviceCount} + +instance CanReadField "physicalDeviceCount" + VkDeviceGroupDeviceCreateInfoKHX + where + {-# INLINE getField #-} + getField = vkPhysicalDeviceCount + + {-# INLINE readField #-} + readField = readVkPhysicalDeviceCount + +instance CanWriteField "physicalDeviceCount" + VkDeviceGroupDeviceCreateInfoKHX + where + {-# INLINE writeField #-} + writeField = writeVkPhysicalDeviceCount + +instance {-# OVERLAPPING #-} + HasVkPPhysicalDevices VkDeviceGroupDeviceCreateInfoKHX where + type VkPPhysicalDevicesMType VkDeviceGroupDeviceCreateInfoKHX = + Ptr VkPhysicalDevice + + {-# NOINLINE vkPPhysicalDevices #-} + vkPPhysicalDevices x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDeviceGroupDeviceCreateInfoKHX, pPhysicalDevices}) + + {-# INLINE vkPPhysicalDevicesByteOffset #-} + vkPPhysicalDevicesByteOffset ~_ + = #{offset VkDeviceGroupDeviceCreateInfoKHX, pPhysicalDevices} + + {-# INLINE readVkPPhysicalDevices #-} + readVkPPhysicalDevices p + = peekByteOff p #{offset VkDeviceGroupDeviceCreateInfoKHX, pPhysicalDevices} + + {-# INLINE writeVkPPhysicalDevices #-} + writeVkPPhysicalDevices p + = pokeByteOff p #{offset VkDeviceGroupDeviceCreateInfoKHX, pPhysicalDevices} + +instance {-# OVERLAPPING #-} + HasField "pPhysicalDevices" VkDeviceGroupDeviceCreateInfoKHX where + type FieldType "pPhysicalDevices" VkDeviceGroupDeviceCreateInfoKHX + = Ptr VkPhysicalDevice + type FieldOptional "pPhysicalDevices" + VkDeviceGroupDeviceCreateInfoKHX + = 'False -- ' closing tick for hsc2hs + type FieldOffset "pPhysicalDevices" + VkDeviceGroupDeviceCreateInfoKHX + = + #{offset VkDeviceGroupDeviceCreateInfoKHX, pPhysicalDevices} + type FieldIsArray "pPhysicalDevices" + VkDeviceGroupDeviceCreateInfoKHX + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDeviceGroupDeviceCreateInfoKHX, pPhysicalDevices} + +instance CanReadField "pPhysicalDevices" + VkDeviceGroupDeviceCreateInfoKHX + where + {-# INLINE getField #-} + getField = vkPPhysicalDevices + + {-# INLINE readField #-} + readField = readVkPPhysicalDevices + +instance CanWriteField "pPhysicalDevices" + VkDeviceGroupDeviceCreateInfoKHX + where + {-# INLINE writeField #-} + writeField = writeVkPPhysicalDevices + +instance Show VkDeviceGroupDeviceCreateInfoKHX where + showsPrec d x + = showString "VkDeviceGroupDeviceCreateInfoKHX {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkPhysicalDeviceCount = " . + showsPrec d (vkPhysicalDeviceCount x) . + showString ", " . + showString "vkPPhysicalDevices = " . + showsPrec d (vkPPhysicalDevices x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkDeviceGroupPresentCapabilitiesKHX.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkDeviceGroupPresentCapabilitiesKHX.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkDeviceGroupPresentCapabilitiesKHX.hsc @@ -0,0 +1,338 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleContexts #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE ScopedTypeVariables #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +{-# LANGUAGE UndecidableInstances #-} +module Graphics.Vulkan.Types.Struct.VkDeviceGroupPresentCapabilitiesKHX + (VkDeviceGroupPresentCapabilitiesKHX(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import GHC.TypeLits (KnownNat, + natVal') -- ' closing tick for hsc2hs +import Graphics.Vulkan.Constants (VK_MAX_DEVICE_GROUP_SIZE_KHX, + pattern VK_MAX_DEVICE_GROUP_SIZE_KHX) +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkDeviceGroupPresentModeFlagsKHX (VkDeviceGroupPresentModeFlagsKHX) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkDeviceGroupPresentCapabilitiesKHX { +-- > VkStructureType sType; +-- > const void* pNext; +-- > uint32_t presentMask[VK_MAX_DEVICE_GROUP_SIZE_KHX]; +-- > VkDeviceGroupPresentModeFlagsKHX modes; +-- > } VkDeviceGroupPresentCapabilitiesKHX; +-- +-- +data VkDeviceGroupPresentCapabilitiesKHX = VkDeviceGroupPresentCapabilitiesKHX## Addr## + ByteArray## + +instance Eq VkDeviceGroupPresentCapabilitiesKHX where + (VkDeviceGroupPresentCapabilitiesKHX## a _) == + x@(VkDeviceGroupPresentCapabilitiesKHX## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkDeviceGroupPresentCapabilitiesKHX where + (VkDeviceGroupPresentCapabilitiesKHX## a _) `compare` + x@(VkDeviceGroupPresentCapabilitiesKHX## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkDeviceGroupPresentCapabilitiesKHX where + sizeOf ~_ = #{size VkDeviceGroupPresentCapabilitiesKHX} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkDeviceGroupPresentCapabilitiesKHX} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkDeviceGroupPresentCapabilitiesKHX + where + unsafeAddr (VkDeviceGroupPresentCapabilitiesKHX## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkDeviceGroupPresentCapabilitiesKHX## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkDeviceGroupPresentCapabilitiesKHX## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkDeviceGroupPresentCapabilitiesKHX where + type StructFields VkDeviceGroupPresentCapabilitiesKHX = + '["sType", "pNext", "presentMask", "modes"] -- ' closing tick for hsc2hs + type CUnionType VkDeviceGroupPresentCapabilitiesKHX = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkDeviceGroupPresentCapabilitiesKHX = 'True -- ' closing tick for hsc2hs + type StructExtends VkDeviceGroupPresentCapabilitiesKHX = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkDeviceGroupPresentCapabilitiesKHX where + type VkSTypeMType VkDeviceGroupPresentCapabilitiesKHX = + VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDeviceGroupPresentCapabilitiesKHX, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkDeviceGroupPresentCapabilitiesKHX, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkDeviceGroupPresentCapabilitiesKHX, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkDeviceGroupPresentCapabilitiesKHX, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkDeviceGroupPresentCapabilitiesKHX where + type FieldType "sType" VkDeviceGroupPresentCapabilitiesKHX = + VkStructureType + type FieldOptional "sType" VkDeviceGroupPresentCapabilitiesKHX = + 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkDeviceGroupPresentCapabilitiesKHX = + #{offset VkDeviceGroupPresentCapabilitiesKHX, sType} + type FieldIsArray "sType" VkDeviceGroupPresentCapabilitiesKHX = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDeviceGroupPresentCapabilitiesKHX, sType} + +instance CanReadField "sType" VkDeviceGroupPresentCapabilitiesKHX + where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkDeviceGroupPresentCapabilitiesKHX where + type VkPNextMType VkDeviceGroupPresentCapabilitiesKHX = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDeviceGroupPresentCapabilitiesKHX, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkDeviceGroupPresentCapabilitiesKHX, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkDeviceGroupPresentCapabilitiesKHX, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkDeviceGroupPresentCapabilitiesKHX, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkDeviceGroupPresentCapabilitiesKHX where + type FieldType "pNext" VkDeviceGroupPresentCapabilitiesKHX = + Ptr Void + type FieldOptional "pNext" VkDeviceGroupPresentCapabilitiesKHX = + 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkDeviceGroupPresentCapabilitiesKHX = + #{offset VkDeviceGroupPresentCapabilitiesKHX, pNext} + type FieldIsArray "pNext" VkDeviceGroupPresentCapabilitiesKHX = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDeviceGroupPresentCapabilitiesKHX, pNext} + +instance CanReadField "pNext" VkDeviceGroupPresentCapabilitiesKHX + where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance {-# OVERLAPPING #-} + HasVkPresentMaskArray VkDeviceGroupPresentCapabilitiesKHX where + type VkPresentMaskArrayMType VkDeviceGroupPresentCapabilitiesKHX = + Word32 + + {-# NOINLINE vkPresentMaskArray #-} + vkPresentMaskArray x idx + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) + (idx * sizeOf (undefined :: Word32) + + #{offset VkDeviceGroupPresentCapabilitiesKHX, presentMask})) + + {-# INLINE vkPresentMaskArrayByteOffset #-} + vkPresentMaskArrayByteOffset ~_ + = #{offset VkDeviceGroupPresentCapabilitiesKHX, presentMask} + + {-# INLINE readVkPresentMaskArray #-} + readVkPresentMaskArray p idx + = peekByteOff p + (idx * sizeOf (undefined :: Word32) + + #{offset VkDeviceGroupPresentCapabilitiesKHX, presentMask}) + + {-# INLINE writeVkPresentMaskArray #-} + writeVkPresentMaskArray p idx + = pokeByteOff p + (idx * sizeOf (undefined :: Word32) + + #{offset VkDeviceGroupPresentCapabilitiesKHX, presentMask}) + +instance {-# OVERLAPPING #-} + HasField "presentMask" VkDeviceGroupPresentCapabilitiesKHX where + type FieldType "presentMask" VkDeviceGroupPresentCapabilitiesKHX = + Word32 + type FieldOptional "presentMask" + VkDeviceGroupPresentCapabilitiesKHX + = 'False -- ' closing tick for hsc2hs + type FieldOffset "presentMask" VkDeviceGroupPresentCapabilitiesKHX + = + #{offset VkDeviceGroupPresentCapabilitiesKHX, presentMask} + type FieldIsArray "presentMask" VkDeviceGroupPresentCapabilitiesKHX + = 'True -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDeviceGroupPresentCapabilitiesKHX, presentMask} + +instance (KnownNat idx, + IndexInBounds "presentMask" idx + VkDeviceGroupPresentCapabilitiesKHX) => + CanReadFieldArray "presentMask" idx + VkDeviceGroupPresentCapabilitiesKHX + where + {-# SPECIALISE instance + CanReadFieldArray "presentMask" 0 + VkDeviceGroupPresentCapabilitiesKHX + #-} + + {-# SPECIALISE instance + CanReadFieldArray "presentMask" 1 + VkDeviceGroupPresentCapabilitiesKHX + #-} + + {-# SPECIALISE instance + CanReadFieldArray "presentMask" 2 + VkDeviceGroupPresentCapabilitiesKHX + #-} + + {-# SPECIALISE instance + CanReadFieldArray "presentMask" 3 + VkDeviceGroupPresentCapabilitiesKHX + #-} + type FieldArrayLength "presentMask" + VkDeviceGroupPresentCapabilitiesKHX + = VK_MAX_DEVICE_GROUP_SIZE_KHX + + {-# INLINE fieldArrayLength #-} + fieldArrayLength = VK_MAX_DEVICE_GROUP_SIZE_KHX + + {-# INLINE getFieldArray #-} + getFieldArray x + = vkPresentMaskArray x + (fromInteger $ natVal' (proxy## :: Proxy## idx)) -- ' closing tick for hsc2hs + + {-# INLINE readFieldArray #-} + readFieldArray x + = readVkPresentMaskArray x + (fromInteger $ natVal' (proxy## :: Proxy## idx)) -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkModes VkDeviceGroupPresentCapabilitiesKHX where + type VkModesMType VkDeviceGroupPresentCapabilitiesKHX = + VkDeviceGroupPresentModeFlagsKHX + + {-# NOINLINE vkModes #-} + vkModes x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDeviceGroupPresentCapabilitiesKHX, modes}) + + {-# INLINE vkModesByteOffset #-} + vkModesByteOffset ~_ + = #{offset VkDeviceGroupPresentCapabilitiesKHX, modes} + + {-# INLINE readVkModes #-} + readVkModes p + = peekByteOff p #{offset VkDeviceGroupPresentCapabilitiesKHX, modes} + + {-# INLINE writeVkModes #-} + writeVkModes p + = pokeByteOff p #{offset VkDeviceGroupPresentCapabilitiesKHX, modes} + +instance {-# OVERLAPPING #-} + HasField "modes" VkDeviceGroupPresentCapabilitiesKHX where + type FieldType "modes" VkDeviceGroupPresentCapabilitiesKHX = + VkDeviceGroupPresentModeFlagsKHX + type FieldOptional "modes" VkDeviceGroupPresentCapabilitiesKHX = + 'False -- ' closing tick for hsc2hs + type FieldOffset "modes" VkDeviceGroupPresentCapabilitiesKHX = + #{offset VkDeviceGroupPresentCapabilitiesKHX, modes} + type FieldIsArray "modes" VkDeviceGroupPresentCapabilitiesKHX = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDeviceGroupPresentCapabilitiesKHX, modes} + +instance CanReadField "modes" VkDeviceGroupPresentCapabilitiesKHX + where + {-# INLINE getField #-} + getField = vkModes + + {-# INLINE readField #-} + readField = readVkModes + +instance Show VkDeviceGroupPresentCapabilitiesKHX where + showsPrec d x + = showString "VkDeviceGroupPresentCapabilitiesKHX {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkPresentMaskArray = [" . + showsPrec d + (map (vkPresentMaskArray x) [1 .. VK_MAX_DEVICE_GROUP_SIZE_KHX]) + . + showChar ']' . + showString ", " . + showString "vkModes = " . showsPrec d (vkModes x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkDeviceGroupPresentInfoKHX.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkDeviceGroupPresentInfoKHX.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkDeviceGroupPresentInfoKHX.hsc @@ -0,0 +1,345 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkDeviceGroupPresentInfoKHX + (VkDeviceGroupPresentInfoKHX(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkDeviceGroupPresentModeFlagsKHX (VkDeviceGroupPresentModeFlagBitsKHX) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Struct.VkPresentInfoKHR (VkPresentInfoKHR) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkDeviceGroupPresentInfoKHX { +-- > VkStructureType sType; +-- > const void* pNext; +-- > uint32_t swapchainCount; +-- > const uint32_t* pDeviceMasks; +-- > VkDeviceGroupPresentModeFlagBitsKHX mode; +-- > } VkDeviceGroupPresentInfoKHX; +-- +-- +data VkDeviceGroupPresentInfoKHX = VkDeviceGroupPresentInfoKHX## Addr## + ByteArray## + +instance Eq VkDeviceGroupPresentInfoKHX where + (VkDeviceGroupPresentInfoKHX## a _) == + x@(VkDeviceGroupPresentInfoKHX## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkDeviceGroupPresentInfoKHX where + (VkDeviceGroupPresentInfoKHX## a _) `compare` + x@(VkDeviceGroupPresentInfoKHX## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkDeviceGroupPresentInfoKHX where + sizeOf ~_ = #{size VkDeviceGroupPresentInfoKHX} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkDeviceGroupPresentInfoKHX} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkDeviceGroupPresentInfoKHX where + unsafeAddr (VkDeviceGroupPresentInfoKHX## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkDeviceGroupPresentInfoKHX## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkDeviceGroupPresentInfoKHX## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkDeviceGroupPresentInfoKHX where + type StructFields VkDeviceGroupPresentInfoKHX = + '["sType", "pNext", "swapchainCount", "pDeviceMasks", "mode"] -- ' closing tick for hsc2hs + type CUnionType VkDeviceGroupPresentInfoKHX = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkDeviceGroupPresentInfoKHX = 'False -- ' closing tick for hsc2hs + type StructExtends VkDeviceGroupPresentInfoKHX = + '[VkPresentInfoKHR] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkSType VkDeviceGroupPresentInfoKHX + where + type VkSTypeMType VkDeviceGroupPresentInfoKHX = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDeviceGroupPresentInfoKHX, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkDeviceGroupPresentInfoKHX, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkDeviceGroupPresentInfoKHX, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkDeviceGroupPresentInfoKHX, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkDeviceGroupPresentInfoKHX where + type FieldType "sType" VkDeviceGroupPresentInfoKHX = + VkStructureType + type FieldOptional "sType" VkDeviceGroupPresentInfoKHX = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkDeviceGroupPresentInfoKHX = + #{offset VkDeviceGroupPresentInfoKHX, sType} + type FieldIsArray "sType" VkDeviceGroupPresentInfoKHX = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDeviceGroupPresentInfoKHX, sType} + +instance CanReadField "sType" VkDeviceGroupPresentInfoKHX where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkDeviceGroupPresentInfoKHX where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} HasVkPNext VkDeviceGroupPresentInfoKHX + where + type VkPNextMType VkDeviceGroupPresentInfoKHX = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDeviceGroupPresentInfoKHX, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkDeviceGroupPresentInfoKHX, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkDeviceGroupPresentInfoKHX, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkDeviceGroupPresentInfoKHX, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkDeviceGroupPresentInfoKHX where + type FieldType "pNext" VkDeviceGroupPresentInfoKHX = Ptr Void + type FieldOptional "pNext" VkDeviceGroupPresentInfoKHX = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkDeviceGroupPresentInfoKHX = + #{offset VkDeviceGroupPresentInfoKHX, pNext} + type FieldIsArray "pNext" VkDeviceGroupPresentInfoKHX = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDeviceGroupPresentInfoKHX, pNext} + +instance CanReadField "pNext" VkDeviceGroupPresentInfoKHX where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkDeviceGroupPresentInfoKHX where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkSwapchainCount VkDeviceGroupPresentInfoKHX where + type VkSwapchainCountMType VkDeviceGroupPresentInfoKHX = Word32 + + {-# NOINLINE vkSwapchainCount #-} + vkSwapchainCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDeviceGroupPresentInfoKHX, swapchainCount}) + + {-# INLINE vkSwapchainCountByteOffset #-} + vkSwapchainCountByteOffset ~_ + = #{offset VkDeviceGroupPresentInfoKHX, swapchainCount} + + {-# INLINE readVkSwapchainCount #-} + readVkSwapchainCount p + = peekByteOff p #{offset VkDeviceGroupPresentInfoKHX, swapchainCount} + + {-# INLINE writeVkSwapchainCount #-} + writeVkSwapchainCount p + = pokeByteOff p #{offset VkDeviceGroupPresentInfoKHX, swapchainCount} + +instance {-# OVERLAPPING #-} + HasField "swapchainCount" VkDeviceGroupPresentInfoKHX where + type FieldType "swapchainCount" VkDeviceGroupPresentInfoKHX = + Word32 + type FieldOptional "swapchainCount" VkDeviceGroupPresentInfoKHX = + 'True -- ' closing tick for hsc2hs + type FieldOffset "swapchainCount" VkDeviceGroupPresentInfoKHX = + #{offset VkDeviceGroupPresentInfoKHX, swapchainCount} + type FieldIsArray "swapchainCount" VkDeviceGroupPresentInfoKHX = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDeviceGroupPresentInfoKHX, swapchainCount} + +instance CanReadField "swapchainCount" VkDeviceGroupPresentInfoKHX + where + {-# INLINE getField #-} + getField = vkSwapchainCount + + {-# INLINE readField #-} + readField = readVkSwapchainCount + +instance CanWriteField "swapchainCount" VkDeviceGroupPresentInfoKHX + where + {-# INLINE writeField #-} + writeField = writeVkSwapchainCount + +instance {-# OVERLAPPING #-} + HasVkPDeviceMasks VkDeviceGroupPresentInfoKHX where + type VkPDeviceMasksMType VkDeviceGroupPresentInfoKHX = Ptr Word32 + + {-# NOINLINE vkPDeviceMasks #-} + vkPDeviceMasks x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDeviceGroupPresentInfoKHX, pDeviceMasks}) + + {-# INLINE vkPDeviceMasksByteOffset #-} + vkPDeviceMasksByteOffset ~_ + = #{offset VkDeviceGroupPresentInfoKHX, pDeviceMasks} + + {-# INLINE readVkPDeviceMasks #-} + readVkPDeviceMasks p + = peekByteOff p #{offset VkDeviceGroupPresentInfoKHX, pDeviceMasks} + + {-# INLINE writeVkPDeviceMasks #-} + writeVkPDeviceMasks p + = pokeByteOff p #{offset VkDeviceGroupPresentInfoKHX, pDeviceMasks} + +instance {-# OVERLAPPING #-} + HasField "pDeviceMasks" VkDeviceGroupPresentInfoKHX where + type FieldType "pDeviceMasks" VkDeviceGroupPresentInfoKHX = + Ptr Word32 + type FieldOptional "pDeviceMasks" VkDeviceGroupPresentInfoKHX = + 'False -- ' closing tick for hsc2hs + type FieldOffset "pDeviceMasks" VkDeviceGroupPresentInfoKHX = + #{offset VkDeviceGroupPresentInfoKHX, pDeviceMasks} + type FieldIsArray "pDeviceMasks" VkDeviceGroupPresentInfoKHX = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDeviceGroupPresentInfoKHX, pDeviceMasks} + +instance CanReadField "pDeviceMasks" VkDeviceGroupPresentInfoKHX + where + {-# INLINE getField #-} + getField = vkPDeviceMasks + + {-# INLINE readField #-} + readField = readVkPDeviceMasks + +instance CanWriteField "pDeviceMasks" VkDeviceGroupPresentInfoKHX + where + {-# INLINE writeField #-} + writeField = writeVkPDeviceMasks + +instance {-# OVERLAPPING #-} HasVkMode VkDeviceGroupPresentInfoKHX + where + type VkModeMType VkDeviceGroupPresentInfoKHX = + VkDeviceGroupPresentModeFlagBitsKHX + + {-# NOINLINE vkMode #-} + vkMode x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDeviceGroupPresentInfoKHX, mode}) + + {-# INLINE vkModeByteOffset #-} + vkModeByteOffset ~_ + = #{offset VkDeviceGroupPresentInfoKHX, mode} + + {-# INLINE readVkMode #-} + readVkMode p + = peekByteOff p #{offset VkDeviceGroupPresentInfoKHX, mode} + + {-# INLINE writeVkMode #-} + writeVkMode p + = pokeByteOff p #{offset VkDeviceGroupPresentInfoKHX, mode} + +instance {-# OVERLAPPING #-} + HasField "mode" VkDeviceGroupPresentInfoKHX where + type FieldType "mode" VkDeviceGroupPresentInfoKHX = + VkDeviceGroupPresentModeFlagBitsKHX + type FieldOptional "mode" VkDeviceGroupPresentInfoKHX = 'False -- ' closing tick for hsc2hs + type FieldOffset "mode" VkDeviceGroupPresentInfoKHX = + #{offset VkDeviceGroupPresentInfoKHX, mode} + type FieldIsArray "mode" VkDeviceGroupPresentInfoKHX = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDeviceGroupPresentInfoKHX, mode} + +instance CanReadField "mode" VkDeviceGroupPresentInfoKHX where + {-# INLINE getField #-} + getField = vkMode + + {-# INLINE readField #-} + readField = readVkMode + +instance CanWriteField "mode" VkDeviceGroupPresentInfoKHX where + {-# INLINE writeField #-} + writeField = writeVkMode + +instance Show VkDeviceGroupPresentInfoKHX where + showsPrec d x + = showString "VkDeviceGroupPresentInfoKHX {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkSwapchainCount = " . + showsPrec d (vkSwapchainCount x) . + showString ", " . + showString "vkPDeviceMasks = " . + showsPrec d (vkPDeviceMasks x) . + showString ", " . + showString "vkMode = " . showsPrec d (vkMode x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkDeviceGroupRenderPassBeginInfoKHX.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkDeviceGroupRenderPassBeginInfoKHX.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkDeviceGroupRenderPassBeginInfoKHX.hsc @@ -0,0 +1,386 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkDeviceGroupRenderPassBeginInfoKHX + (VkDeviceGroupRenderPassBeginInfoKHX(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Struct.VkRect2D (VkRect2D) +import Graphics.Vulkan.Types.Struct.VkRenderPassBeginInfo (VkRenderPassBeginInfo) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkDeviceGroupRenderPassBeginInfoKHX { +-- > VkStructureType sType; +-- > const void* pNext; +-- > uint32_t deviceMask; +-- > uint32_t deviceRenderAreaCount; +-- > const VkRect2D* pDeviceRenderAreas; +-- > } VkDeviceGroupRenderPassBeginInfoKHX; +-- +-- +data VkDeviceGroupRenderPassBeginInfoKHX = VkDeviceGroupRenderPassBeginInfoKHX## Addr## + ByteArray## + +instance Eq VkDeviceGroupRenderPassBeginInfoKHX where + (VkDeviceGroupRenderPassBeginInfoKHX## a _) == + x@(VkDeviceGroupRenderPassBeginInfoKHX## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkDeviceGroupRenderPassBeginInfoKHX where + (VkDeviceGroupRenderPassBeginInfoKHX## a _) `compare` + x@(VkDeviceGroupRenderPassBeginInfoKHX## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkDeviceGroupRenderPassBeginInfoKHX where + sizeOf ~_ = #{size VkDeviceGroupRenderPassBeginInfoKHX} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkDeviceGroupRenderPassBeginInfoKHX} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkDeviceGroupRenderPassBeginInfoKHX + where + unsafeAddr (VkDeviceGroupRenderPassBeginInfoKHX## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkDeviceGroupRenderPassBeginInfoKHX## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkDeviceGroupRenderPassBeginInfoKHX## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkDeviceGroupRenderPassBeginInfoKHX where + type StructFields VkDeviceGroupRenderPassBeginInfoKHX = + '["sType", "pNext", "deviceMask", "deviceRenderAreaCount", -- ' closing tick for hsc2hs + "pDeviceRenderAreas"] + type CUnionType VkDeviceGroupRenderPassBeginInfoKHX = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkDeviceGroupRenderPassBeginInfoKHX = 'False -- ' closing tick for hsc2hs + type StructExtends VkDeviceGroupRenderPassBeginInfoKHX = + '[VkRenderPassBeginInfo] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkDeviceGroupRenderPassBeginInfoKHX where + type VkSTypeMType VkDeviceGroupRenderPassBeginInfoKHX = + VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDeviceGroupRenderPassBeginInfoKHX, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkDeviceGroupRenderPassBeginInfoKHX, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkDeviceGroupRenderPassBeginInfoKHX, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkDeviceGroupRenderPassBeginInfoKHX, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkDeviceGroupRenderPassBeginInfoKHX where + type FieldType "sType" VkDeviceGroupRenderPassBeginInfoKHX = + VkStructureType + type FieldOptional "sType" VkDeviceGroupRenderPassBeginInfoKHX = + 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkDeviceGroupRenderPassBeginInfoKHX = + #{offset VkDeviceGroupRenderPassBeginInfoKHX, sType} + type FieldIsArray "sType" VkDeviceGroupRenderPassBeginInfoKHX = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDeviceGroupRenderPassBeginInfoKHX, sType} + +instance CanReadField "sType" VkDeviceGroupRenderPassBeginInfoKHX + where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkDeviceGroupRenderPassBeginInfoKHX + where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkDeviceGroupRenderPassBeginInfoKHX where + type VkPNextMType VkDeviceGroupRenderPassBeginInfoKHX = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDeviceGroupRenderPassBeginInfoKHX, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkDeviceGroupRenderPassBeginInfoKHX, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkDeviceGroupRenderPassBeginInfoKHX, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkDeviceGroupRenderPassBeginInfoKHX, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkDeviceGroupRenderPassBeginInfoKHX where + type FieldType "pNext" VkDeviceGroupRenderPassBeginInfoKHX = + Ptr Void + type FieldOptional "pNext" VkDeviceGroupRenderPassBeginInfoKHX = + 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkDeviceGroupRenderPassBeginInfoKHX = + #{offset VkDeviceGroupRenderPassBeginInfoKHX, pNext} + type FieldIsArray "pNext" VkDeviceGroupRenderPassBeginInfoKHX = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDeviceGroupRenderPassBeginInfoKHX, pNext} + +instance CanReadField "pNext" VkDeviceGroupRenderPassBeginInfoKHX + where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkDeviceGroupRenderPassBeginInfoKHX + where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkDeviceMask VkDeviceGroupRenderPassBeginInfoKHX where + type VkDeviceMaskMType VkDeviceGroupRenderPassBeginInfoKHX = Word32 + + {-# NOINLINE vkDeviceMask #-} + vkDeviceMask x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDeviceGroupRenderPassBeginInfoKHX, deviceMask}) + + {-# INLINE vkDeviceMaskByteOffset #-} + vkDeviceMaskByteOffset ~_ + = #{offset VkDeviceGroupRenderPassBeginInfoKHX, deviceMask} + + {-# INLINE readVkDeviceMask #-} + readVkDeviceMask p + = peekByteOff p #{offset VkDeviceGroupRenderPassBeginInfoKHX, deviceMask} + + {-# INLINE writeVkDeviceMask #-} + writeVkDeviceMask p + = pokeByteOff p #{offset VkDeviceGroupRenderPassBeginInfoKHX, deviceMask} + +instance {-# OVERLAPPING #-} + HasField "deviceMask" VkDeviceGroupRenderPassBeginInfoKHX where + type FieldType "deviceMask" VkDeviceGroupRenderPassBeginInfoKHX = + Word32 + type FieldOptional "deviceMask" VkDeviceGroupRenderPassBeginInfoKHX + = 'False -- ' closing tick for hsc2hs + type FieldOffset "deviceMask" VkDeviceGroupRenderPassBeginInfoKHX = + #{offset VkDeviceGroupRenderPassBeginInfoKHX, deviceMask} + type FieldIsArray "deviceMask" VkDeviceGroupRenderPassBeginInfoKHX + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDeviceGroupRenderPassBeginInfoKHX, deviceMask} + +instance CanReadField "deviceMask" + VkDeviceGroupRenderPassBeginInfoKHX + where + {-# INLINE getField #-} + getField = vkDeviceMask + + {-# INLINE readField #-} + readField = readVkDeviceMask + +instance CanWriteField "deviceMask" + VkDeviceGroupRenderPassBeginInfoKHX + where + {-# INLINE writeField #-} + writeField = writeVkDeviceMask + +instance {-# OVERLAPPING #-} + HasVkDeviceRenderAreaCount VkDeviceGroupRenderPassBeginInfoKHX + where + type VkDeviceRenderAreaCountMType + VkDeviceGroupRenderPassBeginInfoKHX + = Word32 + + {-# NOINLINE vkDeviceRenderAreaCount #-} + vkDeviceRenderAreaCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDeviceGroupRenderPassBeginInfoKHX, deviceRenderAreaCount}) + + {-# INLINE vkDeviceRenderAreaCountByteOffset #-} + vkDeviceRenderAreaCountByteOffset ~_ + = #{offset VkDeviceGroupRenderPassBeginInfoKHX, deviceRenderAreaCount} + + {-# INLINE readVkDeviceRenderAreaCount #-} + readVkDeviceRenderAreaCount p + = peekByteOff p #{offset VkDeviceGroupRenderPassBeginInfoKHX, deviceRenderAreaCount} + + {-# INLINE writeVkDeviceRenderAreaCount #-} + writeVkDeviceRenderAreaCount p + = pokeByteOff p #{offset VkDeviceGroupRenderPassBeginInfoKHX, deviceRenderAreaCount} + +instance {-# OVERLAPPING #-} + HasField "deviceRenderAreaCount" + VkDeviceGroupRenderPassBeginInfoKHX + where + type FieldType "deviceRenderAreaCount" + VkDeviceGroupRenderPassBeginInfoKHX + = Word32 + type FieldOptional "deviceRenderAreaCount" + VkDeviceGroupRenderPassBeginInfoKHX + = 'True -- ' closing tick for hsc2hs + type FieldOffset "deviceRenderAreaCount" + VkDeviceGroupRenderPassBeginInfoKHX + = + #{offset VkDeviceGroupRenderPassBeginInfoKHX, deviceRenderAreaCount} + type FieldIsArray "deviceRenderAreaCount" + VkDeviceGroupRenderPassBeginInfoKHX + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDeviceGroupRenderPassBeginInfoKHX, deviceRenderAreaCount} + +instance CanReadField "deviceRenderAreaCount" + VkDeviceGroupRenderPassBeginInfoKHX + where + {-# INLINE getField #-} + getField = vkDeviceRenderAreaCount + + {-# INLINE readField #-} + readField = readVkDeviceRenderAreaCount + +instance CanWriteField "deviceRenderAreaCount" + VkDeviceGroupRenderPassBeginInfoKHX + where + {-# INLINE writeField #-} + writeField = writeVkDeviceRenderAreaCount + +instance {-# OVERLAPPING #-} + HasVkPDeviceRenderAreas VkDeviceGroupRenderPassBeginInfoKHX where + type VkPDeviceRenderAreasMType VkDeviceGroupRenderPassBeginInfoKHX + = Ptr VkRect2D + + {-# NOINLINE vkPDeviceRenderAreas #-} + vkPDeviceRenderAreas x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDeviceGroupRenderPassBeginInfoKHX, pDeviceRenderAreas}) + + {-# INLINE vkPDeviceRenderAreasByteOffset #-} + vkPDeviceRenderAreasByteOffset ~_ + = #{offset VkDeviceGroupRenderPassBeginInfoKHX, pDeviceRenderAreas} + + {-# INLINE readVkPDeviceRenderAreas #-} + readVkPDeviceRenderAreas p + = peekByteOff p #{offset VkDeviceGroupRenderPassBeginInfoKHX, pDeviceRenderAreas} + + {-# INLINE writeVkPDeviceRenderAreas #-} + writeVkPDeviceRenderAreas p + = pokeByteOff p #{offset VkDeviceGroupRenderPassBeginInfoKHX, pDeviceRenderAreas} + +instance {-# OVERLAPPING #-} + HasField "pDeviceRenderAreas" VkDeviceGroupRenderPassBeginInfoKHX + where + type FieldType "pDeviceRenderAreas" + VkDeviceGroupRenderPassBeginInfoKHX + = Ptr VkRect2D + type FieldOptional "pDeviceRenderAreas" + VkDeviceGroupRenderPassBeginInfoKHX + = 'False -- ' closing tick for hsc2hs + type FieldOffset "pDeviceRenderAreas" + VkDeviceGroupRenderPassBeginInfoKHX + = + #{offset VkDeviceGroupRenderPassBeginInfoKHX, pDeviceRenderAreas} + type FieldIsArray "pDeviceRenderAreas" + VkDeviceGroupRenderPassBeginInfoKHX + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDeviceGroupRenderPassBeginInfoKHX, pDeviceRenderAreas} + +instance CanReadField "pDeviceRenderAreas" + VkDeviceGroupRenderPassBeginInfoKHX + where + {-# INLINE getField #-} + getField = vkPDeviceRenderAreas + + {-# INLINE readField #-} + readField = readVkPDeviceRenderAreas + +instance CanWriteField "pDeviceRenderAreas" + VkDeviceGroupRenderPassBeginInfoKHX + where + {-# INLINE writeField #-} + writeField = writeVkPDeviceRenderAreas + +instance Show VkDeviceGroupRenderPassBeginInfoKHX where + showsPrec d x + = showString "VkDeviceGroupRenderPassBeginInfoKHX {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkDeviceMask = " . + showsPrec d (vkDeviceMask x) . + showString ", " . + showString "vkDeviceRenderAreaCount = " . + showsPrec d (vkDeviceRenderAreaCount x) . + showString ", " . + showString "vkPDeviceRenderAreas = " . + showsPrec d (vkPDeviceRenderAreas x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkDeviceGroupSubmitInfoKHX.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkDeviceGroupSubmitInfoKHX.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkDeviceGroupSubmitInfoKHX.hsc @@ -0,0 +1,558 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkDeviceGroupSubmitInfoKHX + (VkDeviceGroupSubmitInfoKHX(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Struct.VkSubmitInfo (VkSubmitInfo) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkDeviceGroupSubmitInfoKHX { +-- > VkStructureType sType; +-- > const void* pNext; +-- > uint32_t waitSemaphoreCount; +-- > const uint32_t* pWaitSemaphoreDeviceIndices; +-- > uint32_t commandBufferCount; +-- > const uint32_t* pCommandBufferDeviceMasks; +-- > uint32_t signalSemaphoreCount; +-- > const uint32_t* pSignalSemaphoreDeviceIndices; +-- > } VkDeviceGroupSubmitInfoKHX; +-- +-- +data VkDeviceGroupSubmitInfoKHX = VkDeviceGroupSubmitInfoKHX## Addr## + ByteArray## + +instance Eq VkDeviceGroupSubmitInfoKHX where + (VkDeviceGroupSubmitInfoKHX## a _) == + x@(VkDeviceGroupSubmitInfoKHX## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkDeviceGroupSubmitInfoKHX where + (VkDeviceGroupSubmitInfoKHX## a _) `compare` + x@(VkDeviceGroupSubmitInfoKHX## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkDeviceGroupSubmitInfoKHX where + sizeOf ~_ = #{size VkDeviceGroupSubmitInfoKHX} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkDeviceGroupSubmitInfoKHX} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkDeviceGroupSubmitInfoKHX where + unsafeAddr (VkDeviceGroupSubmitInfoKHX## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkDeviceGroupSubmitInfoKHX## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkDeviceGroupSubmitInfoKHX## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkDeviceGroupSubmitInfoKHX where + type StructFields VkDeviceGroupSubmitInfoKHX = + '["sType", "pNext", "waitSemaphoreCount", -- ' closing tick for hsc2hs + "pWaitSemaphoreDeviceIndices", "commandBufferCount", + "pCommandBufferDeviceMasks", "signalSemaphoreCount", + "pSignalSemaphoreDeviceIndices"] + type CUnionType VkDeviceGroupSubmitInfoKHX = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkDeviceGroupSubmitInfoKHX = 'False -- ' closing tick for hsc2hs + type StructExtends VkDeviceGroupSubmitInfoKHX = '[VkSubmitInfo] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkSType VkDeviceGroupSubmitInfoKHX + where + type VkSTypeMType VkDeviceGroupSubmitInfoKHX = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDeviceGroupSubmitInfoKHX, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkDeviceGroupSubmitInfoKHX, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkDeviceGroupSubmitInfoKHX, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkDeviceGroupSubmitInfoKHX, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkDeviceGroupSubmitInfoKHX where + type FieldType "sType" VkDeviceGroupSubmitInfoKHX = VkStructureType + type FieldOptional "sType" VkDeviceGroupSubmitInfoKHX = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkDeviceGroupSubmitInfoKHX = + #{offset VkDeviceGroupSubmitInfoKHX, sType} + type FieldIsArray "sType" VkDeviceGroupSubmitInfoKHX = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDeviceGroupSubmitInfoKHX, sType} + +instance CanReadField "sType" VkDeviceGroupSubmitInfoKHX where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkDeviceGroupSubmitInfoKHX where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} HasVkPNext VkDeviceGroupSubmitInfoKHX + where + type VkPNextMType VkDeviceGroupSubmitInfoKHX = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDeviceGroupSubmitInfoKHX, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkDeviceGroupSubmitInfoKHX, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkDeviceGroupSubmitInfoKHX, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkDeviceGroupSubmitInfoKHX, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkDeviceGroupSubmitInfoKHX where + type FieldType "pNext" VkDeviceGroupSubmitInfoKHX = Ptr Void + type FieldOptional "pNext" VkDeviceGroupSubmitInfoKHX = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkDeviceGroupSubmitInfoKHX = + #{offset VkDeviceGroupSubmitInfoKHX, pNext} + type FieldIsArray "pNext" VkDeviceGroupSubmitInfoKHX = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDeviceGroupSubmitInfoKHX, pNext} + +instance CanReadField "pNext" VkDeviceGroupSubmitInfoKHX where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkDeviceGroupSubmitInfoKHX where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkWaitSemaphoreCount VkDeviceGroupSubmitInfoKHX where + type VkWaitSemaphoreCountMType VkDeviceGroupSubmitInfoKHX = Word32 + + {-# NOINLINE vkWaitSemaphoreCount #-} + vkWaitSemaphoreCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDeviceGroupSubmitInfoKHX, waitSemaphoreCount}) + + {-# INLINE vkWaitSemaphoreCountByteOffset #-} + vkWaitSemaphoreCountByteOffset ~_ + = #{offset VkDeviceGroupSubmitInfoKHX, waitSemaphoreCount} + + {-# INLINE readVkWaitSemaphoreCount #-} + readVkWaitSemaphoreCount p + = peekByteOff p #{offset VkDeviceGroupSubmitInfoKHX, waitSemaphoreCount} + + {-# INLINE writeVkWaitSemaphoreCount #-} + writeVkWaitSemaphoreCount p + = pokeByteOff p #{offset VkDeviceGroupSubmitInfoKHX, waitSemaphoreCount} + +instance {-# OVERLAPPING #-} + HasField "waitSemaphoreCount" VkDeviceGroupSubmitInfoKHX where + type FieldType "waitSemaphoreCount" VkDeviceGroupSubmitInfoKHX = + Word32 + type FieldOptional "waitSemaphoreCount" VkDeviceGroupSubmitInfoKHX + = 'True -- ' closing tick for hsc2hs + type FieldOffset "waitSemaphoreCount" VkDeviceGroupSubmitInfoKHX = + #{offset VkDeviceGroupSubmitInfoKHX, waitSemaphoreCount} + type FieldIsArray "waitSemaphoreCount" VkDeviceGroupSubmitInfoKHX = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDeviceGroupSubmitInfoKHX, waitSemaphoreCount} + +instance CanReadField "waitSemaphoreCount" + VkDeviceGroupSubmitInfoKHX + where + {-# INLINE getField #-} + getField = vkWaitSemaphoreCount + + {-# INLINE readField #-} + readField = readVkWaitSemaphoreCount + +instance CanWriteField "waitSemaphoreCount" + VkDeviceGroupSubmitInfoKHX + where + {-# INLINE writeField #-} + writeField = writeVkWaitSemaphoreCount + +instance {-# OVERLAPPING #-} + HasVkPWaitSemaphoreDeviceIndices VkDeviceGroupSubmitInfoKHX where + type VkPWaitSemaphoreDeviceIndicesMType VkDeviceGroupSubmitInfoKHX + = Ptr Word32 + + {-# NOINLINE vkPWaitSemaphoreDeviceIndices #-} + vkPWaitSemaphoreDeviceIndices x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDeviceGroupSubmitInfoKHX, pWaitSemaphoreDeviceIndices}) + + {-# INLINE vkPWaitSemaphoreDeviceIndicesByteOffset #-} + vkPWaitSemaphoreDeviceIndicesByteOffset ~_ + = #{offset VkDeviceGroupSubmitInfoKHX, pWaitSemaphoreDeviceIndices} + + {-# INLINE readVkPWaitSemaphoreDeviceIndices #-} + readVkPWaitSemaphoreDeviceIndices p + = peekByteOff p #{offset VkDeviceGroupSubmitInfoKHX, pWaitSemaphoreDeviceIndices} + + {-# INLINE writeVkPWaitSemaphoreDeviceIndices #-} + writeVkPWaitSemaphoreDeviceIndices p + = pokeByteOff p #{offset VkDeviceGroupSubmitInfoKHX, pWaitSemaphoreDeviceIndices} + +instance {-# OVERLAPPING #-} + HasField "pWaitSemaphoreDeviceIndices" VkDeviceGroupSubmitInfoKHX + where + type FieldType "pWaitSemaphoreDeviceIndices" + VkDeviceGroupSubmitInfoKHX + = Ptr Word32 + type FieldOptional "pWaitSemaphoreDeviceIndices" + VkDeviceGroupSubmitInfoKHX + = 'False -- ' closing tick for hsc2hs + type FieldOffset "pWaitSemaphoreDeviceIndices" + VkDeviceGroupSubmitInfoKHX + = + #{offset VkDeviceGroupSubmitInfoKHX, pWaitSemaphoreDeviceIndices} + type FieldIsArray "pWaitSemaphoreDeviceIndices" + VkDeviceGroupSubmitInfoKHX + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDeviceGroupSubmitInfoKHX, pWaitSemaphoreDeviceIndices} + +instance CanReadField "pWaitSemaphoreDeviceIndices" + VkDeviceGroupSubmitInfoKHX + where + {-# INLINE getField #-} + getField = vkPWaitSemaphoreDeviceIndices + + {-# INLINE readField #-} + readField = readVkPWaitSemaphoreDeviceIndices + +instance CanWriteField "pWaitSemaphoreDeviceIndices" + VkDeviceGroupSubmitInfoKHX + where + {-# INLINE writeField #-} + writeField = writeVkPWaitSemaphoreDeviceIndices + +instance {-# OVERLAPPING #-} + HasVkCommandBufferCount VkDeviceGroupSubmitInfoKHX where + type VkCommandBufferCountMType VkDeviceGroupSubmitInfoKHX = Word32 + + {-# NOINLINE vkCommandBufferCount #-} + vkCommandBufferCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDeviceGroupSubmitInfoKHX, commandBufferCount}) + + {-# INLINE vkCommandBufferCountByteOffset #-} + vkCommandBufferCountByteOffset ~_ + = #{offset VkDeviceGroupSubmitInfoKHX, commandBufferCount} + + {-# INLINE readVkCommandBufferCount #-} + readVkCommandBufferCount p + = peekByteOff p #{offset VkDeviceGroupSubmitInfoKHX, commandBufferCount} + + {-# INLINE writeVkCommandBufferCount #-} + writeVkCommandBufferCount p + = pokeByteOff p #{offset VkDeviceGroupSubmitInfoKHX, commandBufferCount} + +instance {-# OVERLAPPING #-} + HasField "commandBufferCount" VkDeviceGroupSubmitInfoKHX where + type FieldType "commandBufferCount" VkDeviceGroupSubmitInfoKHX = + Word32 + type FieldOptional "commandBufferCount" VkDeviceGroupSubmitInfoKHX + = 'True -- ' closing tick for hsc2hs + type FieldOffset "commandBufferCount" VkDeviceGroupSubmitInfoKHX = + #{offset VkDeviceGroupSubmitInfoKHX, commandBufferCount} + type FieldIsArray "commandBufferCount" VkDeviceGroupSubmitInfoKHX = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDeviceGroupSubmitInfoKHX, commandBufferCount} + +instance CanReadField "commandBufferCount" + VkDeviceGroupSubmitInfoKHX + where + {-# INLINE getField #-} + getField = vkCommandBufferCount + + {-# INLINE readField #-} + readField = readVkCommandBufferCount + +instance CanWriteField "commandBufferCount" + VkDeviceGroupSubmitInfoKHX + where + {-# INLINE writeField #-} + writeField = writeVkCommandBufferCount + +instance {-# OVERLAPPING #-} + HasVkPCommandBufferDeviceMasks VkDeviceGroupSubmitInfoKHX where + type VkPCommandBufferDeviceMasksMType VkDeviceGroupSubmitInfoKHX = + Ptr Word32 + + {-# NOINLINE vkPCommandBufferDeviceMasks #-} + vkPCommandBufferDeviceMasks x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDeviceGroupSubmitInfoKHX, pCommandBufferDeviceMasks}) + + {-# INLINE vkPCommandBufferDeviceMasksByteOffset #-} + vkPCommandBufferDeviceMasksByteOffset ~_ + = #{offset VkDeviceGroupSubmitInfoKHX, pCommandBufferDeviceMasks} + + {-# INLINE readVkPCommandBufferDeviceMasks #-} + readVkPCommandBufferDeviceMasks p + = peekByteOff p #{offset VkDeviceGroupSubmitInfoKHX, pCommandBufferDeviceMasks} + + {-# INLINE writeVkPCommandBufferDeviceMasks #-} + writeVkPCommandBufferDeviceMasks p + = pokeByteOff p #{offset VkDeviceGroupSubmitInfoKHX, pCommandBufferDeviceMasks} + +instance {-# OVERLAPPING #-} + HasField "pCommandBufferDeviceMasks" VkDeviceGroupSubmitInfoKHX + where + type FieldType "pCommandBufferDeviceMasks" + VkDeviceGroupSubmitInfoKHX + = Ptr Word32 + type FieldOptional "pCommandBufferDeviceMasks" + VkDeviceGroupSubmitInfoKHX + = 'False -- ' closing tick for hsc2hs + type FieldOffset "pCommandBufferDeviceMasks" + VkDeviceGroupSubmitInfoKHX + = + #{offset VkDeviceGroupSubmitInfoKHX, pCommandBufferDeviceMasks} + type FieldIsArray "pCommandBufferDeviceMasks" + VkDeviceGroupSubmitInfoKHX + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDeviceGroupSubmitInfoKHX, pCommandBufferDeviceMasks} + +instance CanReadField "pCommandBufferDeviceMasks" + VkDeviceGroupSubmitInfoKHX + where + {-# INLINE getField #-} + getField = vkPCommandBufferDeviceMasks + + {-# INLINE readField #-} + readField = readVkPCommandBufferDeviceMasks + +instance CanWriteField "pCommandBufferDeviceMasks" + VkDeviceGroupSubmitInfoKHX + where + {-# INLINE writeField #-} + writeField = writeVkPCommandBufferDeviceMasks + +instance {-# OVERLAPPING #-} + HasVkSignalSemaphoreCount VkDeviceGroupSubmitInfoKHX where + type VkSignalSemaphoreCountMType VkDeviceGroupSubmitInfoKHX = + Word32 + + {-# NOINLINE vkSignalSemaphoreCount #-} + vkSignalSemaphoreCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDeviceGroupSubmitInfoKHX, signalSemaphoreCount}) + + {-# INLINE vkSignalSemaphoreCountByteOffset #-} + vkSignalSemaphoreCountByteOffset ~_ + = #{offset VkDeviceGroupSubmitInfoKHX, signalSemaphoreCount} + + {-# INLINE readVkSignalSemaphoreCount #-} + readVkSignalSemaphoreCount p + = peekByteOff p #{offset VkDeviceGroupSubmitInfoKHX, signalSemaphoreCount} + + {-# INLINE writeVkSignalSemaphoreCount #-} + writeVkSignalSemaphoreCount p + = pokeByteOff p #{offset VkDeviceGroupSubmitInfoKHX, signalSemaphoreCount} + +instance {-# OVERLAPPING #-} + HasField "signalSemaphoreCount" VkDeviceGroupSubmitInfoKHX where + type FieldType "signalSemaphoreCount" VkDeviceGroupSubmitInfoKHX = + Word32 + type FieldOptional "signalSemaphoreCount" + VkDeviceGroupSubmitInfoKHX + = 'True -- ' closing tick for hsc2hs + type FieldOffset "signalSemaphoreCount" VkDeviceGroupSubmitInfoKHX + = + #{offset VkDeviceGroupSubmitInfoKHX, signalSemaphoreCount} + type FieldIsArray "signalSemaphoreCount" VkDeviceGroupSubmitInfoKHX + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDeviceGroupSubmitInfoKHX, signalSemaphoreCount} + +instance CanReadField "signalSemaphoreCount" + VkDeviceGroupSubmitInfoKHX + where + {-# INLINE getField #-} + getField = vkSignalSemaphoreCount + + {-# INLINE readField #-} + readField = readVkSignalSemaphoreCount + +instance CanWriteField "signalSemaphoreCount" + VkDeviceGroupSubmitInfoKHX + where + {-# INLINE writeField #-} + writeField = writeVkSignalSemaphoreCount + +instance {-# OVERLAPPING #-} + HasVkPSignalSemaphoreDeviceIndices VkDeviceGroupSubmitInfoKHX where + type VkPSignalSemaphoreDeviceIndicesMType + VkDeviceGroupSubmitInfoKHX + = Ptr Word32 + + {-# NOINLINE vkPSignalSemaphoreDeviceIndices #-} + vkPSignalSemaphoreDeviceIndices x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDeviceGroupSubmitInfoKHX, pSignalSemaphoreDeviceIndices}) + + {-# INLINE vkPSignalSemaphoreDeviceIndicesByteOffset #-} + vkPSignalSemaphoreDeviceIndicesByteOffset ~_ + = #{offset VkDeviceGroupSubmitInfoKHX, pSignalSemaphoreDeviceIndices} + + {-# INLINE readVkPSignalSemaphoreDeviceIndices #-} + readVkPSignalSemaphoreDeviceIndices p + = peekByteOff p #{offset VkDeviceGroupSubmitInfoKHX, pSignalSemaphoreDeviceIndices} + + {-# INLINE writeVkPSignalSemaphoreDeviceIndices #-} + writeVkPSignalSemaphoreDeviceIndices p + = pokeByteOff p #{offset VkDeviceGroupSubmitInfoKHX, pSignalSemaphoreDeviceIndices} + +instance {-# OVERLAPPING #-} + HasField "pSignalSemaphoreDeviceIndices" VkDeviceGroupSubmitInfoKHX + where + type FieldType "pSignalSemaphoreDeviceIndices" + VkDeviceGroupSubmitInfoKHX + = Ptr Word32 + type FieldOptional "pSignalSemaphoreDeviceIndices" + VkDeviceGroupSubmitInfoKHX + = 'False -- ' closing tick for hsc2hs + type FieldOffset "pSignalSemaphoreDeviceIndices" + VkDeviceGroupSubmitInfoKHX + = + #{offset VkDeviceGroupSubmitInfoKHX, pSignalSemaphoreDeviceIndices} + type FieldIsArray "pSignalSemaphoreDeviceIndices" + VkDeviceGroupSubmitInfoKHX + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDeviceGroupSubmitInfoKHX, pSignalSemaphoreDeviceIndices} + +instance CanReadField "pSignalSemaphoreDeviceIndices" + VkDeviceGroupSubmitInfoKHX + where + {-# INLINE getField #-} + getField = vkPSignalSemaphoreDeviceIndices + + {-# INLINE readField #-} + readField = readVkPSignalSemaphoreDeviceIndices + +instance CanWriteField "pSignalSemaphoreDeviceIndices" + VkDeviceGroupSubmitInfoKHX + where + {-# INLINE writeField #-} + writeField = writeVkPSignalSemaphoreDeviceIndices + +instance Show VkDeviceGroupSubmitInfoKHX where + showsPrec d x + = showString "VkDeviceGroupSubmitInfoKHX {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkWaitSemaphoreCount = " . + showsPrec d (vkWaitSemaphoreCount x) . + showString ", " . + showString "vkPWaitSemaphoreDeviceIndices = " . + showsPrec d (vkPWaitSemaphoreDeviceIndices x) . + showString ", " . + showString "vkCommandBufferCount = " . + showsPrec d (vkCommandBufferCount x) . + showString ", " . + showString "vkPCommandBufferDeviceMasks = " . + showsPrec d (vkPCommandBufferDeviceMasks x) . + showString ", " . + showString "vkSignalSemaphoreCount = " . + showsPrec d (vkSignalSemaphoreCount x) . + showString ", " . + showString + "vkPSignalSemaphoreDeviceIndices = " + . + showsPrec d + (vkPSignalSemaphoreDeviceIndices x) + . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkDeviceGroupSwapchainCreateInfoKHX.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkDeviceGroupSwapchainCreateInfoKHX.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkDeviceGroupSwapchainCreateInfoKHX.hsc @@ -0,0 +1,250 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkDeviceGroupSwapchainCreateInfoKHX + (VkDeviceGroupSwapchainCreateInfoKHX(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkDeviceGroupPresentModeFlagsKHX (VkDeviceGroupPresentModeFlagsKHX) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Struct.VkSwapchainCreateInfoKHR (VkSwapchainCreateInfoKHR) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkDeviceGroupSwapchainCreateInfoKHX { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkDeviceGroupPresentModeFlagsKHX modes; +-- > } VkDeviceGroupSwapchainCreateInfoKHX; +-- +-- +data VkDeviceGroupSwapchainCreateInfoKHX = VkDeviceGroupSwapchainCreateInfoKHX## Addr## + ByteArray## + +instance Eq VkDeviceGroupSwapchainCreateInfoKHX where + (VkDeviceGroupSwapchainCreateInfoKHX## a _) == + x@(VkDeviceGroupSwapchainCreateInfoKHX## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkDeviceGroupSwapchainCreateInfoKHX where + (VkDeviceGroupSwapchainCreateInfoKHX## a _) `compare` + x@(VkDeviceGroupSwapchainCreateInfoKHX## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkDeviceGroupSwapchainCreateInfoKHX where + sizeOf ~_ = #{size VkDeviceGroupSwapchainCreateInfoKHX} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkDeviceGroupSwapchainCreateInfoKHX} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkDeviceGroupSwapchainCreateInfoKHX + where + unsafeAddr (VkDeviceGroupSwapchainCreateInfoKHX## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkDeviceGroupSwapchainCreateInfoKHX## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkDeviceGroupSwapchainCreateInfoKHX## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkDeviceGroupSwapchainCreateInfoKHX where + type StructFields VkDeviceGroupSwapchainCreateInfoKHX = + '["sType", "pNext", "modes"] -- ' closing tick for hsc2hs + type CUnionType VkDeviceGroupSwapchainCreateInfoKHX = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkDeviceGroupSwapchainCreateInfoKHX = 'False -- ' closing tick for hsc2hs + type StructExtends VkDeviceGroupSwapchainCreateInfoKHX = + '[VkSwapchainCreateInfoKHR] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkDeviceGroupSwapchainCreateInfoKHX where + type VkSTypeMType VkDeviceGroupSwapchainCreateInfoKHX = + VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDeviceGroupSwapchainCreateInfoKHX, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkDeviceGroupSwapchainCreateInfoKHX, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkDeviceGroupSwapchainCreateInfoKHX, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkDeviceGroupSwapchainCreateInfoKHX, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkDeviceGroupSwapchainCreateInfoKHX where + type FieldType "sType" VkDeviceGroupSwapchainCreateInfoKHX = + VkStructureType + type FieldOptional "sType" VkDeviceGroupSwapchainCreateInfoKHX = + 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkDeviceGroupSwapchainCreateInfoKHX = + #{offset VkDeviceGroupSwapchainCreateInfoKHX, sType} + type FieldIsArray "sType" VkDeviceGroupSwapchainCreateInfoKHX = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDeviceGroupSwapchainCreateInfoKHX, sType} + +instance CanReadField "sType" VkDeviceGroupSwapchainCreateInfoKHX + where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkDeviceGroupSwapchainCreateInfoKHX + where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkDeviceGroupSwapchainCreateInfoKHX where + type VkPNextMType VkDeviceGroupSwapchainCreateInfoKHX = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDeviceGroupSwapchainCreateInfoKHX, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkDeviceGroupSwapchainCreateInfoKHX, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkDeviceGroupSwapchainCreateInfoKHX, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkDeviceGroupSwapchainCreateInfoKHX, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkDeviceGroupSwapchainCreateInfoKHX where + type FieldType "pNext" VkDeviceGroupSwapchainCreateInfoKHX = + Ptr Void + type FieldOptional "pNext" VkDeviceGroupSwapchainCreateInfoKHX = + 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkDeviceGroupSwapchainCreateInfoKHX = + #{offset VkDeviceGroupSwapchainCreateInfoKHX, pNext} + type FieldIsArray "pNext" VkDeviceGroupSwapchainCreateInfoKHX = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDeviceGroupSwapchainCreateInfoKHX, pNext} + +instance CanReadField "pNext" VkDeviceGroupSwapchainCreateInfoKHX + where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkDeviceGroupSwapchainCreateInfoKHX + where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkModes VkDeviceGroupSwapchainCreateInfoKHX where + type VkModesMType VkDeviceGroupSwapchainCreateInfoKHX = + VkDeviceGroupPresentModeFlagsKHX + + {-# NOINLINE vkModes #-} + vkModes x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDeviceGroupSwapchainCreateInfoKHX, modes}) + + {-# INLINE vkModesByteOffset #-} + vkModesByteOffset ~_ + = #{offset VkDeviceGroupSwapchainCreateInfoKHX, modes} + + {-# INLINE readVkModes #-} + readVkModes p + = peekByteOff p #{offset VkDeviceGroupSwapchainCreateInfoKHX, modes} + + {-# INLINE writeVkModes #-} + writeVkModes p + = pokeByteOff p #{offset VkDeviceGroupSwapchainCreateInfoKHX, modes} + +instance {-# OVERLAPPING #-} + HasField "modes" VkDeviceGroupSwapchainCreateInfoKHX where + type FieldType "modes" VkDeviceGroupSwapchainCreateInfoKHX = + VkDeviceGroupPresentModeFlagsKHX + type FieldOptional "modes" VkDeviceGroupSwapchainCreateInfoKHX = + 'False -- ' closing tick for hsc2hs + type FieldOffset "modes" VkDeviceGroupSwapchainCreateInfoKHX = + #{offset VkDeviceGroupSwapchainCreateInfoKHX, modes} + type FieldIsArray "modes" VkDeviceGroupSwapchainCreateInfoKHX = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDeviceGroupSwapchainCreateInfoKHX, modes} + +instance CanReadField "modes" VkDeviceGroupSwapchainCreateInfoKHX + where + {-# INLINE getField #-} + getField = vkModes + + {-# INLINE readField #-} + readField = readVkModes + +instance CanWriteField "modes" VkDeviceGroupSwapchainCreateInfoKHX + where + {-# INLINE writeField #-} + writeField = writeVkModes + +instance Show VkDeviceGroupSwapchainCreateInfoKHX where + showsPrec d x + = showString "VkDeviceGroupSwapchainCreateInfoKHX {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkModes = " . showsPrec d (vkModes x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkDeviceQueueCreateInfo.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkDeviceQueueCreateInfo.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkDeviceQueueCreateInfo.hsc @@ -0,0 +1,389 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkDeviceQueueCreateInfo + (VkDeviceQueueCreateInfo(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Bitmasks (VkDeviceQueueCreateFlags) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkDeviceQueueCreateInfo { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkDeviceQueueCreateFlags flags; +-- > uint32_t queueFamilyIndex; +-- > uint32_t queueCount; +-- > const float* pQueuePriorities; +-- > } VkDeviceQueueCreateInfo; +-- +-- +data VkDeviceQueueCreateInfo = VkDeviceQueueCreateInfo## Addr## + ByteArray## + +instance Eq VkDeviceQueueCreateInfo where + (VkDeviceQueueCreateInfo## a _) == x@(VkDeviceQueueCreateInfo## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkDeviceQueueCreateInfo where + (VkDeviceQueueCreateInfo## a _) `compare` + x@(VkDeviceQueueCreateInfo## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkDeviceQueueCreateInfo where + sizeOf ~_ = #{size VkDeviceQueueCreateInfo} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkDeviceQueueCreateInfo} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkDeviceQueueCreateInfo where + unsafeAddr (VkDeviceQueueCreateInfo## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkDeviceQueueCreateInfo## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkDeviceQueueCreateInfo## (plusAddr## (byteArrayContents## b) off) b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkDeviceQueueCreateInfo where + type StructFields VkDeviceQueueCreateInfo = + '["sType", "pNext", "flags", "queueFamilyIndex", "queueCount", -- ' closing tick for hsc2hs + "pQueuePriorities"] + type CUnionType VkDeviceQueueCreateInfo = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkDeviceQueueCreateInfo = 'False -- ' closing tick for hsc2hs + type StructExtends VkDeviceQueueCreateInfo = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkSType VkDeviceQueueCreateInfo + where + type VkSTypeMType VkDeviceQueueCreateInfo = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDeviceQueueCreateInfo, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkDeviceQueueCreateInfo, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkDeviceQueueCreateInfo, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkDeviceQueueCreateInfo, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkDeviceQueueCreateInfo where + type FieldType "sType" VkDeviceQueueCreateInfo = VkStructureType + type FieldOptional "sType" VkDeviceQueueCreateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkDeviceQueueCreateInfo = + #{offset VkDeviceQueueCreateInfo, sType} + type FieldIsArray "sType" VkDeviceQueueCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkDeviceQueueCreateInfo, sType} + +instance CanReadField "sType" VkDeviceQueueCreateInfo where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkDeviceQueueCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} HasVkPNext VkDeviceQueueCreateInfo + where + type VkPNextMType VkDeviceQueueCreateInfo = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDeviceQueueCreateInfo, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkDeviceQueueCreateInfo, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkDeviceQueueCreateInfo, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkDeviceQueueCreateInfo, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkDeviceQueueCreateInfo where + type FieldType "pNext" VkDeviceQueueCreateInfo = Ptr Void + type FieldOptional "pNext" VkDeviceQueueCreateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkDeviceQueueCreateInfo = + #{offset VkDeviceQueueCreateInfo, pNext} + type FieldIsArray "pNext" VkDeviceQueueCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkDeviceQueueCreateInfo, pNext} + +instance CanReadField "pNext" VkDeviceQueueCreateInfo where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkDeviceQueueCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} HasVkFlags VkDeviceQueueCreateInfo + where + type VkFlagsMType VkDeviceQueueCreateInfo = + VkDeviceQueueCreateFlags + + {-# NOINLINE vkFlags #-} + vkFlags x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDeviceQueueCreateInfo, flags}) + + {-# INLINE vkFlagsByteOffset #-} + vkFlagsByteOffset ~_ + = #{offset VkDeviceQueueCreateInfo, flags} + + {-# INLINE readVkFlags #-} + readVkFlags p + = peekByteOff p #{offset VkDeviceQueueCreateInfo, flags} + + {-# INLINE writeVkFlags #-} + writeVkFlags p + = pokeByteOff p #{offset VkDeviceQueueCreateInfo, flags} + +instance {-# OVERLAPPING #-} + HasField "flags" VkDeviceQueueCreateInfo where + type FieldType "flags" VkDeviceQueueCreateInfo = + VkDeviceQueueCreateFlags + type FieldOptional "flags" VkDeviceQueueCreateInfo = 'True -- ' closing tick for hsc2hs + type FieldOffset "flags" VkDeviceQueueCreateInfo = + #{offset VkDeviceQueueCreateInfo, flags} + type FieldIsArray "flags" VkDeviceQueueCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkDeviceQueueCreateInfo, flags} + +instance CanReadField "flags" VkDeviceQueueCreateInfo where + {-# INLINE getField #-} + getField = vkFlags + + {-# INLINE readField #-} + readField = readVkFlags + +instance CanWriteField "flags" VkDeviceQueueCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkFlags + +instance {-# OVERLAPPING #-} + HasVkQueueFamilyIndex VkDeviceQueueCreateInfo where + type VkQueueFamilyIndexMType VkDeviceQueueCreateInfo = Word32 + + {-# NOINLINE vkQueueFamilyIndex #-} + vkQueueFamilyIndex x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDeviceQueueCreateInfo, queueFamilyIndex}) + + {-# INLINE vkQueueFamilyIndexByteOffset #-} + vkQueueFamilyIndexByteOffset ~_ + = #{offset VkDeviceQueueCreateInfo, queueFamilyIndex} + + {-# INLINE readVkQueueFamilyIndex #-} + readVkQueueFamilyIndex p + = peekByteOff p #{offset VkDeviceQueueCreateInfo, queueFamilyIndex} + + {-# INLINE writeVkQueueFamilyIndex #-} + writeVkQueueFamilyIndex p + = pokeByteOff p #{offset VkDeviceQueueCreateInfo, queueFamilyIndex} + +instance {-# OVERLAPPING #-} + HasField "queueFamilyIndex" VkDeviceQueueCreateInfo where + type FieldType "queueFamilyIndex" VkDeviceQueueCreateInfo = Word32 + type FieldOptional "queueFamilyIndex" VkDeviceQueueCreateInfo = + 'False -- ' closing tick for hsc2hs + type FieldOffset "queueFamilyIndex" VkDeviceQueueCreateInfo = + #{offset VkDeviceQueueCreateInfo, queueFamilyIndex} + type FieldIsArray "queueFamilyIndex" VkDeviceQueueCreateInfo = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDeviceQueueCreateInfo, queueFamilyIndex} + +instance CanReadField "queueFamilyIndex" VkDeviceQueueCreateInfo + where + {-# INLINE getField #-} + getField = vkQueueFamilyIndex + + {-# INLINE readField #-} + readField = readVkQueueFamilyIndex + +instance CanWriteField "queueFamilyIndex" VkDeviceQueueCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkQueueFamilyIndex + +instance {-# OVERLAPPING #-} + HasVkQueueCount VkDeviceQueueCreateInfo where + type VkQueueCountMType VkDeviceQueueCreateInfo = Word32 + + {-# NOINLINE vkQueueCount #-} + vkQueueCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDeviceQueueCreateInfo, queueCount}) + + {-# INLINE vkQueueCountByteOffset #-} + vkQueueCountByteOffset ~_ + = #{offset VkDeviceQueueCreateInfo, queueCount} + + {-# INLINE readVkQueueCount #-} + readVkQueueCount p + = peekByteOff p #{offset VkDeviceQueueCreateInfo, queueCount} + + {-# INLINE writeVkQueueCount #-} + writeVkQueueCount p + = pokeByteOff p #{offset VkDeviceQueueCreateInfo, queueCount} + +instance {-# OVERLAPPING #-} + HasField "queueCount" VkDeviceQueueCreateInfo where + type FieldType "queueCount" VkDeviceQueueCreateInfo = Word32 + type FieldOptional "queueCount" VkDeviceQueueCreateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "queueCount" VkDeviceQueueCreateInfo = + #{offset VkDeviceQueueCreateInfo, queueCount} + type FieldIsArray "queueCount" VkDeviceQueueCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDeviceQueueCreateInfo, queueCount} + +instance CanReadField "queueCount" VkDeviceQueueCreateInfo where + {-# INLINE getField #-} + getField = vkQueueCount + + {-# INLINE readField #-} + readField = readVkQueueCount + +instance CanWriteField "queueCount" VkDeviceQueueCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkQueueCount + +instance {-# OVERLAPPING #-} + HasVkPQueuePriorities VkDeviceQueueCreateInfo where + type VkPQueuePrioritiesMType VkDeviceQueueCreateInfo = + Ptr #{type float} + + {-# NOINLINE vkPQueuePriorities #-} + vkPQueuePriorities x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDeviceQueueCreateInfo, pQueuePriorities}) + + {-# INLINE vkPQueuePrioritiesByteOffset #-} + vkPQueuePrioritiesByteOffset ~_ + = #{offset VkDeviceQueueCreateInfo, pQueuePriorities} + + {-# INLINE readVkPQueuePriorities #-} + readVkPQueuePriorities p + = peekByteOff p #{offset VkDeviceQueueCreateInfo, pQueuePriorities} + + {-# INLINE writeVkPQueuePriorities #-} + writeVkPQueuePriorities p + = pokeByteOff p #{offset VkDeviceQueueCreateInfo, pQueuePriorities} + +instance {-# OVERLAPPING #-} + HasField "pQueuePriorities" VkDeviceQueueCreateInfo where + type FieldType "pQueuePriorities" VkDeviceQueueCreateInfo = + Ptr #{type float} + type FieldOptional "pQueuePriorities" VkDeviceQueueCreateInfo = + 'False -- ' closing tick for hsc2hs + type FieldOffset "pQueuePriorities" VkDeviceQueueCreateInfo = + #{offset VkDeviceQueueCreateInfo, pQueuePriorities} + type FieldIsArray "pQueuePriorities" VkDeviceQueueCreateInfo = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDeviceQueueCreateInfo, pQueuePriorities} + +instance CanReadField "pQueuePriorities" VkDeviceQueueCreateInfo + where + {-# INLINE getField #-} + getField = vkPQueuePriorities + + {-# INLINE readField #-} + readField = readVkPQueuePriorities + +instance CanWriteField "pQueuePriorities" VkDeviceQueueCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkPQueuePriorities + +instance Show VkDeviceQueueCreateInfo where + showsPrec d x + = showString "VkDeviceQueueCreateInfo {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkFlags = " . + showsPrec d (vkFlags x) . + showString ", " . + showString "vkQueueFamilyIndex = " . + showsPrec d (vkQueueFamilyIndex x) . + showString ", " . + showString "vkQueueCount = " . + showsPrec d (vkQueueCount x) . + showString ", " . + showString "vkPQueuePriorities = " . + showsPrec d (vkPQueuePriorities x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkDeviceQueueGlobalPriorityCreateInfoEXT.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkDeviceQueueGlobalPriorityCreateInfoEXT.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkDeviceQueueGlobalPriorityCreateInfoEXT.hsc @@ -0,0 +1,266 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkDeviceQueueGlobalPriorityCreateInfoEXT + (VkDeviceQueueGlobalPriorityCreateInfoEXT(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkQueueGlobalPriorityEXT (VkQueueGlobalPriorityEXT) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Struct.VkDeviceQueueCreateInfo (VkDeviceQueueCreateInfo) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkDeviceQueueGlobalPriorityCreateInfoEXT { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkQueueGlobalPriorityEXT globalPriority; +-- > } VkDeviceQueueGlobalPriorityCreateInfoEXT; +-- +-- +data VkDeviceQueueGlobalPriorityCreateInfoEXT = VkDeviceQueueGlobalPriorityCreateInfoEXT## Addr## + ByteArray## + +instance Eq VkDeviceQueueGlobalPriorityCreateInfoEXT where + (VkDeviceQueueGlobalPriorityCreateInfoEXT## a _) == + x@(VkDeviceQueueGlobalPriorityCreateInfoEXT## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkDeviceQueueGlobalPriorityCreateInfoEXT where + (VkDeviceQueueGlobalPriorityCreateInfoEXT## a _) `compare` + x@(VkDeviceQueueGlobalPriorityCreateInfoEXT## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkDeviceQueueGlobalPriorityCreateInfoEXT where + sizeOf ~_ + = #{size VkDeviceQueueGlobalPriorityCreateInfoEXT} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkDeviceQueueGlobalPriorityCreateInfoEXT} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkDeviceQueueGlobalPriorityCreateInfoEXT + where + unsafeAddr (VkDeviceQueueGlobalPriorityCreateInfoEXT## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkDeviceQueueGlobalPriorityCreateInfoEXT## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkDeviceQueueGlobalPriorityCreateInfoEXT## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkDeviceQueueGlobalPriorityCreateInfoEXT + where + type StructFields VkDeviceQueueGlobalPriorityCreateInfoEXT = + '["sType", "pNext", "globalPriority"] -- ' closing tick for hsc2hs + type CUnionType VkDeviceQueueGlobalPriorityCreateInfoEXT = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkDeviceQueueGlobalPriorityCreateInfoEXT = 'False -- ' closing tick for hsc2hs + type StructExtends VkDeviceQueueGlobalPriorityCreateInfoEXT = + '[VkDeviceQueueCreateInfo] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkDeviceQueueGlobalPriorityCreateInfoEXT where + type VkSTypeMType VkDeviceQueueGlobalPriorityCreateInfoEXT = + VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDeviceQueueGlobalPriorityCreateInfoEXT, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkDeviceQueueGlobalPriorityCreateInfoEXT, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkDeviceQueueGlobalPriorityCreateInfoEXT, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkDeviceQueueGlobalPriorityCreateInfoEXT, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkDeviceQueueGlobalPriorityCreateInfoEXT where + type FieldType "sType" VkDeviceQueueGlobalPriorityCreateInfoEXT = + VkStructureType + type FieldOptional "sType" VkDeviceQueueGlobalPriorityCreateInfoEXT + = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkDeviceQueueGlobalPriorityCreateInfoEXT = + #{offset VkDeviceQueueGlobalPriorityCreateInfoEXT, sType} + type FieldIsArray "sType" VkDeviceQueueGlobalPriorityCreateInfoEXT + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDeviceQueueGlobalPriorityCreateInfoEXT, sType} + +instance CanReadField "sType" + VkDeviceQueueGlobalPriorityCreateInfoEXT + where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" + VkDeviceQueueGlobalPriorityCreateInfoEXT + where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkDeviceQueueGlobalPriorityCreateInfoEXT where + type VkPNextMType VkDeviceQueueGlobalPriorityCreateInfoEXT = + Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDeviceQueueGlobalPriorityCreateInfoEXT, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkDeviceQueueGlobalPriorityCreateInfoEXT, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkDeviceQueueGlobalPriorityCreateInfoEXT, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkDeviceQueueGlobalPriorityCreateInfoEXT, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkDeviceQueueGlobalPriorityCreateInfoEXT where + type FieldType "pNext" VkDeviceQueueGlobalPriorityCreateInfoEXT = + Ptr Void + type FieldOptional "pNext" VkDeviceQueueGlobalPriorityCreateInfoEXT + = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkDeviceQueueGlobalPriorityCreateInfoEXT = + #{offset VkDeviceQueueGlobalPriorityCreateInfoEXT, pNext} + type FieldIsArray "pNext" VkDeviceQueueGlobalPriorityCreateInfoEXT + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDeviceQueueGlobalPriorityCreateInfoEXT, pNext} + +instance CanReadField "pNext" + VkDeviceQueueGlobalPriorityCreateInfoEXT + where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" + VkDeviceQueueGlobalPriorityCreateInfoEXT + where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkGlobalPriority VkDeviceQueueGlobalPriorityCreateInfoEXT where + type VkGlobalPriorityMType VkDeviceQueueGlobalPriorityCreateInfoEXT + = VkQueueGlobalPriorityEXT + + {-# NOINLINE vkGlobalPriority #-} + vkGlobalPriority x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDeviceQueueGlobalPriorityCreateInfoEXT, globalPriority}) + + {-# INLINE vkGlobalPriorityByteOffset #-} + vkGlobalPriorityByteOffset ~_ + = #{offset VkDeviceQueueGlobalPriorityCreateInfoEXT, globalPriority} + + {-# INLINE readVkGlobalPriority #-} + readVkGlobalPriority p + = peekByteOff p #{offset VkDeviceQueueGlobalPriorityCreateInfoEXT, globalPriority} + + {-# INLINE writeVkGlobalPriority #-} + writeVkGlobalPriority p + = pokeByteOff p #{offset VkDeviceQueueGlobalPriorityCreateInfoEXT, globalPriority} + +instance {-# OVERLAPPING #-} + HasField "globalPriority" VkDeviceQueueGlobalPriorityCreateInfoEXT + where + type FieldType "globalPriority" + VkDeviceQueueGlobalPriorityCreateInfoEXT + = VkQueueGlobalPriorityEXT + type FieldOptional "globalPriority" + VkDeviceQueueGlobalPriorityCreateInfoEXT + = 'False -- ' closing tick for hsc2hs + type FieldOffset "globalPriority" + VkDeviceQueueGlobalPriorityCreateInfoEXT + = + #{offset VkDeviceQueueGlobalPriorityCreateInfoEXT, globalPriority} + type FieldIsArray "globalPriority" + VkDeviceQueueGlobalPriorityCreateInfoEXT + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDeviceQueueGlobalPriorityCreateInfoEXT, globalPriority} + +instance CanReadField "globalPriority" + VkDeviceQueueGlobalPriorityCreateInfoEXT + where + {-# INLINE getField #-} + getField = vkGlobalPriority + + {-# INLINE readField #-} + readField = readVkGlobalPriority + +instance CanWriteField "globalPriority" + VkDeviceQueueGlobalPriorityCreateInfoEXT + where + {-# INLINE writeField #-} + writeField = writeVkGlobalPriority + +instance Show VkDeviceQueueGlobalPriorityCreateInfoEXT where + showsPrec d x + = showString "VkDeviceQueueGlobalPriorityCreateInfoEXT {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkGlobalPriority = " . + showsPrec d (vkGlobalPriority x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkDispatchIndirectCommand.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkDispatchIndirectCommand.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkDispatchIndirectCommand.hsc @@ -0,0 +1,217 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkDispatchIndirectCommand + (VkDispatchIndirectCommand(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkDispatchIndirectCommand { +-- > uint32_t x; +-- > uint32_t y; +-- > uint32_t z; +-- > } VkDispatchIndirectCommand; +-- +-- +data VkDispatchIndirectCommand = VkDispatchIndirectCommand## Addr## + ByteArray## + +instance Eq VkDispatchIndirectCommand where + (VkDispatchIndirectCommand## a _) == + x@(VkDispatchIndirectCommand## b _) = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkDispatchIndirectCommand where + (VkDispatchIndirectCommand## a _) `compare` + x@(VkDispatchIndirectCommand## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkDispatchIndirectCommand where + sizeOf ~_ = #{size VkDispatchIndirectCommand} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkDispatchIndirectCommand} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkDispatchIndirectCommand where + unsafeAddr (VkDispatchIndirectCommand## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkDispatchIndirectCommand## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkDispatchIndirectCommand## (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkDispatchIndirectCommand where + type StructFields VkDispatchIndirectCommand = '["x", "y", "z"] -- ' closing tick for hsc2hs + type CUnionType VkDispatchIndirectCommand = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkDispatchIndirectCommand = 'False -- ' closing tick for hsc2hs + type StructExtends VkDispatchIndirectCommand = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkX VkDispatchIndirectCommand where + type VkXMType VkDispatchIndirectCommand = Word32 + + {-# NOINLINE vkX #-} + vkX x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDispatchIndirectCommand, x}) + + {-# INLINE vkXByteOffset #-} + vkXByteOffset ~_ + = #{offset VkDispatchIndirectCommand, x} + + {-# INLINE readVkX #-} + readVkX p + = peekByteOff p #{offset VkDispatchIndirectCommand, x} + + {-# INLINE writeVkX #-} + writeVkX p + = pokeByteOff p #{offset VkDispatchIndirectCommand, x} + +instance {-# OVERLAPPING #-} HasField "x" VkDispatchIndirectCommand + where + type FieldType "x" VkDispatchIndirectCommand = Word32 + type FieldOptional "x" VkDispatchIndirectCommand = 'False -- ' closing tick for hsc2hs + type FieldOffset "x" VkDispatchIndirectCommand = + #{offset VkDispatchIndirectCommand, x} + type FieldIsArray "x" VkDispatchIndirectCommand = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkDispatchIndirectCommand, x} + +instance CanReadField "x" VkDispatchIndirectCommand where + {-# INLINE getField #-} + getField = vkX + + {-# INLINE readField #-} + readField = readVkX + +instance CanWriteField "x" VkDispatchIndirectCommand where + {-# INLINE writeField #-} + writeField = writeVkX + +instance {-# OVERLAPPING #-} HasVkY VkDispatchIndirectCommand where + type VkYMType VkDispatchIndirectCommand = Word32 + + {-# NOINLINE vkY #-} + vkY x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDispatchIndirectCommand, y}) + + {-# INLINE vkYByteOffset #-} + vkYByteOffset ~_ + = #{offset VkDispatchIndirectCommand, y} + + {-# INLINE readVkY #-} + readVkY p + = peekByteOff p #{offset VkDispatchIndirectCommand, y} + + {-# INLINE writeVkY #-} + writeVkY p + = pokeByteOff p #{offset VkDispatchIndirectCommand, y} + +instance {-# OVERLAPPING #-} HasField "y" VkDispatchIndirectCommand + where + type FieldType "y" VkDispatchIndirectCommand = Word32 + type FieldOptional "y" VkDispatchIndirectCommand = 'False -- ' closing tick for hsc2hs + type FieldOffset "y" VkDispatchIndirectCommand = + #{offset VkDispatchIndirectCommand, y} + type FieldIsArray "y" VkDispatchIndirectCommand = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkDispatchIndirectCommand, y} + +instance CanReadField "y" VkDispatchIndirectCommand where + {-# INLINE getField #-} + getField = vkY + + {-# INLINE readField #-} + readField = readVkY + +instance CanWriteField "y" VkDispatchIndirectCommand where + {-# INLINE writeField #-} + writeField = writeVkY + +instance {-# OVERLAPPING #-} HasVkZ VkDispatchIndirectCommand where + type VkZMType VkDispatchIndirectCommand = Word32 + + {-# NOINLINE vkZ #-} + vkZ x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDispatchIndirectCommand, z}) + + {-# INLINE vkZByteOffset #-} + vkZByteOffset ~_ + = #{offset VkDispatchIndirectCommand, z} + + {-# INLINE readVkZ #-} + readVkZ p + = peekByteOff p #{offset VkDispatchIndirectCommand, z} + + {-# INLINE writeVkZ #-} + writeVkZ p + = pokeByteOff p #{offset VkDispatchIndirectCommand, z} + +instance {-# OVERLAPPING #-} HasField "z" VkDispatchIndirectCommand + where + type FieldType "z" VkDispatchIndirectCommand = Word32 + type FieldOptional "z" VkDispatchIndirectCommand = 'False -- ' closing tick for hsc2hs + type FieldOffset "z" VkDispatchIndirectCommand = + #{offset VkDispatchIndirectCommand, z} + type FieldIsArray "z" VkDispatchIndirectCommand = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkDispatchIndirectCommand, z} + +instance CanReadField "z" VkDispatchIndirectCommand where + {-# INLINE getField #-} + getField = vkZ + + {-# INLINE readField #-} + readField = readVkZ + +instance CanWriteField "z" VkDispatchIndirectCommand where + {-# INLINE writeField #-} + writeField = writeVkZ + +instance Show VkDispatchIndirectCommand where + showsPrec d x + = showString "VkDispatchIndirectCommand {" . + showString "vkX = " . + showsPrec d (vkX x) . + showString ", " . + showString "vkY = " . + showsPrec d (vkY x) . + showString ", " . + showString "vkZ = " . showsPrec d (vkZ x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkDisplayEventInfoEXT.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkDisplayEventInfoEXT.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkDisplayEventInfoEXT.hsc @@ -0,0 +1,224 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkDisplayEventInfoEXT + (VkDisplayEventInfoEXT(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkDisplayEventTypeEXT (VkDisplayEventTypeEXT) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkDisplayEventInfoEXT { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkDisplayEventTypeEXT displayEvent; +-- > } VkDisplayEventInfoEXT; +-- +-- +data VkDisplayEventInfoEXT = VkDisplayEventInfoEXT## Addr## + ByteArray## + +instance Eq VkDisplayEventInfoEXT where + (VkDisplayEventInfoEXT## a _) == x@(VkDisplayEventInfoEXT## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkDisplayEventInfoEXT where + (VkDisplayEventInfoEXT## a _) `compare` + x@(VkDisplayEventInfoEXT## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkDisplayEventInfoEXT where + sizeOf ~_ = #{size VkDisplayEventInfoEXT} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkDisplayEventInfoEXT} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkDisplayEventInfoEXT where + unsafeAddr (VkDisplayEventInfoEXT## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkDisplayEventInfoEXT## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkDisplayEventInfoEXT## (plusAddr## (byteArrayContents## b) off) b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkDisplayEventInfoEXT where + type StructFields VkDisplayEventInfoEXT = + '["sType", "pNext", "displayEvent"] -- ' closing tick for hsc2hs + type CUnionType VkDisplayEventInfoEXT = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkDisplayEventInfoEXT = 'False -- ' closing tick for hsc2hs + type StructExtends VkDisplayEventInfoEXT = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkSType VkDisplayEventInfoEXT where + type VkSTypeMType VkDisplayEventInfoEXT = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDisplayEventInfoEXT, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkDisplayEventInfoEXT, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkDisplayEventInfoEXT, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkDisplayEventInfoEXT, sType} + +instance {-# OVERLAPPING #-} HasField "sType" VkDisplayEventInfoEXT + where + type FieldType "sType" VkDisplayEventInfoEXT = VkStructureType + type FieldOptional "sType" VkDisplayEventInfoEXT = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkDisplayEventInfoEXT = + #{offset VkDisplayEventInfoEXT, sType} + type FieldIsArray "sType" VkDisplayEventInfoEXT = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkDisplayEventInfoEXT, sType} + +instance CanReadField "sType" VkDisplayEventInfoEXT where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkDisplayEventInfoEXT where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} HasVkPNext VkDisplayEventInfoEXT where + type VkPNextMType VkDisplayEventInfoEXT = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDisplayEventInfoEXT, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkDisplayEventInfoEXT, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkDisplayEventInfoEXT, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkDisplayEventInfoEXT, pNext} + +instance {-# OVERLAPPING #-} HasField "pNext" VkDisplayEventInfoEXT + where + type FieldType "pNext" VkDisplayEventInfoEXT = Ptr Void + type FieldOptional "pNext" VkDisplayEventInfoEXT = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkDisplayEventInfoEXT = + #{offset VkDisplayEventInfoEXT, pNext} + type FieldIsArray "pNext" VkDisplayEventInfoEXT = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkDisplayEventInfoEXT, pNext} + +instance CanReadField "pNext" VkDisplayEventInfoEXT where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkDisplayEventInfoEXT where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkDisplayEvent VkDisplayEventInfoEXT where + type VkDisplayEventMType VkDisplayEventInfoEXT = + VkDisplayEventTypeEXT + + {-# NOINLINE vkDisplayEvent #-} + vkDisplayEvent x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDisplayEventInfoEXT, displayEvent}) + + {-# INLINE vkDisplayEventByteOffset #-} + vkDisplayEventByteOffset ~_ + = #{offset VkDisplayEventInfoEXT, displayEvent} + + {-# INLINE readVkDisplayEvent #-} + readVkDisplayEvent p + = peekByteOff p #{offset VkDisplayEventInfoEXT, displayEvent} + + {-# INLINE writeVkDisplayEvent #-} + writeVkDisplayEvent p + = pokeByteOff p #{offset VkDisplayEventInfoEXT, displayEvent} + +instance {-# OVERLAPPING #-} + HasField "displayEvent" VkDisplayEventInfoEXT where + type FieldType "displayEvent" VkDisplayEventInfoEXT = + VkDisplayEventTypeEXT + type FieldOptional "displayEvent" VkDisplayEventInfoEXT = 'False -- ' closing tick for hsc2hs + type FieldOffset "displayEvent" VkDisplayEventInfoEXT = + #{offset VkDisplayEventInfoEXT, displayEvent} + type FieldIsArray "displayEvent" VkDisplayEventInfoEXT = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDisplayEventInfoEXT, displayEvent} + +instance CanReadField "displayEvent" VkDisplayEventInfoEXT where + {-# INLINE getField #-} + getField = vkDisplayEvent + + {-# INLINE readField #-} + readField = readVkDisplayEvent + +instance CanWriteField "displayEvent" VkDisplayEventInfoEXT where + {-# INLINE writeField #-} + writeField = writeVkDisplayEvent + +instance Show VkDisplayEventInfoEXT where + showsPrec d x + = showString "VkDisplayEventInfoEXT {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkDisplayEvent = " . + showsPrec d (vkDisplayEvent x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkDisplayModeCreateInfoKHR.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkDisplayModeCreateInfoKHR.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkDisplayModeCreateInfoKHR.hsc @@ -0,0 +1,286 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkDisplayModeCreateInfoKHR + (VkDisplayModeCreateInfoKHR(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Bitmasks (VkDisplayModeCreateFlagsKHR) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Struct.VkDisplayModeParametersKHR (VkDisplayModeParametersKHR) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkDisplayModeCreateInfoKHR { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkDisplayModeCreateFlagsKHR flags; +-- > VkDisplayModeParametersKHR parameters; +-- > } VkDisplayModeCreateInfoKHR; +-- +-- +data VkDisplayModeCreateInfoKHR = VkDisplayModeCreateInfoKHR## Addr## + ByteArray## + +instance Eq VkDisplayModeCreateInfoKHR where + (VkDisplayModeCreateInfoKHR## a _) == + x@(VkDisplayModeCreateInfoKHR## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkDisplayModeCreateInfoKHR where + (VkDisplayModeCreateInfoKHR## a _) `compare` + x@(VkDisplayModeCreateInfoKHR## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkDisplayModeCreateInfoKHR where + sizeOf ~_ = #{size VkDisplayModeCreateInfoKHR} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkDisplayModeCreateInfoKHR} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkDisplayModeCreateInfoKHR where + unsafeAddr (VkDisplayModeCreateInfoKHR## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkDisplayModeCreateInfoKHR## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkDisplayModeCreateInfoKHR## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkDisplayModeCreateInfoKHR where + type StructFields VkDisplayModeCreateInfoKHR = + '["sType", "pNext", "flags", "parameters"] -- ' closing tick for hsc2hs + type CUnionType VkDisplayModeCreateInfoKHR = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkDisplayModeCreateInfoKHR = 'False -- ' closing tick for hsc2hs + type StructExtends VkDisplayModeCreateInfoKHR = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkSType VkDisplayModeCreateInfoKHR + where + type VkSTypeMType VkDisplayModeCreateInfoKHR = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDisplayModeCreateInfoKHR, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkDisplayModeCreateInfoKHR, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkDisplayModeCreateInfoKHR, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkDisplayModeCreateInfoKHR, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkDisplayModeCreateInfoKHR where + type FieldType "sType" VkDisplayModeCreateInfoKHR = VkStructureType + type FieldOptional "sType" VkDisplayModeCreateInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkDisplayModeCreateInfoKHR = + #{offset VkDisplayModeCreateInfoKHR, sType} + type FieldIsArray "sType" VkDisplayModeCreateInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDisplayModeCreateInfoKHR, sType} + +instance CanReadField "sType" VkDisplayModeCreateInfoKHR where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkDisplayModeCreateInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} HasVkPNext VkDisplayModeCreateInfoKHR + where + type VkPNextMType VkDisplayModeCreateInfoKHR = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDisplayModeCreateInfoKHR, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkDisplayModeCreateInfoKHR, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkDisplayModeCreateInfoKHR, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkDisplayModeCreateInfoKHR, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkDisplayModeCreateInfoKHR where + type FieldType "pNext" VkDisplayModeCreateInfoKHR = Ptr Void + type FieldOptional "pNext" VkDisplayModeCreateInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkDisplayModeCreateInfoKHR = + #{offset VkDisplayModeCreateInfoKHR, pNext} + type FieldIsArray "pNext" VkDisplayModeCreateInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDisplayModeCreateInfoKHR, pNext} + +instance CanReadField "pNext" VkDisplayModeCreateInfoKHR where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkDisplayModeCreateInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} HasVkFlags VkDisplayModeCreateInfoKHR + where + type VkFlagsMType VkDisplayModeCreateInfoKHR = + VkDisplayModeCreateFlagsKHR + + {-# NOINLINE vkFlags #-} + vkFlags x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDisplayModeCreateInfoKHR, flags}) + + {-# INLINE vkFlagsByteOffset #-} + vkFlagsByteOffset ~_ + = #{offset VkDisplayModeCreateInfoKHR, flags} + + {-# INLINE readVkFlags #-} + readVkFlags p + = peekByteOff p #{offset VkDisplayModeCreateInfoKHR, flags} + + {-# INLINE writeVkFlags #-} + writeVkFlags p + = pokeByteOff p #{offset VkDisplayModeCreateInfoKHR, flags} + +instance {-# OVERLAPPING #-} + HasField "flags" VkDisplayModeCreateInfoKHR where + type FieldType "flags" VkDisplayModeCreateInfoKHR = + VkDisplayModeCreateFlagsKHR + type FieldOptional "flags" VkDisplayModeCreateInfoKHR = 'True -- ' closing tick for hsc2hs + type FieldOffset "flags" VkDisplayModeCreateInfoKHR = + #{offset VkDisplayModeCreateInfoKHR, flags} + type FieldIsArray "flags" VkDisplayModeCreateInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDisplayModeCreateInfoKHR, flags} + +instance CanReadField "flags" VkDisplayModeCreateInfoKHR where + {-# INLINE getField #-} + getField = vkFlags + + {-# INLINE readField #-} + readField = readVkFlags + +instance CanWriteField "flags" VkDisplayModeCreateInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkFlags + +instance {-# OVERLAPPING #-} + HasVkParameters VkDisplayModeCreateInfoKHR where + type VkParametersMType VkDisplayModeCreateInfoKHR = + VkDisplayModeParametersKHR + + {-# NOINLINE vkParameters #-} + vkParameters x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDisplayModeCreateInfoKHR, parameters}) + + {-# INLINE vkParametersByteOffset #-} + vkParametersByteOffset ~_ + = #{offset VkDisplayModeCreateInfoKHR, parameters} + + {-# INLINE readVkParameters #-} + readVkParameters p + = peekByteOff p #{offset VkDisplayModeCreateInfoKHR, parameters} + + {-# INLINE writeVkParameters #-} + writeVkParameters p + = pokeByteOff p #{offset VkDisplayModeCreateInfoKHR, parameters} + +instance {-# OVERLAPPING #-} + HasField "parameters" VkDisplayModeCreateInfoKHR where + type FieldType "parameters" VkDisplayModeCreateInfoKHR = + VkDisplayModeParametersKHR + type FieldOptional "parameters" VkDisplayModeCreateInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "parameters" VkDisplayModeCreateInfoKHR = + #{offset VkDisplayModeCreateInfoKHR, parameters} + type FieldIsArray "parameters" VkDisplayModeCreateInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDisplayModeCreateInfoKHR, parameters} + +instance CanReadField "parameters" VkDisplayModeCreateInfoKHR where + {-# INLINE getField #-} + getField = vkParameters + + {-# INLINE readField #-} + readField = readVkParameters + +instance CanWriteField "parameters" VkDisplayModeCreateInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkParameters + +instance Show VkDisplayModeCreateInfoKHR where + showsPrec d x + = showString "VkDisplayModeCreateInfoKHR {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkFlags = " . + showsPrec d (vkFlags x) . + showString ", " . + showString "vkParameters = " . + showsPrec d (vkParameters x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkDisplayModeParametersKHR.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkDisplayModeParametersKHR.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkDisplayModeParametersKHR.hsc @@ -0,0 +1,185 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkDisplayModeParametersKHR + (VkDisplayModeParametersKHR(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Struct.VkExtent2D (VkExtent2D) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkDisplayModeParametersKHR { +-- > VkExtent2D visibleRegion; +-- > uint32_t refreshRate; +-- > } VkDisplayModeParametersKHR; +-- +-- +data VkDisplayModeParametersKHR = VkDisplayModeParametersKHR## Addr## + ByteArray## + +instance Eq VkDisplayModeParametersKHR where + (VkDisplayModeParametersKHR## a _) == + x@(VkDisplayModeParametersKHR## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkDisplayModeParametersKHR where + (VkDisplayModeParametersKHR## a _) `compare` + x@(VkDisplayModeParametersKHR## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkDisplayModeParametersKHR where + sizeOf ~_ = #{size VkDisplayModeParametersKHR} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkDisplayModeParametersKHR} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkDisplayModeParametersKHR where + unsafeAddr (VkDisplayModeParametersKHR## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkDisplayModeParametersKHR## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkDisplayModeParametersKHR## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkDisplayModeParametersKHR where + type StructFields VkDisplayModeParametersKHR = + '["visibleRegion", "refreshRate"] -- ' closing tick for hsc2hs + type CUnionType VkDisplayModeParametersKHR = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkDisplayModeParametersKHR = 'False -- ' closing tick for hsc2hs + type StructExtends VkDisplayModeParametersKHR = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkVisibleRegion VkDisplayModeParametersKHR where + type VkVisibleRegionMType VkDisplayModeParametersKHR = VkExtent2D + + {-# NOINLINE vkVisibleRegion #-} + vkVisibleRegion x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDisplayModeParametersKHR, visibleRegion}) + + {-# INLINE vkVisibleRegionByteOffset #-} + vkVisibleRegionByteOffset ~_ + = #{offset VkDisplayModeParametersKHR, visibleRegion} + + {-# INLINE readVkVisibleRegion #-} + readVkVisibleRegion p + = peekByteOff p #{offset VkDisplayModeParametersKHR, visibleRegion} + + {-# INLINE writeVkVisibleRegion #-} + writeVkVisibleRegion p + = pokeByteOff p #{offset VkDisplayModeParametersKHR, visibleRegion} + +instance {-# OVERLAPPING #-} + HasField "visibleRegion" VkDisplayModeParametersKHR where + type FieldType "visibleRegion" VkDisplayModeParametersKHR = + VkExtent2D + type FieldOptional "visibleRegion" VkDisplayModeParametersKHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "visibleRegion" VkDisplayModeParametersKHR = + #{offset VkDisplayModeParametersKHR, visibleRegion} + type FieldIsArray "visibleRegion" VkDisplayModeParametersKHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDisplayModeParametersKHR, visibleRegion} + +instance CanReadField "visibleRegion" VkDisplayModeParametersKHR + where + {-# INLINE getField #-} + getField = vkVisibleRegion + + {-# INLINE readField #-} + readField = readVkVisibleRegion + +instance CanWriteField "visibleRegion" VkDisplayModeParametersKHR + where + {-# INLINE writeField #-} + writeField = writeVkVisibleRegion + +instance {-# OVERLAPPING #-} + HasVkRefreshRate VkDisplayModeParametersKHR where + type VkRefreshRateMType VkDisplayModeParametersKHR = Word32 + + {-# NOINLINE vkRefreshRate #-} + vkRefreshRate x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDisplayModeParametersKHR, refreshRate}) + + {-# INLINE vkRefreshRateByteOffset #-} + vkRefreshRateByteOffset ~_ + = #{offset VkDisplayModeParametersKHR, refreshRate} + + {-# INLINE readVkRefreshRate #-} + readVkRefreshRate p + = peekByteOff p #{offset VkDisplayModeParametersKHR, refreshRate} + + {-# INLINE writeVkRefreshRate #-} + writeVkRefreshRate p + = pokeByteOff p #{offset VkDisplayModeParametersKHR, refreshRate} + +instance {-# OVERLAPPING #-} + HasField "refreshRate" VkDisplayModeParametersKHR where + type FieldType "refreshRate" VkDisplayModeParametersKHR = Word32 + type FieldOptional "refreshRate" VkDisplayModeParametersKHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "refreshRate" VkDisplayModeParametersKHR = + #{offset VkDisplayModeParametersKHR, refreshRate} + type FieldIsArray "refreshRate" VkDisplayModeParametersKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDisplayModeParametersKHR, refreshRate} + +instance CanReadField "refreshRate" VkDisplayModeParametersKHR + where + {-# INLINE getField #-} + getField = vkRefreshRate + + {-# INLINE readField #-} + readField = readVkRefreshRate + +instance CanWriteField "refreshRate" VkDisplayModeParametersKHR + where + {-# INLINE writeField #-} + writeField = writeVkRefreshRate + +instance Show VkDisplayModeParametersKHR where + showsPrec d x + = showString "VkDisplayModeParametersKHR {" . + showString "vkVisibleRegion = " . + showsPrec d (vkVisibleRegion x) . + showString ", " . + showString "vkRefreshRate = " . + showsPrec d (vkRefreshRate x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkDisplayModePropertiesKHR.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkDisplayModePropertiesKHR.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkDisplayModePropertiesKHR.hsc @@ -0,0 +1,176 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkDisplayModePropertiesKHR + (VkDisplayModePropertiesKHR(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Handles (VkDisplayModeKHR) +import Graphics.Vulkan.Types.Struct.VkDisplayModeParametersKHR (VkDisplayModeParametersKHR) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkDisplayModePropertiesKHR { +-- > VkDisplayModeKHR displayMode; +-- > VkDisplayModeParametersKHR parameters; +-- > } VkDisplayModePropertiesKHR; +-- +-- +data VkDisplayModePropertiesKHR = VkDisplayModePropertiesKHR## Addr## + ByteArray## + +instance Eq VkDisplayModePropertiesKHR where + (VkDisplayModePropertiesKHR## a _) == + x@(VkDisplayModePropertiesKHR## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkDisplayModePropertiesKHR where + (VkDisplayModePropertiesKHR## a _) `compare` + x@(VkDisplayModePropertiesKHR## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkDisplayModePropertiesKHR where + sizeOf ~_ = #{size VkDisplayModePropertiesKHR} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkDisplayModePropertiesKHR} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkDisplayModePropertiesKHR where + unsafeAddr (VkDisplayModePropertiesKHR## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkDisplayModePropertiesKHR## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkDisplayModePropertiesKHR## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkDisplayModePropertiesKHR where + type StructFields VkDisplayModePropertiesKHR = + '["displayMode", "parameters"] -- ' closing tick for hsc2hs + type CUnionType VkDisplayModePropertiesKHR = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkDisplayModePropertiesKHR = 'True -- ' closing tick for hsc2hs + type StructExtends VkDisplayModePropertiesKHR = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkDisplayMode VkDisplayModePropertiesKHR where + type VkDisplayModeMType VkDisplayModePropertiesKHR = + VkDisplayModeKHR + + {-# NOINLINE vkDisplayMode #-} + vkDisplayMode x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDisplayModePropertiesKHR, displayMode}) + + {-# INLINE vkDisplayModeByteOffset #-} + vkDisplayModeByteOffset ~_ + = #{offset VkDisplayModePropertiesKHR, displayMode} + + {-# INLINE readVkDisplayMode #-} + readVkDisplayMode p + = peekByteOff p #{offset VkDisplayModePropertiesKHR, displayMode} + + {-# INLINE writeVkDisplayMode #-} + writeVkDisplayMode p + = pokeByteOff p #{offset VkDisplayModePropertiesKHR, displayMode} + +instance {-# OVERLAPPING #-} + HasField "displayMode" VkDisplayModePropertiesKHR where + type FieldType "displayMode" VkDisplayModePropertiesKHR = + VkDisplayModeKHR + type FieldOptional "displayMode" VkDisplayModePropertiesKHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "displayMode" VkDisplayModePropertiesKHR = + #{offset VkDisplayModePropertiesKHR, displayMode} + type FieldIsArray "displayMode" VkDisplayModePropertiesKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDisplayModePropertiesKHR, displayMode} + +instance CanReadField "displayMode" VkDisplayModePropertiesKHR + where + {-# INLINE getField #-} + getField = vkDisplayMode + + {-# INLINE readField #-} + readField = readVkDisplayMode + +instance {-# OVERLAPPING #-} + HasVkParameters VkDisplayModePropertiesKHR where + type VkParametersMType VkDisplayModePropertiesKHR = + VkDisplayModeParametersKHR + + {-# NOINLINE vkParameters #-} + vkParameters x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDisplayModePropertiesKHR, parameters}) + + {-# INLINE vkParametersByteOffset #-} + vkParametersByteOffset ~_ + = #{offset VkDisplayModePropertiesKHR, parameters} + + {-# INLINE readVkParameters #-} + readVkParameters p + = peekByteOff p #{offset VkDisplayModePropertiesKHR, parameters} + + {-# INLINE writeVkParameters #-} + writeVkParameters p + = pokeByteOff p #{offset VkDisplayModePropertiesKHR, parameters} + +instance {-# OVERLAPPING #-} + HasField "parameters" VkDisplayModePropertiesKHR where + type FieldType "parameters" VkDisplayModePropertiesKHR = + VkDisplayModeParametersKHR + type FieldOptional "parameters" VkDisplayModePropertiesKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "parameters" VkDisplayModePropertiesKHR = + #{offset VkDisplayModePropertiesKHR, parameters} + type FieldIsArray "parameters" VkDisplayModePropertiesKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDisplayModePropertiesKHR, parameters} + +instance CanReadField "parameters" VkDisplayModePropertiesKHR where + {-# INLINE getField #-} + getField = vkParameters + + {-# INLINE readField #-} + readField = readVkParameters + +instance Show VkDisplayModePropertiesKHR where + showsPrec d x + = showString "VkDisplayModePropertiesKHR {" . + showString "vkDisplayMode = " . + showsPrec d (vkDisplayMode x) . + showString ", " . + showString "vkParameters = " . + showsPrec d (vkParameters x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkDisplayPlaneCapabilitiesKHR.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkDisplayPlaneCapabilitiesKHR.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkDisplayPlaneCapabilitiesKHR.hsc @@ -0,0 +1,550 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkDisplayPlaneCapabilitiesKHR + (VkDisplayPlaneCapabilitiesKHR(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkDisplayPlaneAlphaFlagsKHR (VkDisplayPlaneAlphaFlagsKHR) +import Graphics.Vulkan.Types.Struct.VkExtent2D (VkExtent2D) +import Graphics.Vulkan.Types.Struct.VkOffset2D (VkOffset2D) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkDisplayPlaneCapabilitiesKHR { +-- > VkDisplayPlaneAlphaFlagsKHR supportedAlpha; +-- > VkOffset2D minSrcPosition; +-- > VkOffset2D maxSrcPosition; +-- > VkExtent2D minSrcExtent; +-- > VkExtent2D maxSrcExtent; +-- > VkOffset2D minDstPosition; +-- > VkOffset2D maxDstPosition; +-- > VkExtent2D minDstExtent; +-- > VkExtent2D maxDstExtent; +-- > } VkDisplayPlaneCapabilitiesKHR; +-- +-- +data VkDisplayPlaneCapabilitiesKHR = VkDisplayPlaneCapabilitiesKHR## Addr## + ByteArray## + +instance Eq VkDisplayPlaneCapabilitiesKHR where + (VkDisplayPlaneCapabilitiesKHR## a _) == + x@(VkDisplayPlaneCapabilitiesKHR## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkDisplayPlaneCapabilitiesKHR where + (VkDisplayPlaneCapabilitiesKHR## a _) `compare` + x@(VkDisplayPlaneCapabilitiesKHR## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkDisplayPlaneCapabilitiesKHR where + sizeOf ~_ = #{size VkDisplayPlaneCapabilitiesKHR} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkDisplayPlaneCapabilitiesKHR} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkDisplayPlaneCapabilitiesKHR where + unsafeAddr (VkDisplayPlaneCapabilitiesKHR## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkDisplayPlaneCapabilitiesKHR## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkDisplayPlaneCapabilitiesKHR## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkDisplayPlaneCapabilitiesKHR where + type StructFields VkDisplayPlaneCapabilitiesKHR = + '["supportedAlpha", "minSrcPosition", "maxSrcPosition", -- ' closing tick for hsc2hs + "minSrcExtent", "maxSrcExtent", "minDstPosition", "maxDstPosition", + "minDstExtent", "maxDstExtent"] + type CUnionType VkDisplayPlaneCapabilitiesKHR = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkDisplayPlaneCapabilitiesKHR = 'True -- ' closing tick for hsc2hs + type StructExtends VkDisplayPlaneCapabilitiesKHR = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSupportedAlpha VkDisplayPlaneCapabilitiesKHR where + type VkSupportedAlphaMType VkDisplayPlaneCapabilitiesKHR = + VkDisplayPlaneAlphaFlagsKHR + + {-# NOINLINE vkSupportedAlpha #-} + vkSupportedAlpha x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDisplayPlaneCapabilitiesKHR, supportedAlpha}) + + {-# INLINE vkSupportedAlphaByteOffset #-} + vkSupportedAlphaByteOffset ~_ + = #{offset VkDisplayPlaneCapabilitiesKHR, supportedAlpha} + + {-# INLINE readVkSupportedAlpha #-} + readVkSupportedAlpha p + = peekByteOff p #{offset VkDisplayPlaneCapabilitiesKHR, supportedAlpha} + + {-# INLINE writeVkSupportedAlpha #-} + writeVkSupportedAlpha p + = pokeByteOff p #{offset VkDisplayPlaneCapabilitiesKHR, supportedAlpha} + +instance {-# OVERLAPPING #-} + HasField "supportedAlpha" VkDisplayPlaneCapabilitiesKHR where + type FieldType "supportedAlpha" VkDisplayPlaneCapabilitiesKHR = + VkDisplayPlaneAlphaFlagsKHR + type FieldOptional "supportedAlpha" VkDisplayPlaneCapabilitiesKHR = + 'True -- ' closing tick for hsc2hs + type FieldOffset "supportedAlpha" VkDisplayPlaneCapabilitiesKHR = + #{offset VkDisplayPlaneCapabilitiesKHR, supportedAlpha} + type FieldIsArray "supportedAlpha" VkDisplayPlaneCapabilitiesKHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDisplayPlaneCapabilitiesKHR, supportedAlpha} + +instance CanReadField "supportedAlpha" + VkDisplayPlaneCapabilitiesKHR + where + {-# INLINE getField #-} + getField = vkSupportedAlpha + + {-# INLINE readField #-} + readField = readVkSupportedAlpha + +instance {-# OVERLAPPING #-} + HasVkMinSrcPosition VkDisplayPlaneCapabilitiesKHR where + type VkMinSrcPositionMType VkDisplayPlaneCapabilitiesKHR = + VkOffset2D + + {-# NOINLINE vkMinSrcPosition #-} + vkMinSrcPosition x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDisplayPlaneCapabilitiesKHR, minSrcPosition}) + + {-# INLINE vkMinSrcPositionByteOffset #-} + vkMinSrcPositionByteOffset ~_ + = #{offset VkDisplayPlaneCapabilitiesKHR, minSrcPosition} + + {-# INLINE readVkMinSrcPosition #-} + readVkMinSrcPosition p + = peekByteOff p #{offset VkDisplayPlaneCapabilitiesKHR, minSrcPosition} + + {-# INLINE writeVkMinSrcPosition #-} + writeVkMinSrcPosition p + = pokeByteOff p #{offset VkDisplayPlaneCapabilitiesKHR, minSrcPosition} + +instance {-# OVERLAPPING #-} + HasField "minSrcPosition" VkDisplayPlaneCapabilitiesKHR where + type FieldType "minSrcPosition" VkDisplayPlaneCapabilitiesKHR = + VkOffset2D + type FieldOptional "minSrcPosition" VkDisplayPlaneCapabilitiesKHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "minSrcPosition" VkDisplayPlaneCapabilitiesKHR = + #{offset VkDisplayPlaneCapabilitiesKHR, minSrcPosition} + type FieldIsArray "minSrcPosition" VkDisplayPlaneCapabilitiesKHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDisplayPlaneCapabilitiesKHR, minSrcPosition} + +instance CanReadField "minSrcPosition" + VkDisplayPlaneCapabilitiesKHR + where + {-# INLINE getField #-} + getField = vkMinSrcPosition + + {-# INLINE readField #-} + readField = readVkMinSrcPosition + +instance {-# OVERLAPPING #-} + HasVkMaxSrcPosition VkDisplayPlaneCapabilitiesKHR where + type VkMaxSrcPositionMType VkDisplayPlaneCapabilitiesKHR = + VkOffset2D + + {-# NOINLINE vkMaxSrcPosition #-} + vkMaxSrcPosition x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDisplayPlaneCapabilitiesKHR, maxSrcPosition}) + + {-# INLINE vkMaxSrcPositionByteOffset #-} + vkMaxSrcPositionByteOffset ~_ + = #{offset VkDisplayPlaneCapabilitiesKHR, maxSrcPosition} + + {-# INLINE readVkMaxSrcPosition #-} + readVkMaxSrcPosition p + = peekByteOff p #{offset VkDisplayPlaneCapabilitiesKHR, maxSrcPosition} + + {-# INLINE writeVkMaxSrcPosition #-} + writeVkMaxSrcPosition p + = pokeByteOff p #{offset VkDisplayPlaneCapabilitiesKHR, maxSrcPosition} + +instance {-# OVERLAPPING #-} + HasField "maxSrcPosition" VkDisplayPlaneCapabilitiesKHR where + type FieldType "maxSrcPosition" VkDisplayPlaneCapabilitiesKHR = + VkOffset2D + type FieldOptional "maxSrcPosition" VkDisplayPlaneCapabilitiesKHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "maxSrcPosition" VkDisplayPlaneCapabilitiesKHR = + #{offset VkDisplayPlaneCapabilitiesKHR, maxSrcPosition} + type FieldIsArray "maxSrcPosition" VkDisplayPlaneCapabilitiesKHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDisplayPlaneCapabilitiesKHR, maxSrcPosition} + +instance CanReadField "maxSrcPosition" + VkDisplayPlaneCapabilitiesKHR + where + {-# INLINE getField #-} + getField = vkMaxSrcPosition + + {-# INLINE readField #-} + readField = readVkMaxSrcPosition + +instance {-# OVERLAPPING #-} + HasVkMinSrcExtent VkDisplayPlaneCapabilitiesKHR where + type VkMinSrcExtentMType VkDisplayPlaneCapabilitiesKHR = VkExtent2D + + {-# NOINLINE vkMinSrcExtent #-} + vkMinSrcExtent x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDisplayPlaneCapabilitiesKHR, minSrcExtent}) + + {-# INLINE vkMinSrcExtentByteOffset #-} + vkMinSrcExtentByteOffset ~_ + = #{offset VkDisplayPlaneCapabilitiesKHR, minSrcExtent} + + {-# INLINE readVkMinSrcExtent #-} + readVkMinSrcExtent p + = peekByteOff p #{offset VkDisplayPlaneCapabilitiesKHR, minSrcExtent} + + {-# INLINE writeVkMinSrcExtent #-} + writeVkMinSrcExtent p + = pokeByteOff p #{offset VkDisplayPlaneCapabilitiesKHR, minSrcExtent} + +instance {-# OVERLAPPING #-} + HasField "minSrcExtent" VkDisplayPlaneCapabilitiesKHR where + type FieldType "minSrcExtent" VkDisplayPlaneCapabilitiesKHR = + VkExtent2D + type FieldOptional "minSrcExtent" VkDisplayPlaneCapabilitiesKHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "minSrcExtent" VkDisplayPlaneCapabilitiesKHR = + #{offset VkDisplayPlaneCapabilitiesKHR, minSrcExtent} + type FieldIsArray "minSrcExtent" VkDisplayPlaneCapabilitiesKHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDisplayPlaneCapabilitiesKHR, minSrcExtent} + +instance CanReadField "minSrcExtent" VkDisplayPlaneCapabilitiesKHR + where + {-# INLINE getField #-} + getField = vkMinSrcExtent + + {-# INLINE readField #-} + readField = readVkMinSrcExtent + +instance {-# OVERLAPPING #-} + HasVkMaxSrcExtent VkDisplayPlaneCapabilitiesKHR where + type VkMaxSrcExtentMType VkDisplayPlaneCapabilitiesKHR = VkExtent2D + + {-# NOINLINE vkMaxSrcExtent #-} + vkMaxSrcExtent x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDisplayPlaneCapabilitiesKHR, maxSrcExtent}) + + {-# INLINE vkMaxSrcExtentByteOffset #-} + vkMaxSrcExtentByteOffset ~_ + = #{offset VkDisplayPlaneCapabilitiesKHR, maxSrcExtent} + + {-# INLINE readVkMaxSrcExtent #-} + readVkMaxSrcExtent p + = peekByteOff p #{offset VkDisplayPlaneCapabilitiesKHR, maxSrcExtent} + + {-# INLINE writeVkMaxSrcExtent #-} + writeVkMaxSrcExtent p + = pokeByteOff p #{offset VkDisplayPlaneCapabilitiesKHR, maxSrcExtent} + +instance {-# OVERLAPPING #-} + HasField "maxSrcExtent" VkDisplayPlaneCapabilitiesKHR where + type FieldType "maxSrcExtent" VkDisplayPlaneCapabilitiesKHR = + VkExtent2D + type FieldOptional "maxSrcExtent" VkDisplayPlaneCapabilitiesKHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "maxSrcExtent" VkDisplayPlaneCapabilitiesKHR = + #{offset VkDisplayPlaneCapabilitiesKHR, maxSrcExtent} + type FieldIsArray "maxSrcExtent" VkDisplayPlaneCapabilitiesKHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDisplayPlaneCapabilitiesKHR, maxSrcExtent} + +instance CanReadField "maxSrcExtent" VkDisplayPlaneCapabilitiesKHR + where + {-# INLINE getField #-} + getField = vkMaxSrcExtent + + {-# INLINE readField #-} + readField = readVkMaxSrcExtent + +instance {-# OVERLAPPING #-} + HasVkMinDstPosition VkDisplayPlaneCapabilitiesKHR where + type VkMinDstPositionMType VkDisplayPlaneCapabilitiesKHR = + VkOffset2D + + {-# NOINLINE vkMinDstPosition #-} + vkMinDstPosition x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDisplayPlaneCapabilitiesKHR, minDstPosition}) + + {-# INLINE vkMinDstPositionByteOffset #-} + vkMinDstPositionByteOffset ~_ + = #{offset VkDisplayPlaneCapabilitiesKHR, minDstPosition} + + {-# INLINE readVkMinDstPosition #-} + readVkMinDstPosition p + = peekByteOff p #{offset VkDisplayPlaneCapabilitiesKHR, minDstPosition} + + {-# INLINE writeVkMinDstPosition #-} + writeVkMinDstPosition p + = pokeByteOff p #{offset VkDisplayPlaneCapabilitiesKHR, minDstPosition} + +instance {-# OVERLAPPING #-} + HasField "minDstPosition" VkDisplayPlaneCapabilitiesKHR where + type FieldType "minDstPosition" VkDisplayPlaneCapabilitiesKHR = + VkOffset2D + type FieldOptional "minDstPosition" VkDisplayPlaneCapabilitiesKHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "minDstPosition" VkDisplayPlaneCapabilitiesKHR = + #{offset VkDisplayPlaneCapabilitiesKHR, minDstPosition} + type FieldIsArray "minDstPosition" VkDisplayPlaneCapabilitiesKHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDisplayPlaneCapabilitiesKHR, minDstPosition} + +instance CanReadField "minDstPosition" + VkDisplayPlaneCapabilitiesKHR + where + {-# INLINE getField #-} + getField = vkMinDstPosition + + {-# INLINE readField #-} + readField = readVkMinDstPosition + +instance {-# OVERLAPPING #-} + HasVkMaxDstPosition VkDisplayPlaneCapabilitiesKHR where + type VkMaxDstPositionMType VkDisplayPlaneCapabilitiesKHR = + VkOffset2D + + {-# NOINLINE vkMaxDstPosition #-} + vkMaxDstPosition x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDisplayPlaneCapabilitiesKHR, maxDstPosition}) + + {-# INLINE vkMaxDstPositionByteOffset #-} + vkMaxDstPositionByteOffset ~_ + = #{offset VkDisplayPlaneCapabilitiesKHR, maxDstPosition} + + {-# INLINE readVkMaxDstPosition #-} + readVkMaxDstPosition p + = peekByteOff p #{offset VkDisplayPlaneCapabilitiesKHR, maxDstPosition} + + {-# INLINE writeVkMaxDstPosition #-} + writeVkMaxDstPosition p + = pokeByteOff p #{offset VkDisplayPlaneCapabilitiesKHR, maxDstPosition} + +instance {-# OVERLAPPING #-} + HasField "maxDstPosition" VkDisplayPlaneCapabilitiesKHR where + type FieldType "maxDstPosition" VkDisplayPlaneCapabilitiesKHR = + VkOffset2D + type FieldOptional "maxDstPosition" VkDisplayPlaneCapabilitiesKHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "maxDstPosition" VkDisplayPlaneCapabilitiesKHR = + #{offset VkDisplayPlaneCapabilitiesKHR, maxDstPosition} + type FieldIsArray "maxDstPosition" VkDisplayPlaneCapabilitiesKHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDisplayPlaneCapabilitiesKHR, maxDstPosition} + +instance CanReadField "maxDstPosition" + VkDisplayPlaneCapabilitiesKHR + where + {-# INLINE getField #-} + getField = vkMaxDstPosition + + {-# INLINE readField #-} + readField = readVkMaxDstPosition + +instance {-# OVERLAPPING #-} + HasVkMinDstExtent VkDisplayPlaneCapabilitiesKHR where + type VkMinDstExtentMType VkDisplayPlaneCapabilitiesKHR = VkExtent2D + + {-# NOINLINE vkMinDstExtent #-} + vkMinDstExtent x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDisplayPlaneCapabilitiesKHR, minDstExtent}) + + {-# INLINE vkMinDstExtentByteOffset #-} + vkMinDstExtentByteOffset ~_ + = #{offset VkDisplayPlaneCapabilitiesKHR, minDstExtent} + + {-# INLINE readVkMinDstExtent #-} + readVkMinDstExtent p + = peekByteOff p #{offset VkDisplayPlaneCapabilitiesKHR, minDstExtent} + + {-# INLINE writeVkMinDstExtent #-} + writeVkMinDstExtent p + = pokeByteOff p #{offset VkDisplayPlaneCapabilitiesKHR, minDstExtent} + +instance {-# OVERLAPPING #-} + HasField "minDstExtent" VkDisplayPlaneCapabilitiesKHR where + type FieldType "minDstExtent" VkDisplayPlaneCapabilitiesKHR = + VkExtent2D + type FieldOptional "minDstExtent" VkDisplayPlaneCapabilitiesKHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "minDstExtent" VkDisplayPlaneCapabilitiesKHR = + #{offset VkDisplayPlaneCapabilitiesKHR, minDstExtent} + type FieldIsArray "minDstExtent" VkDisplayPlaneCapabilitiesKHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDisplayPlaneCapabilitiesKHR, minDstExtent} + +instance CanReadField "minDstExtent" VkDisplayPlaneCapabilitiesKHR + where + {-# INLINE getField #-} + getField = vkMinDstExtent + + {-# INLINE readField #-} + readField = readVkMinDstExtent + +instance {-# OVERLAPPING #-} + HasVkMaxDstExtent VkDisplayPlaneCapabilitiesKHR where + type VkMaxDstExtentMType VkDisplayPlaneCapabilitiesKHR = VkExtent2D + + {-# NOINLINE vkMaxDstExtent #-} + vkMaxDstExtent x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDisplayPlaneCapabilitiesKHR, maxDstExtent}) + + {-# INLINE vkMaxDstExtentByteOffset #-} + vkMaxDstExtentByteOffset ~_ + = #{offset VkDisplayPlaneCapabilitiesKHR, maxDstExtent} + + {-# INLINE readVkMaxDstExtent #-} + readVkMaxDstExtent p + = peekByteOff p #{offset VkDisplayPlaneCapabilitiesKHR, maxDstExtent} + + {-# INLINE writeVkMaxDstExtent #-} + writeVkMaxDstExtent p + = pokeByteOff p #{offset VkDisplayPlaneCapabilitiesKHR, maxDstExtent} + +instance {-# OVERLAPPING #-} + HasField "maxDstExtent" VkDisplayPlaneCapabilitiesKHR where + type FieldType "maxDstExtent" VkDisplayPlaneCapabilitiesKHR = + VkExtent2D + type FieldOptional "maxDstExtent" VkDisplayPlaneCapabilitiesKHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "maxDstExtent" VkDisplayPlaneCapabilitiesKHR = + #{offset VkDisplayPlaneCapabilitiesKHR, maxDstExtent} + type FieldIsArray "maxDstExtent" VkDisplayPlaneCapabilitiesKHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDisplayPlaneCapabilitiesKHR, maxDstExtent} + +instance CanReadField "maxDstExtent" VkDisplayPlaneCapabilitiesKHR + where + {-# INLINE getField #-} + getField = vkMaxDstExtent + + {-# INLINE readField #-} + readField = readVkMaxDstExtent + +instance Show VkDisplayPlaneCapabilitiesKHR where + showsPrec d x + = showString "VkDisplayPlaneCapabilitiesKHR {" . + showString "vkSupportedAlpha = " . + showsPrec d (vkSupportedAlpha x) . + showString ", " . + showString "vkMinSrcPosition = " . + showsPrec d (vkMinSrcPosition x) . + showString ", " . + showString "vkMaxSrcPosition = " . + showsPrec d (vkMaxSrcPosition x) . + showString ", " . + showString "vkMinSrcExtent = " . + showsPrec d (vkMinSrcExtent x) . + showString ", " . + showString "vkMaxSrcExtent = " . + showsPrec d (vkMaxSrcExtent x) . + showString ", " . + showString "vkMinDstPosition = " . + showsPrec d (vkMinDstPosition x) . + showString ", " . + showString "vkMaxDstPosition = " . + showsPrec d (vkMaxDstPosition x) . + showString ", " . + showString "vkMinDstExtent = " . + showsPrec d (vkMinDstExtent x) . + showString ", " . + showString "vkMaxDstExtent = " . + showsPrec d (vkMaxDstExtent x) . + showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkDisplayPlanePropertiesKHR.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkDisplayPlanePropertiesKHR.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkDisplayPlanePropertiesKHR.hsc @@ -0,0 +1,179 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkDisplayPlanePropertiesKHR + (VkDisplayPlanePropertiesKHR(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Handles (VkDisplayKHR) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkDisplayPlanePropertiesKHR { +-- > VkDisplayKHR currentDisplay; +-- > uint32_t currentStackIndex; +-- > } VkDisplayPlanePropertiesKHR; +-- +-- +data VkDisplayPlanePropertiesKHR = VkDisplayPlanePropertiesKHR## Addr## + ByteArray## + +instance Eq VkDisplayPlanePropertiesKHR where + (VkDisplayPlanePropertiesKHR## a _) == + x@(VkDisplayPlanePropertiesKHR## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkDisplayPlanePropertiesKHR where + (VkDisplayPlanePropertiesKHR## a _) `compare` + x@(VkDisplayPlanePropertiesKHR## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkDisplayPlanePropertiesKHR where + sizeOf ~_ = #{size VkDisplayPlanePropertiesKHR} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkDisplayPlanePropertiesKHR} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkDisplayPlanePropertiesKHR where + unsafeAddr (VkDisplayPlanePropertiesKHR## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkDisplayPlanePropertiesKHR## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkDisplayPlanePropertiesKHR## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkDisplayPlanePropertiesKHR where + type StructFields VkDisplayPlanePropertiesKHR = + '["currentDisplay", "currentStackIndex"] -- ' closing tick for hsc2hs + type CUnionType VkDisplayPlanePropertiesKHR = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkDisplayPlanePropertiesKHR = 'True -- ' closing tick for hsc2hs + type StructExtends VkDisplayPlanePropertiesKHR = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkCurrentDisplay VkDisplayPlanePropertiesKHR where + type VkCurrentDisplayMType VkDisplayPlanePropertiesKHR = + VkDisplayKHR + + {-# NOINLINE vkCurrentDisplay #-} + vkCurrentDisplay x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDisplayPlanePropertiesKHR, currentDisplay}) + + {-# INLINE vkCurrentDisplayByteOffset #-} + vkCurrentDisplayByteOffset ~_ + = #{offset VkDisplayPlanePropertiesKHR, currentDisplay} + + {-# INLINE readVkCurrentDisplay #-} + readVkCurrentDisplay p + = peekByteOff p #{offset VkDisplayPlanePropertiesKHR, currentDisplay} + + {-# INLINE writeVkCurrentDisplay #-} + writeVkCurrentDisplay p + = pokeByteOff p #{offset VkDisplayPlanePropertiesKHR, currentDisplay} + +instance {-# OVERLAPPING #-} + HasField "currentDisplay" VkDisplayPlanePropertiesKHR where + type FieldType "currentDisplay" VkDisplayPlanePropertiesKHR = + VkDisplayKHR + type FieldOptional "currentDisplay" VkDisplayPlanePropertiesKHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "currentDisplay" VkDisplayPlanePropertiesKHR = + #{offset VkDisplayPlanePropertiesKHR, currentDisplay} + type FieldIsArray "currentDisplay" VkDisplayPlanePropertiesKHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDisplayPlanePropertiesKHR, currentDisplay} + +instance CanReadField "currentDisplay" VkDisplayPlanePropertiesKHR + where + {-# INLINE getField #-} + getField = vkCurrentDisplay + + {-# INLINE readField #-} + readField = readVkCurrentDisplay + +instance {-# OVERLAPPING #-} + HasVkCurrentStackIndex VkDisplayPlanePropertiesKHR where + type VkCurrentStackIndexMType VkDisplayPlanePropertiesKHR = Word32 + + {-# NOINLINE vkCurrentStackIndex #-} + vkCurrentStackIndex x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDisplayPlanePropertiesKHR, currentStackIndex}) + + {-# INLINE vkCurrentStackIndexByteOffset #-} + vkCurrentStackIndexByteOffset ~_ + = #{offset VkDisplayPlanePropertiesKHR, currentStackIndex} + + {-# INLINE readVkCurrentStackIndex #-} + readVkCurrentStackIndex p + = peekByteOff p #{offset VkDisplayPlanePropertiesKHR, currentStackIndex} + + {-# INLINE writeVkCurrentStackIndex #-} + writeVkCurrentStackIndex p + = pokeByteOff p #{offset VkDisplayPlanePropertiesKHR, currentStackIndex} + +instance {-# OVERLAPPING #-} + HasField "currentStackIndex" VkDisplayPlanePropertiesKHR where + type FieldType "currentStackIndex" VkDisplayPlanePropertiesKHR = + Word32 + type FieldOptional "currentStackIndex" VkDisplayPlanePropertiesKHR + = 'False -- ' closing tick for hsc2hs + type FieldOffset "currentStackIndex" VkDisplayPlanePropertiesKHR = + #{offset VkDisplayPlanePropertiesKHR, currentStackIndex} + type FieldIsArray "currentStackIndex" VkDisplayPlanePropertiesKHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDisplayPlanePropertiesKHR, currentStackIndex} + +instance CanReadField "currentStackIndex" + VkDisplayPlanePropertiesKHR + where + {-# INLINE getField #-} + getField = vkCurrentStackIndex + + {-# INLINE readField #-} + readField = readVkCurrentStackIndex + +instance Show VkDisplayPlanePropertiesKHR where + showsPrec d x + = showString "VkDisplayPlanePropertiesKHR {" . + showString "vkCurrentDisplay = " . + showsPrec d (vkCurrentDisplay x) . + showString ", " . + showString "vkCurrentStackIndex = " . + showsPrec d (vkCurrentStackIndex x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkDisplayPowerInfoEXT.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkDisplayPowerInfoEXT.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkDisplayPowerInfoEXT.hsc @@ -0,0 +1,224 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkDisplayPowerInfoEXT + (VkDisplayPowerInfoEXT(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkDisplayPowerStateEXT (VkDisplayPowerStateEXT) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkDisplayPowerInfoEXT { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkDisplayPowerStateEXT powerState; +-- > } VkDisplayPowerInfoEXT; +-- +-- +data VkDisplayPowerInfoEXT = VkDisplayPowerInfoEXT## Addr## + ByteArray## + +instance Eq VkDisplayPowerInfoEXT where + (VkDisplayPowerInfoEXT## a _) == x@(VkDisplayPowerInfoEXT## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkDisplayPowerInfoEXT where + (VkDisplayPowerInfoEXT## a _) `compare` + x@(VkDisplayPowerInfoEXT## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkDisplayPowerInfoEXT where + sizeOf ~_ = #{size VkDisplayPowerInfoEXT} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkDisplayPowerInfoEXT} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkDisplayPowerInfoEXT where + unsafeAddr (VkDisplayPowerInfoEXT## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkDisplayPowerInfoEXT## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkDisplayPowerInfoEXT## (plusAddr## (byteArrayContents## b) off) b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkDisplayPowerInfoEXT where + type StructFields VkDisplayPowerInfoEXT = + '["sType", "pNext", "powerState"] -- ' closing tick for hsc2hs + type CUnionType VkDisplayPowerInfoEXT = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkDisplayPowerInfoEXT = 'False -- ' closing tick for hsc2hs + type StructExtends VkDisplayPowerInfoEXT = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkSType VkDisplayPowerInfoEXT where + type VkSTypeMType VkDisplayPowerInfoEXT = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDisplayPowerInfoEXT, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkDisplayPowerInfoEXT, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkDisplayPowerInfoEXT, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkDisplayPowerInfoEXT, sType} + +instance {-# OVERLAPPING #-} HasField "sType" VkDisplayPowerInfoEXT + where + type FieldType "sType" VkDisplayPowerInfoEXT = VkStructureType + type FieldOptional "sType" VkDisplayPowerInfoEXT = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkDisplayPowerInfoEXT = + #{offset VkDisplayPowerInfoEXT, sType} + type FieldIsArray "sType" VkDisplayPowerInfoEXT = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkDisplayPowerInfoEXT, sType} + +instance CanReadField "sType" VkDisplayPowerInfoEXT where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkDisplayPowerInfoEXT where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} HasVkPNext VkDisplayPowerInfoEXT where + type VkPNextMType VkDisplayPowerInfoEXT = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDisplayPowerInfoEXT, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkDisplayPowerInfoEXT, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkDisplayPowerInfoEXT, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkDisplayPowerInfoEXT, pNext} + +instance {-# OVERLAPPING #-} HasField "pNext" VkDisplayPowerInfoEXT + where + type FieldType "pNext" VkDisplayPowerInfoEXT = Ptr Void + type FieldOptional "pNext" VkDisplayPowerInfoEXT = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkDisplayPowerInfoEXT = + #{offset VkDisplayPowerInfoEXT, pNext} + type FieldIsArray "pNext" VkDisplayPowerInfoEXT = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkDisplayPowerInfoEXT, pNext} + +instance CanReadField "pNext" VkDisplayPowerInfoEXT where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkDisplayPowerInfoEXT where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} HasVkPowerState VkDisplayPowerInfoEXT + where + type VkPowerStateMType VkDisplayPowerInfoEXT = + VkDisplayPowerStateEXT + + {-# NOINLINE vkPowerState #-} + vkPowerState x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDisplayPowerInfoEXT, powerState}) + + {-# INLINE vkPowerStateByteOffset #-} + vkPowerStateByteOffset ~_ + = #{offset VkDisplayPowerInfoEXT, powerState} + + {-# INLINE readVkPowerState #-} + readVkPowerState p + = peekByteOff p #{offset VkDisplayPowerInfoEXT, powerState} + + {-# INLINE writeVkPowerState #-} + writeVkPowerState p + = pokeByteOff p #{offset VkDisplayPowerInfoEXT, powerState} + +instance {-# OVERLAPPING #-} + HasField "powerState" VkDisplayPowerInfoEXT where + type FieldType "powerState" VkDisplayPowerInfoEXT = + VkDisplayPowerStateEXT + type FieldOptional "powerState" VkDisplayPowerInfoEXT = 'False -- ' closing tick for hsc2hs + type FieldOffset "powerState" VkDisplayPowerInfoEXT = + #{offset VkDisplayPowerInfoEXT, powerState} + type FieldIsArray "powerState" VkDisplayPowerInfoEXT = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDisplayPowerInfoEXT, powerState} + +instance CanReadField "powerState" VkDisplayPowerInfoEXT where + {-# INLINE getField #-} + getField = vkPowerState + + {-# INLINE readField #-} + readField = readVkPowerState + +instance CanWriteField "powerState" VkDisplayPowerInfoEXT where + {-# INLINE writeField #-} + writeField = writeVkPowerState + +instance Show VkDisplayPowerInfoEXT where + showsPrec d x + = showString "VkDisplayPowerInfoEXT {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkPowerState = " . + showsPrec d (vkPowerState x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkDisplayPresentInfoKHR.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkDisplayPresentInfoKHR.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkDisplayPresentInfoKHR.hsc @@ -0,0 +1,328 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkDisplayPresentInfoKHR + (VkDisplayPresentInfoKHR(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.BaseTypes (VkBool32) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Struct.VkPresentInfoKHR (VkPresentInfoKHR) +import Graphics.Vulkan.Types.Struct.VkRect2D (VkRect2D) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkDisplayPresentInfoKHR { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkRect2D srcRect; +-- > VkRect2D dstRect; +-- > VkBool32 persistent; +-- > } VkDisplayPresentInfoKHR; +-- +-- +data VkDisplayPresentInfoKHR = VkDisplayPresentInfoKHR## Addr## + ByteArray## + +instance Eq VkDisplayPresentInfoKHR where + (VkDisplayPresentInfoKHR## a _) == x@(VkDisplayPresentInfoKHR## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkDisplayPresentInfoKHR where + (VkDisplayPresentInfoKHR## a _) `compare` + x@(VkDisplayPresentInfoKHR## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkDisplayPresentInfoKHR where + sizeOf ~_ = #{size VkDisplayPresentInfoKHR} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkDisplayPresentInfoKHR} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkDisplayPresentInfoKHR where + unsafeAddr (VkDisplayPresentInfoKHR## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkDisplayPresentInfoKHR## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkDisplayPresentInfoKHR## (plusAddr## (byteArrayContents## b) off) b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkDisplayPresentInfoKHR where + type StructFields VkDisplayPresentInfoKHR = + '["sType", "pNext", "srcRect", "dstRect", "persistent"] -- ' closing tick for hsc2hs + type CUnionType VkDisplayPresentInfoKHR = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkDisplayPresentInfoKHR = 'False -- ' closing tick for hsc2hs + type StructExtends VkDisplayPresentInfoKHR = '[VkPresentInfoKHR] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkSType VkDisplayPresentInfoKHR + where + type VkSTypeMType VkDisplayPresentInfoKHR = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDisplayPresentInfoKHR, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkDisplayPresentInfoKHR, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkDisplayPresentInfoKHR, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkDisplayPresentInfoKHR, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkDisplayPresentInfoKHR where + type FieldType "sType" VkDisplayPresentInfoKHR = VkStructureType + type FieldOptional "sType" VkDisplayPresentInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkDisplayPresentInfoKHR = + #{offset VkDisplayPresentInfoKHR, sType} + type FieldIsArray "sType" VkDisplayPresentInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkDisplayPresentInfoKHR, sType} + +instance CanReadField "sType" VkDisplayPresentInfoKHR where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkDisplayPresentInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} HasVkPNext VkDisplayPresentInfoKHR + where + type VkPNextMType VkDisplayPresentInfoKHR = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDisplayPresentInfoKHR, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkDisplayPresentInfoKHR, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkDisplayPresentInfoKHR, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkDisplayPresentInfoKHR, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkDisplayPresentInfoKHR where + type FieldType "pNext" VkDisplayPresentInfoKHR = Ptr Void + type FieldOptional "pNext" VkDisplayPresentInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkDisplayPresentInfoKHR = + #{offset VkDisplayPresentInfoKHR, pNext} + type FieldIsArray "pNext" VkDisplayPresentInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkDisplayPresentInfoKHR, pNext} + +instance CanReadField "pNext" VkDisplayPresentInfoKHR where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkDisplayPresentInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} HasVkSrcRect VkDisplayPresentInfoKHR + where + type VkSrcRectMType VkDisplayPresentInfoKHR = VkRect2D + + {-# NOINLINE vkSrcRect #-} + vkSrcRect x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDisplayPresentInfoKHR, srcRect}) + + {-# INLINE vkSrcRectByteOffset #-} + vkSrcRectByteOffset ~_ + = #{offset VkDisplayPresentInfoKHR, srcRect} + + {-# INLINE readVkSrcRect #-} + readVkSrcRect p + = peekByteOff p #{offset VkDisplayPresentInfoKHR, srcRect} + + {-# INLINE writeVkSrcRect #-} + writeVkSrcRect p + = pokeByteOff p #{offset VkDisplayPresentInfoKHR, srcRect} + +instance {-# OVERLAPPING #-} + HasField "srcRect" VkDisplayPresentInfoKHR where + type FieldType "srcRect" VkDisplayPresentInfoKHR = VkRect2D + type FieldOptional "srcRect" VkDisplayPresentInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "srcRect" VkDisplayPresentInfoKHR = + #{offset VkDisplayPresentInfoKHR, srcRect} + type FieldIsArray "srcRect" VkDisplayPresentInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDisplayPresentInfoKHR, srcRect} + +instance CanReadField "srcRect" VkDisplayPresentInfoKHR where + {-# INLINE getField #-} + getField = vkSrcRect + + {-# INLINE readField #-} + readField = readVkSrcRect + +instance CanWriteField "srcRect" VkDisplayPresentInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkSrcRect + +instance {-# OVERLAPPING #-} HasVkDstRect VkDisplayPresentInfoKHR + where + type VkDstRectMType VkDisplayPresentInfoKHR = VkRect2D + + {-# NOINLINE vkDstRect #-} + vkDstRect x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDisplayPresentInfoKHR, dstRect}) + + {-# INLINE vkDstRectByteOffset #-} + vkDstRectByteOffset ~_ + = #{offset VkDisplayPresentInfoKHR, dstRect} + + {-# INLINE readVkDstRect #-} + readVkDstRect p + = peekByteOff p #{offset VkDisplayPresentInfoKHR, dstRect} + + {-# INLINE writeVkDstRect #-} + writeVkDstRect p + = pokeByteOff p #{offset VkDisplayPresentInfoKHR, dstRect} + +instance {-# OVERLAPPING #-} + HasField "dstRect" VkDisplayPresentInfoKHR where + type FieldType "dstRect" VkDisplayPresentInfoKHR = VkRect2D + type FieldOptional "dstRect" VkDisplayPresentInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "dstRect" VkDisplayPresentInfoKHR = + #{offset VkDisplayPresentInfoKHR, dstRect} + type FieldIsArray "dstRect" VkDisplayPresentInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDisplayPresentInfoKHR, dstRect} + +instance CanReadField "dstRect" VkDisplayPresentInfoKHR where + {-# INLINE getField #-} + getField = vkDstRect + + {-# INLINE readField #-} + readField = readVkDstRect + +instance CanWriteField "dstRect" VkDisplayPresentInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkDstRect + +instance {-# OVERLAPPING #-} + HasVkPersistent VkDisplayPresentInfoKHR where + type VkPersistentMType VkDisplayPresentInfoKHR = VkBool32 + + {-# NOINLINE vkPersistent #-} + vkPersistent x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDisplayPresentInfoKHR, persistent}) + + {-# INLINE vkPersistentByteOffset #-} + vkPersistentByteOffset ~_ + = #{offset VkDisplayPresentInfoKHR, persistent} + + {-# INLINE readVkPersistent #-} + readVkPersistent p + = peekByteOff p #{offset VkDisplayPresentInfoKHR, persistent} + + {-# INLINE writeVkPersistent #-} + writeVkPersistent p + = pokeByteOff p #{offset VkDisplayPresentInfoKHR, persistent} + +instance {-# OVERLAPPING #-} + HasField "persistent" VkDisplayPresentInfoKHR where + type FieldType "persistent" VkDisplayPresentInfoKHR = VkBool32 + type FieldOptional "persistent" VkDisplayPresentInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "persistent" VkDisplayPresentInfoKHR = + #{offset VkDisplayPresentInfoKHR, persistent} + type FieldIsArray "persistent" VkDisplayPresentInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDisplayPresentInfoKHR, persistent} + +instance CanReadField "persistent" VkDisplayPresentInfoKHR where + {-# INLINE getField #-} + getField = vkPersistent + + {-# INLINE readField #-} + readField = readVkPersistent + +instance CanWriteField "persistent" VkDisplayPresentInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkPersistent + +instance Show VkDisplayPresentInfoKHR where + showsPrec d x + = showString "VkDisplayPresentInfoKHR {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkSrcRect = " . + showsPrec d (vkSrcRect x) . + showString ", " . + showString "vkDstRect = " . + showsPrec d (vkDstRect x) . + showString ", " . + showString "vkPersistent = " . + showsPrec d (vkPersistent x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkDisplayPropertiesKHR.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkDisplayPropertiesKHR.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkDisplayPropertiesKHR.hsc @@ -0,0 +1,427 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkDisplayPropertiesKHR + (VkDisplayPropertiesKHR(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.BaseTypes (VkBool32) +import Graphics.Vulkan.Types.Enum.VkSurfaceTransformFlagsKHR (VkSurfaceTransformFlagsKHR) +import Graphics.Vulkan.Types.Handles (VkDisplayKHR) +import Graphics.Vulkan.Types.Struct.VkExtent2D (VkExtent2D) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkDisplayPropertiesKHR { +-- > VkDisplayKHR display; +-- > const char* displayName; +-- > VkExtent2D physicalDimensions; +-- > VkExtent2D physicalResolution; +-- > VkSurfaceTransformFlagsKHR supportedTransforms; +-- > VkBool32 planeReorderPossible; +-- > VkBool32 persistentContent; +-- > } VkDisplayPropertiesKHR; +-- +-- +data VkDisplayPropertiesKHR = VkDisplayPropertiesKHR## Addr## + ByteArray## + +instance Eq VkDisplayPropertiesKHR where + (VkDisplayPropertiesKHR## a _) == x@(VkDisplayPropertiesKHR## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkDisplayPropertiesKHR where + (VkDisplayPropertiesKHR## a _) `compare` + x@(VkDisplayPropertiesKHR## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkDisplayPropertiesKHR where + sizeOf ~_ = #{size VkDisplayPropertiesKHR} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkDisplayPropertiesKHR} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkDisplayPropertiesKHR where + unsafeAddr (VkDisplayPropertiesKHR## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkDisplayPropertiesKHR## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkDisplayPropertiesKHR## (plusAddr## (byteArrayContents## b) off) b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkDisplayPropertiesKHR where + type StructFields VkDisplayPropertiesKHR = + '["display", "displayName", "physicalDimensions", -- ' closing tick for hsc2hs + "physicalResolution", "supportedTransforms", + "planeReorderPossible", "persistentContent"] + type CUnionType VkDisplayPropertiesKHR = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkDisplayPropertiesKHR = 'True -- ' closing tick for hsc2hs + type StructExtends VkDisplayPropertiesKHR = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkDisplay VkDisplayPropertiesKHR + where + type VkDisplayMType VkDisplayPropertiesKHR = VkDisplayKHR + + {-# NOINLINE vkDisplay #-} + vkDisplay x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDisplayPropertiesKHR, display}) + + {-# INLINE vkDisplayByteOffset #-} + vkDisplayByteOffset ~_ + = #{offset VkDisplayPropertiesKHR, display} + + {-# INLINE readVkDisplay #-} + readVkDisplay p + = peekByteOff p #{offset VkDisplayPropertiesKHR, display} + + {-# INLINE writeVkDisplay #-} + writeVkDisplay p + = pokeByteOff p #{offset VkDisplayPropertiesKHR, display} + +instance {-# OVERLAPPING #-} + HasField "display" VkDisplayPropertiesKHR where + type FieldType "display" VkDisplayPropertiesKHR = VkDisplayKHR + type FieldOptional "display" VkDisplayPropertiesKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "display" VkDisplayPropertiesKHR = + #{offset VkDisplayPropertiesKHR, display} + type FieldIsArray "display" VkDisplayPropertiesKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkDisplayPropertiesKHR, display} + +instance CanReadField "display" VkDisplayPropertiesKHR where + {-# INLINE getField #-} + getField = vkDisplay + + {-# INLINE readField #-} + readField = readVkDisplay + +instance {-# OVERLAPPING #-} + HasVkDisplayName VkDisplayPropertiesKHR where + type VkDisplayNameMType VkDisplayPropertiesKHR = CString + + {-# NOINLINE vkDisplayName #-} + vkDisplayName x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDisplayPropertiesKHR, displayName}) + + {-# INLINE vkDisplayNameByteOffset #-} + vkDisplayNameByteOffset ~_ + = #{offset VkDisplayPropertiesKHR, displayName} + + {-# INLINE readVkDisplayName #-} + readVkDisplayName p + = peekByteOff p #{offset VkDisplayPropertiesKHR, displayName} + + {-# INLINE writeVkDisplayName #-} + writeVkDisplayName p + = pokeByteOff p #{offset VkDisplayPropertiesKHR, displayName} + +instance {-# OVERLAPPING #-} + HasField "displayName" VkDisplayPropertiesKHR where + type FieldType "displayName" VkDisplayPropertiesKHR = CString + type FieldOptional "displayName" VkDisplayPropertiesKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "displayName" VkDisplayPropertiesKHR = + #{offset VkDisplayPropertiesKHR, displayName} + type FieldIsArray "displayName" VkDisplayPropertiesKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDisplayPropertiesKHR, displayName} + +instance CanReadField "displayName" VkDisplayPropertiesKHR where + {-# INLINE getField #-} + getField = vkDisplayName + + {-# INLINE readField #-} + readField = readVkDisplayName + +instance {-# OVERLAPPING #-} + HasVkPhysicalDimensions VkDisplayPropertiesKHR where + type VkPhysicalDimensionsMType VkDisplayPropertiesKHR = VkExtent2D + + {-# NOINLINE vkPhysicalDimensions #-} + vkPhysicalDimensions x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDisplayPropertiesKHR, physicalDimensions}) + + {-# INLINE vkPhysicalDimensionsByteOffset #-} + vkPhysicalDimensionsByteOffset ~_ + = #{offset VkDisplayPropertiesKHR, physicalDimensions} + + {-# INLINE readVkPhysicalDimensions #-} + readVkPhysicalDimensions p + = peekByteOff p #{offset VkDisplayPropertiesKHR, physicalDimensions} + + {-# INLINE writeVkPhysicalDimensions #-} + writeVkPhysicalDimensions p + = pokeByteOff p #{offset VkDisplayPropertiesKHR, physicalDimensions} + +instance {-# OVERLAPPING #-} + HasField "physicalDimensions" VkDisplayPropertiesKHR where + type FieldType "physicalDimensions" VkDisplayPropertiesKHR = + VkExtent2D + type FieldOptional "physicalDimensions" VkDisplayPropertiesKHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "physicalDimensions" VkDisplayPropertiesKHR = + #{offset VkDisplayPropertiesKHR, physicalDimensions} + type FieldIsArray "physicalDimensions" VkDisplayPropertiesKHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDisplayPropertiesKHR, physicalDimensions} + +instance CanReadField "physicalDimensions" VkDisplayPropertiesKHR + where + {-# INLINE getField #-} + getField = vkPhysicalDimensions + + {-# INLINE readField #-} + readField = readVkPhysicalDimensions + +instance {-# OVERLAPPING #-} + HasVkPhysicalResolution VkDisplayPropertiesKHR where + type VkPhysicalResolutionMType VkDisplayPropertiesKHR = VkExtent2D + + {-# NOINLINE vkPhysicalResolution #-} + vkPhysicalResolution x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDisplayPropertiesKHR, physicalResolution}) + + {-# INLINE vkPhysicalResolutionByteOffset #-} + vkPhysicalResolutionByteOffset ~_ + = #{offset VkDisplayPropertiesKHR, physicalResolution} + + {-# INLINE readVkPhysicalResolution #-} + readVkPhysicalResolution p + = peekByteOff p #{offset VkDisplayPropertiesKHR, physicalResolution} + + {-# INLINE writeVkPhysicalResolution #-} + writeVkPhysicalResolution p + = pokeByteOff p #{offset VkDisplayPropertiesKHR, physicalResolution} + +instance {-# OVERLAPPING #-} + HasField "physicalResolution" VkDisplayPropertiesKHR where + type FieldType "physicalResolution" VkDisplayPropertiesKHR = + VkExtent2D + type FieldOptional "physicalResolution" VkDisplayPropertiesKHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "physicalResolution" VkDisplayPropertiesKHR = + #{offset VkDisplayPropertiesKHR, physicalResolution} + type FieldIsArray "physicalResolution" VkDisplayPropertiesKHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDisplayPropertiesKHR, physicalResolution} + +instance CanReadField "physicalResolution" VkDisplayPropertiesKHR + where + {-# INLINE getField #-} + getField = vkPhysicalResolution + + {-# INLINE readField #-} + readField = readVkPhysicalResolution + +instance {-# OVERLAPPING #-} + HasVkSupportedTransforms VkDisplayPropertiesKHR where + type VkSupportedTransformsMType VkDisplayPropertiesKHR = + VkSurfaceTransformFlagsKHR + + {-# NOINLINE vkSupportedTransforms #-} + vkSupportedTransforms x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDisplayPropertiesKHR, supportedTransforms}) + + {-# INLINE vkSupportedTransformsByteOffset #-} + vkSupportedTransformsByteOffset ~_ + = #{offset VkDisplayPropertiesKHR, supportedTransforms} + + {-# INLINE readVkSupportedTransforms #-} + readVkSupportedTransforms p + = peekByteOff p #{offset VkDisplayPropertiesKHR, supportedTransforms} + + {-# INLINE writeVkSupportedTransforms #-} + writeVkSupportedTransforms p + = pokeByteOff p #{offset VkDisplayPropertiesKHR, supportedTransforms} + +instance {-# OVERLAPPING #-} + HasField "supportedTransforms" VkDisplayPropertiesKHR where + type FieldType "supportedTransforms" VkDisplayPropertiesKHR = + VkSurfaceTransformFlagsKHR + type FieldOptional "supportedTransforms" VkDisplayPropertiesKHR = + 'True -- ' closing tick for hsc2hs + type FieldOffset "supportedTransforms" VkDisplayPropertiesKHR = + #{offset VkDisplayPropertiesKHR, supportedTransforms} + type FieldIsArray "supportedTransforms" VkDisplayPropertiesKHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDisplayPropertiesKHR, supportedTransforms} + +instance CanReadField "supportedTransforms" VkDisplayPropertiesKHR + where + {-# INLINE getField #-} + getField = vkSupportedTransforms + + {-# INLINE readField #-} + readField = readVkSupportedTransforms + +instance {-# OVERLAPPING #-} + HasVkPlaneReorderPossible VkDisplayPropertiesKHR where + type VkPlaneReorderPossibleMType VkDisplayPropertiesKHR = VkBool32 + + {-# NOINLINE vkPlaneReorderPossible #-} + vkPlaneReorderPossible x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDisplayPropertiesKHR, planeReorderPossible}) + + {-# INLINE vkPlaneReorderPossibleByteOffset #-} + vkPlaneReorderPossibleByteOffset ~_ + = #{offset VkDisplayPropertiesKHR, planeReorderPossible} + + {-# INLINE readVkPlaneReorderPossible #-} + readVkPlaneReorderPossible p + = peekByteOff p #{offset VkDisplayPropertiesKHR, planeReorderPossible} + + {-# INLINE writeVkPlaneReorderPossible #-} + writeVkPlaneReorderPossible p + = pokeByteOff p #{offset VkDisplayPropertiesKHR, planeReorderPossible} + +instance {-# OVERLAPPING #-} + HasField "planeReorderPossible" VkDisplayPropertiesKHR where + type FieldType "planeReorderPossible" VkDisplayPropertiesKHR = + VkBool32 + type FieldOptional "planeReorderPossible" VkDisplayPropertiesKHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "planeReorderPossible" VkDisplayPropertiesKHR = + #{offset VkDisplayPropertiesKHR, planeReorderPossible} + type FieldIsArray "planeReorderPossible" VkDisplayPropertiesKHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDisplayPropertiesKHR, planeReorderPossible} + +instance CanReadField "planeReorderPossible" VkDisplayPropertiesKHR + where + {-# INLINE getField #-} + getField = vkPlaneReorderPossible + + {-# INLINE readField #-} + readField = readVkPlaneReorderPossible + +instance {-# OVERLAPPING #-} + HasVkPersistentContent VkDisplayPropertiesKHR where + type VkPersistentContentMType VkDisplayPropertiesKHR = VkBool32 + + {-# NOINLINE vkPersistentContent #-} + vkPersistentContent x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDisplayPropertiesKHR, persistentContent}) + + {-# INLINE vkPersistentContentByteOffset #-} + vkPersistentContentByteOffset ~_ + = #{offset VkDisplayPropertiesKHR, persistentContent} + + {-# INLINE readVkPersistentContent #-} + readVkPersistentContent p + = peekByteOff p #{offset VkDisplayPropertiesKHR, persistentContent} + + {-# INLINE writeVkPersistentContent #-} + writeVkPersistentContent p + = pokeByteOff p #{offset VkDisplayPropertiesKHR, persistentContent} + +instance {-# OVERLAPPING #-} + HasField "persistentContent" VkDisplayPropertiesKHR where + type FieldType "persistentContent" VkDisplayPropertiesKHR = + VkBool32 + type FieldOptional "persistentContent" VkDisplayPropertiesKHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "persistentContent" VkDisplayPropertiesKHR = + #{offset VkDisplayPropertiesKHR, persistentContent} + type FieldIsArray "persistentContent" VkDisplayPropertiesKHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDisplayPropertiesKHR, persistentContent} + +instance CanReadField "persistentContent" VkDisplayPropertiesKHR + where + {-# INLINE getField #-} + getField = vkPersistentContent + + {-# INLINE readField #-} + readField = readVkPersistentContent + +instance Show VkDisplayPropertiesKHR where + showsPrec d x + = showString "VkDisplayPropertiesKHR {" . + showString "vkDisplay = " . + showsPrec d (vkDisplay x) . + showString ", " . + showString "vkDisplayName = " . + showsPrec d (vkDisplayName x) . + showString ", " . + showString "vkPhysicalDimensions = " . + showsPrec d (vkPhysicalDimensions x) . + showString ", " . + showString "vkPhysicalResolution = " . + showsPrec d (vkPhysicalResolution x) . + showString ", " . + showString "vkSupportedTransforms = " . + showsPrec d (vkSupportedTransforms x) . + showString ", " . + showString "vkPlaneReorderPossible = " . + showsPrec d (vkPlaneReorderPossible x) . + showString ", " . + showString "vkPersistentContent = " . + showsPrec d (vkPersistentContent x) . + showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkDisplaySurfaceCreateInfoKHR.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkDisplaySurfaceCreateInfoKHR.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkDisplaySurfaceCreateInfoKHR.hsc @@ -0,0 +1,637 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkDisplaySurfaceCreateInfoKHR + (VkDisplaySurfaceCreateInfoKHR(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Bitmasks (VkDisplaySurfaceCreateFlagsKHR) +import Graphics.Vulkan.Types.Enum.VkDisplayPlaneAlphaFlagsKHR (VkDisplayPlaneAlphaFlagBitsKHR) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Enum.VkSurfaceTransformFlagsKHR (VkSurfaceTransformFlagBitsKHR) +import Graphics.Vulkan.Types.Handles (VkDisplayModeKHR) +import Graphics.Vulkan.Types.Struct.VkExtent2D (VkExtent2D) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkDisplaySurfaceCreateInfoKHR { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkDisplaySurfaceCreateFlagsKHR flags; +-- > VkDisplayModeKHR displayMode; +-- > uint32_t planeIndex; +-- > uint32_t planeStackIndex; +-- > VkSurfaceTransformFlagBitsKHR transform; +-- > float globalAlpha; +-- > VkDisplayPlaneAlphaFlagBitsKHR alphaMode; +-- > VkExtent2D imageExtent; +-- > } VkDisplaySurfaceCreateInfoKHR; +-- +-- +data VkDisplaySurfaceCreateInfoKHR = VkDisplaySurfaceCreateInfoKHR## Addr## + ByteArray## + +instance Eq VkDisplaySurfaceCreateInfoKHR where + (VkDisplaySurfaceCreateInfoKHR## a _) == + x@(VkDisplaySurfaceCreateInfoKHR## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkDisplaySurfaceCreateInfoKHR where + (VkDisplaySurfaceCreateInfoKHR## a _) `compare` + x@(VkDisplaySurfaceCreateInfoKHR## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkDisplaySurfaceCreateInfoKHR where + sizeOf ~_ = #{size VkDisplaySurfaceCreateInfoKHR} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkDisplaySurfaceCreateInfoKHR} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkDisplaySurfaceCreateInfoKHR where + unsafeAddr (VkDisplaySurfaceCreateInfoKHR## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkDisplaySurfaceCreateInfoKHR## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkDisplaySurfaceCreateInfoKHR## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkDisplaySurfaceCreateInfoKHR where + type StructFields VkDisplaySurfaceCreateInfoKHR = + '["sType", "pNext", "flags", "displayMode", "planeIndex", -- ' closing tick for hsc2hs + "planeStackIndex", "transform", "globalAlpha", "alphaMode", + "imageExtent"] + type CUnionType VkDisplaySurfaceCreateInfoKHR = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkDisplaySurfaceCreateInfoKHR = 'False -- ' closing tick for hsc2hs + type StructExtends VkDisplaySurfaceCreateInfoKHR = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkDisplaySurfaceCreateInfoKHR where + type VkSTypeMType VkDisplaySurfaceCreateInfoKHR = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDisplaySurfaceCreateInfoKHR, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkDisplaySurfaceCreateInfoKHR, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkDisplaySurfaceCreateInfoKHR, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkDisplaySurfaceCreateInfoKHR, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkDisplaySurfaceCreateInfoKHR where + type FieldType "sType" VkDisplaySurfaceCreateInfoKHR = + VkStructureType + type FieldOptional "sType" VkDisplaySurfaceCreateInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkDisplaySurfaceCreateInfoKHR = + #{offset VkDisplaySurfaceCreateInfoKHR, sType} + type FieldIsArray "sType" VkDisplaySurfaceCreateInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDisplaySurfaceCreateInfoKHR, sType} + +instance CanReadField "sType" VkDisplaySurfaceCreateInfoKHR where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkDisplaySurfaceCreateInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkDisplaySurfaceCreateInfoKHR where + type VkPNextMType VkDisplaySurfaceCreateInfoKHR = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDisplaySurfaceCreateInfoKHR, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkDisplaySurfaceCreateInfoKHR, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkDisplaySurfaceCreateInfoKHR, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkDisplaySurfaceCreateInfoKHR, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkDisplaySurfaceCreateInfoKHR where + type FieldType "pNext" VkDisplaySurfaceCreateInfoKHR = Ptr Void + type FieldOptional "pNext" VkDisplaySurfaceCreateInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkDisplaySurfaceCreateInfoKHR = + #{offset VkDisplaySurfaceCreateInfoKHR, pNext} + type FieldIsArray "pNext" VkDisplaySurfaceCreateInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDisplaySurfaceCreateInfoKHR, pNext} + +instance CanReadField "pNext" VkDisplaySurfaceCreateInfoKHR where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkDisplaySurfaceCreateInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkFlags VkDisplaySurfaceCreateInfoKHR where + type VkFlagsMType VkDisplaySurfaceCreateInfoKHR = + VkDisplaySurfaceCreateFlagsKHR + + {-# NOINLINE vkFlags #-} + vkFlags x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDisplaySurfaceCreateInfoKHR, flags}) + + {-# INLINE vkFlagsByteOffset #-} + vkFlagsByteOffset ~_ + = #{offset VkDisplaySurfaceCreateInfoKHR, flags} + + {-# INLINE readVkFlags #-} + readVkFlags p + = peekByteOff p #{offset VkDisplaySurfaceCreateInfoKHR, flags} + + {-# INLINE writeVkFlags #-} + writeVkFlags p + = pokeByteOff p #{offset VkDisplaySurfaceCreateInfoKHR, flags} + +instance {-# OVERLAPPING #-} + HasField "flags" VkDisplaySurfaceCreateInfoKHR where + type FieldType "flags" VkDisplaySurfaceCreateInfoKHR = + VkDisplaySurfaceCreateFlagsKHR + type FieldOptional "flags" VkDisplaySurfaceCreateInfoKHR = 'True -- ' closing tick for hsc2hs + type FieldOffset "flags" VkDisplaySurfaceCreateInfoKHR = + #{offset VkDisplaySurfaceCreateInfoKHR, flags} + type FieldIsArray "flags" VkDisplaySurfaceCreateInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDisplaySurfaceCreateInfoKHR, flags} + +instance CanReadField "flags" VkDisplaySurfaceCreateInfoKHR where + {-# INLINE getField #-} + getField = vkFlags + + {-# INLINE readField #-} + readField = readVkFlags + +instance CanWriteField "flags" VkDisplaySurfaceCreateInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkFlags + +instance {-# OVERLAPPING #-} + HasVkDisplayMode VkDisplaySurfaceCreateInfoKHR where + type VkDisplayModeMType VkDisplaySurfaceCreateInfoKHR = + VkDisplayModeKHR + + {-# NOINLINE vkDisplayMode #-} + vkDisplayMode x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDisplaySurfaceCreateInfoKHR, displayMode}) + + {-# INLINE vkDisplayModeByteOffset #-} + vkDisplayModeByteOffset ~_ + = #{offset VkDisplaySurfaceCreateInfoKHR, displayMode} + + {-# INLINE readVkDisplayMode #-} + readVkDisplayMode p + = peekByteOff p #{offset VkDisplaySurfaceCreateInfoKHR, displayMode} + + {-# INLINE writeVkDisplayMode #-} + writeVkDisplayMode p + = pokeByteOff p #{offset VkDisplaySurfaceCreateInfoKHR, displayMode} + +instance {-# OVERLAPPING #-} + HasField "displayMode" VkDisplaySurfaceCreateInfoKHR where + type FieldType "displayMode" VkDisplaySurfaceCreateInfoKHR = + VkDisplayModeKHR + type FieldOptional "displayMode" VkDisplaySurfaceCreateInfoKHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "displayMode" VkDisplaySurfaceCreateInfoKHR = + #{offset VkDisplaySurfaceCreateInfoKHR, displayMode} + type FieldIsArray "displayMode" VkDisplaySurfaceCreateInfoKHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDisplaySurfaceCreateInfoKHR, displayMode} + +instance CanReadField "displayMode" VkDisplaySurfaceCreateInfoKHR + where + {-# INLINE getField #-} + getField = vkDisplayMode + + {-# INLINE readField #-} + readField = readVkDisplayMode + +instance CanWriteField "displayMode" VkDisplaySurfaceCreateInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkDisplayMode + +instance {-# OVERLAPPING #-} + HasVkPlaneIndex VkDisplaySurfaceCreateInfoKHR where + type VkPlaneIndexMType VkDisplaySurfaceCreateInfoKHR = Word32 + + {-# NOINLINE vkPlaneIndex #-} + vkPlaneIndex x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDisplaySurfaceCreateInfoKHR, planeIndex}) + + {-# INLINE vkPlaneIndexByteOffset #-} + vkPlaneIndexByteOffset ~_ + = #{offset VkDisplaySurfaceCreateInfoKHR, planeIndex} + + {-# INLINE readVkPlaneIndex #-} + readVkPlaneIndex p + = peekByteOff p #{offset VkDisplaySurfaceCreateInfoKHR, planeIndex} + + {-# INLINE writeVkPlaneIndex #-} + writeVkPlaneIndex p + = pokeByteOff p #{offset VkDisplaySurfaceCreateInfoKHR, planeIndex} + +instance {-# OVERLAPPING #-} + HasField "planeIndex" VkDisplaySurfaceCreateInfoKHR where + type FieldType "planeIndex" VkDisplaySurfaceCreateInfoKHR = Word32 + type FieldOptional "planeIndex" VkDisplaySurfaceCreateInfoKHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "planeIndex" VkDisplaySurfaceCreateInfoKHR = + #{offset VkDisplaySurfaceCreateInfoKHR, planeIndex} + type FieldIsArray "planeIndex" VkDisplaySurfaceCreateInfoKHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDisplaySurfaceCreateInfoKHR, planeIndex} + +instance CanReadField "planeIndex" VkDisplaySurfaceCreateInfoKHR + where + {-# INLINE getField #-} + getField = vkPlaneIndex + + {-# INLINE readField #-} + readField = readVkPlaneIndex + +instance CanWriteField "planeIndex" VkDisplaySurfaceCreateInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkPlaneIndex + +instance {-# OVERLAPPING #-} + HasVkPlaneStackIndex VkDisplaySurfaceCreateInfoKHR where + type VkPlaneStackIndexMType VkDisplaySurfaceCreateInfoKHR = Word32 + + {-# NOINLINE vkPlaneStackIndex #-} + vkPlaneStackIndex x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDisplaySurfaceCreateInfoKHR, planeStackIndex}) + + {-# INLINE vkPlaneStackIndexByteOffset #-} + vkPlaneStackIndexByteOffset ~_ + = #{offset VkDisplaySurfaceCreateInfoKHR, planeStackIndex} + + {-# INLINE readVkPlaneStackIndex #-} + readVkPlaneStackIndex p + = peekByteOff p #{offset VkDisplaySurfaceCreateInfoKHR, planeStackIndex} + + {-# INLINE writeVkPlaneStackIndex #-} + writeVkPlaneStackIndex p + = pokeByteOff p #{offset VkDisplaySurfaceCreateInfoKHR, planeStackIndex} + +instance {-# OVERLAPPING #-} + HasField "planeStackIndex" VkDisplaySurfaceCreateInfoKHR where + type FieldType "planeStackIndex" VkDisplaySurfaceCreateInfoKHR = + Word32 + type FieldOptional "planeStackIndex" VkDisplaySurfaceCreateInfoKHR + = 'False -- ' closing tick for hsc2hs + type FieldOffset "planeStackIndex" VkDisplaySurfaceCreateInfoKHR = + #{offset VkDisplaySurfaceCreateInfoKHR, planeStackIndex} + type FieldIsArray "planeStackIndex" VkDisplaySurfaceCreateInfoKHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDisplaySurfaceCreateInfoKHR, planeStackIndex} + +instance CanReadField "planeStackIndex" + VkDisplaySurfaceCreateInfoKHR + where + {-# INLINE getField #-} + getField = vkPlaneStackIndex + + {-# INLINE readField #-} + readField = readVkPlaneStackIndex + +instance CanWriteField "planeStackIndex" + VkDisplaySurfaceCreateInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkPlaneStackIndex + +instance {-# OVERLAPPING #-} + HasVkTransform VkDisplaySurfaceCreateInfoKHR where + type VkTransformMType VkDisplaySurfaceCreateInfoKHR = + VkSurfaceTransformFlagBitsKHR + + {-# NOINLINE vkTransform #-} + vkTransform x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDisplaySurfaceCreateInfoKHR, transform}) + + {-# INLINE vkTransformByteOffset #-} + vkTransformByteOffset ~_ + = #{offset VkDisplaySurfaceCreateInfoKHR, transform} + + {-# INLINE readVkTransform #-} + readVkTransform p + = peekByteOff p #{offset VkDisplaySurfaceCreateInfoKHR, transform} + + {-# INLINE writeVkTransform #-} + writeVkTransform p + = pokeByteOff p #{offset VkDisplaySurfaceCreateInfoKHR, transform} + +instance {-# OVERLAPPING #-} + HasField "transform" VkDisplaySurfaceCreateInfoKHR where + type FieldType "transform" VkDisplaySurfaceCreateInfoKHR = + VkSurfaceTransformFlagBitsKHR + type FieldOptional "transform" VkDisplaySurfaceCreateInfoKHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "transform" VkDisplaySurfaceCreateInfoKHR = + #{offset VkDisplaySurfaceCreateInfoKHR, transform} + type FieldIsArray "transform" VkDisplaySurfaceCreateInfoKHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDisplaySurfaceCreateInfoKHR, transform} + +instance CanReadField "transform" VkDisplaySurfaceCreateInfoKHR + where + {-# INLINE getField #-} + getField = vkTransform + + {-# INLINE readField #-} + readField = readVkTransform + +instance CanWriteField "transform" VkDisplaySurfaceCreateInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkTransform + +instance {-# OVERLAPPING #-} + HasVkGlobalAlpha VkDisplaySurfaceCreateInfoKHR where + type VkGlobalAlphaMType VkDisplaySurfaceCreateInfoKHR = + #{type float} + + {-# NOINLINE vkGlobalAlpha #-} + vkGlobalAlpha x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDisplaySurfaceCreateInfoKHR, globalAlpha}) + + {-# INLINE vkGlobalAlphaByteOffset #-} + vkGlobalAlphaByteOffset ~_ + = #{offset VkDisplaySurfaceCreateInfoKHR, globalAlpha} + + {-# INLINE readVkGlobalAlpha #-} + readVkGlobalAlpha p + = peekByteOff p #{offset VkDisplaySurfaceCreateInfoKHR, globalAlpha} + + {-# INLINE writeVkGlobalAlpha #-} + writeVkGlobalAlpha p + = pokeByteOff p #{offset VkDisplaySurfaceCreateInfoKHR, globalAlpha} + +instance {-# OVERLAPPING #-} + HasField "globalAlpha" VkDisplaySurfaceCreateInfoKHR where + type FieldType "globalAlpha" VkDisplaySurfaceCreateInfoKHR = + #{type float} + type FieldOptional "globalAlpha" VkDisplaySurfaceCreateInfoKHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "globalAlpha" VkDisplaySurfaceCreateInfoKHR = + #{offset VkDisplaySurfaceCreateInfoKHR, globalAlpha} + type FieldIsArray "globalAlpha" VkDisplaySurfaceCreateInfoKHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDisplaySurfaceCreateInfoKHR, globalAlpha} + +instance CanReadField "globalAlpha" VkDisplaySurfaceCreateInfoKHR + where + {-# INLINE getField #-} + getField = vkGlobalAlpha + + {-# INLINE readField #-} + readField = readVkGlobalAlpha + +instance CanWriteField "globalAlpha" VkDisplaySurfaceCreateInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkGlobalAlpha + +instance {-# OVERLAPPING #-} + HasVkAlphaMode VkDisplaySurfaceCreateInfoKHR where + type VkAlphaModeMType VkDisplaySurfaceCreateInfoKHR = + VkDisplayPlaneAlphaFlagBitsKHR + + {-# NOINLINE vkAlphaMode #-} + vkAlphaMode x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDisplaySurfaceCreateInfoKHR, alphaMode}) + + {-# INLINE vkAlphaModeByteOffset #-} + vkAlphaModeByteOffset ~_ + = #{offset VkDisplaySurfaceCreateInfoKHR, alphaMode} + + {-# INLINE readVkAlphaMode #-} + readVkAlphaMode p + = peekByteOff p #{offset VkDisplaySurfaceCreateInfoKHR, alphaMode} + + {-# INLINE writeVkAlphaMode #-} + writeVkAlphaMode p + = pokeByteOff p #{offset VkDisplaySurfaceCreateInfoKHR, alphaMode} + +instance {-# OVERLAPPING #-} + HasField "alphaMode" VkDisplaySurfaceCreateInfoKHR where + type FieldType "alphaMode" VkDisplaySurfaceCreateInfoKHR = + VkDisplayPlaneAlphaFlagBitsKHR + type FieldOptional "alphaMode" VkDisplaySurfaceCreateInfoKHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "alphaMode" VkDisplaySurfaceCreateInfoKHR = + #{offset VkDisplaySurfaceCreateInfoKHR, alphaMode} + type FieldIsArray "alphaMode" VkDisplaySurfaceCreateInfoKHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDisplaySurfaceCreateInfoKHR, alphaMode} + +instance CanReadField "alphaMode" VkDisplaySurfaceCreateInfoKHR + where + {-# INLINE getField #-} + getField = vkAlphaMode + + {-# INLINE readField #-} + readField = readVkAlphaMode + +instance CanWriteField "alphaMode" VkDisplaySurfaceCreateInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkAlphaMode + +instance {-# OVERLAPPING #-} + HasVkImageExtent VkDisplaySurfaceCreateInfoKHR where + type VkImageExtentMType VkDisplaySurfaceCreateInfoKHR = VkExtent2D + + {-# NOINLINE vkImageExtent #-} + vkImageExtent x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDisplaySurfaceCreateInfoKHR, imageExtent}) + + {-# INLINE vkImageExtentByteOffset #-} + vkImageExtentByteOffset ~_ + = #{offset VkDisplaySurfaceCreateInfoKHR, imageExtent} + + {-# INLINE readVkImageExtent #-} + readVkImageExtent p + = peekByteOff p #{offset VkDisplaySurfaceCreateInfoKHR, imageExtent} + + {-# INLINE writeVkImageExtent #-} + writeVkImageExtent p + = pokeByteOff p #{offset VkDisplaySurfaceCreateInfoKHR, imageExtent} + +instance {-# OVERLAPPING #-} + HasField "imageExtent" VkDisplaySurfaceCreateInfoKHR where + type FieldType "imageExtent" VkDisplaySurfaceCreateInfoKHR = + VkExtent2D + type FieldOptional "imageExtent" VkDisplaySurfaceCreateInfoKHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "imageExtent" VkDisplaySurfaceCreateInfoKHR = + #{offset VkDisplaySurfaceCreateInfoKHR, imageExtent} + type FieldIsArray "imageExtent" VkDisplaySurfaceCreateInfoKHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDisplaySurfaceCreateInfoKHR, imageExtent} + +instance CanReadField "imageExtent" VkDisplaySurfaceCreateInfoKHR + where + {-# INLINE getField #-} + getField = vkImageExtent + + {-# INLINE readField #-} + readField = readVkImageExtent + +instance CanWriteField "imageExtent" VkDisplaySurfaceCreateInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkImageExtent + +instance Show VkDisplaySurfaceCreateInfoKHR where + showsPrec d x + = showString "VkDisplaySurfaceCreateInfoKHR {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkFlags = " . + showsPrec d (vkFlags x) . + showString ", " . + showString "vkDisplayMode = " . + showsPrec d (vkDisplayMode x) . + showString ", " . + showString "vkPlaneIndex = " . + showsPrec d (vkPlaneIndex x) . + showString ", " . + showString "vkPlaneStackIndex = " . + showsPrec d (vkPlaneStackIndex x) . + showString ", " . + showString "vkTransform = " . + showsPrec d (vkTransform x) . + showString ", " . + showString "vkGlobalAlpha = " . + showsPrec d (vkGlobalAlpha x) . + showString ", " . + showString "vkAlphaMode = " . + showsPrec d (vkAlphaMode x) . + showString ", " . + showString "vkImageExtent = " . + showsPrec d (vkImageExtent x) + . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkDrawIndexedIndirectCommand.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkDrawIndexedIndirectCommand.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkDrawIndexedIndirectCommand.hsc @@ -0,0 +1,353 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkDrawIndexedIndirectCommand + (VkDrawIndexedIndirectCommand(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkDrawIndexedIndirectCommand { +-- > uint32_t indexCount; +-- > uint32_t instanceCount; +-- > uint32_t firstIndex; +-- > int32_t vertexOffset; +-- > uint32_t firstInstance; +-- > } VkDrawIndexedIndirectCommand; +-- +-- +data VkDrawIndexedIndirectCommand = VkDrawIndexedIndirectCommand## Addr## + ByteArray## + +instance Eq VkDrawIndexedIndirectCommand where + (VkDrawIndexedIndirectCommand## a _) == + x@(VkDrawIndexedIndirectCommand## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkDrawIndexedIndirectCommand where + (VkDrawIndexedIndirectCommand## a _) `compare` + x@(VkDrawIndexedIndirectCommand## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkDrawIndexedIndirectCommand where + sizeOf ~_ = #{size VkDrawIndexedIndirectCommand} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkDrawIndexedIndirectCommand} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkDrawIndexedIndirectCommand where + unsafeAddr (VkDrawIndexedIndirectCommand## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkDrawIndexedIndirectCommand## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkDrawIndexedIndirectCommand## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkDrawIndexedIndirectCommand where + type StructFields VkDrawIndexedIndirectCommand = + '["indexCount", "instanceCount", "firstIndex", "vertexOffset", -- ' closing tick for hsc2hs + "firstInstance"] + type CUnionType VkDrawIndexedIndirectCommand = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkDrawIndexedIndirectCommand = 'False -- ' closing tick for hsc2hs + type StructExtends VkDrawIndexedIndirectCommand = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkIndexCount VkDrawIndexedIndirectCommand where + type VkIndexCountMType VkDrawIndexedIndirectCommand = Word32 + + {-# NOINLINE vkIndexCount #-} + vkIndexCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDrawIndexedIndirectCommand, indexCount}) + + {-# INLINE vkIndexCountByteOffset #-} + vkIndexCountByteOffset ~_ + = #{offset VkDrawIndexedIndirectCommand, indexCount} + + {-# INLINE readVkIndexCount #-} + readVkIndexCount p + = peekByteOff p #{offset VkDrawIndexedIndirectCommand, indexCount} + + {-# INLINE writeVkIndexCount #-} + writeVkIndexCount p + = pokeByteOff p #{offset VkDrawIndexedIndirectCommand, indexCount} + +instance {-# OVERLAPPING #-} + HasField "indexCount" VkDrawIndexedIndirectCommand where + type FieldType "indexCount" VkDrawIndexedIndirectCommand = Word32 + type FieldOptional "indexCount" VkDrawIndexedIndirectCommand = + 'False -- ' closing tick for hsc2hs + type FieldOffset "indexCount" VkDrawIndexedIndirectCommand = + #{offset VkDrawIndexedIndirectCommand, indexCount} + type FieldIsArray "indexCount" VkDrawIndexedIndirectCommand = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDrawIndexedIndirectCommand, indexCount} + +instance CanReadField "indexCount" VkDrawIndexedIndirectCommand + where + {-# INLINE getField #-} + getField = vkIndexCount + + {-# INLINE readField #-} + readField = readVkIndexCount + +instance CanWriteField "indexCount" VkDrawIndexedIndirectCommand + where + {-# INLINE writeField #-} + writeField = writeVkIndexCount + +instance {-# OVERLAPPING #-} + HasVkInstanceCount VkDrawIndexedIndirectCommand where + type VkInstanceCountMType VkDrawIndexedIndirectCommand = Word32 + + {-# NOINLINE vkInstanceCount #-} + vkInstanceCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDrawIndexedIndirectCommand, instanceCount}) + + {-# INLINE vkInstanceCountByteOffset #-} + vkInstanceCountByteOffset ~_ + = #{offset VkDrawIndexedIndirectCommand, instanceCount} + + {-# INLINE readVkInstanceCount #-} + readVkInstanceCount p + = peekByteOff p #{offset VkDrawIndexedIndirectCommand, instanceCount} + + {-# INLINE writeVkInstanceCount #-} + writeVkInstanceCount p + = pokeByteOff p #{offset VkDrawIndexedIndirectCommand, instanceCount} + +instance {-# OVERLAPPING #-} + HasField "instanceCount" VkDrawIndexedIndirectCommand where + type FieldType "instanceCount" VkDrawIndexedIndirectCommand = + Word32 + type FieldOptional "instanceCount" VkDrawIndexedIndirectCommand = + 'False -- ' closing tick for hsc2hs + type FieldOffset "instanceCount" VkDrawIndexedIndirectCommand = + #{offset VkDrawIndexedIndirectCommand, instanceCount} + type FieldIsArray "instanceCount" VkDrawIndexedIndirectCommand = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDrawIndexedIndirectCommand, instanceCount} + +instance CanReadField "instanceCount" VkDrawIndexedIndirectCommand + where + {-# INLINE getField #-} + getField = vkInstanceCount + + {-# INLINE readField #-} + readField = readVkInstanceCount + +instance CanWriteField "instanceCount" VkDrawIndexedIndirectCommand + where + {-# INLINE writeField #-} + writeField = writeVkInstanceCount + +instance {-# OVERLAPPING #-} + HasVkFirstIndex VkDrawIndexedIndirectCommand where + type VkFirstIndexMType VkDrawIndexedIndirectCommand = Word32 + + {-# NOINLINE vkFirstIndex #-} + vkFirstIndex x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDrawIndexedIndirectCommand, firstIndex}) + + {-# INLINE vkFirstIndexByteOffset #-} + vkFirstIndexByteOffset ~_ + = #{offset VkDrawIndexedIndirectCommand, firstIndex} + + {-# INLINE readVkFirstIndex #-} + readVkFirstIndex p + = peekByteOff p #{offset VkDrawIndexedIndirectCommand, firstIndex} + + {-# INLINE writeVkFirstIndex #-} + writeVkFirstIndex p + = pokeByteOff p #{offset VkDrawIndexedIndirectCommand, firstIndex} + +instance {-# OVERLAPPING #-} + HasField "firstIndex" VkDrawIndexedIndirectCommand where + type FieldType "firstIndex" VkDrawIndexedIndirectCommand = Word32 + type FieldOptional "firstIndex" VkDrawIndexedIndirectCommand = + 'False -- ' closing tick for hsc2hs + type FieldOffset "firstIndex" VkDrawIndexedIndirectCommand = + #{offset VkDrawIndexedIndirectCommand, firstIndex} + type FieldIsArray "firstIndex" VkDrawIndexedIndirectCommand = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDrawIndexedIndirectCommand, firstIndex} + +instance CanReadField "firstIndex" VkDrawIndexedIndirectCommand + where + {-# INLINE getField #-} + getField = vkFirstIndex + + {-# INLINE readField #-} + readField = readVkFirstIndex + +instance CanWriteField "firstIndex" VkDrawIndexedIndirectCommand + where + {-# INLINE writeField #-} + writeField = writeVkFirstIndex + +instance {-# OVERLAPPING #-} + HasVkVertexOffset VkDrawIndexedIndirectCommand where + type VkVertexOffsetMType VkDrawIndexedIndirectCommand = Int32 + + {-# NOINLINE vkVertexOffset #-} + vkVertexOffset x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDrawIndexedIndirectCommand, vertexOffset}) + + {-# INLINE vkVertexOffsetByteOffset #-} + vkVertexOffsetByteOffset ~_ + = #{offset VkDrawIndexedIndirectCommand, vertexOffset} + + {-# INLINE readVkVertexOffset #-} + readVkVertexOffset p + = peekByteOff p #{offset VkDrawIndexedIndirectCommand, vertexOffset} + + {-# INLINE writeVkVertexOffset #-} + writeVkVertexOffset p + = pokeByteOff p #{offset VkDrawIndexedIndirectCommand, vertexOffset} + +instance {-# OVERLAPPING #-} + HasField "vertexOffset" VkDrawIndexedIndirectCommand where + type FieldType "vertexOffset" VkDrawIndexedIndirectCommand = Int32 + type FieldOptional "vertexOffset" VkDrawIndexedIndirectCommand = + 'False -- ' closing tick for hsc2hs + type FieldOffset "vertexOffset" VkDrawIndexedIndirectCommand = + #{offset VkDrawIndexedIndirectCommand, vertexOffset} + type FieldIsArray "vertexOffset" VkDrawIndexedIndirectCommand = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDrawIndexedIndirectCommand, vertexOffset} + +instance CanReadField "vertexOffset" VkDrawIndexedIndirectCommand + where + {-# INLINE getField #-} + getField = vkVertexOffset + + {-# INLINE readField #-} + readField = readVkVertexOffset + +instance CanWriteField "vertexOffset" VkDrawIndexedIndirectCommand + where + {-# INLINE writeField #-} + writeField = writeVkVertexOffset + +instance {-# OVERLAPPING #-} + HasVkFirstInstance VkDrawIndexedIndirectCommand where + type VkFirstInstanceMType VkDrawIndexedIndirectCommand = Word32 + + {-# NOINLINE vkFirstInstance #-} + vkFirstInstance x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDrawIndexedIndirectCommand, firstInstance}) + + {-# INLINE vkFirstInstanceByteOffset #-} + vkFirstInstanceByteOffset ~_ + = #{offset VkDrawIndexedIndirectCommand, firstInstance} + + {-# INLINE readVkFirstInstance #-} + readVkFirstInstance p + = peekByteOff p #{offset VkDrawIndexedIndirectCommand, firstInstance} + + {-# INLINE writeVkFirstInstance #-} + writeVkFirstInstance p + = pokeByteOff p #{offset VkDrawIndexedIndirectCommand, firstInstance} + +instance {-# OVERLAPPING #-} + HasField "firstInstance" VkDrawIndexedIndirectCommand where + type FieldType "firstInstance" VkDrawIndexedIndirectCommand = + Word32 + type FieldOptional "firstInstance" VkDrawIndexedIndirectCommand = + 'False -- ' closing tick for hsc2hs + type FieldOffset "firstInstance" VkDrawIndexedIndirectCommand = + #{offset VkDrawIndexedIndirectCommand, firstInstance} + type FieldIsArray "firstInstance" VkDrawIndexedIndirectCommand = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDrawIndexedIndirectCommand, firstInstance} + +instance CanReadField "firstInstance" VkDrawIndexedIndirectCommand + where + {-# INLINE getField #-} + getField = vkFirstInstance + + {-# INLINE readField #-} + readField = readVkFirstInstance + +instance CanWriteField "firstInstance" VkDrawIndexedIndirectCommand + where + {-# INLINE writeField #-} + writeField = writeVkFirstInstance + +instance Show VkDrawIndexedIndirectCommand where + showsPrec d x + = showString "VkDrawIndexedIndirectCommand {" . + showString "vkIndexCount = " . + showsPrec d (vkIndexCount x) . + showString ", " . + showString "vkInstanceCount = " . + showsPrec d (vkInstanceCount x) . + showString ", " . + showString "vkFirstIndex = " . + showsPrec d (vkFirstIndex x) . + showString ", " . + showString "vkVertexOffset = " . + showsPrec d (vkVertexOffset x) . + showString ", " . + showString "vkFirstInstance = " . + showsPrec d (vkFirstInstance x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkDrawIndirectCommand.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkDrawIndirectCommand.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkDrawIndirectCommand.hsc @@ -0,0 +1,275 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkDrawIndirectCommand + (VkDrawIndirectCommand(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkDrawIndirectCommand { +-- > uint32_t vertexCount; +-- > uint32_t instanceCount; +-- > uint32_t firstVertex; +-- > uint32_t firstInstance; +-- > } VkDrawIndirectCommand; +-- +-- +data VkDrawIndirectCommand = VkDrawIndirectCommand## Addr## + ByteArray## + +instance Eq VkDrawIndirectCommand where + (VkDrawIndirectCommand## a _) == x@(VkDrawIndirectCommand## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkDrawIndirectCommand where + (VkDrawIndirectCommand## a _) `compare` + x@(VkDrawIndirectCommand## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkDrawIndirectCommand where + sizeOf ~_ = #{size VkDrawIndirectCommand} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkDrawIndirectCommand} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkDrawIndirectCommand where + unsafeAddr (VkDrawIndirectCommand## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkDrawIndirectCommand## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkDrawIndirectCommand## (plusAddr## (byteArrayContents## b) off) b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkDrawIndirectCommand where + type StructFields VkDrawIndirectCommand = + '["vertexCount", "instanceCount", "firstVertex", "firstInstance"] -- ' closing tick for hsc2hs + type CUnionType VkDrawIndirectCommand = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkDrawIndirectCommand = 'False -- ' closing tick for hsc2hs + type StructExtends VkDrawIndirectCommand = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkVertexCount VkDrawIndirectCommand + where + type VkVertexCountMType VkDrawIndirectCommand = Word32 + + {-# NOINLINE vkVertexCount #-} + vkVertexCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDrawIndirectCommand, vertexCount}) + + {-# INLINE vkVertexCountByteOffset #-} + vkVertexCountByteOffset ~_ + = #{offset VkDrawIndirectCommand, vertexCount} + + {-# INLINE readVkVertexCount #-} + readVkVertexCount p + = peekByteOff p #{offset VkDrawIndirectCommand, vertexCount} + + {-# INLINE writeVkVertexCount #-} + writeVkVertexCount p + = pokeByteOff p #{offset VkDrawIndirectCommand, vertexCount} + +instance {-# OVERLAPPING #-} + HasField "vertexCount" VkDrawIndirectCommand where + type FieldType "vertexCount" VkDrawIndirectCommand = Word32 + type FieldOptional "vertexCount" VkDrawIndirectCommand = 'False -- ' closing tick for hsc2hs + type FieldOffset "vertexCount" VkDrawIndirectCommand = + #{offset VkDrawIndirectCommand, vertexCount} + type FieldIsArray "vertexCount" VkDrawIndirectCommand = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDrawIndirectCommand, vertexCount} + +instance CanReadField "vertexCount" VkDrawIndirectCommand where + {-# INLINE getField #-} + getField = vkVertexCount + + {-# INLINE readField #-} + readField = readVkVertexCount + +instance CanWriteField "vertexCount" VkDrawIndirectCommand where + {-# INLINE writeField #-} + writeField = writeVkVertexCount + +instance {-# OVERLAPPING #-} + HasVkInstanceCount VkDrawIndirectCommand where + type VkInstanceCountMType VkDrawIndirectCommand = Word32 + + {-# NOINLINE vkInstanceCount #-} + vkInstanceCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDrawIndirectCommand, instanceCount}) + + {-# INLINE vkInstanceCountByteOffset #-} + vkInstanceCountByteOffset ~_ + = #{offset VkDrawIndirectCommand, instanceCount} + + {-# INLINE readVkInstanceCount #-} + readVkInstanceCount p + = peekByteOff p #{offset VkDrawIndirectCommand, instanceCount} + + {-# INLINE writeVkInstanceCount #-} + writeVkInstanceCount p + = pokeByteOff p #{offset VkDrawIndirectCommand, instanceCount} + +instance {-# OVERLAPPING #-} + HasField "instanceCount" VkDrawIndirectCommand where + type FieldType "instanceCount" VkDrawIndirectCommand = Word32 + type FieldOptional "instanceCount" VkDrawIndirectCommand = 'False -- ' closing tick for hsc2hs + type FieldOffset "instanceCount" VkDrawIndirectCommand = + #{offset VkDrawIndirectCommand, instanceCount} + type FieldIsArray "instanceCount" VkDrawIndirectCommand = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDrawIndirectCommand, instanceCount} + +instance CanReadField "instanceCount" VkDrawIndirectCommand where + {-# INLINE getField #-} + getField = vkInstanceCount + + {-# INLINE readField #-} + readField = readVkInstanceCount + +instance CanWriteField "instanceCount" VkDrawIndirectCommand where + {-# INLINE writeField #-} + writeField = writeVkInstanceCount + +instance {-# OVERLAPPING #-} HasVkFirstVertex VkDrawIndirectCommand + where + type VkFirstVertexMType VkDrawIndirectCommand = Word32 + + {-# NOINLINE vkFirstVertex #-} + vkFirstVertex x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDrawIndirectCommand, firstVertex}) + + {-# INLINE vkFirstVertexByteOffset #-} + vkFirstVertexByteOffset ~_ + = #{offset VkDrawIndirectCommand, firstVertex} + + {-# INLINE readVkFirstVertex #-} + readVkFirstVertex p + = peekByteOff p #{offset VkDrawIndirectCommand, firstVertex} + + {-# INLINE writeVkFirstVertex #-} + writeVkFirstVertex p + = pokeByteOff p #{offset VkDrawIndirectCommand, firstVertex} + +instance {-# OVERLAPPING #-} + HasField "firstVertex" VkDrawIndirectCommand where + type FieldType "firstVertex" VkDrawIndirectCommand = Word32 + type FieldOptional "firstVertex" VkDrawIndirectCommand = 'False -- ' closing tick for hsc2hs + type FieldOffset "firstVertex" VkDrawIndirectCommand = + #{offset VkDrawIndirectCommand, firstVertex} + type FieldIsArray "firstVertex" VkDrawIndirectCommand = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDrawIndirectCommand, firstVertex} + +instance CanReadField "firstVertex" VkDrawIndirectCommand where + {-# INLINE getField #-} + getField = vkFirstVertex + + {-# INLINE readField #-} + readField = readVkFirstVertex + +instance CanWriteField "firstVertex" VkDrawIndirectCommand where + {-# INLINE writeField #-} + writeField = writeVkFirstVertex + +instance {-# OVERLAPPING #-} + HasVkFirstInstance VkDrawIndirectCommand where + type VkFirstInstanceMType VkDrawIndirectCommand = Word32 + + {-# NOINLINE vkFirstInstance #-} + vkFirstInstance x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkDrawIndirectCommand, firstInstance}) + + {-# INLINE vkFirstInstanceByteOffset #-} + vkFirstInstanceByteOffset ~_ + = #{offset VkDrawIndirectCommand, firstInstance} + + {-# INLINE readVkFirstInstance #-} + readVkFirstInstance p + = peekByteOff p #{offset VkDrawIndirectCommand, firstInstance} + + {-# INLINE writeVkFirstInstance #-} + writeVkFirstInstance p + = pokeByteOff p #{offset VkDrawIndirectCommand, firstInstance} + +instance {-# OVERLAPPING #-} + HasField "firstInstance" VkDrawIndirectCommand where + type FieldType "firstInstance" VkDrawIndirectCommand = Word32 + type FieldOptional "firstInstance" VkDrawIndirectCommand = 'False -- ' closing tick for hsc2hs + type FieldOffset "firstInstance" VkDrawIndirectCommand = + #{offset VkDrawIndirectCommand, firstInstance} + type FieldIsArray "firstInstance" VkDrawIndirectCommand = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkDrawIndirectCommand, firstInstance} + +instance CanReadField "firstInstance" VkDrawIndirectCommand where + {-# INLINE getField #-} + getField = vkFirstInstance + + {-# INLINE readField #-} + readField = readVkFirstInstance + +instance CanWriteField "firstInstance" VkDrawIndirectCommand where + {-# INLINE writeField #-} + writeField = writeVkFirstInstance + +instance Show VkDrawIndirectCommand where + showsPrec d x + = showString "VkDrawIndirectCommand {" . + showString "vkVertexCount = " . + showsPrec d (vkVertexCount x) . + showString ", " . + showString "vkInstanceCount = " . + showsPrec d (vkInstanceCount x) . + showString ", " . + showString "vkFirstVertex = " . + showsPrec d (vkFirstVertex x) . + showString ", " . + showString "vkFirstInstance = " . + showsPrec d (vkFirstInstance x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkEventCreateInfo.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkEventCreateInfo.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkEventCreateInfo.hsc @@ -0,0 +1,217 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkEventCreateInfo + (VkEventCreateInfo(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Bitmasks (VkEventCreateFlags) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkEventCreateInfo { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkEventCreateFlags flags; +-- > } VkEventCreateInfo; +-- +-- +data VkEventCreateInfo = VkEventCreateInfo## Addr## ByteArray## + +instance Eq VkEventCreateInfo where + (VkEventCreateInfo## a _) == x@(VkEventCreateInfo## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkEventCreateInfo where + (VkEventCreateInfo## a _) `compare` x@(VkEventCreateInfo## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkEventCreateInfo where + sizeOf ~_ = #{size VkEventCreateInfo} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkEventCreateInfo} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkEventCreateInfo where + unsafeAddr (VkEventCreateInfo## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkEventCreateInfo## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkEventCreateInfo## (plusAddr## (byteArrayContents## b) off) b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkEventCreateInfo where + type StructFields VkEventCreateInfo = '["sType", "pNext", "flags"] -- ' closing tick for hsc2hs + type CUnionType VkEventCreateInfo = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkEventCreateInfo = 'False -- ' closing tick for hsc2hs + type StructExtends VkEventCreateInfo = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkSType VkEventCreateInfo where + type VkSTypeMType VkEventCreateInfo = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkEventCreateInfo, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkEventCreateInfo, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkEventCreateInfo, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkEventCreateInfo, sType} + +instance {-# OVERLAPPING #-} HasField "sType" VkEventCreateInfo + where + type FieldType "sType" VkEventCreateInfo = VkStructureType + type FieldOptional "sType" VkEventCreateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkEventCreateInfo = + #{offset VkEventCreateInfo, sType} + type FieldIsArray "sType" VkEventCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkEventCreateInfo, sType} + +instance CanReadField "sType" VkEventCreateInfo where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkEventCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} HasVkPNext VkEventCreateInfo where + type VkPNextMType VkEventCreateInfo = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkEventCreateInfo, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkEventCreateInfo, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkEventCreateInfo, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkEventCreateInfo, pNext} + +instance {-# OVERLAPPING #-} HasField "pNext" VkEventCreateInfo + where + type FieldType "pNext" VkEventCreateInfo = Ptr Void + type FieldOptional "pNext" VkEventCreateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkEventCreateInfo = + #{offset VkEventCreateInfo, pNext} + type FieldIsArray "pNext" VkEventCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkEventCreateInfo, pNext} + +instance CanReadField "pNext" VkEventCreateInfo where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkEventCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} HasVkFlags VkEventCreateInfo where + type VkFlagsMType VkEventCreateInfo = VkEventCreateFlags + + {-# NOINLINE vkFlags #-} + vkFlags x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkEventCreateInfo, flags}) + + {-# INLINE vkFlagsByteOffset #-} + vkFlagsByteOffset ~_ + = #{offset VkEventCreateInfo, flags} + + {-# INLINE readVkFlags #-} + readVkFlags p + = peekByteOff p #{offset VkEventCreateInfo, flags} + + {-# INLINE writeVkFlags #-} + writeVkFlags p + = pokeByteOff p #{offset VkEventCreateInfo, flags} + +instance {-# OVERLAPPING #-} HasField "flags" VkEventCreateInfo + where + type FieldType "flags" VkEventCreateInfo = VkEventCreateFlags + type FieldOptional "flags" VkEventCreateInfo = 'True -- ' closing tick for hsc2hs + type FieldOffset "flags" VkEventCreateInfo = + #{offset VkEventCreateInfo, flags} + type FieldIsArray "flags" VkEventCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkEventCreateInfo, flags} + +instance CanReadField "flags" VkEventCreateInfo where + {-# INLINE getField #-} + getField = vkFlags + + {-# INLINE readField #-} + readField = readVkFlags + +instance CanWriteField "flags" VkEventCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkFlags + +instance Show VkEventCreateInfo where + showsPrec d x + = showString "VkEventCreateInfo {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkFlags = " . showsPrec d (vkFlags x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkExportFenceCreateInfoKHR.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkExportFenceCreateInfoKHR.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkExportFenceCreateInfoKHR.hsc @@ -0,0 +1,235 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkExportFenceCreateInfoKHR + (VkExportFenceCreateInfoKHR(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkExternalFenceHandleTypeFlagsKHR (VkExternalFenceHandleTypeFlagsKHR) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Struct.VkFenceCreateInfo (VkFenceCreateInfo) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkExportFenceCreateInfoKHR { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkExternalFenceHandleTypeFlagsKHR handleTypes; +-- > } VkExportFenceCreateInfoKHR; +-- +-- +data VkExportFenceCreateInfoKHR = VkExportFenceCreateInfoKHR## Addr## + ByteArray## + +instance Eq VkExportFenceCreateInfoKHR where + (VkExportFenceCreateInfoKHR## a _) == + x@(VkExportFenceCreateInfoKHR## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkExportFenceCreateInfoKHR where + (VkExportFenceCreateInfoKHR## a _) `compare` + x@(VkExportFenceCreateInfoKHR## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkExportFenceCreateInfoKHR where + sizeOf ~_ = #{size VkExportFenceCreateInfoKHR} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkExportFenceCreateInfoKHR} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkExportFenceCreateInfoKHR where + unsafeAddr (VkExportFenceCreateInfoKHR## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkExportFenceCreateInfoKHR## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkExportFenceCreateInfoKHR## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkExportFenceCreateInfoKHR where + type StructFields VkExportFenceCreateInfoKHR = + '["sType", "pNext", "handleTypes"] -- ' closing tick for hsc2hs + type CUnionType VkExportFenceCreateInfoKHR = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkExportFenceCreateInfoKHR = 'False -- ' closing tick for hsc2hs + type StructExtends VkExportFenceCreateInfoKHR = + '[VkFenceCreateInfo] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkSType VkExportFenceCreateInfoKHR + where + type VkSTypeMType VkExportFenceCreateInfoKHR = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkExportFenceCreateInfoKHR, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkExportFenceCreateInfoKHR, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkExportFenceCreateInfoKHR, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkExportFenceCreateInfoKHR, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkExportFenceCreateInfoKHR where + type FieldType "sType" VkExportFenceCreateInfoKHR = VkStructureType + type FieldOptional "sType" VkExportFenceCreateInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkExportFenceCreateInfoKHR = + #{offset VkExportFenceCreateInfoKHR, sType} + type FieldIsArray "sType" VkExportFenceCreateInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkExportFenceCreateInfoKHR, sType} + +instance CanReadField "sType" VkExportFenceCreateInfoKHR where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkExportFenceCreateInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} HasVkPNext VkExportFenceCreateInfoKHR + where + type VkPNextMType VkExportFenceCreateInfoKHR = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkExportFenceCreateInfoKHR, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkExportFenceCreateInfoKHR, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkExportFenceCreateInfoKHR, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkExportFenceCreateInfoKHR, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkExportFenceCreateInfoKHR where + type FieldType "pNext" VkExportFenceCreateInfoKHR = Ptr Void + type FieldOptional "pNext" VkExportFenceCreateInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkExportFenceCreateInfoKHR = + #{offset VkExportFenceCreateInfoKHR, pNext} + type FieldIsArray "pNext" VkExportFenceCreateInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkExportFenceCreateInfoKHR, pNext} + +instance CanReadField "pNext" VkExportFenceCreateInfoKHR where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkExportFenceCreateInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkHandleTypes VkExportFenceCreateInfoKHR where + type VkHandleTypesMType VkExportFenceCreateInfoKHR = + VkExternalFenceHandleTypeFlagsKHR + + {-# NOINLINE vkHandleTypes #-} + vkHandleTypes x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkExportFenceCreateInfoKHR, handleTypes}) + + {-# INLINE vkHandleTypesByteOffset #-} + vkHandleTypesByteOffset ~_ + = #{offset VkExportFenceCreateInfoKHR, handleTypes} + + {-# INLINE readVkHandleTypes #-} + readVkHandleTypes p + = peekByteOff p #{offset VkExportFenceCreateInfoKHR, handleTypes} + + {-# INLINE writeVkHandleTypes #-} + writeVkHandleTypes p + = pokeByteOff p #{offset VkExportFenceCreateInfoKHR, handleTypes} + +instance {-# OVERLAPPING #-} + HasField "handleTypes" VkExportFenceCreateInfoKHR where + type FieldType "handleTypes" VkExportFenceCreateInfoKHR = + VkExternalFenceHandleTypeFlagsKHR + type FieldOptional "handleTypes" VkExportFenceCreateInfoKHR = 'True -- ' closing tick for hsc2hs + type FieldOffset "handleTypes" VkExportFenceCreateInfoKHR = + #{offset VkExportFenceCreateInfoKHR, handleTypes} + type FieldIsArray "handleTypes" VkExportFenceCreateInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkExportFenceCreateInfoKHR, handleTypes} + +instance CanReadField "handleTypes" VkExportFenceCreateInfoKHR + where + {-# INLINE getField #-} + getField = vkHandleTypes + + {-# INLINE readField #-} + readField = readVkHandleTypes + +instance CanWriteField "handleTypes" VkExportFenceCreateInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkHandleTypes + +instance Show VkExportFenceCreateInfoKHR where + showsPrec d x + = showString "VkExportFenceCreateInfoKHR {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkHandleTypes = " . + showsPrec d (vkHandleTypes x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkExportFenceWin32HandleInfoKHR.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkExportFenceWin32HandleInfoKHR.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkExportFenceWin32HandleInfoKHR.hsc @@ -0,0 +1,347 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkExportFenceWin32HandleInfoKHR + (VkExportFenceWin32HandleInfoKHR(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Include (DWORD, LPCWSTR, SECURITY_ATTRIBUTES) +import Graphics.Vulkan.Types.Struct.VkFenceCreateInfo (VkFenceCreateInfo) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkExportFenceWin32HandleInfoKHR { +-- > VkStructureType sType; +-- > const void* pNext; +-- > const SECURITY_ATTRIBUTES* pAttributes; +-- > DWORD dwAccess; +-- > LPCWSTR name; +-- > } VkExportFenceWin32HandleInfoKHR; +-- +-- +data VkExportFenceWin32HandleInfoKHR = VkExportFenceWin32HandleInfoKHR## Addr## + ByteArray## + +instance Eq VkExportFenceWin32HandleInfoKHR where + (VkExportFenceWin32HandleInfoKHR## a _) == + x@(VkExportFenceWin32HandleInfoKHR## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkExportFenceWin32HandleInfoKHR where + (VkExportFenceWin32HandleInfoKHR## a _) `compare` + x@(VkExportFenceWin32HandleInfoKHR## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkExportFenceWin32HandleInfoKHR where + sizeOf ~_ = #{size VkExportFenceWin32HandleInfoKHR} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkExportFenceWin32HandleInfoKHR} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkExportFenceWin32HandleInfoKHR where + unsafeAddr (VkExportFenceWin32HandleInfoKHR## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkExportFenceWin32HandleInfoKHR## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkExportFenceWin32HandleInfoKHR## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkExportFenceWin32HandleInfoKHR where + type StructFields VkExportFenceWin32HandleInfoKHR = + '["sType", "pNext", "pAttributes", "dwAccess", "name"] -- ' closing tick for hsc2hs + type CUnionType VkExportFenceWin32HandleInfoKHR = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkExportFenceWin32HandleInfoKHR = 'False -- ' closing tick for hsc2hs + type StructExtends VkExportFenceWin32HandleInfoKHR = + '[VkFenceCreateInfo] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkExportFenceWin32HandleInfoKHR where + type VkSTypeMType VkExportFenceWin32HandleInfoKHR = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkExportFenceWin32HandleInfoKHR, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkExportFenceWin32HandleInfoKHR, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkExportFenceWin32HandleInfoKHR, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkExportFenceWin32HandleInfoKHR, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkExportFenceWin32HandleInfoKHR where + type FieldType "sType" VkExportFenceWin32HandleInfoKHR = + VkStructureType + type FieldOptional "sType" VkExportFenceWin32HandleInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkExportFenceWin32HandleInfoKHR = + #{offset VkExportFenceWin32HandleInfoKHR, sType} + type FieldIsArray "sType" VkExportFenceWin32HandleInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkExportFenceWin32HandleInfoKHR, sType} + +instance CanReadField "sType" VkExportFenceWin32HandleInfoKHR where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkExportFenceWin32HandleInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkExportFenceWin32HandleInfoKHR where + type VkPNextMType VkExportFenceWin32HandleInfoKHR = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkExportFenceWin32HandleInfoKHR, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkExportFenceWin32HandleInfoKHR, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkExportFenceWin32HandleInfoKHR, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkExportFenceWin32HandleInfoKHR, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkExportFenceWin32HandleInfoKHR where + type FieldType "pNext" VkExportFenceWin32HandleInfoKHR = Ptr Void + type FieldOptional "pNext" VkExportFenceWin32HandleInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkExportFenceWin32HandleInfoKHR = + #{offset VkExportFenceWin32HandleInfoKHR, pNext} + type FieldIsArray "pNext" VkExportFenceWin32HandleInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkExportFenceWin32HandleInfoKHR, pNext} + +instance CanReadField "pNext" VkExportFenceWin32HandleInfoKHR where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkExportFenceWin32HandleInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkPAttributes VkExportFenceWin32HandleInfoKHR where + type VkPAttributesMType VkExportFenceWin32HandleInfoKHR = + Ptr SECURITY_ATTRIBUTES + + {-# NOINLINE vkPAttributes #-} + vkPAttributes x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkExportFenceWin32HandleInfoKHR, pAttributes}) + + {-# INLINE vkPAttributesByteOffset #-} + vkPAttributesByteOffset ~_ + = #{offset VkExportFenceWin32HandleInfoKHR, pAttributes} + + {-# INLINE readVkPAttributes #-} + readVkPAttributes p + = peekByteOff p #{offset VkExportFenceWin32HandleInfoKHR, pAttributes} + + {-# INLINE writeVkPAttributes #-} + writeVkPAttributes p + = pokeByteOff p #{offset VkExportFenceWin32HandleInfoKHR, pAttributes} + +instance {-# OVERLAPPING #-} + HasField "pAttributes" VkExportFenceWin32HandleInfoKHR where + type FieldType "pAttributes" VkExportFenceWin32HandleInfoKHR = + Ptr SECURITY_ATTRIBUTES + type FieldOptional "pAttributes" VkExportFenceWin32HandleInfoKHR = + 'True -- ' closing tick for hsc2hs + type FieldOffset "pAttributes" VkExportFenceWin32HandleInfoKHR = + #{offset VkExportFenceWin32HandleInfoKHR, pAttributes} + type FieldIsArray "pAttributes" VkExportFenceWin32HandleInfoKHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkExportFenceWin32HandleInfoKHR, pAttributes} + +instance CanReadField "pAttributes" VkExportFenceWin32HandleInfoKHR + where + {-# INLINE getField #-} + getField = vkPAttributes + + {-# INLINE readField #-} + readField = readVkPAttributes + +instance CanWriteField "pAttributes" + VkExportFenceWin32HandleInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkPAttributes + +instance {-# OVERLAPPING #-} + HasVkDwAccess VkExportFenceWin32HandleInfoKHR where + type VkDwAccessMType VkExportFenceWin32HandleInfoKHR = DWORD + + {-# NOINLINE vkDwAccess #-} + vkDwAccess x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkExportFenceWin32HandleInfoKHR, dwAccess}) + + {-# INLINE vkDwAccessByteOffset #-} + vkDwAccessByteOffset ~_ + = #{offset VkExportFenceWin32HandleInfoKHR, dwAccess} + + {-# INLINE readVkDwAccess #-} + readVkDwAccess p + = peekByteOff p #{offset VkExportFenceWin32HandleInfoKHR, dwAccess} + + {-# INLINE writeVkDwAccess #-} + writeVkDwAccess p + = pokeByteOff p #{offset VkExportFenceWin32HandleInfoKHR, dwAccess} + +instance {-# OVERLAPPING #-} + HasField "dwAccess" VkExportFenceWin32HandleInfoKHR where + type FieldType "dwAccess" VkExportFenceWin32HandleInfoKHR = DWORD + type FieldOptional "dwAccess" VkExportFenceWin32HandleInfoKHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "dwAccess" VkExportFenceWin32HandleInfoKHR = + #{offset VkExportFenceWin32HandleInfoKHR, dwAccess} + type FieldIsArray "dwAccess" VkExportFenceWin32HandleInfoKHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkExportFenceWin32HandleInfoKHR, dwAccess} + +instance CanReadField "dwAccess" VkExportFenceWin32HandleInfoKHR + where + {-# INLINE getField #-} + getField = vkDwAccess + + {-# INLINE readField #-} + readField = readVkDwAccess + +instance CanWriteField "dwAccess" VkExportFenceWin32HandleInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkDwAccess + +instance {-# OVERLAPPING #-} + HasVkName VkExportFenceWin32HandleInfoKHR where + type VkNameMType VkExportFenceWin32HandleInfoKHR = LPCWSTR + + {-# NOINLINE vkName #-} + vkName x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkExportFenceWin32HandleInfoKHR, name}) + + {-# INLINE vkNameByteOffset #-} + vkNameByteOffset ~_ + = #{offset VkExportFenceWin32HandleInfoKHR, name} + + {-# INLINE readVkName #-} + readVkName p + = peekByteOff p #{offset VkExportFenceWin32HandleInfoKHR, name} + + {-# INLINE writeVkName #-} + writeVkName p + = pokeByteOff p #{offset VkExportFenceWin32HandleInfoKHR, name} + +instance {-# OVERLAPPING #-} + HasField "name" VkExportFenceWin32HandleInfoKHR where + type FieldType "name" VkExportFenceWin32HandleInfoKHR = LPCWSTR + type FieldOptional "name" VkExportFenceWin32HandleInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "name" VkExportFenceWin32HandleInfoKHR = + #{offset VkExportFenceWin32HandleInfoKHR, name} + type FieldIsArray "name" VkExportFenceWin32HandleInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkExportFenceWin32HandleInfoKHR, name} + +instance CanReadField "name" VkExportFenceWin32HandleInfoKHR where + {-# INLINE getField #-} + getField = vkName + + {-# INLINE readField #-} + readField = readVkName + +instance CanWriteField "name" VkExportFenceWin32HandleInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkName + +instance Show VkExportFenceWin32HandleInfoKHR where + showsPrec d x + = showString "VkExportFenceWin32HandleInfoKHR {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkPAttributes = " . + showsPrec d (vkPAttributes x) . + showString ", " . + showString "vkDwAccess = " . + showsPrec d (vkDwAccess x) . + showString ", " . + showString "vkName = " . showsPrec d (vkName x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkExportMemoryAllocateInfoKHR.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkExportMemoryAllocateInfoKHR.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkExportMemoryAllocateInfoKHR.hsc @@ -0,0 +1,239 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkExportMemoryAllocateInfoKHR + (VkExportMemoryAllocateInfoKHR(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkExternalMemoryHandleTypeFlagsKHR (VkExternalMemoryHandleTypeFlagsKHR) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Struct.VkMemoryAllocateInfo (VkMemoryAllocateInfo) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkExportMemoryAllocateInfoKHR { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkExternalMemoryHandleTypeFlagsKHR handleTypes; +-- > } VkExportMemoryAllocateInfoKHR; +-- +-- +data VkExportMemoryAllocateInfoKHR = VkExportMemoryAllocateInfoKHR## Addr## + ByteArray## + +instance Eq VkExportMemoryAllocateInfoKHR where + (VkExportMemoryAllocateInfoKHR## a _) == + x@(VkExportMemoryAllocateInfoKHR## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkExportMemoryAllocateInfoKHR where + (VkExportMemoryAllocateInfoKHR## a _) `compare` + x@(VkExportMemoryAllocateInfoKHR## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkExportMemoryAllocateInfoKHR where + sizeOf ~_ = #{size VkExportMemoryAllocateInfoKHR} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkExportMemoryAllocateInfoKHR} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkExportMemoryAllocateInfoKHR where + unsafeAddr (VkExportMemoryAllocateInfoKHR## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkExportMemoryAllocateInfoKHR## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkExportMemoryAllocateInfoKHR## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkExportMemoryAllocateInfoKHR where + type StructFields VkExportMemoryAllocateInfoKHR = + '["sType", "pNext", "handleTypes"] -- ' closing tick for hsc2hs + type CUnionType VkExportMemoryAllocateInfoKHR = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkExportMemoryAllocateInfoKHR = 'False -- ' closing tick for hsc2hs + type StructExtends VkExportMemoryAllocateInfoKHR = + '[VkMemoryAllocateInfo] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkExportMemoryAllocateInfoKHR where + type VkSTypeMType VkExportMemoryAllocateInfoKHR = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkExportMemoryAllocateInfoKHR, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkExportMemoryAllocateInfoKHR, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkExportMemoryAllocateInfoKHR, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkExportMemoryAllocateInfoKHR, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkExportMemoryAllocateInfoKHR where + type FieldType "sType" VkExportMemoryAllocateInfoKHR = + VkStructureType + type FieldOptional "sType" VkExportMemoryAllocateInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkExportMemoryAllocateInfoKHR = + #{offset VkExportMemoryAllocateInfoKHR, sType} + type FieldIsArray "sType" VkExportMemoryAllocateInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkExportMemoryAllocateInfoKHR, sType} + +instance CanReadField "sType" VkExportMemoryAllocateInfoKHR where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkExportMemoryAllocateInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkExportMemoryAllocateInfoKHR where + type VkPNextMType VkExportMemoryAllocateInfoKHR = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkExportMemoryAllocateInfoKHR, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkExportMemoryAllocateInfoKHR, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkExportMemoryAllocateInfoKHR, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkExportMemoryAllocateInfoKHR, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkExportMemoryAllocateInfoKHR where + type FieldType "pNext" VkExportMemoryAllocateInfoKHR = Ptr Void + type FieldOptional "pNext" VkExportMemoryAllocateInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkExportMemoryAllocateInfoKHR = + #{offset VkExportMemoryAllocateInfoKHR, pNext} + type FieldIsArray "pNext" VkExportMemoryAllocateInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkExportMemoryAllocateInfoKHR, pNext} + +instance CanReadField "pNext" VkExportMemoryAllocateInfoKHR where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkExportMemoryAllocateInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkHandleTypes VkExportMemoryAllocateInfoKHR where + type VkHandleTypesMType VkExportMemoryAllocateInfoKHR = + VkExternalMemoryHandleTypeFlagsKHR + + {-# NOINLINE vkHandleTypes #-} + vkHandleTypes x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkExportMemoryAllocateInfoKHR, handleTypes}) + + {-# INLINE vkHandleTypesByteOffset #-} + vkHandleTypesByteOffset ~_ + = #{offset VkExportMemoryAllocateInfoKHR, handleTypes} + + {-# INLINE readVkHandleTypes #-} + readVkHandleTypes p + = peekByteOff p #{offset VkExportMemoryAllocateInfoKHR, handleTypes} + + {-# INLINE writeVkHandleTypes #-} + writeVkHandleTypes p + = pokeByteOff p #{offset VkExportMemoryAllocateInfoKHR, handleTypes} + +instance {-# OVERLAPPING #-} + HasField "handleTypes" VkExportMemoryAllocateInfoKHR where + type FieldType "handleTypes" VkExportMemoryAllocateInfoKHR = + VkExternalMemoryHandleTypeFlagsKHR + type FieldOptional "handleTypes" VkExportMemoryAllocateInfoKHR = + 'True -- ' closing tick for hsc2hs + type FieldOffset "handleTypes" VkExportMemoryAllocateInfoKHR = + #{offset VkExportMemoryAllocateInfoKHR, handleTypes} + type FieldIsArray "handleTypes" VkExportMemoryAllocateInfoKHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkExportMemoryAllocateInfoKHR, handleTypes} + +instance CanReadField "handleTypes" VkExportMemoryAllocateInfoKHR + where + {-# INLINE getField #-} + getField = vkHandleTypes + + {-# INLINE readField #-} + readField = readVkHandleTypes + +instance CanWriteField "handleTypes" VkExportMemoryAllocateInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkHandleTypes + +instance Show VkExportMemoryAllocateInfoKHR where + showsPrec d x + = showString "VkExportMemoryAllocateInfoKHR {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkHandleTypes = " . + showsPrec d (vkHandleTypes x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkExportMemoryAllocateInfoNV.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkExportMemoryAllocateInfoNV.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkExportMemoryAllocateInfoNV.hsc @@ -0,0 +1,239 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkExportMemoryAllocateInfoNV + (VkExportMemoryAllocateInfoNV(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkExternalMemoryHandleTypeFlagsNV (VkExternalMemoryHandleTypeFlagsNV) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Struct.VkMemoryAllocateInfo (VkMemoryAllocateInfo) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkExportMemoryAllocateInfoNV { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkExternalMemoryHandleTypeFlagsNV handleTypes; +-- > } VkExportMemoryAllocateInfoNV; +-- +-- +data VkExportMemoryAllocateInfoNV = VkExportMemoryAllocateInfoNV## Addr## + ByteArray## + +instance Eq VkExportMemoryAllocateInfoNV where + (VkExportMemoryAllocateInfoNV## a _) == + x@(VkExportMemoryAllocateInfoNV## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkExportMemoryAllocateInfoNV where + (VkExportMemoryAllocateInfoNV## a _) `compare` + x@(VkExportMemoryAllocateInfoNV## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkExportMemoryAllocateInfoNV where + sizeOf ~_ = #{size VkExportMemoryAllocateInfoNV} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkExportMemoryAllocateInfoNV} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkExportMemoryAllocateInfoNV where + unsafeAddr (VkExportMemoryAllocateInfoNV## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkExportMemoryAllocateInfoNV## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkExportMemoryAllocateInfoNV## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkExportMemoryAllocateInfoNV where + type StructFields VkExportMemoryAllocateInfoNV = + '["sType", "pNext", "handleTypes"] -- ' closing tick for hsc2hs + type CUnionType VkExportMemoryAllocateInfoNV = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkExportMemoryAllocateInfoNV = 'False -- ' closing tick for hsc2hs + type StructExtends VkExportMemoryAllocateInfoNV = + '[VkMemoryAllocateInfo] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkExportMemoryAllocateInfoNV where + type VkSTypeMType VkExportMemoryAllocateInfoNV = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkExportMemoryAllocateInfoNV, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkExportMemoryAllocateInfoNV, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkExportMemoryAllocateInfoNV, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkExportMemoryAllocateInfoNV, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkExportMemoryAllocateInfoNV where + type FieldType "sType" VkExportMemoryAllocateInfoNV = + VkStructureType + type FieldOptional "sType" VkExportMemoryAllocateInfoNV = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkExportMemoryAllocateInfoNV = + #{offset VkExportMemoryAllocateInfoNV, sType} + type FieldIsArray "sType" VkExportMemoryAllocateInfoNV = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkExportMemoryAllocateInfoNV, sType} + +instance CanReadField "sType" VkExportMemoryAllocateInfoNV where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkExportMemoryAllocateInfoNV where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkExportMemoryAllocateInfoNV where + type VkPNextMType VkExportMemoryAllocateInfoNV = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkExportMemoryAllocateInfoNV, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkExportMemoryAllocateInfoNV, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkExportMemoryAllocateInfoNV, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkExportMemoryAllocateInfoNV, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkExportMemoryAllocateInfoNV where + type FieldType "pNext" VkExportMemoryAllocateInfoNV = Ptr Void + type FieldOptional "pNext" VkExportMemoryAllocateInfoNV = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkExportMemoryAllocateInfoNV = + #{offset VkExportMemoryAllocateInfoNV, pNext} + type FieldIsArray "pNext" VkExportMemoryAllocateInfoNV = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkExportMemoryAllocateInfoNV, pNext} + +instance CanReadField "pNext" VkExportMemoryAllocateInfoNV where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkExportMemoryAllocateInfoNV where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkHandleTypes VkExportMemoryAllocateInfoNV where + type VkHandleTypesMType VkExportMemoryAllocateInfoNV = + VkExternalMemoryHandleTypeFlagsNV + + {-# NOINLINE vkHandleTypes #-} + vkHandleTypes x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkExportMemoryAllocateInfoNV, handleTypes}) + + {-# INLINE vkHandleTypesByteOffset #-} + vkHandleTypesByteOffset ~_ + = #{offset VkExportMemoryAllocateInfoNV, handleTypes} + + {-# INLINE readVkHandleTypes #-} + readVkHandleTypes p + = peekByteOff p #{offset VkExportMemoryAllocateInfoNV, handleTypes} + + {-# INLINE writeVkHandleTypes #-} + writeVkHandleTypes p + = pokeByteOff p #{offset VkExportMemoryAllocateInfoNV, handleTypes} + +instance {-# OVERLAPPING #-} + HasField "handleTypes" VkExportMemoryAllocateInfoNV where + type FieldType "handleTypes" VkExportMemoryAllocateInfoNV = + VkExternalMemoryHandleTypeFlagsNV + type FieldOptional "handleTypes" VkExportMemoryAllocateInfoNV = + 'True -- ' closing tick for hsc2hs + type FieldOffset "handleTypes" VkExportMemoryAllocateInfoNV = + #{offset VkExportMemoryAllocateInfoNV, handleTypes} + type FieldIsArray "handleTypes" VkExportMemoryAllocateInfoNV = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkExportMemoryAllocateInfoNV, handleTypes} + +instance CanReadField "handleTypes" VkExportMemoryAllocateInfoNV + where + {-# INLINE getField #-} + getField = vkHandleTypes + + {-# INLINE readField #-} + readField = readVkHandleTypes + +instance CanWriteField "handleTypes" VkExportMemoryAllocateInfoNV + where + {-# INLINE writeField #-} + writeField = writeVkHandleTypes + +instance Show VkExportMemoryAllocateInfoNV where + showsPrec d x + = showString "VkExportMemoryAllocateInfoNV {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkHandleTypes = " . + showsPrec d (vkHandleTypes x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkExportMemoryWin32HandleInfoKHR.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkExportMemoryWin32HandleInfoKHR.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkExportMemoryWin32HandleInfoKHR.hsc @@ -0,0 +1,357 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkExportMemoryWin32HandleInfoKHR + (VkExportMemoryWin32HandleInfoKHR(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Include (DWORD, + LPCWSTR, + SECURITY_ATTRIBUTES) +import Graphics.Vulkan.Types.Struct.VkMemoryAllocateInfo (VkMemoryAllocateInfo) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkExportMemoryWin32HandleInfoKHR { +-- > VkStructureType sType; +-- > const void* pNext; +-- > const SECURITY_ATTRIBUTES* pAttributes; +-- > DWORD dwAccess; +-- > LPCWSTR name; +-- > } VkExportMemoryWin32HandleInfoKHR; +-- +-- +data VkExportMemoryWin32HandleInfoKHR = VkExportMemoryWin32HandleInfoKHR## Addr## + ByteArray## + +instance Eq VkExportMemoryWin32HandleInfoKHR where + (VkExportMemoryWin32HandleInfoKHR## a _) == + x@(VkExportMemoryWin32HandleInfoKHR## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkExportMemoryWin32HandleInfoKHR where + (VkExportMemoryWin32HandleInfoKHR## a _) `compare` + x@(VkExportMemoryWin32HandleInfoKHR## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkExportMemoryWin32HandleInfoKHR where + sizeOf ~_ = #{size VkExportMemoryWin32HandleInfoKHR} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkExportMemoryWin32HandleInfoKHR} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkExportMemoryWin32HandleInfoKHR where + unsafeAddr (VkExportMemoryWin32HandleInfoKHR## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkExportMemoryWin32HandleInfoKHR## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkExportMemoryWin32HandleInfoKHR## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkExportMemoryWin32HandleInfoKHR where + type StructFields VkExportMemoryWin32HandleInfoKHR = + '["sType", "pNext", "pAttributes", "dwAccess", "name"] -- ' closing tick for hsc2hs + type CUnionType VkExportMemoryWin32HandleInfoKHR = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkExportMemoryWin32HandleInfoKHR = 'False -- ' closing tick for hsc2hs + type StructExtends VkExportMemoryWin32HandleInfoKHR = + '[VkMemoryAllocateInfo] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkExportMemoryWin32HandleInfoKHR where + type VkSTypeMType VkExportMemoryWin32HandleInfoKHR = + VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkExportMemoryWin32HandleInfoKHR, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkExportMemoryWin32HandleInfoKHR, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkExportMemoryWin32HandleInfoKHR, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkExportMemoryWin32HandleInfoKHR, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkExportMemoryWin32HandleInfoKHR where + type FieldType "sType" VkExportMemoryWin32HandleInfoKHR = + VkStructureType + type FieldOptional "sType" VkExportMemoryWin32HandleInfoKHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkExportMemoryWin32HandleInfoKHR = + #{offset VkExportMemoryWin32HandleInfoKHR, sType} + type FieldIsArray "sType" VkExportMemoryWin32HandleInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkExportMemoryWin32HandleInfoKHR, sType} + +instance CanReadField "sType" VkExportMemoryWin32HandleInfoKHR + where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkExportMemoryWin32HandleInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkExportMemoryWin32HandleInfoKHR where + type VkPNextMType VkExportMemoryWin32HandleInfoKHR = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkExportMemoryWin32HandleInfoKHR, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkExportMemoryWin32HandleInfoKHR, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkExportMemoryWin32HandleInfoKHR, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkExportMemoryWin32HandleInfoKHR, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkExportMemoryWin32HandleInfoKHR where + type FieldType "pNext" VkExportMemoryWin32HandleInfoKHR = Ptr Void + type FieldOptional "pNext" VkExportMemoryWin32HandleInfoKHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkExportMemoryWin32HandleInfoKHR = + #{offset VkExportMemoryWin32HandleInfoKHR, pNext} + type FieldIsArray "pNext" VkExportMemoryWin32HandleInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkExportMemoryWin32HandleInfoKHR, pNext} + +instance CanReadField "pNext" VkExportMemoryWin32HandleInfoKHR + where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkExportMemoryWin32HandleInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkPAttributes VkExportMemoryWin32HandleInfoKHR where + type VkPAttributesMType VkExportMemoryWin32HandleInfoKHR = + Ptr SECURITY_ATTRIBUTES + + {-# NOINLINE vkPAttributes #-} + vkPAttributes x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkExportMemoryWin32HandleInfoKHR, pAttributes}) + + {-# INLINE vkPAttributesByteOffset #-} + vkPAttributesByteOffset ~_ + = #{offset VkExportMemoryWin32HandleInfoKHR, pAttributes} + + {-# INLINE readVkPAttributes #-} + readVkPAttributes p + = peekByteOff p #{offset VkExportMemoryWin32HandleInfoKHR, pAttributes} + + {-# INLINE writeVkPAttributes #-} + writeVkPAttributes p + = pokeByteOff p #{offset VkExportMemoryWin32HandleInfoKHR, pAttributes} + +instance {-# OVERLAPPING #-} + HasField "pAttributes" VkExportMemoryWin32HandleInfoKHR where + type FieldType "pAttributes" VkExportMemoryWin32HandleInfoKHR = + Ptr SECURITY_ATTRIBUTES + type FieldOptional "pAttributes" VkExportMemoryWin32HandleInfoKHR = + 'True -- ' closing tick for hsc2hs + type FieldOffset "pAttributes" VkExportMemoryWin32HandleInfoKHR = + #{offset VkExportMemoryWin32HandleInfoKHR, pAttributes} + type FieldIsArray "pAttributes" VkExportMemoryWin32HandleInfoKHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkExportMemoryWin32HandleInfoKHR, pAttributes} + +instance CanReadField "pAttributes" + VkExportMemoryWin32HandleInfoKHR + where + {-# INLINE getField #-} + getField = vkPAttributes + + {-# INLINE readField #-} + readField = readVkPAttributes + +instance CanWriteField "pAttributes" + VkExportMemoryWin32HandleInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkPAttributes + +instance {-# OVERLAPPING #-} + HasVkDwAccess VkExportMemoryWin32HandleInfoKHR where + type VkDwAccessMType VkExportMemoryWin32HandleInfoKHR = DWORD + + {-# NOINLINE vkDwAccess #-} + vkDwAccess x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkExportMemoryWin32HandleInfoKHR, dwAccess}) + + {-# INLINE vkDwAccessByteOffset #-} + vkDwAccessByteOffset ~_ + = #{offset VkExportMemoryWin32HandleInfoKHR, dwAccess} + + {-# INLINE readVkDwAccess #-} + readVkDwAccess p + = peekByteOff p #{offset VkExportMemoryWin32HandleInfoKHR, dwAccess} + + {-# INLINE writeVkDwAccess #-} + writeVkDwAccess p + = pokeByteOff p #{offset VkExportMemoryWin32HandleInfoKHR, dwAccess} + +instance {-# OVERLAPPING #-} + HasField "dwAccess" VkExportMemoryWin32HandleInfoKHR where + type FieldType "dwAccess" VkExportMemoryWin32HandleInfoKHR = DWORD + type FieldOptional "dwAccess" VkExportMemoryWin32HandleInfoKHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "dwAccess" VkExportMemoryWin32HandleInfoKHR = + #{offset VkExportMemoryWin32HandleInfoKHR, dwAccess} + type FieldIsArray "dwAccess" VkExportMemoryWin32HandleInfoKHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkExportMemoryWin32HandleInfoKHR, dwAccess} + +instance CanReadField "dwAccess" VkExportMemoryWin32HandleInfoKHR + where + {-# INLINE getField #-} + getField = vkDwAccess + + {-# INLINE readField #-} + readField = readVkDwAccess + +instance CanWriteField "dwAccess" VkExportMemoryWin32HandleInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkDwAccess + +instance {-# OVERLAPPING #-} + HasVkName VkExportMemoryWin32HandleInfoKHR where + type VkNameMType VkExportMemoryWin32HandleInfoKHR = LPCWSTR + + {-# NOINLINE vkName #-} + vkName x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkExportMemoryWin32HandleInfoKHR, name}) + + {-# INLINE vkNameByteOffset #-} + vkNameByteOffset ~_ + = #{offset VkExportMemoryWin32HandleInfoKHR, name} + + {-# INLINE readVkName #-} + readVkName p + = peekByteOff p #{offset VkExportMemoryWin32HandleInfoKHR, name} + + {-# INLINE writeVkName #-} + writeVkName p + = pokeByteOff p #{offset VkExportMemoryWin32HandleInfoKHR, name} + +instance {-# OVERLAPPING #-} + HasField "name" VkExportMemoryWin32HandleInfoKHR where + type FieldType "name" VkExportMemoryWin32HandleInfoKHR = LPCWSTR + type FieldOptional "name" VkExportMemoryWin32HandleInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "name" VkExportMemoryWin32HandleInfoKHR = + #{offset VkExportMemoryWin32HandleInfoKHR, name} + type FieldIsArray "name" VkExportMemoryWin32HandleInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkExportMemoryWin32HandleInfoKHR, name} + +instance CanReadField "name" VkExportMemoryWin32HandleInfoKHR where + {-# INLINE getField #-} + getField = vkName + + {-# INLINE readField #-} + readField = readVkName + +instance CanWriteField "name" VkExportMemoryWin32HandleInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkName + +instance Show VkExportMemoryWin32HandleInfoKHR where + showsPrec d x + = showString "VkExportMemoryWin32HandleInfoKHR {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkPAttributes = " . + showsPrec d (vkPAttributes x) . + showString ", " . + showString "vkDwAccess = " . + showsPrec d (vkDwAccess x) . + showString ", " . + showString "vkName = " . showsPrec d (vkName x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkExportMemoryWin32HandleInfoNV.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkExportMemoryWin32HandleInfoNV.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkExportMemoryWin32HandleInfoNV.hsc @@ -0,0 +1,297 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkExportMemoryWin32HandleInfoNV + (VkExportMemoryWin32HandleInfoNV(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Include (DWORD, SECURITY_ATTRIBUTES) +import Graphics.Vulkan.Types.Struct.VkMemoryAllocateInfo (VkMemoryAllocateInfo) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkExportMemoryWin32HandleInfoNV { +-- > VkStructureType sType; +-- > const void* pNext; +-- > const SECURITY_ATTRIBUTES* pAttributes; +-- > DWORD dwAccess; +-- > } VkExportMemoryWin32HandleInfoNV; +-- +-- +data VkExportMemoryWin32HandleInfoNV = VkExportMemoryWin32HandleInfoNV## Addr## + ByteArray## + +instance Eq VkExportMemoryWin32HandleInfoNV where + (VkExportMemoryWin32HandleInfoNV## a _) == + x@(VkExportMemoryWin32HandleInfoNV## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkExportMemoryWin32HandleInfoNV where + (VkExportMemoryWin32HandleInfoNV## a _) `compare` + x@(VkExportMemoryWin32HandleInfoNV## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkExportMemoryWin32HandleInfoNV where + sizeOf ~_ = #{size VkExportMemoryWin32HandleInfoNV} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkExportMemoryWin32HandleInfoNV} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkExportMemoryWin32HandleInfoNV where + unsafeAddr (VkExportMemoryWin32HandleInfoNV## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkExportMemoryWin32HandleInfoNV## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkExportMemoryWin32HandleInfoNV## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkExportMemoryWin32HandleInfoNV where + type StructFields VkExportMemoryWin32HandleInfoNV = + '["sType", "pNext", "pAttributes", "dwAccess"] -- ' closing tick for hsc2hs + type CUnionType VkExportMemoryWin32HandleInfoNV = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkExportMemoryWin32HandleInfoNV = 'False -- ' closing tick for hsc2hs + type StructExtends VkExportMemoryWin32HandleInfoNV = + '[VkMemoryAllocateInfo] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkExportMemoryWin32HandleInfoNV where + type VkSTypeMType VkExportMemoryWin32HandleInfoNV = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkExportMemoryWin32HandleInfoNV, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkExportMemoryWin32HandleInfoNV, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkExportMemoryWin32HandleInfoNV, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkExportMemoryWin32HandleInfoNV, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkExportMemoryWin32HandleInfoNV where + type FieldType "sType" VkExportMemoryWin32HandleInfoNV = + VkStructureType + type FieldOptional "sType" VkExportMemoryWin32HandleInfoNV = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkExportMemoryWin32HandleInfoNV = + #{offset VkExportMemoryWin32HandleInfoNV, sType} + type FieldIsArray "sType" VkExportMemoryWin32HandleInfoNV = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkExportMemoryWin32HandleInfoNV, sType} + +instance CanReadField "sType" VkExportMemoryWin32HandleInfoNV where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkExportMemoryWin32HandleInfoNV + where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkExportMemoryWin32HandleInfoNV where + type VkPNextMType VkExportMemoryWin32HandleInfoNV = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkExportMemoryWin32HandleInfoNV, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkExportMemoryWin32HandleInfoNV, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkExportMemoryWin32HandleInfoNV, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkExportMemoryWin32HandleInfoNV, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkExportMemoryWin32HandleInfoNV where + type FieldType "pNext" VkExportMemoryWin32HandleInfoNV = Ptr Void + type FieldOptional "pNext" VkExportMemoryWin32HandleInfoNV = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkExportMemoryWin32HandleInfoNV = + #{offset VkExportMemoryWin32HandleInfoNV, pNext} + type FieldIsArray "pNext" VkExportMemoryWin32HandleInfoNV = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkExportMemoryWin32HandleInfoNV, pNext} + +instance CanReadField "pNext" VkExportMemoryWin32HandleInfoNV where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkExportMemoryWin32HandleInfoNV + where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkPAttributes VkExportMemoryWin32HandleInfoNV where + type VkPAttributesMType VkExportMemoryWin32HandleInfoNV = + Ptr SECURITY_ATTRIBUTES + + {-# NOINLINE vkPAttributes #-} + vkPAttributes x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkExportMemoryWin32HandleInfoNV, pAttributes}) + + {-# INLINE vkPAttributesByteOffset #-} + vkPAttributesByteOffset ~_ + = #{offset VkExportMemoryWin32HandleInfoNV, pAttributes} + + {-# INLINE readVkPAttributes #-} + readVkPAttributes p + = peekByteOff p #{offset VkExportMemoryWin32HandleInfoNV, pAttributes} + + {-# INLINE writeVkPAttributes #-} + writeVkPAttributes p + = pokeByteOff p #{offset VkExportMemoryWin32HandleInfoNV, pAttributes} + +instance {-# OVERLAPPING #-} + HasField "pAttributes" VkExportMemoryWin32HandleInfoNV where + type FieldType "pAttributes" VkExportMemoryWin32HandleInfoNV = + Ptr SECURITY_ATTRIBUTES + type FieldOptional "pAttributes" VkExportMemoryWin32HandleInfoNV = + 'True -- ' closing tick for hsc2hs + type FieldOffset "pAttributes" VkExportMemoryWin32HandleInfoNV = + #{offset VkExportMemoryWin32HandleInfoNV, pAttributes} + type FieldIsArray "pAttributes" VkExportMemoryWin32HandleInfoNV = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkExportMemoryWin32HandleInfoNV, pAttributes} + +instance CanReadField "pAttributes" VkExportMemoryWin32HandleInfoNV + where + {-# INLINE getField #-} + getField = vkPAttributes + + {-# INLINE readField #-} + readField = readVkPAttributes + +instance CanWriteField "pAttributes" + VkExportMemoryWin32HandleInfoNV + where + {-# INLINE writeField #-} + writeField = writeVkPAttributes + +instance {-# OVERLAPPING #-} + HasVkDwAccess VkExportMemoryWin32HandleInfoNV where + type VkDwAccessMType VkExportMemoryWin32HandleInfoNV = DWORD + + {-# NOINLINE vkDwAccess #-} + vkDwAccess x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkExportMemoryWin32HandleInfoNV, dwAccess}) + + {-# INLINE vkDwAccessByteOffset #-} + vkDwAccessByteOffset ~_ + = #{offset VkExportMemoryWin32HandleInfoNV, dwAccess} + + {-# INLINE readVkDwAccess #-} + readVkDwAccess p + = peekByteOff p #{offset VkExportMemoryWin32HandleInfoNV, dwAccess} + + {-# INLINE writeVkDwAccess #-} + writeVkDwAccess p + = pokeByteOff p #{offset VkExportMemoryWin32HandleInfoNV, dwAccess} + +instance {-# OVERLAPPING #-} + HasField "dwAccess" VkExportMemoryWin32HandleInfoNV where + type FieldType "dwAccess" VkExportMemoryWin32HandleInfoNV = DWORD + type FieldOptional "dwAccess" VkExportMemoryWin32HandleInfoNV = + 'True -- ' closing tick for hsc2hs + type FieldOffset "dwAccess" VkExportMemoryWin32HandleInfoNV = + #{offset VkExportMemoryWin32HandleInfoNV, dwAccess} + type FieldIsArray "dwAccess" VkExportMemoryWin32HandleInfoNV = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkExportMemoryWin32HandleInfoNV, dwAccess} + +instance CanReadField "dwAccess" VkExportMemoryWin32HandleInfoNV + where + {-# INLINE getField #-} + getField = vkDwAccess + + {-# INLINE readField #-} + readField = readVkDwAccess + +instance CanWriteField "dwAccess" VkExportMemoryWin32HandleInfoNV + where + {-# INLINE writeField #-} + writeField = writeVkDwAccess + +instance Show VkExportMemoryWin32HandleInfoNV where + showsPrec d x + = showString "VkExportMemoryWin32HandleInfoNV {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkPAttributes = " . + showsPrec d (vkPAttributes x) . + showString ", " . + showString "vkDwAccess = " . + showsPrec d (vkDwAccess x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkExportSemaphoreCreateInfoKHR.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkExportSemaphoreCreateInfoKHR.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkExportSemaphoreCreateInfoKHR.hsc @@ -0,0 +1,244 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkExportSemaphoreCreateInfoKHR + (VkExportSemaphoreCreateInfoKHR(..)) where +import Foreign.Storable + (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkExternalSemaphoreHandleTypeFlagsKHR + (VkExternalSemaphoreHandleTypeFlagsKHR) +import Graphics.Vulkan.Types.Enum.VkStructureType + (VkStructureType) +import Graphics.Vulkan.Types.Struct.VkSemaphoreCreateInfo + (VkSemaphoreCreateInfo) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe + (unsafeDupablePerformIO) + +-- | > typedef struct VkExportSemaphoreCreateInfoKHR { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkExternalSemaphoreHandleTypeFlagsKHR handleTypes; +-- > } VkExportSemaphoreCreateInfoKHR; +-- +-- +data VkExportSemaphoreCreateInfoKHR = VkExportSemaphoreCreateInfoKHR## Addr## + ByteArray## + +instance Eq VkExportSemaphoreCreateInfoKHR where + (VkExportSemaphoreCreateInfoKHR## a _) == + x@(VkExportSemaphoreCreateInfoKHR## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkExportSemaphoreCreateInfoKHR where + (VkExportSemaphoreCreateInfoKHR## a _) `compare` + x@(VkExportSemaphoreCreateInfoKHR## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkExportSemaphoreCreateInfoKHR where + sizeOf ~_ = #{size VkExportSemaphoreCreateInfoKHR} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkExportSemaphoreCreateInfoKHR} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkExportSemaphoreCreateInfoKHR where + unsafeAddr (VkExportSemaphoreCreateInfoKHR## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkExportSemaphoreCreateInfoKHR## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkExportSemaphoreCreateInfoKHR## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkExportSemaphoreCreateInfoKHR where + type StructFields VkExportSemaphoreCreateInfoKHR = + '["sType", "pNext", "handleTypes"] -- ' closing tick for hsc2hs + type CUnionType VkExportSemaphoreCreateInfoKHR = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkExportSemaphoreCreateInfoKHR = 'False -- ' closing tick for hsc2hs + type StructExtends VkExportSemaphoreCreateInfoKHR = + '[VkSemaphoreCreateInfo] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkExportSemaphoreCreateInfoKHR where + type VkSTypeMType VkExportSemaphoreCreateInfoKHR = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkExportSemaphoreCreateInfoKHR, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkExportSemaphoreCreateInfoKHR, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkExportSemaphoreCreateInfoKHR, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkExportSemaphoreCreateInfoKHR, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkExportSemaphoreCreateInfoKHR where + type FieldType "sType" VkExportSemaphoreCreateInfoKHR = + VkStructureType + type FieldOptional "sType" VkExportSemaphoreCreateInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkExportSemaphoreCreateInfoKHR = + #{offset VkExportSemaphoreCreateInfoKHR, sType} + type FieldIsArray "sType" VkExportSemaphoreCreateInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkExportSemaphoreCreateInfoKHR, sType} + +instance CanReadField "sType" VkExportSemaphoreCreateInfoKHR where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkExportSemaphoreCreateInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkExportSemaphoreCreateInfoKHR where + type VkPNextMType VkExportSemaphoreCreateInfoKHR = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkExportSemaphoreCreateInfoKHR, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkExportSemaphoreCreateInfoKHR, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkExportSemaphoreCreateInfoKHR, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkExportSemaphoreCreateInfoKHR, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkExportSemaphoreCreateInfoKHR where + type FieldType "pNext" VkExportSemaphoreCreateInfoKHR = Ptr Void + type FieldOptional "pNext" VkExportSemaphoreCreateInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkExportSemaphoreCreateInfoKHR = + #{offset VkExportSemaphoreCreateInfoKHR, pNext} + type FieldIsArray "pNext" VkExportSemaphoreCreateInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkExportSemaphoreCreateInfoKHR, pNext} + +instance CanReadField "pNext" VkExportSemaphoreCreateInfoKHR where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkExportSemaphoreCreateInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkHandleTypes VkExportSemaphoreCreateInfoKHR where + type VkHandleTypesMType VkExportSemaphoreCreateInfoKHR = + VkExternalSemaphoreHandleTypeFlagsKHR + + {-# NOINLINE vkHandleTypes #-} + vkHandleTypes x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkExportSemaphoreCreateInfoKHR, handleTypes}) + + {-# INLINE vkHandleTypesByteOffset #-} + vkHandleTypesByteOffset ~_ + = #{offset VkExportSemaphoreCreateInfoKHR, handleTypes} + + {-# INLINE readVkHandleTypes #-} + readVkHandleTypes p + = peekByteOff p #{offset VkExportSemaphoreCreateInfoKHR, handleTypes} + + {-# INLINE writeVkHandleTypes #-} + writeVkHandleTypes p + = pokeByteOff p #{offset VkExportSemaphoreCreateInfoKHR, handleTypes} + +instance {-# OVERLAPPING #-} + HasField "handleTypes" VkExportSemaphoreCreateInfoKHR where + type FieldType "handleTypes" VkExportSemaphoreCreateInfoKHR = + VkExternalSemaphoreHandleTypeFlagsKHR + type FieldOptional "handleTypes" VkExportSemaphoreCreateInfoKHR = + 'True -- ' closing tick for hsc2hs + type FieldOffset "handleTypes" VkExportSemaphoreCreateInfoKHR = + #{offset VkExportSemaphoreCreateInfoKHR, handleTypes} + type FieldIsArray "handleTypes" VkExportSemaphoreCreateInfoKHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkExportSemaphoreCreateInfoKHR, handleTypes} + +instance CanReadField "handleTypes" VkExportSemaphoreCreateInfoKHR + where + {-# INLINE getField #-} + getField = vkHandleTypes + + {-# INLINE readField #-} + readField = readVkHandleTypes + +instance CanWriteField "handleTypes" VkExportSemaphoreCreateInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkHandleTypes + +instance Show VkExportSemaphoreCreateInfoKHR where + showsPrec d x + = showString "VkExportSemaphoreCreateInfoKHR {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkHandleTypes = " . + showsPrec d (vkHandleTypes x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkExportSemaphoreWin32HandleInfoKHR.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkExportSemaphoreWin32HandleInfoKHR.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkExportSemaphoreWin32HandleInfoKHR.hsc @@ -0,0 +1,369 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkExportSemaphoreWin32HandleInfoKHR + (VkExportSemaphoreWin32HandleInfoKHR(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Include (DWORD, + LPCWSTR, + SECURITY_ATTRIBUTES) +import Graphics.Vulkan.Types.Struct.VkSemaphoreCreateInfo (VkSemaphoreCreateInfo) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkExportSemaphoreWin32HandleInfoKHR { +-- > VkStructureType sType; +-- > const void* pNext; +-- > const SECURITY_ATTRIBUTES* pAttributes; +-- > DWORD dwAccess; +-- > LPCWSTR name; +-- > } VkExportSemaphoreWin32HandleInfoKHR; +-- +-- +data VkExportSemaphoreWin32HandleInfoKHR = VkExportSemaphoreWin32HandleInfoKHR## Addr## + ByteArray## + +instance Eq VkExportSemaphoreWin32HandleInfoKHR where + (VkExportSemaphoreWin32HandleInfoKHR## a _) == + x@(VkExportSemaphoreWin32HandleInfoKHR## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkExportSemaphoreWin32HandleInfoKHR where + (VkExportSemaphoreWin32HandleInfoKHR## a _) `compare` + x@(VkExportSemaphoreWin32HandleInfoKHR## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkExportSemaphoreWin32HandleInfoKHR where + sizeOf ~_ = #{size VkExportSemaphoreWin32HandleInfoKHR} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkExportSemaphoreWin32HandleInfoKHR} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkExportSemaphoreWin32HandleInfoKHR + where + unsafeAddr (VkExportSemaphoreWin32HandleInfoKHR## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkExportSemaphoreWin32HandleInfoKHR## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkExportSemaphoreWin32HandleInfoKHR## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkExportSemaphoreWin32HandleInfoKHR where + type StructFields VkExportSemaphoreWin32HandleInfoKHR = + '["sType", "pNext", "pAttributes", "dwAccess", "name"] -- ' closing tick for hsc2hs + type CUnionType VkExportSemaphoreWin32HandleInfoKHR = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkExportSemaphoreWin32HandleInfoKHR = 'False -- ' closing tick for hsc2hs + type StructExtends VkExportSemaphoreWin32HandleInfoKHR = + '[VkSemaphoreCreateInfo] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkExportSemaphoreWin32HandleInfoKHR where + type VkSTypeMType VkExportSemaphoreWin32HandleInfoKHR = + VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkExportSemaphoreWin32HandleInfoKHR, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkExportSemaphoreWin32HandleInfoKHR, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkExportSemaphoreWin32HandleInfoKHR, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkExportSemaphoreWin32HandleInfoKHR, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkExportSemaphoreWin32HandleInfoKHR where + type FieldType "sType" VkExportSemaphoreWin32HandleInfoKHR = + VkStructureType + type FieldOptional "sType" VkExportSemaphoreWin32HandleInfoKHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkExportSemaphoreWin32HandleInfoKHR = + #{offset VkExportSemaphoreWin32HandleInfoKHR, sType} + type FieldIsArray "sType" VkExportSemaphoreWin32HandleInfoKHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkExportSemaphoreWin32HandleInfoKHR, sType} + +instance CanReadField "sType" VkExportSemaphoreWin32HandleInfoKHR + where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkExportSemaphoreWin32HandleInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkExportSemaphoreWin32HandleInfoKHR where + type VkPNextMType VkExportSemaphoreWin32HandleInfoKHR = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkExportSemaphoreWin32HandleInfoKHR, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkExportSemaphoreWin32HandleInfoKHR, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkExportSemaphoreWin32HandleInfoKHR, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkExportSemaphoreWin32HandleInfoKHR, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkExportSemaphoreWin32HandleInfoKHR where + type FieldType "pNext" VkExportSemaphoreWin32HandleInfoKHR = + Ptr Void + type FieldOptional "pNext" VkExportSemaphoreWin32HandleInfoKHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkExportSemaphoreWin32HandleInfoKHR = + #{offset VkExportSemaphoreWin32HandleInfoKHR, pNext} + type FieldIsArray "pNext" VkExportSemaphoreWin32HandleInfoKHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkExportSemaphoreWin32HandleInfoKHR, pNext} + +instance CanReadField "pNext" VkExportSemaphoreWin32HandleInfoKHR + where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkExportSemaphoreWin32HandleInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkPAttributes VkExportSemaphoreWin32HandleInfoKHR where + type VkPAttributesMType VkExportSemaphoreWin32HandleInfoKHR = + Ptr SECURITY_ATTRIBUTES + + {-# NOINLINE vkPAttributes #-} + vkPAttributes x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkExportSemaphoreWin32HandleInfoKHR, pAttributes}) + + {-# INLINE vkPAttributesByteOffset #-} + vkPAttributesByteOffset ~_ + = #{offset VkExportSemaphoreWin32HandleInfoKHR, pAttributes} + + {-# INLINE readVkPAttributes #-} + readVkPAttributes p + = peekByteOff p #{offset VkExportSemaphoreWin32HandleInfoKHR, pAttributes} + + {-# INLINE writeVkPAttributes #-} + writeVkPAttributes p + = pokeByteOff p #{offset VkExportSemaphoreWin32HandleInfoKHR, pAttributes} + +instance {-# OVERLAPPING #-} + HasField "pAttributes" VkExportSemaphoreWin32HandleInfoKHR where + type FieldType "pAttributes" VkExportSemaphoreWin32HandleInfoKHR = + Ptr SECURITY_ATTRIBUTES + type FieldOptional "pAttributes" + VkExportSemaphoreWin32HandleInfoKHR + = 'True -- ' closing tick for hsc2hs + type FieldOffset "pAttributes" VkExportSemaphoreWin32HandleInfoKHR + = + #{offset VkExportSemaphoreWin32HandleInfoKHR, pAttributes} + type FieldIsArray "pAttributes" VkExportSemaphoreWin32HandleInfoKHR + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkExportSemaphoreWin32HandleInfoKHR, pAttributes} + +instance CanReadField "pAttributes" + VkExportSemaphoreWin32HandleInfoKHR + where + {-# INLINE getField #-} + getField = vkPAttributes + + {-# INLINE readField #-} + readField = readVkPAttributes + +instance CanWriteField "pAttributes" + VkExportSemaphoreWin32HandleInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkPAttributes + +instance {-# OVERLAPPING #-} + HasVkDwAccess VkExportSemaphoreWin32HandleInfoKHR where + type VkDwAccessMType VkExportSemaphoreWin32HandleInfoKHR = DWORD + + {-# NOINLINE vkDwAccess #-} + vkDwAccess x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkExportSemaphoreWin32HandleInfoKHR, dwAccess}) + + {-# INLINE vkDwAccessByteOffset #-} + vkDwAccessByteOffset ~_ + = #{offset VkExportSemaphoreWin32HandleInfoKHR, dwAccess} + + {-# INLINE readVkDwAccess #-} + readVkDwAccess p + = peekByteOff p #{offset VkExportSemaphoreWin32HandleInfoKHR, dwAccess} + + {-# INLINE writeVkDwAccess #-} + writeVkDwAccess p + = pokeByteOff p #{offset VkExportSemaphoreWin32HandleInfoKHR, dwAccess} + +instance {-# OVERLAPPING #-} + HasField "dwAccess" VkExportSemaphoreWin32HandleInfoKHR where + type FieldType "dwAccess" VkExportSemaphoreWin32HandleInfoKHR = + DWORD + type FieldOptional "dwAccess" VkExportSemaphoreWin32HandleInfoKHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "dwAccess" VkExportSemaphoreWin32HandleInfoKHR = + #{offset VkExportSemaphoreWin32HandleInfoKHR, dwAccess} + type FieldIsArray "dwAccess" VkExportSemaphoreWin32HandleInfoKHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkExportSemaphoreWin32HandleInfoKHR, dwAccess} + +instance CanReadField "dwAccess" + VkExportSemaphoreWin32HandleInfoKHR + where + {-# INLINE getField #-} + getField = vkDwAccess + + {-# INLINE readField #-} + readField = readVkDwAccess + +instance CanWriteField "dwAccess" + VkExportSemaphoreWin32HandleInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkDwAccess + +instance {-# OVERLAPPING #-} + HasVkName VkExportSemaphoreWin32HandleInfoKHR where + type VkNameMType VkExportSemaphoreWin32HandleInfoKHR = LPCWSTR + + {-# NOINLINE vkName #-} + vkName x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkExportSemaphoreWin32HandleInfoKHR, name}) + + {-# INLINE vkNameByteOffset #-} + vkNameByteOffset ~_ + = #{offset VkExportSemaphoreWin32HandleInfoKHR, name} + + {-# INLINE readVkName #-} + readVkName p + = peekByteOff p #{offset VkExportSemaphoreWin32HandleInfoKHR, name} + + {-# INLINE writeVkName #-} + writeVkName p + = pokeByteOff p #{offset VkExportSemaphoreWin32HandleInfoKHR, name} + +instance {-# OVERLAPPING #-} + HasField "name" VkExportSemaphoreWin32HandleInfoKHR where + type FieldType "name" VkExportSemaphoreWin32HandleInfoKHR = LPCWSTR + type FieldOptional "name" VkExportSemaphoreWin32HandleInfoKHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "name" VkExportSemaphoreWin32HandleInfoKHR = + #{offset VkExportSemaphoreWin32HandleInfoKHR, name} + type FieldIsArray "name" VkExportSemaphoreWin32HandleInfoKHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkExportSemaphoreWin32HandleInfoKHR, name} + +instance CanReadField "name" VkExportSemaphoreWin32HandleInfoKHR + where + {-# INLINE getField #-} + getField = vkName + + {-# INLINE readField #-} + readField = readVkName + +instance CanWriteField "name" VkExportSemaphoreWin32HandleInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkName + +instance Show VkExportSemaphoreWin32HandleInfoKHR where + showsPrec d x + = showString "VkExportSemaphoreWin32HandleInfoKHR {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkPAttributes = " . + showsPrec d (vkPAttributes x) . + showString ", " . + showString "vkDwAccess = " . + showsPrec d (vkDwAccess x) . + showString ", " . + showString "vkName = " . showsPrec d (vkName x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkExtensionProperties.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkExtensionProperties.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkExtensionProperties.hsc @@ -0,0 +1,205 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleContexts #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE ScopedTypeVariables #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +{-# LANGUAGE UndecidableInstances #-} +module Graphics.Vulkan.Types.Struct.VkExtensionProperties + (VkExtensionProperties(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import GHC.TypeLits (KnownNat, natVal') -- ' closing tick for hsc2hs +import Graphics.Vulkan.Constants (VK_MAX_EXTENSION_NAME_SIZE, + pattern VK_MAX_EXTENSION_NAME_SIZE) +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkExtensionProperties { +-- > char extensionName[VK_MAX_EXTENSION_NAME_SIZE]; +-- > uint32_t specVersion; +-- > } VkExtensionProperties; +-- +-- +data VkExtensionProperties = VkExtensionProperties## Addr## + ByteArray## + +instance Eq VkExtensionProperties where + (VkExtensionProperties## a _) == x@(VkExtensionProperties## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkExtensionProperties where + (VkExtensionProperties## a _) `compare` + x@(VkExtensionProperties## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkExtensionProperties where + sizeOf ~_ = #{size VkExtensionProperties} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkExtensionProperties} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkExtensionProperties where + unsafeAddr (VkExtensionProperties## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkExtensionProperties## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkExtensionProperties## (plusAddr## (byteArrayContents## b) off) b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkExtensionProperties where + type StructFields VkExtensionProperties = + '["extensionName", "specVersion"] -- ' closing tick for hsc2hs + type CUnionType VkExtensionProperties = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkExtensionProperties = 'True -- ' closing tick for hsc2hs + type StructExtends VkExtensionProperties = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkExtensionNameArray VkExtensionProperties where + type VkExtensionNameArrayMType VkExtensionProperties = CChar + + {-# NOINLINE vkExtensionNameArray #-} + vkExtensionNameArray x idx + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) + (idx * sizeOf (undefined :: CChar) + + #{offset VkExtensionProperties, extensionName})) + + {-# INLINE vkExtensionNameArrayByteOffset #-} + vkExtensionNameArrayByteOffset ~_ + = #{offset VkExtensionProperties, extensionName} + + {-# INLINE readVkExtensionNameArray #-} + readVkExtensionNameArray p idx + = peekByteOff p + (idx * sizeOf (undefined :: CChar) + + #{offset VkExtensionProperties, extensionName}) + + {-# INLINE writeVkExtensionNameArray #-} + writeVkExtensionNameArray p idx + = pokeByteOff p + (idx * sizeOf (undefined :: CChar) + + #{offset VkExtensionProperties, extensionName}) + +instance {-# OVERLAPPING #-} + HasField "extensionName" VkExtensionProperties where + type FieldType "extensionName" VkExtensionProperties = CChar + type FieldOptional "extensionName" VkExtensionProperties = 'False -- ' closing tick for hsc2hs + type FieldOffset "extensionName" VkExtensionProperties = + #{offset VkExtensionProperties, extensionName} + type FieldIsArray "extensionName" VkExtensionProperties = 'True -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkExtensionProperties, extensionName} + +instance (KnownNat idx, + IndexInBounds "extensionName" idx VkExtensionProperties) => + CanReadFieldArray "extensionName" idx VkExtensionProperties + where + {-# SPECIALISE instance + CanReadFieldArray "extensionName" 0 VkExtensionProperties #-} + + {-# SPECIALISE instance + CanReadFieldArray "extensionName" 1 VkExtensionProperties #-} + + {-# SPECIALISE instance + CanReadFieldArray "extensionName" 2 VkExtensionProperties #-} + + {-# SPECIALISE instance + CanReadFieldArray "extensionName" 3 VkExtensionProperties #-} + type FieldArrayLength "extensionName" VkExtensionProperties = + VK_MAX_EXTENSION_NAME_SIZE + + {-# INLINE fieldArrayLength #-} + fieldArrayLength = VK_MAX_EXTENSION_NAME_SIZE + + {-# INLINE getFieldArray #-} + getFieldArray x + = vkExtensionNameArray x + (fromInteger $ natVal' (proxy## :: Proxy## idx)) -- ' closing tick for hsc2hs + + {-# INLINE readFieldArray #-} + readFieldArray x + = readVkExtensionNameArray x + (fromInteger $ natVal' (proxy## :: Proxy## idx)) -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkSpecVersion VkExtensionProperties + where + type VkSpecVersionMType VkExtensionProperties = Word32 + + {-# NOINLINE vkSpecVersion #-} + vkSpecVersion x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkExtensionProperties, specVersion}) + + {-# INLINE vkSpecVersionByteOffset #-} + vkSpecVersionByteOffset ~_ + = #{offset VkExtensionProperties, specVersion} + + {-# INLINE readVkSpecVersion #-} + readVkSpecVersion p + = peekByteOff p #{offset VkExtensionProperties, specVersion} + + {-# INLINE writeVkSpecVersion #-} + writeVkSpecVersion p + = pokeByteOff p #{offset VkExtensionProperties, specVersion} + +instance {-# OVERLAPPING #-} + HasField "specVersion" VkExtensionProperties where + type FieldType "specVersion" VkExtensionProperties = Word32 + type FieldOptional "specVersion" VkExtensionProperties = 'False -- ' closing tick for hsc2hs + type FieldOffset "specVersion" VkExtensionProperties = + #{offset VkExtensionProperties, specVersion} + type FieldIsArray "specVersion" VkExtensionProperties = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkExtensionProperties, specVersion} + +instance CanReadField "specVersion" VkExtensionProperties where + {-# INLINE getField #-} + getField = vkSpecVersion + + {-# INLINE readField #-} + readField = readVkSpecVersion + +instance Show VkExtensionProperties where + showsPrec d x + = showString "VkExtensionProperties {" . + showString "vkExtensionNameArray = [" . + showsPrec d + (map (vkExtensionNameArray x) [1 .. VK_MAX_EXTENSION_NAME_SIZE]) + . + showChar ']' . + showString ", " . + showString "vkSpecVersion = " . + showsPrec d (vkSpecVersion x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkExtent2D.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkExtent2D.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkExtent2D.hsc @@ -0,0 +1,162 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkExtent2D (VkExtent2D(..)) + where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkExtent2D { +-- > uint32_t width; +-- > uint32_t height; +-- > } VkExtent2D; +-- +-- +data VkExtent2D = VkExtent2D## Addr## ByteArray## + +instance Eq VkExtent2D where + (VkExtent2D## a _) == x@(VkExtent2D## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkExtent2D where + (VkExtent2D## a _) `compare` x@(VkExtent2D## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkExtent2D where + sizeOf ~_ = #{size VkExtent2D} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkExtent2D} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkExtent2D where + unsafeAddr (VkExtent2D## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkExtent2D## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkExtent2D## (plusAddr## (byteArrayContents## b) off) b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkExtent2D where + type StructFields VkExtent2D = '["width", "height"] -- ' closing tick for hsc2hs + type CUnionType VkExtent2D = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkExtent2D = 'False -- ' closing tick for hsc2hs + type StructExtends VkExtent2D = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkWidth VkExtent2D where + type VkWidthMType VkExtent2D = Word32 + + {-# NOINLINE vkWidth #-} + vkWidth x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkExtent2D, width}) + + {-# INLINE vkWidthByteOffset #-} + vkWidthByteOffset ~_ = #{offset VkExtent2D, width} + + {-# INLINE readVkWidth #-} + readVkWidth p + = peekByteOff p #{offset VkExtent2D, width} + + {-# INLINE writeVkWidth #-} + writeVkWidth p + = pokeByteOff p #{offset VkExtent2D, width} + +instance {-# OVERLAPPING #-} HasField "width" VkExtent2D where + type FieldType "width" VkExtent2D = Word32 + type FieldOptional "width" VkExtent2D = 'False -- ' closing tick for hsc2hs + type FieldOffset "width" VkExtent2D = + #{offset VkExtent2D, width} + type FieldIsArray "width" VkExtent2D = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkExtent2D, width} + +instance CanReadField "width" VkExtent2D where + {-# INLINE getField #-} + getField = vkWidth + + {-# INLINE readField #-} + readField = readVkWidth + +instance CanWriteField "width" VkExtent2D where + {-# INLINE writeField #-} + writeField = writeVkWidth + +instance {-# OVERLAPPING #-} HasVkHeight VkExtent2D where + type VkHeightMType VkExtent2D = Word32 + + {-# NOINLINE vkHeight #-} + vkHeight x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkExtent2D, height}) + + {-# INLINE vkHeightByteOffset #-} + vkHeightByteOffset ~_ = #{offset VkExtent2D, height} + + {-# INLINE readVkHeight #-} + readVkHeight p + = peekByteOff p #{offset VkExtent2D, height} + + {-# INLINE writeVkHeight #-} + writeVkHeight p + = pokeByteOff p #{offset VkExtent2D, height} + +instance {-# OVERLAPPING #-} HasField "height" VkExtent2D where + type FieldType "height" VkExtent2D = Word32 + type FieldOptional "height" VkExtent2D = 'False -- ' closing tick for hsc2hs + type FieldOffset "height" VkExtent2D = + #{offset VkExtent2D, height} + type FieldIsArray "height" VkExtent2D = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkExtent2D, height} + +instance CanReadField "height" VkExtent2D where + {-# INLINE getField #-} + getField = vkHeight + + {-# INLINE readField #-} + readField = readVkHeight + +instance CanWriteField "height" VkExtent2D where + {-# INLINE writeField #-} + writeField = writeVkHeight + +instance Show VkExtent2D where + showsPrec d x + = showString "VkExtent2D {" . + showString "vkWidth = " . + showsPrec d (vkWidth x) . + showString ", " . + showString "vkHeight = " . showsPrec d (vkHeight x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkExtent3D.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkExtent3D.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkExtent3D.hsc @@ -0,0 +1,209 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkExtent3D (VkExtent3D(..)) + where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkExtent3D { +-- > uint32_t width; +-- > uint32_t height; +-- > uint32_t depth; +-- > } VkExtent3D; +-- +-- +data VkExtent3D = VkExtent3D## Addr## ByteArray## + +instance Eq VkExtent3D where + (VkExtent3D## a _) == x@(VkExtent3D## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkExtent3D where + (VkExtent3D## a _) `compare` x@(VkExtent3D## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkExtent3D where + sizeOf ~_ = #{size VkExtent3D} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkExtent3D} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkExtent3D where + unsafeAddr (VkExtent3D## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkExtent3D## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkExtent3D## (plusAddr## (byteArrayContents## b) off) b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkExtent3D where + type StructFields VkExtent3D = '["width", "height", "depth"] -- ' closing tick for hsc2hs + type CUnionType VkExtent3D = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkExtent3D = 'False -- ' closing tick for hsc2hs + type StructExtends VkExtent3D = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkWidth VkExtent3D where + type VkWidthMType VkExtent3D = Word32 + + {-# NOINLINE vkWidth #-} + vkWidth x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkExtent3D, width}) + + {-# INLINE vkWidthByteOffset #-} + vkWidthByteOffset ~_ = #{offset VkExtent3D, width} + + {-# INLINE readVkWidth #-} + readVkWidth p + = peekByteOff p #{offset VkExtent3D, width} + + {-# INLINE writeVkWidth #-} + writeVkWidth p + = pokeByteOff p #{offset VkExtent3D, width} + +instance {-# OVERLAPPING #-} HasField "width" VkExtent3D where + type FieldType "width" VkExtent3D = Word32 + type FieldOptional "width" VkExtent3D = 'False -- ' closing tick for hsc2hs + type FieldOffset "width" VkExtent3D = + #{offset VkExtent3D, width} + type FieldIsArray "width" VkExtent3D = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkExtent3D, width} + +instance CanReadField "width" VkExtent3D where + {-# INLINE getField #-} + getField = vkWidth + + {-# INLINE readField #-} + readField = readVkWidth + +instance CanWriteField "width" VkExtent3D where + {-# INLINE writeField #-} + writeField = writeVkWidth + +instance {-# OVERLAPPING #-} HasVkHeight VkExtent3D where + type VkHeightMType VkExtent3D = Word32 + + {-# NOINLINE vkHeight #-} + vkHeight x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkExtent3D, height}) + + {-# INLINE vkHeightByteOffset #-} + vkHeightByteOffset ~_ = #{offset VkExtent3D, height} + + {-# INLINE readVkHeight #-} + readVkHeight p + = peekByteOff p #{offset VkExtent3D, height} + + {-# INLINE writeVkHeight #-} + writeVkHeight p + = pokeByteOff p #{offset VkExtent3D, height} + +instance {-# OVERLAPPING #-} HasField "height" VkExtent3D where + type FieldType "height" VkExtent3D = Word32 + type FieldOptional "height" VkExtent3D = 'False -- ' closing tick for hsc2hs + type FieldOffset "height" VkExtent3D = + #{offset VkExtent3D, height} + type FieldIsArray "height" VkExtent3D = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkExtent3D, height} + +instance CanReadField "height" VkExtent3D where + {-# INLINE getField #-} + getField = vkHeight + + {-# INLINE readField #-} + readField = readVkHeight + +instance CanWriteField "height" VkExtent3D where + {-# INLINE writeField #-} + writeField = writeVkHeight + +instance {-# OVERLAPPING #-} HasVkDepth VkExtent3D where + type VkDepthMType VkExtent3D = Word32 + + {-# NOINLINE vkDepth #-} + vkDepth x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkExtent3D, depth}) + + {-# INLINE vkDepthByteOffset #-} + vkDepthByteOffset ~_ = #{offset VkExtent3D, depth} + + {-# INLINE readVkDepth #-} + readVkDepth p + = peekByteOff p #{offset VkExtent3D, depth} + + {-# INLINE writeVkDepth #-} + writeVkDepth p + = pokeByteOff p #{offset VkExtent3D, depth} + +instance {-# OVERLAPPING #-} HasField "depth" VkExtent3D where + type FieldType "depth" VkExtent3D = Word32 + type FieldOptional "depth" VkExtent3D = 'False -- ' closing tick for hsc2hs + type FieldOffset "depth" VkExtent3D = + #{offset VkExtent3D, depth} + type FieldIsArray "depth" VkExtent3D = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkExtent3D, depth} + +instance CanReadField "depth" VkExtent3D where + {-# INLINE getField #-} + getField = vkDepth + + {-# INLINE readField #-} + readField = readVkDepth + +instance CanWriteField "depth" VkExtent3D where + {-# INLINE writeField #-} + writeField = writeVkDepth + +instance Show VkExtent3D where + showsPrec d x + = showString "VkExtent3D {" . + showString "vkWidth = " . + showsPrec d (vkWidth x) . + showString ", " . + showString "vkHeight = " . + showsPrec d (vkHeight x) . + showString ", " . + showString "vkDepth = " . showsPrec d (vkDepth x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkExternalBufferPropertiesKHR.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkExternalBufferPropertiesKHR.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkExternalBufferPropertiesKHR.hsc @@ -0,0 +1,231 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkExternalBufferPropertiesKHR + (VkExternalBufferPropertiesKHR(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Struct.VkExternalMemoryPropertiesKHR (VkExternalMemoryPropertiesKHR) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkExternalBufferPropertiesKHR { +-- > VkStructureType sType; +-- > void* pNext; +-- > VkExternalMemoryPropertiesKHR externalMemoryProperties; +-- > } VkExternalBufferPropertiesKHR; +-- +-- +data VkExternalBufferPropertiesKHR = VkExternalBufferPropertiesKHR## Addr## + ByteArray## + +instance Eq VkExternalBufferPropertiesKHR where + (VkExternalBufferPropertiesKHR## a _) == + x@(VkExternalBufferPropertiesKHR## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkExternalBufferPropertiesKHR where + (VkExternalBufferPropertiesKHR## a _) `compare` + x@(VkExternalBufferPropertiesKHR## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkExternalBufferPropertiesKHR where + sizeOf ~_ = #{size VkExternalBufferPropertiesKHR} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkExternalBufferPropertiesKHR} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkExternalBufferPropertiesKHR where + unsafeAddr (VkExternalBufferPropertiesKHR## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkExternalBufferPropertiesKHR## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkExternalBufferPropertiesKHR## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkExternalBufferPropertiesKHR where + type StructFields VkExternalBufferPropertiesKHR = + '["sType", "pNext", "externalMemoryProperties"] -- ' closing tick for hsc2hs + type CUnionType VkExternalBufferPropertiesKHR = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkExternalBufferPropertiesKHR = 'True -- ' closing tick for hsc2hs + type StructExtends VkExternalBufferPropertiesKHR = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkExternalBufferPropertiesKHR where + type VkSTypeMType VkExternalBufferPropertiesKHR = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkExternalBufferPropertiesKHR, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkExternalBufferPropertiesKHR, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkExternalBufferPropertiesKHR, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkExternalBufferPropertiesKHR, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkExternalBufferPropertiesKHR where + type FieldType "sType" VkExternalBufferPropertiesKHR = + VkStructureType + type FieldOptional "sType" VkExternalBufferPropertiesKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkExternalBufferPropertiesKHR = + #{offset VkExternalBufferPropertiesKHR, sType} + type FieldIsArray "sType" VkExternalBufferPropertiesKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkExternalBufferPropertiesKHR, sType} + +instance CanReadField "sType" VkExternalBufferPropertiesKHR where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkExternalBufferPropertiesKHR where + type VkPNextMType VkExternalBufferPropertiesKHR = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkExternalBufferPropertiesKHR, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkExternalBufferPropertiesKHR, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkExternalBufferPropertiesKHR, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkExternalBufferPropertiesKHR, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkExternalBufferPropertiesKHR where + type FieldType "pNext" VkExternalBufferPropertiesKHR = Ptr Void + type FieldOptional "pNext" VkExternalBufferPropertiesKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkExternalBufferPropertiesKHR = + #{offset VkExternalBufferPropertiesKHR, pNext} + type FieldIsArray "pNext" VkExternalBufferPropertiesKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkExternalBufferPropertiesKHR, pNext} + +instance CanReadField "pNext" VkExternalBufferPropertiesKHR where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance {-# OVERLAPPING #-} + HasVkExternalMemoryProperties VkExternalBufferPropertiesKHR where + type VkExternalMemoryPropertiesMType VkExternalBufferPropertiesKHR + = VkExternalMemoryPropertiesKHR + + {-# NOINLINE vkExternalMemoryProperties #-} + vkExternalMemoryProperties x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkExternalBufferPropertiesKHR, externalMemoryProperties}) + + {-# INLINE vkExternalMemoryPropertiesByteOffset #-} + vkExternalMemoryPropertiesByteOffset ~_ + = #{offset VkExternalBufferPropertiesKHR, externalMemoryProperties} + + {-# INLINE readVkExternalMemoryProperties #-} + readVkExternalMemoryProperties p + = peekByteOff p #{offset VkExternalBufferPropertiesKHR, externalMemoryProperties} + + {-# INLINE writeVkExternalMemoryProperties #-} + writeVkExternalMemoryProperties p + = pokeByteOff p #{offset VkExternalBufferPropertiesKHR, externalMemoryProperties} + +instance {-# OVERLAPPING #-} + HasField "externalMemoryProperties" VkExternalBufferPropertiesKHR + where + type FieldType "externalMemoryProperties" + VkExternalBufferPropertiesKHR + = VkExternalMemoryPropertiesKHR + type FieldOptional "externalMemoryProperties" + VkExternalBufferPropertiesKHR + = 'False -- ' closing tick for hsc2hs + type FieldOffset "externalMemoryProperties" + VkExternalBufferPropertiesKHR + = + #{offset VkExternalBufferPropertiesKHR, externalMemoryProperties} + type FieldIsArray "externalMemoryProperties" + VkExternalBufferPropertiesKHR + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkExternalBufferPropertiesKHR, externalMemoryProperties} + +instance CanReadField "externalMemoryProperties" + VkExternalBufferPropertiesKHR + where + {-# INLINE getField #-} + getField = vkExternalMemoryProperties + + {-# INLINE readField #-} + readField = readVkExternalMemoryProperties + +instance Show VkExternalBufferPropertiesKHR where + showsPrec d x + = showString "VkExternalBufferPropertiesKHR {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkExternalMemoryProperties = " . + showsPrec d (vkExternalMemoryProperties x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkExternalFencePropertiesKHR.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkExternalFencePropertiesKHR.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkExternalFencePropertiesKHR.hsc @@ -0,0 +1,350 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkExternalFencePropertiesKHR + (VkExternalFencePropertiesKHR(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkExternalFenceFeatureFlagsKHR (VkExternalFenceFeatureFlagsKHR) +import Graphics.Vulkan.Types.Enum.VkExternalFenceHandleTypeFlagsKHR (VkExternalFenceHandleTypeFlagsKHR) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkExternalFencePropertiesKHR { +-- > VkStructureType sType; +-- > void* pNext; +-- > VkExternalFenceHandleTypeFlagsKHR exportFromImportedHandleTypes; +-- > VkExternalFenceHandleTypeFlagsKHR compatibleHandleTypes; +-- > VkExternalFenceFeatureFlagsKHR externalFenceFeatures; +-- > } VkExternalFencePropertiesKHR; +-- +-- +data VkExternalFencePropertiesKHR = VkExternalFencePropertiesKHR## Addr## + ByteArray## + +instance Eq VkExternalFencePropertiesKHR where + (VkExternalFencePropertiesKHR## a _) == + x@(VkExternalFencePropertiesKHR## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkExternalFencePropertiesKHR where + (VkExternalFencePropertiesKHR## a _) `compare` + x@(VkExternalFencePropertiesKHR## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkExternalFencePropertiesKHR where + sizeOf ~_ = #{size VkExternalFencePropertiesKHR} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkExternalFencePropertiesKHR} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkExternalFencePropertiesKHR where + unsafeAddr (VkExternalFencePropertiesKHR## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkExternalFencePropertiesKHR## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkExternalFencePropertiesKHR## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkExternalFencePropertiesKHR where + type StructFields VkExternalFencePropertiesKHR = + '["sType", "pNext", "exportFromImportedHandleTypes", -- ' closing tick for hsc2hs + "compatibleHandleTypes", "externalFenceFeatures"] + type CUnionType VkExternalFencePropertiesKHR = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkExternalFencePropertiesKHR = 'True -- ' closing tick for hsc2hs + type StructExtends VkExternalFencePropertiesKHR = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkExternalFencePropertiesKHR where + type VkSTypeMType VkExternalFencePropertiesKHR = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkExternalFencePropertiesKHR, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkExternalFencePropertiesKHR, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkExternalFencePropertiesKHR, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkExternalFencePropertiesKHR, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkExternalFencePropertiesKHR where + type FieldType "sType" VkExternalFencePropertiesKHR = + VkStructureType + type FieldOptional "sType" VkExternalFencePropertiesKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkExternalFencePropertiesKHR = + #{offset VkExternalFencePropertiesKHR, sType} + type FieldIsArray "sType" VkExternalFencePropertiesKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkExternalFencePropertiesKHR, sType} + +instance CanReadField "sType" VkExternalFencePropertiesKHR where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkExternalFencePropertiesKHR where + type VkPNextMType VkExternalFencePropertiesKHR = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkExternalFencePropertiesKHR, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkExternalFencePropertiesKHR, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkExternalFencePropertiesKHR, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkExternalFencePropertiesKHR, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkExternalFencePropertiesKHR where + type FieldType "pNext" VkExternalFencePropertiesKHR = Ptr Void + type FieldOptional "pNext" VkExternalFencePropertiesKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkExternalFencePropertiesKHR = + #{offset VkExternalFencePropertiesKHR, pNext} + type FieldIsArray "pNext" VkExternalFencePropertiesKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkExternalFencePropertiesKHR, pNext} + +instance CanReadField "pNext" VkExternalFencePropertiesKHR where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance {-# OVERLAPPING #-} + HasVkExportFromImportedHandleTypes VkExternalFencePropertiesKHR + where + type VkExportFromImportedHandleTypesMType + VkExternalFencePropertiesKHR + = VkExternalFenceHandleTypeFlagsKHR + + {-# NOINLINE vkExportFromImportedHandleTypes #-} + vkExportFromImportedHandleTypes x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkExternalFencePropertiesKHR, exportFromImportedHandleTypes}) + + {-# INLINE vkExportFromImportedHandleTypesByteOffset #-} + vkExportFromImportedHandleTypesByteOffset ~_ + = #{offset VkExternalFencePropertiesKHR, exportFromImportedHandleTypes} + + {-# INLINE readVkExportFromImportedHandleTypes #-} + readVkExportFromImportedHandleTypes p + = peekByteOff p #{offset VkExternalFencePropertiesKHR, exportFromImportedHandleTypes} + + {-# INLINE writeVkExportFromImportedHandleTypes #-} + writeVkExportFromImportedHandleTypes p + = pokeByteOff p #{offset VkExternalFencePropertiesKHR, exportFromImportedHandleTypes} + +instance {-# OVERLAPPING #-} + HasField "exportFromImportedHandleTypes" + VkExternalFencePropertiesKHR + where + type FieldType "exportFromImportedHandleTypes" + VkExternalFencePropertiesKHR + = VkExternalFenceHandleTypeFlagsKHR + type FieldOptional "exportFromImportedHandleTypes" + VkExternalFencePropertiesKHR + = 'False -- ' closing tick for hsc2hs + type FieldOffset "exportFromImportedHandleTypes" + VkExternalFencePropertiesKHR + = + #{offset VkExternalFencePropertiesKHR, exportFromImportedHandleTypes} + type FieldIsArray "exportFromImportedHandleTypes" + VkExternalFencePropertiesKHR + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkExternalFencePropertiesKHR, exportFromImportedHandleTypes} + +instance CanReadField "exportFromImportedHandleTypes" + VkExternalFencePropertiesKHR + where + {-# INLINE getField #-} + getField = vkExportFromImportedHandleTypes + + {-# INLINE readField #-} + readField = readVkExportFromImportedHandleTypes + +instance {-# OVERLAPPING #-} + HasVkCompatibleHandleTypes VkExternalFencePropertiesKHR where + type VkCompatibleHandleTypesMType VkExternalFencePropertiesKHR = + VkExternalFenceHandleTypeFlagsKHR + + {-# NOINLINE vkCompatibleHandleTypes #-} + vkCompatibleHandleTypes x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkExternalFencePropertiesKHR, compatibleHandleTypes}) + + {-# INLINE vkCompatibleHandleTypesByteOffset #-} + vkCompatibleHandleTypesByteOffset ~_ + = #{offset VkExternalFencePropertiesKHR, compatibleHandleTypes} + + {-# INLINE readVkCompatibleHandleTypes #-} + readVkCompatibleHandleTypes p + = peekByteOff p #{offset VkExternalFencePropertiesKHR, compatibleHandleTypes} + + {-# INLINE writeVkCompatibleHandleTypes #-} + writeVkCompatibleHandleTypes p + = pokeByteOff p #{offset VkExternalFencePropertiesKHR, compatibleHandleTypes} + +instance {-# OVERLAPPING #-} + HasField "compatibleHandleTypes" VkExternalFencePropertiesKHR where + type FieldType "compatibleHandleTypes" VkExternalFencePropertiesKHR + = VkExternalFenceHandleTypeFlagsKHR + type FieldOptional "compatibleHandleTypes" + VkExternalFencePropertiesKHR + = 'False -- ' closing tick for hsc2hs + type FieldOffset "compatibleHandleTypes" + VkExternalFencePropertiesKHR + = + #{offset VkExternalFencePropertiesKHR, compatibleHandleTypes} + type FieldIsArray "compatibleHandleTypes" + VkExternalFencePropertiesKHR + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkExternalFencePropertiesKHR, compatibleHandleTypes} + +instance CanReadField "compatibleHandleTypes" + VkExternalFencePropertiesKHR + where + {-# INLINE getField #-} + getField = vkCompatibleHandleTypes + + {-# INLINE readField #-} + readField = readVkCompatibleHandleTypes + +instance {-# OVERLAPPING #-} + HasVkExternalFenceFeatures VkExternalFencePropertiesKHR where + type VkExternalFenceFeaturesMType VkExternalFencePropertiesKHR = + VkExternalFenceFeatureFlagsKHR + + {-# NOINLINE vkExternalFenceFeatures #-} + vkExternalFenceFeatures x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkExternalFencePropertiesKHR, externalFenceFeatures}) + + {-# INLINE vkExternalFenceFeaturesByteOffset #-} + vkExternalFenceFeaturesByteOffset ~_ + = #{offset VkExternalFencePropertiesKHR, externalFenceFeatures} + + {-# INLINE readVkExternalFenceFeatures #-} + readVkExternalFenceFeatures p + = peekByteOff p #{offset VkExternalFencePropertiesKHR, externalFenceFeatures} + + {-# INLINE writeVkExternalFenceFeatures #-} + writeVkExternalFenceFeatures p + = pokeByteOff p #{offset VkExternalFencePropertiesKHR, externalFenceFeatures} + +instance {-# OVERLAPPING #-} + HasField "externalFenceFeatures" VkExternalFencePropertiesKHR where + type FieldType "externalFenceFeatures" VkExternalFencePropertiesKHR + = VkExternalFenceFeatureFlagsKHR + type FieldOptional "externalFenceFeatures" + VkExternalFencePropertiesKHR + = 'True -- ' closing tick for hsc2hs + type FieldOffset "externalFenceFeatures" + VkExternalFencePropertiesKHR + = + #{offset VkExternalFencePropertiesKHR, externalFenceFeatures} + type FieldIsArray "externalFenceFeatures" + VkExternalFencePropertiesKHR + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkExternalFencePropertiesKHR, externalFenceFeatures} + +instance CanReadField "externalFenceFeatures" + VkExternalFencePropertiesKHR + where + {-# INLINE getField #-} + getField = vkExternalFenceFeatures + + {-# INLINE readField #-} + readField = readVkExternalFenceFeatures + +instance Show VkExternalFencePropertiesKHR where + showsPrec d x + = showString "VkExternalFencePropertiesKHR {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkExportFromImportedHandleTypes = " . + showsPrec d (vkExportFromImportedHandleTypes x) . + showString ", " . + showString "vkCompatibleHandleTypes = " . + showsPrec d (vkCompatibleHandleTypes x) . + showString ", " . + showString "vkExternalFenceFeatures = " . + showsPrec d (vkExternalFenceFeatures x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkExternalImageFormatPropertiesKHR.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkExternalImageFormatPropertiesKHR.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkExternalImageFormatPropertiesKHR.hsc @@ -0,0 +1,245 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkExternalImageFormatPropertiesKHR + (VkExternalImageFormatPropertiesKHR(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Struct.VkExternalMemoryPropertiesKHR (VkExternalMemoryPropertiesKHR) +import Graphics.Vulkan.Types.Struct.VkImageFormatProperties2KHR (VkImageFormatProperties2KHR) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkExternalImageFormatPropertiesKHR { +-- > VkStructureType sType; +-- > void* pNext; +-- > VkExternalMemoryPropertiesKHR externalMemoryProperties; +-- > } VkExternalImageFormatPropertiesKHR; +-- +-- +data VkExternalImageFormatPropertiesKHR = VkExternalImageFormatPropertiesKHR## Addr## + ByteArray## + +instance Eq VkExternalImageFormatPropertiesKHR where + (VkExternalImageFormatPropertiesKHR## a _) == + x@(VkExternalImageFormatPropertiesKHR## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkExternalImageFormatPropertiesKHR where + (VkExternalImageFormatPropertiesKHR## a _) `compare` + x@(VkExternalImageFormatPropertiesKHR## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkExternalImageFormatPropertiesKHR where + sizeOf ~_ = #{size VkExternalImageFormatPropertiesKHR} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkExternalImageFormatPropertiesKHR} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkExternalImageFormatPropertiesKHR where + unsafeAddr (VkExternalImageFormatPropertiesKHR## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkExternalImageFormatPropertiesKHR## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkExternalImageFormatPropertiesKHR## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkExternalImageFormatPropertiesKHR where + type StructFields VkExternalImageFormatPropertiesKHR = + '["sType", "pNext", "externalMemoryProperties"] -- ' closing tick for hsc2hs + type CUnionType VkExternalImageFormatPropertiesKHR = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkExternalImageFormatPropertiesKHR = 'True -- ' closing tick for hsc2hs + type StructExtends VkExternalImageFormatPropertiesKHR = + '[VkImageFormatProperties2KHR] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkExternalImageFormatPropertiesKHR where + type VkSTypeMType VkExternalImageFormatPropertiesKHR = + VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkExternalImageFormatPropertiesKHR, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkExternalImageFormatPropertiesKHR, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkExternalImageFormatPropertiesKHR, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkExternalImageFormatPropertiesKHR, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkExternalImageFormatPropertiesKHR where + type FieldType "sType" VkExternalImageFormatPropertiesKHR = + VkStructureType + type FieldOptional "sType" VkExternalImageFormatPropertiesKHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkExternalImageFormatPropertiesKHR = + #{offset VkExternalImageFormatPropertiesKHR, sType} + type FieldIsArray "sType" VkExternalImageFormatPropertiesKHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkExternalImageFormatPropertiesKHR, sType} + +instance CanReadField "sType" VkExternalImageFormatPropertiesKHR + where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkExternalImageFormatPropertiesKHR where + type VkPNextMType VkExternalImageFormatPropertiesKHR = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkExternalImageFormatPropertiesKHR, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkExternalImageFormatPropertiesKHR, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkExternalImageFormatPropertiesKHR, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkExternalImageFormatPropertiesKHR, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkExternalImageFormatPropertiesKHR where + type FieldType "pNext" VkExternalImageFormatPropertiesKHR = + Ptr Void + type FieldOptional "pNext" VkExternalImageFormatPropertiesKHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkExternalImageFormatPropertiesKHR = + #{offset VkExternalImageFormatPropertiesKHR, pNext} + type FieldIsArray "pNext" VkExternalImageFormatPropertiesKHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkExternalImageFormatPropertiesKHR, pNext} + +instance CanReadField "pNext" VkExternalImageFormatPropertiesKHR + where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance {-# OVERLAPPING #-} + HasVkExternalMemoryProperties VkExternalImageFormatPropertiesKHR + where + type VkExternalMemoryPropertiesMType + VkExternalImageFormatPropertiesKHR + = VkExternalMemoryPropertiesKHR + + {-# NOINLINE vkExternalMemoryProperties #-} + vkExternalMemoryProperties x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkExternalImageFormatPropertiesKHR, externalMemoryProperties}) + + {-# INLINE vkExternalMemoryPropertiesByteOffset #-} + vkExternalMemoryPropertiesByteOffset ~_ + = #{offset VkExternalImageFormatPropertiesKHR, externalMemoryProperties} + + {-# INLINE readVkExternalMemoryProperties #-} + readVkExternalMemoryProperties p + = peekByteOff p #{offset VkExternalImageFormatPropertiesKHR, externalMemoryProperties} + + {-# INLINE writeVkExternalMemoryProperties #-} + writeVkExternalMemoryProperties p + = pokeByteOff p #{offset VkExternalImageFormatPropertiesKHR, externalMemoryProperties} + +instance {-# OVERLAPPING #-} + HasField "externalMemoryProperties" + VkExternalImageFormatPropertiesKHR + where + type FieldType "externalMemoryProperties" + VkExternalImageFormatPropertiesKHR + = VkExternalMemoryPropertiesKHR + type FieldOptional "externalMemoryProperties" + VkExternalImageFormatPropertiesKHR + = 'False -- ' closing tick for hsc2hs + type FieldOffset "externalMemoryProperties" + VkExternalImageFormatPropertiesKHR + = + #{offset VkExternalImageFormatPropertiesKHR, externalMemoryProperties} + type FieldIsArray "externalMemoryProperties" + VkExternalImageFormatPropertiesKHR + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkExternalImageFormatPropertiesKHR, externalMemoryProperties} + +instance CanReadField "externalMemoryProperties" + VkExternalImageFormatPropertiesKHR + where + {-# INLINE getField #-} + getField = vkExternalMemoryProperties + + {-# INLINE readField #-} + readField = readVkExternalMemoryProperties + +instance Show VkExternalImageFormatPropertiesKHR where + showsPrec d x + = showString "VkExternalImageFormatPropertiesKHR {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkExternalMemoryProperties = " . + showsPrec d (vkExternalMemoryProperties x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkExternalImageFormatPropertiesNV.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkExternalImageFormatPropertiesNV.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkExternalImageFormatPropertiesNV.hsc @@ -0,0 +1,321 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkExternalImageFormatPropertiesNV + (VkExternalImageFormatPropertiesNV(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkExternalMemoryFeatureFlagsNV (VkExternalMemoryFeatureFlagsNV) +import Graphics.Vulkan.Types.Enum.VkExternalMemoryHandleTypeFlagsNV (VkExternalMemoryHandleTypeFlagsNV) +import Graphics.Vulkan.Types.Struct.VkImageFormatProperties (VkImageFormatProperties) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkExternalImageFormatPropertiesNV { +-- > VkImageFormatProperties imageFormatProperties; +-- > VkExternalMemoryFeatureFlagsNV externalMemoryFeatures; +-- > VkExternalMemoryHandleTypeFlagsNV exportFromImportedHandleTypes; +-- > VkExternalMemoryHandleTypeFlagsNV compatibleHandleTypes; +-- > } VkExternalImageFormatPropertiesNV; +-- +-- +data VkExternalImageFormatPropertiesNV = VkExternalImageFormatPropertiesNV## Addr## + ByteArray## + +instance Eq VkExternalImageFormatPropertiesNV where + (VkExternalImageFormatPropertiesNV## a _) == + x@(VkExternalImageFormatPropertiesNV## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkExternalImageFormatPropertiesNV where + (VkExternalImageFormatPropertiesNV## a _) `compare` + x@(VkExternalImageFormatPropertiesNV## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkExternalImageFormatPropertiesNV where + sizeOf ~_ = #{size VkExternalImageFormatPropertiesNV} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkExternalImageFormatPropertiesNV} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkExternalImageFormatPropertiesNV where + unsafeAddr (VkExternalImageFormatPropertiesNV## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkExternalImageFormatPropertiesNV## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkExternalImageFormatPropertiesNV## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkExternalImageFormatPropertiesNV where + type StructFields VkExternalImageFormatPropertiesNV = + '["imageFormatProperties", "externalMemoryFeatures", -- ' closing tick for hsc2hs + "exportFromImportedHandleTypes", "compatibleHandleTypes"] + type CUnionType VkExternalImageFormatPropertiesNV = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkExternalImageFormatPropertiesNV = 'True -- ' closing tick for hsc2hs + type StructExtends VkExternalImageFormatPropertiesNV = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkImageFormatProperties VkExternalImageFormatPropertiesNV where + type VkImageFormatPropertiesMType VkExternalImageFormatPropertiesNV + = VkImageFormatProperties + + {-# NOINLINE vkImageFormatProperties #-} + vkImageFormatProperties x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkExternalImageFormatPropertiesNV, imageFormatProperties}) + + {-# INLINE vkImageFormatPropertiesByteOffset #-} + vkImageFormatPropertiesByteOffset ~_ + = #{offset VkExternalImageFormatPropertiesNV, imageFormatProperties} + + {-# INLINE readVkImageFormatProperties #-} + readVkImageFormatProperties p + = peekByteOff p #{offset VkExternalImageFormatPropertiesNV, imageFormatProperties} + + {-# INLINE writeVkImageFormatProperties #-} + writeVkImageFormatProperties p + = pokeByteOff p #{offset VkExternalImageFormatPropertiesNV, imageFormatProperties} + +instance {-# OVERLAPPING #-} + HasField "imageFormatProperties" VkExternalImageFormatPropertiesNV + where + type FieldType "imageFormatProperties" + VkExternalImageFormatPropertiesNV + = VkImageFormatProperties + type FieldOptional "imageFormatProperties" + VkExternalImageFormatPropertiesNV + = 'False -- ' closing tick for hsc2hs + type FieldOffset "imageFormatProperties" + VkExternalImageFormatPropertiesNV + = + #{offset VkExternalImageFormatPropertiesNV, imageFormatProperties} + type FieldIsArray "imageFormatProperties" + VkExternalImageFormatPropertiesNV + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkExternalImageFormatPropertiesNV, imageFormatProperties} + +instance CanReadField "imageFormatProperties" + VkExternalImageFormatPropertiesNV + where + {-# INLINE getField #-} + getField = vkImageFormatProperties + + {-# INLINE readField #-} + readField = readVkImageFormatProperties + +instance {-# OVERLAPPING #-} + HasVkExternalMemoryFeatures VkExternalImageFormatPropertiesNV where + type VkExternalMemoryFeaturesMType + VkExternalImageFormatPropertiesNV + = VkExternalMemoryFeatureFlagsNV + + {-# NOINLINE vkExternalMemoryFeatures #-} + vkExternalMemoryFeatures x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkExternalImageFormatPropertiesNV, externalMemoryFeatures}) + + {-# INLINE vkExternalMemoryFeaturesByteOffset #-} + vkExternalMemoryFeaturesByteOffset ~_ + = #{offset VkExternalImageFormatPropertiesNV, externalMemoryFeatures} + + {-# INLINE readVkExternalMemoryFeatures #-} + readVkExternalMemoryFeatures p + = peekByteOff p #{offset VkExternalImageFormatPropertiesNV, externalMemoryFeatures} + + {-# INLINE writeVkExternalMemoryFeatures #-} + writeVkExternalMemoryFeatures p + = pokeByteOff p #{offset VkExternalImageFormatPropertiesNV, externalMemoryFeatures} + +instance {-# OVERLAPPING #-} + HasField "externalMemoryFeatures" VkExternalImageFormatPropertiesNV + where + type FieldType "externalMemoryFeatures" + VkExternalImageFormatPropertiesNV + = VkExternalMemoryFeatureFlagsNV + type FieldOptional "externalMemoryFeatures" + VkExternalImageFormatPropertiesNV + = 'True -- ' closing tick for hsc2hs + type FieldOffset "externalMemoryFeatures" + VkExternalImageFormatPropertiesNV + = + #{offset VkExternalImageFormatPropertiesNV, externalMemoryFeatures} + type FieldIsArray "externalMemoryFeatures" + VkExternalImageFormatPropertiesNV + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkExternalImageFormatPropertiesNV, externalMemoryFeatures} + +instance CanReadField "externalMemoryFeatures" + VkExternalImageFormatPropertiesNV + where + {-# INLINE getField #-} + getField = vkExternalMemoryFeatures + + {-# INLINE readField #-} + readField = readVkExternalMemoryFeatures + +instance {-# OVERLAPPING #-} + HasVkExportFromImportedHandleTypes + VkExternalImageFormatPropertiesNV + where + type VkExportFromImportedHandleTypesMType + VkExternalImageFormatPropertiesNV + = VkExternalMemoryHandleTypeFlagsNV + + {-# NOINLINE vkExportFromImportedHandleTypes #-} + vkExportFromImportedHandleTypes x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkExternalImageFormatPropertiesNV, exportFromImportedHandleTypes}) + + {-# INLINE vkExportFromImportedHandleTypesByteOffset #-} + vkExportFromImportedHandleTypesByteOffset ~_ + = #{offset VkExternalImageFormatPropertiesNV, exportFromImportedHandleTypes} + + {-# INLINE readVkExportFromImportedHandleTypes #-} + readVkExportFromImportedHandleTypes p + = peekByteOff p #{offset VkExternalImageFormatPropertiesNV, exportFromImportedHandleTypes} + + {-# INLINE writeVkExportFromImportedHandleTypes #-} + writeVkExportFromImportedHandleTypes p + = pokeByteOff p #{offset VkExternalImageFormatPropertiesNV, exportFromImportedHandleTypes} + +instance {-# OVERLAPPING #-} + HasField "exportFromImportedHandleTypes" + VkExternalImageFormatPropertiesNV + where + type FieldType "exportFromImportedHandleTypes" + VkExternalImageFormatPropertiesNV + = VkExternalMemoryHandleTypeFlagsNV + type FieldOptional "exportFromImportedHandleTypes" + VkExternalImageFormatPropertiesNV + = 'True -- ' closing tick for hsc2hs + type FieldOffset "exportFromImportedHandleTypes" + VkExternalImageFormatPropertiesNV + = + #{offset VkExternalImageFormatPropertiesNV, exportFromImportedHandleTypes} + type FieldIsArray "exportFromImportedHandleTypes" + VkExternalImageFormatPropertiesNV + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkExternalImageFormatPropertiesNV, exportFromImportedHandleTypes} + +instance CanReadField "exportFromImportedHandleTypes" + VkExternalImageFormatPropertiesNV + where + {-# INLINE getField #-} + getField = vkExportFromImportedHandleTypes + + {-# INLINE readField #-} + readField = readVkExportFromImportedHandleTypes + +instance {-# OVERLAPPING #-} + HasVkCompatibleHandleTypes VkExternalImageFormatPropertiesNV where + type VkCompatibleHandleTypesMType VkExternalImageFormatPropertiesNV + = VkExternalMemoryHandleTypeFlagsNV + + {-# NOINLINE vkCompatibleHandleTypes #-} + vkCompatibleHandleTypes x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkExternalImageFormatPropertiesNV, compatibleHandleTypes}) + + {-# INLINE vkCompatibleHandleTypesByteOffset #-} + vkCompatibleHandleTypesByteOffset ~_ + = #{offset VkExternalImageFormatPropertiesNV, compatibleHandleTypes} + + {-# INLINE readVkCompatibleHandleTypes #-} + readVkCompatibleHandleTypes p + = peekByteOff p #{offset VkExternalImageFormatPropertiesNV, compatibleHandleTypes} + + {-# INLINE writeVkCompatibleHandleTypes #-} + writeVkCompatibleHandleTypes p + = pokeByteOff p #{offset VkExternalImageFormatPropertiesNV, compatibleHandleTypes} + +instance {-# OVERLAPPING #-} + HasField "compatibleHandleTypes" VkExternalImageFormatPropertiesNV + where + type FieldType "compatibleHandleTypes" + VkExternalImageFormatPropertiesNV + = VkExternalMemoryHandleTypeFlagsNV + type FieldOptional "compatibleHandleTypes" + VkExternalImageFormatPropertiesNV + = 'True -- ' closing tick for hsc2hs + type FieldOffset "compatibleHandleTypes" + VkExternalImageFormatPropertiesNV + = + #{offset VkExternalImageFormatPropertiesNV, compatibleHandleTypes} + type FieldIsArray "compatibleHandleTypes" + VkExternalImageFormatPropertiesNV + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkExternalImageFormatPropertiesNV, compatibleHandleTypes} + +instance CanReadField "compatibleHandleTypes" + VkExternalImageFormatPropertiesNV + where + {-# INLINE getField #-} + getField = vkCompatibleHandleTypes + + {-# INLINE readField #-} + readField = readVkCompatibleHandleTypes + +instance Show VkExternalImageFormatPropertiesNV where + showsPrec d x + = showString "VkExternalImageFormatPropertiesNV {" . + showString "vkImageFormatProperties = " . + showsPrec d (vkImageFormatProperties x) . + showString ", " . + showString "vkExternalMemoryFeatures = " . + showsPrec d (vkExternalMemoryFeatures x) . + showString ", " . + showString "vkExportFromImportedHandleTypes = " . + showsPrec d (vkExportFromImportedHandleTypes x) . + showString ", " . + showString "vkCompatibleHandleTypes = " . + showsPrec d (vkCompatibleHandleTypes x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkExternalMemoryBufferCreateInfoKHR.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkExternalMemoryBufferCreateInfoKHR.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkExternalMemoryBufferCreateInfoKHR.hsc @@ -0,0 +1,255 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkExternalMemoryBufferCreateInfoKHR + (VkExternalMemoryBufferCreateInfoKHR(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkExternalMemoryHandleTypeFlagsKHR (VkExternalMemoryHandleTypeFlagsKHR) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Struct.VkBufferCreateInfo (VkBufferCreateInfo) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkExternalMemoryBufferCreateInfoKHR { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkExternalMemoryHandleTypeFlagsKHR handleTypes; +-- > } VkExternalMemoryBufferCreateInfoKHR; +-- +-- +data VkExternalMemoryBufferCreateInfoKHR = VkExternalMemoryBufferCreateInfoKHR## Addr## + ByteArray## + +instance Eq VkExternalMemoryBufferCreateInfoKHR where + (VkExternalMemoryBufferCreateInfoKHR## a _) == + x@(VkExternalMemoryBufferCreateInfoKHR## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkExternalMemoryBufferCreateInfoKHR where + (VkExternalMemoryBufferCreateInfoKHR## a _) `compare` + x@(VkExternalMemoryBufferCreateInfoKHR## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkExternalMemoryBufferCreateInfoKHR where + sizeOf ~_ = #{size VkExternalMemoryBufferCreateInfoKHR} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkExternalMemoryBufferCreateInfoKHR} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkExternalMemoryBufferCreateInfoKHR + where + unsafeAddr (VkExternalMemoryBufferCreateInfoKHR## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkExternalMemoryBufferCreateInfoKHR## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkExternalMemoryBufferCreateInfoKHR## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkExternalMemoryBufferCreateInfoKHR where + type StructFields VkExternalMemoryBufferCreateInfoKHR = + '["sType", "pNext", "handleTypes"] -- ' closing tick for hsc2hs + type CUnionType VkExternalMemoryBufferCreateInfoKHR = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkExternalMemoryBufferCreateInfoKHR = 'False -- ' closing tick for hsc2hs + type StructExtends VkExternalMemoryBufferCreateInfoKHR = + '[VkBufferCreateInfo] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkExternalMemoryBufferCreateInfoKHR where + type VkSTypeMType VkExternalMemoryBufferCreateInfoKHR = + VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkExternalMemoryBufferCreateInfoKHR, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkExternalMemoryBufferCreateInfoKHR, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkExternalMemoryBufferCreateInfoKHR, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkExternalMemoryBufferCreateInfoKHR, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkExternalMemoryBufferCreateInfoKHR where + type FieldType "sType" VkExternalMemoryBufferCreateInfoKHR = + VkStructureType + type FieldOptional "sType" VkExternalMemoryBufferCreateInfoKHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkExternalMemoryBufferCreateInfoKHR = + #{offset VkExternalMemoryBufferCreateInfoKHR, sType} + type FieldIsArray "sType" VkExternalMemoryBufferCreateInfoKHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkExternalMemoryBufferCreateInfoKHR, sType} + +instance CanReadField "sType" VkExternalMemoryBufferCreateInfoKHR + where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkExternalMemoryBufferCreateInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkExternalMemoryBufferCreateInfoKHR where + type VkPNextMType VkExternalMemoryBufferCreateInfoKHR = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkExternalMemoryBufferCreateInfoKHR, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkExternalMemoryBufferCreateInfoKHR, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkExternalMemoryBufferCreateInfoKHR, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkExternalMemoryBufferCreateInfoKHR, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkExternalMemoryBufferCreateInfoKHR where + type FieldType "pNext" VkExternalMemoryBufferCreateInfoKHR = + Ptr Void + type FieldOptional "pNext" VkExternalMemoryBufferCreateInfoKHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkExternalMemoryBufferCreateInfoKHR = + #{offset VkExternalMemoryBufferCreateInfoKHR, pNext} + type FieldIsArray "pNext" VkExternalMemoryBufferCreateInfoKHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkExternalMemoryBufferCreateInfoKHR, pNext} + +instance CanReadField "pNext" VkExternalMemoryBufferCreateInfoKHR + where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkExternalMemoryBufferCreateInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkHandleTypes VkExternalMemoryBufferCreateInfoKHR where + type VkHandleTypesMType VkExternalMemoryBufferCreateInfoKHR = + VkExternalMemoryHandleTypeFlagsKHR + + {-# NOINLINE vkHandleTypes #-} + vkHandleTypes x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkExternalMemoryBufferCreateInfoKHR, handleTypes}) + + {-# INLINE vkHandleTypesByteOffset #-} + vkHandleTypesByteOffset ~_ + = #{offset VkExternalMemoryBufferCreateInfoKHR, handleTypes} + + {-# INLINE readVkHandleTypes #-} + readVkHandleTypes p + = peekByteOff p #{offset VkExternalMemoryBufferCreateInfoKHR, handleTypes} + + {-# INLINE writeVkHandleTypes #-} + writeVkHandleTypes p + = pokeByteOff p #{offset VkExternalMemoryBufferCreateInfoKHR, handleTypes} + +instance {-# OVERLAPPING #-} + HasField "handleTypes" VkExternalMemoryBufferCreateInfoKHR where + type FieldType "handleTypes" VkExternalMemoryBufferCreateInfoKHR = + VkExternalMemoryHandleTypeFlagsKHR + type FieldOptional "handleTypes" + VkExternalMemoryBufferCreateInfoKHR + = 'True -- ' closing tick for hsc2hs + type FieldOffset "handleTypes" VkExternalMemoryBufferCreateInfoKHR + = + #{offset VkExternalMemoryBufferCreateInfoKHR, handleTypes} + type FieldIsArray "handleTypes" VkExternalMemoryBufferCreateInfoKHR + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkExternalMemoryBufferCreateInfoKHR, handleTypes} + +instance CanReadField "handleTypes" + VkExternalMemoryBufferCreateInfoKHR + where + {-# INLINE getField #-} + getField = vkHandleTypes + + {-# INLINE readField #-} + readField = readVkHandleTypes + +instance CanWriteField "handleTypes" + VkExternalMemoryBufferCreateInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkHandleTypes + +instance Show VkExternalMemoryBufferCreateInfoKHR where + showsPrec d x + = showString "VkExternalMemoryBufferCreateInfoKHR {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkHandleTypes = " . + showsPrec d (vkHandleTypes x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkExternalMemoryImageCreateInfoKHR.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkExternalMemoryImageCreateInfoKHR.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkExternalMemoryImageCreateInfoKHR.hsc @@ -0,0 +1,252 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkExternalMemoryImageCreateInfoKHR + (VkExternalMemoryImageCreateInfoKHR(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkExternalMemoryHandleTypeFlagsKHR (VkExternalMemoryHandleTypeFlagsKHR) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Struct.VkImageCreateInfo (VkImageCreateInfo) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkExternalMemoryImageCreateInfoKHR { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkExternalMemoryHandleTypeFlagsKHR handleTypes; +-- > } VkExternalMemoryImageCreateInfoKHR; +-- +-- +data VkExternalMemoryImageCreateInfoKHR = VkExternalMemoryImageCreateInfoKHR## Addr## + ByteArray## + +instance Eq VkExternalMemoryImageCreateInfoKHR where + (VkExternalMemoryImageCreateInfoKHR## a _) == + x@(VkExternalMemoryImageCreateInfoKHR## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkExternalMemoryImageCreateInfoKHR where + (VkExternalMemoryImageCreateInfoKHR## a _) `compare` + x@(VkExternalMemoryImageCreateInfoKHR## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkExternalMemoryImageCreateInfoKHR where + sizeOf ~_ = #{size VkExternalMemoryImageCreateInfoKHR} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkExternalMemoryImageCreateInfoKHR} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkExternalMemoryImageCreateInfoKHR where + unsafeAddr (VkExternalMemoryImageCreateInfoKHR## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkExternalMemoryImageCreateInfoKHR## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkExternalMemoryImageCreateInfoKHR## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkExternalMemoryImageCreateInfoKHR where + type StructFields VkExternalMemoryImageCreateInfoKHR = + '["sType", "pNext", "handleTypes"] -- ' closing tick for hsc2hs + type CUnionType VkExternalMemoryImageCreateInfoKHR = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkExternalMemoryImageCreateInfoKHR = 'False -- ' closing tick for hsc2hs + type StructExtends VkExternalMemoryImageCreateInfoKHR = + '[VkImageCreateInfo] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkExternalMemoryImageCreateInfoKHR where + type VkSTypeMType VkExternalMemoryImageCreateInfoKHR = + VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkExternalMemoryImageCreateInfoKHR, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkExternalMemoryImageCreateInfoKHR, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkExternalMemoryImageCreateInfoKHR, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkExternalMemoryImageCreateInfoKHR, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkExternalMemoryImageCreateInfoKHR where + type FieldType "sType" VkExternalMemoryImageCreateInfoKHR = + VkStructureType + type FieldOptional "sType" VkExternalMemoryImageCreateInfoKHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkExternalMemoryImageCreateInfoKHR = + #{offset VkExternalMemoryImageCreateInfoKHR, sType} + type FieldIsArray "sType" VkExternalMemoryImageCreateInfoKHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkExternalMemoryImageCreateInfoKHR, sType} + +instance CanReadField "sType" VkExternalMemoryImageCreateInfoKHR + where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkExternalMemoryImageCreateInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkExternalMemoryImageCreateInfoKHR where + type VkPNextMType VkExternalMemoryImageCreateInfoKHR = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkExternalMemoryImageCreateInfoKHR, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkExternalMemoryImageCreateInfoKHR, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkExternalMemoryImageCreateInfoKHR, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkExternalMemoryImageCreateInfoKHR, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkExternalMemoryImageCreateInfoKHR where + type FieldType "pNext" VkExternalMemoryImageCreateInfoKHR = + Ptr Void + type FieldOptional "pNext" VkExternalMemoryImageCreateInfoKHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkExternalMemoryImageCreateInfoKHR = + #{offset VkExternalMemoryImageCreateInfoKHR, pNext} + type FieldIsArray "pNext" VkExternalMemoryImageCreateInfoKHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkExternalMemoryImageCreateInfoKHR, pNext} + +instance CanReadField "pNext" VkExternalMemoryImageCreateInfoKHR + where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkExternalMemoryImageCreateInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkHandleTypes VkExternalMemoryImageCreateInfoKHR where + type VkHandleTypesMType VkExternalMemoryImageCreateInfoKHR = + VkExternalMemoryHandleTypeFlagsKHR + + {-# NOINLINE vkHandleTypes #-} + vkHandleTypes x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkExternalMemoryImageCreateInfoKHR, handleTypes}) + + {-# INLINE vkHandleTypesByteOffset #-} + vkHandleTypesByteOffset ~_ + = #{offset VkExternalMemoryImageCreateInfoKHR, handleTypes} + + {-# INLINE readVkHandleTypes #-} + readVkHandleTypes p + = peekByteOff p #{offset VkExternalMemoryImageCreateInfoKHR, handleTypes} + + {-# INLINE writeVkHandleTypes #-} + writeVkHandleTypes p + = pokeByteOff p #{offset VkExternalMemoryImageCreateInfoKHR, handleTypes} + +instance {-# OVERLAPPING #-} + HasField "handleTypes" VkExternalMemoryImageCreateInfoKHR where + type FieldType "handleTypes" VkExternalMemoryImageCreateInfoKHR = + VkExternalMemoryHandleTypeFlagsKHR + type FieldOptional "handleTypes" VkExternalMemoryImageCreateInfoKHR + = 'False -- ' closing tick for hsc2hs + type FieldOffset "handleTypes" VkExternalMemoryImageCreateInfoKHR = + #{offset VkExternalMemoryImageCreateInfoKHR, handleTypes} + type FieldIsArray "handleTypes" VkExternalMemoryImageCreateInfoKHR + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkExternalMemoryImageCreateInfoKHR, handleTypes} + +instance CanReadField "handleTypes" + VkExternalMemoryImageCreateInfoKHR + where + {-# INLINE getField #-} + getField = vkHandleTypes + + {-# INLINE readField #-} + readField = readVkHandleTypes + +instance CanWriteField "handleTypes" + VkExternalMemoryImageCreateInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkHandleTypes + +instance Show VkExternalMemoryImageCreateInfoKHR where + showsPrec d x + = showString "VkExternalMemoryImageCreateInfoKHR {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkHandleTypes = " . + showsPrec d (vkHandleTypes x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkExternalMemoryImageCreateInfoNV.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkExternalMemoryImageCreateInfoNV.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkExternalMemoryImageCreateInfoNV.hsc @@ -0,0 +1,251 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkExternalMemoryImageCreateInfoNV + (VkExternalMemoryImageCreateInfoNV(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkExternalMemoryHandleTypeFlagsNV (VkExternalMemoryHandleTypeFlagsNV) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Struct.VkImageCreateInfo (VkImageCreateInfo) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkExternalMemoryImageCreateInfoNV { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkExternalMemoryHandleTypeFlagsNV handleTypes; +-- > } VkExternalMemoryImageCreateInfoNV; +-- +-- +data VkExternalMemoryImageCreateInfoNV = VkExternalMemoryImageCreateInfoNV## Addr## + ByteArray## + +instance Eq VkExternalMemoryImageCreateInfoNV where + (VkExternalMemoryImageCreateInfoNV## a _) == + x@(VkExternalMemoryImageCreateInfoNV## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkExternalMemoryImageCreateInfoNV where + (VkExternalMemoryImageCreateInfoNV## a _) `compare` + x@(VkExternalMemoryImageCreateInfoNV## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkExternalMemoryImageCreateInfoNV where + sizeOf ~_ = #{size VkExternalMemoryImageCreateInfoNV} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkExternalMemoryImageCreateInfoNV} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkExternalMemoryImageCreateInfoNV where + unsafeAddr (VkExternalMemoryImageCreateInfoNV## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkExternalMemoryImageCreateInfoNV## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkExternalMemoryImageCreateInfoNV## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkExternalMemoryImageCreateInfoNV where + type StructFields VkExternalMemoryImageCreateInfoNV = + '["sType", "pNext", "handleTypes"] -- ' closing tick for hsc2hs + type CUnionType VkExternalMemoryImageCreateInfoNV = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkExternalMemoryImageCreateInfoNV = 'False -- ' closing tick for hsc2hs + type StructExtends VkExternalMemoryImageCreateInfoNV = + '[VkImageCreateInfo] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkExternalMemoryImageCreateInfoNV where + type VkSTypeMType VkExternalMemoryImageCreateInfoNV = + VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkExternalMemoryImageCreateInfoNV, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkExternalMemoryImageCreateInfoNV, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkExternalMemoryImageCreateInfoNV, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkExternalMemoryImageCreateInfoNV, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkExternalMemoryImageCreateInfoNV where + type FieldType "sType" VkExternalMemoryImageCreateInfoNV = + VkStructureType + type FieldOptional "sType" VkExternalMemoryImageCreateInfoNV = + 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkExternalMemoryImageCreateInfoNV = + #{offset VkExternalMemoryImageCreateInfoNV, sType} + type FieldIsArray "sType" VkExternalMemoryImageCreateInfoNV = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkExternalMemoryImageCreateInfoNV, sType} + +instance CanReadField "sType" VkExternalMemoryImageCreateInfoNV + where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkExternalMemoryImageCreateInfoNV + where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkExternalMemoryImageCreateInfoNV where + type VkPNextMType VkExternalMemoryImageCreateInfoNV = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkExternalMemoryImageCreateInfoNV, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkExternalMemoryImageCreateInfoNV, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkExternalMemoryImageCreateInfoNV, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkExternalMemoryImageCreateInfoNV, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkExternalMemoryImageCreateInfoNV where + type FieldType "pNext" VkExternalMemoryImageCreateInfoNV = Ptr Void + type FieldOptional "pNext" VkExternalMemoryImageCreateInfoNV = + 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkExternalMemoryImageCreateInfoNV = + #{offset VkExternalMemoryImageCreateInfoNV, pNext} + type FieldIsArray "pNext" VkExternalMemoryImageCreateInfoNV = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkExternalMemoryImageCreateInfoNV, pNext} + +instance CanReadField "pNext" VkExternalMemoryImageCreateInfoNV + where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkExternalMemoryImageCreateInfoNV + where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkHandleTypes VkExternalMemoryImageCreateInfoNV where + type VkHandleTypesMType VkExternalMemoryImageCreateInfoNV = + VkExternalMemoryHandleTypeFlagsNV + + {-# NOINLINE vkHandleTypes #-} + vkHandleTypes x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkExternalMemoryImageCreateInfoNV, handleTypes}) + + {-# INLINE vkHandleTypesByteOffset #-} + vkHandleTypesByteOffset ~_ + = #{offset VkExternalMemoryImageCreateInfoNV, handleTypes} + + {-# INLINE readVkHandleTypes #-} + readVkHandleTypes p + = peekByteOff p #{offset VkExternalMemoryImageCreateInfoNV, handleTypes} + + {-# INLINE writeVkHandleTypes #-} + writeVkHandleTypes p + = pokeByteOff p #{offset VkExternalMemoryImageCreateInfoNV, handleTypes} + +instance {-# OVERLAPPING #-} + HasField "handleTypes" VkExternalMemoryImageCreateInfoNV where + type FieldType "handleTypes" VkExternalMemoryImageCreateInfoNV = + VkExternalMemoryHandleTypeFlagsNV + type FieldOptional "handleTypes" VkExternalMemoryImageCreateInfoNV + = 'True -- ' closing tick for hsc2hs + type FieldOffset "handleTypes" VkExternalMemoryImageCreateInfoNV = + #{offset VkExternalMemoryImageCreateInfoNV, handleTypes} + type FieldIsArray "handleTypes" VkExternalMemoryImageCreateInfoNV = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkExternalMemoryImageCreateInfoNV, handleTypes} + +instance CanReadField "handleTypes" + VkExternalMemoryImageCreateInfoNV + where + {-# INLINE getField #-} + getField = vkHandleTypes + + {-# INLINE readField #-} + readField = readVkHandleTypes + +instance CanWriteField "handleTypes" + VkExternalMemoryImageCreateInfoNV + where + {-# INLINE writeField #-} + writeField = writeVkHandleTypes + +instance Show VkExternalMemoryImageCreateInfoNV where + showsPrec d x + = showString "VkExternalMemoryImageCreateInfoNV {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkHandleTypes = " . + showsPrec d (vkHandleTypes x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkExternalMemoryPropertiesKHR.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkExternalMemoryPropertiesKHR.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkExternalMemoryPropertiesKHR.hsc @@ -0,0 +1,258 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkExternalMemoryPropertiesKHR + (VkExternalMemoryPropertiesKHR(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkExternalMemoryFeatureFlagsKHR (VkExternalMemoryFeatureFlagsKHR) +import Graphics.Vulkan.Types.Enum.VkExternalMemoryHandleTypeFlagsKHR (VkExternalMemoryHandleTypeFlagsKHR) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkExternalMemoryPropertiesKHR { +-- > VkExternalMemoryFeatureFlagsKHR externalMemoryFeatures; +-- > VkExternalMemoryHandleTypeFlagsKHR exportFromImportedHandleTypes; +-- > VkExternalMemoryHandleTypeFlagsKHR compatibleHandleTypes; +-- > } VkExternalMemoryPropertiesKHR; +-- +-- +data VkExternalMemoryPropertiesKHR = VkExternalMemoryPropertiesKHR## Addr## + ByteArray## + +instance Eq VkExternalMemoryPropertiesKHR where + (VkExternalMemoryPropertiesKHR## a _) == + x@(VkExternalMemoryPropertiesKHR## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkExternalMemoryPropertiesKHR where + (VkExternalMemoryPropertiesKHR## a _) `compare` + x@(VkExternalMemoryPropertiesKHR## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkExternalMemoryPropertiesKHR where + sizeOf ~_ = #{size VkExternalMemoryPropertiesKHR} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkExternalMemoryPropertiesKHR} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkExternalMemoryPropertiesKHR where + unsafeAddr (VkExternalMemoryPropertiesKHR## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkExternalMemoryPropertiesKHR## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkExternalMemoryPropertiesKHR## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkExternalMemoryPropertiesKHR where + type StructFields VkExternalMemoryPropertiesKHR = + '["externalMemoryFeatures", "exportFromImportedHandleTypes", -- ' closing tick for hsc2hs + "compatibleHandleTypes"] + type CUnionType VkExternalMemoryPropertiesKHR = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkExternalMemoryPropertiesKHR = 'True -- ' closing tick for hsc2hs + type StructExtends VkExternalMemoryPropertiesKHR = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkExternalMemoryFeatures VkExternalMemoryPropertiesKHR where + type VkExternalMemoryFeaturesMType VkExternalMemoryPropertiesKHR = + VkExternalMemoryFeatureFlagsKHR + + {-# NOINLINE vkExternalMemoryFeatures #-} + vkExternalMemoryFeatures x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkExternalMemoryPropertiesKHR, externalMemoryFeatures}) + + {-# INLINE vkExternalMemoryFeaturesByteOffset #-} + vkExternalMemoryFeaturesByteOffset ~_ + = #{offset VkExternalMemoryPropertiesKHR, externalMemoryFeatures} + + {-# INLINE readVkExternalMemoryFeatures #-} + readVkExternalMemoryFeatures p + = peekByteOff p #{offset VkExternalMemoryPropertiesKHR, externalMemoryFeatures} + + {-# INLINE writeVkExternalMemoryFeatures #-} + writeVkExternalMemoryFeatures p + = pokeByteOff p #{offset VkExternalMemoryPropertiesKHR, externalMemoryFeatures} + +instance {-# OVERLAPPING #-} + HasField "externalMemoryFeatures" VkExternalMemoryPropertiesKHR + where + type FieldType "externalMemoryFeatures" + VkExternalMemoryPropertiesKHR + = VkExternalMemoryFeatureFlagsKHR + type FieldOptional "externalMemoryFeatures" + VkExternalMemoryPropertiesKHR + = 'False -- ' closing tick for hsc2hs + type FieldOffset "externalMemoryFeatures" + VkExternalMemoryPropertiesKHR + = + #{offset VkExternalMemoryPropertiesKHR, externalMemoryFeatures} + type FieldIsArray "externalMemoryFeatures" + VkExternalMemoryPropertiesKHR + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkExternalMemoryPropertiesKHR, externalMemoryFeatures} + +instance CanReadField "externalMemoryFeatures" + VkExternalMemoryPropertiesKHR + where + {-# INLINE getField #-} + getField = vkExternalMemoryFeatures + + {-# INLINE readField #-} + readField = readVkExternalMemoryFeatures + +instance {-# OVERLAPPING #-} + HasVkExportFromImportedHandleTypes VkExternalMemoryPropertiesKHR + where + type VkExportFromImportedHandleTypesMType + VkExternalMemoryPropertiesKHR + = VkExternalMemoryHandleTypeFlagsKHR + + {-# NOINLINE vkExportFromImportedHandleTypes #-} + vkExportFromImportedHandleTypes x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkExternalMemoryPropertiesKHR, exportFromImportedHandleTypes}) + + {-# INLINE vkExportFromImportedHandleTypesByteOffset #-} + vkExportFromImportedHandleTypesByteOffset ~_ + = #{offset VkExternalMemoryPropertiesKHR, exportFromImportedHandleTypes} + + {-# INLINE readVkExportFromImportedHandleTypes #-} + readVkExportFromImportedHandleTypes p + = peekByteOff p #{offset VkExternalMemoryPropertiesKHR, exportFromImportedHandleTypes} + + {-# INLINE writeVkExportFromImportedHandleTypes #-} + writeVkExportFromImportedHandleTypes p + = pokeByteOff p #{offset VkExternalMemoryPropertiesKHR, exportFromImportedHandleTypes} + +instance {-# OVERLAPPING #-} + HasField "exportFromImportedHandleTypes" + VkExternalMemoryPropertiesKHR + where + type FieldType "exportFromImportedHandleTypes" + VkExternalMemoryPropertiesKHR + = VkExternalMemoryHandleTypeFlagsKHR + type FieldOptional "exportFromImportedHandleTypes" + VkExternalMemoryPropertiesKHR + = 'True -- ' closing tick for hsc2hs + type FieldOffset "exportFromImportedHandleTypes" + VkExternalMemoryPropertiesKHR + = + #{offset VkExternalMemoryPropertiesKHR, exportFromImportedHandleTypes} + type FieldIsArray "exportFromImportedHandleTypes" + VkExternalMemoryPropertiesKHR + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkExternalMemoryPropertiesKHR, exportFromImportedHandleTypes} + +instance CanReadField "exportFromImportedHandleTypes" + VkExternalMemoryPropertiesKHR + where + {-# INLINE getField #-} + getField = vkExportFromImportedHandleTypes + + {-# INLINE readField #-} + readField = readVkExportFromImportedHandleTypes + +instance {-# OVERLAPPING #-} + HasVkCompatibleHandleTypes VkExternalMemoryPropertiesKHR where + type VkCompatibleHandleTypesMType VkExternalMemoryPropertiesKHR = + VkExternalMemoryHandleTypeFlagsKHR + + {-# NOINLINE vkCompatibleHandleTypes #-} + vkCompatibleHandleTypes x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkExternalMemoryPropertiesKHR, compatibleHandleTypes}) + + {-# INLINE vkCompatibleHandleTypesByteOffset #-} + vkCompatibleHandleTypesByteOffset ~_ + = #{offset VkExternalMemoryPropertiesKHR, compatibleHandleTypes} + + {-# INLINE readVkCompatibleHandleTypes #-} + readVkCompatibleHandleTypes p + = peekByteOff p #{offset VkExternalMemoryPropertiesKHR, compatibleHandleTypes} + + {-# INLINE writeVkCompatibleHandleTypes #-} + writeVkCompatibleHandleTypes p + = pokeByteOff p #{offset VkExternalMemoryPropertiesKHR, compatibleHandleTypes} + +instance {-# OVERLAPPING #-} + HasField "compatibleHandleTypes" VkExternalMemoryPropertiesKHR + where + type FieldType "compatibleHandleTypes" + VkExternalMemoryPropertiesKHR + = VkExternalMemoryHandleTypeFlagsKHR + type FieldOptional "compatibleHandleTypes" + VkExternalMemoryPropertiesKHR + = 'False -- ' closing tick for hsc2hs + type FieldOffset "compatibleHandleTypes" + VkExternalMemoryPropertiesKHR + = + #{offset VkExternalMemoryPropertiesKHR, compatibleHandleTypes} + type FieldIsArray "compatibleHandleTypes" + VkExternalMemoryPropertiesKHR + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkExternalMemoryPropertiesKHR, compatibleHandleTypes} + +instance CanReadField "compatibleHandleTypes" + VkExternalMemoryPropertiesKHR + where + {-# INLINE getField #-} + getField = vkCompatibleHandleTypes + + {-# INLINE readField #-} + readField = readVkCompatibleHandleTypes + +instance Show VkExternalMemoryPropertiesKHR where + showsPrec d x + = showString "VkExternalMemoryPropertiesKHR {" . + showString "vkExternalMemoryFeatures = " . + showsPrec d (vkExternalMemoryFeatures x) . + showString ", " . + showString "vkExportFromImportedHandleTypes = " . + showsPrec d (vkExportFromImportedHandleTypes x) . + showString ", " . + showString "vkCompatibleHandleTypes = " . + showsPrec d (vkCompatibleHandleTypes x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkExternalSemaphorePropertiesKHR.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkExternalSemaphorePropertiesKHR.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkExternalSemaphorePropertiesKHR.hsc @@ -0,0 +1,368 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkExternalSemaphorePropertiesKHR + (VkExternalSemaphorePropertiesKHR(..)) where +import Foreign.Storable + (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkExternalSemaphoreFeatureFlagsKHR + (VkExternalSemaphoreFeatureFlagsKHR) +import Graphics.Vulkan.Types.Enum.VkExternalSemaphoreHandleTypeFlagsKHR + (VkExternalSemaphoreHandleTypeFlagsKHR) +import Graphics.Vulkan.Types.Enum.VkStructureType + (VkStructureType) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe + (unsafeDupablePerformIO) + +-- | > typedef struct VkExternalSemaphorePropertiesKHR { +-- > VkStructureType sType; +-- > void* pNext; +-- > VkExternalSemaphoreHandleTypeFlagsKHR exportFromImportedHandleTypes; +-- > VkExternalSemaphoreHandleTypeFlagsKHR compatibleHandleTypes; +-- > VkExternalSemaphoreFeatureFlagsKHR externalSemaphoreFeatures; +-- > } VkExternalSemaphorePropertiesKHR; +-- +-- +data VkExternalSemaphorePropertiesKHR = VkExternalSemaphorePropertiesKHR## Addr## + ByteArray## + +instance Eq VkExternalSemaphorePropertiesKHR where + (VkExternalSemaphorePropertiesKHR## a _) == + x@(VkExternalSemaphorePropertiesKHR## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkExternalSemaphorePropertiesKHR where + (VkExternalSemaphorePropertiesKHR## a _) `compare` + x@(VkExternalSemaphorePropertiesKHR## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkExternalSemaphorePropertiesKHR where + sizeOf ~_ = #{size VkExternalSemaphorePropertiesKHR} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkExternalSemaphorePropertiesKHR} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkExternalSemaphorePropertiesKHR where + unsafeAddr (VkExternalSemaphorePropertiesKHR## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkExternalSemaphorePropertiesKHR## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkExternalSemaphorePropertiesKHR## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkExternalSemaphorePropertiesKHR where + type StructFields VkExternalSemaphorePropertiesKHR = + '["sType", "pNext", "exportFromImportedHandleTypes", -- ' closing tick for hsc2hs + "compatibleHandleTypes", "externalSemaphoreFeatures"] + type CUnionType VkExternalSemaphorePropertiesKHR = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkExternalSemaphorePropertiesKHR = 'True -- ' closing tick for hsc2hs + type StructExtends VkExternalSemaphorePropertiesKHR = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkExternalSemaphorePropertiesKHR where + type VkSTypeMType VkExternalSemaphorePropertiesKHR = + VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkExternalSemaphorePropertiesKHR, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkExternalSemaphorePropertiesKHR, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkExternalSemaphorePropertiesKHR, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkExternalSemaphorePropertiesKHR, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkExternalSemaphorePropertiesKHR where + type FieldType "sType" VkExternalSemaphorePropertiesKHR = + VkStructureType + type FieldOptional "sType" VkExternalSemaphorePropertiesKHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkExternalSemaphorePropertiesKHR = + #{offset VkExternalSemaphorePropertiesKHR, sType} + type FieldIsArray "sType" VkExternalSemaphorePropertiesKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkExternalSemaphorePropertiesKHR, sType} + +instance CanReadField "sType" VkExternalSemaphorePropertiesKHR + where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkExternalSemaphorePropertiesKHR where + type VkPNextMType VkExternalSemaphorePropertiesKHR = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkExternalSemaphorePropertiesKHR, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkExternalSemaphorePropertiesKHR, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkExternalSemaphorePropertiesKHR, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkExternalSemaphorePropertiesKHR, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkExternalSemaphorePropertiesKHR where + type FieldType "pNext" VkExternalSemaphorePropertiesKHR = Ptr Void + type FieldOptional "pNext" VkExternalSemaphorePropertiesKHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkExternalSemaphorePropertiesKHR = + #{offset VkExternalSemaphorePropertiesKHR, pNext} + type FieldIsArray "pNext" VkExternalSemaphorePropertiesKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkExternalSemaphorePropertiesKHR, pNext} + +instance CanReadField "pNext" VkExternalSemaphorePropertiesKHR + where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance {-# OVERLAPPING #-} + HasVkExportFromImportedHandleTypes VkExternalSemaphorePropertiesKHR + where + type VkExportFromImportedHandleTypesMType + VkExternalSemaphorePropertiesKHR + = VkExternalSemaphoreHandleTypeFlagsKHR + + {-# NOINLINE vkExportFromImportedHandleTypes #-} + vkExportFromImportedHandleTypes x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkExternalSemaphorePropertiesKHR, exportFromImportedHandleTypes}) + + {-# INLINE vkExportFromImportedHandleTypesByteOffset #-} + vkExportFromImportedHandleTypesByteOffset ~_ + = #{offset VkExternalSemaphorePropertiesKHR, exportFromImportedHandleTypes} + + {-# INLINE readVkExportFromImportedHandleTypes #-} + readVkExportFromImportedHandleTypes p + = peekByteOff p #{offset VkExternalSemaphorePropertiesKHR, exportFromImportedHandleTypes} + + {-# INLINE writeVkExportFromImportedHandleTypes #-} + writeVkExportFromImportedHandleTypes p + = pokeByteOff p #{offset VkExternalSemaphorePropertiesKHR, exportFromImportedHandleTypes} + +instance {-# OVERLAPPING #-} + HasField "exportFromImportedHandleTypes" + VkExternalSemaphorePropertiesKHR + where + type FieldType "exportFromImportedHandleTypes" + VkExternalSemaphorePropertiesKHR + = VkExternalSemaphoreHandleTypeFlagsKHR + type FieldOptional "exportFromImportedHandleTypes" + VkExternalSemaphorePropertiesKHR + = 'False -- ' closing tick for hsc2hs + type FieldOffset "exportFromImportedHandleTypes" + VkExternalSemaphorePropertiesKHR + = + #{offset VkExternalSemaphorePropertiesKHR, exportFromImportedHandleTypes} + type FieldIsArray "exportFromImportedHandleTypes" + VkExternalSemaphorePropertiesKHR + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkExternalSemaphorePropertiesKHR, exportFromImportedHandleTypes} + +instance CanReadField "exportFromImportedHandleTypes" + VkExternalSemaphorePropertiesKHR + where + {-# INLINE getField #-} + getField = vkExportFromImportedHandleTypes + + {-# INLINE readField #-} + readField = readVkExportFromImportedHandleTypes + +instance {-# OVERLAPPING #-} + HasVkCompatibleHandleTypes VkExternalSemaphorePropertiesKHR where + type VkCompatibleHandleTypesMType VkExternalSemaphorePropertiesKHR + = VkExternalSemaphoreHandleTypeFlagsKHR + + {-# NOINLINE vkCompatibleHandleTypes #-} + vkCompatibleHandleTypes x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkExternalSemaphorePropertiesKHR, compatibleHandleTypes}) + + {-# INLINE vkCompatibleHandleTypesByteOffset #-} + vkCompatibleHandleTypesByteOffset ~_ + = #{offset VkExternalSemaphorePropertiesKHR, compatibleHandleTypes} + + {-# INLINE readVkCompatibleHandleTypes #-} + readVkCompatibleHandleTypes p + = peekByteOff p #{offset VkExternalSemaphorePropertiesKHR, compatibleHandleTypes} + + {-# INLINE writeVkCompatibleHandleTypes #-} + writeVkCompatibleHandleTypes p + = pokeByteOff p #{offset VkExternalSemaphorePropertiesKHR, compatibleHandleTypes} + +instance {-# OVERLAPPING #-} + HasField "compatibleHandleTypes" VkExternalSemaphorePropertiesKHR + where + type FieldType "compatibleHandleTypes" + VkExternalSemaphorePropertiesKHR + = VkExternalSemaphoreHandleTypeFlagsKHR + type FieldOptional "compatibleHandleTypes" + VkExternalSemaphorePropertiesKHR + = 'False -- ' closing tick for hsc2hs + type FieldOffset "compatibleHandleTypes" + VkExternalSemaphorePropertiesKHR + = + #{offset VkExternalSemaphorePropertiesKHR, compatibleHandleTypes} + type FieldIsArray "compatibleHandleTypes" + VkExternalSemaphorePropertiesKHR + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkExternalSemaphorePropertiesKHR, compatibleHandleTypes} + +instance CanReadField "compatibleHandleTypes" + VkExternalSemaphorePropertiesKHR + where + {-# INLINE getField #-} + getField = vkCompatibleHandleTypes + + {-# INLINE readField #-} + readField = readVkCompatibleHandleTypes + +instance {-# OVERLAPPING #-} + HasVkExternalSemaphoreFeatures VkExternalSemaphorePropertiesKHR + where + type VkExternalSemaphoreFeaturesMType + VkExternalSemaphorePropertiesKHR + = VkExternalSemaphoreFeatureFlagsKHR + + {-# NOINLINE vkExternalSemaphoreFeatures #-} + vkExternalSemaphoreFeatures x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkExternalSemaphorePropertiesKHR, externalSemaphoreFeatures}) + + {-# INLINE vkExternalSemaphoreFeaturesByteOffset #-} + vkExternalSemaphoreFeaturesByteOffset ~_ + = #{offset VkExternalSemaphorePropertiesKHR, externalSemaphoreFeatures} + + {-# INLINE readVkExternalSemaphoreFeatures #-} + readVkExternalSemaphoreFeatures p + = peekByteOff p #{offset VkExternalSemaphorePropertiesKHR, externalSemaphoreFeatures} + + {-# INLINE writeVkExternalSemaphoreFeatures #-} + writeVkExternalSemaphoreFeatures p + = pokeByteOff p #{offset VkExternalSemaphorePropertiesKHR, externalSemaphoreFeatures} + +instance {-# OVERLAPPING #-} + HasField "externalSemaphoreFeatures" + VkExternalSemaphorePropertiesKHR + where + type FieldType "externalSemaphoreFeatures" + VkExternalSemaphorePropertiesKHR + = VkExternalSemaphoreFeatureFlagsKHR + type FieldOptional "externalSemaphoreFeatures" + VkExternalSemaphorePropertiesKHR + = 'True -- ' closing tick for hsc2hs + type FieldOffset "externalSemaphoreFeatures" + VkExternalSemaphorePropertiesKHR + = + #{offset VkExternalSemaphorePropertiesKHR, externalSemaphoreFeatures} + type FieldIsArray "externalSemaphoreFeatures" + VkExternalSemaphorePropertiesKHR + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkExternalSemaphorePropertiesKHR, externalSemaphoreFeatures} + +instance CanReadField "externalSemaphoreFeatures" + VkExternalSemaphorePropertiesKHR + where + {-# INLINE getField #-} + getField = vkExternalSemaphoreFeatures + + {-# INLINE readField #-} + readField = readVkExternalSemaphoreFeatures + +instance Show VkExternalSemaphorePropertiesKHR where + showsPrec d x + = showString "VkExternalSemaphorePropertiesKHR {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkExportFromImportedHandleTypes = " . + showsPrec d (vkExportFromImportedHandleTypes x) . + showString ", " . + showString "vkCompatibleHandleTypes = " . + showsPrec d (vkCompatibleHandleTypes x) . + showString ", " . + showString "vkExternalSemaphoreFeatures = " . + showsPrec d (vkExternalSemaphoreFeatures x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkFenceCreateInfo.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkFenceCreateInfo.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkFenceCreateInfo.hsc @@ -0,0 +1,217 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkFenceCreateInfo + (VkFenceCreateInfo(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkFenceCreateFlags (VkFenceCreateFlags) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkFenceCreateInfo { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkFenceCreateFlags flags; +-- > } VkFenceCreateInfo; +-- +-- +data VkFenceCreateInfo = VkFenceCreateInfo## Addr## ByteArray## + +instance Eq VkFenceCreateInfo where + (VkFenceCreateInfo## a _) == x@(VkFenceCreateInfo## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkFenceCreateInfo where + (VkFenceCreateInfo## a _) `compare` x@(VkFenceCreateInfo## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkFenceCreateInfo where + sizeOf ~_ = #{size VkFenceCreateInfo} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkFenceCreateInfo} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkFenceCreateInfo where + unsafeAddr (VkFenceCreateInfo## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkFenceCreateInfo## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkFenceCreateInfo## (plusAddr## (byteArrayContents## b) off) b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkFenceCreateInfo where + type StructFields VkFenceCreateInfo = '["sType", "pNext", "flags"] -- ' closing tick for hsc2hs + type CUnionType VkFenceCreateInfo = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkFenceCreateInfo = 'False -- ' closing tick for hsc2hs + type StructExtends VkFenceCreateInfo = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkSType VkFenceCreateInfo where + type VkSTypeMType VkFenceCreateInfo = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkFenceCreateInfo, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkFenceCreateInfo, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkFenceCreateInfo, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkFenceCreateInfo, sType} + +instance {-# OVERLAPPING #-} HasField "sType" VkFenceCreateInfo + where + type FieldType "sType" VkFenceCreateInfo = VkStructureType + type FieldOptional "sType" VkFenceCreateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkFenceCreateInfo = + #{offset VkFenceCreateInfo, sType} + type FieldIsArray "sType" VkFenceCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkFenceCreateInfo, sType} + +instance CanReadField "sType" VkFenceCreateInfo where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkFenceCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} HasVkPNext VkFenceCreateInfo where + type VkPNextMType VkFenceCreateInfo = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkFenceCreateInfo, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkFenceCreateInfo, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkFenceCreateInfo, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkFenceCreateInfo, pNext} + +instance {-# OVERLAPPING #-} HasField "pNext" VkFenceCreateInfo + where + type FieldType "pNext" VkFenceCreateInfo = Ptr Void + type FieldOptional "pNext" VkFenceCreateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkFenceCreateInfo = + #{offset VkFenceCreateInfo, pNext} + type FieldIsArray "pNext" VkFenceCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkFenceCreateInfo, pNext} + +instance CanReadField "pNext" VkFenceCreateInfo where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkFenceCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} HasVkFlags VkFenceCreateInfo where + type VkFlagsMType VkFenceCreateInfo = VkFenceCreateFlags + + {-# NOINLINE vkFlags #-} + vkFlags x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkFenceCreateInfo, flags}) + + {-# INLINE vkFlagsByteOffset #-} + vkFlagsByteOffset ~_ + = #{offset VkFenceCreateInfo, flags} + + {-# INLINE readVkFlags #-} + readVkFlags p + = peekByteOff p #{offset VkFenceCreateInfo, flags} + + {-# INLINE writeVkFlags #-} + writeVkFlags p + = pokeByteOff p #{offset VkFenceCreateInfo, flags} + +instance {-# OVERLAPPING #-} HasField "flags" VkFenceCreateInfo + where + type FieldType "flags" VkFenceCreateInfo = VkFenceCreateFlags + type FieldOptional "flags" VkFenceCreateInfo = 'True -- ' closing tick for hsc2hs + type FieldOffset "flags" VkFenceCreateInfo = + #{offset VkFenceCreateInfo, flags} + type FieldIsArray "flags" VkFenceCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkFenceCreateInfo, flags} + +instance CanReadField "flags" VkFenceCreateInfo where + {-# INLINE getField #-} + getField = vkFlags + + {-# INLINE readField #-} + readField = readVkFlags + +instance CanWriteField "flags" VkFenceCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkFlags + +instance Show VkFenceCreateInfo where + showsPrec d x + = showString "VkFenceCreateInfo {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkFlags = " . showsPrec d (vkFlags x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkFenceGetFdInfoKHR.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkFenceGetFdInfoKHR.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkFenceGetFdInfoKHR.hsc @@ -0,0 +1,272 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkFenceGetFdInfoKHR + (VkFenceGetFdInfoKHR(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkExternalFenceHandleTypeFlagsKHR (VkExternalFenceHandleTypeFlagBitsKHR) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Handles (VkFence) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkFenceGetFdInfoKHR { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkFence fence; +-- > VkExternalFenceHandleTypeFlagBitsKHR handleType; +-- > } VkFenceGetFdInfoKHR; +-- +-- +data VkFenceGetFdInfoKHR = VkFenceGetFdInfoKHR## Addr## ByteArray## + +instance Eq VkFenceGetFdInfoKHR where + (VkFenceGetFdInfoKHR## a _) == x@(VkFenceGetFdInfoKHR## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkFenceGetFdInfoKHR where + (VkFenceGetFdInfoKHR## a _) `compare` x@(VkFenceGetFdInfoKHR## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkFenceGetFdInfoKHR where + sizeOf ~_ = #{size VkFenceGetFdInfoKHR} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkFenceGetFdInfoKHR} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkFenceGetFdInfoKHR where + unsafeAddr (VkFenceGetFdInfoKHR## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkFenceGetFdInfoKHR## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkFenceGetFdInfoKHR## (plusAddr## (byteArrayContents## b) off) b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkFenceGetFdInfoKHR where + type StructFields VkFenceGetFdInfoKHR = + '["sType", "pNext", "fence", "handleType"] -- ' closing tick for hsc2hs + type CUnionType VkFenceGetFdInfoKHR = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkFenceGetFdInfoKHR = 'False -- ' closing tick for hsc2hs + type StructExtends VkFenceGetFdInfoKHR = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkSType VkFenceGetFdInfoKHR where + type VkSTypeMType VkFenceGetFdInfoKHR = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkFenceGetFdInfoKHR, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkFenceGetFdInfoKHR, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkFenceGetFdInfoKHR, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkFenceGetFdInfoKHR, sType} + +instance {-# OVERLAPPING #-} HasField "sType" VkFenceGetFdInfoKHR + where + type FieldType "sType" VkFenceGetFdInfoKHR = VkStructureType + type FieldOptional "sType" VkFenceGetFdInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkFenceGetFdInfoKHR = + #{offset VkFenceGetFdInfoKHR, sType} + type FieldIsArray "sType" VkFenceGetFdInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkFenceGetFdInfoKHR, sType} + +instance CanReadField "sType" VkFenceGetFdInfoKHR where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkFenceGetFdInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} HasVkPNext VkFenceGetFdInfoKHR where + type VkPNextMType VkFenceGetFdInfoKHR = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkFenceGetFdInfoKHR, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkFenceGetFdInfoKHR, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkFenceGetFdInfoKHR, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkFenceGetFdInfoKHR, pNext} + +instance {-# OVERLAPPING #-} HasField "pNext" VkFenceGetFdInfoKHR + where + type FieldType "pNext" VkFenceGetFdInfoKHR = Ptr Void + type FieldOptional "pNext" VkFenceGetFdInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkFenceGetFdInfoKHR = + #{offset VkFenceGetFdInfoKHR, pNext} + type FieldIsArray "pNext" VkFenceGetFdInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkFenceGetFdInfoKHR, pNext} + +instance CanReadField "pNext" VkFenceGetFdInfoKHR where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkFenceGetFdInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} HasVkFence VkFenceGetFdInfoKHR where + type VkFenceMType VkFenceGetFdInfoKHR = VkFence + + {-# NOINLINE vkFence #-} + vkFence x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkFenceGetFdInfoKHR, fence}) + + {-# INLINE vkFenceByteOffset #-} + vkFenceByteOffset ~_ + = #{offset VkFenceGetFdInfoKHR, fence} + + {-# INLINE readVkFence #-} + readVkFence p + = peekByteOff p #{offset VkFenceGetFdInfoKHR, fence} + + {-# INLINE writeVkFence #-} + writeVkFence p + = pokeByteOff p #{offset VkFenceGetFdInfoKHR, fence} + +instance {-# OVERLAPPING #-} HasField "fence" VkFenceGetFdInfoKHR + where + type FieldType "fence" VkFenceGetFdInfoKHR = VkFence + type FieldOptional "fence" VkFenceGetFdInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "fence" VkFenceGetFdInfoKHR = + #{offset VkFenceGetFdInfoKHR, fence} + type FieldIsArray "fence" VkFenceGetFdInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkFenceGetFdInfoKHR, fence} + +instance CanReadField "fence" VkFenceGetFdInfoKHR where + {-# INLINE getField #-} + getField = vkFence + + {-# INLINE readField #-} + readField = readVkFence + +instance CanWriteField "fence" VkFenceGetFdInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkFence + +instance {-# OVERLAPPING #-} HasVkHandleType VkFenceGetFdInfoKHR + where + type VkHandleTypeMType VkFenceGetFdInfoKHR = + VkExternalFenceHandleTypeFlagBitsKHR + + {-# NOINLINE vkHandleType #-} + vkHandleType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkFenceGetFdInfoKHR, handleType}) + + {-# INLINE vkHandleTypeByteOffset #-} + vkHandleTypeByteOffset ~_ + = #{offset VkFenceGetFdInfoKHR, handleType} + + {-# INLINE readVkHandleType #-} + readVkHandleType p + = peekByteOff p #{offset VkFenceGetFdInfoKHR, handleType} + + {-# INLINE writeVkHandleType #-} + writeVkHandleType p + = pokeByteOff p #{offset VkFenceGetFdInfoKHR, handleType} + +instance {-# OVERLAPPING #-} + HasField "handleType" VkFenceGetFdInfoKHR where + type FieldType "handleType" VkFenceGetFdInfoKHR = + VkExternalFenceHandleTypeFlagBitsKHR + type FieldOptional "handleType" VkFenceGetFdInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "handleType" VkFenceGetFdInfoKHR = + #{offset VkFenceGetFdInfoKHR, handleType} + type FieldIsArray "handleType" VkFenceGetFdInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkFenceGetFdInfoKHR, handleType} + +instance CanReadField "handleType" VkFenceGetFdInfoKHR where + {-# INLINE getField #-} + getField = vkHandleType + + {-# INLINE readField #-} + readField = readVkHandleType + +instance CanWriteField "handleType" VkFenceGetFdInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkHandleType + +instance Show VkFenceGetFdInfoKHR where + showsPrec d x + = showString "VkFenceGetFdInfoKHR {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkFence = " . + showsPrec d (vkFence x) . + showString ", " . + showString "vkHandleType = " . + showsPrec d (vkHandleType x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkFenceGetWin32HandleInfoKHR.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkFenceGetWin32HandleInfoKHR.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkFenceGetWin32HandleInfoKHR.hsc @@ -0,0 +1,289 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkFenceGetWin32HandleInfoKHR + (VkFenceGetWin32HandleInfoKHR(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkExternalFenceHandleTypeFlagsKHR (VkExternalFenceHandleTypeFlagBitsKHR) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Handles (VkFence) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkFenceGetWin32HandleInfoKHR { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkFence fence; +-- > VkExternalFenceHandleTypeFlagBitsKHR handleType; +-- > } VkFenceGetWin32HandleInfoKHR; +-- +-- +data VkFenceGetWin32HandleInfoKHR = VkFenceGetWin32HandleInfoKHR## Addr## + ByteArray## + +instance Eq VkFenceGetWin32HandleInfoKHR where + (VkFenceGetWin32HandleInfoKHR## a _) == + x@(VkFenceGetWin32HandleInfoKHR## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkFenceGetWin32HandleInfoKHR where + (VkFenceGetWin32HandleInfoKHR## a _) `compare` + x@(VkFenceGetWin32HandleInfoKHR## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkFenceGetWin32HandleInfoKHR where + sizeOf ~_ = #{size VkFenceGetWin32HandleInfoKHR} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkFenceGetWin32HandleInfoKHR} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkFenceGetWin32HandleInfoKHR where + unsafeAddr (VkFenceGetWin32HandleInfoKHR## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkFenceGetWin32HandleInfoKHR## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkFenceGetWin32HandleInfoKHR## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkFenceGetWin32HandleInfoKHR where + type StructFields VkFenceGetWin32HandleInfoKHR = + '["sType", "pNext", "fence", "handleType"] -- ' closing tick for hsc2hs + type CUnionType VkFenceGetWin32HandleInfoKHR = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkFenceGetWin32HandleInfoKHR = 'False -- ' closing tick for hsc2hs + type StructExtends VkFenceGetWin32HandleInfoKHR = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkFenceGetWin32HandleInfoKHR where + type VkSTypeMType VkFenceGetWin32HandleInfoKHR = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkFenceGetWin32HandleInfoKHR, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkFenceGetWin32HandleInfoKHR, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkFenceGetWin32HandleInfoKHR, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkFenceGetWin32HandleInfoKHR, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkFenceGetWin32HandleInfoKHR where + type FieldType "sType" VkFenceGetWin32HandleInfoKHR = + VkStructureType + type FieldOptional "sType" VkFenceGetWin32HandleInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkFenceGetWin32HandleInfoKHR = + #{offset VkFenceGetWin32HandleInfoKHR, sType} + type FieldIsArray "sType" VkFenceGetWin32HandleInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkFenceGetWin32HandleInfoKHR, sType} + +instance CanReadField "sType" VkFenceGetWin32HandleInfoKHR where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkFenceGetWin32HandleInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkFenceGetWin32HandleInfoKHR where + type VkPNextMType VkFenceGetWin32HandleInfoKHR = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkFenceGetWin32HandleInfoKHR, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkFenceGetWin32HandleInfoKHR, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkFenceGetWin32HandleInfoKHR, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkFenceGetWin32HandleInfoKHR, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkFenceGetWin32HandleInfoKHR where + type FieldType "pNext" VkFenceGetWin32HandleInfoKHR = Ptr Void + type FieldOptional "pNext" VkFenceGetWin32HandleInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkFenceGetWin32HandleInfoKHR = + #{offset VkFenceGetWin32HandleInfoKHR, pNext} + type FieldIsArray "pNext" VkFenceGetWin32HandleInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkFenceGetWin32HandleInfoKHR, pNext} + +instance CanReadField "pNext" VkFenceGetWin32HandleInfoKHR where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkFenceGetWin32HandleInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkFence VkFenceGetWin32HandleInfoKHR where + type VkFenceMType VkFenceGetWin32HandleInfoKHR = VkFence + + {-# NOINLINE vkFence #-} + vkFence x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkFenceGetWin32HandleInfoKHR, fence}) + + {-# INLINE vkFenceByteOffset #-} + vkFenceByteOffset ~_ + = #{offset VkFenceGetWin32HandleInfoKHR, fence} + + {-# INLINE readVkFence #-} + readVkFence p + = peekByteOff p #{offset VkFenceGetWin32HandleInfoKHR, fence} + + {-# INLINE writeVkFence #-} + writeVkFence p + = pokeByteOff p #{offset VkFenceGetWin32HandleInfoKHR, fence} + +instance {-# OVERLAPPING #-} + HasField "fence" VkFenceGetWin32HandleInfoKHR where + type FieldType "fence" VkFenceGetWin32HandleInfoKHR = VkFence + type FieldOptional "fence" VkFenceGetWin32HandleInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "fence" VkFenceGetWin32HandleInfoKHR = + #{offset VkFenceGetWin32HandleInfoKHR, fence} + type FieldIsArray "fence" VkFenceGetWin32HandleInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkFenceGetWin32HandleInfoKHR, fence} + +instance CanReadField "fence" VkFenceGetWin32HandleInfoKHR where + {-# INLINE getField #-} + getField = vkFence + + {-# INLINE readField #-} + readField = readVkFence + +instance CanWriteField "fence" VkFenceGetWin32HandleInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkFence + +instance {-# OVERLAPPING #-} + HasVkHandleType VkFenceGetWin32HandleInfoKHR where + type VkHandleTypeMType VkFenceGetWin32HandleInfoKHR = + VkExternalFenceHandleTypeFlagBitsKHR + + {-# NOINLINE vkHandleType #-} + vkHandleType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkFenceGetWin32HandleInfoKHR, handleType}) + + {-# INLINE vkHandleTypeByteOffset #-} + vkHandleTypeByteOffset ~_ + = #{offset VkFenceGetWin32HandleInfoKHR, handleType} + + {-# INLINE readVkHandleType #-} + readVkHandleType p + = peekByteOff p #{offset VkFenceGetWin32HandleInfoKHR, handleType} + + {-# INLINE writeVkHandleType #-} + writeVkHandleType p + = pokeByteOff p #{offset VkFenceGetWin32HandleInfoKHR, handleType} + +instance {-# OVERLAPPING #-} + HasField "handleType" VkFenceGetWin32HandleInfoKHR where + type FieldType "handleType" VkFenceGetWin32HandleInfoKHR = + VkExternalFenceHandleTypeFlagBitsKHR + type FieldOptional "handleType" VkFenceGetWin32HandleInfoKHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "handleType" VkFenceGetWin32HandleInfoKHR = + #{offset VkFenceGetWin32HandleInfoKHR, handleType} + type FieldIsArray "handleType" VkFenceGetWin32HandleInfoKHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkFenceGetWin32HandleInfoKHR, handleType} + +instance CanReadField "handleType" VkFenceGetWin32HandleInfoKHR + where + {-# INLINE getField #-} + getField = vkHandleType + + {-# INLINE readField #-} + readField = readVkHandleType + +instance CanWriteField "handleType" VkFenceGetWin32HandleInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkHandleType + +instance Show VkFenceGetWin32HandleInfoKHR where + showsPrec d x + = showString "VkFenceGetWin32HandleInfoKHR {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkFence = " . + showsPrec d (vkFence x) . + showString ", " . + showString "vkHandleType = " . + showsPrec d (vkHandleType x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkFormatProperties.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkFormatProperties.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkFormatProperties.hsc @@ -0,0 +1,225 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkFormatProperties + (VkFormatProperties(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkFormatFeatureFlags (VkFormatFeatureFlags) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkFormatProperties { +-- > VkFormatFeatureFlags linearTilingFeatures; +-- > VkFormatFeatureFlags optimalTilingFeatures; +-- > VkFormatFeatureFlags bufferFeatures; +-- > } VkFormatProperties; +-- +-- +data VkFormatProperties = VkFormatProperties## Addr## ByteArray## + +instance Eq VkFormatProperties where + (VkFormatProperties## a _) == x@(VkFormatProperties## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkFormatProperties where + (VkFormatProperties## a _) `compare` x@(VkFormatProperties## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkFormatProperties where + sizeOf ~_ = #{size VkFormatProperties} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkFormatProperties} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkFormatProperties where + unsafeAddr (VkFormatProperties## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkFormatProperties## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkFormatProperties## (plusAddr## (byteArrayContents## b) off) b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkFormatProperties where + type StructFields VkFormatProperties = + '["linearTilingFeatures", "optimalTilingFeatures", -- ' closing tick for hsc2hs + "bufferFeatures"] + type CUnionType VkFormatProperties = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkFormatProperties = 'True -- ' closing tick for hsc2hs + type StructExtends VkFormatProperties = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkLinearTilingFeatures VkFormatProperties where + type VkLinearTilingFeaturesMType VkFormatProperties = + VkFormatFeatureFlags + + {-# NOINLINE vkLinearTilingFeatures #-} + vkLinearTilingFeatures x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkFormatProperties, linearTilingFeatures}) + + {-# INLINE vkLinearTilingFeaturesByteOffset #-} + vkLinearTilingFeaturesByteOffset ~_ + = #{offset VkFormatProperties, linearTilingFeatures} + + {-# INLINE readVkLinearTilingFeatures #-} + readVkLinearTilingFeatures p + = peekByteOff p #{offset VkFormatProperties, linearTilingFeatures} + + {-# INLINE writeVkLinearTilingFeatures #-} + writeVkLinearTilingFeatures p + = pokeByteOff p #{offset VkFormatProperties, linearTilingFeatures} + +instance {-# OVERLAPPING #-} + HasField "linearTilingFeatures" VkFormatProperties where + type FieldType "linearTilingFeatures" VkFormatProperties = + VkFormatFeatureFlags + type FieldOptional "linearTilingFeatures" VkFormatProperties = + 'True -- ' closing tick for hsc2hs + type FieldOffset "linearTilingFeatures" VkFormatProperties = + #{offset VkFormatProperties, linearTilingFeatures} + type FieldIsArray "linearTilingFeatures" VkFormatProperties = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkFormatProperties, linearTilingFeatures} + +instance CanReadField "linearTilingFeatures" VkFormatProperties + where + {-# INLINE getField #-} + getField = vkLinearTilingFeatures + + {-# INLINE readField #-} + readField = readVkLinearTilingFeatures + +instance {-# OVERLAPPING #-} + HasVkOptimalTilingFeatures VkFormatProperties where + type VkOptimalTilingFeaturesMType VkFormatProperties = + VkFormatFeatureFlags + + {-# NOINLINE vkOptimalTilingFeatures #-} + vkOptimalTilingFeatures x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkFormatProperties, optimalTilingFeatures}) + + {-# INLINE vkOptimalTilingFeaturesByteOffset #-} + vkOptimalTilingFeaturesByteOffset ~_ + = #{offset VkFormatProperties, optimalTilingFeatures} + + {-# INLINE readVkOptimalTilingFeatures #-} + readVkOptimalTilingFeatures p + = peekByteOff p #{offset VkFormatProperties, optimalTilingFeatures} + + {-# INLINE writeVkOptimalTilingFeatures #-} + writeVkOptimalTilingFeatures p + = pokeByteOff p #{offset VkFormatProperties, optimalTilingFeatures} + +instance {-# OVERLAPPING #-} + HasField "optimalTilingFeatures" VkFormatProperties where + type FieldType "optimalTilingFeatures" VkFormatProperties = + VkFormatFeatureFlags + type FieldOptional "optimalTilingFeatures" VkFormatProperties = + 'True -- ' closing tick for hsc2hs + type FieldOffset "optimalTilingFeatures" VkFormatProperties = + #{offset VkFormatProperties, optimalTilingFeatures} + type FieldIsArray "optimalTilingFeatures" VkFormatProperties = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkFormatProperties, optimalTilingFeatures} + +instance CanReadField "optimalTilingFeatures" VkFormatProperties + where + {-# INLINE getField #-} + getField = vkOptimalTilingFeatures + + {-# INLINE readField #-} + readField = readVkOptimalTilingFeatures + +instance {-# OVERLAPPING #-} HasVkBufferFeatures VkFormatProperties + where + type VkBufferFeaturesMType VkFormatProperties = + VkFormatFeatureFlags + + {-# NOINLINE vkBufferFeatures #-} + vkBufferFeatures x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkFormatProperties, bufferFeatures}) + + {-# INLINE vkBufferFeaturesByteOffset #-} + vkBufferFeaturesByteOffset ~_ + = #{offset VkFormatProperties, bufferFeatures} + + {-# INLINE readVkBufferFeatures #-} + readVkBufferFeatures p + = peekByteOff p #{offset VkFormatProperties, bufferFeatures} + + {-# INLINE writeVkBufferFeatures #-} + writeVkBufferFeatures p + = pokeByteOff p #{offset VkFormatProperties, bufferFeatures} + +instance {-# OVERLAPPING #-} + HasField "bufferFeatures" VkFormatProperties where + type FieldType "bufferFeatures" VkFormatProperties = + VkFormatFeatureFlags + type FieldOptional "bufferFeatures" VkFormatProperties = 'True -- ' closing tick for hsc2hs + type FieldOffset "bufferFeatures" VkFormatProperties = + #{offset VkFormatProperties, bufferFeatures} + type FieldIsArray "bufferFeatures" VkFormatProperties = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkFormatProperties, bufferFeatures} + +instance CanReadField "bufferFeatures" VkFormatProperties where + {-# INLINE getField #-} + getField = vkBufferFeatures + + {-# INLINE readField #-} + readField = readVkBufferFeatures + +instance Show VkFormatProperties where + showsPrec d x + = showString "VkFormatProperties {" . + showString "vkLinearTilingFeatures = " . + showsPrec d (vkLinearTilingFeatures x) . + showString ", " . + showString "vkOptimalTilingFeatures = " . + showsPrec d (vkOptimalTilingFeatures x) . + showString ", " . + showString "vkBufferFeatures = " . + showsPrec d (vkBufferFeatures x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkFormatProperties2KHR.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkFormatProperties2KHR.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkFormatProperties2KHR.hsc @@ -0,0 +1,217 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkFormatProperties2KHR + (VkFormatProperties2KHR(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Struct.VkFormatProperties (VkFormatProperties) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkFormatProperties2KHR { +-- > VkStructureType sType; +-- > void* pNext; +-- > VkFormatProperties formatProperties; +-- > } VkFormatProperties2KHR; +-- +-- +data VkFormatProperties2KHR = VkFormatProperties2KHR## Addr## + ByteArray## + +instance Eq VkFormatProperties2KHR where + (VkFormatProperties2KHR## a _) == x@(VkFormatProperties2KHR## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkFormatProperties2KHR where + (VkFormatProperties2KHR## a _) `compare` + x@(VkFormatProperties2KHR## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkFormatProperties2KHR where + sizeOf ~_ = #{size VkFormatProperties2KHR} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkFormatProperties2KHR} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkFormatProperties2KHR where + unsafeAddr (VkFormatProperties2KHR## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkFormatProperties2KHR## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkFormatProperties2KHR## (plusAddr## (byteArrayContents## b) off) b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkFormatProperties2KHR where + type StructFields VkFormatProperties2KHR = + '["sType", "pNext", "formatProperties"] -- ' closing tick for hsc2hs + type CUnionType VkFormatProperties2KHR = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkFormatProperties2KHR = 'True -- ' closing tick for hsc2hs + type StructExtends VkFormatProperties2KHR = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkSType VkFormatProperties2KHR + where + type VkSTypeMType VkFormatProperties2KHR = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkFormatProperties2KHR, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkFormatProperties2KHR, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkFormatProperties2KHR, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkFormatProperties2KHR, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkFormatProperties2KHR where + type FieldType "sType" VkFormatProperties2KHR = VkStructureType + type FieldOptional "sType" VkFormatProperties2KHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkFormatProperties2KHR = + #{offset VkFormatProperties2KHR, sType} + type FieldIsArray "sType" VkFormatProperties2KHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkFormatProperties2KHR, sType} + +instance CanReadField "sType" VkFormatProperties2KHR where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance {-# OVERLAPPING #-} HasVkPNext VkFormatProperties2KHR + where + type VkPNextMType VkFormatProperties2KHR = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkFormatProperties2KHR, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkFormatProperties2KHR, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkFormatProperties2KHR, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkFormatProperties2KHR, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkFormatProperties2KHR where + type FieldType "pNext" VkFormatProperties2KHR = Ptr Void + type FieldOptional "pNext" VkFormatProperties2KHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkFormatProperties2KHR = + #{offset VkFormatProperties2KHR, pNext} + type FieldIsArray "pNext" VkFormatProperties2KHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkFormatProperties2KHR, pNext} + +instance CanReadField "pNext" VkFormatProperties2KHR where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance {-# OVERLAPPING #-} + HasVkFormatProperties VkFormatProperties2KHR where + type VkFormatPropertiesMType VkFormatProperties2KHR = + VkFormatProperties + + {-# NOINLINE vkFormatProperties #-} + vkFormatProperties x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkFormatProperties2KHR, formatProperties}) + + {-# INLINE vkFormatPropertiesByteOffset #-} + vkFormatPropertiesByteOffset ~_ + = #{offset VkFormatProperties2KHR, formatProperties} + + {-# INLINE readVkFormatProperties #-} + readVkFormatProperties p + = peekByteOff p #{offset VkFormatProperties2KHR, formatProperties} + + {-# INLINE writeVkFormatProperties #-} + writeVkFormatProperties p + = pokeByteOff p #{offset VkFormatProperties2KHR, formatProperties} + +instance {-# OVERLAPPING #-} + HasField "formatProperties" VkFormatProperties2KHR where + type FieldType "formatProperties" VkFormatProperties2KHR = + VkFormatProperties + type FieldOptional "formatProperties" VkFormatProperties2KHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "formatProperties" VkFormatProperties2KHR = + #{offset VkFormatProperties2KHR, formatProperties} + type FieldIsArray "formatProperties" VkFormatProperties2KHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkFormatProperties2KHR, formatProperties} + +instance CanReadField "formatProperties" VkFormatProperties2KHR + where + {-# INLINE getField #-} + getField = vkFormatProperties + + {-# INLINE readField #-} + readField = readVkFormatProperties + +instance Show VkFormatProperties2KHR where + showsPrec d x + = showString "VkFormatProperties2KHR {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkFormatProperties = " . + showsPrec d (vkFormatProperties x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkFramebufferCreateInfo.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkFramebufferCreateInfo.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkFramebufferCreateInfo.hsc @@ -0,0 +1,537 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkFramebufferCreateInfo + (VkFramebufferCreateInfo(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Bitmasks (VkFramebufferCreateFlags) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Handles (VkImageView, + VkRenderPass) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkFramebufferCreateInfo { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkFramebufferCreateFlags flags; +-- > VkRenderPass renderPass; +-- > uint32_t attachmentCount; +-- > const VkImageView* pAttachments; +-- > uint32_t width; +-- > uint32_t height; +-- > uint32_t layers; +-- > } VkFramebufferCreateInfo; +-- +-- +data VkFramebufferCreateInfo = VkFramebufferCreateInfo## Addr## + ByteArray## + +instance Eq VkFramebufferCreateInfo where + (VkFramebufferCreateInfo## a _) == x@(VkFramebufferCreateInfo## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkFramebufferCreateInfo where + (VkFramebufferCreateInfo## a _) `compare` + x@(VkFramebufferCreateInfo## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkFramebufferCreateInfo where + sizeOf ~_ = #{size VkFramebufferCreateInfo} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkFramebufferCreateInfo} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkFramebufferCreateInfo where + unsafeAddr (VkFramebufferCreateInfo## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkFramebufferCreateInfo## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkFramebufferCreateInfo## (plusAddr## (byteArrayContents## b) off) b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkFramebufferCreateInfo where + type StructFields VkFramebufferCreateInfo = + '["sType", "pNext", "flags", "renderPass", "attachmentCount", -- ' closing tick for hsc2hs + "pAttachments", "width", "height", "layers"] + type CUnionType VkFramebufferCreateInfo = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkFramebufferCreateInfo = 'False -- ' closing tick for hsc2hs + type StructExtends VkFramebufferCreateInfo = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkSType VkFramebufferCreateInfo + where + type VkSTypeMType VkFramebufferCreateInfo = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkFramebufferCreateInfo, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkFramebufferCreateInfo, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkFramebufferCreateInfo, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkFramebufferCreateInfo, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkFramebufferCreateInfo where + type FieldType "sType" VkFramebufferCreateInfo = VkStructureType + type FieldOptional "sType" VkFramebufferCreateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkFramebufferCreateInfo = + #{offset VkFramebufferCreateInfo, sType} + type FieldIsArray "sType" VkFramebufferCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkFramebufferCreateInfo, sType} + +instance CanReadField "sType" VkFramebufferCreateInfo where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkFramebufferCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} HasVkPNext VkFramebufferCreateInfo + where + type VkPNextMType VkFramebufferCreateInfo = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkFramebufferCreateInfo, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkFramebufferCreateInfo, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkFramebufferCreateInfo, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkFramebufferCreateInfo, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkFramebufferCreateInfo where + type FieldType "pNext" VkFramebufferCreateInfo = Ptr Void + type FieldOptional "pNext" VkFramebufferCreateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkFramebufferCreateInfo = + #{offset VkFramebufferCreateInfo, pNext} + type FieldIsArray "pNext" VkFramebufferCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkFramebufferCreateInfo, pNext} + +instance CanReadField "pNext" VkFramebufferCreateInfo where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkFramebufferCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} HasVkFlags VkFramebufferCreateInfo + where + type VkFlagsMType VkFramebufferCreateInfo = + VkFramebufferCreateFlags + + {-# NOINLINE vkFlags #-} + vkFlags x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkFramebufferCreateInfo, flags}) + + {-# INLINE vkFlagsByteOffset #-} + vkFlagsByteOffset ~_ + = #{offset VkFramebufferCreateInfo, flags} + + {-# INLINE readVkFlags #-} + readVkFlags p + = peekByteOff p #{offset VkFramebufferCreateInfo, flags} + + {-# INLINE writeVkFlags #-} + writeVkFlags p + = pokeByteOff p #{offset VkFramebufferCreateInfo, flags} + +instance {-# OVERLAPPING #-} + HasField "flags" VkFramebufferCreateInfo where + type FieldType "flags" VkFramebufferCreateInfo = + VkFramebufferCreateFlags + type FieldOptional "flags" VkFramebufferCreateInfo = 'True -- ' closing tick for hsc2hs + type FieldOffset "flags" VkFramebufferCreateInfo = + #{offset VkFramebufferCreateInfo, flags} + type FieldIsArray "flags" VkFramebufferCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkFramebufferCreateInfo, flags} + +instance CanReadField "flags" VkFramebufferCreateInfo where + {-# INLINE getField #-} + getField = vkFlags + + {-# INLINE readField #-} + readField = readVkFlags + +instance CanWriteField "flags" VkFramebufferCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkFlags + +instance {-# OVERLAPPING #-} + HasVkRenderPass VkFramebufferCreateInfo where + type VkRenderPassMType VkFramebufferCreateInfo = VkRenderPass + + {-# NOINLINE vkRenderPass #-} + vkRenderPass x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkFramebufferCreateInfo, renderPass}) + + {-# INLINE vkRenderPassByteOffset #-} + vkRenderPassByteOffset ~_ + = #{offset VkFramebufferCreateInfo, renderPass} + + {-# INLINE readVkRenderPass #-} + readVkRenderPass p + = peekByteOff p #{offset VkFramebufferCreateInfo, renderPass} + + {-# INLINE writeVkRenderPass #-} + writeVkRenderPass p + = pokeByteOff p #{offset VkFramebufferCreateInfo, renderPass} + +instance {-# OVERLAPPING #-} + HasField "renderPass" VkFramebufferCreateInfo where + type FieldType "renderPass" VkFramebufferCreateInfo = VkRenderPass + type FieldOptional "renderPass" VkFramebufferCreateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "renderPass" VkFramebufferCreateInfo = + #{offset VkFramebufferCreateInfo, renderPass} + type FieldIsArray "renderPass" VkFramebufferCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkFramebufferCreateInfo, renderPass} + +instance CanReadField "renderPass" VkFramebufferCreateInfo where + {-# INLINE getField #-} + getField = vkRenderPass + + {-# INLINE readField #-} + readField = readVkRenderPass + +instance CanWriteField "renderPass" VkFramebufferCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkRenderPass + +instance {-# OVERLAPPING #-} + HasVkAttachmentCount VkFramebufferCreateInfo where + type VkAttachmentCountMType VkFramebufferCreateInfo = Word32 + + {-# NOINLINE vkAttachmentCount #-} + vkAttachmentCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkFramebufferCreateInfo, attachmentCount}) + + {-# INLINE vkAttachmentCountByteOffset #-} + vkAttachmentCountByteOffset ~_ + = #{offset VkFramebufferCreateInfo, attachmentCount} + + {-# INLINE readVkAttachmentCount #-} + readVkAttachmentCount p + = peekByteOff p #{offset VkFramebufferCreateInfo, attachmentCount} + + {-# INLINE writeVkAttachmentCount #-} + writeVkAttachmentCount p + = pokeByteOff p #{offset VkFramebufferCreateInfo, attachmentCount} + +instance {-# OVERLAPPING #-} + HasField "attachmentCount" VkFramebufferCreateInfo where + type FieldType "attachmentCount" VkFramebufferCreateInfo = Word32 + type FieldOptional "attachmentCount" VkFramebufferCreateInfo = + 'True -- ' closing tick for hsc2hs + type FieldOffset "attachmentCount" VkFramebufferCreateInfo = + #{offset VkFramebufferCreateInfo, attachmentCount} + type FieldIsArray "attachmentCount" VkFramebufferCreateInfo = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkFramebufferCreateInfo, attachmentCount} + +instance CanReadField "attachmentCount" VkFramebufferCreateInfo + where + {-# INLINE getField #-} + getField = vkAttachmentCount + + {-# INLINE readField #-} + readField = readVkAttachmentCount + +instance CanWriteField "attachmentCount" VkFramebufferCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkAttachmentCount + +instance {-# OVERLAPPING #-} + HasVkPAttachments VkFramebufferCreateInfo where + type VkPAttachmentsMType VkFramebufferCreateInfo = Ptr VkImageView + + {-# NOINLINE vkPAttachments #-} + vkPAttachments x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkFramebufferCreateInfo, pAttachments}) + + {-# INLINE vkPAttachmentsByteOffset #-} + vkPAttachmentsByteOffset ~_ + = #{offset VkFramebufferCreateInfo, pAttachments} + + {-# INLINE readVkPAttachments #-} + readVkPAttachments p + = peekByteOff p #{offset VkFramebufferCreateInfo, pAttachments} + + {-# INLINE writeVkPAttachments #-} + writeVkPAttachments p + = pokeByteOff p #{offset VkFramebufferCreateInfo, pAttachments} + +instance {-# OVERLAPPING #-} + HasField "pAttachments" VkFramebufferCreateInfo where + type FieldType "pAttachments" VkFramebufferCreateInfo = + Ptr VkImageView + type FieldOptional "pAttachments" VkFramebufferCreateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "pAttachments" VkFramebufferCreateInfo = + #{offset VkFramebufferCreateInfo, pAttachments} + type FieldIsArray "pAttachments" VkFramebufferCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkFramebufferCreateInfo, pAttachments} + +instance CanReadField "pAttachments" VkFramebufferCreateInfo where + {-# INLINE getField #-} + getField = vkPAttachments + + {-# INLINE readField #-} + readField = readVkPAttachments + +instance CanWriteField "pAttachments" VkFramebufferCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkPAttachments + +instance {-# OVERLAPPING #-} HasVkWidth VkFramebufferCreateInfo + where + type VkWidthMType VkFramebufferCreateInfo = Word32 + + {-# NOINLINE vkWidth #-} + vkWidth x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkFramebufferCreateInfo, width}) + + {-# INLINE vkWidthByteOffset #-} + vkWidthByteOffset ~_ + = #{offset VkFramebufferCreateInfo, width} + + {-# INLINE readVkWidth #-} + readVkWidth p + = peekByteOff p #{offset VkFramebufferCreateInfo, width} + + {-# INLINE writeVkWidth #-} + writeVkWidth p + = pokeByteOff p #{offset VkFramebufferCreateInfo, width} + +instance {-# OVERLAPPING #-} + HasField "width" VkFramebufferCreateInfo where + type FieldType "width" VkFramebufferCreateInfo = Word32 + type FieldOptional "width" VkFramebufferCreateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "width" VkFramebufferCreateInfo = + #{offset VkFramebufferCreateInfo, width} + type FieldIsArray "width" VkFramebufferCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkFramebufferCreateInfo, width} + +instance CanReadField "width" VkFramebufferCreateInfo where + {-# INLINE getField #-} + getField = vkWidth + + {-# INLINE readField #-} + readField = readVkWidth + +instance CanWriteField "width" VkFramebufferCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkWidth + +instance {-# OVERLAPPING #-} HasVkHeight VkFramebufferCreateInfo + where + type VkHeightMType VkFramebufferCreateInfo = Word32 + + {-# NOINLINE vkHeight #-} + vkHeight x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkFramebufferCreateInfo, height}) + + {-# INLINE vkHeightByteOffset #-} + vkHeightByteOffset ~_ + = #{offset VkFramebufferCreateInfo, height} + + {-# INLINE readVkHeight #-} + readVkHeight p + = peekByteOff p #{offset VkFramebufferCreateInfo, height} + + {-# INLINE writeVkHeight #-} + writeVkHeight p + = pokeByteOff p #{offset VkFramebufferCreateInfo, height} + +instance {-# OVERLAPPING #-} + HasField "height" VkFramebufferCreateInfo where + type FieldType "height" VkFramebufferCreateInfo = Word32 + type FieldOptional "height" VkFramebufferCreateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "height" VkFramebufferCreateInfo = + #{offset VkFramebufferCreateInfo, height} + type FieldIsArray "height" VkFramebufferCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkFramebufferCreateInfo, height} + +instance CanReadField "height" VkFramebufferCreateInfo where + {-# INLINE getField #-} + getField = vkHeight + + {-# INLINE readField #-} + readField = readVkHeight + +instance CanWriteField "height" VkFramebufferCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkHeight + +instance {-# OVERLAPPING #-} HasVkLayers VkFramebufferCreateInfo + where + type VkLayersMType VkFramebufferCreateInfo = Word32 + + {-# NOINLINE vkLayers #-} + vkLayers x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkFramebufferCreateInfo, layers}) + + {-# INLINE vkLayersByteOffset #-} + vkLayersByteOffset ~_ + = #{offset VkFramebufferCreateInfo, layers} + + {-# INLINE readVkLayers #-} + readVkLayers p + = peekByteOff p #{offset VkFramebufferCreateInfo, layers} + + {-# INLINE writeVkLayers #-} + writeVkLayers p + = pokeByteOff p #{offset VkFramebufferCreateInfo, layers} + +instance {-# OVERLAPPING #-} + HasField "layers" VkFramebufferCreateInfo where + type FieldType "layers" VkFramebufferCreateInfo = Word32 + type FieldOptional "layers" VkFramebufferCreateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "layers" VkFramebufferCreateInfo = + #{offset VkFramebufferCreateInfo, layers} + type FieldIsArray "layers" VkFramebufferCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkFramebufferCreateInfo, layers} + +instance CanReadField "layers" VkFramebufferCreateInfo where + {-# INLINE getField #-} + getField = vkLayers + + {-# INLINE readField #-} + readField = readVkLayers + +instance CanWriteField "layers" VkFramebufferCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkLayers + +instance Show VkFramebufferCreateInfo where + showsPrec d x + = showString "VkFramebufferCreateInfo {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkFlags = " . + showsPrec d (vkFlags x) . + showString ", " . + showString "vkRenderPass = " . + showsPrec d (vkRenderPass x) . + showString ", " . + showString "vkAttachmentCount = " . + showsPrec d (vkAttachmentCount x) . + showString ", " . + showString "vkPAttachments = " . + showsPrec d (vkPAttachments x) . + showString ", " . + showString "vkWidth = " . + showsPrec d (vkWidth x) . + showString ", " . + showString "vkHeight = " . + showsPrec d (vkHeight x) . + showString ", " . + showString "vkLayers = " . + showsPrec d (vkLayers x) . + showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkGraphicsPipelineCreateInfo.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkGraphicsPipelineCreateInfo.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkGraphicsPipelineCreateInfo.hsc @@ -0,0 +1,1260 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkGraphicsPipelineCreateInfo + (VkGraphicsPipelineCreateInfo(..)) where +import Foreign.Storable + (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkPipelineCreateFlags + (VkPipelineCreateFlags) +import Graphics.Vulkan.Types.Enum.VkStructureType + (VkStructureType) +import Graphics.Vulkan.Types.Handles + (VkPipeline, + VkPipelineLayout, + VkRenderPass) +import Graphics.Vulkan.Types.Struct.VkPipelineColorBlendStateCreateInfo + (VkPipelineColorBlendStateCreateInfo) +import Graphics.Vulkan.Types.Struct.VkPipelineDepthStencilStateCreateInfo + (VkPipelineDepthStencilStateCreateInfo) +import Graphics.Vulkan.Types.Struct.VkPipelineDynamicStateCreateInfo + (VkPipelineDynamicStateCreateInfo) +import Graphics.Vulkan.Types.Struct.VkPipelineInputAssemblyStateCreateInfo + (VkPipelineInputAssemblyStateCreateInfo) +import Graphics.Vulkan.Types.Struct.VkPipelineMultisampleStateCreateInfo + (VkPipelineMultisampleStateCreateInfo) +import Graphics.Vulkan.Types.Struct.VkPipelineRasterizationStateCreateInfo + (VkPipelineRasterizationStateCreateInfo) +import Graphics.Vulkan.Types.Struct.VkPipelineShaderStageCreateInfo + (VkPipelineShaderStageCreateInfo) +import Graphics.Vulkan.Types.Struct.VkPipelineTessellationStateCreateInfo + (VkPipelineTessellationStateCreateInfo) +import Graphics.Vulkan.Types.Struct.VkPipelineVertexInputStateCreateInfo + (VkPipelineVertexInputStateCreateInfo) +import Graphics.Vulkan.Types.Struct.VkPipelineViewportStateCreateInfo + (VkPipelineViewportStateCreateInfo) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe + (unsafeDupablePerformIO) + +-- | > typedef struct VkGraphicsPipelineCreateInfo { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkPipelineCreateFlags flags; +-- > uint32_t stageCount; +-- > const VkPipelineShaderStageCreateInfo* pStages; +-- > const VkPipelineVertexInputStateCreateInfo* pVertexInputState; +-- > const VkPipelineInputAssemblyStateCreateInfo* pInputAssemblyState; +-- > const VkPipelineTessellationStateCreateInfo* pTessellationState; +-- > const VkPipelineViewportStateCreateInfo* pViewportState; +-- > const VkPipelineRasterizationStateCreateInfo* pRasterizationState; +-- > const VkPipelineMultisampleStateCreateInfo* pMultisampleState; +-- > const VkPipelineDepthStencilStateCreateInfo* pDepthStencilState; +-- > const VkPipelineColorBlendStateCreateInfo* pColorBlendState; +-- > const VkPipelineDynamicStateCreateInfo* pDynamicState; +-- > VkPipelineLayout layout; +-- > VkRenderPass renderPass; +-- > uint32_t subpass; +-- > VkPipeline basePipelineHandle; +-- > int32_t basePipelineIndex; +-- > } VkGraphicsPipelineCreateInfo; +-- +-- +data VkGraphicsPipelineCreateInfo = VkGraphicsPipelineCreateInfo## Addr## + ByteArray## + +instance Eq VkGraphicsPipelineCreateInfo where + (VkGraphicsPipelineCreateInfo## a _) == + x@(VkGraphicsPipelineCreateInfo## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkGraphicsPipelineCreateInfo where + (VkGraphicsPipelineCreateInfo## a _) `compare` + x@(VkGraphicsPipelineCreateInfo## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkGraphicsPipelineCreateInfo where + sizeOf ~_ = #{size VkGraphicsPipelineCreateInfo} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkGraphicsPipelineCreateInfo} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkGraphicsPipelineCreateInfo where + unsafeAddr (VkGraphicsPipelineCreateInfo## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkGraphicsPipelineCreateInfo## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkGraphicsPipelineCreateInfo## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkGraphicsPipelineCreateInfo where + type StructFields VkGraphicsPipelineCreateInfo = + '["sType", "pNext", "flags", "stageCount", "pStages", -- ' closing tick for hsc2hs + "pVertexInputState", "pInputAssemblyState", "pTessellationState", + "pViewportState", "pRasterizationState", "pMultisampleState", + "pDepthStencilState", "pColorBlendState", "pDynamicState", + "layout", "renderPass", "subpass", "basePipelineHandle", + "basePipelineIndex"] + type CUnionType VkGraphicsPipelineCreateInfo = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkGraphicsPipelineCreateInfo = 'False -- ' closing tick for hsc2hs + type StructExtends VkGraphicsPipelineCreateInfo = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkGraphicsPipelineCreateInfo where + type VkSTypeMType VkGraphicsPipelineCreateInfo = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkGraphicsPipelineCreateInfo, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkGraphicsPipelineCreateInfo, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkGraphicsPipelineCreateInfo, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkGraphicsPipelineCreateInfo, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkGraphicsPipelineCreateInfo where + type FieldType "sType" VkGraphicsPipelineCreateInfo = + VkStructureType + type FieldOptional "sType" VkGraphicsPipelineCreateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkGraphicsPipelineCreateInfo = + #{offset VkGraphicsPipelineCreateInfo, sType} + type FieldIsArray "sType" VkGraphicsPipelineCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkGraphicsPipelineCreateInfo, sType} + +instance CanReadField "sType" VkGraphicsPipelineCreateInfo where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkGraphicsPipelineCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkGraphicsPipelineCreateInfo where + type VkPNextMType VkGraphicsPipelineCreateInfo = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkGraphicsPipelineCreateInfo, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkGraphicsPipelineCreateInfo, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkGraphicsPipelineCreateInfo, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkGraphicsPipelineCreateInfo, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkGraphicsPipelineCreateInfo where + type FieldType "pNext" VkGraphicsPipelineCreateInfo = Ptr Void + type FieldOptional "pNext" VkGraphicsPipelineCreateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkGraphicsPipelineCreateInfo = + #{offset VkGraphicsPipelineCreateInfo, pNext} + type FieldIsArray "pNext" VkGraphicsPipelineCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkGraphicsPipelineCreateInfo, pNext} + +instance CanReadField "pNext" VkGraphicsPipelineCreateInfo where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkGraphicsPipelineCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkFlags VkGraphicsPipelineCreateInfo where + type VkFlagsMType VkGraphicsPipelineCreateInfo = + VkPipelineCreateFlags + + {-# NOINLINE vkFlags #-} + vkFlags x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkGraphicsPipelineCreateInfo, flags}) + + {-# INLINE vkFlagsByteOffset #-} + vkFlagsByteOffset ~_ + = #{offset VkGraphicsPipelineCreateInfo, flags} + + {-# INLINE readVkFlags #-} + readVkFlags p + = peekByteOff p #{offset VkGraphicsPipelineCreateInfo, flags} + + {-# INLINE writeVkFlags #-} + writeVkFlags p + = pokeByteOff p #{offset VkGraphicsPipelineCreateInfo, flags} + +instance {-# OVERLAPPING #-} + HasField "flags" VkGraphicsPipelineCreateInfo where + type FieldType "flags" VkGraphicsPipelineCreateInfo = + VkPipelineCreateFlags + type FieldOptional "flags" VkGraphicsPipelineCreateInfo = 'True -- ' closing tick for hsc2hs + type FieldOffset "flags" VkGraphicsPipelineCreateInfo = + #{offset VkGraphicsPipelineCreateInfo, flags} + type FieldIsArray "flags" VkGraphicsPipelineCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkGraphicsPipelineCreateInfo, flags} + +instance CanReadField "flags" VkGraphicsPipelineCreateInfo where + {-# INLINE getField #-} + getField = vkFlags + + {-# INLINE readField #-} + readField = readVkFlags + +instance CanWriteField "flags" VkGraphicsPipelineCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkFlags + +instance {-# OVERLAPPING #-} + HasVkStageCount VkGraphicsPipelineCreateInfo where + type VkStageCountMType VkGraphicsPipelineCreateInfo = Word32 + + {-# NOINLINE vkStageCount #-} + vkStageCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkGraphicsPipelineCreateInfo, stageCount}) + + {-# INLINE vkStageCountByteOffset #-} + vkStageCountByteOffset ~_ + = #{offset VkGraphicsPipelineCreateInfo, stageCount} + + {-# INLINE readVkStageCount #-} + readVkStageCount p + = peekByteOff p #{offset VkGraphicsPipelineCreateInfo, stageCount} + + {-# INLINE writeVkStageCount #-} + writeVkStageCount p + = pokeByteOff p #{offset VkGraphicsPipelineCreateInfo, stageCount} + +instance {-# OVERLAPPING #-} + HasField "stageCount" VkGraphicsPipelineCreateInfo where + type FieldType "stageCount" VkGraphicsPipelineCreateInfo = Word32 + type FieldOptional "stageCount" VkGraphicsPipelineCreateInfo = + 'False -- ' closing tick for hsc2hs + type FieldOffset "stageCount" VkGraphicsPipelineCreateInfo = + #{offset VkGraphicsPipelineCreateInfo, stageCount} + type FieldIsArray "stageCount" VkGraphicsPipelineCreateInfo = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkGraphicsPipelineCreateInfo, stageCount} + +instance CanReadField "stageCount" VkGraphicsPipelineCreateInfo + where + {-# INLINE getField #-} + getField = vkStageCount + + {-# INLINE readField #-} + readField = readVkStageCount + +instance CanWriteField "stageCount" VkGraphicsPipelineCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkStageCount + +instance {-# OVERLAPPING #-} + HasVkPStages VkGraphicsPipelineCreateInfo where + type VkPStagesMType VkGraphicsPipelineCreateInfo = + Ptr VkPipelineShaderStageCreateInfo + + {-# NOINLINE vkPStages #-} + vkPStages x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkGraphicsPipelineCreateInfo, pStages}) + + {-# INLINE vkPStagesByteOffset #-} + vkPStagesByteOffset ~_ + = #{offset VkGraphicsPipelineCreateInfo, pStages} + + {-# INLINE readVkPStages #-} + readVkPStages p + = peekByteOff p #{offset VkGraphicsPipelineCreateInfo, pStages} + + {-# INLINE writeVkPStages #-} + writeVkPStages p + = pokeByteOff p #{offset VkGraphicsPipelineCreateInfo, pStages} + +instance {-# OVERLAPPING #-} + HasField "pStages" VkGraphicsPipelineCreateInfo where + type FieldType "pStages" VkGraphicsPipelineCreateInfo = + Ptr VkPipelineShaderStageCreateInfo + type FieldOptional "pStages" VkGraphicsPipelineCreateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "pStages" VkGraphicsPipelineCreateInfo = + #{offset VkGraphicsPipelineCreateInfo, pStages} + type FieldIsArray "pStages" VkGraphicsPipelineCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkGraphicsPipelineCreateInfo, pStages} + +instance CanReadField "pStages" VkGraphicsPipelineCreateInfo where + {-# INLINE getField #-} + getField = vkPStages + + {-# INLINE readField #-} + readField = readVkPStages + +instance CanWriteField "pStages" VkGraphicsPipelineCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkPStages + +instance {-# OVERLAPPING #-} + HasVkPVertexInputState VkGraphicsPipelineCreateInfo where + type VkPVertexInputStateMType VkGraphicsPipelineCreateInfo = + Ptr VkPipelineVertexInputStateCreateInfo + + {-# NOINLINE vkPVertexInputState #-} + vkPVertexInputState x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkGraphicsPipelineCreateInfo, pVertexInputState}) + + {-# INLINE vkPVertexInputStateByteOffset #-} + vkPVertexInputStateByteOffset ~_ + = #{offset VkGraphicsPipelineCreateInfo, pVertexInputState} + + {-# INLINE readVkPVertexInputState #-} + readVkPVertexInputState p + = peekByteOff p #{offset VkGraphicsPipelineCreateInfo, pVertexInputState} + + {-# INLINE writeVkPVertexInputState #-} + writeVkPVertexInputState p + = pokeByteOff p #{offset VkGraphicsPipelineCreateInfo, pVertexInputState} + +instance {-# OVERLAPPING #-} + HasField "pVertexInputState" VkGraphicsPipelineCreateInfo where + type FieldType "pVertexInputState" VkGraphicsPipelineCreateInfo = + Ptr VkPipelineVertexInputStateCreateInfo + type FieldOptional "pVertexInputState" VkGraphicsPipelineCreateInfo + = 'False -- ' closing tick for hsc2hs + type FieldOffset "pVertexInputState" VkGraphicsPipelineCreateInfo = + #{offset VkGraphicsPipelineCreateInfo, pVertexInputState} + type FieldIsArray "pVertexInputState" VkGraphicsPipelineCreateInfo + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkGraphicsPipelineCreateInfo, pVertexInputState} + +instance CanReadField "pVertexInputState" + VkGraphicsPipelineCreateInfo + where + {-# INLINE getField #-} + getField = vkPVertexInputState + + {-# INLINE readField #-} + readField = readVkPVertexInputState + +instance CanWriteField "pVertexInputState" + VkGraphicsPipelineCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkPVertexInputState + +instance {-# OVERLAPPING #-} + HasVkPInputAssemblyState VkGraphicsPipelineCreateInfo where + type VkPInputAssemblyStateMType VkGraphicsPipelineCreateInfo = + Ptr VkPipelineInputAssemblyStateCreateInfo + + {-# NOINLINE vkPInputAssemblyState #-} + vkPInputAssemblyState x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkGraphicsPipelineCreateInfo, pInputAssemblyState}) + + {-# INLINE vkPInputAssemblyStateByteOffset #-} + vkPInputAssemblyStateByteOffset ~_ + = #{offset VkGraphicsPipelineCreateInfo, pInputAssemblyState} + + {-# INLINE readVkPInputAssemblyState #-} + readVkPInputAssemblyState p + = peekByteOff p #{offset VkGraphicsPipelineCreateInfo, pInputAssemblyState} + + {-# INLINE writeVkPInputAssemblyState #-} + writeVkPInputAssemblyState p + = pokeByteOff p #{offset VkGraphicsPipelineCreateInfo, pInputAssemblyState} + +instance {-# OVERLAPPING #-} + HasField "pInputAssemblyState" VkGraphicsPipelineCreateInfo where + type FieldType "pInputAssemblyState" VkGraphicsPipelineCreateInfo = + Ptr VkPipelineInputAssemblyStateCreateInfo + type FieldOptional "pInputAssemblyState" + VkGraphicsPipelineCreateInfo + = 'False -- ' closing tick for hsc2hs + type FieldOffset "pInputAssemblyState" VkGraphicsPipelineCreateInfo + = + #{offset VkGraphicsPipelineCreateInfo, pInputAssemblyState} + type FieldIsArray "pInputAssemblyState" + VkGraphicsPipelineCreateInfo + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkGraphicsPipelineCreateInfo, pInputAssemblyState} + +instance CanReadField "pInputAssemblyState" + VkGraphicsPipelineCreateInfo + where + {-# INLINE getField #-} + getField = vkPInputAssemblyState + + {-# INLINE readField #-} + readField = readVkPInputAssemblyState + +instance CanWriteField "pInputAssemblyState" + VkGraphicsPipelineCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkPInputAssemblyState + +instance {-# OVERLAPPING #-} + HasVkPTessellationState VkGraphicsPipelineCreateInfo where + type VkPTessellationStateMType VkGraphicsPipelineCreateInfo = + Ptr VkPipelineTessellationStateCreateInfo + + {-# NOINLINE vkPTessellationState #-} + vkPTessellationState x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkGraphicsPipelineCreateInfo, pTessellationState}) + + {-# INLINE vkPTessellationStateByteOffset #-} + vkPTessellationStateByteOffset ~_ + = #{offset VkGraphicsPipelineCreateInfo, pTessellationState} + + {-# INLINE readVkPTessellationState #-} + readVkPTessellationState p + = peekByteOff p #{offset VkGraphicsPipelineCreateInfo, pTessellationState} + + {-# INLINE writeVkPTessellationState #-} + writeVkPTessellationState p + = pokeByteOff p #{offset VkGraphicsPipelineCreateInfo, pTessellationState} + +instance {-# OVERLAPPING #-} + HasField "pTessellationState" VkGraphicsPipelineCreateInfo where + type FieldType "pTessellationState" VkGraphicsPipelineCreateInfo = + Ptr VkPipelineTessellationStateCreateInfo + type FieldOptional "pTessellationState" + VkGraphicsPipelineCreateInfo + = 'True -- ' closing tick for hsc2hs + type FieldOffset "pTessellationState" VkGraphicsPipelineCreateInfo + = + #{offset VkGraphicsPipelineCreateInfo, pTessellationState} + type FieldIsArray "pTessellationState" VkGraphicsPipelineCreateInfo + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkGraphicsPipelineCreateInfo, pTessellationState} + +instance CanReadField "pTessellationState" + VkGraphicsPipelineCreateInfo + where + {-# INLINE getField #-} + getField = vkPTessellationState + + {-# INLINE readField #-} + readField = readVkPTessellationState + +instance CanWriteField "pTessellationState" + VkGraphicsPipelineCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkPTessellationState + +instance {-# OVERLAPPING #-} + HasVkPViewportState VkGraphicsPipelineCreateInfo where + type VkPViewportStateMType VkGraphicsPipelineCreateInfo = + Ptr VkPipelineViewportStateCreateInfo + + {-# NOINLINE vkPViewportState #-} + vkPViewportState x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkGraphicsPipelineCreateInfo, pViewportState}) + + {-# INLINE vkPViewportStateByteOffset #-} + vkPViewportStateByteOffset ~_ + = #{offset VkGraphicsPipelineCreateInfo, pViewportState} + + {-# INLINE readVkPViewportState #-} + readVkPViewportState p + = peekByteOff p #{offset VkGraphicsPipelineCreateInfo, pViewportState} + + {-# INLINE writeVkPViewportState #-} + writeVkPViewportState p + = pokeByteOff p #{offset VkGraphicsPipelineCreateInfo, pViewportState} + +instance {-# OVERLAPPING #-} + HasField "pViewportState" VkGraphicsPipelineCreateInfo where + type FieldType "pViewportState" VkGraphicsPipelineCreateInfo = + Ptr VkPipelineViewportStateCreateInfo + type FieldOptional "pViewportState" VkGraphicsPipelineCreateInfo = + 'True -- ' closing tick for hsc2hs + type FieldOffset "pViewportState" VkGraphicsPipelineCreateInfo = + #{offset VkGraphicsPipelineCreateInfo, pViewportState} + type FieldIsArray "pViewportState" VkGraphicsPipelineCreateInfo = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkGraphicsPipelineCreateInfo, pViewportState} + +instance CanReadField "pViewportState" VkGraphicsPipelineCreateInfo + where + {-# INLINE getField #-} + getField = vkPViewportState + + {-# INLINE readField #-} + readField = readVkPViewportState + +instance CanWriteField "pViewportState" + VkGraphicsPipelineCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkPViewportState + +instance {-# OVERLAPPING #-} + HasVkPRasterizationState VkGraphicsPipelineCreateInfo where + type VkPRasterizationStateMType VkGraphicsPipelineCreateInfo = + Ptr VkPipelineRasterizationStateCreateInfo + + {-# NOINLINE vkPRasterizationState #-} + vkPRasterizationState x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkGraphicsPipelineCreateInfo, pRasterizationState}) + + {-# INLINE vkPRasterizationStateByteOffset #-} + vkPRasterizationStateByteOffset ~_ + = #{offset VkGraphicsPipelineCreateInfo, pRasterizationState} + + {-# INLINE readVkPRasterizationState #-} + readVkPRasterizationState p + = peekByteOff p #{offset VkGraphicsPipelineCreateInfo, pRasterizationState} + + {-# INLINE writeVkPRasterizationState #-} + writeVkPRasterizationState p + = pokeByteOff p #{offset VkGraphicsPipelineCreateInfo, pRasterizationState} + +instance {-# OVERLAPPING #-} + HasField "pRasterizationState" VkGraphicsPipelineCreateInfo where + type FieldType "pRasterizationState" VkGraphicsPipelineCreateInfo = + Ptr VkPipelineRasterizationStateCreateInfo + type FieldOptional "pRasterizationState" + VkGraphicsPipelineCreateInfo + = 'False -- ' closing tick for hsc2hs + type FieldOffset "pRasterizationState" VkGraphicsPipelineCreateInfo + = + #{offset VkGraphicsPipelineCreateInfo, pRasterizationState} + type FieldIsArray "pRasterizationState" + VkGraphicsPipelineCreateInfo + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkGraphicsPipelineCreateInfo, pRasterizationState} + +instance CanReadField "pRasterizationState" + VkGraphicsPipelineCreateInfo + where + {-# INLINE getField #-} + getField = vkPRasterizationState + + {-# INLINE readField #-} + readField = readVkPRasterizationState + +instance CanWriteField "pRasterizationState" + VkGraphicsPipelineCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkPRasterizationState + +instance {-# OVERLAPPING #-} + HasVkPMultisampleState VkGraphicsPipelineCreateInfo where + type VkPMultisampleStateMType VkGraphicsPipelineCreateInfo = + Ptr VkPipelineMultisampleStateCreateInfo + + {-# NOINLINE vkPMultisampleState #-} + vkPMultisampleState x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkGraphicsPipelineCreateInfo, pMultisampleState}) + + {-# INLINE vkPMultisampleStateByteOffset #-} + vkPMultisampleStateByteOffset ~_ + = #{offset VkGraphicsPipelineCreateInfo, pMultisampleState} + + {-# INLINE readVkPMultisampleState #-} + readVkPMultisampleState p + = peekByteOff p #{offset VkGraphicsPipelineCreateInfo, pMultisampleState} + + {-# INLINE writeVkPMultisampleState #-} + writeVkPMultisampleState p + = pokeByteOff p #{offset VkGraphicsPipelineCreateInfo, pMultisampleState} + +instance {-# OVERLAPPING #-} + HasField "pMultisampleState" VkGraphicsPipelineCreateInfo where + type FieldType "pMultisampleState" VkGraphicsPipelineCreateInfo = + Ptr VkPipelineMultisampleStateCreateInfo + type FieldOptional "pMultisampleState" VkGraphicsPipelineCreateInfo + = 'True -- ' closing tick for hsc2hs + type FieldOffset "pMultisampleState" VkGraphicsPipelineCreateInfo = + #{offset VkGraphicsPipelineCreateInfo, pMultisampleState} + type FieldIsArray "pMultisampleState" VkGraphicsPipelineCreateInfo + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkGraphicsPipelineCreateInfo, pMultisampleState} + +instance CanReadField "pMultisampleState" + VkGraphicsPipelineCreateInfo + where + {-# INLINE getField #-} + getField = vkPMultisampleState + + {-# INLINE readField #-} + readField = readVkPMultisampleState + +instance CanWriteField "pMultisampleState" + VkGraphicsPipelineCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkPMultisampleState + +instance {-# OVERLAPPING #-} + HasVkPDepthStencilState VkGraphicsPipelineCreateInfo where + type VkPDepthStencilStateMType VkGraphicsPipelineCreateInfo = + Ptr VkPipelineDepthStencilStateCreateInfo + + {-# NOINLINE vkPDepthStencilState #-} + vkPDepthStencilState x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkGraphicsPipelineCreateInfo, pDepthStencilState}) + + {-# INLINE vkPDepthStencilStateByteOffset #-} + vkPDepthStencilStateByteOffset ~_ + = #{offset VkGraphicsPipelineCreateInfo, pDepthStencilState} + + {-# INLINE readVkPDepthStencilState #-} + readVkPDepthStencilState p + = peekByteOff p #{offset VkGraphicsPipelineCreateInfo, pDepthStencilState} + + {-# INLINE writeVkPDepthStencilState #-} + writeVkPDepthStencilState p + = pokeByteOff p #{offset VkGraphicsPipelineCreateInfo, pDepthStencilState} + +instance {-# OVERLAPPING #-} + HasField "pDepthStencilState" VkGraphicsPipelineCreateInfo where + type FieldType "pDepthStencilState" VkGraphicsPipelineCreateInfo = + Ptr VkPipelineDepthStencilStateCreateInfo + type FieldOptional "pDepthStencilState" + VkGraphicsPipelineCreateInfo + = 'True -- ' closing tick for hsc2hs + type FieldOffset "pDepthStencilState" VkGraphicsPipelineCreateInfo + = + #{offset VkGraphicsPipelineCreateInfo, pDepthStencilState} + type FieldIsArray "pDepthStencilState" VkGraphicsPipelineCreateInfo + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkGraphicsPipelineCreateInfo, pDepthStencilState} + +instance CanReadField "pDepthStencilState" + VkGraphicsPipelineCreateInfo + where + {-# INLINE getField #-} + getField = vkPDepthStencilState + + {-# INLINE readField #-} + readField = readVkPDepthStencilState + +instance CanWriteField "pDepthStencilState" + VkGraphicsPipelineCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkPDepthStencilState + +instance {-# OVERLAPPING #-} + HasVkPColorBlendState VkGraphicsPipelineCreateInfo where + type VkPColorBlendStateMType VkGraphicsPipelineCreateInfo = + Ptr VkPipelineColorBlendStateCreateInfo + + {-# NOINLINE vkPColorBlendState #-} + vkPColorBlendState x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkGraphicsPipelineCreateInfo, pColorBlendState}) + + {-# INLINE vkPColorBlendStateByteOffset #-} + vkPColorBlendStateByteOffset ~_ + = #{offset VkGraphicsPipelineCreateInfo, pColorBlendState} + + {-# INLINE readVkPColorBlendState #-} + readVkPColorBlendState p + = peekByteOff p #{offset VkGraphicsPipelineCreateInfo, pColorBlendState} + + {-# INLINE writeVkPColorBlendState #-} + writeVkPColorBlendState p + = pokeByteOff p #{offset VkGraphicsPipelineCreateInfo, pColorBlendState} + +instance {-# OVERLAPPING #-} + HasField "pColorBlendState" VkGraphicsPipelineCreateInfo where + type FieldType "pColorBlendState" VkGraphicsPipelineCreateInfo = + Ptr VkPipelineColorBlendStateCreateInfo + type FieldOptional "pColorBlendState" VkGraphicsPipelineCreateInfo + = 'True -- ' closing tick for hsc2hs + type FieldOffset "pColorBlendState" VkGraphicsPipelineCreateInfo = + #{offset VkGraphicsPipelineCreateInfo, pColorBlendState} + type FieldIsArray "pColorBlendState" VkGraphicsPipelineCreateInfo = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkGraphicsPipelineCreateInfo, pColorBlendState} + +instance CanReadField "pColorBlendState" + VkGraphicsPipelineCreateInfo + where + {-# INLINE getField #-} + getField = vkPColorBlendState + + {-# INLINE readField #-} + readField = readVkPColorBlendState + +instance CanWriteField "pColorBlendState" + VkGraphicsPipelineCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkPColorBlendState + +instance {-# OVERLAPPING #-} + HasVkPDynamicState VkGraphicsPipelineCreateInfo where + type VkPDynamicStateMType VkGraphicsPipelineCreateInfo = + Ptr VkPipelineDynamicStateCreateInfo + + {-# NOINLINE vkPDynamicState #-} + vkPDynamicState x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkGraphicsPipelineCreateInfo, pDynamicState}) + + {-# INLINE vkPDynamicStateByteOffset #-} + vkPDynamicStateByteOffset ~_ + = #{offset VkGraphicsPipelineCreateInfo, pDynamicState} + + {-# INLINE readVkPDynamicState #-} + readVkPDynamicState p + = peekByteOff p #{offset VkGraphicsPipelineCreateInfo, pDynamicState} + + {-# INLINE writeVkPDynamicState #-} + writeVkPDynamicState p + = pokeByteOff p #{offset VkGraphicsPipelineCreateInfo, pDynamicState} + +instance {-# OVERLAPPING #-} + HasField "pDynamicState" VkGraphicsPipelineCreateInfo where + type FieldType "pDynamicState" VkGraphicsPipelineCreateInfo = + Ptr VkPipelineDynamicStateCreateInfo + type FieldOptional "pDynamicState" VkGraphicsPipelineCreateInfo = + 'True -- ' closing tick for hsc2hs + type FieldOffset "pDynamicState" VkGraphicsPipelineCreateInfo = + #{offset VkGraphicsPipelineCreateInfo, pDynamicState} + type FieldIsArray "pDynamicState" VkGraphicsPipelineCreateInfo = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkGraphicsPipelineCreateInfo, pDynamicState} + +instance CanReadField "pDynamicState" VkGraphicsPipelineCreateInfo + where + {-# INLINE getField #-} + getField = vkPDynamicState + + {-# INLINE readField #-} + readField = readVkPDynamicState + +instance CanWriteField "pDynamicState" VkGraphicsPipelineCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkPDynamicState + +instance {-# OVERLAPPING #-} + HasVkLayout VkGraphicsPipelineCreateInfo where + type VkLayoutMType VkGraphicsPipelineCreateInfo = VkPipelineLayout + + {-# NOINLINE vkLayout #-} + vkLayout x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkGraphicsPipelineCreateInfo, layout}) + + {-# INLINE vkLayoutByteOffset #-} + vkLayoutByteOffset ~_ + = #{offset VkGraphicsPipelineCreateInfo, layout} + + {-# INLINE readVkLayout #-} + readVkLayout p + = peekByteOff p #{offset VkGraphicsPipelineCreateInfo, layout} + + {-# INLINE writeVkLayout #-} + writeVkLayout p + = pokeByteOff p #{offset VkGraphicsPipelineCreateInfo, layout} + +instance {-# OVERLAPPING #-} + HasField "layout" VkGraphicsPipelineCreateInfo where + type FieldType "layout" VkGraphicsPipelineCreateInfo = + VkPipelineLayout + type FieldOptional "layout" VkGraphicsPipelineCreateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "layout" VkGraphicsPipelineCreateInfo = + #{offset VkGraphicsPipelineCreateInfo, layout} + type FieldIsArray "layout" VkGraphicsPipelineCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkGraphicsPipelineCreateInfo, layout} + +instance CanReadField "layout" VkGraphicsPipelineCreateInfo where + {-# INLINE getField #-} + getField = vkLayout + + {-# INLINE readField #-} + readField = readVkLayout + +instance CanWriteField "layout" VkGraphicsPipelineCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkLayout + +instance {-# OVERLAPPING #-} + HasVkRenderPass VkGraphicsPipelineCreateInfo where + type VkRenderPassMType VkGraphicsPipelineCreateInfo = VkRenderPass + + {-# NOINLINE vkRenderPass #-} + vkRenderPass x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkGraphicsPipelineCreateInfo, renderPass}) + + {-# INLINE vkRenderPassByteOffset #-} + vkRenderPassByteOffset ~_ + = #{offset VkGraphicsPipelineCreateInfo, renderPass} + + {-# INLINE readVkRenderPass #-} + readVkRenderPass p + = peekByteOff p #{offset VkGraphicsPipelineCreateInfo, renderPass} + + {-# INLINE writeVkRenderPass #-} + writeVkRenderPass p + = pokeByteOff p #{offset VkGraphicsPipelineCreateInfo, renderPass} + +instance {-# OVERLAPPING #-} + HasField "renderPass" VkGraphicsPipelineCreateInfo where + type FieldType "renderPass" VkGraphicsPipelineCreateInfo = + VkRenderPass + type FieldOptional "renderPass" VkGraphicsPipelineCreateInfo = + 'False -- ' closing tick for hsc2hs + type FieldOffset "renderPass" VkGraphicsPipelineCreateInfo = + #{offset VkGraphicsPipelineCreateInfo, renderPass} + type FieldIsArray "renderPass" VkGraphicsPipelineCreateInfo = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkGraphicsPipelineCreateInfo, renderPass} + +instance CanReadField "renderPass" VkGraphicsPipelineCreateInfo + where + {-# INLINE getField #-} + getField = vkRenderPass + + {-# INLINE readField #-} + readField = readVkRenderPass + +instance CanWriteField "renderPass" VkGraphicsPipelineCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkRenderPass + +instance {-# OVERLAPPING #-} + HasVkSubpass VkGraphicsPipelineCreateInfo where + type VkSubpassMType VkGraphicsPipelineCreateInfo = Word32 + + {-# NOINLINE vkSubpass #-} + vkSubpass x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkGraphicsPipelineCreateInfo, subpass}) + + {-# INLINE vkSubpassByteOffset #-} + vkSubpassByteOffset ~_ + = #{offset VkGraphicsPipelineCreateInfo, subpass} + + {-# INLINE readVkSubpass #-} + readVkSubpass p + = peekByteOff p #{offset VkGraphicsPipelineCreateInfo, subpass} + + {-# INLINE writeVkSubpass #-} + writeVkSubpass p + = pokeByteOff p #{offset VkGraphicsPipelineCreateInfo, subpass} + +instance {-# OVERLAPPING #-} + HasField "subpass" VkGraphicsPipelineCreateInfo where + type FieldType "subpass" VkGraphicsPipelineCreateInfo = Word32 + type FieldOptional "subpass" VkGraphicsPipelineCreateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "subpass" VkGraphicsPipelineCreateInfo = + #{offset VkGraphicsPipelineCreateInfo, subpass} + type FieldIsArray "subpass" VkGraphicsPipelineCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkGraphicsPipelineCreateInfo, subpass} + +instance CanReadField "subpass" VkGraphicsPipelineCreateInfo where + {-# INLINE getField #-} + getField = vkSubpass + + {-# INLINE readField #-} + readField = readVkSubpass + +instance CanWriteField "subpass" VkGraphicsPipelineCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkSubpass + +instance {-# OVERLAPPING #-} + HasVkBasePipelineHandle VkGraphicsPipelineCreateInfo where + type VkBasePipelineHandleMType VkGraphicsPipelineCreateInfo = + VkPipeline + + {-# NOINLINE vkBasePipelineHandle #-} + vkBasePipelineHandle x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkGraphicsPipelineCreateInfo, basePipelineHandle}) + + {-# INLINE vkBasePipelineHandleByteOffset #-} + vkBasePipelineHandleByteOffset ~_ + = #{offset VkGraphicsPipelineCreateInfo, basePipelineHandle} + + {-# INLINE readVkBasePipelineHandle #-} + readVkBasePipelineHandle p + = peekByteOff p #{offset VkGraphicsPipelineCreateInfo, basePipelineHandle} + + {-# INLINE writeVkBasePipelineHandle #-} + writeVkBasePipelineHandle p + = pokeByteOff p #{offset VkGraphicsPipelineCreateInfo, basePipelineHandle} + +instance {-# OVERLAPPING #-} + HasField "basePipelineHandle" VkGraphicsPipelineCreateInfo where + type FieldType "basePipelineHandle" VkGraphicsPipelineCreateInfo = + VkPipeline + type FieldOptional "basePipelineHandle" + VkGraphicsPipelineCreateInfo + = 'True -- ' closing tick for hsc2hs + type FieldOffset "basePipelineHandle" VkGraphicsPipelineCreateInfo + = + #{offset VkGraphicsPipelineCreateInfo, basePipelineHandle} + type FieldIsArray "basePipelineHandle" VkGraphicsPipelineCreateInfo + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkGraphicsPipelineCreateInfo, basePipelineHandle} + +instance CanReadField "basePipelineHandle" + VkGraphicsPipelineCreateInfo + where + {-# INLINE getField #-} + getField = vkBasePipelineHandle + + {-# INLINE readField #-} + readField = readVkBasePipelineHandle + +instance CanWriteField "basePipelineHandle" + VkGraphicsPipelineCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkBasePipelineHandle + +instance {-# OVERLAPPING #-} + HasVkBasePipelineIndex VkGraphicsPipelineCreateInfo where + type VkBasePipelineIndexMType VkGraphicsPipelineCreateInfo = Int32 + + {-# NOINLINE vkBasePipelineIndex #-} + vkBasePipelineIndex x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkGraphicsPipelineCreateInfo, basePipelineIndex}) + + {-# INLINE vkBasePipelineIndexByteOffset #-} + vkBasePipelineIndexByteOffset ~_ + = #{offset VkGraphicsPipelineCreateInfo, basePipelineIndex} + + {-# INLINE readVkBasePipelineIndex #-} + readVkBasePipelineIndex p + = peekByteOff p #{offset VkGraphicsPipelineCreateInfo, basePipelineIndex} + + {-# INLINE writeVkBasePipelineIndex #-} + writeVkBasePipelineIndex p + = pokeByteOff p #{offset VkGraphicsPipelineCreateInfo, basePipelineIndex} + +instance {-# OVERLAPPING #-} + HasField "basePipelineIndex" VkGraphicsPipelineCreateInfo where + type FieldType "basePipelineIndex" VkGraphicsPipelineCreateInfo = + Int32 + type FieldOptional "basePipelineIndex" VkGraphicsPipelineCreateInfo + = 'False -- ' closing tick for hsc2hs + type FieldOffset "basePipelineIndex" VkGraphicsPipelineCreateInfo = + #{offset VkGraphicsPipelineCreateInfo, basePipelineIndex} + type FieldIsArray "basePipelineIndex" VkGraphicsPipelineCreateInfo + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkGraphicsPipelineCreateInfo, basePipelineIndex} + +instance CanReadField "basePipelineIndex" + VkGraphicsPipelineCreateInfo + where + {-# INLINE getField #-} + getField = vkBasePipelineIndex + + {-# INLINE readField #-} + readField = readVkBasePipelineIndex + +instance CanWriteField "basePipelineIndex" + VkGraphicsPipelineCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkBasePipelineIndex + +instance Show VkGraphicsPipelineCreateInfo where + showsPrec d x + = showString "VkGraphicsPipelineCreateInfo {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkFlags = " . + showsPrec d (vkFlags x) . + showString ", " . + showString "vkStageCount = " . + showsPrec d (vkStageCount x) . + showString ", " . + showString "vkPStages = " . + showsPrec d (vkPStages x) . + showString ", " . + showString "vkPVertexInputState = " . + showsPrec d (vkPVertexInputState x) . + showString ", " . + showString "vkPInputAssemblyState = " . + showsPrec d (vkPInputAssemblyState x) . + showString ", " . + showString "vkPTessellationState = " . + showsPrec d (vkPTessellationState x) . + showString ", " . + showString "vkPViewportState = " . + showsPrec d (vkPViewportState x) . + showString ", " . + showString + "vkPRasterizationState = " + . + showsPrec d + (vkPRasterizationState x) + . + showString ", " . + showString + "vkPMultisampleState = " + . + showsPrec d + (vkPMultisampleState + x) + . + showString ", " . + showString + "vkPDepthStencilState = " + . + showsPrec d + (vkPDepthStencilState + x) + . + showString ", " + . + showString + "vkPColorBlendState = " + . + showsPrec d + (vkPColorBlendState + x) + . + showString + ", " + . + showString + "vkPDynamicState = " + . + showsPrec + d + (vkPDynamicState + x) + . + showString + ", " + . + showString + "vkLayout = " + . + showsPrec + d + (vkLayout + x) + . + showString + ", " + . + showString + "vkRenderPass = " + . + showsPrec + d + (vkRenderPass + x) + . + showString + ", " + . + showString + "vkSubpass = " + . + showsPrec + d + (vkSubpass + x) + . + showString + ", " + . + showString + "vkBasePipelineHandle = " + . + showsPrec + d + (vkBasePipelineHandle + x) + . + showString + ", " + . + showString + "vkBasePipelineIndex = " + . + showsPrec + d + (vkBasePipelineIndex + x) + . + showChar + '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkHdrMetadataEXT.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkHdrMetadataEXT.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkHdrMetadataEXT.hsc @@ -0,0 +1,598 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkHdrMetadataEXT + (VkHdrMetadataEXT(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Struct.VkXYColorEXT (VkXYColorEXT) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkHdrMetadataEXT { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkXYColorEXT displayPrimaryRed; +-- > VkXYColorEXT displayPrimaryGreen; +-- > VkXYColorEXT displayPrimaryBlue; +-- > VkXYColorEXT whitePoint; +-- > float maxLuminance; +-- > float minLuminance; +-- > float maxContentLightLevel; +-- > float maxFrameAverageLightLevel; +-- > } VkHdrMetadataEXT; +-- +-- +data VkHdrMetadataEXT = VkHdrMetadataEXT## Addr## ByteArray## + +instance Eq VkHdrMetadataEXT where + (VkHdrMetadataEXT## a _) == x@(VkHdrMetadataEXT## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkHdrMetadataEXT where + (VkHdrMetadataEXT## a _) `compare` x@(VkHdrMetadataEXT## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkHdrMetadataEXT where + sizeOf ~_ = #{size VkHdrMetadataEXT} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkHdrMetadataEXT} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkHdrMetadataEXT where + unsafeAddr (VkHdrMetadataEXT## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkHdrMetadataEXT## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkHdrMetadataEXT## (plusAddr## (byteArrayContents## b) off) b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkHdrMetadataEXT where + type StructFields VkHdrMetadataEXT = + '["sType", "pNext", "displayPrimaryRed", "displayPrimaryGreen", -- ' closing tick for hsc2hs + "displayPrimaryBlue", "whitePoint", "maxLuminance", "minLuminance", + "maxContentLightLevel", "maxFrameAverageLightLevel"] + type CUnionType VkHdrMetadataEXT = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkHdrMetadataEXT = 'False -- ' closing tick for hsc2hs + type StructExtends VkHdrMetadataEXT = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkSType VkHdrMetadataEXT where + type VkSTypeMType VkHdrMetadataEXT = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkHdrMetadataEXT, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkHdrMetadataEXT, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkHdrMetadataEXT, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkHdrMetadataEXT, sType} + +instance {-# OVERLAPPING #-} HasField "sType" VkHdrMetadataEXT + where + type FieldType "sType" VkHdrMetadataEXT = VkStructureType + type FieldOptional "sType" VkHdrMetadataEXT = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkHdrMetadataEXT = + #{offset VkHdrMetadataEXT, sType} + type FieldIsArray "sType" VkHdrMetadataEXT = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkHdrMetadataEXT, sType} + +instance CanReadField "sType" VkHdrMetadataEXT where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkHdrMetadataEXT where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} HasVkPNext VkHdrMetadataEXT where + type VkPNextMType VkHdrMetadataEXT = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkHdrMetadataEXT, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkHdrMetadataEXT, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkHdrMetadataEXT, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkHdrMetadataEXT, pNext} + +instance {-# OVERLAPPING #-} HasField "pNext" VkHdrMetadataEXT + where + type FieldType "pNext" VkHdrMetadataEXT = Ptr Void + type FieldOptional "pNext" VkHdrMetadataEXT = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkHdrMetadataEXT = + #{offset VkHdrMetadataEXT, pNext} + type FieldIsArray "pNext" VkHdrMetadataEXT = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkHdrMetadataEXT, pNext} + +instance CanReadField "pNext" VkHdrMetadataEXT where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkHdrMetadataEXT where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkDisplayPrimaryRed VkHdrMetadataEXT where + type VkDisplayPrimaryRedMType VkHdrMetadataEXT = VkXYColorEXT + + {-# NOINLINE vkDisplayPrimaryRed #-} + vkDisplayPrimaryRed x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkHdrMetadataEXT, displayPrimaryRed}) + + {-# INLINE vkDisplayPrimaryRedByteOffset #-} + vkDisplayPrimaryRedByteOffset ~_ + = #{offset VkHdrMetadataEXT, displayPrimaryRed} + + {-# INLINE readVkDisplayPrimaryRed #-} + readVkDisplayPrimaryRed p + = peekByteOff p #{offset VkHdrMetadataEXT, displayPrimaryRed} + + {-# INLINE writeVkDisplayPrimaryRed #-} + writeVkDisplayPrimaryRed p + = pokeByteOff p #{offset VkHdrMetadataEXT, displayPrimaryRed} + +instance {-# OVERLAPPING #-} + HasField "displayPrimaryRed" VkHdrMetadataEXT where + type FieldType "displayPrimaryRed" VkHdrMetadataEXT = VkXYColorEXT + type FieldOptional "displayPrimaryRed" VkHdrMetadataEXT = 'False -- ' closing tick for hsc2hs + type FieldOffset "displayPrimaryRed" VkHdrMetadataEXT = + #{offset VkHdrMetadataEXT, displayPrimaryRed} + type FieldIsArray "displayPrimaryRed" VkHdrMetadataEXT = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkHdrMetadataEXT, displayPrimaryRed} + +instance CanReadField "displayPrimaryRed" VkHdrMetadataEXT where + {-# INLINE getField #-} + getField = vkDisplayPrimaryRed + + {-# INLINE readField #-} + readField = readVkDisplayPrimaryRed + +instance CanWriteField "displayPrimaryRed" VkHdrMetadataEXT where + {-# INLINE writeField #-} + writeField = writeVkDisplayPrimaryRed + +instance {-# OVERLAPPING #-} + HasVkDisplayPrimaryGreen VkHdrMetadataEXT where + type VkDisplayPrimaryGreenMType VkHdrMetadataEXT = VkXYColorEXT + + {-# NOINLINE vkDisplayPrimaryGreen #-} + vkDisplayPrimaryGreen x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkHdrMetadataEXT, displayPrimaryGreen}) + + {-# INLINE vkDisplayPrimaryGreenByteOffset #-} + vkDisplayPrimaryGreenByteOffset ~_ + = #{offset VkHdrMetadataEXT, displayPrimaryGreen} + + {-# INLINE readVkDisplayPrimaryGreen #-} + readVkDisplayPrimaryGreen p + = peekByteOff p #{offset VkHdrMetadataEXT, displayPrimaryGreen} + + {-# INLINE writeVkDisplayPrimaryGreen #-} + writeVkDisplayPrimaryGreen p + = pokeByteOff p #{offset VkHdrMetadataEXT, displayPrimaryGreen} + +instance {-# OVERLAPPING #-} + HasField "displayPrimaryGreen" VkHdrMetadataEXT where + type FieldType "displayPrimaryGreen" VkHdrMetadataEXT = + VkXYColorEXT + type FieldOptional "displayPrimaryGreen" VkHdrMetadataEXT = 'False -- ' closing tick for hsc2hs + type FieldOffset "displayPrimaryGreen" VkHdrMetadataEXT = + #{offset VkHdrMetadataEXT, displayPrimaryGreen} + type FieldIsArray "displayPrimaryGreen" VkHdrMetadataEXT = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkHdrMetadataEXT, displayPrimaryGreen} + +instance CanReadField "displayPrimaryGreen" VkHdrMetadataEXT where + {-# INLINE getField #-} + getField = vkDisplayPrimaryGreen + + {-# INLINE readField #-} + readField = readVkDisplayPrimaryGreen + +instance CanWriteField "displayPrimaryGreen" VkHdrMetadataEXT where + {-# INLINE writeField #-} + writeField = writeVkDisplayPrimaryGreen + +instance {-# OVERLAPPING #-} + HasVkDisplayPrimaryBlue VkHdrMetadataEXT where + type VkDisplayPrimaryBlueMType VkHdrMetadataEXT = VkXYColorEXT + + {-# NOINLINE vkDisplayPrimaryBlue #-} + vkDisplayPrimaryBlue x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkHdrMetadataEXT, displayPrimaryBlue}) + + {-# INLINE vkDisplayPrimaryBlueByteOffset #-} + vkDisplayPrimaryBlueByteOffset ~_ + = #{offset VkHdrMetadataEXT, displayPrimaryBlue} + + {-# INLINE readVkDisplayPrimaryBlue #-} + readVkDisplayPrimaryBlue p + = peekByteOff p #{offset VkHdrMetadataEXT, displayPrimaryBlue} + + {-# INLINE writeVkDisplayPrimaryBlue #-} + writeVkDisplayPrimaryBlue p + = pokeByteOff p #{offset VkHdrMetadataEXT, displayPrimaryBlue} + +instance {-# OVERLAPPING #-} + HasField "displayPrimaryBlue" VkHdrMetadataEXT where + type FieldType "displayPrimaryBlue" VkHdrMetadataEXT = VkXYColorEXT + type FieldOptional "displayPrimaryBlue" VkHdrMetadataEXT = 'False -- ' closing tick for hsc2hs + type FieldOffset "displayPrimaryBlue" VkHdrMetadataEXT = + #{offset VkHdrMetadataEXT, displayPrimaryBlue} + type FieldIsArray "displayPrimaryBlue" VkHdrMetadataEXT = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkHdrMetadataEXT, displayPrimaryBlue} + +instance CanReadField "displayPrimaryBlue" VkHdrMetadataEXT where + {-# INLINE getField #-} + getField = vkDisplayPrimaryBlue + + {-# INLINE readField #-} + readField = readVkDisplayPrimaryBlue + +instance CanWriteField "displayPrimaryBlue" VkHdrMetadataEXT where + {-# INLINE writeField #-} + writeField = writeVkDisplayPrimaryBlue + +instance {-# OVERLAPPING #-} HasVkWhitePoint VkHdrMetadataEXT where + type VkWhitePointMType VkHdrMetadataEXT = VkXYColorEXT + + {-# NOINLINE vkWhitePoint #-} + vkWhitePoint x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkHdrMetadataEXT, whitePoint}) + + {-# INLINE vkWhitePointByteOffset #-} + vkWhitePointByteOffset ~_ + = #{offset VkHdrMetadataEXT, whitePoint} + + {-# INLINE readVkWhitePoint #-} + readVkWhitePoint p + = peekByteOff p #{offset VkHdrMetadataEXT, whitePoint} + + {-# INLINE writeVkWhitePoint #-} + writeVkWhitePoint p + = pokeByteOff p #{offset VkHdrMetadataEXT, whitePoint} + +instance {-# OVERLAPPING #-} HasField "whitePoint" VkHdrMetadataEXT + where + type FieldType "whitePoint" VkHdrMetadataEXT = VkXYColorEXT + type FieldOptional "whitePoint" VkHdrMetadataEXT = 'False -- ' closing tick for hsc2hs + type FieldOffset "whitePoint" VkHdrMetadataEXT = + #{offset VkHdrMetadataEXT, whitePoint} + type FieldIsArray "whitePoint" VkHdrMetadataEXT = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkHdrMetadataEXT, whitePoint} + +instance CanReadField "whitePoint" VkHdrMetadataEXT where + {-# INLINE getField #-} + getField = vkWhitePoint + + {-# INLINE readField #-} + readField = readVkWhitePoint + +instance CanWriteField "whitePoint" VkHdrMetadataEXT where + {-# INLINE writeField #-} + writeField = writeVkWhitePoint + +instance {-# OVERLAPPING #-} HasVkMaxLuminance VkHdrMetadataEXT + where + type VkMaxLuminanceMType VkHdrMetadataEXT = + #{type float} + + {-# NOINLINE vkMaxLuminance #-} + vkMaxLuminance x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkHdrMetadataEXT, maxLuminance}) + + {-# INLINE vkMaxLuminanceByteOffset #-} + vkMaxLuminanceByteOffset ~_ + = #{offset VkHdrMetadataEXT, maxLuminance} + + {-# INLINE readVkMaxLuminance #-} + readVkMaxLuminance p + = peekByteOff p #{offset VkHdrMetadataEXT, maxLuminance} + + {-# INLINE writeVkMaxLuminance #-} + writeVkMaxLuminance p + = pokeByteOff p #{offset VkHdrMetadataEXT, maxLuminance} + +instance {-# OVERLAPPING #-} + HasField "maxLuminance" VkHdrMetadataEXT where + type FieldType "maxLuminance" VkHdrMetadataEXT = + #{type float} + type FieldOptional "maxLuminance" VkHdrMetadataEXT = 'False -- ' closing tick for hsc2hs + type FieldOffset "maxLuminance" VkHdrMetadataEXT = + #{offset VkHdrMetadataEXT, maxLuminance} + type FieldIsArray "maxLuminance" VkHdrMetadataEXT = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkHdrMetadataEXT, maxLuminance} + +instance CanReadField "maxLuminance" VkHdrMetadataEXT where + {-# INLINE getField #-} + getField = vkMaxLuminance + + {-# INLINE readField #-} + readField = readVkMaxLuminance + +instance CanWriteField "maxLuminance" VkHdrMetadataEXT where + {-# INLINE writeField #-} + writeField = writeVkMaxLuminance + +instance {-# OVERLAPPING #-} HasVkMinLuminance VkHdrMetadataEXT + where + type VkMinLuminanceMType VkHdrMetadataEXT = + #{type float} + + {-# NOINLINE vkMinLuminance #-} + vkMinLuminance x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkHdrMetadataEXT, minLuminance}) + + {-# INLINE vkMinLuminanceByteOffset #-} + vkMinLuminanceByteOffset ~_ + = #{offset VkHdrMetadataEXT, minLuminance} + + {-# INLINE readVkMinLuminance #-} + readVkMinLuminance p + = peekByteOff p #{offset VkHdrMetadataEXT, minLuminance} + + {-# INLINE writeVkMinLuminance #-} + writeVkMinLuminance p + = pokeByteOff p #{offset VkHdrMetadataEXT, minLuminance} + +instance {-# OVERLAPPING #-} + HasField "minLuminance" VkHdrMetadataEXT where + type FieldType "minLuminance" VkHdrMetadataEXT = + #{type float} + type FieldOptional "minLuminance" VkHdrMetadataEXT = 'False -- ' closing tick for hsc2hs + type FieldOffset "minLuminance" VkHdrMetadataEXT = + #{offset VkHdrMetadataEXT, minLuminance} + type FieldIsArray "minLuminance" VkHdrMetadataEXT = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkHdrMetadataEXT, minLuminance} + +instance CanReadField "minLuminance" VkHdrMetadataEXT where + {-# INLINE getField #-} + getField = vkMinLuminance + + {-# INLINE readField #-} + readField = readVkMinLuminance + +instance CanWriteField "minLuminance" VkHdrMetadataEXT where + {-# INLINE writeField #-} + writeField = writeVkMinLuminance + +instance {-# OVERLAPPING #-} + HasVkMaxContentLightLevel VkHdrMetadataEXT where + type VkMaxContentLightLevelMType VkHdrMetadataEXT = + #{type float} + + {-# NOINLINE vkMaxContentLightLevel #-} + vkMaxContentLightLevel x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkHdrMetadataEXT, maxContentLightLevel}) + + {-# INLINE vkMaxContentLightLevelByteOffset #-} + vkMaxContentLightLevelByteOffset ~_ + = #{offset VkHdrMetadataEXT, maxContentLightLevel} + + {-# INLINE readVkMaxContentLightLevel #-} + readVkMaxContentLightLevel p + = peekByteOff p #{offset VkHdrMetadataEXT, maxContentLightLevel} + + {-# INLINE writeVkMaxContentLightLevel #-} + writeVkMaxContentLightLevel p + = pokeByteOff p #{offset VkHdrMetadataEXT, maxContentLightLevel} + +instance {-# OVERLAPPING #-} + HasField "maxContentLightLevel" VkHdrMetadataEXT where + type FieldType "maxContentLightLevel" VkHdrMetadataEXT = + #{type float} + type FieldOptional "maxContentLightLevel" VkHdrMetadataEXT = 'False -- ' closing tick for hsc2hs + type FieldOffset "maxContentLightLevel" VkHdrMetadataEXT = + #{offset VkHdrMetadataEXT, maxContentLightLevel} + type FieldIsArray "maxContentLightLevel" VkHdrMetadataEXT = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkHdrMetadataEXT, maxContentLightLevel} + +instance CanReadField "maxContentLightLevel" VkHdrMetadataEXT where + {-# INLINE getField #-} + getField = vkMaxContentLightLevel + + {-# INLINE readField #-} + readField = readVkMaxContentLightLevel + +instance CanWriteField "maxContentLightLevel" VkHdrMetadataEXT + where + {-# INLINE writeField #-} + writeField = writeVkMaxContentLightLevel + +instance {-# OVERLAPPING #-} + HasVkMaxFrameAverageLightLevel VkHdrMetadataEXT where + type VkMaxFrameAverageLightLevelMType VkHdrMetadataEXT = + #{type float} + + {-# NOINLINE vkMaxFrameAverageLightLevel #-} + vkMaxFrameAverageLightLevel x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkHdrMetadataEXT, maxFrameAverageLightLevel}) + + {-# INLINE vkMaxFrameAverageLightLevelByteOffset #-} + vkMaxFrameAverageLightLevelByteOffset ~_ + = #{offset VkHdrMetadataEXT, maxFrameAverageLightLevel} + + {-# INLINE readVkMaxFrameAverageLightLevel #-} + readVkMaxFrameAverageLightLevel p + = peekByteOff p #{offset VkHdrMetadataEXT, maxFrameAverageLightLevel} + + {-# INLINE writeVkMaxFrameAverageLightLevel #-} + writeVkMaxFrameAverageLightLevel p + = pokeByteOff p #{offset VkHdrMetadataEXT, maxFrameAverageLightLevel} + +instance {-# OVERLAPPING #-} + HasField "maxFrameAverageLightLevel" VkHdrMetadataEXT where + type FieldType "maxFrameAverageLightLevel" VkHdrMetadataEXT = + #{type float} + type FieldOptional "maxFrameAverageLightLevel" VkHdrMetadataEXT = + 'False -- ' closing tick for hsc2hs + type FieldOffset "maxFrameAverageLightLevel" VkHdrMetadataEXT = + #{offset VkHdrMetadataEXT, maxFrameAverageLightLevel} + type FieldIsArray "maxFrameAverageLightLevel" VkHdrMetadataEXT = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkHdrMetadataEXT, maxFrameAverageLightLevel} + +instance CanReadField "maxFrameAverageLightLevel" VkHdrMetadataEXT + where + {-# INLINE getField #-} + getField = vkMaxFrameAverageLightLevel + + {-# INLINE readField #-} + readField = readVkMaxFrameAverageLightLevel + +instance CanWriteField "maxFrameAverageLightLevel" VkHdrMetadataEXT + where + {-# INLINE writeField #-} + writeField = writeVkMaxFrameAverageLightLevel + +instance Show VkHdrMetadataEXT where + showsPrec d x + = showString "VkHdrMetadataEXT {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkDisplayPrimaryRed = " . + showsPrec d (vkDisplayPrimaryRed x) . + showString ", " . + showString "vkDisplayPrimaryGreen = " . + showsPrec d (vkDisplayPrimaryGreen x) . + showString ", " . + showString "vkDisplayPrimaryBlue = " . + showsPrec d (vkDisplayPrimaryBlue x) . + showString ", " . + showString "vkWhitePoint = " . + showsPrec d (vkWhitePoint x) . + showString ", " . + showString "vkMaxLuminance = " . + showsPrec d (vkMaxLuminance x) . + showString ", " . + showString "vkMinLuminance = " . + showsPrec d (vkMinLuminance x) . + showString ", " . + showString "vkMaxContentLightLevel = " + . + showsPrec d + (vkMaxContentLightLevel x) + . + showString ", " . + showString + "vkMaxFrameAverageLightLevel = " + . + showsPrec d + (vkMaxFrameAverageLightLevel + x) + . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkIOSSurfaceCreateInfoMVK.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkIOSSurfaceCreateInfoMVK.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkIOSSurfaceCreateInfoMVK.hsc @@ -0,0 +1,279 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkIOSSurfaceCreateInfoMVK + (VkIOSSurfaceCreateInfoMVK(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Bitmasks (VkIOSSurfaceCreateFlagsMVK) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkIOSSurfaceCreateInfoMVK { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkIOSSurfaceCreateFlagsMVK flags; +-- > const void* pView; +-- > } VkIOSSurfaceCreateInfoMVK; +-- +-- +data VkIOSSurfaceCreateInfoMVK = VkIOSSurfaceCreateInfoMVK## Addr## + ByteArray## + +instance Eq VkIOSSurfaceCreateInfoMVK where + (VkIOSSurfaceCreateInfoMVK## a _) == + x@(VkIOSSurfaceCreateInfoMVK## b _) = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkIOSSurfaceCreateInfoMVK where + (VkIOSSurfaceCreateInfoMVK## a _) `compare` + x@(VkIOSSurfaceCreateInfoMVK## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkIOSSurfaceCreateInfoMVK where + sizeOf ~_ = #{size VkIOSSurfaceCreateInfoMVK} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkIOSSurfaceCreateInfoMVK} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkIOSSurfaceCreateInfoMVK where + unsafeAddr (VkIOSSurfaceCreateInfoMVK## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkIOSSurfaceCreateInfoMVK## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkIOSSurfaceCreateInfoMVK## (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkIOSSurfaceCreateInfoMVK where + type StructFields VkIOSSurfaceCreateInfoMVK = + '["sType", "pNext", "flags", "pView"] -- ' closing tick for hsc2hs + type CUnionType VkIOSSurfaceCreateInfoMVK = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkIOSSurfaceCreateInfoMVK = 'False -- ' closing tick for hsc2hs + type StructExtends VkIOSSurfaceCreateInfoMVK = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkSType VkIOSSurfaceCreateInfoMVK + where + type VkSTypeMType VkIOSSurfaceCreateInfoMVK = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkIOSSurfaceCreateInfoMVK, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkIOSSurfaceCreateInfoMVK, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkIOSSurfaceCreateInfoMVK, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkIOSSurfaceCreateInfoMVK, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkIOSSurfaceCreateInfoMVK where + type FieldType "sType" VkIOSSurfaceCreateInfoMVK = VkStructureType + type FieldOptional "sType" VkIOSSurfaceCreateInfoMVK = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkIOSSurfaceCreateInfoMVK = + #{offset VkIOSSurfaceCreateInfoMVK, sType} + type FieldIsArray "sType" VkIOSSurfaceCreateInfoMVK = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkIOSSurfaceCreateInfoMVK, sType} + +instance CanReadField "sType" VkIOSSurfaceCreateInfoMVK where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkIOSSurfaceCreateInfoMVK where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} HasVkPNext VkIOSSurfaceCreateInfoMVK + where + type VkPNextMType VkIOSSurfaceCreateInfoMVK = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkIOSSurfaceCreateInfoMVK, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkIOSSurfaceCreateInfoMVK, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkIOSSurfaceCreateInfoMVK, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkIOSSurfaceCreateInfoMVK, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkIOSSurfaceCreateInfoMVK where + type FieldType "pNext" VkIOSSurfaceCreateInfoMVK = Ptr Void + type FieldOptional "pNext" VkIOSSurfaceCreateInfoMVK = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkIOSSurfaceCreateInfoMVK = + #{offset VkIOSSurfaceCreateInfoMVK, pNext} + type FieldIsArray "pNext" VkIOSSurfaceCreateInfoMVK = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkIOSSurfaceCreateInfoMVK, pNext} + +instance CanReadField "pNext" VkIOSSurfaceCreateInfoMVK where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkIOSSurfaceCreateInfoMVK where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} HasVkFlags VkIOSSurfaceCreateInfoMVK + where + type VkFlagsMType VkIOSSurfaceCreateInfoMVK = + VkIOSSurfaceCreateFlagsMVK + + {-# NOINLINE vkFlags #-} + vkFlags x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkIOSSurfaceCreateInfoMVK, flags}) + + {-# INLINE vkFlagsByteOffset #-} + vkFlagsByteOffset ~_ + = #{offset VkIOSSurfaceCreateInfoMVK, flags} + + {-# INLINE readVkFlags #-} + readVkFlags p + = peekByteOff p #{offset VkIOSSurfaceCreateInfoMVK, flags} + + {-# INLINE writeVkFlags #-} + writeVkFlags p + = pokeByteOff p #{offset VkIOSSurfaceCreateInfoMVK, flags} + +instance {-# OVERLAPPING #-} + HasField "flags" VkIOSSurfaceCreateInfoMVK where + type FieldType "flags" VkIOSSurfaceCreateInfoMVK = + VkIOSSurfaceCreateFlagsMVK + type FieldOptional "flags" VkIOSSurfaceCreateInfoMVK = 'True -- ' closing tick for hsc2hs + type FieldOffset "flags" VkIOSSurfaceCreateInfoMVK = + #{offset VkIOSSurfaceCreateInfoMVK, flags} + type FieldIsArray "flags" VkIOSSurfaceCreateInfoMVK = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkIOSSurfaceCreateInfoMVK, flags} + +instance CanReadField "flags" VkIOSSurfaceCreateInfoMVK where + {-# INLINE getField #-} + getField = vkFlags + + {-# INLINE readField #-} + readField = readVkFlags + +instance CanWriteField "flags" VkIOSSurfaceCreateInfoMVK where + {-# INLINE writeField #-} + writeField = writeVkFlags + +instance {-# OVERLAPPING #-} HasVkPView VkIOSSurfaceCreateInfoMVK + where + type VkPViewMType VkIOSSurfaceCreateInfoMVK = Ptr Void + + {-# NOINLINE vkPView #-} + vkPView x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkIOSSurfaceCreateInfoMVK, pView}) + + {-# INLINE vkPViewByteOffset #-} + vkPViewByteOffset ~_ + = #{offset VkIOSSurfaceCreateInfoMVK, pView} + + {-# INLINE readVkPView #-} + readVkPView p + = peekByteOff p #{offset VkIOSSurfaceCreateInfoMVK, pView} + + {-# INLINE writeVkPView #-} + writeVkPView p + = pokeByteOff p #{offset VkIOSSurfaceCreateInfoMVK, pView} + +instance {-# OVERLAPPING #-} + HasField "pView" VkIOSSurfaceCreateInfoMVK where + type FieldType "pView" VkIOSSurfaceCreateInfoMVK = Ptr Void + type FieldOptional "pView" VkIOSSurfaceCreateInfoMVK = 'False -- ' closing tick for hsc2hs + type FieldOffset "pView" VkIOSSurfaceCreateInfoMVK = + #{offset VkIOSSurfaceCreateInfoMVK, pView} + type FieldIsArray "pView" VkIOSSurfaceCreateInfoMVK = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkIOSSurfaceCreateInfoMVK, pView} + +instance CanReadField "pView" VkIOSSurfaceCreateInfoMVK where + {-# INLINE getField #-} + getField = vkPView + + {-# INLINE readField #-} + readField = readVkPView + +instance CanWriteField "pView" VkIOSSurfaceCreateInfoMVK where + {-# INLINE writeField #-} + writeField = writeVkPView + +instance Show VkIOSSurfaceCreateInfoMVK where + showsPrec d x + = showString "VkIOSSurfaceCreateInfoMVK {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkFlags = " . + showsPrec d (vkFlags x) . + showString ", " . + showString "vkPView = " . showsPrec d (vkPView x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkImageBlit.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkImageBlit.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkImageBlit.hsc @@ -0,0 +1,346 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleContexts #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE ScopedTypeVariables #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +{-# LANGUAGE UndecidableInstances #-} +module Graphics.Vulkan.Types.Struct.VkImageBlit (VkImageBlit(..)) + where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import GHC.TypeLits (KnownNat, + natVal') -- ' closing tick for hsc2hs +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Struct.VkImageSubresourceLayers (VkImageSubresourceLayers) +import Graphics.Vulkan.Types.Struct.VkOffset3D (VkOffset3D) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkImageBlit { +-- > VkImageSubresourceLayers srcSubresource; +-- > VkOffset3D srcOffsets[2]; +-- > VkImageSubresourceLayers dstSubresource; +-- > VkOffset3D dstOffsets[2]; +-- > } VkImageBlit; +-- +-- +data VkImageBlit = VkImageBlit## Addr## ByteArray## + +instance Eq VkImageBlit where + (VkImageBlit## a _) == x@(VkImageBlit## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkImageBlit where + (VkImageBlit## a _) `compare` x@(VkImageBlit## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkImageBlit where + sizeOf ~_ = #{size VkImageBlit} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkImageBlit} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkImageBlit where + unsafeAddr (VkImageBlit## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkImageBlit## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkImageBlit## (plusAddr## (byteArrayContents## b) off) b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkImageBlit where + type StructFields VkImageBlit = + '["srcSubresource", "srcOffsets", "dstSubresource", "dstOffsets"] -- ' closing tick for hsc2hs + type CUnionType VkImageBlit = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkImageBlit = 'False -- ' closing tick for hsc2hs + type StructExtends VkImageBlit = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkSrcSubresource VkImageBlit where + type VkSrcSubresourceMType VkImageBlit = VkImageSubresourceLayers + + {-# NOINLINE vkSrcSubresource #-} + vkSrcSubresource x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImageBlit, srcSubresource}) + + {-# INLINE vkSrcSubresourceByteOffset #-} + vkSrcSubresourceByteOffset ~_ + = #{offset VkImageBlit, srcSubresource} + + {-# INLINE readVkSrcSubresource #-} + readVkSrcSubresource p + = peekByteOff p #{offset VkImageBlit, srcSubresource} + + {-# INLINE writeVkSrcSubresource #-} + writeVkSrcSubresource p + = pokeByteOff p #{offset VkImageBlit, srcSubresource} + +instance {-# OVERLAPPING #-} HasField "srcSubresource" VkImageBlit + where + type FieldType "srcSubresource" VkImageBlit = + VkImageSubresourceLayers + type FieldOptional "srcSubresource" VkImageBlit = 'False -- ' closing tick for hsc2hs + type FieldOffset "srcSubresource" VkImageBlit = + #{offset VkImageBlit, srcSubresource} + type FieldIsArray "srcSubresource" VkImageBlit = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkImageBlit, srcSubresource} + +instance CanReadField "srcSubresource" VkImageBlit where + {-# INLINE getField #-} + getField = vkSrcSubresource + + {-# INLINE readField #-} + readField = readVkSrcSubresource + +instance CanWriteField "srcSubresource" VkImageBlit where + {-# INLINE writeField #-} + writeField = writeVkSrcSubresource + +instance {-# OVERLAPPING #-} HasVkSrcOffsetsArray VkImageBlit where + type VkSrcOffsetsArrayMType VkImageBlit = VkOffset3D + + {-# NOINLINE vkSrcOffsetsArray #-} + vkSrcOffsetsArray x idx + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) + (idx * sizeOf (undefined :: VkOffset3D) + + #{offset VkImageBlit, srcOffsets})) + + {-# INLINE vkSrcOffsetsArrayByteOffset #-} + vkSrcOffsetsArrayByteOffset ~_ + = #{offset VkImageBlit, srcOffsets} + + {-# INLINE readVkSrcOffsetsArray #-} + readVkSrcOffsetsArray p idx + = peekByteOff p + (idx * sizeOf (undefined :: VkOffset3D) + + #{offset VkImageBlit, srcOffsets}) + + {-# INLINE writeVkSrcOffsetsArray #-} + writeVkSrcOffsetsArray p idx + = pokeByteOff p + (idx * sizeOf (undefined :: VkOffset3D) + + #{offset VkImageBlit, srcOffsets}) + +instance {-# OVERLAPPING #-} HasField "srcOffsets" VkImageBlit + where + type FieldType "srcOffsets" VkImageBlit = VkOffset3D + type FieldOptional "srcOffsets" VkImageBlit = 'False -- ' closing tick for hsc2hs + type FieldOffset "srcOffsets" VkImageBlit = + #{offset VkImageBlit, srcOffsets} + type FieldIsArray "srcOffsets" VkImageBlit = 'True -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkImageBlit, srcOffsets} + +instance (KnownNat idx, + IndexInBounds "srcOffsets" idx VkImageBlit) => + CanReadFieldArray "srcOffsets" idx VkImageBlit + where + {-# SPECIALISE instance + CanReadFieldArray "srcOffsets" 0 VkImageBlit #-} + + {-# SPECIALISE instance + CanReadFieldArray "srcOffsets" 1 VkImageBlit #-} + type FieldArrayLength "srcOffsets" VkImageBlit = 2 + + {-# INLINE fieldArrayLength #-} + fieldArrayLength = 2 + + {-# INLINE getFieldArray #-} + getFieldArray x + = vkSrcOffsetsArray x + (fromInteger $ natVal' (proxy## :: Proxy## idx)) -- ' closing tick for hsc2hs + + {-# INLINE readFieldArray #-} + readFieldArray x + = readVkSrcOffsetsArray x + (fromInteger $ natVal' (proxy## :: Proxy## idx)) -- ' closing tick for hsc2hs + +instance (KnownNat idx, + IndexInBounds "srcOffsets" idx VkImageBlit) => + CanWriteFieldArray "srcOffsets" idx VkImageBlit + where + {-# SPECIALISE instance + CanWriteFieldArray "srcOffsets" 0 VkImageBlit #-} + + {-# SPECIALISE instance + CanWriteFieldArray "srcOffsets" 1 VkImageBlit #-} + + {-# INLINE writeFieldArray #-} + writeFieldArray x + = writeVkSrcOffsetsArray x + (fromInteger $ natVal' (proxy## :: Proxy## idx)) -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkDstSubresource VkImageBlit where + type VkDstSubresourceMType VkImageBlit = VkImageSubresourceLayers + + {-# NOINLINE vkDstSubresource #-} + vkDstSubresource x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImageBlit, dstSubresource}) + + {-# INLINE vkDstSubresourceByteOffset #-} + vkDstSubresourceByteOffset ~_ + = #{offset VkImageBlit, dstSubresource} + + {-# INLINE readVkDstSubresource #-} + readVkDstSubresource p + = peekByteOff p #{offset VkImageBlit, dstSubresource} + + {-# INLINE writeVkDstSubresource #-} + writeVkDstSubresource p + = pokeByteOff p #{offset VkImageBlit, dstSubresource} + +instance {-# OVERLAPPING #-} HasField "dstSubresource" VkImageBlit + where + type FieldType "dstSubresource" VkImageBlit = + VkImageSubresourceLayers + type FieldOptional "dstSubresource" VkImageBlit = 'False -- ' closing tick for hsc2hs + type FieldOffset "dstSubresource" VkImageBlit = + #{offset VkImageBlit, dstSubresource} + type FieldIsArray "dstSubresource" VkImageBlit = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkImageBlit, dstSubresource} + +instance CanReadField "dstSubresource" VkImageBlit where + {-# INLINE getField #-} + getField = vkDstSubresource + + {-# INLINE readField #-} + readField = readVkDstSubresource + +instance CanWriteField "dstSubresource" VkImageBlit where + {-# INLINE writeField #-} + writeField = writeVkDstSubresource + +instance {-# OVERLAPPING #-} HasVkDstOffsetsArray VkImageBlit where + type VkDstOffsetsArrayMType VkImageBlit = VkOffset3D + + {-# NOINLINE vkDstOffsetsArray #-} + vkDstOffsetsArray x idx + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) + (idx * sizeOf (undefined :: VkOffset3D) + + #{offset VkImageBlit, dstOffsets})) + + {-# INLINE vkDstOffsetsArrayByteOffset #-} + vkDstOffsetsArrayByteOffset ~_ + = #{offset VkImageBlit, dstOffsets} + + {-# INLINE readVkDstOffsetsArray #-} + readVkDstOffsetsArray p idx + = peekByteOff p + (idx * sizeOf (undefined :: VkOffset3D) + + #{offset VkImageBlit, dstOffsets}) + + {-# INLINE writeVkDstOffsetsArray #-} + writeVkDstOffsetsArray p idx + = pokeByteOff p + (idx * sizeOf (undefined :: VkOffset3D) + + #{offset VkImageBlit, dstOffsets}) + +instance {-# OVERLAPPING #-} HasField "dstOffsets" VkImageBlit + where + type FieldType "dstOffsets" VkImageBlit = VkOffset3D + type FieldOptional "dstOffsets" VkImageBlit = 'False -- ' closing tick for hsc2hs + type FieldOffset "dstOffsets" VkImageBlit = + #{offset VkImageBlit, dstOffsets} + type FieldIsArray "dstOffsets" VkImageBlit = 'True -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkImageBlit, dstOffsets} + +instance (KnownNat idx, + IndexInBounds "dstOffsets" idx VkImageBlit) => + CanReadFieldArray "dstOffsets" idx VkImageBlit + where + {-# SPECIALISE instance + CanReadFieldArray "dstOffsets" 0 VkImageBlit #-} + + {-# SPECIALISE instance + CanReadFieldArray "dstOffsets" 1 VkImageBlit #-} + type FieldArrayLength "dstOffsets" VkImageBlit = 2 + + {-# INLINE fieldArrayLength #-} + fieldArrayLength = 2 + + {-# INLINE getFieldArray #-} + getFieldArray x + = vkDstOffsetsArray x + (fromInteger $ natVal' (proxy## :: Proxy## idx)) -- ' closing tick for hsc2hs + + {-# INLINE readFieldArray #-} + readFieldArray x + = readVkDstOffsetsArray x + (fromInteger $ natVal' (proxy## :: Proxy## idx)) -- ' closing tick for hsc2hs + +instance (KnownNat idx, + IndexInBounds "dstOffsets" idx VkImageBlit) => + CanWriteFieldArray "dstOffsets" idx VkImageBlit + where + {-# SPECIALISE instance + CanWriteFieldArray "dstOffsets" 0 VkImageBlit #-} + + {-# SPECIALISE instance + CanWriteFieldArray "dstOffsets" 1 VkImageBlit #-} + + {-# INLINE writeFieldArray #-} + writeFieldArray x + = writeVkDstOffsetsArray x + (fromInteger $ natVal' (proxy## :: Proxy## idx)) -- ' closing tick for hsc2hs + +instance Show VkImageBlit where + showsPrec d x + = showString "VkImageBlit {" . + showString "vkSrcSubresource = " . + showsPrec d (vkSrcSubresource x) . + showString ", " . + showString "vkSrcOffsetsArray = [" . + showsPrec d (map (vkSrcOffsetsArray x) [1 .. 2]) . + showChar ']' . + showString ", " . + showString "vkDstSubresource = " . + showsPrec d (vkDstSubresource x) . + showString ", " . + showString "vkDstOffsetsArray = [" . + showsPrec d (map (vkDstOffsetsArray x) [1 .. 2]) . + showChar ']' . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkImageCopy.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkImageCopy.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkImageCopy.hsc @@ -0,0 +1,317 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkImageCopy (VkImageCopy(..)) + where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Struct.VkExtent3D (VkExtent3D) +import Graphics.Vulkan.Types.Struct.VkImageSubresourceLayers (VkImageSubresourceLayers) +import Graphics.Vulkan.Types.Struct.VkOffset3D (VkOffset3D) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkImageCopy { +-- > VkImageSubresourceLayers srcSubresource; +-- > VkOffset3D srcOffset; +-- > VkImageSubresourceLayers dstSubresource; +-- > VkOffset3D dstOffset; +-- > VkExtent3D extent; +-- > } VkImageCopy; +-- +-- +data VkImageCopy = VkImageCopy## Addr## ByteArray## + +instance Eq VkImageCopy where + (VkImageCopy## a _) == x@(VkImageCopy## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkImageCopy where + (VkImageCopy## a _) `compare` x@(VkImageCopy## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkImageCopy where + sizeOf ~_ = #{size VkImageCopy} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkImageCopy} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkImageCopy where + unsafeAddr (VkImageCopy## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkImageCopy## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkImageCopy## (plusAddr## (byteArrayContents## b) off) b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkImageCopy where + type StructFields VkImageCopy = + '["srcSubresource", "srcOffset", "dstSubresource", "dstOffset", -- ' closing tick for hsc2hs + "extent"] + type CUnionType VkImageCopy = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkImageCopy = 'False -- ' closing tick for hsc2hs + type StructExtends VkImageCopy = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkSrcSubresource VkImageCopy where + type VkSrcSubresourceMType VkImageCopy = VkImageSubresourceLayers + + {-# NOINLINE vkSrcSubresource #-} + vkSrcSubresource x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImageCopy, srcSubresource}) + + {-# INLINE vkSrcSubresourceByteOffset #-} + vkSrcSubresourceByteOffset ~_ + = #{offset VkImageCopy, srcSubresource} + + {-# INLINE readVkSrcSubresource #-} + readVkSrcSubresource p + = peekByteOff p #{offset VkImageCopy, srcSubresource} + + {-# INLINE writeVkSrcSubresource #-} + writeVkSrcSubresource p + = pokeByteOff p #{offset VkImageCopy, srcSubresource} + +instance {-# OVERLAPPING #-} HasField "srcSubresource" VkImageCopy + where + type FieldType "srcSubresource" VkImageCopy = + VkImageSubresourceLayers + type FieldOptional "srcSubresource" VkImageCopy = 'False -- ' closing tick for hsc2hs + type FieldOffset "srcSubresource" VkImageCopy = + #{offset VkImageCopy, srcSubresource} + type FieldIsArray "srcSubresource" VkImageCopy = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkImageCopy, srcSubresource} + +instance CanReadField "srcSubresource" VkImageCopy where + {-# INLINE getField #-} + getField = vkSrcSubresource + + {-# INLINE readField #-} + readField = readVkSrcSubresource + +instance CanWriteField "srcSubresource" VkImageCopy where + {-# INLINE writeField #-} + writeField = writeVkSrcSubresource + +instance {-# OVERLAPPING #-} HasVkSrcOffset VkImageCopy where + type VkSrcOffsetMType VkImageCopy = VkOffset3D + + {-# NOINLINE vkSrcOffset #-} + vkSrcOffset x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImageCopy, srcOffset}) + + {-# INLINE vkSrcOffsetByteOffset #-} + vkSrcOffsetByteOffset ~_ + = #{offset VkImageCopy, srcOffset} + + {-# INLINE readVkSrcOffset #-} + readVkSrcOffset p + = peekByteOff p #{offset VkImageCopy, srcOffset} + + {-# INLINE writeVkSrcOffset #-} + writeVkSrcOffset p + = pokeByteOff p #{offset VkImageCopy, srcOffset} + +instance {-# OVERLAPPING #-} HasField "srcOffset" VkImageCopy where + type FieldType "srcOffset" VkImageCopy = VkOffset3D + type FieldOptional "srcOffset" VkImageCopy = 'False -- ' closing tick for hsc2hs + type FieldOffset "srcOffset" VkImageCopy = + #{offset VkImageCopy, srcOffset} + type FieldIsArray "srcOffset" VkImageCopy = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkImageCopy, srcOffset} + +instance CanReadField "srcOffset" VkImageCopy where + {-# INLINE getField #-} + getField = vkSrcOffset + + {-# INLINE readField #-} + readField = readVkSrcOffset + +instance CanWriteField "srcOffset" VkImageCopy where + {-# INLINE writeField #-} + writeField = writeVkSrcOffset + +instance {-# OVERLAPPING #-} HasVkDstSubresource VkImageCopy where + type VkDstSubresourceMType VkImageCopy = VkImageSubresourceLayers + + {-# NOINLINE vkDstSubresource #-} + vkDstSubresource x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImageCopy, dstSubresource}) + + {-# INLINE vkDstSubresourceByteOffset #-} + vkDstSubresourceByteOffset ~_ + = #{offset VkImageCopy, dstSubresource} + + {-# INLINE readVkDstSubresource #-} + readVkDstSubresource p + = peekByteOff p #{offset VkImageCopy, dstSubresource} + + {-# INLINE writeVkDstSubresource #-} + writeVkDstSubresource p + = pokeByteOff p #{offset VkImageCopy, dstSubresource} + +instance {-# OVERLAPPING #-} HasField "dstSubresource" VkImageCopy + where + type FieldType "dstSubresource" VkImageCopy = + VkImageSubresourceLayers + type FieldOptional "dstSubresource" VkImageCopy = 'False -- ' closing tick for hsc2hs + type FieldOffset "dstSubresource" VkImageCopy = + #{offset VkImageCopy, dstSubresource} + type FieldIsArray "dstSubresource" VkImageCopy = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkImageCopy, dstSubresource} + +instance CanReadField "dstSubresource" VkImageCopy where + {-# INLINE getField #-} + getField = vkDstSubresource + + {-# INLINE readField #-} + readField = readVkDstSubresource + +instance CanWriteField "dstSubresource" VkImageCopy where + {-# INLINE writeField #-} + writeField = writeVkDstSubresource + +instance {-# OVERLAPPING #-} HasVkDstOffset VkImageCopy where + type VkDstOffsetMType VkImageCopy = VkOffset3D + + {-# NOINLINE vkDstOffset #-} + vkDstOffset x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImageCopy, dstOffset}) + + {-# INLINE vkDstOffsetByteOffset #-} + vkDstOffsetByteOffset ~_ + = #{offset VkImageCopy, dstOffset} + + {-# INLINE readVkDstOffset #-} + readVkDstOffset p + = peekByteOff p #{offset VkImageCopy, dstOffset} + + {-# INLINE writeVkDstOffset #-} + writeVkDstOffset p + = pokeByteOff p #{offset VkImageCopy, dstOffset} + +instance {-# OVERLAPPING #-} HasField "dstOffset" VkImageCopy where + type FieldType "dstOffset" VkImageCopy = VkOffset3D + type FieldOptional "dstOffset" VkImageCopy = 'False -- ' closing tick for hsc2hs + type FieldOffset "dstOffset" VkImageCopy = + #{offset VkImageCopy, dstOffset} + type FieldIsArray "dstOffset" VkImageCopy = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkImageCopy, dstOffset} + +instance CanReadField "dstOffset" VkImageCopy where + {-# INLINE getField #-} + getField = vkDstOffset + + {-# INLINE readField #-} + readField = readVkDstOffset + +instance CanWriteField "dstOffset" VkImageCopy where + {-# INLINE writeField #-} + writeField = writeVkDstOffset + +instance {-# OVERLAPPING #-} HasVkExtent VkImageCopy where + type VkExtentMType VkImageCopy = VkExtent3D + + {-# NOINLINE vkExtent #-} + vkExtent x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImageCopy, extent}) + + {-# INLINE vkExtentByteOffset #-} + vkExtentByteOffset ~_ = #{offset VkImageCopy, extent} + + {-# INLINE readVkExtent #-} + readVkExtent p + = peekByteOff p #{offset VkImageCopy, extent} + + {-# INLINE writeVkExtent #-} + writeVkExtent p + = pokeByteOff p #{offset VkImageCopy, extent} + +instance {-# OVERLAPPING #-} HasField "extent" VkImageCopy where + type FieldType "extent" VkImageCopy = VkExtent3D + type FieldOptional "extent" VkImageCopy = 'False -- ' closing tick for hsc2hs + type FieldOffset "extent" VkImageCopy = + #{offset VkImageCopy, extent} + type FieldIsArray "extent" VkImageCopy = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkImageCopy, extent} + +instance CanReadField "extent" VkImageCopy where + {-# INLINE getField #-} + getField = vkExtent + + {-# INLINE readField #-} + readField = readVkExtent + +instance CanWriteField "extent" VkImageCopy where + {-# INLINE writeField #-} + writeField = writeVkExtent + +instance Show VkImageCopy where + showsPrec d x + = showString "VkImageCopy {" . + showString "vkSrcSubresource = " . + showsPrec d (vkSrcSubresource x) . + showString ", " . + showString "vkSrcOffset = " . + showsPrec d (vkSrcOffset x) . + showString ", " . + showString "vkDstSubresource = " . + showsPrec d (vkDstSubresource x) . + showString ", " . + showString "vkDstOffset = " . + showsPrec d (vkDstOffset x) . + showString ", " . + showString "vkExtent = " . + showsPrec d (vkExtent x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkImageCreateInfo.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkImageCreateInfo.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkImageCreateInfo.hsc @@ -0,0 +1,861 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkImageCreateInfo + (VkImageCreateInfo(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkFormat (VkFormat) +import Graphics.Vulkan.Types.Enum.VkImageCreateFlags (VkImageCreateFlags) +import Graphics.Vulkan.Types.Enum.VkImageLayout (VkImageLayout) +import Graphics.Vulkan.Types.Enum.VkImageTiling (VkImageTiling) +import Graphics.Vulkan.Types.Enum.VkImageType (VkImageType) +import Graphics.Vulkan.Types.Enum.VkImageUsageFlags (VkImageUsageFlags) +import Graphics.Vulkan.Types.Enum.VkSampleCountFlags (VkSampleCountFlagBits) +import Graphics.Vulkan.Types.Enum.VkSharingMode (VkSharingMode) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Struct.VkExtent3D (VkExtent3D) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkImageCreateInfo { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkImageCreateFlags flags; +-- > VkImageType imageType; +-- > VkFormat format; +-- > VkExtent3D extent; +-- > uint32_t mipLevels; +-- > uint32_t arrayLayers; +-- > VkSampleCountFlagBits samples; +-- > VkImageTiling tiling; +-- > VkImageUsageFlags usage; +-- > VkSharingMode sharingMode; +-- > uint32_t queueFamilyIndexCount; +-- > const uint32_t* pQueueFamilyIndices; +-- > VkImageLayout initialLayout; +-- > } VkImageCreateInfo; +-- +-- +data VkImageCreateInfo = VkImageCreateInfo## Addr## ByteArray## + +instance Eq VkImageCreateInfo where + (VkImageCreateInfo## a _) == x@(VkImageCreateInfo## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkImageCreateInfo where + (VkImageCreateInfo## a _) `compare` x@(VkImageCreateInfo## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkImageCreateInfo where + sizeOf ~_ = #{size VkImageCreateInfo} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkImageCreateInfo} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkImageCreateInfo where + unsafeAddr (VkImageCreateInfo## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkImageCreateInfo## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkImageCreateInfo## (plusAddr## (byteArrayContents## b) off) b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkImageCreateInfo where + type StructFields VkImageCreateInfo = + '["sType", "pNext", "flags", "imageType", "format", "extent", -- ' closing tick for hsc2hs + "mipLevels", "arrayLayers", "samples", "tiling", "usage", + "sharingMode", "queueFamilyIndexCount", "pQueueFamilyIndices", + "initialLayout"] + type CUnionType VkImageCreateInfo = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkImageCreateInfo = 'False -- ' closing tick for hsc2hs + type StructExtends VkImageCreateInfo = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkSType VkImageCreateInfo where + type VkSTypeMType VkImageCreateInfo = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImageCreateInfo, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkImageCreateInfo, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkImageCreateInfo, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkImageCreateInfo, sType} + +instance {-# OVERLAPPING #-} HasField "sType" VkImageCreateInfo + where + type FieldType "sType" VkImageCreateInfo = VkStructureType + type FieldOptional "sType" VkImageCreateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkImageCreateInfo = + #{offset VkImageCreateInfo, sType} + type FieldIsArray "sType" VkImageCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkImageCreateInfo, sType} + +instance CanReadField "sType" VkImageCreateInfo where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkImageCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} HasVkPNext VkImageCreateInfo where + type VkPNextMType VkImageCreateInfo = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImageCreateInfo, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkImageCreateInfo, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkImageCreateInfo, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkImageCreateInfo, pNext} + +instance {-# OVERLAPPING #-} HasField "pNext" VkImageCreateInfo + where + type FieldType "pNext" VkImageCreateInfo = Ptr Void + type FieldOptional "pNext" VkImageCreateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkImageCreateInfo = + #{offset VkImageCreateInfo, pNext} + type FieldIsArray "pNext" VkImageCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkImageCreateInfo, pNext} + +instance CanReadField "pNext" VkImageCreateInfo where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkImageCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} HasVkFlags VkImageCreateInfo where + type VkFlagsMType VkImageCreateInfo = VkImageCreateFlags + + {-# NOINLINE vkFlags #-} + vkFlags x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImageCreateInfo, flags}) + + {-# INLINE vkFlagsByteOffset #-} + vkFlagsByteOffset ~_ + = #{offset VkImageCreateInfo, flags} + + {-# INLINE readVkFlags #-} + readVkFlags p + = peekByteOff p #{offset VkImageCreateInfo, flags} + + {-# INLINE writeVkFlags #-} + writeVkFlags p + = pokeByteOff p #{offset VkImageCreateInfo, flags} + +instance {-# OVERLAPPING #-} HasField "flags" VkImageCreateInfo + where + type FieldType "flags" VkImageCreateInfo = VkImageCreateFlags + type FieldOptional "flags" VkImageCreateInfo = 'True -- ' closing tick for hsc2hs + type FieldOffset "flags" VkImageCreateInfo = + #{offset VkImageCreateInfo, flags} + type FieldIsArray "flags" VkImageCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkImageCreateInfo, flags} + +instance CanReadField "flags" VkImageCreateInfo where + {-# INLINE getField #-} + getField = vkFlags + + {-# INLINE readField #-} + readField = readVkFlags + +instance CanWriteField "flags" VkImageCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkFlags + +instance {-# OVERLAPPING #-} HasVkImageType VkImageCreateInfo where + type VkImageTypeMType VkImageCreateInfo = VkImageType + + {-# NOINLINE vkImageType #-} + vkImageType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImageCreateInfo, imageType}) + + {-# INLINE vkImageTypeByteOffset #-} + vkImageTypeByteOffset ~_ + = #{offset VkImageCreateInfo, imageType} + + {-# INLINE readVkImageType #-} + readVkImageType p + = peekByteOff p #{offset VkImageCreateInfo, imageType} + + {-# INLINE writeVkImageType #-} + writeVkImageType p + = pokeByteOff p #{offset VkImageCreateInfo, imageType} + +instance {-# OVERLAPPING #-} HasField "imageType" VkImageCreateInfo + where + type FieldType "imageType" VkImageCreateInfo = VkImageType + type FieldOptional "imageType" VkImageCreateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "imageType" VkImageCreateInfo = + #{offset VkImageCreateInfo, imageType} + type FieldIsArray "imageType" VkImageCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkImageCreateInfo, imageType} + +instance CanReadField "imageType" VkImageCreateInfo where + {-# INLINE getField #-} + getField = vkImageType + + {-# INLINE readField #-} + readField = readVkImageType + +instance CanWriteField "imageType" VkImageCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkImageType + +instance {-# OVERLAPPING #-} HasVkFormat VkImageCreateInfo where + type VkFormatMType VkImageCreateInfo = VkFormat + + {-# NOINLINE vkFormat #-} + vkFormat x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImageCreateInfo, format}) + + {-# INLINE vkFormatByteOffset #-} + vkFormatByteOffset ~_ + = #{offset VkImageCreateInfo, format} + + {-# INLINE readVkFormat #-} + readVkFormat p + = peekByteOff p #{offset VkImageCreateInfo, format} + + {-# INLINE writeVkFormat #-} + writeVkFormat p + = pokeByteOff p #{offset VkImageCreateInfo, format} + +instance {-# OVERLAPPING #-} HasField "format" VkImageCreateInfo + where + type FieldType "format" VkImageCreateInfo = VkFormat + type FieldOptional "format" VkImageCreateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "format" VkImageCreateInfo = + #{offset VkImageCreateInfo, format} + type FieldIsArray "format" VkImageCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkImageCreateInfo, format} + +instance CanReadField "format" VkImageCreateInfo where + {-# INLINE getField #-} + getField = vkFormat + + {-# INLINE readField #-} + readField = readVkFormat + +instance CanWriteField "format" VkImageCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkFormat + +instance {-# OVERLAPPING #-} HasVkExtent VkImageCreateInfo where + type VkExtentMType VkImageCreateInfo = VkExtent3D + + {-# NOINLINE vkExtent #-} + vkExtent x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImageCreateInfo, extent}) + + {-# INLINE vkExtentByteOffset #-} + vkExtentByteOffset ~_ + = #{offset VkImageCreateInfo, extent} + + {-# INLINE readVkExtent #-} + readVkExtent p + = peekByteOff p #{offset VkImageCreateInfo, extent} + + {-# INLINE writeVkExtent #-} + writeVkExtent p + = pokeByteOff p #{offset VkImageCreateInfo, extent} + +instance {-# OVERLAPPING #-} HasField "extent" VkImageCreateInfo + where + type FieldType "extent" VkImageCreateInfo = VkExtent3D + type FieldOptional "extent" VkImageCreateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "extent" VkImageCreateInfo = + #{offset VkImageCreateInfo, extent} + type FieldIsArray "extent" VkImageCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkImageCreateInfo, extent} + +instance CanReadField "extent" VkImageCreateInfo where + {-# INLINE getField #-} + getField = vkExtent + + {-# INLINE readField #-} + readField = readVkExtent + +instance CanWriteField "extent" VkImageCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkExtent + +instance {-# OVERLAPPING #-} HasVkMipLevels VkImageCreateInfo where + type VkMipLevelsMType VkImageCreateInfo = Word32 + + {-# NOINLINE vkMipLevels #-} + vkMipLevels x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImageCreateInfo, mipLevels}) + + {-# INLINE vkMipLevelsByteOffset #-} + vkMipLevelsByteOffset ~_ + = #{offset VkImageCreateInfo, mipLevels} + + {-# INLINE readVkMipLevels #-} + readVkMipLevels p + = peekByteOff p #{offset VkImageCreateInfo, mipLevels} + + {-# INLINE writeVkMipLevels #-} + writeVkMipLevels p + = pokeByteOff p #{offset VkImageCreateInfo, mipLevels} + +instance {-# OVERLAPPING #-} HasField "mipLevels" VkImageCreateInfo + where + type FieldType "mipLevels" VkImageCreateInfo = Word32 + type FieldOptional "mipLevels" VkImageCreateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "mipLevels" VkImageCreateInfo = + #{offset VkImageCreateInfo, mipLevels} + type FieldIsArray "mipLevels" VkImageCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkImageCreateInfo, mipLevels} + +instance CanReadField "mipLevels" VkImageCreateInfo where + {-# INLINE getField #-} + getField = vkMipLevels + + {-# INLINE readField #-} + readField = readVkMipLevels + +instance CanWriteField "mipLevels" VkImageCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkMipLevels + +instance {-# OVERLAPPING #-} HasVkArrayLayers VkImageCreateInfo + where + type VkArrayLayersMType VkImageCreateInfo = Word32 + + {-# NOINLINE vkArrayLayers #-} + vkArrayLayers x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImageCreateInfo, arrayLayers}) + + {-# INLINE vkArrayLayersByteOffset #-} + vkArrayLayersByteOffset ~_ + = #{offset VkImageCreateInfo, arrayLayers} + + {-# INLINE readVkArrayLayers #-} + readVkArrayLayers p + = peekByteOff p #{offset VkImageCreateInfo, arrayLayers} + + {-# INLINE writeVkArrayLayers #-} + writeVkArrayLayers p + = pokeByteOff p #{offset VkImageCreateInfo, arrayLayers} + +instance {-# OVERLAPPING #-} + HasField "arrayLayers" VkImageCreateInfo where + type FieldType "arrayLayers" VkImageCreateInfo = Word32 + type FieldOptional "arrayLayers" VkImageCreateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "arrayLayers" VkImageCreateInfo = + #{offset VkImageCreateInfo, arrayLayers} + type FieldIsArray "arrayLayers" VkImageCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkImageCreateInfo, arrayLayers} + +instance CanReadField "arrayLayers" VkImageCreateInfo where + {-# INLINE getField #-} + getField = vkArrayLayers + + {-# INLINE readField #-} + readField = readVkArrayLayers + +instance CanWriteField "arrayLayers" VkImageCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkArrayLayers + +instance {-# OVERLAPPING #-} HasVkSamples VkImageCreateInfo where + type VkSamplesMType VkImageCreateInfo = VkSampleCountFlagBits + + {-# NOINLINE vkSamples #-} + vkSamples x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImageCreateInfo, samples}) + + {-# INLINE vkSamplesByteOffset #-} + vkSamplesByteOffset ~_ + = #{offset VkImageCreateInfo, samples} + + {-# INLINE readVkSamples #-} + readVkSamples p + = peekByteOff p #{offset VkImageCreateInfo, samples} + + {-# INLINE writeVkSamples #-} + writeVkSamples p + = pokeByteOff p #{offset VkImageCreateInfo, samples} + +instance {-# OVERLAPPING #-} HasField "samples" VkImageCreateInfo + where + type FieldType "samples" VkImageCreateInfo = VkSampleCountFlagBits + type FieldOptional "samples" VkImageCreateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "samples" VkImageCreateInfo = + #{offset VkImageCreateInfo, samples} + type FieldIsArray "samples" VkImageCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkImageCreateInfo, samples} + +instance CanReadField "samples" VkImageCreateInfo where + {-# INLINE getField #-} + getField = vkSamples + + {-# INLINE readField #-} + readField = readVkSamples + +instance CanWriteField "samples" VkImageCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkSamples + +instance {-# OVERLAPPING #-} HasVkTiling VkImageCreateInfo where + type VkTilingMType VkImageCreateInfo = VkImageTiling + + {-# NOINLINE vkTiling #-} + vkTiling x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImageCreateInfo, tiling}) + + {-# INLINE vkTilingByteOffset #-} + vkTilingByteOffset ~_ + = #{offset VkImageCreateInfo, tiling} + + {-# INLINE readVkTiling #-} + readVkTiling p + = peekByteOff p #{offset VkImageCreateInfo, tiling} + + {-# INLINE writeVkTiling #-} + writeVkTiling p + = pokeByteOff p #{offset VkImageCreateInfo, tiling} + +instance {-# OVERLAPPING #-} HasField "tiling" VkImageCreateInfo + where + type FieldType "tiling" VkImageCreateInfo = VkImageTiling + type FieldOptional "tiling" VkImageCreateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "tiling" VkImageCreateInfo = + #{offset VkImageCreateInfo, tiling} + type FieldIsArray "tiling" VkImageCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkImageCreateInfo, tiling} + +instance CanReadField "tiling" VkImageCreateInfo where + {-# INLINE getField #-} + getField = vkTiling + + {-# INLINE readField #-} + readField = readVkTiling + +instance CanWriteField "tiling" VkImageCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkTiling + +instance {-# OVERLAPPING #-} HasVkUsage VkImageCreateInfo where + type VkUsageMType VkImageCreateInfo = VkImageUsageFlags + + {-# NOINLINE vkUsage #-} + vkUsage x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImageCreateInfo, usage}) + + {-# INLINE vkUsageByteOffset #-} + vkUsageByteOffset ~_ + = #{offset VkImageCreateInfo, usage} + + {-# INLINE readVkUsage #-} + readVkUsage p + = peekByteOff p #{offset VkImageCreateInfo, usage} + + {-# INLINE writeVkUsage #-} + writeVkUsage p + = pokeByteOff p #{offset VkImageCreateInfo, usage} + +instance {-# OVERLAPPING #-} HasField "usage" VkImageCreateInfo + where + type FieldType "usage" VkImageCreateInfo = VkImageUsageFlags + type FieldOptional "usage" VkImageCreateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "usage" VkImageCreateInfo = + #{offset VkImageCreateInfo, usage} + type FieldIsArray "usage" VkImageCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkImageCreateInfo, usage} + +instance CanReadField "usage" VkImageCreateInfo where + {-# INLINE getField #-} + getField = vkUsage + + {-# INLINE readField #-} + readField = readVkUsage + +instance CanWriteField "usage" VkImageCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkUsage + +instance {-# OVERLAPPING #-} HasVkSharingMode VkImageCreateInfo + where + type VkSharingModeMType VkImageCreateInfo = VkSharingMode + + {-# NOINLINE vkSharingMode #-} + vkSharingMode x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImageCreateInfo, sharingMode}) + + {-# INLINE vkSharingModeByteOffset #-} + vkSharingModeByteOffset ~_ + = #{offset VkImageCreateInfo, sharingMode} + + {-# INLINE readVkSharingMode #-} + readVkSharingMode p + = peekByteOff p #{offset VkImageCreateInfo, sharingMode} + + {-# INLINE writeVkSharingMode #-} + writeVkSharingMode p + = pokeByteOff p #{offset VkImageCreateInfo, sharingMode} + +instance {-# OVERLAPPING #-} + HasField "sharingMode" VkImageCreateInfo where + type FieldType "sharingMode" VkImageCreateInfo = VkSharingMode + type FieldOptional "sharingMode" VkImageCreateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "sharingMode" VkImageCreateInfo = + #{offset VkImageCreateInfo, sharingMode} + type FieldIsArray "sharingMode" VkImageCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkImageCreateInfo, sharingMode} + +instance CanReadField "sharingMode" VkImageCreateInfo where + {-# INLINE getField #-} + getField = vkSharingMode + + {-# INLINE readField #-} + readField = readVkSharingMode + +instance CanWriteField "sharingMode" VkImageCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkSharingMode + +instance {-# OVERLAPPING #-} + HasVkQueueFamilyIndexCount VkImageCreateInfo where + type VkQueueFamilyIndexCountMType VkImageCreateInfo = Word32 + + {-# NOINLINE vkQueueFamilyIndexCount #-} + vkQueueFamilyIndexCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImageCreateInfo, queueFamilyIndexCount}) + + {-# INLINE vkQueueFamilyIndexCountByteOffset #-} + vkQueueFamilyIndexCountByteOffset ~_ + = #{offset VkImageCreateInfo, queueFamilyIndexCount} + + {-# INLINE readVkQueueFamilyIndexCount #-} + readVkQueueFamilyIndexCount p + = peekByteOff p #{offset VkImageCreateInfo, queueFamilyIndexCount} + + {-# INLINE writeVkQueueFamilyIndexCount #-} + writeVkQueueFamilyIndexCount p + = pokeByteOff p #{offset VkImageCreateInfo, queueFamilyIndexCount} + +instance {-# OVERLAPPING #-} + HasField "queueFamilyIndexCount" VkImageCreateInfo where + type FieldType "queueFamilyIndexCount" VkImageCreateInfo = Word32 + type FieldOptional "queueFamilyIndexCount" VkImageCreateInfo = + 'True -- ' closing tick for hsc2hs + type FieldOffset "queueFamilyIndexCount" VkImageCreateInfo = + #{offset VkImageCreateInfo, queueFamilyIndexCount} + type FieldIsArray "queueFamilyIndexCount" VkImageCreateInfo = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkImageCreateInfo, queueFamilyIndexCount} + +instance CanReadField "queueFamilyIndexCount" VkImageCreateInfo + where + {-# INLINE getField #-} + getField = vkQueueFamilyIndexCount + + {-# INLINE readField #-} + readField = readVkQueueFamilyIndexCount + +instance CanWriteField "queueFamilyIndexCount" VkImageCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkQueueFamilyIndexCount + +instance {-# OVERLAPPING #-} + HasVkPQueueFamilyIndices VkImageCreateInfo where + type VkPQueueFamilyIndicesMType VkImageCreateInfo = Ptr Word32 + + {-# NOINLINE vkPQueueFamilyIndices #-} + vkPQueueFamilyIndices x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImageCreateInfo, pQueueFamilyIndices}) + + {-# INLINE vkPQueueFamilyIndicesByteOffset #-} + vkPQueueFamilyIndicesByteOffset ~_ + = #{offset VkImageCreateInfo, pQueueFamilyIndices} + + {-# INLINE readVkPQueueFamilyIndices #-} + readVkPQueueFamilyIndices p + = peekByteOff p #{offset VkImageCreateInfo, pQueueFamilyIndices} + + {-# INLINE writeVkPQueueFamilyIndices #-} + writeVkPQueueFamilyIndices p + = pokeByteOff p #{offset VkImageCreateInfo, pQueueFamilyIndices} + +instance {-# OVERLAPPING #-} + HasField "pQueueFamilyIndices" VkImageCreateInfo where + type FieldType "pQueueFamilyIndices" VkImageCreateInfo = Ptr Word32 + type FieldOptional "pQueueFamilyIndices" VkImageCreateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "pQueueFamilyIndices" VkImageCreateInfo = + #{offset VkImageCreateInfo, pQueueFamilyIndices} + type FieldIsArray "pQueueFamilyIndices" VkImageCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkImageCreateInfo, pQueueFamilyIndices} + +instance CanReadField "pQueueFamilyIndices" VkImageCreateInfo where + {-# INLINE getField #-} + getField = vkPQueueFamilyIndices + + {-# INLINE readField #-} + readField = readVkPQueueFamilyIndices + +instance CanWriteField "pQueueFamilyIndices" VkImageCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkPQueueFamilyIndices + +instance {-# OVERLAPPING #-} HasVkInitialLayout VkImageCreateInfo + where + type VkInitialLayoutMType VkImageCreateInfo = VkImageLayout + + {-# NOINLINE vkInitialLayout #-} + vkInitialLayout x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImageCreateInfo, initialLayout}) + + {-# INLINE vkInitialLayoutByteOffset #-} + vkInitialLayoutByteOffset ~_ + = #{offset VkImageCreateInfo, initialLayout} + + {-# INLINE readVkInitialLayout #-} + readVkInitialLayout p + = peekByteOff p #{offset VkImageCreateInfo, initialLayout} + + {-# INLINE writeVkInitialLayout #-} + writeVkInitialLayout p + = pokeByteOff p #{offset VkImageCreateInfo, initialLayout} + +instance {-# OVERLAPPING #-} + HasField "initialLayout" VkImageCreateInfo where + type FieldType "initialLayout" VkImageCreateInfo = VkImageLayout + type FieldOptional "initialLayout" VkImageCreateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "initialLayout" VkImageCreateInfo = + #{offset VkImageCreateInfo, initialLayout} + type FieldIsArray "initialLayout" VkImageCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkImageCreateInfo, initialLayout} + +instance CanReadField "initialLayout" VkImageCreateInfo where + {-# INLINE getField #-} + getField = vkInitialLayout + + {-# INLINE readField #-} + readField = readVkInitialLayout + +instance CanWriteField "initialLayout" VkImageCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkInitialLayout + +instance Show VkImageCreateInfo where + showsPrec d x + = showString "VkImageCreateInfo {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkFlags = " . + showsPrec d (vkFlags x) . + showString ", " . + showString "vkImageType = " . + showsPrec d (vkImageType x) . + showString ", " . + showString "vkFormat = " . + showsPrec d (vkFormat x) . + showString ", " . + showString "vkExtent = " . + showsPrec d (vkExtent x) . + showString ", " . + showString "vkMipLevels = " . + showsPrec d (vkMipLevels x) . + showString ", " . + showString "vkArrayLayers = " . + showsPrec d (vkArrayLayers x) . + showString ", " . + showString "vkSamples = " . + showsPrec d (vkSamples x) . + showString ", " . + showString "vkTiling = " . + showsPrec d (vkTiling x) . + showString ", " . + showString "vkUsage = " . + showsPrec d (vkUsage x) + . + showString ", " . + showString + "vkSharingMode = " + . + showsPrec d + (vkSharingMode + x) + . + showString ", " + . + showString + "vkQueueFamilyIndexCount = " + . + showsPrec d + (vkQueueFamilyIndexCount + x) + . + showString + ", " + . + showString + "vkPQueueFamilyIndices = " + . + showsPrec + d + (vkPQueueFamilyIndices + x) + . + showString + ", " + . + showString + "vkInitialLayout = " + . + showsPrec + d + (vkInitialLayout + x) + . + showChar + '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkImageFormatListCreateInfoKHR.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkImageFormatListCreateInfoKHR.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkImageFormatListCreateInfoKHR.hsc @@ -0,0 +1,298 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkImageFormatListCreateInfoKHR + (VkImageFormatListCreateInfoKHR(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkFormat (VkFormat) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Struct.VkImageCreateInfo (VkImageCreateInfo) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkImageFormatListCreateInfoKHR { +-- > VkStructureType sType; +-- > const void* pNext; +-- > uint32_t viewFormatCount; +-- > const VkFormat* pViewFormats; +-- > } VkImageFormatListCreateInfoKHR; +-- +-- +data VkImageFormatListCreateInfoKHR = VkImageFormatListCreateInfoKHR## Addr## + ByteArray## + +instance Eq VkImageFormatListCreateInfoKHR where + (VkImageFormatListCreateInfoKHR## a _) == + x@(VkImageFormatListCreateInfoKHR## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkImageFormatListCreateInfoKHR where + (VkImageFormatListCreateInfoKHR## a _) `compare` + x@(VkImageFormatListCreateInfoKHR## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkImageFormatListCreateInfoKHR where + sizeOf ~_ = #{size VkImageFormatListCreateInfoKHR} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkImageFormatListCreateInfoKHR} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkImageFormatListCreateInfoKHR where + unsafeAddr (VkImageFormatListCreateInfoKHR## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkImageFormatListCreateInfoKHR## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkImageFormatListCreateInfoKHR## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkImageFormatListCreateInfoKHR where + type StructFields VkImageFormatListCreateInfoKHR = + '["sType", "pNext", "viewFormatCount", "pViewFormats"] -- ' closing tick for hsc2hs + type CUnionType VkImageFormatListCreateInfoKHR = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkImageFormatListCreateInfoKHR = 'False -- ' closing tick for hsc2hs + type StructExtends VkImageFormatListCreateInfoKHR = + '[VkImageCreateInfo] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkImageFormatListCreateInfoKHR where + type VkSTypeMType VkImageFormatListCreateInfoKHR = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImageFormatListCreateInfoKHR, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkImageFormatListCreateInfoKHR, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkImageFormatListCreateInfoKHR, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkImageFormatListCreateInfoKHR, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkImageFormatListCreateInfoKHR where + type FieldType "sType" VkImageFormatListCreateInfoKHR = + VkStructureType + type FieldOptional "sType" VkImageFormatListCreateInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkImageFormatListCreateInfoKHR = + #{offset VkImageFormatListCreateInfoKHR, sType} + type FieldIsArray "sType" VkImageFormatListCreateInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkImageFormatListCreateInfoKHR, sType} + +instance CanReadField "sType" VkImageFormatListCreateInfoKHR where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkImageFormatListCreateInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkImageFormatListCreateInfoKHR where + type VkPNextMType VkImageFormatListCreateInfoKHR = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImageFormatListCreateInfoKHR, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkImageFormatListCreateInfoKHR, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkImageFormatListCreateInfoKHR, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkImageFormatListCreateInfoKHR, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkImageFormatListCreateInfoKHR where + type FieldType "pNext" VkImageFormatListCreateInfoKHR = Ptr Void + type FieldOptional "pNext" VkImageFormatListCreateInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkImageFormatListCreateInfoKHR = + #{offset VkImageFormatListCreateInfoKHR, pNext} + type FieldIsArray "pNext" VkImageFormatListCreateInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkImageFormatListCreateInfoKHR, pNext} + +instance CanReadField "pNext" VkImageFormatListCreateInfoKHR where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkImageFormatListCreateInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkViewFormatCount VkImageFormatListCreateInfoKHR where + type VkViewFormatCountMType VkImageFormatListCreateInfoKHR = Word32 + + {-# NOINLINE vkViewFormatCount #-} + vkViewFormatCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImageFormatListCreateInfoKHR, viewFormatCount}) + + {-# INLINE vkViewFormatCountByteOffset #-} + vkViewFormatCountByteOffset ~_ + = #{offset VkImageFormatListCreateInfoKHR, viewFormatCount} + + {-# INLINE readVkViewFormatCount #-} + readVkViewFormatCount p + = peekByteOff p #{offset VkImageFormatListCreateInfoKHR, viewFormatCount} + + {-# INLINE writeVkViewFormatCount #-} + writeVkViewFormatCount p + = pokeByteOff p #{offset VkImageFormatListCreateInfoKHR, viewFormatCount} + +instance {-# OVERLAPPING #-} + HasField "viewFormatCount" VkImageFormatListCreateInfoKHR where + type FieldType "viewFormatCount" VkImageFormatListCreateInfoKHR = + Word32 + type FieldOptional "viewFormatCount" VkImageFormatListCreateInfoKHR + = 'True -- ' closing tick for hsc2hs + type FieldOffset "viewFormatCount" VkImageFormatListCreateInfoKHR = + #{offset VkImageFormatListCreateInfoKHR, viewFormatCount} + type FieldIsArray "viewFormatCount" VkImageFormatListCreateInfoKHR + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkImageFormatListCreateInfoKHR, viewFormatCount} + +instance CanReadField "viewFormatCount" + VkImageFormatListCreateInfoKHR + where + {-# INLINE getField #-} + getField = vkViewFormatCount + + {-# INLINE readField #-} + readField = readVkViewFormatCount + +instance CanWriteField "viewFormatCount" + VkImageFormatListCreateInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkViewFormatCount + +instance {-# OVERLAPPING #-} + HasVkPViewFormats VkImageFormatListCreateInfoKHR where + type VkPViewFormatsMType VkImageFormatListCreateInfoKHR = + Ptr VkFormat + + {-# NOINLINE vkPViewFormats #-} + vkPViewFormats x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImageFormatListCreateInfoKHR, pViewFormats}) + + {-# INLINE vkPViewFormatsByteOffset #-} + vkPViewFormatsByteOffset ~_ + = #{offset VkImageFormatListCreateInfoKHR, pViewFormats} + + {-# INLINE readVkPViewFormats #-} + readVkPViewFormats p + = peekByteOff p #{offset VkImageFormatListCreateInfoKHR, pViewFormats} + + {-# INLINE writeVkPViewFormats #-} + writeVkPViewFormats p + = pokeByteOff p #{offset VkImageFormatListCreateInfoKHR, pViewFormats} + +instance {-# OVERLAPPING #-} + HasField "pViewFormats" VkImageFormatListCreateInfoKHR where + type FieldType "pViewFormats" VkImageFormatListCreateInfoKHR = + Ptr VkFormat + type FieldOptional "pViewFormats" VkImageFormatListCreateInfoKHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "pViewFormats" VkImageFormatListCreateInfoKHR = + #{offset VkImageFormatListCreateInfoKHR, pViewFormats} + type FieldIsArray "pViewFormats" VkImageFormatListCreateInfoKHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkImageFormatListCreateInfoKHR, pViewFormats} + +instance CanReadField "pViewFormats" VkImageFormatListCreateInfoKHR + where + {-# INLINE getField #-} + getField = vkPViewFormats + + {-# INLINE readField #-} + readField = readVkPViewFormats + +instance CanWriteField "pViewFormats" + VkImageFormatListCreateInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkPViewFormats + +instance Show VkImageFormatListCreateInfoKHR where + showsPrec d x + = showString "VkImageFormatListCreateInfoKHR {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkViewFormatCount = " . + showsPrec d (vkViewFormatCount x) . + showString ", " . + showString "vkPViewFormats = " . + showsPrec d (vkPViewFormats x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkImageFormatProperties.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkImageFormatProperties.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkImageFormatProperties.hsc @@ -0,0 +1,318 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkImageFormatProperties + (VkImageFormatProperties(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.BaseTypes (VkDeviceSize) +import Graphics.Vulkan.Types.Enum.VkSampleCountFlags (VkSampleCountFlags) +import Graphics.Vulkan.Types.Struct.VkExtent3D (VkExtent3D) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkImageFormatProperties { +-- > VkExtent3D maxExtent; +-- > uint32_t maxMipLevels; +-- > uint32_t maxArrayLayers; +-- > VkSampleCountFlags sampleCounts; +-- > VkDeviceSize maxResourceSize; +-- > } VkImageFormatProperties; +-- +-- +data VkImageFormatProperties = VkImageFormatProperties## Addr## + ByteArray## + +instance Eq VkImageFormatProperties where + (VkImageFormatProperties## a _) == x@(VkImageFormatProperties## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkImageFormatProperties where + (VkImageFormatProperties## a _) `compare` + x@(VkImageFormatProperties## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkImageFormatProperties where + sizeOf ~_ = #{size VkImageFormatProperties} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkImageFormatProperties} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkImageFormatProperties where + unsafeAddr (VkImageFormatProperties## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkImageFormatProperties## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkImageFormatProperties## (plusAddr## (byteArrayContents## b) off) b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkImageFormatProperties where + type StructFields VkImageFormatProperties = + '["maxExtent", "maxMipLevels", "maxArrayLayers", "sampleCounts", -- ' closing tick for hsc2hs + "maxResourceSize"] + type CUnionType VkImageFormatProperties = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkImageFormatProperties = 'True -- ' closing tick for hsc2hs + type StructExtends VkImageFormatProperties = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkMaxExtent VkImageFormatProperties + where + type VkMaxExtentMType VkImageFormatProperties = VkExtent3D + + {-# NOINLINE vkMaxExtent #-} + vkMaxExtent x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImageFormatProperties, maxExtent}) + + {-# INLINE vkMaxExtentByteOffset #-} + vkMaxExtentByteOffset ~_ + = #{offset VkImageFormatProperties, maxExtent} + + {-# INLINE readVkMaxExtent #-} + readVkMaxExtent p + = peekByteOff p #{offset VkImageFormatProperties, maxExtent} + + {-# INLINE writeVkMaxExtent #-} + writeVkMaxExtent p + = pokeByteOff p #{offset VkImageFormatProperties, maxExtent} + +instance {-# OVERLAPPING #-} + HasField "maxExtent" VkImageFormatProperties where + type FieldType "maxExtent" VkImageFormatProperties = VkExtent3D + type FieldOptional "maxExtent" VkImageFormatProperties = 'False -- ' closing tick for hsc2hs + type FieldOffset "maxExtent" VkImageFormatProperties = + #{offset VkImageFormatProperties, maxExtent} + type FieldIsArray "maxExtent" VkImageFormatProperties = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkImageFormatProperties, maxExtent} + +instance CanReadField "maxExtent" VkImageFormatProperties where + {-# INLINE getField #-} + getField = vkMaxExtent + + {-# INLINE readField #-} + readField = readVkMaxExtent + +instance {-# OVERLAPPING #-} + HasVkMaxMipLevels VkImageFormatProperties where + type VkMaxMipLevelsMType VkImageFormatProperties = Word32 + + {-# NOINLINE vkMaxMipLevels #-} + vkMaxMipLevels x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImageFormatProperties, maxMipLevels}) + + {-# INLINE vkMaxMipLevelsByteOffset #-} + vkMaxMipLevelsByteOffset ~_ + = #{offset VkImageFormatProperties, maxMipLevels} + + {-# INLINE readVkMaxMipLevels #-} + readVkMaxMipLevels p + = peekByteOff p #{offset VkImageFormatProperties, maxMipLevels} + + {-# INLINE writeVkMaxMipLevels #-} + writeVkMaxMipLevels p + = pokeByteOff p #{offset VkImageFormatProperties, maxMipLevels} + +instance {-# OVERLAPPING #-} + HasField "maxMipLevels" VkImageFormatProperties where + type FieldType "maxMipLevels" VkImageFormatProperties = Word32 + type FieldOptional "maxMipLevels" VkImageFormatProperties = 'False -- ' closing tick for hsc2hs + type FieldOffset "maxMipLevels" VkImageFormatProperties = + #{offset VkImageFormatProperties, maxMipLevels} + type FieldIsArray "maxMipLevels" VkImageFormatProperties = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkImageFormatProperties, maxMipLevels} + +instance CanReadField "maxMipLevels" VkImageFormatProperties where + {-# INLINE getField #-} + getField = vkMaxMipLevels + + {-# INLINE readField #-} + readField = readVkMaxMipLevels + +instance {-# OVERLAPPING #-} + HasVkMaxArrayLayers VkImageFormatProperties where + type VkMaxArrayLayersMType VkImageFormatProperties = Word32 + + {-# NOINLINE vkMaxArrayLayers #-} + vkMaxArrayLayers x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImageFormatProperties, maxArrayLayers}) + + {-# INLINE vkMaxArrayLayersByteOffset #-} + vkMaxArrayLayersByteOffset ~_ + = #{offset VkImageFormatProperties, maxArrayLayers} + + {-# INLINE readVkMaxArrayLayers #-} + readVkMaxArrayLayers p + = peekByteOff p #{offset VkImageFormatProperties, maxArrayLayers} + + {-# INLINE writeVkMaxArrayLayers #-} + writeVkMaxArrayLayers p + = pokeByteOff p #{offset VkImageFormatProperties, maxArrayLayers} + +instance {-# OVERLAPPING #-} + HasField "maxArrayLayers" VkImageFormatProperties where + type FieldType "maxArrayLayers" VkImageFormatProperties = Word32 + type FieldOptional "maxArrayLayers" VkImageFormatProperties = + 'False -- ' closing tick for hsc2hs + type FieldOffset "maxArrayLayers" VkImageFormatProperties = + #{offset VkImageFormatProperties, maxArrayLayers} + type FieldIsArray "maxArrayLayers" VkImageFormatProperties = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkImageFormatProperties, maxArrayLayers} + +instance CanReadField "maxArrayLayers" VkImageFormatProperties + where + {-# INLINE getField #-} + getField = vkMaxArrayLayers + + {-# INLINE readField #-} + readField = readVkMaxArrayLayers + +instance {-# OVERLAPPING #-} + HasVkSampleCounts VkImageFormatProperties where + type VkSampleCountsMType VkImageFormatProperties = + VkSampleCountFlags + + {-# NOINLINE vkSampleCounts #-} + vkSampleCounts x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImageFormatProperties, sampleCounts}) + + {-# INLINE vkSampleCountsByteOffset #-} + vkSampleCountsByteOffset ~_ + = #{offset VkImageFormatProperties, sampleCounts} + + {-# INLINE readVkSampleCounts #-} + readVkSampleCounts p + = peekByteOff p #{offset VkImageFormatProperties, sampleCounts} + + {-# INLINE writeVkSampleCounts #-} + writeVkSampleCounts p + = pokeByteOff p #{offset VkImageFormatProperties, sampleCounts} + +instance {-# OVERLAPPING #-} + HasField "sampleCounts" VkImageFormatProperties where + type FieldType "sampleCounts" VkImageFormatProperties = + VkSampleCountFlags + type FieldOptional "sampleCounts" VkImageFormatProperties = 'True -- ' closing tick for hsc2hs + type FieldOffset "sampleCounts" VkImageFormatProperties = + #{offset VkImageFormatProperties, sampleCounts} + type FieldIsArray "sampleCounts" VkImageFormatProperties = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkImageFormatProperties, sampleCounts} + +instance CanReadField "sampleCounts" VkImageFormatProperties where + {-# INLINE getField #-} + getField = vkSampleCounts + + {-# INLINE readField #-} + readField = readVkSampleCounts + +instance {-# OVERLAPPING #-} + HasVkMaxResourceSize VkImageFormatProperties where + type VkMaxResourceSizeMType VkImageFormatProperties = VkDeviceSize + + {-# NOINLINE vkMaxResourceSize #-} + vkMaxResourceSize x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImageFormatProperties, maxResourceSize}) + + {-# INLINE vkMaxResourceSizeByteOffset #-} + vkMaxResourceSizeByteOffset ~_ + = #{offset VkImageFormatProperties, maxResourceSize} + + {-# INLINE readVkMaxResourceSize #-} + readVkMaxResourceSize p + = peekByteOff p #{offset VkImageFormatProperties, maxResourceSize} + + {-# INLINE writeVkMaxResourceSize #-} + writeVkMaxResourceSize p + = pokeByteOff p #{offset VkImageFormatProperties, maxResourceSize} + +instance {-# OVERLAPPING #-} + HasField "maxResourceSize" VkImageFormatProperties where + type FieldType "maxResourceSize" VkImageFormatProperties = + VkDeviceSize + type FieldOptional "maxResourceSize" VkImageFormatProperties = + 'False -- ' closing tick for hsc2hs + type FieldOffset "maxResourceSize" VkImageFormatProperties = + #{offset VkImageFormatProperties, maxResourceSize} + type FieldIsArray "maxResourceSize" VkImageFormatProperties = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkImageFormatProperties, maxResourceSize} + +instance CanReadField "maxResourceSize" VkImageFormatProperties + where + {-# INLINE getField #-} + getField = vkMaxResourceSize + + {-# INLINE readField #-} + readField = readVkMaxResourceSize + +instance Show VkImageFormatProperties where + showsPrec d x + = showString "VkImageFormatProperties {" . + showString "vkMaxExtent = " . + showsPrec d (vkMaxExtent x) . + showString ", " . + showString "vkMaxMipLevels = " . + showsPrec d (vkMaxMipLevels x) . + showString ", " . + showString "vkMaxArrayLayers = " . + showsPrec d (vkMaxArrayLayers x) . + showString ", " . + showString "vkSampleCounts = " . + showsPrec d (vkSampleCounts x) . + showString ", " . + showString "vkMaxResourceSize = " . + showsPrec d (vkMaxResourceSize x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkImageFormatProperties2KHR.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkImageFormatProperties2KHR.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkImageFormatProperties2KHR.hsc @@ -0,0 +1,228 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkImageFormatProperties2KHR + (VkImageFormatProperties2KHR(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Struct.VkImageFormatProperties (VkImageFormatProperties) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkImageFormatProperties2KHR { +-- > VkStructureType sType; +-- > void* pNext; +-- > VkImageFormatProperties imageFormatProperties; +-- > } VkImageFormatProperties2KHR; +-- +-- +data VkImageFormatProperties2KHR = VkImageFormatProperties2KHR## Addr## + ByteArray## + +instance Eq VkImageFormatProperties2KHR where + (VkImageFormatProperties2KHR## a _) == + x@(VkImageFormatProperties2KHR## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkImageFormatProperties2KHR where + (VkImageFormatProperties2KHR## a _) `compare` + x@(VkImageFormatProperties2KHR## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkImageFormatProperties2KHR where + sizeOf ~_ = #{size VkImageFormatProperties2KHR} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkImageFormatProperties2KHR} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkImageFormatProperties2KHR where + unsafeAddr (VkImageFormatProperties2KHR## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkImageFormatProperties2KHR## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkImageFormatProperties2KHR## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkImageFormatProperties2KHR where + type StructFields VkImageFormatProperties2KHR = + '["sType", "pNext", "imageFormatProperties"] -- ' closing tick for hsc2hs + type CUnionType VkImageFormatProperties2KHR = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkImageFormatProperties2KHR = 'True -- ' closing tick for hsc2hs + type StructExtends VkImageFormatProperties2KHR = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkSType VkImageFormatProperties2KHR + where + type VkSTypeMType VkImageFormatProperties2KHR = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImageFormatProperties2KHR, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkImageFormatProperties2KHR, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkImageFormatProperties2KHR, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkImageFormatProperties2KHR, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkImageFormatProperties2KHR where + type FieldType "sType" VkImageFormatProperties2KHR = + VkStructureType + type FieldOptional "sType" VkImageFormatProperties2KHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkImageFormatProperties2KHR = + #{offset VkImageFormatProperties2KHR, sType} + type FieldIsArray "sType" VkImageFormatProperties2KHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkImageFormatProperties2KHR, sType} + +instance CanReadField "sType" VkImageFormatProperties2KHR where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance {-# OVERLAPPING #-} HasVkPNext VkImageFormatProperties2KHR + where + type VkPNextMType VkImageFormatProperties2KHR = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImageFormatProperties2KHR, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkImageFormatProperties2KHR, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkImageFormatProperties2KHR, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkImageFormatProperties2KHR, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkImageFormatProperties2KHR where + type FieldType "pNext" VkImageFormatProperties2KHR = Ptr Void + type FieldOptional "pNext" VkImageFormatProperties2KHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkImageFormatProperties2KHR = + #{offset VkImageFormatProperties2KHR, pNext} + type FieldIsArray "pNext" VkImageFormatProperties2KHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkImageFormatProperties2KHR, pNext} + +instance CanReadField "pNext" VkImageFormatProperties2KHR where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance {-# OVERLAPPING #-} + HasVkImageFormatProperties VkImageFormatProperties2KHR where + type VkImageFormatPropertiesMType VkImageFormatProperties2KHR = + VkImageFormatProperties + + {-# NOINLINE vkImageFormatProperties #-} + vkImageFormatProperties x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImageFormatProperties2KHR, imageFormatProperties}) + + {-# INLINE vkImageFormatPropertiesByteOffset #-} + vkImageFormatPropertiesByteOffset ~_ + = #{offset VkImageFormatProperties2KHR, imageFormatProperties} + + {-# INLINE readVkImageFormatProperties #-} + readVkImageFormatProperties p + = peekByteOff p #{offset VkImageFormatProperties2KHR, imageFormatProperties} + + {-# INLINE writeVkImageFormatProperties #-} + writeVkImageFormatProperties p + = pokeByteOff p #{offset VkImageFormatProperties2KHR, imageFormatProperties} + +instance {-# OVERLAPPING #-} + HasField "imageFormatProperties" VkImageFormatProperties2KHR where + type FieldType "imageFormatProperties" VkImageFormatProperties2KHR + = VkImageFormatProperties + type FieldOptional "imageFormatProperties" + VkImageFormatProperties2KHR + = 'False -- ' closing tick for hsc2hs + type FieldOffset "imageFormatProperties" + VkImageFormatProperties2KHR + = + #{offset VkImageFormatProperties2KHR, imageFormatProperties} + type FieldIsArray "imageFormatProperties" + VkImageFormatProperties2KHR + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkImageFormatProperties2KHR, imageFormatProperties} + +instance CanReadField "imageFormatProperties" + VkImageFormatProperties2KHR + where + {-# INLINE getField #-} + getField = vkImageFormatProperties + + {-# INLINE readField #-} + readField = readVkImageFormatProperties + +instance Show VkImageFormatProperties2KHR where + showsPrec d x + = showString "VkImageFormatProperties2KHR {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkImageFormatProperties = " . + showsPrec d (vkImageFormatProperties x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkImageMemoryBarrier.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkImageMemoryBarrier.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkImageMemoryBarrier.hsc @@ -0,0 +1,594 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkImageMemoryBarrier + (VkImageMemoryBarrier(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkAccessFlags (VkAccessFlags) +import Graphics.Vulkan.Types.Enum.VkImageLayout (VkImageLayout) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Handles (VkImage) +import Graphics.Vulkan.Types.Struct.VkImageSubresourceRange (VkImageSubresourceRange) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkImageMemoryBarrier { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkAccessFlags srcAccessMask; +-- > VkAccessFlags dstAccessMask; +-- > VkImageLayout oldLayout; +-- > VkImageLayout newLayout; +-- > uint32_t srcQueueFamilyIndex; +-- > uint32_t dstQueueFamilyIndex; +-- > VkImage image; +-- > VkImageSubresourceRange subresourceRange; +-- > } VkImageMemoryBarrier; +-- +-- +data VkImageMemoryBarrier = VkImageMemoryBarrier## Addr## ByteArray## + +instance Eq VkImageMemoryBarrier where + (VkImageMemoryBarrier## a _) == x@(VkImageMemoryBarrier## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkImageMemoryBarrier where + (VkImageMemoryBarrier## a _) `compare` x@(VkImageMemoryBarrier## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkImageMemoryBarrier where + sizeOf ~_ = #{size VkImageMemoryBarrier} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkImageMemoryBarrier} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkImageMemoryBarrier where + unsafeAddr (VkImageMemoryBarrier## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkImageMemoryBarrier## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkImageMemoryBarrier## (plusAddr## (byteArrayContents## b) off) b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkImageMemoryBarrier where + type StructFields VkImageMemoryBarrier = + '["sType", "pNext", "srcAccessMask", "dstAccessMask", "oldLayout", -- ' closing tick for hsc2hs + "newLayout", "srcQueueFamilyIndex", "dstQueueFamilyIndex", "image", + "subresourceRange"] + type CUnionType VkImageMemoryBarrier = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkImageMemoryBarrier = 'False -- ' closing tick for hsc2hs + type StructExtends VkImageMemoryBarrier = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkSType VkImageMemoryBarrier where + type VkSTypeMType VkImageMemoryBarrier = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImageMemoryBarrier, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkImageMemoryBarrier, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkImageMemoryBarrier, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkImageMemoryBarrier, sType} + +instance {-# OVERLAPPING #-} HasField "sType" VkImageMemoryBarrier + where + type FieldType "sType" VkImageMemoryBarrier = VkStructureType + type FieldOptional "sType" VkImageMemoryBarrier = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkImageMemoryBarrier = + #{offset VkImageMemoryBarrier, sType} + type FieldIsArray "sType" VkImageMemoryBarrier = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkImageMemoryBarrier, sType} + +instance CanReadField "sType" VkImageMemoryBarrier where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkImageMemoryBarrier where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} HasVkPNext VkImageMemoryBarrier where + type VkPNextMType VkImageMemoryBarrier = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImageMemoryBarrier, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkImageMemoryBarrier, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkImageMemoryBarrier, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkImageMemoryBarrier, pNext} + +instance {-# OVERLAPPING #-} HasField "pNext" VkImageMemoryBarrier + where + type FieldType "pNext" VkImageMemoryBarrier = Ptr Void + type FieldOptional "pNext" VkImageMemoryBarrier = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkImageMemoryBarrier = + #{offset VkImageMemoryBarrier, pNext} + type FieldIsArray "pNext" VkImageMemoryBarrier = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkImageMemoryBarrier, pNext} + +instance CanReadField "pNext" VkImageMemoryBarrier where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkImageMemoryBarrier where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkSrcAccessMask VkImageMemoryBarrier where + type VkSrcAccessMaskMType VkImageMemoryBarrier = VkAccessFlags + + {-# NOINLINE vkSrcAccessMask #-} + vkSrcAccessMask x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImageMemoryBarrier, srcAccessMask}) + + {-# INLINE vkSrcAccessMaskByteOffset #-} + vkSrcAccessMaskByteOffset ~_ + = #{offset VkImageMemoryBarrier, srcAccessMask} + + {-# INLINE readVkSrcAccessMask #-} + readVkSrcAccessMask p + = peekByteOff p #{offset VkImageMemoryBarrier, srcAccessMask} + + {-# INLINE writeVkSrcAccessMask #-} + writeVkSrcAccessMask p + = pokeByteOff p #{offset VkImageMemoryBarrier, srcAccessMask} + +instance {-# OVERLAPPING #-} + HasField "srcAccessMask" VkImageMemoryBarrier where + type FieldType "srcAccessMask" VkImageMemoryBarrier = VkAccessFlags + type FieldOptional "srcAccessMask" VkImageMemoryBarrier = 'True -- ' closing tick for hsc2hs + type FieldOffset "srcAccessMask" VkImageMemoryBarrier = + #{offset VkImageMemoryBarrier, srcAccessMask} + type FieldIsArray "srcAccessMask" VkImageMemoryBarrier = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkImageMemoryBarrier, srcAccessMask} + +instance CanReadField "srcAccessMask" VkImageMemoryBarrier where + {-# INLINE getField #-} + getField = vkSrcAccessMask + + {-# INLINE readField #-} + readField = readVkSrcAccessMask + +instance CanWriteField "srcAccessMask" VkImageMemoryBarrier where + {-# INLINE writeField #-} + writeField = writeVkSrcAccessMask + +instance {-# OVERLAPPING #-} + HasVkDstAccessMask VkImageMemoryBarrier where + type VkDstAccessMaskMType VkImageMemoryBarrier = VkAccessFlags + + {-# NOINLINE vkDstAccessMask #-} + vkDstAccessMask x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImageMemoryBarrier, dstAccessMask}) + + {-# INLINE vkDstAccessMaskByteOffset #-} + vkDstAccessMaskByteOffset ~_ + = #{offset VkImageMemoryBarrier, dstAccessMask} + + {-# INLINE readVkDstAccessMask #-} + readVkDstAccessMask p + = peekByteOff p #{offset VkImageMemoryBarrier, dstAccessMask} + + {-# INLINE writeVkDstAccessMask #-} + writeVkDstAccessMask p + = pokeByteOff p #{offset VkImageMemoryBarrier, dstAccessMask} + +instance {-# OVERLAPPING #-} + HasField "dstAccessMask" VkImageMemoryBarrier where + type FieldType "dstAccessMask" VkImageMemoryBarrier = VkAccessFlags + type FieldOptional "dstAccessMask" VkImageMemoryBarrier = 'True -- ' closing tick for hsc2hs + type FieldOffset "dstAccessMask" VkImageMemoryBarrier = + #{offset VkImageMemoryBarrier, dstAccessMask} + type FieldIsArray "dstAccessMask" VkImageMemoryBarrier = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkImageMemoryBarrier, dstAccessMask} + +instance CanReadField "dstAccessMask" VkImageMemoryBarrier where + {-# INLINE getField #-} + getField = vkDstAccessMask + + {-# INLINE readField #-} + readField = readVkDstAccessMask + +instance CanWriteField "dstAccessMask" VkImageMemoryBarrier where + {-# INLINE writeField #-} + writeField = writeVkDstAccessMask + +instance {-# OVERLAPPING #-} HasVkOldLayout VkImageMemoryBarrier + where + type VkOldLayoutMType VkImageMemoryBarrier = VkImageLayout + + {-# NOINLINE vkOldLayout #-} + vkOldLayout x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImageMemoryBarrier, oldLayout}) + + {-# INLINE vkOldLayoutByteOffset #-} + vkOldLayoutByteOffset ~_ + = #{offset VkImageMemoryBarrier, oldLayout} + + {-# INLINE readVkOldLayout #-} + readVkOldLayout p + = peekByteOff p #{offset VkImageMemoryBarrier, oldLayout} + + {-# INLINE writeVkOldLayout #-} + writeVkOldLayout p + = pokeByteOff p #{offset VkImageMemoryBarrier, oldLayout} + +instance {-# OVERLAPPING #-} + HasField "oldLayout" VkImageMemoryBarrier where + type FieldType "oldLayout" VkImageMemoryBarrier = VkImageLayout + type FieldOptional "oldLayout" VkImageMemoryBarrier = 'False -- ' closing tick for hsc2hs + type FieldOffset "oldLayout" VkImageMemoryBarrier = + #{offset VkImageMemoryBarrier, oldLayout} + type FieldIsArray "oldLayout" VkImageMemoryBarrier = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkImageMemoryBarrier, oldLayout} + +instance CanReadField "oldLayout" VkImageMemoryBarrier where + {-# INLINE getField #-} + getField = vkOldLayout + + {-# INLINE readField #-} + readField = readVkOldLayout + +instance CanWriteField "oldLayout" VkImageMemoryBarrier where + {-# INLINE writeField #-} + writeField = writeVkOldLayout + +instance {-# OVERLAPPING #-} HasVkNewLayout VkImageMemoryBarrier + where + type VkNewLayoutMType VkImageMemoryBarrier = VkImageLayout + + {-# NOINLINE vkNewLayout #-} + vkNewLayout x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImageMemoryBarrier, newLayout}) + + {-# INLINE vkNewLayoutByteOffset #-} + vkNewLayoutByteOffset ~_ + = #{offset VkImageMemoryBarrier, newLayout} + + {-# INLINE readVkNewLayout #-} + readVkNewLayout p + = peekByteOff p #{offset VkImageMemoryBarrier, newLayout} + + {-# INLINE writeVkNewLayout #-} + writeVkNewLayout p + = pokeByteOff p #{offset VkImageMemoryBarrier, newLayout} + +instance {-# OVERLAPPING #-} + HasField "newLayout" VkImageMemoryBarrier where + type FieldType "newLayout" VkImageMemoryBarrier = VkImageLayout + type FieldOptional "newLayout" VkImageMemoryBarrier = 'False -- ' closing tick for hsc2hs + type FieldOffset "newLayout" VkImageMemoryBarrier = + #{offset VkImageMemoryBarrier, newLayout} + type FieldIsArray "newLayout" VkImageMemoryBarrier = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkImageMemoryBarrier, newLayout} + +instance CanReadField "newLayout" VkImageMemoryBarrier where + {-# INLINE getField #-} + getField = vkNewLayout + + {-# INLINE readField #-} + readField = readVkNewLayout + +instance CanWriteField "newLayout" VkImageMemoryBarrier where + {-# INLINE writeField #-} + writeField = writeVkNewLayout + +instance {-# OVERLAPPING #-} + HasVkSrcQueueFamilyIndex VkImageMemoryBarrier where + type VkSrcQueueFamilyIndexMType VkImageMemoryBarrier = Word32 + + {-# NOINLINE vkSrcQueueFamilyIndex #-} + vkSrcQueueFamilyIndex x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImageMemoryBarrier, srcQueueFamilyIndex}) + + {-# INLINE vkSrcQueueFamilyIndexByteOffset #-} + vkSrcQueueFamilyIndexByteOffset ~_ + = #{offset VkImageMemoryBarrier, srcQueueFamilyIndex} + + {-# INLINE readVkSrcQueueFamilyIndex #-} + readVkSrcQueueFamilyIndex p + = peekByteOff p #{offset VkImageMemoryBarrier, srcQueueFamilyIndex} + + {-# INLINE writeVkSrcQueueFamilyIndex #-} + writeVkSrcQueueFamilyIndex p + = pokeByteOff p #{offset VkImageMemoryBarrier, srcQueueFamilyIndex} + +instance {-# OVERLAPPING #-} + HasField "srcQueueFamilyIndex" VkImageMemoryBarrier where + type FieldType "srcQueueFamilyIndex" VkImageMemoryBarrier = Word32 + type FieldOptional "srcQueueFamilyIndex" VkImageMemoryBarrier = + 'False -- ' closing tick for hsc2hs + type FieldOffset "srcQueueFamilyIndex" VkImageMemoryBarrier = + #{offset VkImageMemoryBarrier, srcQueueFamilyIndex} + type FieldIsArray "srcQueueFamilyIndex" VkImageMemoryBarrier = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkImageMemoryBarrier, srcQueueFamilyIndex} + +instance CanReadField "srcQueueFamilyIndex" VkImageMemoryBarrier + where + {-# INLINE getField #-} + getField = vkSrcQueueFamilyIndex + + {-# INLINE readField #-} + readField = readVkSrcQueueFamilyIndex + +instance CanWriteField "srcQueueFamilyIndex" VkImageMemoryBarrier + where + {-# INLINE writeField #-} + writeField = writeVkSrcQueueFamilyIndex + +instance {-# OVERLAPPING #-} + HasVkDstQueueFamilyIndex VkImageMemoryBarrier where + type VkDstQueueFamilyIndexMType VkImageMemoryBarrier = Word32 + + {-# NOINLINE vkDstQueueFamilyIndex #-} + vkDstQueueFamilyIndex x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImageMemoryBarrier, dstQueueFamilyIndex}) + + {-# INLINE vkDstQueueFamilyIndexByteOffset #-} + vkDstQueueFamilyIndexByteOffset ~_ + = #{offset VkImageMemoryBarrier, dstQueueFamilyIndex} + + {-# INLINE readVkDstQueueFamilyIndex #-} + readVkDstQueueFamilyIndex p + = peekByteOff p #{offset VkImageMemoryBarrier, dstQueueFamilyIndex} + + {-# INLINE writeVkDstQueueFamilyIndex #-} + writeVkDstQueueFamilyIndex p + = pokeByteOff p #{offset VkImageMemoryBarrier, dstQueueFamilyIndex} + +instance {-# OVERLAPPING #-} + HasField "dstQueueFamilyIndex" VkImageMemoryBarrier where + type FieldType "dstQueueFamilyIndex" VkImageMemoryBarrier = Word32 + type FieldOptional "dstQueueFamilyIndex" VkImageMemoryBarrier = + 'False -- ' closing tick for hsc2hs + type FieldOffset "dstQueueFamilyIndex" VkImageMemoryBarrier = + #{offset VkImageMemoryBarrier, dstQueueFamilyIndex} + type FieldIsArray "dstQueueFamilyIndex" VkImageMemoryBarrier = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkImageMemoryBarrier, dstQueueFamilyIndex} + +instance CanReadField "dstQueueFamilyIndex" VkImageMemoryBarrier + where + {-# INLINE getField #-} + getField = vkDstQueueFamilyIndex + + {-# INLINE readField #-} + readField = readVkDstQueueFamilyIndex + +instance CanWriteField "dstQueueFamilyIndex" VkImageMemoryBarrier + where + {-# INLINE writeField #-} + writeField = writeVkDstQueueFamilyIndex + +instance {-# OVERLAPPING #-} HasVkImage VkImageMemoryBarrier where + type VkImageMType VkImageMemoryBarrier = VkImage + + {-# NOINLINE vkImage #-} + vkImage x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImageMemoryBarrier, image}) + + {-# INLINE vkImageByteOffset #-} + vkImageByteOffset ~_ + = #{offset VkImageMemoryBarrier, image} + + {-# INLINE readVkImage #-} + readVkImage p + = peekByteOff p #{offset VkImageMemoryBarrier, image} + + {-# INLINE writeVkImage #-} + writeVkImage p + = pokeByteOff p #{offset VkImageMemoryBarrier, image} + +instance {-# OVERLAPPING #-} HasField "image" VkImageMemoryBarrier + where + type FieldType "image" VkImageMemoryBarrier = VkImage + type FieldOptional "image" VkImageMemoryBarrier = 'False -- ' closing tick for hsc2hs + type FieldOffset "image" VkImageMemoryBarrier = + #{offset VkImageMemoryBarrier, image} + type FieldIsArray "image" VkImageMemoryBarrier = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkImageMemoryBarrier, image} + +instance CanReadField "image" VkImageMemoryBarrier where + {-# INLINE getField #-} + getField = vkImage + + {-# INLINE readField #-} + readField = readVkImage + +instance CanWriteField "image" VkImageMemoryBarrier where + {-# INLINE writeField #-} + writeField = writeVkImage + +instance {-# OVERLAPPING #-} + HasVkSubresourceRange VkImageMemoryBarrier where + type VkSubresourceRangeMType VkImageMemoryBarrier = + VkImageSubresourceRange + + {-# NOINLINE vkSubresourceRange #-} + vkSubresourceRange x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImageMemoryBarrier, subresourceRange}) + + {-# INLINE vkSubresourceRangeByteOffset #-} + vkSubresourceRangeByteOffset ~_ + = #{offset VkImageMemoryBarrier, subresourceRange} + + {-# INLINE readVkSubresourceRange #-} + readVkSubresourceRange p + = peekByteOff p #{offset VkImageMemoryBarrier, subresourceRange} + + {-# INLINE writeVkSubresourceRange #-} + writeVkSubresourceRange p + = pokeByteOff p #{offset VkImageMemoryBarrier, subresourceRange} + +instance {-# OVERLAPPING #-} + HasField "subresourceRange" VkImageMemoryBarrier where + type FieldType "subresourceRange" VkImageMemoryBarrier = + VkImageSubresourceRange + type FieldOptional "subresourceRange" VkImageMemoryBarrier = 'False -- ' closing tick for hsc2hs + type FieldOffset "subresourceRange" VkImageMemoryBarrier = + #{offset VkImageMemoryBarrier, subresourceRange} + type FieldIsArray "subresourceRange" VkImageMemoryBarrier = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkImageMemoryBarrier, subresourceRange} + +instance CanReadField "subresourceRange" VkImageMemoryBarrier where + {-# INLINE getField #-} + getField = vkSubresourceRange + + {-# INLINE readField #-} + readField = readVkSubresourceRange + +instance CanWriteField "subresourceRange" VkImageMemoryBarrier + where + {-# INLINE writeField #-} + writeField = writeVkSubresourceRange + +instance Show VkImageMemoryBarrier where + showsPrec d x + = showString "VkImageMemoryBarrier {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkSrcAccessMask = " . + showsPrec d (vkSrcAccessMask x) . + showString ", " . + showString "vkDstAccessMask = " . + showsPrec d (vkDstAccessMask x) . + showString ", " . + showString "vkOldLayout = " . + showsPrec d (vkOldLayout x) . + showString ", " . + showString "vkNewLayout = " . + showsPrec d (vkNewLayout x) . + showString ", " . + showString "vkSrcQueueFamilyIndex = " . + showsPrec d (vkSrcQueueFamilyIndex x) . + showString ", " . + showString "vkDstQueueFamilyIndex = " . + showsPrec d (vkDstQueueFamilyIndex x) . + showString ", " . + showString "vkImage = " . + showsPrec d (vkImage x) . + showString ", " . + showString + "vkSubresourceRange = " + . + showsPrec d + (vkSubresourceRange x) + . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkImageMemoryRequirementsInfo2KHR.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkImageMemoryRequirementsInfo2KHR.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkImageMemoryRequirementsInfo2KHR.hsc @@ -0,0 +1,244 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkImageMemoryRequirementsInfo2KHR + (VkImageMemoryRequirementsInfo2KHR(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Handles (VkImage) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkImageMemoryRequirementsInfo2KHR { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkImage image; +-- > } VkImageMemoryRequirementsInfo2KHR; +-- +-- +data VkImageMemoryRequirementsInfo2KHR = VkImageMemoryRequirementsInfo2KHR## Addr## + ByteArray## + +instance Eq VkImageMemoryRequirementsInfo2KHR where + (VkImageMemoryRequirementsInfo2KHR## a _) == + x@(VkImageMemoryRequirementsInfo2KHR## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkImageMemoryRequirementsInfo2KHR where + (VkImageMemoryRequirementsInfo2KHR## a _) `compare` + x@(VkImageMemoryRequirementsInfo2KHR## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkImageMemoryRequirementsInfo2KHR where + sizeOf ~_ = #{size VkImageMemoryRequirementsInfo2KHR} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkImageMemoryRequirementsInfo2KHR} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkImageMemoryRequirementsInfo2KHR where + unsafeAddr (VkImageMemoryRequirementsInfo2KHR## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkImageMemoryRequirementsInfo2KHR## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkImageMemoryRequirementsInfo2KHR## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkImageMemoryRequirementsInfo2KHR where + type StructFields VkImageMemoryRequirementsInfo2KHR = + '["sType", "pNext", "image"] -- ' closing tick for hsc2hs + type CUnionType VkImageMemoryRequirementsInfo2KHR = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkImageMemoryRequirementsInfo2KHR = 'False -- ' closing tick for hsc2hs + type StructExtends VkImageMemoryRequirementsInfo2KHR = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkImageMemoryRequirementsInfo2KHR where + type VkSTypeMType VkImageMemoryRequirementsInfo2KHR = + VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImageMemoryRequirementsInfo2KHR, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkImageMemoryRequirementsInfo2KHR, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkImageMemoryRequirementsInfo2KHR, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkImageMemoryRequirementsInfo2KHR, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkImageMemoryRequirementsInfo2KHR where + type FieldType "sType" VkImageMemoryRequirementsInfo2KHR = + VkStructureType + type FieldOptional "sType" VkImageMemoryRequirementsInfo2KHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkImageMemoryRequirementsInfo2KHR = + #{offset VkImageMemoryRequirementsInfo2KHR, sType} + type FieldIsArray "sType" VkImageMemoryRequirementsInfo2KHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkImageMemoryRequirementsInfo2KHR, sType} + +instance CanReadField "sType" VkImageMemoryRequirementsInfo2KHR + where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkImageMemoryRequirementsInfo2KHR + where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkImageMemoryRequirementsInfo2KHR where + type VkPNextMType VkImageMemoryRequirementsInfo2KHR = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImageMemoryRequirementsInfo2KHR, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkImageMemoryRequirementsInfo2KHR, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkImageMemoryRequirementsInfo2KHR, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkImageMemoryRequirementsInfo2KHR, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkImageMemoryRequirementsInfo2KHR where + type FieldType "pNext" VkImageMemoryRequirementsInfo2KHR = Ptr Void + type FieldOptional "pNext" VkImageMemoryRequirementsInfo2KHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkImageMemoryRequirementsInfo2KHR = + #{offset VkImageMemoryRequirementsInfo2KHR, pNext} + type FieldIsArray "pNext" VkImageMemoryRequirementsInfo2KHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkImageMemoryRequirementsInfo2KHR, pNext} + +instance CanReadField "pNext" VkImageMemoryRequirementsInfo2KHR + where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkImageMemoryRequirementsInfo2KHR + where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkImage VkImageMemoryRequirementsInfo2KHR where + type VkImageMType VkImageMemoryRequirementsInfo2KHR = VkImage + + {-# NOINLINE vkImage #-} + vkImage x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImageMemoryRequirementsInfo2KHR, image}) + + {-# INLINE vkImageByteOffset #-} + vkImageByteOffset ~_ + = #{offset VkImageMemoryRequirementsInfo2KHR, image} + + {-# INLINE readVkImage #-} + readVkImage p + = peekByteOff p #{offset VkImageMemoryRequirementsInfo2KHR, image} + + {-# INLINE writeVkImage #-} + writeVkImage p + = pokeByteOff p #{offset VkImageMemoryRequirementsInfo2KHR, image} + +instance {-# OVERLAPPING #-} + HasField "image" VkImageMemoryRequirementsInfo2KHR where + type FieldType "image" VkImageMemoryRequirementsInfo2KHR = VkImage + type FieldOptional "image" VkImageMemoryRequirementsInfo2KHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "image" VkImageMemoryRequirementsInfo2KHR = + #{offset VkImageMemoryRequirementsInfo2KHR, image} + type FieldIsArray "image" VkImageMemoryRequirementsInfo2KHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkImageMemoryRequirementsInfo2KHR, image} + +instance CanReadField "image" VkImageMemoryRequirementsInfo2KHR + where + {-# INLINE getField #-} + getField = vkImage + + {-# INLINE readField #-} + readField = readVkImage + +instance CanWriteField "image" VkImageMemoryRequirementsInfo2KHR + where + {-# INLINE writeField #-} + writeField = writeVkImage + +instance Show VkImageMemoryRequirementsInfo2KHR where + showsPrec d x + = showString "VkImageMemoryRequirementsInfo2KHR {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkImage = " . showsPrec d (vkImage x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkImagePlaneMemoryRequirementsInfoKHR.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkImagePlaneMemoryRequirementsInfoKHR.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkImagePlaneMemoryRequirementsInfoKHR.hsc @@ -0,0 +1,260 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkImagePlaneMemoryRequirementsInfoKHR + (VkImagePlaneMemoryRequirementsInfoKHR(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkImageAspectFlags (VkImageAspectFlagBits) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Struct.VkImageMemoryRequirementsInfo2KHR (VkImageMemoryRequirementsInfo2KHR) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkImagePlaneMemoryRequirementsInfoKHR { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkImageAspectFlagBits planeAspect; +-- > } VkImagePlaneMemoryRequirementsInfoKHR; +-- +-- +data VkImagePlaneMemoryRequirementsInfoKHR = VkImagePlaneMemoryRequirementsInfoKHR## Addr## + ByteArray## + +instance Eq VkImagePlaneMemoryRequirementsInfoKHR where + (VkImagePlaneMemoryRequirementsInfoKHR## a _) == + x@(VkImagePlaneMemoryRequirementsInfoKHR## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkImagePlaneMemoryRequirementsInfoKHR where + (VkImagePlaneMemoryRequirementsInfoKHR## a _) `compare` + x@(VkImagePlaneMemoryRequirementsInfoKHR## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkImagePlaneMemoryRequirementsInfoKHR where + sizeOf ~_ + = #{size VkImagePlaneMemoryRequirementsInfoKHR} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkImagePlaneMemoryRequirementsInfoKHR} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkImagePlaneMemoryRequirementsInfoKHR + where + unsafeAddr (VkImagePlaneMemoryRequirementsInfoKHR## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkImagePlaneMemoryRequirementsInfoKHR## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkImagePlaneMemoryRequirementsInfoKHR## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkImagePlaneMemoryRequirementsInfoKHR where + type StructFields VkImagePlaneMemoryRequirementsInfoKHR = + '["sType", "pNext", "planeAspect"] -- ' closing tick for hsc2hs + type CUnionType VkImagePlaneMemoryRequirementsInfoKHR = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkImagePlaneMemoryRequirementsInfoKHR = 'False -- ' closing tick for hsc2hs + type StructExtends VkImagePlaneMemoryRequirementsInfoKHR = + '[VkImageMemoryRequirementsInfo2KHR] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkImagePlaneMemoryRequirementsInfoKHR where + type VkSTypeMType VkImagePlaneMemoryRequirementsInfoKHR = + VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImagePlaneMemoryRequirementsInfoKHR, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkImagePlaneMemoryRequirementsInfoKHR, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkImagePlaneMemoryRequirementsInfoKHR, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkImagePlaneMemoryRequirementsInfoKHR, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkImagePlaneMemoryRequirementsInfoKHR where + type FieldType "sType" VkImagePlaneMemoryRequirementsInfoKHR = + VkStructureType + type FieldOptional "sType" VkImagePlaneMemoryRequirementsInfoKHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkImagePlaneMemoryRequirementsInfoKHR = + #{offset VkImagePlaneMemoryRequirementsInfoKHR, sType} + type FieldIsArray "sType" VkImagePlaneMemoryRequirementsInfoKHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkImagePlaneMemoryRequirementsInfoKHR, sType} + +instance CanReadField "sType" VkImagePlaneMemoryRequirementsInfoKHR + where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" + VkImagePlaneMemoryRequirementsInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkImagePlaneMemoryRequirementsInfoKHR where + type VkPNextMType VkImagePlaneMemoryRequirementsInfoKHR = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImagePlaneMemoryRequirementsInfoKHR, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkImagePlaneMemoryRequirementsInfoKHR, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkImagePlaneMemoryRequirementsInfoKHR, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkImagePlaneMemoryRequirementsInfoKHR, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkImagePlaneMemoryRequirementsInfoKHR where + type FieldType "pNext" VkImagePlaneMemoryRequirementsInfoKHR = + Ptr Void + type FieldOptional "pNext" VkImagePlaneMemoryRequirementsInfoKHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkImagePlaneMemoryRequirementsInfoKHR = + #{offset VkImagePlaneMemoryRequirementsInfoKHR, pNext} + type FieldIsArray "pNext" VkImagePlaneMemoryRequirementsInfoKHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkImagePlaneMemoryRequirementsInfoKHR, pNext} + +instance CanReadField "pNext" VkImagePlaneMemoryRequirementsInfoKHR + where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" + VkImagePlaneMemoryRequirementsInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkPlaneAspect VkImagePlaneMemoryRequirementsInfoKHR where + type VkPlaneAspectMType VkImagePlaneMemoryRequirementsInfoKHR = + VkImageAspectFlagBits + + {-# NOINLINE vkPlaneAspect #-} + vkPlaneAspect x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImagePlaneMemoryRequirementsInfoKHR, planeAspect}) + + {-# INLINE vkPlaneAspectByteOffset #-} + vkPlaneAspectByteOffset ~_ + = #{offset VkImagePlaneMemoryRequirementsInfoKHR, planeAspect} + + {-# INLINE readVkPlaneAspect #-} + readVkPlaneAspect p + = peekByteOff p #{offset VkImagePlaneMemoryRequirementsInfoKHR, planeAspect} + + {-# INLINE writeVkPlaneAspect #-} + writeVkPlaneAspect p + = pokeByteOff p #{offset VkImagePlaneMemoryRequirementsInfoKHR, planeAspect} + +instance {-# OVERLAPPING #-} + HasField "planeAspect" VkImagePlaneMemoryRequirementsInfoKHR where + type FieldType "planeAspect" VkImagePlaneMemoryRequirementsInfoKHR + = VkImageAspectFlagBits + type FieldOptional "planeAspect" + VkImagePlaneMemoryRequirementsInfoKHR + = 'False -- ' closing tick for hsc2hs + type FieldOffset "planeAspect" + VkImagePlaneMemoryRequirementsInfoKHR + = + #{offset VkImagePlaneMemoryRequirementsInfoKHR, planeAspect} + type FieldIsArray "planeAspect" + VkImagePlaneMemoryRequirementsInfoKHR + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkImagePlaneMemoryRequirementsInfoKHR, planeAspect} + +instance CanReadField "planeAspect" + VkImagePlaneMemoryRequirementsInfoKHR + where + {-# INLINE getField #-} + getField = vkPlaneAspect + + {-# INLINE readField #-} + readField = readVkPlaneAspect + +instance CanWriteField "planeAspect" + VkImagePlaneMemoryRequirementsInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkPlaneAspect + +instance Show VkImagePlaneMemoryRequirementsInfoKHR where + showsPrec d x + = showString "VkImagePlaneMemoryRequirementsInfoKHR {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkPlaneAspect = " . + showsPrec d (vkPlaneAspect x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkImageResolve.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkImageResolve.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkImageResolve.hsc @@ -0,0 +1,324 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkImageResolve + (VkImageResolve(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Struct.VkExtent3D (VkExtent3D) +import Graphics.Vulkan.Types.Struct.VkImageSubresourceLayers (VkImageSubresourceLayers) +import Graphics.Vulkan.Types.Struct.VkOffset3D (VkOffset3D) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkImageResolve { +-- > VkImageSubresourceLayers srcSubresource; +-- > VkOffset3D srcOffset; +-- > VkImageSubresourceLayers dstSubresource; +-- > VkOffset3D dstOffset; +-- > VkExtent3D extent; +-- > } VkImageResolve; +-- +-- +data VkImageResolve = VkImageResolve## Addr## ByteArray## + +instance Eq VkImageResolve where + (VkImageResolve## a _) == x@(VkImageResolve## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkImageResolve where + (VkImageResolve## a _) `compare` x@(VkImageResolve## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkImageResolve where + sizeOf ~_ = #{size VkImageResolve} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkImageResolve} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkImageResolve where + unsafeAddr (VkImageResolve## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkImageResolve## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkImageResolve## (plusAddr## (byteArrayContents## b) off) b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkImageResolve where + type StructFields VkImageResolve = + '["srcSubresource", "srcOffset", "dstSubresource", "dstOffset", -- ' closing tick for hsc2hs + "extent"] + type CUnionType VkImageResolve = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkImageResolve = 'False -- ' closing tick for hsc2hs + type StructExtends VkImageResolve = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkSrcSubresource VkImageResolve + where + type VkSrcSubresourceMType VkImageResolve = + VkImageSubresourceLayers + + {-# NOINLINE vkSrcSubresource #-} + vkSrcSubresource x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImageResolve, srcSubresource}) + + {-# INLINE vkSrcSubresourceByteOffset #-} + vkSrcSubresourceByteOffset ~_ + = #{offset VkImageResolve, srcSubresource} + + {-# INLINE readVkSrcSubresource #-} + readVkSrcSubresource p + = peekByteOff p #{offset VkImageResolve, srcSubresource} + + {-# INLINE writeVkSrcSubresource #-} + writeVkSrcSubresource p + = pokeByteOff p #{offset VkImageResolve, srcSubresource} + +instance {-# OVERLAPPING #-} + HasField "srcSubresource" VkImageResolve where + type FieldType "srcSubresource" VkImageResolve = + VkImageSubresourceLayers + type FieldOptional "srcSubresource" VkImageResolve = 'False -- ' closing tick for hsc2hs + type FieldOffset "srcSubresource" VkImageResolve = + #{offset VkImageResolve, srcSubresource} + type FieldIsArray "srcSubresource" VkImageResolve = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkImageResolve, srcSubresource} + +instance CanReadField "srcSubresource" VkImageResolve where + {-# INLINE getField #-} + getField = vkSrcSubresource + + {-# INLINE readField #-} + readField = readVkSrcSubresource + +instance CanWriteField "srcSubresource" VkImageResolve where + {-# INLINE writeField #-} + writeField = writeVkSrcSubresource + +instance {-# OVERLAPPING #-} HasVkSrcOffset VkImageResolve where + type VkSrcOffsetMType VkImageResolve = VkOffset3D + + {-# NOINLINE vkSrcOffset #-} + vkSrcOffset x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImageResolve, srcOffset}) + + {-# INLINE vkSrcOffsetByteOffset #-} + vkSrcOffsetByteOffset ~_ + = #{offset VkImageResolve, srcOffset} + + {-# INLINE readVkSrcOffset #-} + readVkSrcOffset p + = peekByteOff p #{offset VkImageResolve, srcOffset} + + {-# INLINE writeVkSrcOffset #-} + writeVkSrcOffset p + = pokeByteOff p #{offset VkImageResolve, srcOffset} + +instance {-# OVERLAPPING #-} HasField "srcOffset" VkImageResolve + where + type FieldType "srcOffset" VkImageResolve = VkOffset3D + type FieldOptional "srcOffset" VkImageResolve = 'False -- ' closing tick for hsc2hs + type FieldOffset "srcOffset" VkImageResolve = + #{offset VkImageResolve, srcOffset} + type FieldIsArray "srcOffset" VkImageResolve = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkImageResolve, srcOffset} + +instance CanReadField "srcOffset" VkImageResolve where + {-# INLINE getField #-} + getField = vkSrcOffset + + {-# INLINE readField #-} + readField = readVkSrcOffset + +instance CanWriteField "srcOffset" VkImageResolve where + {-# INLINE writeField #-} + writeField = writeVkSrcOffset + +instance {-# OVERLAPPING #-} HasVkDstSubresource VkImageResolve + where + type VkDstSubresourceMType VkImageResolve = + VkImageSubresourceLayers + + {-# NOINLINE vkDstSubresource #-} + vkDstSubresource x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImageResolve, dstSubresource}) + + {-# INLINE vkDstSubresourceByteOffset #-} + vkDstSubresourceByteOffset ~_ + = #{offset VkImageResolve, dstSubresource} + + {-# INLINE readVkDstSubresource #-} + readVkDstSubresource p + = peekByteOff p #{offset VkImageResolve, dstSubresource} + + {-# INLINE writeVkDstSubresource #-} + writeVkDstSubresource p + = pokeByteOff p #{offset VkImageResolve, dstSubresource} + +instance {-# OVERLAPPING #-} + HasField "dstSubresource" VkImageResolve where + type FieldType "dstSubresource" VkImageResolve = + VkImageSubresourceLayers + type FieldOptional "dstSubresource" VkImageResolve = 'False -- ' closing tick for hsc2hs + type FieldOffset "dstSubresource" VkImageResolve = + #{offset VkImageResolve, dstSubresource} + type FieldIsArray "dstSubresource" VkImageResolve = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkImageResolve, dstSubresource} + +instance CanReadField "dstSubresource" VkImageResolve where + {-# INLINE getField #-} + getField = vkDstSubresource + + {-# INLINE readField #-} + readField = readVkDstSubresource + +instance CanWriteField "dstSubresource" VkImageResolve where + {-# INLINE writeField #-} + writeField = writeVkDstSubresource + +instance {-# OVERLAPPING #-} HasVkDstOffset VkImageResolve where + type VkDstOffsetMType VkImageResolve = VkOffset3D + + {-# NOINLINE vkDstOffset #-} + vkDstOffset x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImageResolve, dstOffset}) + + {-# INLINE vkDstOffsetByteOffset #-} + vkDstOffsetByteOffset ~_ + = #{offset VkImageResolve, dstOffset} + + {-# INLINE readVkDstOffset #-} + readVkDstOffset p + = peekByteOff p #{offset VkImageResolve, dstOffset} + + {-# INLINE writeVkDstOffset #-} + writeVkDstOffset p + = pokeByteOff p #{offset VkImageResolve, dstOffset} + +instance {-# OVERLAPPING #-} HasField "dstOffset" VkImageResolve + where + type FieldType "dstOffset" VkImageResolve = VkOffset3D + type FieldOptional "dstOffset" VkImageResolve = 'False -- ' closing tick for hsc2hs + type FieldOffset "dstOffset" VkImageResolve = + #{offset VkImageResolve, dstOffset} + type FieldIsArray "dstOffset" VkImageResolve = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkImageResolve, dstOffset} + +instance CanReadField "dstOffset" VkImageResolve where + {-# INLINE getField #-} + getField = vkDstOffset + + {-# INLINE readField #-} + readField = readVkDstOffset + +instance CanWriteField "dstOffset" VkImageResolve where + {-# INLINE writeField #-} + writeField = writeVkDstOffset + +instance {-# OVERLAPPING #-} HasVkExtent VkImageResolve where + type VkExtentMType VkImageResolve = VkExtent3D + + {-# NOINLINE vkExtent #-} + vkExtent x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImageResolve, extent}) + + {-# INLINE vkExtentByteOffset #-} + vkExtentByteOffset ~_ + = #{offset VkImageResolve, extent} + + {-# INLINE readVkExtent #-} + readVkExtent p + = peekByteOff p #{offset VkImageResolve, extent} + + {-# INLINE writeVkExtent #-} + writeVkExtent p + = pokeByteOff p #{offset VkImageResolve, extent} + +instance {-# OVERLAPPING #-} HasField "extent" VkImageResolve where + type FieldType "extent" VkImageResolve = VkExtent3D + type FieldOptional "extent" VkImageResolve = 'False -- ' closing tick for hsc2hs + type FieldOffset "extent" VkImageResolve = + #{offset VkImageResolve, extent} + type FieldIsArray "extent" VkImageResolve = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkImageResolve, extent} + +instance CanReadField "extent" VkImageResolve where + {-# INLINE getField #-} + getField = vkExtent + + {-# INLINE readField #-} + readField = readVkExtent + +instance CanWriteField "extent" VkImageResolve where + {-# INLINE writeField #-} + writeField = writeVkExtent + +instance Show VkImageResolve where + showsPrec d x + = showString "VkImageResolve {" . + showString "vkSrcSubresource = " . + showsPrec d (vkSrcSubresource x) . + showString ", " . + showString "vkSrcOffset = " . + showsPrec d (vkSrcOffset x) . + showString ", " . + showString "vkDstSubresource = " . + showsPrec d (vkDstSubresource x) . + showString ", " . + showString "vkDstOffset = " . + showsPrec d (vkDstOffset x) . + showString ", " . + showString "vkExtent = " . + showsPrec d (vkExtent x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkImageSparseMemoryRequirementsInfo2KHR.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkImageSparseMemoryRequirementsInfo2KHR.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkImageSparseMemoryRequirementsInfo2KHR.hsc @@ -0,0 +1,256 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkImageSparseMemoryRequirementsInfo2KHR + (VkImageSparseMemoryRequirementsInfo2KHR(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Handles (VkImage) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkImageSparseMemoryRequirementsInfo2KHR { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkImage image; +-- > } VkImageSparseMemoryRequirementsInfo2KHR; +-- +-- +data VkImageSparseMemoryRequirementsInfo2KHR = VkImageSparseMemoryRequirementsInfo2KHR## Addr## + ByteArray## + +instance Eq VkImageSparseMemoryRequirementsInfo2KHR where + (VkImageSparseMemoryRequirementsInfo2KHR## a _) == + x@(VkImageSparseMemoryRequirementsInfo2KHR## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkImageSparseMemoryRequirementsInfo2KHR where + (VkImageSparseMemoryRequirementsInfo2KHR## a _) `compare` + x@(VkImageSparseMemoryRequirementsInfo2KHR## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkImageSparseMemoryRequirementsInfo2KHR where + sizeOf ~_ + = #{size VkImageSparseMemoryRequirementsInfo2KHR} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkImageSparseMemoryRequirementsInfo2KHR} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkImageSparseMemoryRequirementsInfo2KHR + where + unsafeAddr (VkImageSparseMemoryRequirementsInfo2KHR## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkImageSparseMemoryRequirementsInfo2KHR## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkImageSparseMemoryRequirementsInfo2KHR## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkImageSparseMemoryRequirementsInfo2KHR + where + type StructFields VkImageSparseMemoryRequirementsInfo2KHR = + '["sType", "pNext", "image"] -- ' closing tick for hsc2hs + type CUnionType VkImageSparseMemoryRequirementsInfo2KHR = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkImageSparseMemoryRequirementsInfo2KHR = 'False -- ' closing tick for hsc2hs + type StructExtends VkImageSparseMemoryRequirementsInfo2KHR = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkImageSparseMemoryRequirementsInfo2KHR where + type VkSTypeMType VkImageSparseMemoryRequirementsInfo2KHR = + VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImageSparseMemoryRequirementsInfo2KHR, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkImageSparseMemoryRequirementsInfo2KHR, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkImageSparseMemoryRequirementsInfo2KHR, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkImageSparseMemoryRequirementsInfo2KHR, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkImageSparseMemoryRequirementsInfo2KHR where + type FieldType "sType" VkImageSparseMemoryRequirementsInfo2KHR = + VkStructureType + type FieldOptional "sType" VkImageSparseMemoryRequirementsInfo2KHR + = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkImageSparseMemoryRequirementsInfo2KHR = + #{offset VkImageSparseMemoryRequirementsInfo2KHR, sType} + type FieldIsArray "sType" VkImageSparseMemoryRequirementsInfo2KHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkImageSparseMemoryRequirementsInfo2KHR, sType} + +instance CanReadField "sType" + VkImageSparseMemoryRequirementsInfo2KHR + where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" + VkImageSparseMemoryRequirementsInfo2KHR + where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkImageSparseMemoryRequirementsInfo2KHR where + type VkPNextMType VkImageSparseMemoryRequirementsInfo2KHR = + Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImageSparseMemoryRequirementsInfo2KHR, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkImageSparseMemoryRequirementsInfo2KHR, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkImageSparseMemoryRequirementsInfo2KHR, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkImageSparseMemoryRequirementsInfo2KHR, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkImageSparseMemoryRequirementsInfo2KHR where + type FieldType "pNext" VkImageSparseMemoryRequirementsInfo2KHR = + Ptr Void + type FieldOptional "pNext" VkImageSparseMemoryRequirementsInfo2KHR + = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkImageSparseMemoryRequirementsInfo2KHR = + #{offset VkImageSparseMemoryRequirementsInfo2KHR, pNext} + type FieldIsArray "pNext" VkImageSparseMemoryRequirementsInfo2KHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkImageSparseMemoryRequirementsInfo2KHR, pNext} + +instance CanReadField "pNext" + VkImageSparseMemoryRequirementsInfo2KHR + where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" + VkImageSparseMemoryRequirementsInfo2KHR + where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkImage VkImageSparseMemoryRequirementsInfo2KHR where + type VkImageMType VkImageSparseMemoryRequirementsInfo2KHR = VkImage + + {-# NOINLINE vkImage #-} + vkImage x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImageSparseMemoryRequirementsInfo2KHR, image}) + + {-# INLINE vkImageByteOffset #-} + vkImageByteOffset ~_ + = #{offset VkImageSparseMemoryRequirementsInfo2KHR, image} + + {-# INLINE readVkImage #-} + readVkImage p + = peekByteOff p #{offset VkImageSparseMemoryRequirementsInfo2KHR, image} + + {-# INLINE writeVkImage #-} + writeVkImage p + = pokeByteOff p #{offset VkImageSparseMemoryRequirementsInfo2KHR, image} + +instance {-# OVERLAPPING #-} + HasField "image" VkImageSparseMemoryRequirementsInfo2KHR where + type FieldType "image" VkImageSparseMemoryRequirementsInfo2KHR = + VkImage + type FieldOptional "image" VkImageSparseMemoryRequirementsInfo2KHR + = 'False -- ' closing tick for hsc2hs + type FieldOffset "image" VkImageSparseMemoryRequirementsInfo2KHR = + #{offset VkImageSparseMemoryRequirementsInfo2KHR, image} + type FieldIsArray "image" VkImageSparseMemoryRequirementsInfo2KHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkImageSparseMemoryRequirementsInfo2KHR, image} + +instance CanReadField "image" + VkImageSparseMemoryRequirementsInfo2KHR + where + {-# INLINE getField #-} + getField = vkImage + + {-# INLINE readField #-} + readField = readVkImage + +instance CanWriteField "image" + VkImageSparseMemoryRequirementsInfo2KHR + where + {-# INLINE writeField #-} + writeField = writeVkImage + +instance Show VkImageSparseMemoryRequirementsInfo2KHR where + showsPrec d x + = showString "VkImageSparseMemoryRequirementsInfo2KHR {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkImage = " . showsPrec d (vkImage x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkImageSubresource.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkImageSubresource.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkImageSubresource.hsc @@ -0,0 +1,220 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkImageSubresource + (VkImageSubresource(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkImageAspectFlags (VkImageAspectFlags) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkImageSubresource { +-- > VkImageAspectFlags aspectMask; +-- > uint32_t mipLevel; +-- > uint32_t arrayLayer; +-- > } VkImageSubresource; +-- +-- +data VkImageSubresource = VkImageSubresource## Addr## ByteArray## + +instance Eq VkImageSubresource where + (VkImageSubresource## a _) == x@(VkImageSubresource## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkImageSubresource where + (VkImageSubresource## a _) `compare` x@(VkImageSubresource## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkImageSubresource where + sizeOf ~_ = #{size VkImageSubresource} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkImageSubresource} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkImageSubresource where + unsafeAddr (VkImageSubresource## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkImageSubresource## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkImageSubresource## (plusAddr## (byteArrayContents## b) off) b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkImageSubresource where + type StructFields VkImageSubresource = + '["aspectMask", "mipLevel", "arrayLayer"] -- ' closing tick for hsc2hs + type CUnionType VkImageSubresource = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkImageSubresource = 'False -- ' closing tick for hsc2hs + type StructExtends VkImageSubresource = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkAspectMask VkImageSubresource + where + type VkAspectMaskMType VkImageSubresource = VkImageAspectFlags + + {-# NOINLINE vkAspectMask #-} + vkAspectMask x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImageSubresource, aspectMask}) + + {-# INLINE vkAspectMaskByteOffset #-} + vkAspectMaskByteOffset ~_ + = #{offset VkImageSubresource, aspectMask} + + {-# INLINE readVkAspectMask #-} + readVkAspectMask p + = peekByteOff p #{offset VkImageSubresource, aspectMask} + + {-# INLINE writeVkAspectMask #-} + writeVkAspectMask p + = pokeByteOff p #{offset VkImageSubresource, aspectMask} + +instance {-# OVERLAPPING #-} + HasField "aspectMask" VkImageSubresource where + type FieldType "aspectMask" VkImageSubresource = VkImageAspectFlags + type FieldOptional "aspectMask" VkImageSubresource = 'False -- ' closing tick for hsc2hs + type FieldOffset "aspectMask" VkImageSubresource = + #{offset VkImageSubresource, aspectMask} + type FieldIsArray "aspectMask" VkImageSubresource = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkImageSubresource, aspectMask} + +instance CanReadField "aspectMask" VkImageSubresource where + {-# INLINE getField #-} + getField = vkAspectMask + + {-# INLINE readField #-} + readField = readVkAspectMask + +instance CanWriteField "aspectMask" VkImageSubresource where + {-# INLINE writeField #-} + writeField = writeVkAspectMask + +instance {-# OVERLAPPING #-} HasVkMipLevel VkImageSubresource where + type VkMipLevelMType VkImageSubresource = Word32 + + {-# NOINLINE vkMipLevel #-} + vkMipLevel x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImageSubresource, mipLevel}) + + {-# INLINE vkMipLevelByteOffset #-} + vkMipLevelByteOffset ~_ + = #{offset VkImageSubresource, mipLevel} + + {-# INLINE readVkMipLevel #-} + readVkMipLevel p + = peekByteOff p #{offset VkImageSubresource, mipLevel} + + {-# INLINE writeVkMipLevel #-} + writeVkMipLevel p + = pokeByteOff p #{offset VkImageSubresource, mipLevel} + +instance {-# OVERLAPPING #-} HasField "mipLevel" VkImageSubresource + where + type FieldType "mipLevel" VkImageSubresource = Word32 + type FieldOptional "mipLevel" VkImageSubresource = 'False -- ' closing tick for hsc2hs + type FieldOffset "mipLevel" VkImageSubresource = + #{offset VkImageSubresource, mipLevel} + type FieldIsArray "mipLevel" VkImageSubresource = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkImageSubresource, mipLevel} + +instance CanReadField "mipLevel" VkImageSubresource where + {-# INLINE getField #-} + getField = vkMipLevel + + {-# INLINE readField #-} + readField = readVkMipLevel + +instance CanWriteField "mipLevel" VkImageSubresource where + {-# INLINE writeField #-} + writeField = writeVkMipLevel + +instance {-# OVERLAPPING #-} HasVkArrayLayer VkImageSubresource + where + type VkArrayLayerMType VkImageSubresource = Word32 + + {-# NOINLINE vkArrayLayer #-} + vkArrayLayer x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImageSubresource, arrayLayer}) + + {-# INLINE vkArrayLayerByteOffset #-} + vkArrayLayerByteOffset ~_ + = #{offset VkImageSubresource, arrayLayer} + + {-# INLINE readVkArrayLayer #-} + readVkArrayLayer p + = peekByteOff p #{offset VkImageSubresource, arrayLayer} + + {-# INLINE writeVkArrayLayer #-} + writeVkArrayLayer p + = pokeByteOff p #{offset VkImageSubresource, arrayLayer} + +instance {-# OVERLAPPING #-} + HasField "arrayLayer" VkImageSubresource where + type FieldType "arrayLayer" VkImageSubresource = Word32 + type FieldOptional "arrayLayer" VkImageSubresource = 'False -- ' closing tick for hsc2hs + type FieldOffset "arrayLayer" VkImageSubresource = + #{offset VkImageSubresource, arrayLayer} + type FieldIsArray "arrayLayer" VkImageSubresource = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkImageSubresource, arrayLayer} + +instance CanReadField "arrayLayer" VkImageSubresource where + {-# INLINE getField #-} + getField = vkArrayLayer + + {-# INLINE readField #-} + readField = readVkArrayLayer + +instance CanWriteField "arrayLayer" VkImageSubresource where + {-# INLINE writeField #-} + writeField = writeVkArrayLayer + +instance Show VkImageSubresource where + showsPrec d x + = showString "VkImageSubresource {" . + showString "vkAspectMask = " . + showsPrec d (vkAspectMask x) . + showString ", " . + showString "vkMipLevel = " . + showsPrec d (vkMipLevel x) . + showString ", " . + showString "vkArrayLayer = " . + showsPrec d (vkArrayLayer x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkImageSubresourceLayers.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkImageSubresourceLayers.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkImageSubresourceLayers.hsc @@ -0,0 +1,283 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkImageSubresourceLayers + (VkImageSubresourceLayers(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkImageAspectFlags (VkImageAspectFlags) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkImageSubresourceLayers { +-- > VkImageAspectFlags aspectMask; +-- > uint32_t mipLevel; +-- > uint32_t baseArrayLayer; +-- > uint32_t layerCount; +-- > } VkImageSubresourceLayers; +-- +-- +data VkImageSubresourceLayers = VkImageSubresourceLayers## Addr## + ByteArray## + +instance Eq VkImageSubresourceLayers where + (VkImageSubresourceLayers## a _) == + x@(VkImageSubresourceLayers## b _) = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkImageSubresourceLayers where + (VkImageSubresourceLayers## a _) `compare` + x@(VkImageSubresourceLayers## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkImageSubresourceLayers where + sizeOf ~_ = #{size VkImageSubresourceLayers} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkImageSubresourceLayers} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkImageSubresourceLayers where + unsafeAddr (VkImageSubresourceLayers## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkImageSubresourceLayers## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkImageSubresourceLayers## (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkImageSubresourceLayers where + type StructFields VkImageSubresourceLayers = + '["aspectMask", "mipLevel", "baseArrayLayer", "layerCount"] -- ' closing tick for hsc2hs + type CUnionType VkImageSubresourceLayers = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkImageSubresourceLayers = 'False -- ' closing tick for hsc2hs + type StructExtends VkImageSubresourceLayers = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkAspectMask VkImageSubresourceLayers where + type VkAspectMaskMType VkImageSubresourceLayers = + VkImageAspectFlags + + {-# NOINLINE vkAspectMask #-} + vkAspectMask x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImageSubresourceLayers, aspectMask}) + + {-# INLINE vkAspectMaskByteOffset #-} + vkAspectMaskByteOffset ~_ + = #{offset VkImageSubresourceLayers, aspectMask} + + {-# INLINE readVkAspectMask #-} + readVkAspectMask p + = peekByteOff p #{offset VkImageSubresourceLayers, aspectMask} + + {-# INLINE writeVkAspectMask #-} + writeVkAspectMask p + = pokeByteOff p #{offset VkImageSubresourceLayers, aspectMask} + +instance {-# OVERLAPPING #-} + HasField "aspectMask" VkImageSubresourceLayers where + type FieldType "aspectMask" VkImageSubresourceLayers = + VkImageAspectFlags + type FieldOptional "aspectMask" VkImageSubresourceLayers = 'False -- ' closing tick for hsc2hs + type FieldOffset "aspectMask" VkImageSubresourceLayers = + #{offset VkImageSubresourceLayers, aspectMask} + type FieldIsArray "aspectMask" VkImageSubresourceLayers = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkImageSubresourceLayers, aspectMask} + +instance CanReadField "aspectMask" VkImageSubresourceLayers where + {-# INLINE getField #-} + getField = vkAspectMask + + {-# INLINE readField #-} + readField = readVkAspectMask + +instance CanWriteField "aspectMask" VkImageSubresourceLayers where + {-# INLINE writeField #-} + writeField = writeVkAspectMask + +instance {-# OVERLAPPING #-} HasVkMipLevel VkImageSubresourceLayers + where + type VkMipLevelMType VkImageSubresourceLayers = Word32 + + {-# NOINLINE vkMipLevel #-} + vkMipLevel x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImageSubresourceLayers, mipLevel}) + + {-# INLINE vkMipLevelByteOffset #-} + vkMipLevelByteOffset ~_ + = #{offset VkImageSubresourceLayers, mipLevel} + + {-# INLINE readVkMipLevel #-} + readVkMipLevel p + = peekByteOff p #{offset VkImageSubresourceLayers, mipLevel} + + {-# INLINE writeVkMipLevel #-} + writeVkMipLevel p + = pokeByteOff p #{offset VkImageSubresourceLayers, mipLevel} + +instance {-# OVERLAPPING #-} + HasField "mipLevel" VkImageSubresourceLayers where + type FieldType "mipLevel" VkImageSubresourceLayers = Word32 + type FieldOptional "mipLevel" VkImageSubresourceLayers = 'False -- ' closing tick for hsc2hs + type FieldOffset "mipLevel" VkImageSubresourceLayers = + #{offset VkImageSubresourceLayers, mipLevel} + type FieldIsArray "mipLevel" VkImageSubresourceLayers = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkImageSubresourceLayers, mipLevel} + +instance CanReadField "mipLevel" VkImageSubresourceLayers where + {-# INLINE getField #-} + getField = vkMipLevel + + {-# INLINE readField #-} + readField = readVkMipLevel + +instance CanWriteField "mipLevel" VkImageSubresourceLayers where + {-# INLINE writeField #-} + writeField = writeVkMipLevel + +instance {-# OVERLAPPING #-} + HasVkBaseArrayLayer VkImageSubresourceLayers where + type VkBaseArrayLayerMType VkImageSubresourceLayers = Word32 + + {-# NOINLINE vkBaseArrayLayer #-} + vkBaseArrayLayer x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImageSubresourceLayers, baseArrayLayer}) + + {-# INLINE vkBaseArrayLayerByteOffset #-} + vkBaseArrayLayerByteOffset ~_ + = #{offset VkImageSubresourceLayers, baseArrayLayer} + + {-# INLINE readVkBaseArrayLayer #-} + readVkBaseArrayLayer p + = peekByteOff p #{offset VkImageSubresourceLayers, baseArrayLayer} + + {-# INLINE writeVkBaseArrayLayer #-} + writeVkBaseArrayLayer p + = pokeByteOff p #{offset VkImageSubresourceLayers, baseArrayLayer} + +instance {-# OVERLAPPING #-} + HasField "baseArrayLayer" VkImageSubresourceLayers where + type FieldType "baseArrayLayer" VkImageSubresourceLayers = Word32 + type FieldOptional "baseArrayLayer" VkImageSubresourceLayers = + 'False -- ' closing tick for hsc2hs + type FieldOffset "baseArrayLayer" VkImageSubresourceLayers = + #{offset VkImageSubresourceLayers, baseArrayLayer} + type FieldIsArray "baseArrayLayer" VkImageSubresourceLayers = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkImageSubresourceLayers, baseArrayLayer} + +instance CanReadField "baseArrayLayer" VkImageSubresourceLayers + where + {-# INLINE getField #-} + getField = vkBaseArrayLayer + + {-# INLINE readField #-} + readField = readVkBaseArrayLayer + +instance CanWriteField "baseArrayLayer" VkImageSubresourceLayers + where + {-# INLINE writeField #-} + writeField = writeVkBaseArrayLayer + +instance {-# OVERLAPPING #-} + HasVkLayerCount VkImageSubresourceLayers where + type VkLayerCountMType VkImageSubresourceLayers = Word32 + + {-# NOINLINE vkLayerCount #-} + vkLayerCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImageSubresourceLayers, layerCount}) + + {-# INLINE vkLayerCountByteOffset #-} + vkLayerCountByteOffset ~_ + = #{offset VkImageSubresourceLayers, layerCount} + + {-# INLINE readVkLayerCount #-} + readVkLayerCount p + = peekByteOff p #{offset VkImageSubresourceLayers, layerCount} + + {-# INLINE writeVkLayerCount #-} + writeVkLayerCount p + = pokeByteOff p #{offset VkImageSubresourceLayers, layerCount} + +instance {-# OVERLAPPING #-} + HasField "layerCount" VkImageSubresourceLayers where + type FieldType "layerCount" VkImageSubresourceLayers = Word32 + type FieldOptional "layerCount" VkImageSubresourceLayers = 'False -- ' closing tick for hsc2hs + type FieldOffset "layerCount" VkImageSubresourceLayers = + #{offset VkImageSubresourceLayers, layerCount} + type FieldIsArray "layerCount" VkImageSubresourceLayers = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkImageSubresourceLayers, layerCount} + +instance CanReadField "layerCount" VkImageSubresourceLayers where + {-# INLINE getField #-} + getField = vkLayerCount + + {-# INLINE readField #-} + readField = readVkLayerCount + +instance CanWriteField "layerCount" VkImageSubresourceLayers where + {-# INLINE writeField #-} + writeField = writeVkLayerCount + +instance Show VkImageSubresourceLayers where + showsPrec d x + = showString "VkImageSubresourceLayers {" . + showString "vkAspectMask = " . + showsPrec d (vkAspectMask x) . + showString ", " . + showString "vkMipLevel = " . + showsPrec d (vkMipLevel x) . + showString ", " . + showString "vkBaseArrayLayer = " . + showsPrec d (vkBaseArrayLayer x) . + showString ", " . + showString "vkLayerCount = " . + showsPrec d (vkLayerCount x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkImageSubresourceRange.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkImageSubresourceRange.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkImageSubresourceRange.hsc @@ -0,0 +1,332 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkImageSubresourceRange + (VkImageSubresourceRange(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkImageAspectFlags (VkImageAspectFlags) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkImageSubresourceRange { +-- > VkImageAspectFlags aspectMask; +-- > uint32_t baseMipLevel; +-- > uint32_t levelCount; +-- > uint32_t baseArrayLayer; +-- > uint32_t layerCount; +-- > } VkImageSubresourceRange; +-- +-- +data VkImageSubresourceRange = VkImageSubresourceRange## Addr## + ByteArray## + +instance Eq VkImageSubresourceRange where + (VkImageSubresourceRange## a _) == x@(VkImageSubresourceRange## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkImageSubresourceRange where + (VkImageSubresourceRange## a _) `compare` + x@(VkImageSubresourceRange## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkImageSubresourceRange where + sizeOf ~_ = #{size VkImageSubresourceRange} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkImageSubresourceRange} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkImageSubresourceRange where + unsafeAddr (VkImageSubresourceRange## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkImageSubresourceRange## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkImageSubresourceRange## (plusAddr## (byteArrayContents## b) off) b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkImageSubresourceRange where + type StructFields VkImageSubresourceRange = + '["aspectMask", "baseMipLevel", "levelCount", "baseArrayLayer", -- ' closing tick for hsc2hs + "layerCount"] + type CUnionType VkImageSubresourceRange = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkImageSubresourceRange = 'False -- ' closing tick for hsc2hs + type StructExtends VkImageSubresourceRange = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkAspectMask VkImageSubresourceRange where + type VkAspectMaskMType VkImageSubresourceRange = VkImageAspectFlags + + {-# NOINLINE vkAspectMask #-} + vkAspectMask x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImageSubresourceRange, aspectMask}) + + {-# INLINE vkAspectMaskByteOffset #-} + vkAspectMaskByteOffset ~_ + = #{offset VkImageSubresourceRange, aspectMask} + + {-# INLINE readVkAspectMask #-} + readVkAspectMask p + = peekByteOff p #{offset VkImageSubresourceRange, aspectMask} + + {-# INLINE writeVkAspectMask #-} + writeVkAspectMask p + = pokeByteOff p #{offset VkImageSubresourceRange, aspectMask} + +instance {-# OVERLAPPING #-} + HasField "aspectMask" VkImageSubresourceRange where + type FieldType "aspectMask" VkImageSubresourceRange = + VkImageAspectFlags + type FieldOptional "aspectMask" VkImageSubresourceRange = 'False -- ' closing tick for hsc2hs + type FieldOffset "aspectMask" VkImageSubresourceRange = + #{offset VkImageSubresourceRange, aspectMask} + type FieldIsArray "aspectMask" VkImageSubresourceRange = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkImageSubresourceRange, aspectMask} + +instance CanReadField "aspectMask" VkImageSubresourceRange where + {-# INLINE getField #-} + getField = vkAspectMask + + {-# INLINE readField #-} + readField = readVkAspectMask + +instance CanWriteField "aspectMask" VkImageSubresourceRange where + {-# INLINE writeField #-} + writeField = writeVkAspectMask + +instance {-# OVERLAPPING #-} + HasVkBaseMipLevel VkImageSubresourceRange where + type VkBaseMipLevelMType VkImageSubresourceRange = Word32 + + {-# NOINLINE vkBaseMipLevel #-} + vkBaseMipLevel x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImageSubresourceRange, baseMipLevel}) + + {-# INLINE vkBaseMipLevelByteOffset #-} + vkBaseMipLevelByteOffset ~_ + = #{offset VkImageSubresourceRange, baseMipLevel} + + {-# INLINE readVkBaseMipLevel #-} + readVkBaseMipLevel p + = peekByteOff p #{offset VkImageSubresourceRange, baseMipLevel} + + {-# INLINE writeVkBaseMipLevel #-} + writeVkBaseMipLevel p + = pokeByteOff p #{offset VkImageSubresourceRange, baseMipLevel} + +instance {-# OVERLAPPING #-} + HasField "baseMipLevel" VkImageSubresourceRange where + type FieldType "baseMipLevel" VkImageSubresourceRange = Word32 + type FieldOptional "baseMipLevel" VkImageSubresourceRange = 'False -- ' closing tick for hsc2hs + type FieldOffset "baseMipLevel" VkImageSubresourceRange = + #{offset VkImageSubresourceRange, baseMipLevel} + type FieldIsArray "baseMipLevel" VkImageSubresourceRange = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkImageSubresourceRange, baseMipLevel} + +instance CanReadField "baseMipLevel" VkImageSubresourceRange where + {-# INLINE getField #-} + getField = vkBaseMipLevel + + {-# INLINE readField #-} + readField = readVkBaseMipLevel + +instance CanWriteField "baseMipLevel" VkImageSubresourceRange where + {-# INLINE writeField #-} + writeField = writeVkBaseMipLevel + +instance {-# OVERLAPPING #-} + HasVkLevelCount VkImageSubresourceRange where + type VkLevelCountMType VkImageSubresourceRange = Word32 + + {-# NOINLINE vkLevelCount #-} + vkLevelCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImageSubresourceRange, levelCount}) + + {-# INLINE vkLevelCountByteOffset #-} + vkLevelCountByteOffset ~_ + = #{offset VkImageSubresourceRange, levelCount} + + {-# INLINE readVkLevelCount #-} + readVkLevelCount p + = peekByteOff p #{offset VkImageSubresourceRange, levelCount} + + {-# INLINE writeVkLevelCount #-} + writeVkLevelCount p + = pokeByteOff p #{offset VkImageSubresourceRange, levelCount} + +instance {-# OVERLAPPING #-} + HasField "levelCount" VkImageSubresourceRange where + type FieldType "levelCount" VkImageSubresourceRange = Word32 + type FieldOptional "levelCount" VkImageSubresourceRange = 'False -- ' closing tick for hsc2hs + type FieldOffset "levelCount" VkImageSubresourceRange = + #{offset VkImageSubresourceRange, levelCount} + type FieldIsArray "levelCount" VkImageSubresourceRange = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkImageSubresourceRange, levelCount} + +instance CanReadField "levelCount" VkImageSubresourceRange where + {-# INLINE getField #-} + getField = vkLevelCount + + {-# INLINE readField #-} + readField = readVkLevelCount + +instance CanWriteField "levelCount" VkImageSubresourceRange where + {-# INLINE writeField #-} + writeField = writeVkLevelCount + +instance {-# OVERLAPPING #-} + HasVkBaseArrayLayer VkImageSubresourceRange where + type VkBaseArrayLayerMType VkImageSubresourceRange = Word32 + + {-# NOINLINE vkBaseArrayLayer #-} + vkBaseArrayLayer x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImageSubresourceRange, baseArrayLayer}) + + {-# INLINE vkBaseArrayLayerByteOffset #-} + vkBaseArrayLayerByteOffset ~_ + = #{offset VkImageSubresourceRange, baseArrayLayer} + + {-# INLINE readVkBaseArrayLayer #-} + readVkBaseArrayLayer p + = peekByteOff p #{offset VkImageSubresourceRange, baseArrayLayer} + + {-# INLINE writeVkBaseArrayLayer #-} + writeVkBaseArrayLayer p + = pokeByteOff p #{offset VkImageSubresourceRange, baseArrayLayer} + +instance {-# OVERLAPPING #-} + HasField "baseArrayLayer" VkImageSubresourceRange where + type FieldType "baseArrayLayer" VkImageSubresourceRange = Word32 + type FieldOptional "baseArrayLayer" VkImageSubresourceRange = + 'False -- ' closing tick for hsc2hs + type FieldOffset "baseArrayLayer" VkImageSubresourceRange = + #{offset VkImageSubresourceRange, baseArrayLayer} + type FieldIsArray "baseArrayLayer" VkImageSubresourceRange = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkImageSubresourceRange, baseArrayLayer} + +instance CanReadField "baseArrayLayer" VkImageSubresourceRange + where + {-# INLINE getField #-} + getField = vkBaseArrayLayer + + {-# INLINE readField #-} + readField = readVkBaseArrayLayer + +instance CanWriteField "baseArrayLayer" VkImageSubresourceRange + where + {-# INLINE writeField #-} + writeField = writeVkBaseArrayLayer + +instance {-# OVERLAPPING #-} + HasVkLayerCount VkImageSubresourceRange where + type VkLayerCountMType VkImageSubresourceRange = Word32 + + {-# NOINLINE vkLayerCount #-} + vkLayerCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImageSubresourceRange, layerCount}) + + {-# INLINE vkLayerCountByteOffset #-} + vkLayerCountByteOffset ~_ + = #{offset VkImageSubresourceRange, layerCount} + + {-# INLINE readVkLayerCount #-} + readVkLayerCount p + = peekByteOff p #{offset VkImageSubresourceRange, layerCount} + + {-# INLINE writeVkLayerCount #-} + writeVkLayerCount p + = pokeByteOff p #{offset VkImageSubresourceRange, layerCount} + +instance {-# OVERLAPPING #-} + HasField "layerCount" VkImageSubresourceRange where + type FieldType "layerCount" VkImageSubresourceRange = Word32 + type FieldOptional "layerCount" VkImageSubresourceRange = 'False -- ' closing tick for hsc2hs + type FieldOffset "layerCount" VkImageSubresourceRange = + #{offset VkImageSubresourceRange, layerCount} + type FieldIsArray "layerCount" VkImageSubresourceRange = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkImageSubresourceRange, layerCount} + +instance CanReadField "layerCount" VkImageSubresourceRange where + {-# INLINE getField #-} + getField = vkLayerCount + + {-# INLINE readField #-} + readField = readVkLayerCount + +instance CanWriteField "layerCount" VkImageSubresourceRange where + {-# INLINE writeField #-} + writeField = writeVkLayerCount + +instance Show VkImageSubresourceRange where + showsPrec d x + = showString "VkImageSubresourceRange {" . + showString "vkAspectMask = " . + showsPrec d (vkAspectMask x) . + showString ", " . + showString "vkBaseMipLevel = " . + showsPrec d (vkBaseMipLevel x) . + showString ", " . + showString "vkLevelCount = " . + showsPrec d (vkLevelCount x) . + showString ", " . + showString "vkBaseArrayLayer = " . + showsPrec d (vkBaseArrayLayer x) . + showString ", " . + showString "vkLayerCount = " . + showsPrec d (vkLayerCount x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkImageSwapchainCreateInfoKHX.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkImageSwapchainCreateInfoKHX.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkImageSwapchainCreateInfoKHX.hsc @@ -0,0 +1,239 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkImageSwapchainCreateInfoKHX + (VkImageSwapchainCreateInfoKHX(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Handles (VkSwapchainKHR) +import Graphics.Vulkan.Types.Struct.VkImageCreateInfo (VkImageCreateInfo) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkImageSwapchainCreateInfoKHX { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkSwapchainKHR swapchain; +-- > } VkImageSwapchainCreateInfoKHX; +-- +-- +data VkImageSwapchainCreateInfoKHX = VkImageSwapchainCreateInfoKHX## Addr## + ByteArray## + +instance Eq VkImageSwapchainCreateInfoKHX where + (VkImageSwapchainCreateInfoKHX## a _) == + x@(VkImageSwapchainCreateInfoKHX## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkImageSwapchainCreateInfoKHX where + (VkImageSwapchainCreateInfoKHX## a _) `compare` + x@(VkImageSwapchainCreateInfoKHX## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkImageSwapchainCreateInfoKHX where + sizeOf ~_ = #{size VkImageSwapchainCreateInfoKHX} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkImageSwapchainCreateInfoKHX} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkImageSwapchainCreateInfoKHX where + unsafeAddr (VkImageSwapchainCreateInfoKHX## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkImageSwapchainCreateInfoKHX## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkImageSwapchainCreateInfoKHX## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkImageSwapchainCreateInfoKHX where + type StructFields VkImageSwapchainCreateInfoKHX = + '["sType", "pNext", "swapchain"] -- ' closing tick for hsc2hs + type CUnionType VkImageSwapchainCreateInfoKHX = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkImageSwapchainCreateInfoKHX = 'False -- ' closing tick for hsc2hs + type StructExtends VkImageSwapchainCreateInfoKHX = + '[VkImageCreateInfo] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkImageSwapchainCreateInfoKHX where + type VkSTypeMType VkImageSwapchainCreateInfoKHX = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImageSwapchainCreateInfoKHX, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkImageSwapchainCreateInfoKHX, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkImageSwapchainCreateInfoKHX, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkImageSwapchainCreateInfoKHX, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkImageSwapchainCreateInfoKHX where + type FieldType "sType" VkImageSwapchainCreateInfoKHX = + VkStructureType + type FieldOptional "sType" VkImageSwapchainCreateInfoKHX = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkImageSwapchainCreateInfoKHX = + #{offset VkImageSwapchainCreateInfoKHX, sType} + type FieldIsArray "sType" VkImageSwapchainCreateInfoKHX = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkImageSwapchainCreateInfoKHX, sType} + +instance CanReadField "sType" VkImageSwapchainCreateInfoKHX where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkImageSwapchainCreateInfoKHX where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkImageSwapchainCreateInfoKHX where + type VkPNextMType VkImageSwapchainCreateInfoKHX = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImageSwapchainCreateInfoKHX, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkImageSwapchainCreateInfoKHX, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkImageSwapchainCreateInfoKHX, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkImageSwapchainCreateInfoKHX, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkImageSwapchainCreateInfoKHX where + type FieldType "pNext" VkImageSwapchainCreateInfoKHX = Ptr Void + type FieldOptional "pNext" VkImageSwapchainCreateInfoKHX = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkImageSwapchainCreateInfoKHX = + #{offset VkImageSwapchainCreateInfoKHX, pNext} + type FieldIsArray "pNext" VkImageSwapchainCreateInfoKHX = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkImageSwapchainCreateInfoKHX, pNext} + +instance CanReadField "pNext" VkImageSwapchainCreateInfoKHX where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkImageSwapchainCreateInfoKHX where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkSwapchain VkImageSwapchainCreateInfoKHX where + type VkSwapchainMType VkImageSwapchainCreateInfoKHX = + VkSwapchainKHR + + {-# NOINLINE vkSwapchain #-} + vkSwapchain x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImageSwapchainCreateInfoKHX, swapchain}) + + {-# INLINE vkSwapchainByteOffset #-} + vkSwapchainByteOffset ~_ + = #{offset VkImageSwapchainCreateInfoKHX, swapchain} + + {-# INLINE readVkSwapchain #-} + readVkSwapchain p + = peekByteOff p #{offset VkImageSwapchainCreateInfoKHX, swapchain} + + {-# INLINE writeVkSwapchain #-} + writeVkSwapchain p + = pokeByteOff p #{offset VkImageSwapchainCreateInfoKHX, swapchain} + +instance {-# OVERLAPPING #-} + HasField "swapchain" VkImageSwapchainCreateInfoKHX where + type FieldType "swapchain" VkImageSwapchainCreateInfoKHX = + VkSwapchainKHR + type FieldOptional "swapchain" VkImageSwapchainCreateInfoKHX = + 'True -- ' closing tick for hsc2hs + type FieldOffset "swapchain" VkImageSwapchainCreateInfoKHX = + #{offset VkImageSwapchainCreateInfoKHX, swapchain} + type FieldIsArray "swapchain" VkImageSwapchainCreateInfoKHX = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkImageSwapchainCreateInfoKHX, swapchain} + +instance CanReadField "swapchain" VkImageSwapchainCreateInfoKHX + where + {-# INLINE getField #-} + getField = vkSwapchain + + {-# INLINE readField #-} + readField = readVkSwapchain + +instance CanWriteField "swapchain" VkImageSwapchainCreateInfoKHX + where + {-# INLINE writeField #-} + writeField = writeVkSwapchain + +instance Show VkImageSwapchainCreateInfoKHX where + showsPrec d x + = showString "VkImageSwapchainCreateInfoKHX {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkSwapchain = " . + showsPrec d (vkSwapchain x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkImageViewCreateInfo.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkImageViewCreateInfo.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkImageViewCreateInfo.hsc @@ -0,0 +1,485 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkImageViewCreateInfo + (VkImageViewCreateInfo(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Bitmasks (VkImageViewCreateFlags) +import Graphics.Vulkan.Types.Enum.VkFormat (VkFormat) +import Graphics.Vulkan.Types.Enum.VkImageViewType (VkImageViewType) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Handles (VkImage) +import Graphics.Vulkan.Types.Struct.VkComponentMapping (VkComponentMapping) +import Graphics.Vulkan.Types.Struct.VkImageSubresourceRange (VkImageSubresourceRange) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkImageViewCreateInfo { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkImageViewCreateFlags flags; +-- > VkImage image; +-- > VkImageViewType viewType; +-- > VkFormat format; +-- > VkComponentMapping components; +-- > VkImageSubresourceRange subresourceRange; +-- > } VkImageViewCreateInfo; +-- +-- +data VkImageViewCreateInfo = VkImageViewCreateInfo## Addr## + ByteArray## + +instance Eq VkImageViewCreateInfo where + (VkImageViewCreateInfo## a _) == x@(VkImageViewCreateInfo## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkImageViewCreateInfo where + (VkImageViewCreateInfo## a _) `compare` + x@(VkImageViewCreateInfo## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkImageViewCreateInfo where + sizeOf ~_ = #{size VkImageViewCreateInfo} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkImageViewCreateInfo} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkImageViewCreateInfo where + unsafeAddr (VkImageViewCreateInfo## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkImageViewCreateInfo## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkImageViewCreateInfo## (plusAddr## (byteArrayContents## b) off) b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkImageViewCreateInfo where + type StructFields VkImageViewCreateInfo = + '["sType", "pNext", "flags", "image", "viewType", "format", -- ' closing tick for hsc2hs + "components", "subresourceRange"] + type CUnionType VkImageViewCreateInfo = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkImageViewCreateInfo = 'False -- ' closing tick for hsc2hs + type StructExtends VkImageViewCreateInfo = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkSType VkImageViewCreateInfo where + type VkSTypeMType VkImageViewCreateInfo = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImageViewCreateInfo, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkImageViewCreateInfo, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkImageViewCreateInfo, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkImageViewCreateInfo, sType} + +instance {-# OVERLAPPING #-} HasField "sType" VkImageViewCreateInfo + where + type FieldType "sType" VkImageViewCreateInfo = VkStructureType + type FieldOptional "sType" VkImageViewCreateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkImageViewCreateInfo = + #{offset VkImageViewCreateInfo, sType} + type FieldIsArray "sType" VkImageViewCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkImageViewCreateInfo, sType} + +instance CanReadField "sType" VkImageViewCreateInfo where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkImageViewCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} HasVkPNext VkImageViewCreateInfo where + type VkPNextMType VkImageViewCreateInfo = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImageViewCreateInfo, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkImageViewCreateInfo, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkImageViewCreateInfo, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkImageViewCreateInfo, pNext} + +instance {-# OVERLAPPING #-} HasField "pNext" VkImageViewCreateInfo + where + type FieldType "pNext" VkImageViewCreateInfo = Ptr Void + type FieldOptional "pNext" VkImageViewCreateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkImageViewCreateInfo = + #{offset VkImageViewCreateInfo, pNext} + type FieldIsArray "pNext" VkImageViewCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkImageViewCreateInfo, pNext} + +instance CanReadField "pNext" VkImageViewCreateInfo where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkImageViewCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} HasVkFlags VkImageViewCreateInfo where + type VkFlagsMType VkImageViewCreateInfo = VkImageViewCreateFlags + + {-# NOINLINE vkFlags #-} + vkFlags x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImageViewCreateInfo, flags}) + + {-# INLINE vkFlagsByteOffset #-} + vkFlagsByteOffset ~_ + = #{offset VkImageViewCreateInfo, flags} + + {-# INLINE readVkFlags #-} + readVkFlags p + = peekByteOff p #{offset VkImageViewCreateInfo, flags} + + {-# INLINE writeVkFlags #-} + writeVkFlags p + = pokeByteOff p #{offset VkImageViewCreateInfo, flags} + +instance {-# OVERLAPPING #-} HasField "flags" VkImageViewCreateInfo + where + type FieldType "flags" VkImageViewCreateInfo = + VkImageViewCreateFlags + type FieldOptional "flags" VkImageViewCreateInfo = 'True -- ' closing tick for hsc2hs + type FieldOffset "flags" VkImageViewCreateInfo = + #{offset VkImageViewCreateInfo, flags} + type FieldIsArray "flags" VkImageViewCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkImageViewCreateInfo, flags} + +instance CanReadField "flags" VkImageViewCreateInfo where + {-# INLINE getField #-} + getField = vkFlags + + {-# INLINE readField #-} + readField = readVkFlags + +instance CanWriteField "flags" VkImageViewCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkFlags + +instance {-# OVERLAPPING #-} HasVkImage VkImageViewCreateInfo where + type VkImageMType VkImageViewCreateInfo = VkImage + + {-# NOINLINE vkImage #-} + vkImage x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImageViewCreateInfo, image}) + + {-# INLINE vkImageByteOffset #-} + vkImageByteOffset ~_ + = #{offset VkImageViewCreateInfo, image} + + {-# INLINE readVkImage #-} + readVkImage p + = peekByteOff p #{offset VkImageViewCreateInfo, image} + + {-# INLINE writeVkImage #-} + writeVkImage p + = pokeByteOff p #{offset VkImageViewCreateInfo, image} + +instance {-# OVERLAPPING #-} HasField "image" VkImageViewCreateInfo + where + type FieldType "image" VkImageViewCreateInfo = VkImage + type FieldOptional "image" VkImageViewCreateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "image" VkImageViewCreateInfo = + #{offset VkImageViewCreateInfo, image} + type FieldIsArray "image" VkImageViewCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkImageViewCreateInfo, image} + +instance CanReadField "image" VkImageViewCreateInfo where + {-# INLINE getField #-} + getField = vkImage + + {-# INLINE readField #-} + readField = readVkImage + +instance CanWriteField "image" VkImageViewCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkImage + +instance {-# OVERLAPPING #-} HasVkViewType VkImageViewCreateInfo + where + type VkViewTypeMType VkImageViewCreateInfo = VkImageViewType + + {-# NOINLINE vkViewType #-} + vkViewType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImageViewCreateInfo, viewType}) + + {-# INLINE vkViewTypeByteOffset #-} + vkViewTypeByteOffset ~_ + = #{offset VkImageViewCreateInfo, viewType} + + {-# INLINE readVkViewType #-} + readVkViewType p + = peekByteOff p #{offset VkImageViewCreateInfo, viewType} + + {-# INLINE writeVkViewType #-} + writeVkViewType p + = pokeByteOff p #{offset VkImageViewCreateInfo, viewType} + +instance {-# OVERLAPPING #-} + HasField "viewType" VkImageViewCreateInfo where + type FieldType "viewType" VkImageViewCreateInfo = VkImageViewType + type FieldOptional "viewType" VkImageViewCreateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "viewType" VkImageViewCreateInfo = + #{offset VkImageViewCreateInfo, viewType} + type FieldIsArray "viewType" VkImageViewCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkImageViewCreateInfo, viewType} + +instance CanReadField "viewType" VkImageViewCreateInfo where + {-# INLINE getField #-} + getField = vkViewType + + {-# INLINE readField #-} + readField = readVkViewType + +instance CanWriteField "viewType" VkImageViewCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkViewType + +instance {-# OVERLAPPING #-} HasVkFormat VkImageViewCreateInfo + where + type VkFormatMType VkImageViewCreateInfo = VkFormat + + {-# NOINLINE vkFormat #-} + vkFormat x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImageViewCreateInfo, format}) + + {-# INLINE vkFormatByteOffset #-} + vkFormatByteOffset ~_ + = #{offset VkImageViewCreateInfo, format} + + {-# INLINE readVkFormat #-} + readVkFormat p + = peekByteOff p #{offset VkImageViewCreateInfo, format} + + {-# INLINE writeVkFormat #-} + writeVkFormat p + = pokeByteOff p #{offset VkImageViewCreateInfo, format} + +instance {-# OVERLAPPING #-} + HasField "format" VkImageViewCreateInfo where + type FieldType "format" VkImageViewCreateInfo = VkFormat + type FieldOptional "format" VkImageViewCreateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "format" VkImageViewCreateInfo = + #{offset VkImageViewCreateInfo, format} + type FieldIsArray "format" VkImageViewCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkImageViewCreateInfo, format} + +instance CanReadField "format" VkImageViewCreateInfo where + {-# INLINE getField #-} + getField = vkFormat + + {-# INLINE readField #-} + readField = readVkFormat + +instance CanWriteField "format" VkImageViewCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkFormat + +instance {-# OVERLAPPING #-} HasVkComponents VkImageViewCreateInfo + where + type VkComponentsMType VkImageViewCreateInfo = VkComponentMapping + + {-# NOINLINE vkComponents #-} + vkComponents x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImageViewCreateInfo, components}) + + {-# INLINE vkComponentsByteOffset #-} + vkComponentsByteOffset ~_ + = #{offset VkImageViewCreateInfo, components} + + {-# INLINE readVkComponents #-} + readVkComponents p + = peekByteOff p #{offset VkImageViewCreateInfo, components} + + {-# INLINE writeVkComponents #-} + writeVkComponents p + = pokeByteOff p #{offset VkImageViewCreateInfo, components} + +instance {-# OVERLAPPING #-} + HasField "components" VkImageViewCreateInfo where + type FieldType "components" VkImageViewCreateInfo = + VkComponentMapping + type FieldOptional "components" VkImageViewCreateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "components" VkImageViewCreateInfo = + #{offset VkImageViewCreateInfo, components} + type FieldIsArray "components" VkImageViewCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkImageViewCreateInfo, components} + +instance CanReadField "components" VkImageViewCreateInfo where + {-# INLINE getField #-} + getField = vkComponents + + {-# INLINE readField #-} + readField = readVkComponents + +instance CanWriteField "components" VkImageViewCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkComponents + +instance {-# OVERLAPPING #-} + HasVkSubresourceRange VkImageViewCreateInfo where + type VkSubresourceRangeMType VkImageViewCreateInfo = + VkImageSubresourceRange + + {-# NOINLINE vkSubresourceRange #-} + vkSubresourceRange x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImageViewCreateInfo, subresourceRange}) + + {-# INLINE vkSubresourceRangeByteOffset #-} + vkSubresourceRangeByteOffset ~_ + = #{offset VkImageViewCreateInfo, subresourceRange} + + {-# INLINE readVkSubresourceRange #-} + readVkSubresourceRange p + = peekByteOff p #{offset VkImageViewCreateInfo, subresourceRange} + + {-# INLINE writeVkSubresourceRange #-} + writeVkSubresourceRange p + = pokeByteOff p #{offset VkImageViewCreateInfo, subresourceRange} + +instance {-# OVERLAPPING #-} + HasField "subresourceRange" VkImageViewCreateInfo where + type FieldType "subresourceRange" VkImageViewCreateInfo = + VkImageSubresourceRange + type FieldOptional "subresourceRange" VkImageViewCreateInfo = + 'False -- ' closing tick for hsc2hs + type FieldOffset "subresourceRange" VkImageViewCreateInfo = + #{offset VkImageViewCreateInfo, subresourceRange} + type FieldIsArray "subresourceRange" VkImageViewCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkImageViewCreateInfo, subresourceRange} + +instance CanReadField "subresourceRange" VkImageViewCreateInfo + where + {-# INLINE getField #-} + getField = vkSubresourceRange + + {-# INLINE readField #-} + readField = readVkSubresourceRange + +instance CanWriteField "subresourceRange" VkImageViewCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkSubresourceRange + +instance Show VkImageViewCreateInfo where + showsPrec d x + = showString "VkImageViewCreateInfo {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkFlags = " . + showsPrec d (vkFlags x) . + showString ", " . + showString "vkImage = " . + showsPrec d (vkImage x) . + showString ", " . + showString "vkViewType = " . + showsPrec d (vkViewType x) . + showString ", " . + showString "vkFormat = " . + showsPrec d (vkFormat x) . + showString ", " . + showString "vkComponents = " . + showsPrec d (vkComponents x) . + showString ", " . + showString "vkSubresourceRange = " . + showsPrec d (vkSubresourceRange x) . + showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkImageViewUsageCreateInfoKHR.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkImageViewUsageCreateInfoKHR.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkImageViewUsageCreateInfoKHR.hsc @@ -0,0 +1,233 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkImageViewUsageCreateInfoKHR + (VkImageViewUsageCreateInfoKHR(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkImageUsageFlags (VkImageUsageFlags) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Struct.VkImageViewCreateInfo (VkImageViewCreateInfo) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkImageViewUsageCreateInfoKHR { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkImageUsageFlags usage; +-- > } VkImageViewUsageCreateInfoKHR; +-- +-- +data VkImageViewUsageCreateInfoKHR = VkImageViewUsageCreateInfoKHR## Addr## + ByteArray## + +instance Eq VkImageViewUsageCreateInfoKHR where + (VkImageViewUsageCreateInfoKHR## a _) == + x@(VkImageViewUsageCreateInfoKHR## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkImageViewUsageCreateInfoKHR where + (VkImageViewUsageCreateInfoKHR## a _) `compare` + x@(VkImageViewUsageCreateInfoKHR## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkImageViewUsageCreateInfoKHR where + sizeOf ~_ = #{size VkImageViewUsageCreateInfoKHR} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkImageViewUsageCreateInfoKHR} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkImageViewUsageCreateInfoKHR where + unsafeAddr (VkImageViewUsageCreateInfoKHR## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkImageViewUsageCreateInfoKHR## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkImageViewUsageCreateInfoKHR## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkImageViewUsageCreateInfoKHR where + type StructFields VkImageViewUsageCreateInfoKHR = + '["sType", "pNext", "usage"] -- ' closing tick for hsc2hs + type CUnionType VkImageViewUsageCreateInfoKHR = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkImageViewUsageCreateInfoKHR = 'False -- ' closing tick for hsc2hs + type StructExtends VkImageViewUsageCreateInfoKHR = + '[VkImageViewCreateInfo] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkImageViewUsageCreateInfoKHR where + type VkSTypeMType VkImageViewUsageCreateInfoKHR = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImageViewUsageCreateInfoKHR, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkImageViewUsageCreateInfoKHR, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkImageViewUsageCreateInfoKHR, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkImageViewUsageCreateInfoKHR, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkImageViewUsageCreateInfoKHR where + type FieldType "sType" VkImageViewUsageCreateInfoKHR = + VkStructureType + type FieldOptional "sType" VkImageViewUsageCreateInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkImageViewUsageCreateInfoKHR = + #{offset VkImageViewUsageCreateInfoKHR, sType} + type FieldIsArray "sType" VkImageViewUsageCreateInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkImageViewUsageCreateInfoKHR, sType} + +instance CanReadField "sType" VkImageViewUsageCreateInfoKHR where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkImageViewUsageCreateInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkImageViewUsageCreateInfoKHR where + type VkPNextMType VkImageViewUsageCreateInfoKHR = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImageViewUsageCreateInfoKHR, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkImageViewUsageCreateInfoKHR, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkImageViewUsageCreateInfoKHR, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkImageViewUsageCreateInfoKHR, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkImageViewUsageCreateInfoKHR where + type FieldType "pNext" VkImageViewUsageCreateInfoKHR = Ptr Void + type FieldOptional "pNext" VkImageViewUsageCreateInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkImageViewUsageCreateInfoKHR = + #{offset VkImageViewUsageCreateInfoKHR, pNext} + type FieldIsArray "pNext" VkImageViewUsageCreateInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkImageViewUsageCreateInfoKHR, pNext} + +instance CanReadField "pNext" VkImageViewUsageCreateInfoKHR where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkImageViewUsageCreateInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkUsage VkImageViewUsageCreateInfoKHR where + type VkUsageMType VkImageViewUsageCreateInfoKHR = VkImageUsageFlags + + {-# NOINLINE vkUsage #-} + vkUsage x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImageViewUsageCreateInfoKHR, usage}) + + {-# INLINE vkUsageByteOffset #-} + vkUsageByteOffset ~_ + = #{offset VkImageViewUsageCreateInfoKHR, usage} + + {-# INLINE readVkUsage #-} + readVkUsage p + = peekByteOff p #{offset VkImageViewUsageCreateInfoKHR, usage} + + {-# INLINE writeVkUsage #-} + writeVkUsage p + = pokeByteOff p #{offset VkImageViewUsageCreateInfoKHR, usage} + +instance {-# OVERLAPPING #-} + HasField "usage" VkImageViewUsageCreateInfoKHR where + type FieldType "usage" VkImageViewUsageCreateInfoKHR = + VkImageUsageFlags + type FieldOptional "usage" VkImageViewUsageCreateInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "usage" VkImageViewUsageCreateInfoKHR = + #{offset VkImageViewUsageCreateInfoKHR, usage} + type FieldIsArray "usage" VkImageViewUsageCreateInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkImageViewUsageCreateInfoKHR, usage} + +instance CanReadField "usage" VkImageViewUsageCreateInfoKHR where + {-# INLINE getField #-} + getField = vkUsage + + {-# INLINE readField #-} + readField = readVkUsage + +instance CanWriteField "usage" VkImageViewUsageCreateInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkUsage + +instance Show VkImageViewUsageCreateInfoKHR where + showsPrec d x + = showString "VkImageViewUsageCreateInfoKHR {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkUsage = " . showsPrec d (vkUsage x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkImportFenceFdInfoKHR.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkImportFenceFdInfoKHR.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkImportFenceFdInfoKHR.hsc @@ -0,0 +1,378 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkImportFenceFdInfoKHR + (VkImportFenceFdInfoKHR(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkExternalFenceHandleTypeFlagsKHR (VkExternalFenceHandleTypeFlagBitsKHR) +import Graphics.Vulkan.Types.Enum.VkFenceImportFlagsKHR (VkFenceImportFlagsKHR) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Handles (VkFence) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkImportFenceFdInfoKHR { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkFence fence; +-- > VkFenceImportFlagsKHR flags; +-- > VkExternalFenceHandleTypeFlagBitsKHR handleType; +-- > int fd; +-- > } VkImportFenceFdInfoKHR; +-- +-- +data VkImportFenceFdInfoKHR = VkImportFenceFdInfoKHR## Addr## + ByteArray## + +instance Eq VkImportFenceFdInfoKHR where + (VkImportFenceFdInfoKHR## a _) == x@(VkImportFenceFdInfoKHR## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkImportFenceFdInfoKHR where + (VkImportFenceFdInfoKHR## a _) `compare` + x@(VkImportFenceFdInfoKHR## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkImportFenceFdInfoKHR where + sizeOf ~_ = #{size VkImportFenceFdInfoKHR} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkImportFenceFdInfoKHR} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkImportFenceFdInfoKHR where + unsafeAddr (VkImportFenceFdInfoKHR## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkImportFenceFdInfoKHR## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkImportFenceFdInfoKHR## (plusAddr## (byteArrayContents## b) off) b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkImportFenceFdInfoKHR where + type StructFields VkImportFenceFdInfoKHR = + '["sType", "pNext", "fence", "flags", "handleType", "fd"] -- ' closing tick for hsc2hs + type CUnionType VkImportFenceFdInfoKHR = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkImportFenceFdInfoKHR = 'False -- ' closing tick for hsc2hs + type StructExtends VkImportFenceFdInfoKHR = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkSType VkImportFenceFdInfoKHR + where + type VkSTypeMType VkImportFenceFdInfoKHR = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImportFenceFdInfoKHR, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkImportFenceFdInfoKHR, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkImportFenceFdInfoKHR, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkImportFenceFdInfoKHR, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkImportFenceFdInfoKHR where + type FieldType "sType" VkImportFenceFdInfoKHR = VkStructureType + type FieldOptional "sType" VkImportFenceFdInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkImportFenceFdInfoKHR = + #{offset VkImportFenceFdInfoKHR, sType} + type FieldIsArray "sType" VkImportFenceFdInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkImportFenceFdInfoKHR, sType} + +instance CanReadField "sType" VkImportFenceFdInfoKHR where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkImportFenceFdInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} HasVkPNext VkImportFenceFdInfoKHR + where + type VkPNextMType VkImportFenceFdInfoKHR = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImportFenceFdInfoKHR, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkImportFenceFdInfoKHR, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkImportFenceFdInfoKHR, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkImportFenceFdInfoKHR, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkImportFenceFdInfoKHR where + type FieldType "pNext" VkImportFenceFdInfoKHR = Ptr Void + type FieldOptional "pNext" VkImportFenceFdInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkImportFenceFdInfoKHR = + #{offset VkImportFenceFdInfoKHR, pNext} + type FieldIsArray "pNext" VkImportFenceFdInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkImportFenceFdInfoKHR, pNext} + +instance CanReadField "pNext" VkImportFenceFdInfoKHR where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkImportFenceFdInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} HasVkFence VkImportFenceFdInfoKHR + where + type VkFenceMType VkImportFenceFdInfoKHR = VkFence + + {-# NOINLINE vkFence #-} + vkFence x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImportFenceFdInfoKHR, fence}) + + {-# INLINE vkFenceByteOffset #-} + vkFenceByteOffset ~_ + = #{offset VkImportFenceFdInfoKHR, fence} + + {-# INLINE readVkFence #-} + readVkFence p + = peekByteOff p #{offset VkImportFenceFdInfoKHR, fence} + + {-# INLINE writeVkFence #-} + writeVkFence p + = pokeByteOff p #{offset VkImportFenceFdInfoKHR, fence} + +instance {-# OVERLAPPING #-} + HasField "fence" VkImportFenceFdInfoKHR where + type FieldType "fence" VkImportFenceFdInfoKHR = VkFence + type FieldOptional "fence" VkImportFenceFdInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "fence" VkImportFenceFdInfoKHR = + #{offset VkImportFenceFdInfoKHR, fence} + type FieldIsArray "fence" VkImportFenceFdInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkImportFenceFdInfoKHR, fence} + +instance CanReadField "fence" VkImportFenceFdInfoKHR where + {-# INLINE getField #-} + getField = vkFence + + {-# INLINE readField #-} + readField = readVkFence + +instance CanWriteField "fence" VkImportFenceFdInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkFence + +instance {-# OVERLAPPING #-} HasVkFlags VkImportFenceFdInfoKHR + where + type VkFlagsMType VkImportFenceFdInfoKHR = VkFenceImportFlagsKHR + + {-# NOINLINE vkFlags #-} + vkFlags x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImportFenceFdInfoKHR, flags}) + + {-# INLINE vkFlagsByteOffset #-} + vkFlagsByteOffset ~_ + = #{offset VkImportFenceFdInfoKHR, flags} + + {-# INLINE readVkFlags #-} + readVkFlags p + = peekByteOff p #{offset VkImportFenceFdInfoKHR, flags} + + {-# INLINE writeVkFlags #-} + writeVkFlags p + = pokeByteOff p #{offset VkImportFenceFdInfoKHR, flags} + +instance {-# OVERLAPPING #-} + HasField "flags" VkImportFenceFdInfoKHR where + type FieldType "flags" VkImportFenceFdInfoKHR = + VkFenceImportFlagsKHR + type FieldOptional "flags" VkImportFenceFdInfoKHR = 'True -- ' closing tick for hsc2hs + type FieldOffset "flags" VkImportFenceFdInfoKHR = + #{offset VkImportFenceFdInfoKHR, flags} + type FieldIsArray "flags" VkImportFenceFdInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkImportFenceFdInfoKHR, flags} + +instance CanReadField "flags" VkImportFenceFdInfoKHR where + {-# INLINE getField #-} + getField = vkFlags + + {-# INLINE readField #-} + readField = readVkFlags + +instance CanWriteField "flags" VkImportFenceFdInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkFlags + +instance {-# OVERLAPPING #-} HasVkHandleType VkImportFenceFdInfoKHR + where + type VkHandleTypeMType VkImportFenceFdInfoKHR = + VkExternalFenceHandleTypeFlagBitsKHR + + {-# NOINLINE vkHandleType #-} + vkHandleType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImportFenceFdInfoKHR, handleType}) + + {-# INLINE vkHandleTypeByteOffset #-} + vkHandleTypeByteOffset ~_ + = #{offset VkImportFenceFdInfoKHR, handleType} + + {-# INLINE readVkHandleType #-} + readVkHandleType p + = peekByteOff p #{offset VkImportFenceFdInfoKHR, handleType} + + {-# INLINE writeVkHandleType #-} + writeVkHandleType p + = pokeByteOff p #{offset VkImportFenceFdInfoKHR, handleType} + +instance {-# OVERLAPPING #-} + HasField "handleType" VkImportFenceFdInfoKHR where + type FieldType "handleType" VkImportFenceFdInfoKHR = + VkExternalFenceHandleTypeFlagBitsKHR + type FieldOptional "handleType" VkImportFenceFdInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "handleType" VkImportFenceFdInfoKHR = + #{offset VkImportFenceFdInfoKHR, handleType} + type FieldIsArray "handleType" VkImportFenceFdInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkImportFenceFdInfoKHR, handleType} + +instance CanReadField "handleType" VkImportFenceFdInfoKHR where + {-# INLINE getField #-} + getField = vkHandleType + + {-# INLINE readField #-} + readField = readVkHandleType + +instance CanWriteField "handleType" VkImportFenceFdInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkHandleType + +instance {-# OVERLAPPING #-} HasVkFd VkImportFenceFdInfoKHR where + type VkFdMType VkImportFenceFdInfoKHR = CInt + + {-# NOINLINE vkFd #-} + vkFd x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImportFenceFdInfoKHR, fd}) + + {-# INLINE vkFdByteOffset #-} + vkFdByteOffset ~_ + = #{offset VkImportFenceFdInfoKHR, fd} + + {-# INLINE readVkFd #-} + readVkFd p + = peekByteOff p #{offset VkImportFenceFdInfoKHR, fd} + + {-# INLINE writeVkFd #-} + writeVkFd p + = pokeByteOff p #{offset VkImportFenceFdInfoKHR, fd} + +instance {-# OVERLAPPING #-} HasField "fd" VkImportFenceFdInfoKHR + where + type FieldType "fd" VkImportFenceFdInfoKHR = CInt + type FieldOptional "fd" VkImportFenceFdInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "fd" VkImportFenceFdInfoKHR = + #{offset VkImportFenceFdInfoKHR, fd} + type FieldIsArray "fd" VkImportFenceFdInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkImportFenceFdInfoKHR, fd} + +instance CanReadField "fd" VkImportFenceFdInfoKHR where + {-# INLINE getField #-} + getField = vkFd + + {-# INLINE readField #-} + readField = readVkFd + +instance CanWriteField "fd" VkImportFenceFdInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkFd + +instance Show VkImportFenceFdInfoKHR where + showsPrec d x + = showString "VkImportFenceFdInfoKHR {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkFence = " . + showsPrec d (vkFence x) . + showString ", " . + showString "vkFlags = " . + showsPrec d (vkFlags x) . + showString ", " . + showString "vkHandleType = " . + showsPrec d (vkHandleType x) . + showString ", " . + showString "vkFd = " . + showsPrec d (vkFd x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkImportFenceWin32HandleInfoKHR.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkImportFenceWin32HandleInfoKHR.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkImportFenceWin32HandleInfoKHR.hsc @@ -0,0 +1,454 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkImportFenceWin32HandleInfoKHR + (VkImportFenceWin32HandleInfoKHR(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkExternalFenceHandleTypeFlagsKHR (VkExternalFenceHandleTypeFlagBitsKHR) +import Graphics.Vulkan.Types.Enum.VkFenceImportFlagsKHR (VkFenceImportFlagsKHR) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Handles (VkFence) +import Graphics.Vulkan.Types.Include (HANDLE, + LPCWSTR) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkImportFenceWin32HandleInfoKHR { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkFence fence; +-- > VkFenceImportFlagsKHR flags; +-- > VkExternalFenceHandleTypeFlagBitsKHR handleType; +-- > HANDLE handle; +-- > LPCWSTR name; +-- > } VkImportFenceWin32HandleInfoKHR; +-- +-- +data VkImportFenceWin32HandleInfoKHR = VkImportFenceWin32HandleInfoKHR## Addr## + ByteArray## + +instance Eq VkImportFenceWin32HandleInfoKHR where + (VkImportFenceWin32HandleInfoKHR## a _) == + x@(VkImportFenceWin32HandleInfoKHR## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkImportFenceWin32HandleInfoKHR where + (VkImportFenceWin32HandleInfoKHR## a _) `compare` + x@(VkImportFenceWin32HandleInfoKHR## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkImportFenceWin32HandleInfoKHR where + sizeOf ~_ = #{size VkImportFenceWin32HandleInfoKHR} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkImportFenceWin32HandleInfoKHR} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkImportFenceWin32HandleInfoKHR where + unsafeAddr (VkImportFenceWin32HandleInfoKHR## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkImportFenceWin32HandleInfoKHR## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkImportFenceWin32HandleInfoKHR## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkImportFenceWin32HandleInfoKHR where + type StructFields VkImportFenceWin32HandleInfoKHR = + '["sType", "pNext", "fence", "flags", "handleType", "handle", -- ' closing tick for hsc2hs + "name"] + type CUnionType VkImportFenceWin32HandleInfoKHR = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkImportFenceWin32HandleInfoKHR = 'False -- ' closing tick for hsc2hs + type StructExtends VkImportFenceWin32HandleInfoKHR = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkImportFenceWin32HandleInfoKHR where + type VkSTypeMType VkImportFenceWin32HandleInfoKHR = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImportFenceWin32HandleInfoKHR, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkImportFenceWin32HandleInfoKHR, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkImportFenceWin32HandleInfoKHR, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkImportFenceWin32HandleInfoKHR, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkImportFenceWin32HandleInfoKHR where + type FieldType "sType" VkImportFenceWin32HandleInfoKHR = + VkStructureType + type FieldOptional "sType" VkImportFenceWin32HandleInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkImportFenceWin32HandleInfoKHR = + #{offset VkImportFenceWin32HandleInfoKHR, sType} + type FieldIsArray "sType" VkImportFenceWin32HandleInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkImportFenceWin32HandleInfoKHR, sType} + +instance CanReadField "sType" VkImportFenceWin32HandleInfoKHR where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkImportFenceWin32HandleInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkImportFenceWin32HandleInfoKHR where + type VkPNextMType VkImportFenceWin32HandleInfoKHR = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImportFenceWin32HandleInfoKHR, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkImportFenceWin32HandleInfoKHR, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkImportFenceWin32HandleInfoKHR, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkImportFenceWin32HandleInfoKHR, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkImportFenceWin32HandleInfoKHR where + type FieldType "pNext" VkImportFenceWin32HandleInfoKHR = Ptr Void + type FieldOptional "pNext" VkImportFenceWin32HandleInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkImportFenceWin32HandleInfoKHR = + #{offset VkImportFenceWin32HandleInfoKHR, pNext} + type FieldIsArray "pNext" VkImportFenceWin32HandleInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkImportFenceWin32HandleInfoKHR, pNext} + +instance CanReadField "pNext" VkImportFenceWin32HandleInfoKHR where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkImportFenceWin32HandleInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkFence VkImportFenceWin32HandleInfoKHR where + type VkFenceMType VkImportFenceWin32HandleInfoKHR = VkFence + + {-# NOINLINE vkFence #-} + vkFence x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImportFenceWin32HandleInfoKHR, fence}) + + {-# INLINE vkFenceByteOffset #-} + vkFenceByteOffset ~_ + = #{offset VkImportFenceWin32HandleInfoKHR, fence} + + {-# INLINE readVkFence #-} + readVkFence p + = peekByteOff p #{offset VkImportFenceWin32HandleInfoKHR, fence} + + {-# INLINE writeVkFence #-} + writeVkFence p + = pokeByteOff p #{offset VkImportFenceWin32HandleInfoKHR, fence} + +instance {-# OVERLAPPING #-} + HasField "fence" VkImportFenceWin32HandleInfoKHR where + type FieldType "fence" VkImportFenceWin32HandleInfoKHR = VkFence + type FieldOptional "fence" VkImportFenceWin32HandleInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "fence" VkImportFenceWin32HandleInfoKHR = + #{offset VkImportFenceWin32HandleInfoKHR, fence} + type FieldIsArray "fence" VkImportFenceWin32HandleInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkImportFenceWin32HandleInfoKHR, fence} + +instance CanReadField "fence" VkImportFenceWin32HandleInfoKHR where + {-# INLINE getField #-} + getField = vkFence + + {-# INLINE readField #-} + readField = readVkFence + +instance CanWriteField "fence" VkImportFenceWin32HandleInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkFence + +instance {-# OVERLAPPING #-} + HasVkFlags VkImportFenceWin32HandleInfoKHR where + type VkFlagsMType VkImportFenceWin32HandleInfoKHR = + VkFenceImportFlagsKHR + + {-# NOINLINE vkFlags #-} + vkFlags x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImportFenceWin32HandleInfoKHR, flags}) + + {-# INLINE vkFlagsByteOffset #-} + vkFlagsByteOffset ~_ + = #{offset VkImportFenceWin32HandleInfoKHR, flags} + + {-# INLINE readVkFlags #-} + readVkFlags p + = peekByteOff p #{offset VkImportFenceWin32HandleInfoKHR, flags} + + {-# INLINE writeVkFlags #-} + writeVkFlags p + = pokeByteOff p #{offset VkImportFenceWin32HandleInfoKHR, flags} + +instance {-# OVERLAPPING #-} + HasField "flags" VkImportFenceWin32HandleInfoKHR where + type FieldType "flags" VkImportFenceWin32HandleInfoKHR = + VkFenceImportFlagsKHR + type FieldOptional "flags" VkImportFenceWin32HandleInfoKHR = 'True -- ' closing tick for hsc2hs + type FieldOffset "flags" VkImportFenceWin32HandleInfoKHR = + #{offset VkImportFenceWin32HandleInfoKHR, flags} + type FieldIsArray "flags" VkImportFenceWin32HandleInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkImportFenceWin32HandleInfoKHR, flags} + +instance CanReadField "flags" VkImportFenceWin32HandleInfoKHR where + {-# INLINE getField #-} + getField = vkFlags + + {-# INLINE readField #-} + readField = readVkFlags + +instance CanWriteField "flags" VkImportFenceWin32HandleInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkFlags + +instance {-# OVERLAPPING #-} + HasVkHandleType VkImportFenceWin32HandleInfoKHR where + type VkHandleTypeMType VkImportFenceWin32HandleInfoKHR = + VkExternalFenceHandleTypeFlagBitsKHR + + {-# NOINLINE vkHandleType #-} + vkHandleType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImportFenceWin32HandleInfoKHR, handleType}) + + {-# INLINE vkHandleTypeByteOffset #-} + vkHandleTypeByteOffset ~_ + = #{offset VkImportFenceWin32HandleInfoKHR, handleType} + + {-# INLINE readVkHandleType #-} + readVkHandleType p + = peekByteOff p #{offset VkImportFenceWin32HandleInfoKHR, handleType} + + {-# INLINE writeVkHandleType #-} + writeVkHandleType p + = pokeByteOff p #{offset VkImportFenceWin32HandleInfoKHR, handleType} + +instance {-# OVERLAPPING #-} + HasField "handleType" VkImportFenceWin32HandleInfoKHR where + type FieldType "handleType" VkImportFenceWin32HandleInfoKHR = + VkExternalFenceHandleTypeFlagBitsKHR + type FieldOptional "handleType" VkImportFenceWin32HandleInfoKHR = + 'True -- ' closing tick for hsc2hs + type FieldOffset "handleType" VkImportFenceWin32HandleInfoKHR = + #{offset VkImportFenceWin32HandleInfoKHR, handleType} + type FieldIsArray "handleType" VkImportFenceWin32HandleInfoKHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkImportFenceWin32HandleInfoKHR, handleType} + +instance CanReadField "handleType" VkImportFenceWin32HandleInfoKHR + where + {-# INLINE getField #-} + getField = vkHandleType + + {-# INLINE readField #-} + readField = readVkHandleType + +instance CanWriteField "handleType" VkImportFenceWin32HandleInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkHandleType + +instance {-# OVERLAPPING #-} + HasVkHandle VkImportFenceWin32HandleInfoKHR where + type VkHandleMType VkImportFenceWin32HandleInfoKHR = HANDLE + + {-# NOINLINE vkHandle #-} + vkHandle x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImportFenceWin32HandleInfoKHR, handle}) + + {-# INLINE vkHandleByteOffset #-} + vkHandleByteOffset ~_ + = #{offset VkImportFenceWin32HandleInfoKHR, handle} + + {-# INLINE readVkHandle #-} + readVkHandle p + = peekByteOff p #{offset VkImportFenceWin32HandleInfoKHR, handle} + + {-# INLINE writeVkHandle #-} + writeVkHandle p + = pokeByteOff p #{offset VkImportFenceWin32HandleInfoKHR, handle} + +instance {-# OVERLAPPING #-} + HasField "handle" VkImportFenceWin32HandleInfoKHR where + type FieldType "handle" VkImportFenceWin32HandleInfoKHR = HANDLE + type FieldOptional "handle" VkImportFenceWin32HandleInfoKHR = 'True -- ' closing tick for hsc2hs + type FieldOffset "handle" VkImportFenceWin32HandleInfoKHR = + #{offset VkImportFenceWin32HandleInfoKHR, handle} + type FieldIsArray "handle" VkImportFenceWin32HandleInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkImportFenceWin32HandleInfoKHR, handle} + +instance CanReadField "handle" VkImportFenceWin32HandleInfoKHR + where + {-# INLINE getField #-} + getField = vkHandle + + {-# INLINE readField #-} + readField = readVkHandle + +instance CanWriteField "handle" VkImportFenceWin32HandleInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkHandle + +instance {-# OVERLAPPING #-} + HasVkName VkImportFenceWin32HandleInfoKHR where + type VkNameMType VkImportFenceWin32HandleInfoKHR = LPCWSTR + + {-# NOINLINE vkName #-} + vkName x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImportFenceWin32HandleInfoKHR, name}) + + {-# INLINE vkNameByteOffset #-} + vkNameByteOffset ~_ + = #{offset VkImportFenceWin32HandleInfoKHR, name} + + {-# INLINE readVkName #-} + readVkName p + = peekByteOff p #{offset VkImportFenceWin32HandleInfoKHR, name} + + {-# INLINE writeVkName #-} + writeVkName p + = pokeByteOff p #{offset VkImportFenceWin32HandleInfoKHR, name} + +instance {-# OVERLAPPING #-} + HasField "name" VkImportFenceWin32HandleInfoKHR where + type FieldType "name" VkImportFenceWin32HandleInfoKHR = LPCWSTR + type FieldOptional "name" VkImportFenceWin32HandleInfoKHR = 'True -- ' closing tick for hsc2hs + type FieldOffset "name" VkImportFenceWin32HandleInfoKHR = + #{offset VkImportFenceWin32HandleInfoKHR, name} + type FieldIsArray "name" VkImportFenceWin32HandleInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkImportFenceWin32HandleInfoKHR, name} + +instance CanReadField "name" VkImportFenceWin32HandleInfoKHR where + {-# INLINE getField #-} + getField = vkName + + {-# INLINE readField #-} + readField = readVkName + +instance CanWriteField "name" VkImportFenceWin32HandleInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkName + +instance Show VkImportFenceWin32HandleInfoKHR where + showsPrec d x + = showString "VkImportFenceWin32HandleInfoKHR {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkFence = " . + showsPrec d (vkFence x) . + showString ", " . + showString "vkFlags = " . + showsPrec d (vkFlags x) . + showString ", " . + showString "vkHandleType = " . + showsPrec d (vkHandleType x) . + showString ", " . + showString "vkHandle = " . + showsPrec d (vkHandle x) . + showString ", " . + showString "vkName = " . + showsPrec d (vkName x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkImportMemoryFdInfoKHR.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkImportMemoryFdInfoKHR.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkImportMemoryFdInfoKHR.hsc @@ -0,0 +1,276 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkImportMemoryFdInfoKHR + (VkImportMemoryFdInfoKHR(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkExternalMemoryHandleTypeFlagsKHR (VkExternalMemoryHandleTypeFlagBitsKHR) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Struct.VkMemoryAllocateInfo (VkMemoryAllocateInfo) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkImportMemoryFdInfoKHR { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkExternalMemoryHandleTypeFlagBitsKHR handleType; +-- > int fd; +-- > } VkImportMemoryFdInfoKHR; +-- +-- +data VkImportMemoryFdInfoKHR = VkImportMemoryFdInfoKHR## Addr## + ByteArray## + +instance Eq VkImportMemoryFdInfoKHR where + (VkImportMemoryFdInfoKHR## a _) == x@(VkImportMemoryFdInfoKHR## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkImportMemoryFdInfoKHR where + (VkImportMemoryFdInfoKHR## a _) `compare` + x@(VkImportMemoryFdInfoKHR## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkImportMemoryFdInfoKHR where + sizeOf ~_ = #{size VkImportMemoryFdInfoKHR} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkImportMemoryFdInfoKHR} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkImportMemoryFdInfoKHR where + unsafeAddr (VkImportMemoryFdInfoKHR## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkImportMemoryFdInfoKHR## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkImportMemoryFdInfoKHR## (plusAddr## (byteArrayContents## b) off) b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkImportMemoryFdInfoKHR where + type StructFields VkImportMemoryFdInfoKHR = + '["sType", "pNext", "handleType", "fd"] -- ' closing tick for hsc2hs + type CUnionType VkImportMemoryFdInfoKHR = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkImportMemoryFdInfoKHR = 'False -- ' closing tick for hsc2hs + type StructExtends VkImportMemoryFdInfoKHR = + '[VkMemoryAllocateInfo] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkSType VkImportMemoryFdInfoKHR + where + type VkSTypeMType VkImportMemoryFdInfoKHR = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImportMemoryFdInfoKHR, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkImportMemoryFdInfoKHR, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkImportMemoryFdInfoKHR, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkImportMemoryFdInfoKHR, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkImportMemoryFdInfoKHR where + type FieldType "sType" VkImportMemoryFdInfoKHR = VkStructureType + type FieldOptional "sType" VkImportMemoryFdInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkImportMemoryFdInfoKHR = + #{offset VkImportMemoryFdInfoKHR, sType} + type FieldIsArray "sType" VkImportMemoryFdInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkImportMemoryFdInfoKHR, sType} + +instance CanReadField "sType" VkImportMemoryFdInfoKHR where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkImportMemoryFdInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} HasVkPNext VkImportMemoryFdInfoKHR + where + type VkPNextMType VkImportMemoryFdInfoKHR = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImportMemoryFdInfoKHR, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkImportMemoryFdInfoKHR, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkImportMemoryFdInfoKHR, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkImportMemoryFdInfoKHR, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkImportMemoryFdInfoKHR where + type FieldType "pNext" VkImportMemoryFdInfoKHR = Ptr Void + type FieldOptional "pNext" VkImportMemoryFdInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkImportMemoryFdInfoKHR = + #{offset VkImportMemoryFdInfoKHR, pNext} + type FieldIsArray "pNext" VkImportMemoryFdInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkImportMemoryFdInfoKHR, pNext} + +instance CanReadField "pNext" VkImportMemoryFdInfoKHR where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkImportMemoryFdInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkHandleType VkImportMemoryFdInfoKHR where + type VkHandleTypeMType VkImportMemoryFdInfoKHR = + VkExternalMemoryHandleTypeFlagBitsKHR + + {-# NOINLINE vkHandleType #-} + vkHandleType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImportMemoryFdInfoKHR, handleType}) + + {-# INLINE vkHandleTypeByteOffset #-} + vkHandleTypeByteOffset ~_ + = #{offset VkImportMemoryFdInfoKHR, handleType} + + {-# INLINE readVkHandleType #-} + readVkHandleType p + = peekByteOff p #{offset VkImportMemoryFdInfoKHR, handleType} + + {-# INLINE writeVkHandleType #-} + writeVkHandleType p + = pokeByteOff p #{offset VkImportMemoryFdInfoKHR, handleType} + +instance {-# OVERLAPPING #-} + HasField "handleType" VkImportMemoryFdInfoKHR where + type FieldType "handleType" VkImportMemoryFdInfoKHR = + VkExternalMemoryHandleTypeFlagBitsKHR + type FieldOptional "handleType" VkImportMemoryFdInfoKHR = 'True -- ' closing tick for hsc2hs + type FieldOffset "handleType" VkImportMemoryFdInfoKHR = + #{offset VkImportMemoryFdInfoKHR, handleType} + type FieldIsArray "handleType" VkImportMemoryFdInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkImportMemoryFdInfoKHR, handleType} + +instance CanReadField "handleType" VkImportMemoryFdInfoKHR where + {-# INLINE getField #-} + getField = vkHandleType + + {-# INLINE readField #-} + readField = readVkHandleType + +instance CanWriteField "handleType" VkImportMemoryFdInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkHandleType + +instance {-# OVERLAPPING #-} HasVkFd VkImportMemoryFdInfoKHR where + type VkFdMType VkImportMemoryFdInfoKHR = CInt + + {-# NOINLINE vkFd #-} + vkFd x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImportMemoryFdInfoKHR, fd}) + + {-# INLINE vkFdByteOffset #-} + vkFdByteOffset ~_ + = #{offset VkImportMemoryFdInfoKHR, fd} + + {-# INLINE readVkFd #-} + readVkFd p + = peekByteOff p #{offset VkImportMemoryFdInfoKHR, fd} + + {-# INLINE writeVkFd #-} + writeVkFd p + = pokeByteOff p #{offset VkImportMemoryFdInfoKHR, fd} + +instance {-# OVERLAPPING #-} HasField "fd" VkImportMemoryFdInfoKHR + where + type FieldType "fd" VkImportMemoryFdInfoKHR = CInt + type FieldOptional "fd" VkImportMemoryFdInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "fd" VkImportMemoryFdInfoKHR = + #{offset VkImportMemoryFdInfoKHR, fd} + type FieldIsArray "fd" VkImportMemoryFdInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkImportMemoryFdInfoKHR, fd} + +instance CanReadField "fd" VkImportMemoryFdInfoKHR where + {-# INLINE getField #-} + getField = vkFd + + {-# INLINE readField #-} + readField = readVkFd + +instance CanWriteField "fd" VkImportMemoryFdInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkFd + +instance Show VkImportMemoryFdInfoKHR where + showsPrec d x + = showString "VkImportMemoryFdInfoKHR {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkHandleType = " . + showsPrec d (vkHandleType x) . + showString ", " . + showString "vkFd = " . showsPrec d (vkFd x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkImportMemoryHostPointerInfoEXT.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkImportMemoryHostPointerInfoEXT.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkImportMemoryHostPointerInfoEXT.hsc @@ -0,0 +1,307 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkImportMemoryHostPointerInfoEXT + (VkImportMemoryHostPointerInfoEXT(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkExternalMemoryHandleTypeFlagsKHR (VkExternalMemoryHandleTypeFlagBitsKHR) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Struct.VkMemoryAllocateInfo (VkMemoryAllocateInfo) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkImportMemoryHostPointerInfoEXT { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkExternalMemoryHandleTypeFlagBitsKHR handleType; +-- > void* pHostPointer; +-- > } VkImportMemoryHostPointerInfoEXT; +-- +-- +data VkImportMemoryHostPointerInfoEXT = VkImportMemoryHostPointerInfoEXT## Addr## + ByteArray## + +instance Eq VkImportMemoryHostPointerInfoEXT where + (VkImportMemoryHostPointerInfoEXT## a _) == + x@(VkImportMemoryHostPointerInfoEXT## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkImportMemoryHostPointerInfoEXT where + (VkImportMemoryHostPointerInfoEXT## a _) `compare` + x@(VkImportMemoryHostPointerInfoEXT## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkImportMemoryHostPointerInfoEXT where + sizeOf ~_ = #{size VkImportMemoryHostPointerInfoEXT} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkImportMemoryHostPointerInfoEXT} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkImportMemoryHostPointerInfoEXT where + unsafeAddr (VkImportMemoryHostPointerInfoEXT## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkImportMemoryHostPointerInfoEXT## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkImportMemoryHostPointerInfoEXT## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkImportMemoryHostPointerInfoEXT where + type StructFields VkImportMemoryHostPointerInfoEXT = + '["sType", "pNext", "handleType", "pHostPointer"] -- ' closing tick for hsc2hs + type CUnionType VkImportMemoryHostPointerInfoEXT = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkImportMemoryHostPointerInfoEXT = 'False -- ' closing tick for hsc2hs + type StructExtends VkImportMemoryHostPointerInfoEXT = + '[VkMemoryAllocateInfo] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkImportMemoryHostPointerInfoEXT where + type VkSTypeMType VkImportMemoryHostPointerInfoEXT = + VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImportMemoryHostPointerInfoEXT, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkImportMemoryHostPointerInfoEXT, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkImportMemoryHostPointerInfoEXT, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkImportMemoryHostPointerInfoEXT, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkImportMemoryHostPointerInfoEXT where + type FieldType "sType" VkImportMemoryHostPointerInfoEXT = + VkStructureType + type FieldOptional "sType" VkImportMemoryHostPointerInfoEXT = + 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkImportMemoryHostPointerInfoEXT = + #{offset VkImportMemoryHostPointerInfoEXT, sType} + type FieldIsArray "sType" VkImportMemoryHostPointerInfoEXT = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkImportMemoryHostPointerInfoEXT, sType} + +instance CanReadField "sType" VkImportMemoryHostPointerInfoEXT + where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkImportMemoryHostPointerInfoEXT + where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkImportMemoryHostPointerInfoEXT where + type VkPNextMType VkImportMemoryHostPointerInfoEXT = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImportMemoryHostPointerInfoEXT, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkImportMemoryHostPointerInfoEXT, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkImportMemoryHostPointerInfoEXT, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkImportMemoryHostPointerInfoEXT, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkImportMemoryHostPointerInfoEXT where + type FieldType "pNext" VkImportMemoryHostPointerInfoEXT = Ptr Void + type FieldOptional "pNext" VkImportMemoryHostPointerInfoEXT = + 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkImportMemoryHostPointerInfoEXT = + #{offset VkImportMemoryHostPointerInfoEXT, pNext} + type FieldIsArray "pNext" VkImportMemoryHostPointerInfoEXT = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkImportMemoryHostPointerInfoEXT, pNext} + +instance CanReadField "pNext" VkImportMemoryHostPointerInfoEXT + where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkImportMemoryHostPointerInfoEXT + where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkHandleType VkImportMemoryHostPointerInfoEXT where + type VkHandleTypeMType VkImportMemoryHostPointerInfoEXT = + VkExternalMemoryHandleTypeFlagBitsKHR + + {-# NOINLINE vkHandleType #-} + vkHandleType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImportMemoryHostPointerInfoEXT, handleType}) + + {-# INLINE vkHandleTypeByteOffset #-} + vkHandleTypeByteOffset ~_ + = #{offset VkImportMemoryHostPointerInfoEXT, handleType} + + {-# INLINE readVkHandleType #-} + readVkHandleType p + = peekByteOff p #{offset VkImportMemoryHostPointerInfoEXT, handleType} + + {-# INLINE writeVkHandleType #-} + writeVkHandleType p + = pokeByteOff p #{offset VkImportMemoryHostPointerInfoEXT, handleType} + +instance {-# OVERLAPPING #-} + HasField "handleType" VkImportMemoryHostPointerInfoEXT where + type FieldType "handleType" VkImportMemoryHostPointerInfoEXT = + VkExternalMemoryHandleTypeFlagBitsKHR + type FieldOptional "handleType" VkImportMemoryHostPointerInfoEXT = + 'False -- ' closing tick for hsc2hs + type FieldOffset "handleType" VkImportMemoryHostPointerInfoEXT = + #{offset VkImportMemoryHostPointerInfoEXT, handleType} + type FieldIsArray "handleType" VkImportMemoryHostPointerInfoEXT = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkImportMemoryHostPointerInfoEXT, handleType} + +instance CanReadField "handleType" VkImportMemoryHostPointerInfoEXT + where + {-# INLINE getField #-} + getField = vkHandleType + + {-# INLINE readField #-} + readField = readVkHandleType + +instance CanWriteField "handleType" + VkImportMemoryHostPointerInfoEXT + where + {-# INLINE writeField #-} + writeField = writeVkHandleType + +instance {-# OVERLAPPING #-} + HasVkPHostPointer VkImportMemoryHostPointerInfoEXT where + type VkPHostPointerMType VkImportMemoryHostPointerInfoEXT = + Ptr Void + + {-# NOINLINE vkPHostPointer #-} + vkPHostPointer x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImportMemoryHostPointerInfoEXT, pHostPointer}) + + {-# INLINE vkPHostPointerByteOffset #-} + vkPHostPointerByteOffset ~_ + = #{offset VkImportMemoryHostPointerInfoEXT, pHostPointer} + + {-# INLINE readVkPHostPointer #-} + readVkPHostPointer p + = peekByteOff p #{offset VkImportMemoryHostPointerInfoEXT, pHostPointer} + + {-# INLINE writeVkPHostPointer #-} + writeVkPHostPointer p + = pokeByteOff p #{offset VkImportMemoryHostPointerInfoEXT, pHostPointer} + +instance {-# OVERLAPPING #-} + HasField "pHostPointer" VkImportMemoryHostPointerInfoEXT where + type FieldType "pHostPointer" VkImportMemoryHostPointerInfoEXT = + Ptr Void + type FieldOptional "pHostPointer" VkImportMemoryHostPointerInfoEXT + = 'False -- ' closing tick for hsc2hs + type FieldOffset "pHostPointer" VkImportMemoryHostPointerInfoEXT = + #{offset VkImportMemoryHostPointerInfoEXT, pHostPointer} + type FieldIsArray "pHostPointer" VkImportMemoryHostPointerInfoEXT = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkImportMemoryHostPointerInfoEXT, pHostPointer} + +instance CanReadField "pHostPointer" + VkImportMemoryHostPointerInfoEXT + where + {-# INLINE getField #-} + getField = vkPHostPointer + + {-# INLINE readField #-} + readField = readVkPHostPointer + +instance CanWriteField "pHostPointer" + VkImportMemoryHostPointerInfoEXT + where + {-# INLINE writeField #-} + writeField = writeVkPHostPointer + +instance Show VkImportMemoryHostPointerInfoEXT where + showsPrec d x + = showString "VkImportMemoryHostPointerInfoEXT {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkHandleType = " . + showsPrec d (vkHandleType x) . + showString ", " . + showString "vkPHostPointer = " . + showsPrec d (vkPHostPointer x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkImportMemoryWin32HandleInfoKHR.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkImportMemoryWin32HandleInfoKHR.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkImportMemoryWin32HandleInfoKHR.hsc @@ -0,0 +1,356 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkImportMemoryWin32HandleInfoKHR + (VkImportMemoryWin32HandleInfoKHR(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkExternalMemoryHandleTypeFlagsKHR (VkExternalMemoryHandleTypeFlagBitsKHR) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Include (HANDLE, + LPCWSTR) +import Graphics.Vulkan.Types.Struct.VkMemoryAllocateInfo (VkMemoryAllocateInfo) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkImportMemoryWin32HandleInfoKHR { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkExternalMemoryHandleTypeFlagBitsKHR handleType; +-- > HANDLE handle; +-- > LPCWSTR name; +-- > } VkImportMemoryWin32HandleInfoKHR; +-- +-- +data VkImportMemoryWin32HandleInfoKHR = VkImportMemoryWin32HandleInfoKHR## Addr## + ByteArray## + +instance Eq VkImportMemoryWin32HandleInfoKHR where + (VkImportMemoryWin32HandleInfoKHR## a _) == + x@(VkImportMemoryWin32HandleInfoKHR## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkImportMemoryWin32HandleInfoKHR where + (VkImportMemoryWin32HandleInfoKHR## a _) `compare` + x@(VkImportMemoryWin32HandleInfoKHR## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkImportMemoryWin32HandleInfoKHR where + sizeOf ~_ = #{size VkImportMemoryWin32HandleInfoKHR} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkImportMemoryWin32HandleInfoKHR} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkImportMemoryWin32HandleInfoKHR where + unsafeAddr (VkImportMemoryWin32HandleInfoKHR## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkImportMemoryWin32HandleInfoKHR## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkImportMemoryWin32HandleInfoKHR## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkImportMemoryWin32HandleInfoKHR where + type StructFields VkImportMemoryWin32HandleInfoKHR = + '["sType", "pNext", "handleType", "handle", "name"] -- ' closing tick for hsc2hs + type CUnionType VkImportMemoryWin32HandleInfoKHR = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkImportMemoryWin32HandleInfoKHR = 'False -- ' closing tick for hsc2hs + type StructExtends VkImportMemoryWin32HandleInfoKHR = + '[VkMemoryAllocateInfo] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkImportMemoryWin32HandleInfoKHR where + type VkSTypeMType VkImportMemoryWin32HandleInfoKHR = + VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImportMemoryWin32HandleInfoKHR, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkImportMemoryWin32HandleInfoKHR, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkImportMemoryWin32HandleInfoKHR, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkImportMemoryWin32HandleInfoKHR, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkImportMemoryWin32HandleInfoKHR where + type FieldType "sType" VkImportMemoryWin32HandleInfoKHR = + VkStructureType + type FieldOptional "sType" VkImportMemoryWin32HandleInfoKHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkImportMemoryWin32HandleInfoKHR = + #{offset VkImportMemoryWin32HandleInfoKHR, sType} + type FieldIsArray "sType" VkImportMemoryWin32HandleInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkImportMemoryWin32HandleInfoKHR, sType} + +instance CanReadField "sType" VkImportMemoryWin32HandleInfoKHR + where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkImportMemoryWin32HandleInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkImportMemoryWin32HandleInfoKHR where + type VkPNextMType VkImportMemoryWin32HandleInfoKHR = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImportMemoryWin32HandleInfoKHR, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkImportMemoryWin32HandleInfoKHR, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkImportMemoryWin32HandleInfoKHR, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkImportMemoryWin32HandleInfoKHR, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkImportMemoryWin32HandleInfoKHR where + type FieldType "pNext" VkImportMemoryWin32HandleInfoKHR = Ptr Void + type FieldOptional "pNext" VkImportMemoryWin32HandleInfoKHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkImportMemoryWin32HandleInfoKHR = + #{offset VkImportMemoryWin32HandleInfoKHR, pNext} + type FieldIsArray "pNext" VkImportMemoryWin32HandleInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkImportMemoryWin32HandleInfoKHR, pNext} + +instance CanReadField "pNext" VkImportMemoryWin32HandleInfoKHR + where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkImportMemoryWin32HandleInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkHandleType VkImportMemoryWin32HandleInfoKHR where + type VkHandleTypeMType VkImportMemoryWin32HandleInfoKHR = + VkExternalMemoryHandleTypeFlagBitsKHR + + {-# NOINLINE vkHandleType #-} + vkHandleType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImportMemoryWin32HandleInfoKHR, handleType}) + + {-# INLINE vkHandleTypeByteOffset #-} + vkHandleTypeByteOffset ~_ + = #{offset VkImportMemoryWin32HandleInfoKHR, handleType} + + {-# INLINE readVkHandleType #-} + readVkHandleType p + = peekByteOff p #{offset VkImportMemoryWin32HandleInfoKHR, handleType} + + {-# INLINE writeVkHandleType #-} + writeVkHandleType p + = pokeByteOff p #{offset VkImportMemoryWin32HandleInfoKHR, handleType} + +instance {-# OVERLAPPING #-} + HasField "handleType" VkImportMemoryWin32HandleInfoKHR where + type FieldType "handleType" VkImportMemoryWin32HandleInfoKHR = + VkExternalMemoryHandleTypeFlagBitsKHR + type FieldOptional "handleType" VkImportMemoryWin32HandleInfoKHR = + 'True -- ' closing tick for hsc2hs + type FieldOffset "handleType" VkImportMemoryWin32HandleInfoKHR = + #{offset VkImportMemoryWin32HandleInfoKHR, handleType} + type FieldIsArray "handleType" VkImportMemoryWin32HandleInfoKHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkImportMemoryWin32HandleInfoKHR, handleType} + +instance CanReadField "handleType" VkImportMemoryWin32HandleInfoKHR + where + {-# INLINE getField #-} + getField = vkHandleType + + {-# INLINE readField #-} + readField = readVkHandleType + +instance CanWriteField "handleType" + VkImportMemoryWin32HandleInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkHandleType + +instance {-# OVERLAPPING #-} + HasVkHandle VkImportMemoryWin32HandleInfoKHR where + type VkHandleMType VkImportMemoryWin32HandleInfoKHR = HANDLE + + {-# NOINLINE vkHandle #-} + vkHandle x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImportMemoryWin32HandleInfoKHR, handle}) + + {-# INLINE vkHandleByteOffset #-} + vkHandleByteOffset ~_ + = #{offset VkImportMemoryWin32HandleInfoKHR, handle} + + {-# INLINE readVkHandle #-} + readVkHandle p + = peekByteOff p #{offset VkImportMemoryWin32HandleInfoKHR, handle} + + {-# INLINE writeVkHandle #-} + writeVkHandle p + = pokeByteOff p #{offset VkImportMemoryWin32HandleInfoKHR, handle} + +instance {-# OVERLAPPING #-} + HasField "handle" VkImportMemoryWin32HandleInfoKHR where + type FieldType "handle" VkImportMemoryWin32HandleInfoKHR = HANDLE + type FieldOptional "handle" VkImportMemoryWin32HandleInfoKHR = + 'True -- ' closing tick for hsc2hs + type FieldOffset "handle" VkImportMemoryWin32HandleInfoKHR = + #{offset VkImportMemoryWin32HandleInfoKHR, handle} + type FieldIsArray "handle" VkImportMemoryWin32HandleInfoKHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkImportMemoryWin32HandleInfoKHR, handle} + +instance CanReadField "handle" VkImportMemoryWin32HandleInfoKHR + where + {-# INLINE getField #-} + getField = vkHandle + + {-# INLINE readField #-} + readField = readVkHandle + +instance CanWriteField "handle" VkImportMemoryWin32HandleInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkHandle + +instance {-# OVERLAPPING #-} + HasVkName VkImportMemoryWin32HandleInfoKHR where + type VkNameMType VkImportMemoryWin32HandleInfoKHR = LPCWSTR + + {-# NOINLINE vkName #-} + vkName x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImportMemoryWin32HandleInfoKHR, name}) + + {-# INLINE vkNameByteOffset #-} + vkNameByteOffset ~_ + = #{offset VkImportMemoryWin32HandleInfoKHR, name} + + {-# INLINE readVkName #-} + readVkName p + = peekByteOff p #{offset VkImportMemoryWin32HandleInfoKHR, name} + + {-# INLINE writeVkName #-} + writeVkName p + = pokeByteOff p #{offset VkImportMemoryWin32HandleInfoKHR, name} + +instance {-# OVERLAPPING #-} + HasField "name" VkImportMemoryWin32HandleInfoKHR where + type FieldType "name" VkImportMemoryWin32HandleInfoKHR = LPCWSTR + type FieldOptional "name" VkImportMemoryWin32HandleInfoKHR = 'True -- ' closing tick for hsc2hs + type FieldOffset "name" VkImportMemoryWin32HandleInfoKHR = + #{offset VkImportMemoryWin32HandleInfoKHR, name} + type FieldIsArray "name" VkImportMemoryWin32HandleInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkImportMemoryWin32HandleInfoKHR, name} + +instance CanReadField "name" VkImportMemoryWin32HandleInfoKHR where + {-# INLINE getField #-} + getField = vkName + + {-# INLINE readField #-} + readField = readVkName + +instance CanWriteField "name" VkImportMemoryWin32HandleInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkName + +instance Show VkImportMemoryWin32HandleInfoKHR where + showsPrec d x + = showString "VkImportMemoryWin32HandleInfoKHR {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkHandleType = " . + showsPrec d (vkHandleType x) . + showString ", " . + showString "vkHandle = " . + showsPrec d (vkHandle x) . + showString ", " . + showString "vkName = " . showsPrec d (vkName x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkImportMemoryWin32HandleInfoNV.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkImportMemoryWin32HandleInfoNV.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkImportMemoryWin32HandleInfoNV.hsc @@ -0,0 +1,294 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkImportMemoryWin32HandleInfoNV + (VkImportMemoryWin32HandleInfoNV(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkExternalMemoryHandleTypeFlagsNV (VkExternalMemoryHandleTypeFlagsNV) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Include (HANDLE) +import Graphics.Vulkan.Types.Struct.VkMemoryAllocateInfo (VkMemoryAllocateInfo) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkImportMemoryWin32HandleInfoNV { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkExternalMemoryHandleTypeFlagsNV handleType; +-- > HANDLE handle; +-- > } VkImportMemoryWin32HandleInfoNV; +-- +-- +data VkImportMemoryWin32HandleInfoNV = VkImportMemoryWin32HandleInfoNV## Addr## + ByteArray## + +instance Eq VkImportMemoryWin32HandleInfoNV where + (VkImportMemoryWin32HandleInfoNV## a _) == + x@(VkImportMemoryWin32HandleInfoNV## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkImportMemoryWin32HandleInfoNV where + (VkImportMemoryWin32HandleInfoNV## a _) `compare` + x@(VkImportMemoryWin32HandleInfoNV## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkImportMemoryWin32HandleInfoNV where + sizeOf ~_ = #{size VkImportMemoryWin32HandleInfoNV} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkImportMemoryWin32HandleInfoNV} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkImportMemoryWin32HandleInfoNV where + unsafeAddr (VkImportMemoryWin32HandleInfoNV## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkImportMemoryWin32HandleInfoNV## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkImportMemoryWin32HandleInfoNV## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkImportMemoryWin32HandleInfoNV where + type StructFields VkImportMemoryWin32HandleInfoNV = + '["sType", "pNext", "handleType", "handle"] -- ' closing tick for hsc2hs + type CUnionType VkImportMemoryWin32HandleInfoNV = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkImportMemoryWin32HandleInfoNV = 'False -- ' closing tick for hsc2hs + type StructExtends VkImportMemoryWin32HandleInfoNV = + '[VkMemoryAllocateInfo] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkImportMemoryWin32HandleInfoNV where + type VkSTypeMType VkImportMemoryWin32HandleInfoNV = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImportMemoryWin32HandleInfoNV, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkImportMemoryWin32HandleInfoNV, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkImportMemoryWin32HandleInfoNV, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkImportMemoryWin32HandleInfoNV, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkImportMemoryWin32HandleInfoNV where + type FieldType "sType" VkImportMemoryWin32HandleInfoNV = + VkStructureType + type FieldOptional "sType" VkImportMemoryWin32HandleInfoNV = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkImportMemoryWin32HandleInfoNV = + #{offset VkImportMemoryWin32HandleInfoNV, sType} + type FieldIsArray "sType" VkImportMemoryWin32HandleInfoNV = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkImportMemoryWin32HandleInfoNV, sType} + +instance CanReadField "sType" VkImportMemoryWin32HandleInfoNV where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkImportMemoryWin32HandleInfoNV + where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkImportMemoryWin32HandleInfoNV where + type VkPNextMType VkImportMemoryWin32HandleInfoNV = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImportMemoryWin32HandleInfoNV, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkImportMemoryWin32HandleInfoNV, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkImportMemoryWin32HandleInfoNV, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkImportMemoryWin32HandleInfoNV, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkImportMemoryWin32HandleInfoNV where + type FieldType "pNext" VkImportMemoryWin32HandleInfoNV = Ptr Void + type FieldOptional "pNext" VkImportMemoryWin32HandleInfoNV = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkImportMemoryWin32HandleInfoNV = + #{offset VkImportMemoryWin32HandleInfoNV, pNext} + type FieldIsArray "pNext" VkImportMemoryWin32HandleInfoNV = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkImportMemoryWin32HandleInfoNV, pNext} + +instance CanReadField "pNext" VkImportMemoryWin32HandleInfoNV where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkImportMemoryWin32HandleInfoNV + where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkHandleType VkImportMemoryWin32HandleInfoNV where + type VkHandleTypeMType VkImportMemoryWin32HandleInfoNV = + VkExternalMemoryHandleTypeFlagsNV + + {-# NOINLINE vkHandleType #-} + vkHandleType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImportMemoryWin32HandleInfoNV, handleType}) + + {-# INLINE vkHandleTypeByteOffset #-} + vkHandleTypeByteOffset ~_ + = #{offset VkImportMemoryWin32HandleInfoNV, handleType} + + {-# INLINE readVkHandleType #-} + readVkHandleType p + = peekByteOff p #{offset VkImportMemoryWin32HandleInfoNV, handleType} + + {-# INLINE writeVkHandleType #-} + writeVkHandleType p + = pokeByteOff p #{offset VkImportMemoryWin32HandleInfoNV, handleType} + +instance {-# OVERLAPPING #-} + HasField "handleType" VkImportMemoryWin32HandleInfoNV where + type FieldType "handleType" VkImportMemoryWin32HandleInfoNV = + VkExternalMemoryHandleTypeFlagsNV + type FieldOptional "handleType" VkImportMemoryWin32HandleInfoNV = + 'True -- ' closing tick for hsc2hs + type FieldOffset "handleType" VkImportMemoryWin32HandleInfoNV = + #{offset VkImportMemoryWin32HandleInfoNV, handleType} + type FieldIsArray "handleType" VkImportMemoryWin32HandleInfoNV = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkImportMemoryWin32HandleInfoNV, handleType} + +instance CanReadField "handleType" VkImportMemoryWin32HandleInfoNV + where + {-# INLINE getField #-} + getField = vkHandleType + + {-# INLINE readField #-} + readField = readVkHandleType + +instance CanWriteField "handleType" VkImportMemoryWin32HandleInfoNV + where + {-# INLINE writeField #-} + writeField = writeVkHandleType + +instance {-# OVERLAPPING #-} + HasVkHandle VkImportMemoryWin32HandleInfoNV where + type VkHandleMType VkImportMemoryWin32HandleInfoNV = HANDLE + + {-# NOINLINE vkHandle #-} + vkHandle x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImportMemoryWin32HandleInfoNV, handle}) + + {-# INLINE vkHandleByteOffset #-} + vkHandleByteOffset ~_ + = #{offset VkImportMemoryWin32HandleInfoNV, handle} + + {-# INLINE readVkHandle #-} + readVkHandle p + = peekByteOff p #{offset VkImportMemoryWin32HandleInfoNV, handle} + + {-# INLINE writeVkHandle #-} + writeVkHandle p + = pokeByteOff p #{offset VkImportMemoryWin32HandleInfoNV, handle} + +instance {-# OVERLAPPING #-} + HasField "handle" VkImportMemoryWin32HandleInfoNV where + type FieldType "handle" VkImportMemoryWin32HandleInfoNV = HANDLE + type FieldOptional "handle" VkImportMemoryWin32HandleInfoNV = 'True -- ' closing tick for hsc2hs + type FieldOffset "handle" VkImportMemoryWin32HandleInfoNV = + #{offset VkImportMemoryWin32HandleInfoNV, handle} + type FieldIsArray "handle" VkImportMemoryWin32HandleInfoNV = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkImportMemoryWin32HandleInfoNV, handle} + +instance CanReadField "handle" VkImportMemoryWin32HandleInfoNV + where + {-# INLINE getField #-} + getField = vkHandle + + {-# INLINE readField #-} + readField = readVkHandle + +instance CanWriteField "handle" VkImportMemoryWin32HandleInfoNV + where + {-# INLINE writeField #-} + writeField = writeVkHandle + +instance Show VkImportMemoryWin32HandleInfoNV where + showsPrec d x + = showString "VkImportMemoryWin32HandleInfoNV {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkHandleType = " . + showsPrec d (vkHandleType x) . + showString ", " . + showString "vkHandle = " . showsPrec d (vkHandle x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkImportSemaphoreFdInfoKHR.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkImportSemaphoreFdInfoKHR.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkImportSemaphoreFdInfoKHR.hsc @@ -0,0 +1,394 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkImportSemaphoreFdInfoKHR + (VkImportSemaphoreFdInfoKHR(..)) where +import Foreign.Storable + (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkExternalSemaphoreHandleTypeFlagsKHR + (VkExternalSemaphoreHandleTypeFlagBitsKHR) +import Graphics.Vulkan.Types.Enum.VkSemaphoreImportFlagsKHR + (VkSemaphoreImportFlagsKHR) +import Graphics.Vulkan.Types.Enum.VkStructureType + (VkStructureType) +import Graphics.Vulkan.Types.Handles + (VkSemaphore) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe + (unsafeDupablePerformIO) + +-- | > typedef struct VkImportSemaphoreFdInfoKHR { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkSemaphore semaphore; +-- > VkSemaphoreImportFlagsKHR flags; +-- > VkExternalSemaphoreHandleTypeFlagBitsKHR handleType; +-- > int fd; +-- > } VkImportSemaphoreFdInfoKHR; +-- +-- +data VkImportSemaphoreFdInfoKHR = VkImportSemaphoreFdInfoKHR## Addr## + ByteArray## + +instance Eq VkImportSemaphoreFdInfoKHR where + (VkImportSemaphoreFdInfoKHR## a _) == + x@(VkImportSemaphoreFdInfoKHR## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkImportSemaphoreFdInfoKHR where + (VkImportSemaphoreFdInfoKHR## a _) `compare` + x@(VkImportSemaphoreFdInfoKHR## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkImportSemaphoreFdInfoKHR where + sizeOf ~_ = #{size VkImportSemaphoreFdInfoKHR} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkImportSemaphoreFdInfoKHR} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkImportSemaphoreFdInfoKHR where + unsafeAddr (VkImportSemaphoreFdInfoKHR## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkImportSemaphoreFdInfoKHR## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkImportSemaphoreFdInfoKHR## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkImportSemaphoreFdInfoKHR where + type StructFields VkImportSemaphoreFdInfoKHR = + '["sType", "pNext", "semaphore", "flags", "handleType", "fd"] -- ' closing tick for hsc2hs + type CUnionType VkImportSemaphoreFdInfoKHR = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkImportSemaphoreFdInfoKHR = 'False -- ' closing tick for hsc2hs + type StructExtends VkImportSemaphoreFdInfoKHR = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkSType VkImportSemaphoreFdInfoKHR + where + type VkSTypeMType VkImportSemaphoreFdInfoKHR = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImportSemaphoreFdInfoKHR, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkImportSemaphoreFdInfoKHR, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkImportSemaphoreFdInfoKHR, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkImportSemaphoreFdInfoKHR, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkImportSemaphoreFdInfoKHR where + type FieldType "sType" VkImportSemaphoreFdInfoKHR = VkStructureType + type FieldOptional "sType" VkImportSemaphoreFdInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkImportSemaphoreFdInfoKHR = + #{offset VkImportSemaphoreFdInfoKHR, sType} + type FieldIsArray "sType" VkImportSemaphoreFdInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkImportSemaphoreFdInfoKHR, sType} + +instance CanReadField "sType" VkImportSemaphoreFdInfoKHR where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkImportSemaphoreFdInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} HasVkPNext VkImportSemaphoreFdInfoKHR + where + type VkPNextMType VkImportSemaphoreFdInfoKHR = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImportSemaphoreFdInfoKHR, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkImportSemaphoreFdInfoKHR, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkImportSemaphoreFdInfoKHR, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkImportSemaphoreFdInfoKHR, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkImportSemaphoreFdInfoKHR where + type FieldType "pNext" VkImportSemaphoreFdInfoKHR = Ptr Void + type FieldOptional "pNext" VkImportSemaphoreFdInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkImportSemaphoreFdInfoKHR = + #{offset VkImportSemaphoreFdInfoKHR, pNext} + type FieldIsArray "pNext" VkImportSemaphoreFdInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkImportSemaphoreFdInfoKHR, pNext} + +instance CanReadField "pNext" VkImportSemaphoreFdInfoKHR where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkImportSemaphoreFdInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkSemaphore VkImportSemaphoreFdInfoKHR where + type VkSemaphoreMType VkImportSemaphoreFdInfoKHR = VkSemaphore + + {-# NOINLINE vkSemaphore #-} + vkSemaphore x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImportSemaphoreFdInfoKHR, semaphore}) + + {-# INLINE vkSemaphoreByteOffset #-} + vkSemaphoreByteOffset ~_ + = #{offset VkImportSemaphoreFdInfoKHR, semaphore} + + {-# INLINE readVkSemaphore #-} + readVkSemaphore p + = peekByteOff p #{offset VkImportSemaphoreFdInfoKHR, semaphore} + + {-# INLINE writeVkSemaphore #-} + writeVkSemaphore p + = pokeByteOff p #{offset VkImportSemaphoreFdInfoKHR, semaphore} + +instance {-# OVERLAPPING #-} + HasField "semaphore" VkImportSemaphoreFdInfoKHR where + type FieldType "semaphore" VkImportSemaphoreFdInfoKHR = VkSemaphore + type FieldOptional "semaphore" VkImportSemaphoreFdInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "semaphore" VkImportSemaphoreFdInfoKHR = + #{offset VkImportSemaphoreFdInfoKHR, semaphore} + type FieldIsArray "semaphore" VkImportSemaphoreFdInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkImportSemaphoreFdInfoKHR, semaphore} + +instance CanReadField "semaphore" VkImportSemaphoreFdInfoKHR where + {-# INLINE getField #-} + getField = vkSemaphore + + {-# INLINE readField #-} + readField = readVkSemaphore + +instance CanWriteField "semaphore" VkImportSemaphoreFdInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkSemaphore + +instance {-# OVERLAPPING #-} HasVkFlags VkImportSemaphoreFdInfoKHR + where + type VkFlagsMType VkImportSemaphoreFdInfoKHR = + VkSemaphoreImportFlagsKHR + + {-# NOINLINE vkFlags #-} + vkFlags x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImportSemaphoreFdInfoKHR, flags}) + + {-# INLINE vkFlagsByteOffset #-} + vkFlagsByteOffset ~_ + = #{offset VkImportSemaphoreFdInfoKHR, flags} + + {-# INLINE readVkFlags #-} + readVkFlags p + = peekByteOff p #{offset VkImportSemaphoreFdInfoKHR, flags} + + {-# INLINE writeVkFlags #-} + writeVkFlags p + = pokeByteOff p #{offset VkImportSemaphoreFdInfoKHR, flags} + +instance {-# OVERLAPPING #-} + HasField "flags" VkImportSemaphoreFdInfoKHR where + type FieldType "flags" VkImportSemaphoreFdInfoKHR = + VkSemaphoreImportFlagsKHR + type FieldOptional "flags" VkImportSemaphoreFdInfoKHR = 'True -- ' closing tick for hsc2hs + type FieldOffset "flags" VkImportSemaphoreFdInfoKHR = + #{offset VkImportSemaphoreFdInfoKHR, flags} + type FieldIsArray "flags" VkImportSemaphoreFdInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkImportSemaphoreFdInfoKHR, flags} + +instance CanReadField "flags" VkImportSemaphoreFdInfoKHR where + {-# INLINE getField #-} + getField = vkFlags + + {-# INLINE readField #-} + readField = readVkFlags + +instance CanWriteField "flags" VkImportSemaphoreFdInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkFlags + +instance {-# OVERLAPPING #-} + HasVkHandleType VkImportSemaphoreFdInfoKHR where + type VkHandleTypeMType VkImportSemaphoreFdInfoKHR = + VkExternalSemaphoreHandleTypeFlagBitsKHR + + {-# NOINLINE vkHandleType #-} + vkHandleType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImportSemaphoreFdInfoKHR, handleType}) + + {-# INLINE vkHandleTypeByteOffset #-} + vkHandleTypeByteOffset ~_ + = #{offset VkImportSemaphoreFdInfoKHR, handleType} + + {-# INLINE readVkHandleType #-} + readVkHandleType p + = peekByteOff p #{offset VkImportSemaphoreFdInfoKHR, handleType} + + {-# INLINE writeVkHandleType #-} + writeVkHandleType p + = pokeByteOff p #{offset VkImportSemaphoreFdInfoKHR, handleType} + +instance {-# OVERLAPPING #-} + HasField "handleType" VkImportSemaphoreFdInfoKHR where + type FieldType "handleType" VkImportSemaphoreFdInfoKHR = + VkExternalSemaphoreHandleTypeFlagBitsKHR + type FieldOptional "handleType" VkImportSemaphoreFdInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "handleType" VkImportSemaphoreFdInfoKHR = + #{offset VkImportSemaphoreFdInfoKHR, handleType} + type FieldIsArray "handleType" VkImportSemaphoreFdInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkImportSemaphoreFdInfoKHR, handleType} + +instance CanReadField "handleType" VkImportSemaphoreFdInfoKHR where + {-# INLINE getField #-} + getField = vkHandleType + + {-# INLINE readField #-} + readField = readVkHandleType + +instance CanWriteField "handleType" VkImportSemaphoreFdInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkHandleType + +instance {-# OVERLAPPING #-} HasVkFd VkImportSemaphoreFdInfoKHR + where + type VkFdMType VkImportSemaphoreFdInfoKHR = CInt + + {-# NOINLINE vkFd #-} + vkFd x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImportSemaphoreFdInfoKHR, fd}) + + {-# INLINE vkFdByteOffset #-} + vkFdByteOffset ~_ + = #{offset VkImportSemaphoreFdInfoKHR, fd} + + {-# INLINE readVkFd #-} + readVkFd p + = peekByteOff p #{offset VkImportSemaphoreFdInfoKHR, fd} + + {-# INLINE writeVkFd #-} + writeVkFd p + = pokeByteOff p #{offset VkImportSemaphoreFdInfoKHR, fd} + +instance {-# OVERLAPPING #-} + HasField "fd" VkImportSemaphoreFdInfoKHR where + type FieldType "fd" VkImportSemaphoreFdInfoKHR = CInt + type FieldOptional "fd" VkImportSemaphoreFdInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "fd" VkImportSemaphoreFdInfoKHR = + #{offset VkImportSemaphoreFdInfoKHR, fd} + type FieldIsArray "fd" VkImportSemaphoreFdInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkImportSemaphoreFdInfoKHR, fd} + +instance CanReadField "fd" VkImportSemaphoreFdInfoKHR where + {-# INLINE getField #-} + getField = vkFd + + {-# INLINE readField #-} + readField = readVkFd + +instance CanWriteField "fd" VkImportSemaphoreFdInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkFd + +instance Show VkImportSemaphoreFdInfoKHR where + showsPrec d x + = showString "VkImportSemaphoreFdInfoKHR {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkSemaphore = " . + showsPrec d (vkSemaphore x) . + showString ", " . + showString "vkFlags = " . + showsPrec d (vkFlags x) . + showString ", " . + showString "vkHandleType = " . + showsPrec d (vkHandleType x) . + showString ", " . + showString "vkFd = " . + showsPrec d (vkFd x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkImportSemaphoreWin32HandleInfoKHR.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkImportSemaphoreWin32HandleInfoKHR.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkImportSemaphoreWin32HandleInfoKHR.hsc @@ -0,0 +1,490 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkImportSemaphoreWin32HandleInfoKHR + (VkImportSemaphoreWin32HandleInfoKHR(..)) where +import Foreign.Storable + (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkExternalSemaphoreHandleTypeFlagsKHR + (VkExternalSemaphoreHandleTypeFlagBitsKHR) +import Graphics.Vulkan.Types.Enum.VkSemaphoreImportFlagsKHR + (VkSemaphoreImportFlagsKHR) +import Graphics.Vulkan.Types.Enum.VkStructureType + (VkStructureType) +import Graphics.Vulkan.Types.Handles + (VkSemaphore) +import Graphics.Vulkan.Types.Include + (HANDLE, + LPCWSTR) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe + (unsafeDupablePerformIO) + +-- | > typedef struct VkImportSemaphoreWin32HandleInfoKHR { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkSemaphore semaphore; +-- > VkSemaphoreImportFlagsKHR flags; +-- > VkExternalSemaphoreHandleTypeFlagBitsKHR handleType; +-- > HANDLE handle; +-- > LPCWSTR name; +-- > } VkImportSemaphoreWin32HandleInfoKHR; +-- +-- +data VkImportSemaphoreWin32HandleInfoKHR = VkImportSemaphoreWin32HandleInfoKHR## Addr## + ByteArray## + +instance Eq VkImportSemaphoreWin32HandleInfoKHR where + (VkImportSemaphoreWin32HandleInfoKHR## a _) == + x@(VkImportSemaphoreWin32HandleInfoKHR## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkImportSemaphoreWin32HandleInfoKHR where + (VkImportSemaphoreWin32HandleInfoKHR## a _) `compare` + x@(VkImportSemaphoreWin32HandleInfoKHR## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkImportSemaphoreWin32HandleInfoKHR where + sizeOf ~_ = #{size VkImportSemaphoreWin32HandleInfoKHR} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkImportSemaphoreWin32HandleInfoKHR} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkImportSemaphoreWin32HandleInfoKHR + where + unsafeAddr (VkImportSemaphoreWin32HandleInfoKHR## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkImportSemaphoreWin32HandleInfoKHR## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkImportSemaphoreWin32HandleInfoKHR## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkImportSemaphoreWin32HandleInfoKHR where + type StructFields VkImportSemaphoreWin32HandleInfoKHR = + '["sType", "pNext", "semaphore", "flags", "handleType", "handle", -- ' closing tick for hsc2hs + "name"] + type CUnionType VkImportSemaphoreWin32HandleInfoKHR = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkImportSemaphoreWin32HandleInfoKHR = 'False -- ' closing tick for hsc2hs + type StructExtends VkImportSemaphoreWin32HandleInfoKHR = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkImportSemaphoreWin32HandleInfoKHR where + type VkSTypeMType VkImportSemaphoreWin32HandleInfoKHR = + VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImportSemaphoreWin32HandleInfoKHR, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkImportSemaphoreWin32HandleInfoKHR, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkImportSemaphoreWin32HandleInfoKHR, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkImportSemaphoreWin32HandleInfoKHR, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkImportSemaphoreWin32HandleInfoKHR where + type FieldType "sType" VkImportSemaphoreWin32HandleInfoKHR = + VkStructureType + type FieldOptional "sType" VkImportSemaphoreWin32HandleInfoKHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkImportSemaphoreWin32HandleInfoKHR = + #{offset VkImportSemaphoreWin32HandleInfoKHR, sType} + type FieldIsArray "sType" VkImportSemaphoreWin32HandleInfoKHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkImportSemaphoreWin32HandleInfoKHR, sType} + +instance CanReadField "sType" VkImportSemaphoreWin32HandleInfoKHR + where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkImportSemaphoreWin32HandleInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkImportSemaphoreWin32HandleInfoKHR where + type VkPNextMType VkImportSemaphoreWin32HandleInfoKHR = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImportSemaphoreWin32HandleInfoKHR, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkImportSemaphoreWin32HandleInfoKHR, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkImportSemaphoreWin32HandleInfoKHR, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkImportSemaphoreWin32HandleInfoKHR, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkImportSemaphoreWin32HandleInfoKHR where + type FieldType "pNext" VkImportSemaphoreWin32HandleInfoKHR = + Ptr Void + type FieldOptional "pNext" VkImportSemaphoreWin32HandleInfoKHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkImportSemaphoreWin32HandleInfoKHR = + #{offset VkImportSemaphoreWin32HandleInfoKHR, pNext} + type FieldIsArray "pNext" VkImportSemaphoreWin32HandleInfoKHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkImportSemaphoreWin32HandleInfoKHR, pNext} + +instance CanReadField "pNext" VkImportSemaphoreWin32HandleInfoKHR + where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkImportSemaphoreWin32HandleInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkSemaphore VkImportSemaphoreWin32HandleInfoKHR where + type VkSemaphoreMType VkImportSemaphoreWin32HandleInfoKHR = + VkSemaphore + + {-# NOINLINE vkSemaphore #-} + vkSemaphore x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImportSemaphoreWin32HandleInfoKHR, semaphore}) + + {-# INLINE vkSemaphoreByteOffset #-} + vkSemaphoreByteOffset ~_ + = #{offset VkImportSemaphoreWin32HandleInfoKHR, semaphore} + + {-# INLINE readVkSemaphore #-} + readVkSemaphore p + = peekByteOff p #{offset VkImportSemaphoreWin32HandleInfoKHR, semaphore} + + {-# INLINE writeVkSemaphore #-} + writeVkSemaphore p + = pokeByteOff p #{offset VkImportSemaphoreWin32HandleInfoKHR, semaphore} + +instance {-# OVERLAPPING #-} + HasField "semaphore" VkImportSemaphoreWin32HandleInfoKHR where + type FieldType "semaphore" VkImportSemaphoreWin32HandleInfoKHR = + VkSemaphore + type FieldOptional "semaphore" VkImportSemaphoreWin32HandleInfoKHR + = 'False -- ' closing tick for hsc2hs + type FieldOffset "semaphore" VkImportSemaphoreWin32HandleInfoKHR = + #{offset VkImportSemaphoreWin32HandleInfoKHR, semaphore} + type FieldIsArray "semaphore" VkImportSemaphoreWin32HandleInfoKHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkImportSemaphoreWin32HandleInfoKHR, semaphore} + +instance CanReadField "semaphore" + VkImportSemaphoreWin32HandleInfoKHR + where + {-# INLINE getField #-} + getField = vkSemaphore + + {-# INLINE readField #-} + readField = readVkSemaphore + +instance CanWriteField "semaphore" + VkImportSemaphoreWin32HandleInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkSemaphore + +instance {-# OVERLAPPING #-} + HasVkFlags VkImportSemaphoreWin32HandleInfoKHR where + type VkFlagsMType VkImportSemaphoreWin32HandleInfoKHR = + VkSemaphoreImportFlagsKHR + + {-# NOINLINE vkFlags #-} + vkFlags x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImportSemaphoreWin32HandleInfoKHR, flags}) + + {-# INLINE vkFlagsByteOffset #-} + vkFlagsByteOffset ~_ + = #{offset VkImportSemaphoreWin32HandleInfoKHR, flags} + + {-# INLINE readVkFlags #-} + readVkFlags p + = peekByteOff p #{offset VkImportSemaphoreWin32HandleInfoKHR, flags} + + {-# INLINE writeVkFlags #-} + writeVkFlags p + = pokeByteOff p #{offset VkImportSemaphoreWin32HandleInfoKHR, flags} + +instance {-# OVERLAPPING #-} + HasField "flags" VkImportSemaphoreWin32HandleInfoKHR where + type FieldType "flags" VkImportSemaphoreWin32HandleInfoKHR = + VkSemaphoreImportFlagsKHR + type FieldOptional "flags" VkImportSemaphoreWin32HandleInfoKHR = + 'True -- ' closing tick for hsc2hs + type FieldOffset "flags" VkImportSemaphoreWin32HandleInfoKHR = + #{offset VkImportSemaphoreWin32HandleInfoKHR, flags} + type FieldIsArray "flags" VkImportSemaphoreWin32HandleInfoKHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkImportSemaphoreWin32HandleInfoKHR, flags} + +instance CanReadField "flags" VkImportSemaphoreWin32HandleInfoKHR + where + {-# INLINE getField #-} + getField = vkFlags + + {-# INLINE readField #-} + readField = readVkFlags + +instance CanWriteField "flags" VkImportSemaphoreWin32HandleInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkFlags + +instance {-# OVERLAPPING #-} + HasVkHandleType VkImportSemaphoreWin32HandleInfoKHR where + type VkHandleTypeMType VkImportSemaphoreWin32HandleInfoKHR = + VkExternalSemaphoreHandleTypeFlagBitsKHR + + {-# NOINLINE vkHandleType #-} + vkHandleType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImportSemaphoreWin32HandleInfoKHR, handleType}) + + {-# INLINE vkHandleTypeByteOffset #-} + vkHandleTypeByteOffset ~_ + = #{offset VkImportSemaphoreWin32HandleInfoKHR, handleType} + + {-# INLINE readVkHandleType #-} + readVkHandleType p + = peekByteOff p #{offset VkImportSemaphoreWin32HandleInfoKHR, handleType} + + {-# INLINE writeVkHandleType #-} + writeVkHandleType p + = pokeByteOff p #{offset VkImportSemaphoreWin32HandleInfoKHR, handleType} + +instance {-# OVERLAPPING #-} + HasField "handleType" VkImportSemaphoreWin32HandleInfoKHR where + type FieldType "handleType" VkImportSemaphoreWin32HandleInfoKHR = + VkExternalSemaphoreHandleTypeFlagBitsKHR + type FieldOptional "handleType" VkImportSemaphoreWin32HandleInfoKHR + = 'True -- ' closing tick for hsc2hs + type FieldOffset "handleType" VkImportSemaphoreWin32HandleInfoKHR = + #{offset VkImportSemaphoreWin32HandleInfoKHR, handleType} + type FieldIsArray "handleType" VkImportSemaphoreWin32HandleInfoKHR + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkImportSemaphoreWin32HandleInfoKHR, handleType} + +instance CanReadField "handleType" + VkImportSemaphoreWin32HandleInfoKHR + where + {-# INLINE getField #-} + getField = vkHandleType + + {-# INLINE readField #-} + readField = readVkHandleType + +instance CanWriteField "handleType" + VkImportSemaphoreWin32HandleInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkHandleType + +instance {-# OVERLAPPING #-} + HasVkHandle VkImportSemaphoreWin32HandleInfoKHR where + type VkHandleMType VkImportSemaphoreWin32HandleInfoKHR = HANDLE + + {-# NOINLINE vkHandle #-} + vkHandle x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImportSemaphoreWin32HandleInfoKHR, handle}) + + {-# INLINE vkHandleByteOffset #-} + vkHandleByteOffset ~_ + = #{offset VkImportSemaphoreWin32HandleInfoKHR, handle} + + {-# INLINE readVkHandle #-} + readVkHandle p + = peekByteOff p #{offset VkImportSemaphoreWin32HandleInfoKHR, handle} + + {-# INLINE writeVkHandle #-} + writeVkHandle p + = pokeByteOff p #{offset VkImportSemaphoreWin32HandleInfoKHR, handle} + +instance {-# OVERLAPPING #-} + HasField "handle" VkImportSemaphoreWin32HandleInfoKHR where + type FieldType "handle" VkImportSemaphoreWin32HandleInfoKHR = + HANDLE + type FieldOptional "handle" VkImportSemaphoreWin32HandleInfoKHR = + 'True -- ' closing tick for hsc2hs + type FieldOffset "handle" VkImportSemaphoreWin32HandleInfoKHR = + #{offset VkImportSemaphoreWin32HandleInfoKHR, handle} + type FieldIsArray "handle" VkImportSemaphoreWin32HandleInfoKHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkImportSemaphoreWin32HandleInfoKHR, handle} + +instance CanReadField "handle" VkImportSemaphoreWin32HandleInfoKHR + where + {-# INLINE getField #-} + getField = vkHandle + + {-# INLINE readField #-} + readField = readVkHandle + +instance CanWriteField "handle" VkImportSemaphoreWin32HandleInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkHandle + +instance {-# OVERLAPPING #-} + HasVkName VkImportSemaphoreWin32HandleInfoKHR where + type VkNameMType VkImportSemaphoreWin32HandleInfoKHR = LPCWSTR + + {-# NOINLINE vkName #-} + vkName x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkImportSemaphoreWin32HandleInfoKHR, name}) + + {-# INLINE vkNameByteOffset #-} + vkNameByteOffset ~_ + = #{offset VkImportSemaphoreWin32HandleInfoKHR, name} + + {-# INLINE readVkName #-} + readVkName p + = peekByteOff p #{offset VkImportSemaphoreWin32HandleInfoKHR, name} + + {-# INLINE writeVkName #-} + writeVkName p + = pokeByteOff p #{offset VkImportSemaphoreWin32HandleInfoKHR, name} + +instance {-# OVERLAPPING #-} + HasField "name" VkImportSemaphoreWin32HandleInfoKHR where + type FieldType "name" VkImportSemaphoreWin32HandleInfoKHR = LPCWSTR + type FieldOptional "name" VkImportSemaphoreWin32HandleInfoKHR = + 'True -- ' closing tick for hsc2hs + type FieldOffset "name" VkImportSemaphoreWin32HandleInfoKHR = + #{offset VkImportSemaphoreWin32HandleInfoKHR, name} + type FieldIsArray "name" VkImportSemaphoreWin32HandleInfoKHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkImportSemaphoreWin32HandleInfoKHR, name} + +instance CanReadField "name" VkImportSemaphoreWin32HandleInfoKHR + where + {-# INLINE getField #-} + getField = vkName + + {-# INLINE readField #-} + readField = readVkName + +instance CanWriteField "name" VkImportSemaphoreWin32HandleInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkName + +instance Show VkImportSemaphoreWin32HandleInfoKHR where + showsPrec d x + = showString "VkImportSemaphoreWin32HandleInfoKHR {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkSemaphore = " . + showsPrec d (vkSemaphore x) . + showString ", " . + showString "vkFlags = " . + showsPrec d (vkFlags x) . + showString ", " . + showString "vkHandleType = " . + showsPrec d (vkHandleType x) . + showString ", " . + showString "vkHandle = " . + showsPrec d (vkHandle x) . + showString ", " . + showString "vkName = " . + showsPrec d (vkName x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkIndirectCommandsLayoutCreateInfoNVX.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkIndirectCommandsLayoutCreateInfoNVX.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkIndirectCommandsLayoutCreateInfoNVX.hsc @@ -0,0 +1,448 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkIndirectCommandsLayoutCreateInfoNVX + (VkIndirectCommandsLayoutCreateInfoNVX(..)) where +import Foreign.Storable + (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkIndirectCommandsLayoutUsageFlagsNVX + (VkIndirectCommandsLayoutUsageFlagsNVX) +import Graphics.Vulkan.Types.Enum.VkPipelineBindPoint + (VkPipelineBindPoint) +import Graphics.Vulkan.Types.Enum.VkStructureType + (VkStructureType) +import Graphics.Vulkan.Types.Struct.VkIndirectCommandsLayoutTokenNVX + (VkIndirectCommandsLayoutTokenNVX) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe + (unsafeDupablePerformIO) + +-- | > typedef struct VkIndirectCommandsLayoutCreateInfoNVX { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkPipelineBindPoint pipelineBindPoint; +-- > VkIndirectCommandsLayoutUsageFlagsNVX flags; +-- > uint32_t tokenCount; +-- > const VkIndirectCommandsLayoutTokenNVX* pTokens; +-- > } VkIndirectCommandsLayoutCreateInfoNVX; +-- +-- +data VkIndirectCommandsLayoutCreateInfoNVX = VkIndirectCommandsLayoutCreateInfoNVX## Addr## + ByteArray## + +instance Eq VkIndirectCommandsLayoutCreateInfoNVX where + (VkIndirectCommandsLayoutCreateInfoNVX## a _) == + x@(VkIndirectCommandsLayoutCreateInfoNVX## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkIndirectCommandsLayoutCreateInfoNVX where + (VkIndirectCommandsLayoutCreateInfoNVX## a _) `compare` + x@(VkIndirectCommandsLayoutCreateInfoNVX## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkIndirectCommandsLayoutCreateInfoNVX where + sizeOf ~_ + = #{size VkIndirectCommandsLayoutCreateInfoNVX} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkIndirectCommandsLayoutCreateInfoNVX} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkIndirectCommandsLayoutCreateInfoNVX + where + unsafeAddr (VkIndirectCommandsLayoutCreateInfoNVX## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkIndirectCommandsLayoutCreateInfoNVX## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkIndirectCommandsLayoutCreateInfoNVX## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkIndirectCommandsLayoutCreateInfoNVX where + type StructFields VkIndirectCommandsLayoutCreateInfoNVX = + '["sType", "pNext", "pipelineBindPoint", "flags", "tokenCount", -- ' closing tick for hsc2hs + "pTokens"] + type CUnionType VkIndirectCommandsLayoutCreateInfoNVX = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkIndirectCommandsLayoutCreateInfoNVX = 'False -- ' closing tick for hsc2hs + type StructExtends VkIndirectCommandsLayoutCreateInfoNVX = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkIndirectCommandsLayoutCreateInfoNVX where + type VkSTypeMType VkIndirectCommandsLayoutCreateInfoNVX = + VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkIndirectCommandsLayoutCreateInfoNVX, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkIndirectCommandsLayoutCreateInfoNVX, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkIndirectCommandsLayoutCreateInfoNVX, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkIndirectCommandsLayoutCreateInfoNVX, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkIndirectCommandsLayoutCreateInfoNVX where + type FieldType "sType" VkIndirectCommandsLayoutCreateInfoNVX = + VkStructureType + type FieldOptional "sType" VkIndirectCommandsLayoutCreateInfoNVX = + 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkIndirectCommandsLayoutCreateInfoNVX = + #{offset VkIndirectCommandsLayoutCreateInfoNVX, sType} + type FieldIsArray "sType" VkIndirectCommandsLayoutCreateInfoNVX = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkIndirectCommandsLayoutCreateInfoNVX, sType} + +instance CanReadField "sType" VkIndirectCommandsLayoutCreateInfoNVX + where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" + VkIndirectCommandsLayoutCreateInfoNVX + where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkIndirectCommandsLayoutCreateInfoNVX where + type VkPNextMType VkIndirectCommandsLayoutCreateInfoNVX = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkIndirectCommandsLayoutCreateInfoNVX, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkIndirectCommandsLayoutCreateInfoNVX, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkIndirectCommandsLayoutCreateInfoNVX, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkIndirectCommandsLayoutCreateInfoNVX, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkIndirectCommandsLayoutCreateInfoNVX where + type FieldType "pNext" VkIndirectCommandsLayoutCreateInfoNVX = + Ptr Void + type FieldOptional "pNext" VkIndirectCommandsLayoutCreateInfoNVX = + 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkIndirectCommandsLayoutCreateInfoNVX = + #{offset VkIndirectCommandsLayoutCreateInfoNVX, pNext} + type FieldIsArray "pNext" VkIndirectCommandsLayoutCreateInfoNVX = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkIndirectCommandsLayoutCreateInfoNVX, pNext} + +instance CanReadField "pNext" VkIndirectCommandsLayoutCreateInfoNVX + where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" + VkIndirectCommandsLayoutCreateInfoNVX + where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkPipelineBindPoint VkIndirectCommandsLayoutCreateInfoNVX where + type VkPipelineBindPointMType VkIndirectCommandsLayoutCreateInfoNVX + = VkPipelineBindPoint + + {-# NOINLINE vkPipelineBindPoint #-} + vkPipelineBindPoint x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkIndirectCommandsLayoutCreateInfoNVX, pipelineBindPoint}) + + {-# INLINE vkPipelineBindPointByteOffset #-} + vkPipelineBindPointByteOffset ~_ + = #{offset VkIndirectCommandsLayoutCreateInfoNVX, pipelineBindPoint} + + {-# INLINE readVkPipelineBindPoint #-} + readVkPipelineBindPoint p + = peekByteOff p #{offset VkIndirectCommandsLayoutCreateInfoNVX, pipelineBindPoint} + + {-# INLINE writeVkPipelineBindPoint #-} + writeVkPipelineBindPoint p + = pokeByteOff p #{offset VkIndirectCommandsLayoutCreateInfoNVX, pipelineBindPoint} + +instance {-# OVERLAPPING #-} + HasField "pipelineBindPoint" VkIndirectCommandsLayoutCreateInfoNVX + where + type FieldType "pipelineBindPoint" + VkIndirectCommandsLayoutCreateInfoNVX + = VkPipelineBindPoint + type FieldOptional "pipelineBindPoint" + VkIndirectCommandsLayoutCreateInfoNVX + = 'False -- ' closing tick for hsc2hs + type FieldOffset "pipelineBindPoint" + VkIndirectCommandsLayoutCreateInfoNVX + = + #{offset VkIndirectCommandsLayoutCreateInfoNVX, pipelineBindPoint} + type FieldIsArray "pipelineBindPoint" + VkIndirectCommandsLayoutCreateInfoNVX + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkIndirectCommandsLayoutCreateInfoNVX, pipelineBindPoint} + +instance CanReadField "pipelineBindPoint" + VkIndirectCommandsLayoutCreateInfoNVX + where + {-# INLINE getField #-} + getField = vkPipelineBindPoint + + {-# INLINE readField #-} + readField = readVkPipelineBindPoint + +instance CanWriteField "pipelineBindPoint" + VkIndirectCommandsLayoutCreateInfoNVX + where + {-# INLINE writeField #-} + writeField = writeVkPipelineBindPoint + +instance {-# OVERLAPPING #-} + HasVkFlags VkIndirectCommandsLayoutCreateInfoNVX where + type VkFlagsMType VkIndirectCommandsLayoutCreateInfoNVX = + VkIndirectCommandsLayoutUsageFlagsNVX + + {-# NOINLINE vkFlags #-} + vkFlags x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkIndirectCommandsLayoutCreateInfoNVX, flags}) + + {-# INLINE vkFlagsByteOffset #-} + vkFlagsByteOffset ~_ + = #{offset VkIndirectCommandsLayoutCreateInfoNVX, flags} + + {-# INLINE readVkFlags #-} + readVkFlags p + = peekByteOff p #{offset VkIndirectCommandsLayoutCreateInfoNVX, flags} + + {-# INLINE writeVkFlags #-} + writeVkFlags p + = pokeByteOff p #{offset VkIndirectCommandsLayoutCreateInfoNVX, flags} + +instance {-# OVERLAPPING #-} + HasField "flags" VkIndirectCommandsLayoutCreateInfoNVX where + type FieldType "flags" VkIndirectCommandsLayoutCreateInfoNVX = + VkIndirectCommandsLayoutUsageFlagsNVX + type FieldOptional "flags" VkIndirectCommandsLayoutCreateInfoNVX = + 'False -- ' closing tick for hsc2hs + type FieldOffset "flags" VkIndirectCommandsLayoutCreateInfoNVX = + #{offset VkIndirectCommandsLayoutCreateInfoNVX, flags} + type FieldIsArray "flags" VkIndirectCommandsLayoutCreateInfoNVX = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkIndirectCommandsLayoutCreateInfoNVX, flags} + +instance CanReadField "flags" VkIndirectCommandsLayoutCreateInfoNVX + where + {-# INLINE getField #-} + getField = vkFlags + + {-# INLINE readField #-} + readField = readVkFlags + +instance CanWriteField "flags" + VkIndirectCommandsLayoutCreateInfoNVX + where + {-# INLINE writeField #-} + writeField = writeVkFlags + +instance {-# OVERLAPPING #-} + HasVkTokenCount VkIndirectCommandsLayoutCreateInfoNVX where + type VkTokenCountMType VkIndirectCommandsLayoutCreateInfoNVX = + Word32 + + {-# NOINLINE vkTokenCount #-} + vkTokenCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkIndirectCommandsLayoutCreateInfoNVX, tokenCount}) + + {-# INLINE vkTokenCountByteOffset #-} + vkTokenCountByteOffset ~_ + = #{offset VkIndirectCommandsLayoutCreateInfoNVX, tokenCount} + + {-# INLINE readVkTokenCount #-} + readVkTokenCount p + = peekByteOff p #{offset VkIndirectCommandsLayoutCreateInfoNVX, tokenCount} + + {-# INLINE writeVkTokenCount #-} + writeVkTokenCount p + = pokeByteOff p #{offset VkIndirectCommandsLayoutCreateInfoNVX, tokenCount} + +instance {-# OVERLAPPING #-} + HasField "tokenCount" VkIndirectCommandsLayoutCreateInfoNVX where + type FieldType "tokenCount" VkIndirectCommandsLayoutCreateInfoNVX = + Word32 + type FieldOptional "tokenCount" + VkIndirectCommandsLayoutCreateInfoNVX + = 'False -- ' closing tick for hsc2hs + type FieldOffset "tokenCount" VkIndirectCommandsLayoutCreateInfoNVX + = + #{offset VkIndirectCommandsLayoutCreateInfoNVX, tokenCount} + type FieldIsArray "tokenCount" + VkIndirectCommandsLayoutCreateInfoNVX + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkIndirectCommandsLayoutCreateInfoNVX, tokenCount} + +instance CanReadField "tokenCount" + VkIndirectCommandsLayoutCreateInfoNVX + where + {-# INLINE getField #-} + getField = vkTokenCount + + {-# INLINE readField #-} + readField = readVkTokenCount + +instance CanWriteField "tokenCount" + VkIndirectCommandsLayoutCreateInfoNVX + where + {-# INLINE writeField #-} + writeField = writeVkTokenCount + +instance {-# OVERLAPPING #-} + HasVkPTokens VkIndirectCommandsLayoutCreateInfoNVX where + type VkPTokensMType VkIndirectCommandsLayoutCreateInfoNVX = + Ptr VkIndirectCommandsLayoutTokenNVX + + {-# NOINLINE vkPTokens #-} + vkPTokens x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkIndirectCommandsLayoutCreateInfoNVX, pTokens}) + + {-# INLINE vkPTokensByteOffset #-} + vkPTokensByteOffset ~_ + = #{offset VkIndirectCommandsLayoutCreateInfoNVX, pTokens} + + {-# INLINE readVkPTokens #-} + readVkPTokens p + = peekByteOff p #{offset VkIndirectCommandsLayoutCreateInfoNVX, pTokens} + + {-# INLINE writeVkPTokens #-} + writeVkPTokens p + = pokeByteOff p #{offset VkIndirectCommandsLayoutCreateInfoNVX, pTokens} + +instance {-# OVERLAPPING #-} + HasField "pTokens" VkIndirectCommandsLayoutCreateInfoNVX where + type FieldType "pTokens" VkIndirectCommandsLayoutCreateInfoNVX = + Ptr VkIndirectCommandsLayoutTokenNVX + type FieldOptional "pTokens" VkIndirectCommandsLayoutCreateInfoNVX + = 'False -- ' closing tick for hsc2hs + type FieldOffset "pTokens" VkIndirectCommandsLayoutCreateInfoNVX = + #{offset VkIndirectCommandsLayoutCreateInfoNVX, pTokens} + type FieldIsArray "pTokens" VkIndirectCommandsLayoutCreateInfoNVX = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkIndirectCommandsLayoutCreateInfoNVX, pTokens} + +instance CanReadField "pTokens" + VkIndirectCommandsLayoutCreateInfoNVX + where + {-# INLINE getField #-} + getField = vkPTokens + + {-# INLINE readField #-} + readField = readVkPTokens + +instance CanWriteField "pTokens" + VkIndirectCommandsLayoutCreateInfoNVX + where + {-# INLINE writeField #-} + writeField = writeVkPTokens + +instance Show VkIndirectCommandsLayoutCreateInfoNVX where + showsPrec d x + = showString "VkIndirectCommandsLayoutCreateInfoNVX {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkPipelineBindPoint = " . + showsPrec d (vkPipelineBindPoint x) . + showString ", " . + showString "vkFlags = " . + showsPrec d (vkFlags x) . + showString ", " . + showString "vkTokenCount = " . + showsPrec d (vkTokenCount x) . + showString ", " . + showString "vkPTokens = " . + showsPrec d (vkPTokens x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkIndirectCommandsLayoutTokenNVX.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkIndirectCommandsLayoutTokenNVX.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkIndirectCommandsLayoutTokenNVX.hsc @@ -0,0 +1,305 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkIndirectCommandsLayoutTokenNVX + (VkIndirectCommandsLayoutTokenNVX(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkIndirectCommandsTokenTypeNVX (VkIndirectCommandsTokenTypeNVX) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkIndirectCommandsLayoutTokenNVX { +-- > VkIndirectCommandsTokenTypeNVX tokenType; +-- > uint32_t bindingUnit; +-- > uint32_t dynamicCount; +-- > uint32_t divisor; +-- > } VkIndirectCommandsLayoutTokenNVX; +-- +-- +data VkIndirectCommandsLayoutTokenNVX = VkIndirectCommandsLayoutTokenNVX## Addr## + ByteArray## + +instance Eq VkIndirectCommandsLayoutTokenNVX where + (VkIndirectCommandsLayoutTokenNVX## a _) == + x@(VkIndirectCommandsLayoutTokenNVX## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkIndirectCommandsLayoutTokenNVX where + (VkIndirectCommandsLayoutTokenNVX## a _) `compare` + x@(VkIndirectCommandsLayoutTokenNVX## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkIndirectCommandsLayoutTokenNVX where + sizeOf ~_ = #{size VkIndirectCommandsLayoutTokenNVX} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkIndirectCommandsLayoutTokenNVX} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkIndirectCommandsLayoutTokenNVX where + unsafeAddr (VkIndirectCommandsLayoutTokenNVX## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkIndirectCommandsLayoutTokenNVX## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkIndirectCommandsLayoutTokenNVX## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkIndirectCommandsLayoutTokenNVX where + type StructFields VkIndirectCommandsLayoutTokenNVX = + '["tokenType", "bindingUnit", "dynamicCount", "divisor"] -- ' closing tick for hsc2hs + type CUnionType VkIndirectCommandsLayoutTokenNVX = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkIndirectCommandsLayoutTokenNVX = 'False -- ' closing tick for hsc2hs + type StructExtends VkIndirectCommandsLayoutTokenNVX = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkTokenType VkIndirectCommandsLayoutTokenNVX where + type VkTokenTypeMType VkIndirectCommandsLayoutTokenNVX = + VkIndirectCommandsTokenTypeNVX + + {-# NOINLINE vkTokenType #-} + vkTokenType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkIndirectCommandsLayoutTokenNVX, tokenType}) + + {-# INLINE vkTokenTypeByteOffset #-} + vkTokenTypeByteOffset ~_ + = #{offset VkIndirectCommandsLayoutTokenNVX, tokenType} + + {-# INLINE readVkTokenType #-} + readVkTokenType p + = peekByteOff p #{offset VkIndirectCommandsLayoutTokenNVX, tokenType} + + {-# INLINE writeVkTokenType #-} + writeVkTokenType p + = pokeByteOff p #{offset VkIndirectCommandsLayoutTokenNVX, tokenType} + +instance {-# OVERLAPPING #-} + HasField "tokenType" VkIndirectCommandsLayoutTokenNVX where + type FieldType "tokenType" VkIndirectCommandsLayoutTokenNVX = + VkIndirectCommandsTokenTypeNVX + type FieldOptional "tokenType" VkIndirectCommandsLayoutTokenNVX = + 'False -- ' closing tick for hsc2hs + type FieldOffset "tokenType" VkIndirectCommandsLayoutTokenNVX = + #{offset VkIndirectCommandsLayoutTokenNVX, tokenType} + type FieldIsArray "tokenType" VkIndirectCommandsLayoutTokenNVX = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkIndirectCommandsLayoutTokenNVX, tokenType} + +instance CanReadField "tokenType" VkIndirectCommandsLayoutTokenNVX + where + {-# INLINE getField #-} + getField = vkTokenType + + {-# INLINE readField #-} + readField = readVkTokenType + +instance CanWriteField "tokenType" VkIndirectCommandsLayoutTokenNVX + where + {-# INLINE writeField #-} + writeField = writeVkTokenType + +instance {-# OVERLAPPING #-} + HasVkBindingUnit VkIndirectCommandsLayoutTokenNVX where + type VkBindingUnitMType VkIndirectCommandsLayoutTokenNVX = Word32 + + {-# NOINLINE vkBindingUnit #-} + vkBindingUnit x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkIndirectCommandsLayoutTokenNVX, bindingUnit}) + + {-# INLINE vkBindingUnitByteOffset #-} + vkBindingUnitByteOffset ~_ + = #{offset VkIndirectCommandsLayoutTokenNVX, bindingUnit} + + {-# INLINE readVkBindingUnit #-} + readVkBindingUnit p + = peekByteOff p #{offset VkIndirectCommandsLayoutTokenNVX, bindingUnit} + + {-# INLINE writeVkBindingUnit #-} + writeVkBindingUnit p + = pokeByteOff p #{offset VkIndirectCommandsLayoutTokenNVX, bindingUnit} + +instance {-# OVERLAPPING #-} + HasField "bindingUnit" VkIndirectCommandsLayoutTokenNVX where + type FieldType "bindingUnit" VkIndirectCommandsLayoutTokenNVX = + Word32 + type FieldOptional "bindingUnit" VkIndirectCommandsLayoutTokenNVX = + 'False -- ' closing tick for hsc2hs + type FieldOffset "bindingUnit" VkIndirectCommandsLayoutTokenNVX = + #{offset VkIndirectCommandsLayoutTokenNVX, bindingUnit} + type FieldIsArray "bindingUnit" VkIndirectCommandsLayoutTokenNVX = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkIndirectCommandsLayoutTokenNVX, bindingUnit} + +instance CanReadField "bindingUnit" + VkIndirectCommandsLayoutTokenNVX + where + {-# INLINE getField #-} + getField = vkBindingUnit + + {-# INLINE readField #-} + readField = readVkBindingUnit + +instance CanWriteField "bindingUnit" + VkIndirectCommandsLayoutTokenNVX + where + {-# INLINE writeField #-} + writeField = writeVkBindingUnit + +instance {-# OVERLAPPING #-} + HasVkDynamicCount VkIndirectCommandsLayoutTokenNVX where + type VkDynamicCountMType VkIndirectCommandsLayoutTokenNVX = Word32 + + {-# NOINLINE vkDynamicCount #-} + vkDynamicCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkIndirectCommandsLayoutTokenNVX, dynamicCount}) + + {-# INLINE vkDynamicCountByteOffset #-} + vkDynamicCountByteOffset ~_ + = #{offset VkIndirectCommandsLayoutTokenNVX, dynamicCount} + + {-# INLINE readVkDynamicCount #-} + readVkDynamicCount p + = peekByteOff p #{offset VkIndirectCommandsLayoutTokenNVX, dynamicCount} + + {-# INLINE writeVkDynamicCount #-} + writeVkDynamicCount p + = pokeByteOff p #{offset VkIndirectCommandsLayoutTokenNVX, dynamicCount} + +instance {-# OVERLAPPING #-} + HasField "dynamicCount" VkIndirectCommandsLayoutTokenNVX where + type FieldType "dynamicCount" VkIndirectCommandsLayoutTokenNVX = + Word32 + type FieldOptional "dynamicCount" VkIndirectCommandsLayoutTokenNVX + = 'False -- ' closing tick for hsc2hs + type FieldOffset "dynamicCount" VkIndirectCommandsLayoutTokenNVX = + #{offset VkIndirectCommandsLayoutTokenNVX, dynamicCount} + type FieldIsArray "dynamicCount" VkIndirectCommandsLayoutTokenNVX = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkIndirectCommandsLayoutTokenNVX, dynamicCount} + +instance CanReadField "dynamicCount" + VkIndirectCommandsLayoutTokenNVX + where + {-# INLINE getField #-} + getField = vkDynamicCount + + {-# INLINE readField #-} + readField = readVkDynamicCount + +instance CanWriteField "dynamicCount" + VkIndirectCommandsLayoutTokenNVX + where + {-# INLINE writeField #-} + writeField = writeVkDynamicCount + +instance {-# OVERLAPPING #-} + HasVkDivisor VkIndirectCommandsLayoutTokenNVX where + type VkDivisorMType VkIndirectCommandsLayoutTokenNVX = Word32 + + {-# NOINLINE vkDivisor #-} + vkDivisor x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkIndirectCommandsLayoutTokenNVX, divisor}) + + {-# INLINE vkDivisorByteOffset #-} + vkDivisorByteOffset ~_ + = #{offset VkIndirectCommandsLayoutTokenNVX, divisor} + + {-# INLINE readVkDivisor #-} + readVkDivisor p + = peekByteOff p #{offset VkIndirectCommandsLayoutTokenNVX, divisor} + + {-# INLINE writeVkDivisor #-} + writeVkDivisor p + = pokeByteOff p #{offset VkIndirectCommandsLayoutTokenNVX, divisor} + +instance {-# OVERLAPPING #-} + HasField "divisor" VkIndirectCommandsLayoutTokenNVX where + type FieldType "divisor" VkIndirectCommandsLayoutTokenNVX = Word32 + type FieldOptional "divisor" VkIndirectCommandsLayoutTokenNVX = + 'False -- ' closing tick for hsc2hs + type FieldOffset "divisor" VkIndirectCommandsLayoutTokenNVX = + #{offset VkIndirectCommandsLayoutTokenNVX, divisor} + type FieldIsArray "divisor" VkIndirectCommandsLayoutTokenNVX = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkIndirectCommandsLayoutTokenNVX, divisor} + +instance CanReadField "divisor" VkIndirectCommandsLayoutTokenNVX + where + {-# INLINE getField #-} + getField = vkDivisor + + {-# INLINE readField #-} + readField = readVkDivisor + +instance CanWriteField "divisor" VkIndirectCommandsLayoutTokenNVX + where + {-# INLINE writeField #-} + writeField = writeVkDivisor + +instance Show VkIndirectCommandsLayoutTokenNVX where + showsPrec d x + = showString "VkIndirectCommandsLayoutTokenNVX {" . + showString "vkTokenType = " . + showsPrec d (vkTokenType x) . + showString ", " . + showString "vkBindingUnit = " . + showsPrec d (vkBindingUnit x) . + showString ", " . + showString "vkDynamicCount = " . + showsPrec d (vkDynamicCount x) . + showString ", " . + showString "vkDivisor = " . + showsPrec d (vkDivisor x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkIndirectCommandsTokenNVX.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkIndirectCommandsTokenNVX.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkIndirectCommandsTokenNVX.hsc @@ -0,0 +1,231 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkIndirectCommandsTokenNVX + (VkIndirectCommandsTokenNVX(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.BaseTypes (VkDeviceSize) +import Graphics.Vulkan.Types.Enum.VkIndirectCommandsTokenTypeNVX (VkIndirectCommandsTokenTypeNVX) +import Graphics.Vulkan.Types.Handles (VkBuffer) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkIndirectCommandsTokenNVX { +-- > VkIndirectCommandsTokenTypeNVX tokenType; +-- > VkBuffer buffer; +-- > VkDeviceSize offset; +-- > } VkIndirectCommandsTokenNVX; +-- +-- +data VkIndirectCommandsTokenNVX = VkIndirectCommandsTokenNVX## Addr## + ByteArray## + +instance Eq VkIndirectCommandsTokenNVX where + (VkIndirectCommandsTokenNVX## a _) == + x@(VkIndirectCommandsTokenNVX## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkIndirectCommandsTokenNVX where + (VkIndirectCommandsTokenNVX## a _) `compare` + x@(VkIndirectCommandsTokenNVX## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkIndirectCommandsTokenNVX where + sizeOf ~_ = #{size VkIndirectCommandsTokenNVX} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkIndirectCommandsTokenNVX} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkIndirectCommandsTokenNVX where + unsafeAddr (VkIndirectCommandsTokenNVX## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkIndirectCommandsTokenNVX## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkIndirectCommandsTokenNVX## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkIndirectCommandsTokenNVX where + type StructFields VkIndirectCommandsTokenNVX = + '["tokenType", "buffer", "offset"] -- ' closing tick for hsc2hs + type CUnionType VkIndirectCommandsTokenNVX = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkIndirectCommandsTokenNVX = 'False -- ' closing tick for hsc2hs + type StructExtends VkIndirectCommandsTokenNVX = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkTokenType VkIndirectCommandsTokenNVX where + type VkTokenTypeMType VkIndirectCommandsTokenNVX = + VkIndirectCommandsTokenTypeNVX + + {-# NOINLINE vkTokenType #-} + vkTokenType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkIndirectCommandsTokenNVX, tokenType}) + + {-# INLINE vkTokenTypeByteOffset #-} + vkTokenTypeByteOffset ~_ + = #{offset VkIndirectCommandsTokenNVX, tokenType} + + {-# INLINE readVkTokenType #-} + readVkTokenType p + = peekByteOff p #{offset VkIndirectCommandsTokenNVX, tokenType} + + {-# INLINE writeVkTokenType #-} + writeVkTokenType p + = pokeByteOff p #{offset VkIndirectCommandsTokenNVX, tokenType} + +instance {-# OVERLAPPING #-} + HasField "tokenType" VkIndirectCommandsTokenNVX where + type FieldType "tokenType" VkIndirectCommandsTokenNVX = + VkIndirectCommandsTokenTypeNVX + type FieldOptional "tokenType" VkIndirectCommandsTokenNVX = 'False -- ' closing tick for hsc2hs + type FieldOffset "tokenType" VkIndirectCommandsTokenNVX = + #{offset VkIndirectCommandsTokenNVX, tokenType} + type FieldIsArray "tokenType" VkIndirectCommandsTokenNVX = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkIndirectCommandsTokenNVX, tokenType} + +instance CanReadField "tokenType" VkIndirectCommandsTokenNVX where + {-# INLINE getField #-} + getField = vkTokenType + + {-# INLINE readField #-} + readField = readVkTokenType + +instance CanWriteField "tokenType" VkIndirectCommandsTokenNVX where + {-# INLINE writeField #-} + writeField = writeVkTokenType + +instance {-# OVERLAPPING #-} HasVkBuffer VkIndirectCommandsTokenNVX + where + type VkBufferMType VkIndirectCommandsTokenNVX = VkBuffer + + {-# NOINLINE vkBuffer #-} + vkBuffer x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkIndirectCommandsTokenNVX, buffer}) + + {-# INLINE vkBufferByteOffset #-} + vkBufferByteOffset ~_ + = #{offset VkIndirectCommandsTokenNVX, buffer} + + {-# INLINE readVkBuffer #-} + readVkBuffer p + = peekByteOff p #{offset VkIndirectCommandsTokenNVX, buffer} + + {-# INLINE writeVkBuffer #-} + writeVkBuffer p + = pokeByteOff p #{offset VkIndirectCommandsTokenNVX, buffer} + +instance {-# OVERLAPPING #-} + HasField "buffer" VkIndirectCommandsTokenNVX where + type FieldType "buffer" VkIndirectCommandsTokenNVX = VkBuffer + type FieldOptional "buffer" VkIndirectCommandsTokenNVX = 'False -- ' closing tick for hsc2hs + type FieldOffset "buffer" VkIndirectCommandsTokenNVX = + #{offset VkIndirectCommandsTokenNVX, buffer} + type FieldIsArray "buffer" VkIndirectCommandsTokenNVX = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkIndirectCommandsTokenNVX, buffer} + +instance CanReadField "buffer" VkIndirectCommandsTokenNVX where + {-# INLINE getField #-} + getField = vkBuffer + + {-# INLINE readField #-} + readField = readVkBuffer + +instance CanWriteField "buffer" VkIndirectCommandsTokenNVX where + {-# INLINE writeField #-} + writeField = writeVkBuffer + +instance {-# OVERLAPPING #-} HasVkOffset VkIndirectCommandsTokenNVX + where + type VkOffsetMType VkIndirectCommandsTokenNVX = VkDeviceSize + + {-# NOINLINE vkOffset #-} + vkOffset x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkIndirectCommandsTokenNVX, offset}) + + {-# INLINE vkOffsetByteOffset #-} + vkOffsetByteOffset ~_ + = #{offset VkIndirectCommandsTokenNVX, offset} + + {-# INLINE readVkOffset #-} + readVkOffset p + = peekByteOff p #{offset VkIndirectCommandsTokenNVX, offset} + + {-# INLINE writeVkOffset #-} + writeVkOffset p + = pokeByteOff p #{offset VkIndirectCommandsTokenNVX, offset} + +instance {-# OVERLAPPING #-} + HasField "offset" VkIndirectCommandsTokenNVX where + type FieldType "offset" VkIndirectCommandsTokenNVX = VkDeviceSize + type FieldOptional "offset" VkIndirectCommandsTokenNVX = 'False -- ' closing tick for hsc2hs + type FieldOffset "offset" VkIndirectCommandsTokenNVX = + #{offset VkIndirectCommandsTokenNVX, offset} + type FieldIsArray "offset" VkIndirectCommandsTokenNVX = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkIndirectCommandsTokenNVX, offset} + +instance CanReadField "offset" VkIndirectCommandsTokenNVX where + {-# INLINE getField #-} + getField = vkOffset + + {-# INLINE readField #-} + readField = readVkOffset + +instance CanWriteField "offset" VkIndirectCommandsTokenNVX where + {-# INLINE writeField #-} + writeField = writeVkOffset + +instance Show VkIndirectCommandsTokenNVX where + showsPrec d x + = showString "VkIndirectCommandsTokenNVX {" . + showString "vkTokenType = " . + showsPrec d (vkTokenType x) . + showString ", " . + showString "vkBuffer = " . + showsPrec d (vkBuffer x) . + showString ", " . + showString "vkOffset = " . showsPrec d (vkOffset x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkInputAttachmentAspectReferenceKHR.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkInputAttachmentAspectReferenceKHR.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkInputAttachmentAspectReferenceKHR.hsc @@ -0,0 +1,260 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkInputAttachmentAspectReferenceKHR + (VkInputAttachmentAspectReferenceKHR(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkImageAspectFlags (VkImageAspectFlags) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkInputAttachmentAspectReferenceKHR { +-- > uint32_t subpass; +-- > uint32_t inputAttachmentIndex; +-- > VkImageAspectFlags aspectMask; +-- > } VkInputAttachmentAspectReferenceKHR; +-- +-- +data VkInputAttachmentAspectReferenceKHR = VkInputAttachmentAspectReferenceKHR## Addr## + ByteArray## + +instance Eq VkInputAttachmentAspectReferenceKHR where + (VkInputAttachmentAspectReferenceKHR## a _) == + x@(VkInputAttachmentAspectReferenceKHR## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkInputAttachmentAspectReferenceKHR where + (VkInputAttachmentAspectReferenceKHR## a _) `compare` + x@(VkInputAttachmentAspectReferenceKHR## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkInputAttachmentAspectReferenceKHR where + sizeOf ~_ = #{size VkInputAttachmentAspectReferenceKHR} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkInputAttachmentAspectReferenceKHR} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkInputAttachmentAspectReferenceKHR + where + unsafeAddr (VkInputAttachmentAspectReferenceKHR## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkInputAttachmentAspectReferenceKHR## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkInputAttachmentAspectReferenceKHR## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkInputAttachmentAspectReferenceKHR where + type StructFields VkInputAttachmentAspectReferenceKHR = + '["subpass", "inputAttachmentIndex", "aspectMask"] -- ' closing tick for hsc2hs + type CUnionType VkInputAttachmentAspectReferenceKHR = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkInputAttachmentAspectReferenceKHR = 'False -- ' closing tick for hsc2hs + type StructExtends VkInputAttachmentAspectReferenceKHR = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSubpass VkInputAttachmentAspectReferenceKHR where + type VkSubpassMType VkInputAttachmentAspectReferenceKHR = Word32 + + {-# NOINLINE vkSubpass #-} + vkSubpass x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkInputAttachmentAspectReferenceKHR, subpass}) + + {-# INLINE vkSubpassByteOffset #-} + vkSubpassByteOffset ~_ + = #{offset VkInputAttachmentAspectReferenceKHR, subpass} + + {-# INLINE readVkSubpass #-} + readVkSubpass p + = peekByteOff p #{offset VkInputAttachmentAspectReferenceKHR, subpass} + + {-# INLINE writeVkSubpass #-} + writeVkSubpass p + = pokeByteOff p #{offset VkInputAttachmentAspectReferenceKHR, subpass} + +instance {-# OVERLAPPING #-} + HasField "subpass" VkInputAttachmentAspectReferenceKHR where + type FieldType "subpass" VkInputAttachmentAspectReferenceKHR = + Word32 + type FieldOptional "subpass" VkInputAttachmentAspectReferenceKHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "subpass" VkInputAttachmentAspectReferenceKHR = + #{offset VkInputAttachmentAspectReferenceKHR, subpass} + type FieldIsArray "subpass" VkInputAttachmentAspectReferenceKHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkInputAttachmentAspectReferenceKHR, subpass} + +instance CanReadField "subpass" VkInputAttachmentAspectReferenceKHR + where + {-# INLINE getField #-} + getField = vkSubpass + + {-# INLINE readField #-} + readField = readVkSubpass + +instance CanWriteField "subpass" + VkInputAttachmentAspectReferenceKHR + where + {-# INLINE writeField #-} + writeField = writeVkSubpass + +instance {-# OVERLAPPING #-} + HasVkInputAttachmentIndex VkInputAttachmentAspectReferenceKHR where + type VkInputAttachmentIndexMType + VkInputAttachmentAspectReferenceKHR + = Word32 + + {-# NOINLINE vkInputAttachmentIndex #-} + vkInputAttachmentIndex x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkInputAttachmentAspectReferenceKHR, inputAttachmentIndex}) + + {-# INLINE vkInputAttachmentIndexByteOffset #-} + vkInputAttachmentIndexByteOffset ~_ + = #{offset VkInputAttachmentAspectReferenceKHR, inputAttachmentIndex} + + {-# INLINE readVkInputAttachmentIndex #-} + readVkInputAttachmentIndex p + = peekByteOff p #{offset VkInputAttachmentAspectReferenceKHR, inputAttachmentIndex} + + {-# INLINE writeVkInputAttachmentIndex #-} + writeVkInputAttachmentIndex p + = pokeByteOff p #{offset VkInputAttachmentAspectReferenceKHR, inputAttachmentIndex} + +instance {-# OVERLAPPING #-} + HasField "inputAttachmentIndex" VkInputAttachmentAspectReferenceKHR + where + type FieldType "inputAttachmentIndex" + VkInputAttachmentAspectReferenceKHR + = Word32 + type FieldOptional "inputAttachmentIndex" + VkInputAttachmentAspectReferenceKHR + = 'False -- ' closing tick for hsc2hs + type FieldOffset "inputAttachmentIndex" + VkInputAttachmentAspectReferenceKHR + = + #{offset VkInputAttachmentAspectReferenceKHR, inputAttachmentIndex} + type FieldIsArray "inputAttachmentIndex" + VkInputAttachmentAspectReferenceKHR + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkInputAttachmentAspectReferenceKHR, inputAttachmentIndex} + +instance CanReadField "inputAttachmentIndex" + VkInputAttachmentAspectReferenceKHR + where + {-# INLINE getField #-} + getField = vkInputAttachmentIndex + + {-# INLINE readField #-} + readField = readVkInputAttachmentIndex + +instance CanWriteField "inputAttachmentIndex" + VkInputAttachmentAspectReferenceKHR + where + {-# INLINE writeField #-} + writeField = writeVkInputAttachmentIndex + +instance {-# OVERLAPPING #-} + HasVkAspectMask VkInputAttachmentAspectReferenceKHR where + type VkAspectMaskMType VkInputAttachmentAspectReferenceKHR = + VkImageAspectFlags + + {-# NOINLINE vkAspectMask #-} + vkAspectMask x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkInputAttachmentAspectReferenceKHR, aspectMask}) + + {-# INLINE vkAspectMaskByteOffset #-} + vkAspectMaskByteOffset ~_ + = #{offset VkInputAttachmentAspectReferenceKHR, aspectMask} + + {-# INLINE readVkAspectMask #-} + readVkAspectMask p + = peekByteOff p #{offset VkInputAttachmentAspectReferenceKHR, aspectMask} + + {-# INLINE writeVkAspectMask #-} + writeVkAspectMask p + = pokeByteOff p #{offset VkInputAttachmentAspectReferenceKHR, aspectMask} + +instance {-# OVERLAPPING #-} + HasField "aspectMask" VkInputAttachmentAspectReferenceKHR where + type FieldType "aspectMask" VkInputAttachmentAspectReferenceKHR = + VkImageAspectFlags + type FieldOptional "aspectMask" VkInputAttachmentAspectReferenceKHR + = 'False -- ' closing tick for hsc2hs + type FieldOffset "aspectMask" VkInputAttachmentAspectReferenceKHR = + #{offset VkInputAttachmentAspectReferenceKHR, aspectMask} + type FieldIsArray "aspectMask" VkInputAttachmentAspectReferenceKHR + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkInputAttachmentAspectReferenceKHR, aspectMask} + +instance CanReadField "aspectMask" + VkInputAttachmentAspectReferenceKHR + where + {-# INLINE getField #-} + getField = vkAspectMask + + {-# INLINE readField #-} + readField = readVkAspectMask + +instance CanWriteField "aspectMask" + VkInputAttachmentAspectReferenceKHR + where + {-# INLINE writeField #-} + writeField = writeVkAspectMask + +instance Show VkInputAttachmentAspectReferenceKHR where + showsPrec d x + = showString "VkInputAttachmentAspectReferenceKHR {" . + showString "vkSubpass = " . + showsPrec d (vkSubpass x) . + showString ", " . + showString "vkInputAttachmentIndex = " . + showsPrec d (vkInputAttachmentIndex x) . + showString ", " . + showString "vkAspectMask = " . + showsPrec d (vkAspectMask x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkInstanceCreateInfo.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkInstanceCreateInfo.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkInstanceCreateInfo.hsc @@ -0,0 +1,501 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkInstanceCreateInfo + (VkInstanceCreateInfo(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Bitmasks (VkInstanceCreateFlags) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Struct.VkApplicationInfo (VkApplicationInfo) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkInstanceCreateInfo { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkInstanceCreateFlags flags; +-- > const VkApplicationInfo* pApplicationInfo; +-- > uint32_t enabledLayerCount; +-- > const char* const* ppEnabledLayerNames; +-- > uint32_t enabledExtensionCount; +-- > const char* const* ppEnabledExtensionNames; +-- > } VkInstanceCreateInfo; +-- +-- +data VkInstanceCreateInfo = VkInstanceCreateInfo## Addr## ByteArray## + +instance Eq VkInstanceCreateInfo where + (VkInstanceCreateInfo## a _) == x@(VkInstanceCreateInfo## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkInstanceCreateInfo where + (VkInstanceCreateInfo## a _) `compare` x@(VkInstanceCreateInfo## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkInstanceCreateInfo where + sizeOf ~_ = #{size VkInstanceCreateInfo} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkInstanceCreateInfo} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkInstanceCreateInfo where + unsafeAddr (VkInstanceCreateInfo## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkInstanceCreateInfo## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkInstanceCreateInfo## (plusAddr## (byteArrayContents## b) off) b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkInstanceCreateInfo where + type StructFields VkInstanceCreateInfo = + '["sType", "pNext", "flags", "pApplicationInfo", -- ' closing tick for hsc2hs + "enabledLayerCount", "ppEnabledLayerNames", + "enabledExtensionCount", "ppEnabledExtensionNames"] + type CUnionType VkInstanceCreateInfo = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkInstanceCreateInfo = 'False -- ' closing tick for hsc2hs + type StructExtends VkInstanceCreateInfo = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkSType VkInstanceCreateInfo where + type VkSTypeMType VkInstanceCreateInfo = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkInstanceCreateInfo, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkInstanceCreateInfo, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkInstanceCreateInfo, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkInstanceCreateInfo, sType} + +instance {-# OVERLAPPING #-} HasField "sType" VkInstanceCreateInfo + where + type FieldType "sType" VkInstanceCreateInfo = VkStructureType + type FieldOptional "sType" VkInstanceCreateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkInstanceCreateInfo = + #{offset VkInstanceCreateInfo, sType} + type FieldIsArray "sType" VkInstanceCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkInstanceCreateInfo, sType} + +instance CanReadField "sType" VkInstanceCreateInfo where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkInstanceCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} HasVkPNext VkInstanceCreateInfo where + type VkPNextMType VkInstanceCreateInfo = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkInstanceCreateInfo, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkInstanceCreateInfo, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkInstanceCreateInfo, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkInstanceCreateInfo, pNext} + +instance {-# OVERLAPPING #-} HasField "pNext" VkInstanceCreateInfo + where + type FieldType "pNext" VkInstanceCreateInfo = Ptr Void + type FieldOptional "pNext" VkInstanceCreateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkInstanceCreateInfo = + #{offset VkInstanceCreateInfo, pNext} + type FieldIsArray "pNext" VkInstanceCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkInstanceCreateInfo, pNext} + +instance CanReadField "pNext" VkInstanceCreateInfo where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkInstanceCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} HasVkFlags VkInstanceCreateInfo where + type VkFlagsMType VkInstanceCreateInfo = VkInstanceCreateFlags + + {-# NOINLINE vkFlags #-} + vkFlags x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkInstanceCreateInfo, flags}) + + {-# INLINE vkFlagsByteOffset #-} + vkFlagsByteOffset ~_ + = #{offset VkInstanceCreateInfo, flags} + + {-# INLINE readVkFlags #-} + readVkFlags p + = peekByteOff p #{offset VkInstanceCreateInfo, flags} + + {-# INLINE writeVkFlags #-} + writeVkFlags p + = pokeByteOff p #{offset VkInstanceCreateInfo, flags} + +instance {-# OVERLAPPING #-} HasField "flags" VkInstanceCreateInfo + where + type FieldType "flags" VkInstanceCreateInfo = VkInstanceCreateFlags + type FieldOptional "flags" VkInstanceCreateInfo = 'True -- ' closing tick for hsc2hs + type FieldOffset "flags" VkInstanceCreateInfo = + #{offset VkInstanceCreateInfo, flags} + type FieldIsArray "flags" VkInstanceCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkInstanceCreateInfo, flags} + +instance CanReadField "flags" VkInstanceCreateInfo where + {-# INLINE getField #-} + getField = vkFlags + + {-# INLINE readField #-} + readField = readVkFlags + +instance CanWriteField "flags" VkInstanceCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkFlags + +instance {-# OVERLAPPING #-} + HasVkPApplicationInfo VkInstanceCreateInfo where + type VkPApplicationInfoMType VkInstanceCreateInfo = + Ptr VkApplicationInfo + + {-# NOINLINE vkPApplicationInfo #-} + vkPApplicationInfo x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkInstanceCreateInfo, pApplicationInfo}) + + {-# INLINE vkPApplicationInfoByteOffset #-} + vkPApplicationInfoByteOffset ~_ + = #{offset VkInstanceCreateInfo, pApplicationInfo} + + {-# INLINE readVkPApplicationInfo #-} + readVkPApplicationInfo p + = peekByteOff p #{offset VkInstanceCreateInfo, pApplicationInfo} + + {-# INLINE writeVkPApplicationInfo #-} + writeVkPApplicationInfo p + = pokeByteOff p #{offset VkInstanceCreateInfo, pApplicationInfo} + +instance {-# OVERLAPPING #-} + HasField "pApplicationInfo" VkInstanceCreateInfo where + type FieldType "pApplicationInfo" VkInstanceCreateInfo = + Ptr VkApplicationInfo + type FieldOptional "pApplicationInfo" VkInstanceCreateInfo = 'True -- ' closing tick for hsc2hs + type FieldOffset "pApplicationInfo" VkInstanceCreateInfo = + #{offset VkInstanceCreateInfo, pApplicationInfo} + type FieldIsArray "pApplicationInfo" VkInstanceCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkInstanceCreateInfo, pApplicationInfo} + +instance CanReadField "pApplicationInfo" VkInstanceCreateInfo where + {-# INLINE getField #-} + getField = vkPApplicationInfo + + {-# INLINE readField #-} + readField = readVkPApplicationInfo + +instance CanWriteField "pApplicationInfo" VkInstanceCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkPApplicationInfo + +instance {-# OVERLAPPING #-} + HasVkEnabledLayerCount VkInstanceCreateInfo where + type VkEnabledLayerCountMType VkInstanceCreateInfo = Word32 + + {-# NOINLINE vkEnabledLayerCount #-} + vkEnabledLayerCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkInstanceCreateInfo, enabledLayerCount}) + + {-# INLINE vkEnabledLayerCountByteOffset #-} + vkEnabledLayerCountByteOffset ~_ + = #{offset VkInstanceCreateInfo, enabledLayerCount} + + {-# INLINE readVkEnabledLayerCount #-} + readVkEnabledLayerCount p + = peekByteOff p #{offset VkInstanceCreateInfo, enabledLayerCount} + + {-# INLINE writeVkEnabledLayerCount #-} + writeVkEnabledLayerCount p + = pokeByteOff p #{offset VkInstanceCreateInfo, enabledLayerCount} + +instance {-# OVERLAPPING #-} + HasField "enabledLayerCount" VkInstanceCreateInfo where + type FieldType "enabledLayerCount" VkInstanceCreateInfo = Word32 + type FieldOptional "enabledLayerCount" VkInstanceCreateInfo = 'True -- ' closing tick for hsc2hs + type FieldOffset "enabledLayerCount" VkInstanceCreateInfo = + #{offset VkInstanceCreateInfo, enabledLayerCount} + type FieldIsArray "enabledLayerCount" VkInstanceCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkInstanceCreateInfo, enabledLayerCount} + +instance CanReadField "enabledLayerCount" VkInstanceCreateInfo + where + {-# INLINE getField #-} + getField = vkEnabledLayerCount + + {-# INLINE readField #-} + readField = readVkEnabledLayerCount + +instance CanWriteField "enabledLayerCount" VkInstanceCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkEnabledLayerCount + +instance {-# OVERLAPPING #-} + HasVkPpEnabledLayerNames VkInstanceCreateInfo where + type VkPpEnabledLayerNamesMType VkInstanceCreateInfo = Ptr CString + + {-# NOINLINE vkPpEnabledLayerNames #-} + vkPpEnabledLayerNames x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkInstanceCreateInfo, ppEnabledLayerNames}) + + {-# INLINE vkPpEnabledLayerNamesByteOffset #-} + vkPpEnabledLayerNamesByteOffset ~_ + = #{offset VkInstanceCreateInfo, ppEnabledLayerNames} + + {-# INLINE readVkPpEnabledLayerNames #-} + readVkPpEnabledLayerNames p + = peekByteOff p #{offset VkInstanceCreateInfo, ppEnabledLayerNames} + + {-# INLINE writeVkPpEnabledLayerNames #-} + writeVkPpEnabledLayerNames p + = pokeByteOff p #{offset VkInstanceCreateInfo, ppEnabledLayerNames} + +instance {-# OVERLAPPING #-} + HasField "ppEnabledLayerNames" VkInstanceCreateInfo where + type FieldType "ppEnabledLayerNames" VkInstanceCreateInfo = + Ptr CString + type FieldOptional "ppEnabledLayerNames" VkInstanceCreateInfo = + 'False -- ' closing tick for hsc2hs + type FieldOffset "ppEnabledLayerNames" VkInstanceCreateInfo = + #{offset VkInstanceCreateInfo, ppEnabledLayerNames} + type FieldIsArray "ppEnabledLayerNames" VkInstanceCreateInfo = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkInstanceCreateInfo, ppEnabledLayerNames} + +instance CanReadField "ppEnabledLayerNames" VkInstanceCreateInfo + where + {-# INLINE getField #-} + getField = vkPpEnabledLayerNames + + {-# INLINE readField #-} + readField = readVkPpEnabledLayerNames + +instance CanWriteField "ppEnabledLayerNames" VkInstanceCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkPpEnabledLayerNames + +instance {-# OVERLAPPING #-} + HasVkEnabledExtensionCount VkInstanceCreateInfo where + type VkEnabledExtensionCountMType VkInstanceCreateInfo = Word32 + + {-# NOINLINE vkEnabledExtensionCount #-} + vkEnabledExtensionCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkInstanceCreateInfo, enabledExtensionCount}) + + {-# INLINE vkEnabledExtensionCountByteOffset #-} + vkEnabledExtensionCountByteOffset ~_ + = #{offset VkInstanceCreateInfo, enabledExtensionCount} + + {-# INLINE readVkEnabledExtensionCount #-} + readVkEnabledExtensionCount p + = peekByteOff p #{offset VkInstanceCreateInfo, enabledExtensionCount} + + {-# INLINE writeVkEnabledExtensionCount #-} + writeVkEnabledExtensionCount p + = pokeByteOff p #{offset VkInstanceCreateInfo, enabledExtensionCount} + +instance {-# OVERLAPPING #-} + HasField "enabledExtensionCount" VkInstanceCreateInfo where + type FieldType "enabledExtensionCount" VkInstanceCreateInfo = + Word32 + type FieldOptional "enabledExtensionCount" VkInstanceCreateInfo = + 'True -- ' closing tick for hsc2hs + type FieldOffset "enabledExtensionCount" VkInstanceCreateInfo = + #{offset VkInstanceCreateInfo, enabledExtensionCount} + type FieldIsArray "enabledExtensionCount" VkInstanceCreateInfo = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkInstanceCreateInfo, enabledExtensionCount} + +instance CanReadField "enabledExtensionCount" VkInstanceCreateInfo + where + {-# INLINE getField #-} + getField = vkEnabledExtensionCount + + {-# INLINE readField #-} + readField = readVkEnabledExtensionCount + +instance CanWriteField "enabledExtensionCount" VkInstanceCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkEnabledExtensionCount + +instance {-# OVERLAPPING #-} + HasVkPpEnabledExtensionNames VkInstanceCreateInfo where + type VkPpEnabledExtensionNamesMType VkInstanceCreateInfo = + Ptr CString + + {-# NOINLINE vkPpEnabledExtensionNames #-} + vkPpEnabledExtensionNames x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkInstanceCreateInfo, ppEnabledExtensionNames}) + + {-# INLINE vkPpEnabledExtensionNamesByteOffset #-} + vkPpEnabledExtensionNamesByteOffset ~_ + = #{offset VkInstanceCreateInfo, ppEnabledExtensionNames} + + {-# INLINE readVkPpEnabledExtensionNames #-} + readVkPpEnabledExtensionNames p + = peekByteOff p #{offset VkInstanceCreateInfo, ppEnabledExtensionNames} + + {-# INLINE writeVkPpEnabledExtensionNames #-} + writeVkPpEnabledExtensionNames p + = pokeByteOff p #{offset VkInstanceCreateInfo, ppEnabledExtensionNames} + +instance {-# OVERLAPPING #-} + HasField "ppEnabledExtensionNames" VkInstanceCreateInfo where + type FieldType "ppEnabledExtensionNames" VkInstanceCreateInfo = + Ptr CString + type FieldOptional "ppEnabledExtensionNames" VkInstanceCreateInfo = + 'False -- ' closing tick for hsc2hs + type FieldOffset "ppEnabledExtensionNames" VkInstanceCreateInfo = + #{offset VkInstanceCreateInfo, ppEnabledExtensionNames} + type FieldIsArray "ppEnabledExtensionNames" VkInstanceCreateInfo = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkInstanceCreateInfo, ppEnabledExtensionNames} + +instance CanReadField "ppEnabledExtensionNames" + VkInstanceCreateInfo + where + {-# INLINE getField #-} + getField = vkPpEnabledExtensionNames + + {-# INLINE readField #-} + readField = readVkPpEnabledExtensionNames + +instance CanWriteField "ppEnabledExtensionNames" + VkInstanceCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkPpEnabledExtensionNames + +instance Show VkInstanceCreateInfo where + showsPrec d x + = showString "VkInstanceCreateInfo {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkFlags = " . + showsPrec d (vkFlags x) . + showString ", " . + showString "vkPApplicationInfo = " . + showsPrec d (vkPApplicationInfo x) . + showString ", " . + showString "vkEnabledLayerCount = " . + showsPrec d (vkEnabledLayerCount x) . + showString ", " . + showString "vkPpEnabledLayerNames = " . + showsPrec d (vkPpEnabledLayerNames x) . + showString ", " . + showString "vkEnabledExtensionCount = " . + showsPrec d (vkEnabledExtensionCount x) . + showString ", " . + showString "vkPpEnabledExtensionNames = " . + showsPrec d (vkPpEnabledExtensionNames x) + . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkLayerProperties.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkLayerProperties.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkLayerProperties.hsc @@ -0,0 +1,331 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleContexts #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE ScopedTypeVariables #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +{-# LANGUAGE UndecidableInstances #-} +module Graphics.Vulkan.Types.Struct.VkLayerProperties + (VkLayerProperties(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import GHC.TypeLits (KnownNat, natVal') -- ' closing tick for hsc2hs +import Graphics.Vulkan.Constants (VK_MAX_DESCRIPTION_SIZE, pattern VK_MAX_DESCRIPTION_SIZE, + VK_MAX_EXTENSION_NAME_SIZE, + pattern VK_MAX_EXTENSION_NAME_SIZE) +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkLayerProperties { +-- > char layerName[VK_MAX_EXTENSION_NAME_SIZE]; +-- > uint32_t specVersion; +-- > uint32_t implementationVersion; +-- > char description[VK_MAX_DESCRIPTION_SIZE]; +-- > } VkLayerProperties; +-- +-- +data VkLayerProperties = VkLayerProperties## Addr## ByteArray## + +instance Eq VkLayerProperties where + (VkLayerProperties## a _) == x@(VkLayerProperties## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkLayerProperties where + (VkLayerProperties## a _) `compare` x@(VkLayerProperties## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkLayerProperties where + sizeOf ~_ = #{size VkLayerProperties} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkLayerProperties} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkLayerProperties where + unsafeAddr (VkLayerProperties## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkLayerProperties## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkLayerProperties## (plusAddr## (byteArrayContents## b) off) b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkLayerProperties where + type StructFields VkLayerProperties = + '["layerName", "specVersion", "implementationVersion", -- ' closing tick for hsc2hs + "description"] + type CUnionType VkLayerProperties = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkLayerProperties = 'True -- ' closing tick for hsc2hs + type StructExtends VkLayerProperties = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkLayerNameArray VkLayerProperties + where + type VkLayerNameArrayMType VkLayerProperties = CChar + + {-# NOINLINE vkLayerNameArray #-} + vkLayerNameArray x idx + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) + (idx * sizeOf (undefined :: CChar) + + #{offset VkLayerProperties, layerName})) + + {-# INLINE vkLayerNameArrayByteOffset #-} + vkLayerNameArrayByteOffset ~_ + = #{offset VkLayerProperties, layerName} + + {-# INLINE readVkLayerNameArray #-} + readVkLayerNameArray p idx + = peekByteOff p + (idx * sizeOf (undefined :: CChar) + + #{offset VkLayerProperties, layerName}) + + {-# INLINE writeVkLayerNameArray #-} + writeVkLayerNameArray p idx + = pokeByteOff p + (idx * sizeOf (undefined :: CChar) + + #{offset VkLayerProperties, layerName}) + +instance {-# OVERLAPPING #-} HasField "layerName" VkLayerProperties + where + type FieldType "layerName" VkLayerProperties = CChar + type FieldOptional "layerName" VkLayerProperties = 'False -- ' closing tick for hsc2hs + type FieldOffset "layerName" VkLayerProperties = + #{offset VkLayerProperties, layerName} + type FieldIsArray "layerName" VkLayerProperties = 'True -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkLayerProperties, layerName} + +instance (KnownNat idx, + IndexInBounds "layerName" idx VkLayerProperties) => + CanReadFieldArray "layerName" idx VkLayerProperties + where + {-# SPECIALISE instance + CanReadFieldArray "layerName" 0 VkLayerProperties #-} + + {-# SPECIALISE instance + CanReadFieldArray "layerName" 1 VkLayerProperties #-} + + {-# SPECIALISE instance + CanReadFieldArray "layerName" 2 VkLayerProperties #-} + + {-# SPECIALISE instance + CanReadFieldArray "layerName" 3 VkLayerProperties #-} + type FieldArrayLength "layerName" VkLayerProperties = + VK_MAX_EXTENSION_NAME_SIZE + + {-# INLINE fieldArrayLength #-} + fieldArrayLength = VK_MAX_EXTENSION_NAME_SIZE + + {-# INLINE getFieldArray #-} + getFieldArray x + = vkLayerNameArray x (fromInteger $ natVal' (proxy## :: Proxy## idx)) -- ' closing tick for hsc2hs + + {-# INLINE readFieldArray #-} + readFieldArray x + = readVkLayerNameArray x + (fromInteger $ natVal' (proxy## :: Proxy## idx)) -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkSpecVersion VkLayerProperties + where + type VkSpecVersionMType VkLayerProperties = Word32 + + {-# NOINLINE vkSpecVersion #-} + vkSpecVersion x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkLayerProperties, specVersion}) + + {-# INLINE vkSpecVersionByteOffset #-} + vkSpecVersionByteOffset ~_ + = #{offset VkLayerProperties, specVersion} + + {-# INLINE readVkSpecVersion #-} + readVkSpecVersion p + = peekByteOff p #{offset VkLayerProperties, specVersion} + + {-# INLINE writeVkSpecVersion #-} + writeVkSpecVersion p + = pokeByteOff p #{offset VkLayerProperties, specVersion} + +instance {-# OVERLAPPING #-} + HasField "specVersion" VkLayerProperties where + type FieldType "specVersion" VkLayerProperties = Word32 + type FieldOptional "specVersion" VkLayerProperties = 'False -- ' closing tick for hsc2hs + type FieldOffset "specVersion" VkLayerProperties = + #{offset VkLayerProperties, specVersion} + type FieldIsArray "specVersion" VkLayerProperties = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkLayerProperties, specVersion} + +instance CanReadField "specVersion" VkLayerProperties where + {-# INLINE getField #-} + getField = vkSpecVersion + + {-# INLINE readField #-} + readField = readVkSpecVersion + +instance {-# OVERLAPPING #-} + HasVkImplementationVersion VkLayerProperties where + type VkImplementationVersionMType VkLayerProperties = Word32 + + {-# NOINLINE vkImplementationVersion #-} + vkImplementationVersion x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkLayerProperties, implementationVersion}) + + {-# INLINE vkImplementationVersionByteOffset #-} + vkImplementationVersionByteOffset ~_ + = #{offset VkLayerProperties, implementationVersion} + + {-# INLINE readVkImplementationVersion #-} + readVkImplementationVersion p + = peekByteOff p #{offset VkLayerProperties, implementationVersion} + + {-# INLINE writeVkImplementationVersion #-} + writeVkImplementationVersion p + = pokeByteOff p #{offset VkLayerProperties, implementationVersion} + +instance {-# OVERLAPPING #-} + HasField "implementationVersion" VkLayerProperties where + type FieldType "implementationVersion" VkLayerProperties = Word32 + type FieldOptional "implementationVersion" VkLayerProperties = + 'False -- ' closing tick for hsc2hs + type FieldOffset "implementationVersion" VkLayerProperties = + #{offset VkLayerProperties, implementationVersion} + type FieldIsArray "implementationVersion" VkLayerProperties = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkLayerProperties, implementationVersion} + +instance CanReadField "implementationVersion" VkLayerProperties + where + {-# INLINE getField #-} + getField = vkImplementationVersion + + {-# INLINE readField #-} + readField = readVkImplementationVersion + +instance {-# OVERLAPPING #-} + HasVkDescriptionArray VkLayerProperties where + type VkDescriptionArrayMType VkLayerProperties = CChar + + {-# NOINLINE vkDescriptionArray #-} + vkDescriptionArray x idx + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) + (idx * sizeOf (undefined :: CChar) + + #{offset VkLayerProperties, description})) + + {-# INLINE vkDescriptionArrayByteOffset #-} + vkDescriptionArrayByteOffset ~_ + = #{offset VkLayerProperties, description} + + {-# INLINE readVkDescriptionArray #-} + readVkDescriptionArray p idx + = peekByteOff p + (idx * sizeOf (undefined :: CChar) + + #{offset VkLayerProperties, description}) + + {-# INLINE writeVkDescriptionArray #-} + writeVkDescriptionArray p idx + = pokeByteOff p + (idx * sizeOf (undefined :: CChar) + + #{offset VkLayerProperties, description}) + +instance {-# OVERLAPPING #-} + HasField "description" VkLayerProperties where + type FieldType "description" VkLayerProperties = CChar + type FieldOptional "description" VkLayerProperties = 'False -- ' closing tick for hsc2hs + type FieldOffset "description" VkLayerProperties = + #{offset VkLayerProperties, description} + type FieldIsArray "description" VkLayerProperties = 'True -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkLayerProperties, description} + +instance (KnownNat idx, + IndexInBounds "description" idx VkLayerProperties) => + CanReadFieldArray "description" idx VkLayerProperties + where + {-# SPECIALISE instance + CanReadFieldArray "description" 0 VkLayerProperties #-} + + {-# SPECIALISE instance + CanReadFieldArray "description" 1 VkLayerProperties #-} + + {-# SPECIALISE instance + CanReadFieldArray "description" 2 VkLayerProperties #-} + + {-# SPECIALISE instance + CanReadFieldArray "description" 3 VkLayerProperties #-} + type FieldArrayLength "description" VkLayerProperties = + VK_MAX_DESCRIPTION_SIZE + + {-# INLINE fieldArrayLength #-} + fieldArrayLength = VK_MAX_DESCRIPTION_SIZE + + {-# INLINE getFieldArray #-} + getFieldArray x + = vkDescriptionArray x + (fromInteger $ natVal' (proxy## :: Proxy## idx)) -- ' closing tick for hsc2hs + + {-# INLINE readFieldArray #-} + readFieldArray x + = readVkDescriptionArray x + (fromInteger $ natVal' (proxy## :: Proxy## idx)) -- ' closing tick for hsc2hs + +instance Show VkLayerProperties where + showsPrec d x + = showString "VkLayerProperties {" . + showString "vkLayerNameArray = [" . + showsPrec d + (map (vkLayerNameArray x) [1 .. VK_MAX_EXTENSION_NAME_SIZE]) + . + showChar ']' . + showString ", " . + showString "vkSpecVersion = " . + showsPrec d (vkSpecVersion x) . + showString ", " . + showString "vkImplementationVersion = " . + showsPrec d (vkImplementationVersion x) . + showString ", " . + showString "vkDescriptionArray = [" . + showsPrec d + (map (vkDescriptionArray x) [1 .. VK_MAX_DESCRIPTION_SIZE]) + . showChar ']' . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkMacOSSurfaceCreateInfoMVK.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkMacOSSurfaceCreateInfoMVK.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkMacOSSurfaceCreateInfoMVK.hsc @@ -0,0 +1,282 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkMacOSSurfaceCreateInfoMVK + (VkMacOSSurfaceCreateInfoMVK(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Bitmasks (VkMacOSSurfaceCreateFlagsMVK) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkMacOSSurfaceCreateInfoMVK { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkMacOSSurfaceCreateFlagsMVK flags; +-- > const void* pView; +-- > } VkMacOSSurfaceCreateInfoMVK; +-- +-- +data VkMacOSSurfaceCreateInfoMVK = VkMacOSSurfaceCreateInfoMVK## Addr## + ByteArray## + +instance Eq VkMacOSSurfaceCreateInfoMVK where + (VkMacOSSurfaceCreateInfoMVK## a _) == + x@(VkMacOSSurfaceCreateInfoMVK## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkMacOSSurfaceCreateInfoMVK where + (VkMacOSSurfaceCreateInfoMVK## a _) `compare` + x@(VkMacOSSurfaceCreateInfoMVK## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkMacOSSurfaceCreateInfoMVK where + sizeOf ~_ = #{size VkMacOSSurfaceCreateInfoMVK} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkMacOSSurfaceCreateInfoMVK} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkMacOSSurfaceCreateInfoMVK where + unsafeAddr (VkMacOSSurfaceCreateInfoMVK## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkMacOSSurfaceCreateInfoMVK## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkMacOSSurfaceCreateInfoMVK## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkMacOSSurfaceCreateInfoMVK where + type StructFields VkMacOSSurfaceCreateInfoMVK = + '["sType", "pNext", "flags", "pView"] -- ' closing tick for hsc2hs + type CUnionType VkMacOSSurfaceCreateInfoMVK = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkMacOSSurfaceCreateInfoMVK = 'False -- ' closing tick for hsc2hs + type StructExtends VkMacOSSurfaceCreateInfoMVK = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkSType VkMacOSSurfaceCreateInfoMVK + where + type VkSTypeMType VkMacOSSurfaceCreateInfoMVK = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkMacOSSurfaceCreateInfoMVK, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkMacOSSurfaceCreateInfoMVK, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkMacOSSurfaceCreateInfoMVK, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkMacOSSurfaceCreateInfoMVK, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkMacOSSurfaceCreateInfoMVK where + type FieldType "sType" VkMacOSSurfaceCreateInfoMVK = + VkStructureType + type FieldOptional "sType" VkMacOSSurfaceCreateInfoMVK = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkMacOSSurfaceCreateInfoMVK = + #{offset VkMacOSSurfaceCreateInfoMVK, sType} + type FieldIsArray "sType" VkMacOSSurfaceCreateInfoMVK = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkMacOSSurfaceCreateInfoMVK, sType} + +instance CanReadField "sType" VkMacOSSurfaceCreateInfoMVK where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkMacOSSurfaceCreateInfoMVK where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} HasVkPNext VkMacOSSurfaceCreateInfoMVK + where + type VkPNextMType VkMacOSSurfaceCreateInfoMVK = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkMacOSSurfaceCreateInfoMVK, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkMacOSSurfaceCreateInfoMVK, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkMacOSSurfaceCreateInfoMVK, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkMacOSSurfaceCreateInfoMVK, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkMacOSSurfaceCreateInfoMVK where + type FieldType "pNext" VkMacOSSurfaceCreateInfoMVK = Ptr Void + type FieldOptional "pNext" VkMacOSSurfaceCreateInfoMVK = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkMacOSSurfaceCreateInfoMVK = + #{offset VkMacOSSurfaceCreateInfoMVK, pNext} + type FieldIsArray "pNext" VkMacOSSurfaceCreateInfoMVK = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkMacOSSurfaceCreateInfoMVK, pNext} + +instance CanReadField "pNext" VkMacOSSurfaceCreateInfoMVK where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkMacOSSurfaceCreateInfoMVK where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} HasVkFlags VkMacOSSurfaceCreateInfoMVK + where + type VkFlagsMType VkMacOSSurfaceCreateInfoMVK = + VkMacOSSurfaceCreateFlagsMVK + + {-# NOINLINE vkFlags #-} + vkFlags x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkMacOSSurfaceCreateInfoMVK, flags}) + + {-# INLINE vkFlagsByteOffset #-} + vkFlagsByteOffset ~_ + = #{offset VkMacOSSurfaceCreateInfoMVK, flags} + + {-# INLINE readVkFlags #-} + readVkFlags p + = peekByteOff p #{offset VkMacOSSurfaceCreateInfoMVK, flags} + + {-# INLINE writeVkFlags #-} + writeVkFlags p + = pokeByteOff p #{offset VkMacOSSurfaceCreateInfoMVK, flags} + +instance {-# OVERLAPPING #-} + HasField "flags" VkMacOSSurfaceCreateInfoMVK where + type FieldType "flags" VkMacOSSurfaceCreateInfoMVK = + VkMacOSSurfaceCreateFlagsMVK + type FieldOptional "flags" VkMacOSSurfaceCreateInfoMVK = 'True -- ' closing tick for hsc2hs + type FieldOffset "flags" VkMacOSSurfaceCreateInfoMVK = + #{offset VkMacOSSurfaceCreateInfoMVK, flags} + type FieldIsArray "flags" VkMacOSSurfaceCreateInfoMVK = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkMacOSSurfaceCreateInfoMVK, flags} + +instance CanReadField "flags" VkMacOSSurfaceCreateInfoMVK where + {-# INLINE getField #-} + getField = vkFlags + + {-# INLINE readField #-} + readField = readVkFlags + +instance CanWriteField "flags" VkMacOSSurfaceCreateInfoMVK where + {-# INLINE writeField #-} + writeField = writeVkFlags + +instance {-# OVERLAPPING #-} HasVkPView VkMacOSSurfaceCreateInfoMVK + where + type VkPViewMType VkMacOSSurfaceCreateInfoMVK = Ptr Void + + {-# NOINLINE vkPView #-} + vkPView x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkMacOSSurfaceCreateInfoMVK, pView}) + + {-# INLINE vkPViewByteOffset #-} + vkPViewByteOffset ~_ + = #{offset VkMacOSSurfaceCreateInfoMVK, pView} + + {-# INLINE readVkPView #-} + readVkPView p + = peekByteOff p #{offset VkMacOSSurfaceCreateInfoMVK, pView} + + {-# INLINE writeVkPView #-} + writeVkPView p + = pokeByteOff p #{offset VkMacOSSurfaceCreateInfoMVK, pView} + +instance {-# OVERLAPPING #-} + HasField "pView" VkMacOSSurfaceCreateInfoMVK where + type FieldType "pView" VkMacOSSurfaceCreateInfoMVK = Ptr Void + type FieldOptional "pView" VkMacOSSurfaceCreateInfoMVK = 'False -- ' closing tick for hsc2hs + type FieldOffset "pView" VkMacOSSurfaceCreateInfoMVK = + #{offset VkMacOSSurfaceCreateInfoMVK, pView} + type FieldIsArray "pView" VkMacOSSurfaceCreateInfoMVK = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkMacOSSurfaceCreateInfoMVK, pView} + +instance CanReadField "pView" VkMacOSSurfaceCreateInfoMVK where + {-# INLINE getField #-} + getField = vkPView + + {-# INLINE readField #-} + readField = readVkPView + +instance CanWriteField "pView" VkMacOSSurfaceCreateInfoMVK where + {-# INLINE writeField #-} + writeField = writeVkPView + +instance Show VkMacOSSurfaceCreateInfoMVK where + showsPrec d x + = showString "VkMacOSSurfaceCreateInfoMVK {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkFlags = " . + showsPrec d (vkFlags x) . + showString ", " . + showString "vkPView = " . showsPrec d (vkPView x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkMappedMemoryRange.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkMappedMemoryRange.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkMappedMemoryRange.hsc @@ -0,0 +1,317 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkMappedMemoryRange + (VkMappedMemoryRange(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.BaseTypes (VkDeviceSize) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Handles (VkDeviceMemory) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkMappedMemoryRange { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkDeviceMemory memory; +-- > VkDeviceSize offset; +-- > VkDeviceSize size; +-- > } VkMappedMemoryRange; +-- +-- +data VkMappedMemoryRange = VkMappedMemoryRange## Addr## ByteArray## + +instance Eq VkMappedMemoryRange where + (VkMappedMemoryRange## a _) == x@(VkMappedMemoryRange## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkMappedMemoryRange where + (VkMappedMemoryRange## a _) `compare` x@(VkMappedMemoryRange## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkMappedMemoryRange where + sizeOf ~_ = #{size VkMappedMemoryRange} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkMappedMemoryRange} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkMappedMemoryRange where + unsafeAddr (VkMappedMemoryRange## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkMappedMemoryRange## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkMappedMemoryRange## (plusAddr## (byteArrayContents## b) off) b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkMappedMemoryRange where + type StructFields VkMappedMemoryRange = + '["sType", "pNext", "memory", "offset", "size"] -- ' closing tick for hsc2hs + type CUnionType VkMappedMemoryRange = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkMappedMemoryRange = 'False -- ' closing tick for hsc2hs + type StructExtends VkMappedMemoryRange = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkSType VkMappedMemoryRange where + type VkSTypeMType VkMappedMemoryRange = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkMappedMemoryRange, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkMappedMemoryRange, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkMappedMemoryRange, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkMappedMemoryRange, sType} + +instance {-# OVERLAPPING #-} HasField "sType" VkMappedMemoryRange + where + type FieldType "sType" VkMappedMemoryRange = VkStructureType + type FieldOptional "sType" VkMappedMemoryRange = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkMappedMemoryRange = + #{offset VkMappedMemoryRange, sType} + type FieldIsArray "sType" VkMappedMemoryRange = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkMappedMemoryRange, sType} + +instance CanReadField "sType" VkMappedMemoryRange where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkMappedMemoryRange where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} HasVkPNext VkMappedMemoryRange where + type VkPNextMType VkMappedMemoryRange = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkMappedMemoryRange, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkMappedMemoryRange, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkMappedMemoryRange, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkMappedMemoryRange, pNext} + +instance {-# OVERLAPPING #-} HasField "pNext" VkMappedMemoryRange + where + type FieldType "pNext" VkMappedMemoryRange = Ptr Void + type FieldOptional "pNext" VkMappedMemoryRange = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkMappedMemoryRange = + #{offset VkMappedMemoryRange, pNext} + type FieldIsArray "pNext" VkMappedMemoryRange = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkMappedMemoryRange, pNext} + +instance CanReadField "pNext" VkMappedMemoryRange where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkMappedMemoryRange where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} HasVkMemory VkMappedMemoryRange where + type VkMemoryMType VkMappedMemoryRange = VkDeviceMemory + + {-# NOINLINE vkMemory #-} + vkMemory x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkMappedMemoryRange, memory}) + + {-# INLINE vkMemoryByteOffset #-} + vkMemoryByteOffset ~_ + = #{offset VkMappedMemoryRange, memory} + + {-# INLINE readVkMemory #-} + readVkMemory p + = peekByteOff p #{offset VkMappedMemoryRange, memory} + + {-# INLINE writeVkMemory #-} + writeVkMemory p + = pokeByteOff p #{offset VkMappedMemoryRange, memory} + +instance {-# OVERLAPPING #-} HasField "memory" VkMappedMemoryRange + where + type FieldType "memory" VkMappedMemoryRange = VkDeviceMemory + type FieldOptional "memory" VkMappedMemoryRange = 'False -- ' closing tick for hsc2hs + type FieldOffset "memory" VkMappedMemoryRange = + #{offset VkMappedMemoryRange, memory} + type FieldIsArray "memory" VkMappedMemoryRange = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkMappedMemoryRange, memory} + +instance CanReadField "memory" VkMappedMemoryRange where + {-# INLINE getField #-} + getField = vkMemory + + {-# INLINE readField #-} + readField = readVkMemory + +instance CanWriteField "memory" VkMappedMemoryRange where + {-# INLINE writeField #-} + writeField = writeVkMemory + +instance {-# OVERLAPPING #-} HasVkOffset VkMappedMemoryRange where + type VkOffsetMType VkMappedMemoryRange = VkDeviceSize + + {-# NOINLINE vkOffset #-} + vkOffset x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkMappedMemoryRange, offset}) + + {-# INLINE vkOffsetByteOffset #-} + vkOffsetByteOffset ~_ + = #{offset VkMappedMemoryRange, offset} + + {-# INLINE readVkOffset #-} + readVkOffset p + = peekByteOff p #{offset VkMappedMemoryRange, offset} + + {-# INLINE writeVkOffset #-} + writeVkOffset p + = pokeByteOff p #{offset VkMappedMemoryRange, offset} + +instance {-# OVERLAPPING #-} HasField "offset" VkMappedMemoryRange + where + type FieldType "offset" VkMappedMemoryRange = VkDeviceSize + type FieldOptional "offset" VkMappedMemoryRange = 'False -- ' closing tick for hsc2hs + type FieldOffset "offset" VkMappedMemoryRange = + #{offset VkMappedMemoryRange, offset} + type FieldIsArray "offset" VkMappedMemoryRange = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkMappedMemoryRange, offset} + +instance CanReadField "offset" VkMappedMemoryRange where + {-# INLINE getField #-} + getField = vkOffset + + {-# INLINE readField #-} + readField = readVkOffset + +instance CanWriteField "offset" VkMappedMemoryRange where + {-# INLINE writeField #-} + writeField = writeVkOffset + +instance {-# OVERLAPPING #-} HasVkSize VkMappedMemoryRange where + type VkSizeMType VkMappedMemoryRange = VkDeviceSize + + {-# NOINLINE vkSize #-} + vkSize x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkMappedMemoryRange, size}) + + {-# INLINE vkSizeByteOffset #-} + vkSizeByteOffset ~_ + = #{offset VkMappedMemoryRange, size} + + {-# INLINE readVkSize #-} + readVkSize p + = peekByteOff p #{offset VkMappedMemoryRange, size} + + {-# INLINE writeVkSize #-} + writeVkSize p + = pokeByteOff p #{offset VkMappedMemoryRange, size} + +instance {-# OVERLAPPING #-} HasField "size" VkMappedMemoryRange + where + type FieldType "size" VkMappedMemoryRange = VkDeviceSize + type FieldOptional "size" VkMappedMemoryRange = 'False -- ' closing tick for hsc2hs + type FieldOffset "size" VkMappedMemoryRange = + #{offset VkMappedMemoryRange, size} + type FieldIsArray "size" VkMappedMemoryRange = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkMappedMemoryRange, size} + +instance CanReadField "size" VkMappedMemoryRange where + {-# INLINE getField #-} + getField = vkSize + + {-# INLINE readField #-} + readField = readVkSize + +instance CanWriteField "size" VkMappedMemoryRange where + {-# INLINE writeField #-} + writeField = writeVkSize + +instance Show VkMappedMemoryRange where + showsPrec d x + = showString "VkMappedMemoryRange {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkMemory = " . + showsPrec d (vkMemory x) . + showString ", " . + showString "vkOffset = " . + showsPrec d (vkOffset x) . + showString ", " . + showString "vkSize = " . showsPrec d (vkSize x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkMemoryAllocateFlagsInfoKHX.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkMemoryAllocateFlagsInfoKHX.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkMemoryAllocateFlagsInfoKHX.hsc @@ -0,0 +1,290 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkMemoryAllocateFlagsInfoKHX + (VkMemoryAllocateFlagsInfoKHX(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkMemoryAllocateFlagsKHX (VkMemoryAllocateFlagsKHX) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Struct.VkMemoryAllocateInfo (VkMemoryAllocateInfo) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkMemoryAllocateFlagsInfoKHX { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkMemoryAllocateFlagsKHX flags; +-- > uint32_t deviceMask; +-- > } VkMemoryAllocateFlagsInfoKHX; +-- +-- +data VkMemoryAllocateFlagsInfoKHX = VkMemoryAllocateFlagsInfoKHX## Addr## + ByteArray## + +instance Eq VkMemoryAllocateFlagsInfoKHX where + (VkMemoryAllocateFlagsInfoKHX## a _) == + x@(VkMemoryAllocateFlagsInfoKHX## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkMemoryAllocateFlagsInfoKHX where + (VkMemoryAllocateFlagsInfoKHX## a _) `compare` + x@(VkMemoryAllocateFlagsInfoKHX## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkMemoryAllocateFlagsInfoKHX where + sizeOf ~_ = #{size VkMemoryAllocateFlagsInfoKHX} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkMemoryAllocateFlagsInfoKHX} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkMemoryAllocateFlagsInfoKHX where + unsafeAddr (VkMemoryAllocateFlagsInfoKHX## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkMemoryAllocateFlagsInfoKHX## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkMemoryAllocateFlagsInfoKHX## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkMemoryAllocateFlagsInfoKHX where + type StructFields VkMemoryAllocateFlagsInfoKHX = + '["sType", "pNext", "flags", "deviceMask"] -- ' closing tick for hsc2hs + type CUnionType VkMemoryAllocateFlagsInfoKHX = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkMemoryAllocateFlagsInfoKHX = 'False -- ' closing tick for hsc2hs + type StructExtends VkMemoryAllocateFlagsInfoKHX = + '[VkMemoryAllocateInfo] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkMemoryAllocateFlagsInfoKHX where + type VkSTypeMType VkMemoryAllocateFlagsInfoKHX = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkMemoryAllocateFlagsInfoKHX, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkMemoryAllocateFlagsInfoKHX, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkMemoryAllocateFlagsInfoKHX, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkMemoryAllocateFlagsInfoKHX, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkMemoryAllocateFlagsInfoKHX where + type FieldType "sType" VkMemoryAllocateFlagsInfoKHX = + VkStructureType + type FieldOptional "sType" VkMemoryAllocateFlagsInfoKHX = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkMemoryAllocateFlagsInfoKHX = + #{offset VkMemoryAllocateFlagsInfoKHX, sType} + type FieldIsArray "sType" VkMemoryAllocateFlagsInfoKHX = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkMemoryAllocateFlagsInfoKHX, sType} + +instance CanReadField "sType" VkMemoryAllocateFlagsInfoKHX where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkMemoryAllocateFlagsInfoKHX where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkMemoryAllocateFlagsInfoKHX where + type VkPNextMType VkMemoryAllocateFlagsInfoKHX = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkMemoryAllocateFlagsInfoKHX, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkMemoryAllocateFlagsInfoKHX, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkMemoryAllocateFlagsInfoKHX, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkMemoryAllocateFlagsInfoKHX, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkMemoryAllocateFlagsInfoKHX where + type FieldType "pNext" VkMemoryAllocateFlagsInfoKHX = Ptr Void + type FieldOptional "pNext" VkMemoryAllocateFlagsInfoKHX = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkMemoryAllocateFlagsInfoKHX = + #{offset VkMemoryAllocateFlagsInfoKHX, pNext} + type FieldIsArray "pNext" VkMemoryAllocateFlagsInfoKHX = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkMemoryAllocateFlagsInfoKHX, pNext} + +instance CanReadField "pNext" VkMemoryAllocateFlagsInfoKHX where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkMemoryAllocateFlagsInfoKHX where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkFlags VkMemoryAllocateFlagsInfoKHX where + type VkFlagsMType VkMemoryAllocateFlagsInfoKHX = + VkMemoryAllocateFlagsKHX + + {-# NOINLINE vkFlags #-} + vkFlags x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkMemoryAllocateFlagsInfoKHX, flags}) + + {-# INLINE vkFlagsByteOffset #-} + vkFlagsByteOffset ~_ + = #{offset VkMemoryAllocateFlagsInfoKHX, flags} + + {-# INLINE readVkFlags #-} + readVkFlags p + = peekByteOff p #{offset VkMemoryAllocateFlagsInfoKHX, flags} + + {-# INLINE writeVkFlags #-} + writeVkFlags p + = pokeByteOff p #{offset VkMemoryAllocateFlagsInfoKHX, flags} + +instance {-# OVERLAPPING #-} + HasField "flags" VkMemoryAllocateFlagsInfoKHX where + type FieldType "flags" VkMemoryAllocateFlagsInfoKHX = + VkMemoryAllocateFlagsKHX + type FieldOptional "flags" VkMemoryAllocateFlagsInfoKHX = 'True -- ' closing tick for hsc2hs + type FieldOffset "flags" VkMemoryAllocateFlagsInfoKHX = + #{offset VkMemoryAllocateFlagsInfoKHX, flags} + type FieldIsArray "flags" VkMemoryAllocateFlagsInfoKHX = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkMemoryAllocateFlagsInfoKHX, flags} + +instance CanReadField "flags" VkMemoryAllocateFlagsInfoKHX where + {-# INLINE getField #-} + getField = vkFlags + + {-# INLINE readField #-} + readField = readVkFlags + +instance CanWriteField "flags" VkMemoryAllocateFlagsInfoKHX where + {-# INLINE writeField #-} + writeField = writeVkFlags + +instance {-# OVERLAPPING #-} + HasVkDeviceMask VkMemoryAllocateFlagsInfoKHX where + type VkDeviceMaskMType VkMemoryAllocateFlagsInfoKHX = Word32 + + {-# NOINLINE vkDeviceMask #-} + vkDeviceMask x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkMemoryAllocateFlagsInfoKHX, deviceMask}) + + {-# INLINE vkDeviceMaskByteOffset #-} + vkDeviceMaskByteOffset ~_ + = #{offset VkMemoryAllocateFlagsInfoKHX, deviceMask} + + {-# INLINE readVkDeviceMask #-} + readVkDeviceMask p + = peekByteOff p #{offset VkMemoryAllocateFlagsInfoKHX, deviceMask} + + {-# INLINE writeVkDeviceMask #-} + writeVkDeviceMask p + = pokeByteOff p #{offset VkMemoryAllocateFlagsInfoKHX, deviceMask} + +instance {-# OVERLAPPING #-} + HasField "deviceMask" VkMemoryAllocateFlagsInfoKHX where + type FieldType "deviceMask" VkMemoryAllocateFlagsInfoKHX = Word32 + type FieldOptional "deviceMask" VkMemoryAllocateFlagsInfoKHX = + 'False -- ' closing tick for hsc2hs + type FieldOffset "deviceMask" VkMemoryAllocateFlagsInfoKHX = + #{offset VkMemoryAllocateFlagsInfoKHX, deviceMask} + type FieldIsArray "deviceMask" VkMemoryAllocateFlagsInfoKHX = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkMemoryAllocateFlagsInfoKHX, deviceMask} + +instance CanReadField "deviceMask" VkMemoryAllocateFlagsInfoKHX + where + {-# INLINE getField #-} + getField = vkDeviceMask + + {-# INLINE readField #-} + readField = readVkDeviceMask + +instance CanWriteField "deviceMask" VkMemoryAllocateFlagsInfoKHX + where + {-# INLINE writeField #-} + writeField = writeVkDeviceMask + +instance Show VkMemoryAllocateFlagsInfoKHX where + showsPrec d x + = showString "VkMemoryAllocateFlagsInfoKHX {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkFlags = " . + showsPrec d (vkFlags x) . + showString ", " . + showString "vkDeviceMask = " . + showsPrec d (vkDeviceMask x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkMemoryAllocateInfo.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkMemoryAllocateInfo.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkMemoryAllocateInfo.hsc @@ -0,0 +1,272 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkMemoryAllocateInfo + (VkMemoryAllocateInfo(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.BaseTypes (VkDeviceSize) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkMemoryAllocateInfo { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkDeviceSize allocationSize; +-- > uint32_t memoryTypeIndex; +-- > } VkMemoryAllocateInfo; +-- +-- +data VkMemoryAllocateInfo = VkMemoryAllocateInfo## Addr## ByteArray## + +instance Eq VkMemoryAllocateInfo where + (VkMemoryAllocateInfo## a _) == x@(VkMemoryAllocateInfo## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkMemoryAllocateInfo where + (VkMemoryAllocateInfo## a _) `compare` x@(VkMemoryAllocateInfo## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkMemoryAllocateInfo where + sizeOf ~_ = #{size VkMemoryAllocateInfo} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkMemoryAllocateInfo} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkMemoryAllocateInfo where + unsafeAddr (VkMemoryAllocateInfo## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkMemoryAllocateInfo## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkMemoryAllocateInfo## (plusAddr## (byteArrayContents## b) off) b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkMemoryAllocateInfo where + type StructFields VkMemoryAllocateInfo = + '["sType", "pNext", "allocationSize", "memoryTypeIndex"] -- ' closing tick for hsc2hs + type CUnionType VkMemoryAllocateInfo = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkMemoryAllocateInfo = 'False -- ' closing tick for hsc2hs + type StructExtends VkMemoryAllocateInfo = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkSType VkMemoryAllocateInfo where + type VkSTypeMType VkMemoryAllocateInfo = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkMemoryAllocateInfo, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkMemoryAllocateInfo, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkMemoryAllocateInfo, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkMemoryAllocateInfo, sType} + +instance {-# OVERLAPPING #-} HasField "sType" VkMemoryAllocateInfo + where + type FieldType "sType" VkMemoryAllocateInfo = VkStructureType + type FieldOptional "sType" VkMemoryAllocateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkMemoryAllocateInfo = + #{offset VkMemoryAllocateInfo, sType} + type FieldIsArray "sType" VkMemoryAllocateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkMemoryAllocateInfo, sType} + +instance CanReadField "sType" VkMemoryAllocateInfo where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkMemoryAllocateInfo where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} HasVkPNext VkMemoryAllocateInfo where + type VkPNextMType VkMemoryAllocateInfo = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkMemoryAllocateInfo, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkMemoryAllocateInfo, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkMemoryAllocateInfo, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkMemoryAllocateInfo, pNext} + +instance {-# OVERLAPPING #-} HasField "pNext" VkMemoryAllocateInfo + where + type FieldType "pNext" VkMemoryAllocateInfo = Ptr Void + type FieldOptional "pNext" VkMemoryAllocateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkMemoryAllocateInfo = + #{offset VkMemoryAllocateInfo, pNext} + type FieldIsArray "pNext" VkMemoryAllocateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkMemoryAllocateInfo, pNext} + +instance CanReadField "pNext" VkMemoryAllocateInfo where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkMemoryAllocateInfo where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkAllocationSize VkMemoryAllocateInfo where + type VkAllocationSizeMType VkMemoryAllocateInfo = VkDeviceSize + + {-# NOINLINE vkAllocationSize #-} + vkAllocationSize x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkMemoryAllocateInfo, allocationSize}) + + {-# INLINE vkAllocationSizeByteOffset #-} + vkAllocationSizeByteOffset ~_ + = #{offset VkMemoryAllocateInfo, allocationSize} + + {-# INLINE readVkAllocationSize #-} + readVkAllocationSize p + = peekByteOff p #{offset VkMemoryAllocateInfo, allocationSize} + + {-# INLINE writeVkAllocationSize #-} + writeVkAllocationSize p + = pokeByteOff p #{offset VkMemoryAllocateInfo, allocationSize} + +instance {-# OVERLAPPING #-} + HasField "allocationSize" VkMemoryAllocateInfo where + type FieldType "allocationSize" VkMemoryAllocateInfo = VkDeviceSize + type FieldOptional "allocationSize" VkMemoryAllocateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "allocationSize" VkMemoryAllocateInfo = + #{offset VkMemoryAllocateInfo, allocationSize} + type FieldIsArray "allocationSize" VkMemoryAllocateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkMemoryAllocateInfo, allocationSize} + +instance CanReadField "allocationSize" VkMemoryAllocateInfo where + {-# INLINE getField #-} + getField = vkAllocationSize + + {-# INLINE readField #-} + readField = readVkAllocationSize + +instance CanWriteField "allocationSize" VkMemoryAllocateInfo where + {-# INLINE writeField #-} + writeField = writeVkAllocationSize + +instance {-# OVERLAPPING #-} + HasVkMemoryTypeIndex VkMemoryAllocateInfo where + type VkMemoryTypeIndexMType VkMemoryAllocateInfo = Word32 + + {-# NOINLINE vkMemoryTypeIndex #-} + vkMemoryTypeIndex x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkMemoryAllocateInfo, memoryTypeIndex}) + + {-# INLINE vkMemoryTypeIndexByteOffset #-} + vkMemoryTypeIndexByteOffset ~_ + = #{offset VkMemoryAllocateInfo, memoryTypeIndex} + + {-# INLINE readVkMemoryTypeIndex #-} + readVkMemoryTypeIndex p + = peekByteOff p #{offset VkMemoryAllocateInfo, memoryTypeIndex} + + {-# INLINE writeVkMemoryTypeIndex #-} + writeVkMemoryTypeIndex p + = pokeByteOff p #{offset VkMemoryAllocateInfo, memoryTypeIndex} + +instance {-# OVERLAPPING #-} + HasField "memoryTypeIndex" VkMemoryAllocateInfo where + type FieldType "memoryTypeIndex" VkMemoryAllocateInfo = Word32 + type FieldOptional "memoryTypeIndex" VkMemoryAllocateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "memoryTypeIndex" VkMemoryAllocateInfo = + #{offset VkMemoryAllocateInfo, memoryTypeIndex} + type FieldIsArray "memoryTypeIndex" VkMemoryAllocateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkMemoryAllocateInfo, memoryTypeIndex} + +instance CanReadField "memoryTypeIndex" VkMemoryAllocateInfo where + {-# INLINE getField #-} + getField = vkMemoryTypeIndex + + {-# INLINE readField #-} + readField = readVkMemoryTypeIndex + +instance CanWriteField "memoryTypeIndex" VkMemoryAllocateInfo where + {-# INLINE writeField #-} + writeField = writeVkMemoryTypeIndex + +instance Show VkMemoryAllocateInfo where + showsPrec d x + = showString "VkMemoryAllocateInfo {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkAllocationSize = " . + showsPrec d (vkAllocationSize x) . + showString ", " . + showString "vkMemoryTypeIndex = " . + showsPrec d (vkMemoryTypeIndex x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkMemoryBarrier.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkMemoryBarrier.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkMemoryBarrier.hsc @@ -0,0 +1,266 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkMemoryBarrier + (VkMemoryBarrier(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkAccessFlags (VkAccessFlags) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkMemoryBarrier { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkAccessFlags srcAccessMask; +-- > VkAccessFlags dstAccessMask; +-- > } VkMemoryBarrier; +-- +-- +data VkMemoryBarrier = VkMemoryBarrier## Addr## ByteArray## + +instance Eq VkMemoryBarrier where + (VkMemoryBarrier## a _) == x@(VkMemoryBarrier## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkMemoryBarrier where + (VkMemoryBarrier## a _) `compare` x@(VkMemoryBarrier## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkMemoryBarrier where + sizeOf ~_ = #{size VkMemoryBarrier} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkMemoryBarrier} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkMemoryBarrier where + unsafeAddr (VkMemoryBarrier## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkMemoryBarrier## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkMemoryBarrier## (plusAddr## (byteArrayContents## b) off) b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkMemoryBarrier where + type StructFields VkMemoryBarrier = + '["sType", "pNext", "srcAccessMask", "dstAccessMask"] -- ' closing tick for hsc2hs + type CUnionType VkMemoryBarrier = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkMemoryBarrier = 'False -- ' closing tick for hsc2hs + type StructExtends VkMemoryBarrier = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkSType VkMemoryBarrier where + type VkSTypeMType VkMemoryBarrier = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkMemoryBarrier, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ = #{offset VkMemoryBarrier, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkMemoryBarrier, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkMemoryBarrier, sType} + +instance {-# OVERLAPPING #-} HasField "sType" VkMemoryBarrier where + type FieldType "sType" VkMemoryBarrier = VkStructureType + type FieldOptional "sType" VkMemoryBarrier = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkMemoryBarrier = + #{offset VkMemoryBarrier, sType} + type FieldIsArray "sType" VkMemoryBarrier = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkMemoryBarrier, sType} + +instance CanReadField "sType" VkMemoryBarrier where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkMemoryBarrier where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} HasVkPNext VkMemoryBarrier where + type VkPNextMType VkMemoryBarrier = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkMemoryBarrier, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ = #{offset VkMemoryBarrier, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkMemoryBarrier, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkMemoryBarrier, pNext} + +instance {-# OVERLAPPING #-} HasField "pNext" VkMemoryBarrier where + type FieldType "pNext" VkMemoryBarrier = Ptr Void + type FieldOptional "pNext" VkMemoryBarrier = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkMemoryBarrier = + #{offset VkMemoryBarrier, pNext} + type FieldIsArray "pNext" VkMemoryBarrier = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkMemoryBarrier, pNext} + +instance CanReadField "pNext" VkMemoryBarrier where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkMemoryBarrier where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} HasVkSrcAccessMask VkMemoryBarrier + where + type VkSrcAccessMaskMType VkMemoryBarrier = VkAccessFlags + + {-# NOINLINE vkSrcAccessMask #-} + vkSrcAccessMask x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkMemoryBarrier, srcAccessMask}) + + {-# INLINE vkSrcAccessMaskByteOffset #-} + vkSrcAccessMaskByteOffset ~_ + = #{offset VkMemoryBarrier, srcAccessMask} + + {-# INLINE readVkSrcAccessMask #-} + readVkSrcAccessMask p + = peekByteOff p #{offset VkMemoryBarrier, srcAccessMask} + + {-# INLINE writeVkSrcAccessMask #-} + writeVkSrcAccessMask p + = pokeByteOff p #{offset VkMemoryBarrier, srcAccessMask} + +instance {-# OVERLAPPING #-} + HasField "srcAccessMask" VkMemoryBarrier where + type FieldType "srcAccessMask" VkMemoryBarrier = VkAccessFlags + type FieldOptional "srcAccessMask" VkMemoryBarrier = 'True -- ' closing tick for hsc2hs + type FieldOffset "srcAccessMask" VkMemoryBarrier = + #{offset VkMemoryBarrier, srcAccessMask} + type FieldIsArray "srcAccessMask" VkMemoryBarrier = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkMemoryBarrier, srcAccessMask} + +instance CanReadField "srcAccessMask" VkMemoryBarrier where + {-# INLINE getField #-} + getField = vkSrcAccessMask + + {-# INLINE readField #-} + readField = readVkSrcAccessMask + +instance CanWriteField "srcAccessMask" VkMemoryBarrier where + {-# INLINE writeField #-} + writeField = writeVkSrcAccessMask + +instance {-# OVERLAPPING #-} HasVkDstAccessMask VkMemoryBarrier + where + type VkDstAccessMaskMType VkMemoryBarrier = VkAccessFlags + + {-# NOINLINE vkDstAccessMask #-} + vkDstAccessMask x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkMemoryBarrier, dstAccessMask}) + + {-# INLINE vkDstAccessMaskByteOffset #-} + vkDstAccessMaskByteOffset ~_ + = #{offset VkMemoryBarrier, dstAccessMask} + + {-# INLINE readVkDstAccessMask #-} + readVkDstAccessMask p + = peekByteOff p #{offset VkMemoryBarrier, dstAccessMask} + + {-# INLINE writeVkDstAccessMask #-} + writeVkDstAccessMask p + = pokeByteOff p #{offset VkMemoryBarrier, dstAccessMask} + +instance {-# OVERLAPPING #-} + HasField "dstAccessMask" VkMemoryBarrier where + type FieldType "dstAccessMask" VkMemoryBarrier = VkAccessFlags + type FieldOptional "dstAccessMask" VkMemoryBarrier = 'True -- ' closing tick for hsc2hs + type FieldOffset "dstAccessMask" VkMemoryBarrier = + #{offset VkMemoryBarrier, dstAccessMask} + type FieldIsArray "dstAccessMask" VkMemoryBarrier = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkMemoryBarrier, dstAccessMask} + +instance CanReadField "dstAccessMask" VkMemoryBarrier where + {-# INLINE getField #-} + getField = vkDstAccessMask + + {-# INLINE readField #-} + readField = readVkDstAccessMask + +instance CanWriteField "dstAccessMask" VkMemoryBarrier where + {-# INLINE writeField #-} + writeField = writeVkDstAccessMask + +instance Show VkMemoryBarrier where + showsPrec d x + = showString "VkMemoryBarrier {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkSrcAccessMask = " . + showsPrec d (vkSrcAccessMask x) . + showString ", " . + showString "vkDstAccessMask = " . + showsPrec d (vkDstAccessMask x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkMemoryDedicatedAllocateInfoKHR.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkMemoryDedicatedAllocateInfoKHR.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkMemoryDedicatedAllocateInfoKHR.hsc @@ -0,0 +1,298 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkMemoryDedicatedAllocateInfoKHR + (VkMemoryDedicatedAllocateInfoKHR(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Handles (VkBuffer, + VkImage) +import Graphics.Vulkan.Types.Struct.VkMemoryAllocateInfo (VkMemoryAllocateInfo) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkMemoryDedicatedAllocateInfoKHR { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkImage image; +-- > VkBuffer buffer; +-- > } VkMemoryDedicatedAllocateInfoKHR; +-- +-- +data VkMemoryDedicatedAllocateInfoKHR = VkMemoryDedicatedAllocateInfoKHR## Addr## + ByteArray## + +instance Eq VkMemoryDedicatedAllocateInfoKHR where + (VkMemoryDedicatedAllocateInfoKHR## a _) == + x@(VkMemoryDedicatedAllocateInfoKHR## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkMemoryDedicatedAllocateInfoKHR where + (VkMemoryDedicatedAllocateInfoKHR## a _) `compare` + x@(VkMemoryDedicatedAllocateInfoKHR## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkMemoryDedicatedAllocateInfoKHR where + sizeOf ~_ = #{size VkMemoryDedicatedAllocateInfoKHR} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkMemoryDedicatedAllocateInfoKHR} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkMemoryDedicatedAllocateInfoKHR where + unsafeAddr (VkMemoryDedicatedAllocateInfoKHR## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkMemoryDedicatedAllocateInfoKHR## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkMemoryDedicatedAllocateInfoKHR## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkMemoryDedicatedAllocateInfoKHR where + type StructFields VkMemoryDedicatedAllocateInfoKHR = + '["sType", "pNext", "image", "buffer"] -- ' closing tick for hsc2hs + type CUnionType VkMemoryDedicatedAllocateInfoKHR = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkMemoryDedicatedAllocateInfoKHR = 'False -- ' closing tick for hsc2hs + type StructExtends VkMemoryDedicatedAllocateInfoKHR = + '[VkMemoryAllocateInfo] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkMemoryDedicatedAllocateInfoKHR where + type VkSTypeMType VkMemoryDedicatedAllocateInfoKHR = + VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkMemoryDedicatedAllocateInfoKHR, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkMemoryDedicatedAllocateInfoKHR, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkMemoryDedicatedAllocateInfoKHR, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkMemoryDedicatedAllocateInfoKHR, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkMemoryDedicatedAllocateInfoKHR where + type FieldType "sType" VkMemoryDedicatedAllocateInfoKHR = + VkStructureType + type FieldOptional "sType" VkMemoryDedicatedAllocateInfoKHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkMemoryDedicatedAllocateInfoKHR = + #{offset VkMemoryDedicatedAllocateInfoKHR, sType} + type FieldIsArray "sType" VkMemoryDedicatedAllocateInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkMemoryDedicatedAllocateInfoKHR, sType} + +instance CanReadField "sType" VkMemoryDedicatedAllocateInfoKHR + where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkMemoryDedicatedAllocateInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkMemoryDedicatedAllocateInfoKHR where + type VkPNextMType VkMemoryDedicatedAllocateInfoKHR = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkMemoryDedicatedAllocateInfoKHR, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkMemoryDedicatedAllocateInfoKHR, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkMemoryDedicatedAllocateInfoKHR, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkMemoryDedicatedAllocateInfoKHR, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkMemoryDedicatedAllocateInfoKHR where + type FieldType "pNext" VkMemoryDedicatedAllocateInfoKHR = Ptr Void + type FieldOptional "pNext" VkMemoryDedicatedAllocateInfoKHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkMemoryDedicatedAllocateInfoKHR = + #{offset VkMemoryDedicatedAllocateInfoKHR, pNext} + type FieldIsArray "pNext" VkMemoryDedicatedAllocateInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkMemoryDedicatedAllocateInfoKHR, pNext} + +instance CanReadField "pNext" VkMemoryDedicatedAllocateInfoKHR + where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkMemoryDedicatedAllocateInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkImage VkMemoryDedicatedAllocateInfoKHR where + type VkImageMType VkMemoryDedicatedAllocateInfoKHR = VkImage + + {-# NOINLINE vkImage #-} + vkImage x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkMemoryDedicatedAllocateInfoKHR, image}) + + {-# INLINE vkImageByteOffset #-} + vkImageByteOffset ~_ + = #{offset VkMemoryDedicatedAllocateInfoKHR, image} + + {-# INLINE readVkImage #-} + readVkImage p + = peekByteOff p #{offset VkMemoryDedicatedAllocateInfoKHR, image} + + {-# INLINE writeVkImage #-} + writeVkImage p + = pokeByteOff p #{offset VkMemoryDedicatedAllocateInfoKHR, image} + +instance {-# OVERLAPPING #-} + HasField "image" VkMemoryDedicatedAllocateInfoKHR where + type FieldType "image" VkMemoryDedicatedAllocateInfoKHR = VkImage + type FieldOptional "image" VkMemoryDedicatedAllocateInfoKHR = 'True -- ' closing tick for hsc2hs + type FieldOffset "image" VkMemoryDedicatedAllocateInfoKHR = + #{offset VkMemoryDedicatedAllocateInfoKHR, image} + type FieldIsArray "image" VkMemoryDedicatedAllocateInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkMemoryDedicatedAllocateInfoKHR, image} + +instance CanReadField "image" VkMemoryDedicatedAllocateInfoKHR + where + {-# INLINE getField #-} + getField = vkImage + + {-# INLINE readField #-} + readField = readVkImage + +instance CanWriteField "image" VkMemoryDedicatedAllocateInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkImage + +instance {-# OVERLAPPING #-} + HasVkBuffer VkMemoryDedicatedAllocateInfoKHR where + type VkBufferMType VkMemoryDedicatedAllocateInfoKHR = VkBuffer + + {-# NOINLINE vkBuffer #-} + vkBuffer x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkMemoryDedicatedAllocateInfoKHR, buffer}) + + {-# INLINE vkBufferByteOffset #-} + vkBufferByteOffset ~_ + = #{offset VkMemoryDedicatedAllocateInfoKHR, buffer} + + {-# INLINE readVkBuffer #-} + readVkBuffer p + = peekByteOff p #{offset VkMemoryDedicatedAllocateInfoKHR, buffer} + + {-# INLINE writeVkBuffer #-} + writeVkBuffer p + = pokeByteOff p #{offset VkMemoryDedicatedAllocateInfoKHR, buffer} + +instance {-# OVERLAPPING #-} + HasField "buffer" VkMemoryDedicatedAllocateInfoKHR where + type FieldType "buffer" VkMemoryDedicatedAllocateInfoKHR = VkBuffer + type FieldOptional "buffer" VkMemoryDedicatedAllocateInfoKHR = + 'True -- ' closing tick for hsc2hs + type FieldOffset "buffer" VkMemoryDedicatedAllocateInfoKHR = + #{offset VkMemoryDedicatedAllocateInfoKHR, buffer} + type FieldIsArray "buffer" VkMemoryDedicatedAllocateInfoKHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkMemoryDedicatedAllocateInfoKHR, buffer} + +instance CanReadField "buffer" VkMemoryDedicatedAllocateInfoKHR + where + {-# INLINE getField #-} + getField = vkBuffer + + {-# INLINE readField #-} + readField = readVkBuffer + +instance CanWriteField "buffer" VkMemoryDedicatedAllocateInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkBuffer + +instance Show VkMemoryDedicatedAllocateInfoKHR where + showsPrec d x + = showString "VkMemoryDedicatedAllocateInfoKHR {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkImage = " . + showsPrec d (vkImage x) . + showString ", " . + showString "vkBuffer = " . showsPrec d (vkBuffer x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkMemoryDedicatedRequirementsKHR.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkMemoryDedicatedRequirementsKHR.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkMemoryDedicatedRequirementsKHR.hsc @@ -0,0 +1,305 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkMemoryDedicatedRequirementsKHR + (VkMemoryDedicatedRequirementsKHR(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.BaseTypes (VkBool32) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Struct.VkMemoryRequirements2KHR (VkMemoryRequirements2KHR) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkMemoryDedicatedRequirementsKHR { +-- > VkStructureType sType; +-- > void* pNext; +-- > VkBool32 prefersDedicatedAllocation; +-- > VkBool32 requiresDedicatedAllocation; +-- > } VkMemoryDedicatedRequirementsKHR; +-- +-- +data VkMemoryDedicatedRequirementsKHR = VkMemoryDedicatedRequirementsKHR## Addr## + ByteArray## + +instance Eq VkMemoryDedicatedRequirementsKHR where + (VkMemoryDedicatedRequirementsKHR## a _) == + x@(VkMemoryDedicatedRequirementsKHR## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkMemoryDedicatedRequirementsKHR where + (VkMemoryDedicatedRequirementsKHR## a _) `compare` + x@(VkMemoryDedicatedRequirementsKHR## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkMemoryDedicatedRequirementsKHR where + sizeOf ~_ = #{size VkMemoryDedicatedRequirementsKHR} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkMemoryDedicatedRequirementsKHR} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkMemoryDedicatedRequirementsKHR where + unsafeAddr (VkMemoryDedicatedRequirementsKHR## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkMemoryDedicatedRequirementsKHR## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkMemoryDedicatedRequirementsKHR## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkMemoryDedicatedRequirementsKHR where + type StructFields VkMemoryDedicatedRequirementsKHR = + '["sType", "pNext", "prefersDedicatedAllocation", -- ' closing tick for hsc2hs + "requiresDedicatedAllocation"] + type CUnionType VkMemoryDedicatedRequirementsKHR = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkMemoryDedicatedRequirementsKHR = 'True -- ' closing tick for hsc2hs + type StructExtends VkMemoryDedicatedRequirementsKHR = + '[VkMemoryRequirements2KHR] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkMemoryDedicatedRequirementsKHR where + type VkSTypeMType VkMemoryDedicatedRequirementsKHR = + VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkMemoryDedicatedRequirementsKHR, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkMemoryDedicatedRequirementsKHR, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkMemoryDedicatedRequirementsKHR, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkMemoryDedicatedRequirementsKHR, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkMemoryDedicatedRequirementsKHR where + type FieldType "sType" VkMemoryDedicatedRequirementsKHR = + VkStructureType + type FieldOptional "sType" VkMemoryDedicatedRequirementsKHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkMemoryDedicatedRequirementsKHR = + #{offset VkMemoryDedicatedRequirementsKHR, sType} + type FieldIsArray "sType" VkMemoryDedicatedRequirementsKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkMemoryDedicatedRequirementsKHR, sType} + +instance CanReadField "sType" VkMemoryDedicatedRequirementsKHR + where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkMemoryDedicatedRequirementsKHR where + type VkPNextMType VkMemoryDedicatedRequirementsKHR = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkMemoryDedicatedRequirementsKHR, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkMemoryDedicatedRequirementsKHR, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkMemoryDedicatedRequirementsKHR, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkMemoryDedicatedRequirementsKHR, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkMemoryDedicatedRequirementsKHR where + type FieldType "pNext" VkMemoryDedicatedRequirementsKHR = Ptr Void + type FieldOptional "pNext" VkMemoryDedicatedRequirementsKHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkMemoryDedicatedRequirementsKHR = + #{offset VkMemoryDedicatedRequirementsKHR, pNext} + type FieldIsArray "pNext" VkMemoryDedicatedRequirementsKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkMemoryDedicatedRequirementsKHR, pNext} + +instance CanReadField "pNext" VkMemoryDedicatedRequirementsKHR + where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance {-# OVERLAPPING #-} + HasVkPrefersDedicatedAllocation VkMemoryDedicatedRequirementsKHR + where + type VkPrefersDedicatedAllocationMType + VkMemoryDedicatedRequirementsKHR + = VkBool32 + + {-# NOINLINE vkPrefersDedicatedAllocation #-} + vkPrefersDedicatedAllocation x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkMemoryDedicatedRequirementsKHR, prefersDedicatedAllocation}) + + {-# INLINE vkPrefersDedicatedAllocationByteOffset #-} + vkPrefersDedicatedAllocationByteOffset ~_ + = #{offset VkMemoryDedicatedRequirementsKHR, prefersDedicatedAllocation} + + {-# INLINE readVkPrefersDedicatedAllocation #-} + readVkPrefersDedicatedAllocation p + = peekByteOff p #{offset VkMemoryDedicatedRequirementsKHR, prefersDedicatedAllocation} + + {-# INLINE writeVkPrefersDedicatedAllocation #-} + writeVkPrefersDedicatedAllocation p + = pokeByteOff p #{offset VkMemoryDedicatedRequirementsKHR, prefersDedicatedAllocation} + +instance {-# OVERLAPPING #-} + HasField "prefersDedicatedAllocation" + VkMemoryDedicatedRequirementsKHR + where + type FieldType "prefersDedicatedAllocation" + VkMemoryDedicatedRequirementsKHR + = VkBool32 + type FieldOptional "prefersDedicatedAllocation" + VkMemoryDedicatedRequirementsKHR + = 'False -- ' closing tick for hsc2hs + type FieldOffset "prefersDedicatedAllocation" + VkMemoryDedicatedRequirementsKHR + = + #{offset VkMemoryDedicatedRequirementsKHR, prefersDedicatedAllocation} + type FieldIsArray "prefersDedicatedAllocation" + VkMemoryDedicatedRequirementsKHR + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkMemoryDedicatedRequirementsKHR, prefersDedicatedAllocation} + +instance CanReadField "prefersDedicatedAllocation" + VkMemoryDedicatedRequirementsKHR + where + {-# INLINE getField #-} + getField = vkPrefersDedicatedAllocation + + {-# INLINE readField #-} + readField = readVkPrefersDedicatedAllocation + +instance {-# OVERLAPPING #-} + HasVkRequiresDedicatedAllocation VkMemoryDedicatedRequirementsKHR + where + type VkRequiresDedicatedAllocationMType + VkMemoryDedicatedRequirementsKHR + = VkBool32 + + {-# NOINLINE vkRequiresDedicatedAllocation #-} + vkRequiresDedicatedAllocation x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkMemoryDedicatedRequirementsKHR, requiresDedicatedAllocation}) + + {-# INLINE vkRequiresDedicatedAllocationByteOffset #-} + vkRequiresDedicatedAllocationByteOffset ~_ + = #{offset VkMemoryDedicatedRequirementsKHR, requiresDedicatedAllocation} + + {-# INLINE readVkRequiresDedicatedAllocation #-} + readVkRequiresDedicatedAllocation p + = peekByteOff p #{offset VkMemoryDedicatedRequirementsKHR, requiresDedicatedAllocation} + + {-# INLINE writeVkRequiresDedicatedAllocation #-} + writeVkRequiresDedicatedAllocation p + = pokeByteOff p #{offset VkMemoryDedicatedRequirementsKHR, requiresDedicatedAllocation} + +instance {-# OVERLAPPING #-} + HasField "requiresDedicatedAllocation" + VkMemoryDedicatedRequirementsKHR + where + type FieldType "requiresDedicatedAllocation" + VkMemoryDedicatedRequirementsKHR + = VkBool32 + type FieldOptional "requiresDedicatedAllocation" + VkMemoryDedicatedRequirementsKHR + = 'False -- ' closing tick for hsc2hs + type FieldOffset "requiresDedicatedAllocation" + VkMemoryDedicatedRequirementsKHR + = + #{offset VkMemoryDedicatedRequirementsKHR, requiresDedicatedAllocation} + type FieldIsArray "requiresDedicatedAllocation" + VkMemoryDedicatedRequirementsKHR + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkMemoryDedicatedRequirementsKHR, requiresDedicatedAllocation} + +instance CanReadField "requiresDedicatedAllocation" + VkMemoryDedicatedRequirementsKHR + where + {-# INLINE getField #-} + getField = vkRequiresDedicatedAllocation + + {-# INLINE readField #-} + readField = readVkRequiresDedicatedAllocation + +instance Show VkMemoryDedicatedRequirementsKHR where + showsPrec d x + = showString "VkMemoryDedicatedRequirementsKHR {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkPrefersDedicatedAllocation = " . + showsPrec d (vkPrefersDedicatedAllocation x) . + showString ", " . + showString "vkRequiresDedicatedAllocation = " . + showsPrec d (vkRequiresDedicatedAllocation x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkMemoryFdPropertiesKHR.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkMemoryFdPropertiesKHR.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkMemoryFdPropertiesKHR.hsc @@ -0,0 +1,213 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkMemoryFdPropertiesKHR + (VkMemoryFdPropertiesKHR(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkMemoryFdPropertiesKHR { +-- > VkStructureType sType; +-- > void* pNext; +-- > uint32_t memoryTypeBits; +-- > } VkMemoryFdPropertiesKHR; +-- +-- +data VkMemoryFdPropertiesKHR = VkMemoryFdPropertiesKHR## Addr## + ByteArray## + +instance Eq VkMemoryFdPropertiesKHR where + (VkMemoryFdPropertiesKHR## a _) == x@(VkMemoryFdPropertiesKHR## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkMemoryFdPropertiesKHR where + (VkMemoryFdPropertiesKHR## a _) `compare` + x@(VkMemoryFdPropertiesKHR## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkMemoryFdPropertiesKHR where + sizeOf ~_ = #{size VkMemoryFdPropertiesKHR} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkMemoryFdPropertiesKHR} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkMemoryFdPropertiesKHR where + unsafeAddr (VkMemoryFdPropertiesKHR## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkMemoryFdPropertiesKHR## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkMemoryFdPropertiesKHR## (plusAddr## (byteArrayContents## b) off) b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkMemoryFdPropertiesKHR where + type StructFields VkMemoryFdPropertiesKHR = + '["sType", "pNext", "memoryTypeBits"] -- ' closing tick for hsc2hs + type CUnionType VkMemoryFdPropertiesKHR = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkMemoryFdPropertiesKHR = 'True -- ' closing tick for hsc2hs + type StructExtends VkMemoryFdPropertiesKHR = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkSType VkMemoryFdPropertiesKHR + where + type VkSTypeMType VkMemoryFdPropertiesKHR = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkMemoryFdPropertiesKHR, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkMemoryFdPropertiesKHR, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkMemoryFdPropertiesKHR, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkMemoryFdPropertiesKHR, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkMemoryFdPropertiesKHR where + type FieldType "sType" VkMemoryFdPropertiesKHR = VkStructureType + type FieldOptional "sType" VkMemoryFdPropertiesKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkMemoryFdPropertiesKHR = + #{offset VkMemoryFdPropertiesKHR, sType} + type FieldIsArray "sType" VkMemoryFdPropertiesKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkMemoryFdPropertiesKHR, sType} + +instance CanReadField "sType" VkMemoryFdPropertiesKHR where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance {-# OVERLAPPING #-} HasVkPNext VkMemoryFdPropertiesKHR + where + type VkPNextMType VkMemoryFdPropertiesKHR = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkMemoryFdPropertiesKHR, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkMemoryFdPropertiesKHR, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkMemoryFdPropertiesKHR, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkMemoryFdPropertiesKHR, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkMemoryFdPropertiesKHR where + type FieldType "pNext" VkMemoryFdPropertiesKHR = Ptr Void + type FieldOptional "pNext" VkMemoryFdPropertiesKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkMemoryFdPropertiesKHR = + #{offset VkMemoryFdPropertiesKHR, pNext} + type FieldIsArray "pNext" VkMemoryFdPropertiesKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkMemoryFdPropertiesKHR, pNext} + +instance CanReadField "pNext" VkMemoryFdPropertiesKHR where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance {-# OVERLAPPING #-} + HasVkMemoryTypeBits VkMemoryFdPropertiesKHR where + type VkMemoryTypeBitsMType VkMemoryFdPropertiesKHR = Word32 + + {-# NOINLINE vkMemoryTypeBits #-} + vkMemoryTypeBits x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkMemoryFdPropertiesKHR, memoryTypeBits}) + + {-# INLINE vkMemoryTypeBitsByteOffset #-} + vkMemoryTypeBitsByteOffset ~_ + = #{offset VkMemoryFdPropertiesKHR, memoryTypeBits} + + {-# INLINE readVkMemoryTypeBits #-} + readVkMemoryTypeBits p + = peekByteOff p #{offset VkMemoryFdPropertiesKHR, memoryTypeBits} + + {-# INLINE writeVkMemoryTypeBits #-} + writeVkMemoryTypeBits p + = pokeByteOff p #{offset VkMemoryFdPropertiesKHR, memoryTypeBits} + +instance {-# OVERLAPPING #-} + HasField "memoryTypeBits" VkMemoryFdPropertiesKHR where + type FieldType "memoryTypeBits" VkMemoryFdPropertiesKHR = Word32 + type FieldOptional "memoryTypeBits" VkMemoryFdPropertiesKHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "memoryTypeBits" VkMemoryFdPropertiesKHR = + #{offset VkMemoryFdPropertiesKHR, memoryTypeBits} + type FieldIsArray "memoryTypeBits" VkMemoryFdPropertiesKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkMemoryFdPropertiesKHR, memoryTypeBits} + +instance CanReadField "memoryTypeBits" VkMemoryFdPropertiesKHR + where + {-# INLINE getField #-} + getField = vkMemoryTypeBits + + {-# INLINE readField #-} + readField = readVkMemoryTypeBits + +instance Show VkMemoryFdPropertiesKHR where + showsPrec d x + = showString "VkMemoryFdPropertiesKHR {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkMemoryTypeBits = " . + showsPrec d (vkMemoryTypeBits x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkMemoryGetFdInfoKHR.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkMemoryGetFdInfoKHR.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkMemoryGetFdInfoKHR.hsc @@ -0,0 +1,273 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkMemoryGetFdInfoKHR + (VkMemoryGetFdInfoKHR(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkExternalMemoryHandleTypeFlagsKHR (VkExternalMemoryHandleTypeFlagBitsKHR) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Handles (VkDeviceMemory) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkMemoryGetFdInfoKHR { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkDeviceMemory memory; +-- > VkExternalMemoryHandleTypeFlagBitsKHR handleType; +-- > } VkMemoryGetFdInfoKHR; +-- +-- +data VkMemoryGetFdInfoKHR = VkMemoryGetFdInfoKHR## Addr## ByteArray## + +instance Eq VkMemoryGetFdInfoKHR where + (VkMemoryGetFdInfoKHR## a _) == x@(VkMemoryGetFdInfoKHR## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkMemoryGetFdInfoKHR where + (VkMemoryGetFdInfoKHR## a _) `compare` x@(VkMemoryGetFdInfoKHR## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkMemoryGetFdInfoKHR where + sizeOf ~_ = #{size VkMemoryGetFdInfoKHR} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkMemoryGetFdInfoKHR} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkMemoryGetFdInfoKHR where + unsafeAddr (VkMemoryGetFdInfoKHR## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkMemoryGetFdInfoKHR## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkMemoryGetFdInfoKHR## (plusAddr## (byteArrayContents## b) off) b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkMemoryGetFdInfoKHR where + type StructFields VkMemoryGetFdInfoKHR = + '["sType", "pNext", "memory", "handleType"] -- ' closing tick for hsc2hs + type CUnionType VkMemoryGetFdInfoKHR = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkMemoryGetFdInfoKHR = 'False -- ' closing tick for hsc2hs + type StructExtends VkMemoryGetFdInfoKHR = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkSType VkMemoryGetFdInfoKHR where + type VkSTypeMType VkMemoryGetFdInfoKHR = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkMemoryGetFdInfoKHR, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkMemoryGetFdInfoKHR, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkMemoryGetFdInfoKHR, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkMemoryGetFdInfoKHR, sType} + +instance {-# OVERLAPPING #-} HasField "sType" VkMemoryGetFdInfoKHR + where + type FieldType "sType" VkMemoryGetFdInfoKHR = VkStructureType + type FieldOptional "sType" VkMemoryGetFdInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkMemoryGetFdInfoKHR = + #{offset VkMemoryGetFdInfoKHR, sType} + type FieldIsArray "sType" VkMemoryGetFdInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkMemoryGetFdInfoKHR, sType} + +instance CanReadField "sType" VkMemoryGetFdInfoKHR where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkMemoryGetFdInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} HasVkPNext VkMemoryGetFdInfoKHR where + type VkPNextMType VkMemoryGetFdInfoKHR = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkMemoryGetFdInfoKHR, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkMemoryGetFdInfoKHR, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkMemoryGetFdInfoKHR, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkMemoryGetFdInfoKHR, pNext} + +instance {-# OVERLAPPING #-} HasField "pNext" VkMemoryGetFdInfoKHR + where + type FieldType "pNext" VkMemoryGetFdInfoKHR = Ptr Void + type FieldOptional "pNext" VkMemoryGetFdInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkMemoryGetFdInfoKHR = + #{offset VkMemoryGetFdInfoKHR, pNext} + type FieldIsArray "pNext" VkMemoryGetFdInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkMemoryGetFdInfoKHR, pNext} + +instance CanReadField "pNext" VkMemoryGetFdInfoKHR where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkMemoryGetFdInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} HasVkMemory VkMemoryGetFdInfoKHR where + type VkMemoryMType VkMemoryGetFdInfoKHR = VkDeviceMemory + + {-# NOINLINE vkMemory #-} + vkMemory x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkMemoryGetFdInfoKHR, memory}) + + {-# INLINE vkMemoryByteOffset #-} + vkMemoryByteOffset ~_ + = #{offset VkMemoryGetFdInfoKHR, memory} + + {-# INLINE readVkMemory #-} + readVkMemory p + = peekByteOff p #{offset VkMemoryGetFdInfoKHR, memory} + + {-# INLINE writeVkMemory #-} + writeVkMemory p + = pokeByteOff p #{offset VkMemoryGetFdInfoKHR, memory} + +instance {-# OVERLAPPING #-} HasField "memory" VkMemoryGetFdInfoKHR + where + type FieldType "memory" VkMemoryGetFdInfoKHR = VkDeviceMemory + type FieldOptional "memory" VkMemoryGetFdInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "memory" VkMemoryGetFdInfoKHR = + #{offset VkMemoryGetFdInfoKHR, memory} + type FieldIsArray "memory" VkMemoryGetFdInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkMemoryGetFdInfoKHR, memory} + +instance CanReadField "memory" VkMemoryGetFdInfoKHR where + {-# INLINE getField #-} + getField = vkMemory + + {-# INLINE readField #-} + readField = readVkMemory + +instance CanWriteField "memory" VkMemoryGetFdInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkMemory + +instance {-# OVERLAPPING #-} HasVkHandleType VkMemoryGetFdInfoKHR + where + type VkHandleTypeMType VkMemoryGetFdInfoKHR = + VkExternalMemoryHandleTypeFlagBitsKHR + + {-# NOINLINE vkHandleType #-} + vkHandleType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkMemoryGetFdInfoKHR, handleType}) + + {-# INLINE vkHandleTypeByteOffset #-} + vkHandleTypeByteOffset ~_ + = #{offset VkMemoryGetFdInfoKHR, handleType} + + {-# INLINE readVkHandleType #-} + readVkHandleType p + = peekByteOff p #{offset VkMemoryGetFdInfoKHR, handleType} + + {-# INLINE writeVkHandleType #-} + writeVkHandleType p + = pokeByteOff p #{offset VkMemoryGetFdInfoKHR, handleType} + +instance {-# OVERLAPPING #-} + HasField "handleType" VkMemoryGetFdInfoKHR where + type FieldType "handleType" VkMemoryGetFdInfoKHR = + VkExternalMemoryHandleTypeFlagBitsKHR + type FieldOptional "handleType" VkMemoryGetFdInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "handleType" VkMemoryGetFdInfoKHR = + #{offset VkMemoryGetFdInfoKHR, handleType} + type FieldIsArray "handleType" VkMemoryGetFdInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkMemoryGetFdInfoKHR, handleType} + +instance CanReadField "handleType" VkMemoryGetFdInfoKHR where + {-# INLINE getField #-} + getField = vkHandleType + + {-# INLINE readField #-} + readField = readVkHandleType + +instance CanWriteField "handleType" VkMemoryGetFdInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkHandleType + +instance Show VkMemoryGetFdInfoKHR where + showsPrec d x + = showString "VkMemoryGetFdInfoKHR {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkMemory = " . + showsPrec d (vkMemory x) . + showString ", " . + showString "vkHandleType = " . + showsPrec d (vkHandleType x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkMemoryGetWin32HandleInfoKHR.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkMemoryGetWin32HandleInfoKHR.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkMemoryGetWin32HandleInfoKHR.hsc @@ -0,0 +1,290 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkMemoryGetWin32HandleInfoKHR + (VkMemoryGetWin32HandleInfoKHR(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkExternalMemoryHandleTypeFlagsKHR (VkExternalMemoryHandleTypeFlagBitsKHR) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Handles (VkDeviceMemory) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkMemoryGetWin32HandleInfoKHR { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkDeviceMemory memory; +-- > VkExternalMemoryHandleTypeFlagBitsKHR handleType; +-- > } VkMemoryGetWin32HandleInfoKHR; +-- +-- +data VkMemoryGetWin32HandleInfoKHR = VkMemoryGetWin32HandleInfoKHR## Addr## + ByteArray## + +instance Eq VkMemoryGetWin32HandleInfoKHR where + (VkMemoryGetWin32HandleInfoKHR## a _) == + x@(VkMemoryGetWin32HandleInfoKHR## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkMemoryGetWin32HandleInfoKHR where + (VkMemoryGetWin32HandleInfoKHR## a _) `compare` + x@(VkMemoryGetWin32HandleInfoKHR## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkMemoryGetWin32HandleInfoKHR where + sizeOf ~_ = #{size VkMemoryGetWin32HandleInfoKHR} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkMemoryGetWin32HandleInfoKHR} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkMemoryGetWin32HandleInfoKHR where + unsafeAddr (VkMemoryGetWin32HandleInfoKHR## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkMemoryGetWin32HandleInfoKHR## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkMemoryGetWin32HandleInfoKHR## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkMemoryGetWin32HandleInfoKHR where + type StructFields VkMemoryGetWin32HandleInfoKHR = + '["sType", "pNext", "memory", "handleType"] -- ' closing tick for hsc2hs + type CUnionType VkMemoryGetWin32HandleInfoKHR = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkMemoryGetWin32HandleInfoKHR = 'False -- ' closing tick for hsc2hs + type StructExtends VkMemoryGetWin32HandleInfoKHR = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkMemoryGetWin32HandleInfoKHR where + type VkSTypeMType VkMemoryGetWin32HandleInfoKHR = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkMemoryGetWin32HandleInfoKHR, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkMemoryGetWin32HandleInfoKHR, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkMemoryGetWin32HandleInfoKHR, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkMemoryGetWin32HandleInfoKHR, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkMemoryGetWin32HandleInfoKHR where + type FieldType "sType" VkMemoryGetWin32HandleInfoKHR = + VkStructureType + type FieldOptional "sType" VkMemoryGetWin32HandleInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkMemoryGetWin32HandleInfoKHR = + #{offset VkMemoryGetWin32HandleInfoKHR, sType} + type FieldIsArray "sType" VkMemoryGetWin32HandleInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkMemoryGetWin32HandleInfoKHR, sType} + +instance CanReadField "sType" VkMemoryGetWin32HandleInfoKHR where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkMemoryGetWin32HandleInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkMemoryGetWin32HandleInfoKHR where + type VkPNextMType VkMemoryGetWin32HandleInfoKHR = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkMemoryGetWin32HandleInfoKHR, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkMemoryGetWin32HandleInfoKHR, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkMemoryGetWin32HandleInfoKHR, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkMemoryGetWin32HandleInfoKHR, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkMemoryGetWin32HandleInfoKHR where + type FieldType "pNext" VkMemoryGetWin32HandleInfoKHR = Ptr Void + type FieldOptional "pNext" VkMemoryGetWin32HandleInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkMemoryGetWin32HandleInfoKHR = + #{offset VkMemoryGetWin32HandleInfoKHR, pNext} + type FieldIsArray "pNext" VkMemoryGetWin32HandleInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkMemoryGetWin32HandleInfoKHR, pNext} + +instance CanReadField "pNext" VkMemoryGetWin32HandleInfoKHR where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkMemoryGetWin32HandleInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkMemory VkMemoryGetWin32HandleInfoKHR where + type VkMemoryMType VkMemoryGetWin32HandleInfoKHR = VkDeviceMemory + + {-# NOINLINE vkMemory #-} + vkMemory x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkMemoryGetWin32HandleInfoKHR, memory}) + + {-# INLINE vkMemoryByteOffset #-} + vkMemoryByteOffset ~_ + = #{offset VkMemoryGetWin32HandleInfoKHR, memory} + + {-# INLINE readVkMemory #-} + readVkMemory p + = peekByteOff p #{offset VkMemoryGetWin32HandleInfoKHR, memory} + + {-# INLINE writeVkMemory #-} + writeVkMemory p + = pokeByteOff p #{offset VkMemoryGetWin32HandleInfoKHR, memory} + +instance {-# OVERLAPPING #-} + HasField "memory" VkMemoryGetWin32HandleInfoKHR where + type FieldType "memory" VkMemoryGetWin32HandleInfoKHR = + VkDeviceMemory + type FieldOptional "memory" VkMemoryGetWin32HandleInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "memory" VkMemoryGetWin32HandleInfoKHR = + #{offset VkMemoryGetWin32HandleInfoKHR, memory} + type FieldIsArray "memory" VkMemoryGetWin32HandleInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkMemoryGetWin32HandleInfoKHR, memory} + +instance CanReadField "memory" VkMemoryGetWin32HandleInfoKHR where + {-# INLINE getField #-} + getField = vkMemory + + {-# INLINE readField #-} + readField = readVkMemory + +instance CanWriteField "memory" VkMemoryGetWin32HandleInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkMemory + +instance {-# OVERLAPPING #-} + HasVkHandleType VkMemoryGetWin32HandleInfoKHR where + type VkHandleTypeMType VkMemoryGetWin32HandleInfoKHR = + VkExternalMemoryHandleTypeFlagBitsKHR + + {-# NOINLINE vkHandleType #-} + vkHandleType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkMemoryGetWin32HandleInfoKHR, handleType}) + + {-# INLINE vkHandleTypeByteOffset #-} + vkHandleTypeByteOffset ~_ + = #{offset VkMemoryGetWin32HandleInfoKHR, handleType} + + {-# INLINE readVkHandleType #-} + readVkHandleType p + = peekByteOff p #{offset VkMemoryGetWin32HandleInfoKHR, handleType} + + {-# INLINE writeVkHandleType #-} + writeVkHandleType p + = pokeByteOff p #{offset VkMemoryGetWin32HandleInfoKHR, handleType} + +instance {-# OVERLAPPING #-} + HasField "handleType" VkMemoryGetWin32HandleInfoKHR where + type FieldType "handleType" VkMemoryGetWin32HandleInfoKHR = + VkExternalMemoryHandleTypeFlagBitsKHR + type FieldOptional "handleType" VkMemoryGetWin32HandleInfoKHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "handleType" VkMemoryGetWin32HandleInfoKHR = + #{offset VkMemoryGetWin32HandleInfoKHR, handleType} + type FieldIsArray "handleType" VkMemoryGetWin32HandleInfoKHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkMemoryGetWin32HandleInfoKHR, handleType} + +instance CanReadField "handleType" VkMemoryGetWin32HandleInfoKHR + where + {-# INLINE getField #-} + getField = vkHandleType + + {-# INLINE readField #-} + readField = readVkHandleType + +instance CanWriteField "handleType" VkMemoryGetWin32HandleInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkHandleType + +instance Show VkMemoryGetWin32HandleInfoKHR where + showsPrec d x + = showString "VkMemoryGetWin32HandleInfoKHR {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkMemory = " . + showsPrec d (vkMemory x) . + showString ", " . + showString "vkHandleType = " . + showsPrec d (vkHandleType x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkMemoryHeap.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkMemoryHeap.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkMemoryHeap.hsc @@ -0,0 +1,156 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkMemoryHeap (VkMemoryHeap(..)) + where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.BaseTypes (VkDeviceSize) +import Graphics.Vulkan.Types.Enum.VkMemoryHeapFlags (VkMemoryHeapFlags) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkMemoryHeap { +-- > VkDeviceSize size; +-- > VkMemoryHeapFlags flags; +-- > } VkMemoryHeap; +-- +-- +data VkMemoryHeap = VkMemoryHeap## Addr## ByteArray## + +instance Eq VkMemoryHeap where + (VkMemoryHeap## a _) == x@(VkMemoryHeap## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkMemoryHeap where + (VkMemoryHeap## a _) `compare` x@(VkMemoryHeap## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkMemoryHeap where + sizeOf ~_ = #{size VkMemoryHeap} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkMemoryHeap} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkMemoryHeap where + unsafeAddr (VkMemoryHeap## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkMemoryHeap## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkMemoryHeap## (plusAddr## (byteArrayContents## b) off) b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkMemoryHeap where + type StructFields VkMemoryHeap = '["size", "flags"] -- ' closing tick for hsc2hs + type CUnionType VkMemoryHeap = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkMemoryHeap = 'True -- ' closing tick for hsc2hs + type StructExtends VkMemoryHeap = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkSize VkMemoryHeap where + type VkSizeMType VkMemoryHeap = VkDeviceSize + + {-# NOINLINE vkSize #-} + vkSize x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkMemoryHeap, size}) + + {-# INLINE vkSizeByteOffset #-} + vkSizeByteOffset ~_ = #{offset VkMemoryHeap, size} + + {-# INLINE readVkSize #-} + readVkSize p + = peekByteOff p #{offset VkMemoryHeap, size} + + {-# INLINE writeVkSize #-} + writeVkSize p + = pokeByteOff p #{offset VkMemoryHeap, size} + +instance {-# OVERLAPPING #-} HasField "size" VkMemoryHeap where + type FieldType "size" VkMemoryHeap = VkDeviceSize + type FieldOptional "size" VkMemoryHeap = 'False -- ' closing tick for hsc2hs + type FieldOffset "size" VkMemoryHeap = + #{offset VkMemoryHeap, size} + type FieldIsArray "size" VkMemoryHeap = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkMemoryHeap, size} + +instance CanReadField "size" VkMemoryHeap where + {-# INLINE getField #-} + getField = vkSize + + {-# INLINE readField #-} + readField = readVkSize + +instance {-# OVERLAPPING #-} HasVkFlags VkMemoryHeap where + type VkFlagsMType VkMemoryHeap = VkMemoryHeapFlags + + {-# NOINLINE vkFlags #-} + vkFlags x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkMemoryHeap, flags}) + + {-# INLINE vkFlagsByteOffset #-} + vkFlagsByteOffset ~_ = #{offset VkMemoryHeap, flags} + + {-# INLINE readVkFlags #-} + readVkFlags p + = peekByteOff p #{offset VkMemoryHeap, flags} + + {-# INLINE writeVkFlags #-} + writeVkFlags p + = pokeByteOff p #{offset VkMemoryHeap, flags} + +instance {-# OVERLAPPING #-} HasField "flags" VkMemoryHeap where + type FieldType "flags" VkMemoryHeap = VkMemoryHeapFlags + type FieldOptional "flags" VkMemoryHeap = 'True -- ' closing tick for hsc2hs + type FieldOffset "flags" VkMemoryHeap = + #{offset VkMemoryHeap, flags} + type FieldIsArray "flags" VkMemoryHeap = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkMemoryHeap, flags} + +instance CanReadField "flags" VkMemoryHeap where + {-# INLINE getField #-} + getField = vkFlags + + {-# INLINE readField #-} + readField = readVkFlags + +instance Show VkMemoryHeap where + showsPrec d x + = showString "VkMemoryHeap {" . + showString "vkSize = " . + showsPrec d (vkSize x) . + showString ", " . + showString "vkFlags = " . showsPrec d (vkFlags x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkMemoryHostPointerPropertiesEXT.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkMemoryHostPointerPropertiesEXT.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkMemoryHostPointerPropertiesEXT.hsc @@ -0,0 +1,248 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkMemoryHostPointerPropertiesEXT + (VkMemoryHostPointerPropertiesEXT(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkMemoryHostPointerPropertiesEXT { +-- > VkStructureType sType; +-- > void* pNext; +-- > uint32_t memoryTypeBits; +-- > } VkMemoryHostPointerPropertiesEXT; +-- +-- +data VkMemoryHostPointerPropertiesEXT = VkMemoryHostPointerPropertiesEXT## Addr## + ByteArray## + +instance Eq VkMemoryHostPointerPropertiesEXT where + (VkMemoryHostPointerPropertiesEXT## a _) == + x@(VkMemoryHostPointerPropertiesEXT## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkMemoryHostPointerPropertiesEXT where + (VkMemoryHostPointerPropertiesEXT## a _) `compare` + x@(VkMemoryHostPointerPropertiesEXT## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkMemoryHostPointerPropertiesEXT where + sizeOf ~_ = #{size VkMemoryHostPointerPropertiesEXT} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkMemoryHostPointerPropertiesEXT} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkMemoryHostPointerPropertiesEXT where + unsafeAddr (VkMemoryHostPointerPropertiesEXT## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkMemoryHostPointerPropertiesEXT## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkMemoryHostPointerPropertiesEXT## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkMemoryHostPointerPropertiesEXT where + type StructFields VkMemoryHostPointerPropertiesEXT = + '["sType", "pNext", "memoryTypeBits"] -- ' closing tick for hsc2hs + type CUnionType VkMemoryHostPointerPropertiesEXT = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkMemoryHostPointerPropertiesEXT = 'False -- ' closing tick for hsc2hs + type StructExtends VkMemoryHostPointerPropertiesEXT = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkMemoryHostPointerPropertiesEXT where + type VkSTypeMType VkMemoryHostPointerPropertiesEXT = + VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkMemoryHostPointerPropertiesEXT, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkMemoryHostPointerPropertiesEXT, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkMemoryHostPointerPropertiesEXT, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkMemoryHostPointerPropertiesEXT, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkMemoryHostPointerPropertiesEXT where + type FieldType "sType" VkMemoryHostPointerPropertiesEXT = + VkStructureType + type FieldOptional "sType" VkMemoryHostPointerPropertiesEXT = + 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkMemoryHostPointerPropertiesEXT = + #{offset VkMemoryHostPointerPropertiesEXT, sType} + type FieldIsArray "sType" VkMemoryHostPointerPropertiesEXT = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkMemoryHostPointerPropertiesEXT, sType} + +instance CanReadField "sType" VkMemoryHostPointerPropertiesEXT + where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkMemoryHostPointerPropertiesEXT + where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkMemoryHostPointerPropertiesEXT where + type VkPNextMType VkMemoryHostPointerPropertiesEXT = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkMemoryHostPointerPropertiesEXT, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkMemoryHostPointerPropertiesEXT, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkMemoryHostPointerPropertiesEXT, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkMemoryHostPointerPropertiesEXT, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkMemoryHostPointerPropertiesEXT where + type FieldType "pNext" VkMemoryHostPointerPropertiesEXT = Ptr Void + type FieldOptional "pNext" VkMemoryHostPointerPropertiesEXT = + 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkMemoryHostPointerPropertiesEXT = + #{offset VkMemoryHostPointerPropertiesEXT, pNext} + type FieldIsArray "pNext" VkMemoryHostPointerPropertiesEXT = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkMemoryHostPointerPropertiesEXT, pNext} + +instance CanReadField "pNext" VkMemoryHostPointerPropertiesEXT + where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkMemoryHostPointerPropertiesEXT + where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkMemoryTypeBits VkMemoryHostPointerPropertiesEXT where + type VkMemoryTypeBitsMType VkMemoryHostPointerPropertiesEXT = + Word32 + + {-# NOINLINE vkMemoryTypeBits #-} + vkMemoryTypeBits x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkMemoryHostPointerPropertiesEXT, memoryTypeBits}) + + {-# INLINE vkMemoryTypeBitsByteOffset #-} + vkMemoryTypeBitsByteOffset ~_ + = #{offset VkMemoryHostPointerPropertiesEXT, memoryTypeBits} + + {-# INLINE readVkMemoryTypeBits #-} + readVkMemoryTypeBits p + = peekByteOff p #{offset VkMemoryHostPointerPropertiesEXT, memoryTypeBits} + + {-# INLINE writeVkMemoryTypeBits #-} + writeVkMemoryTypeBits p + = pokeByteOff p #{offset VkMemoryHostPointerPropertiesEXT, memoryTypeBits} + +instance {-# OVERLAPPING #-} + HasField "memoryTypeBits" VkMemoryHostPointerPropertiesEXT where + type FieldType "memoryTypeBits" VkMemoryHostPointerPropertiesEXT = + Word32 + type FieldOptional "memoryTypeBits" + VkMemoryHostPointerPropertiesEXT + = 'False -- ' closing tick for hsc2hs + type FieldOffset "memoryTypeBits" VkMemoryHostPointerPropertiesEXT + = + #{offset VkMemoryHostPointerPropertiesEXT, memoryTypeBits} + type FieldIsArray "memoryTypeBits" VkMemoryHostPointerPropertiesEXT + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkMemoryHostPointerPropertiesEXT, memoryTypeBits} + +instance CanReadField "memoryTypeBits" + VkMemoryHostPointerPropertiesEXT + where + {-# INLINE getField #-} + getField = vkMemoryTypeBits + + {-# INLINE readField #-} + readField = readVkMemoryTypeBits + +instance CanWriteField "memoryTypeBits" + VkMemoryHostPointerPropertiesEXT + where + {-# INLINE writeField #-} + writeField = writeVkMemoryTypeBits + +instance Show VkMemoryHostPointerPropertiesEXT where + showsPrec d x + = showString "VkMemoryHostPointerPropertiesEXT {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkMemoryTypeBits = " . + showsPrec d (vkMemoryTypeBits x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkMemoryRequirements.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkMemoryRequirements.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkMemoryRequirements.hsc @@ -0,0 +1,209 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkMemoryRequirements + (VkMemoryRequirements(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.BaseTypes (VkDeviceSize) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkMemoryRequirements { +-- > VkDeviceSize size; +-- > VkDeviceSize alignment; +-- > uint32_t memoryTypeBits; +-- > } VkMemoryRequirements; +-- +-- +data VkMemoryRequirements = VkMemoryRequirements## Addr## ByteArray## + +instance Eq VkMemoryRequirements where + (VkMemoryRequirements## a _) == x@(VkMemoryRequirements## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkMemoryRequirements where + (VkMemoryRequirements## a _) `compare` x@(VkMemoryRequirements## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkMemoryRequirements where + sizeOf ~_ = #{size VkMemoryRequirements} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkMemoryRequirements} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkMemoryRequirements where + unsafeAddr (VkMemoryRequirements## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkMemoryRequirements## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkMemoryRequirements## (plusAddr## (byteArrayContents## b) off) b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkMemoryRequirements where + type StructFields VkMemoryRequirements = + '["size", "alignment", "memoryTypeBits"] -- ' closing tick for hsc2hs + type CUnionType VkMemoryRequirements = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkMemoryRequirements = 'True -- ' closing tick for hsc2hs + type StructExtends VkMemoryRequirements = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkSize VkMemoryRequirements where + type VkSizeMType VkMemoryRequirements = VkDeviceSize + + {-# NOINLINE vkSize #-} + vkSize x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkMemoryRequirements, size}) + + {-# INLINE vkSizeByteOffset #-} + vkSizeByteOffset ~_ + = #{offset VkMemoryRequirements, size} + + {-# INLINE readVkSize #-} + readVkSize p + = peekByteOff p #{offset VkMemoryRequirements, size} + + {-# INLINE writeVkSize #-} + writeVkSize p + = pokeByteOff p #{offset VkMemoryRequirements, size} + +instance {-# OVERLAPPING #-} HasField "size" VkMemoryRequirements + where + type FieldType "size" VkMemoryRequirements = VkDeviceSize + type FieldOptional "size" VkMemoryRequirements = 'False -- ' closing tick for hsc2hs + type FieldOffset "size" VkMemoryRequirements = + #{offset VkMemoryRequirements, size} + type FieldIsArray "size" VkMemoryRequirements = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkMemoryRequirements, size} + +instance CanReadField "size" VkMemoryRequirements where + {-# INLINE getField #-} + getField = vkSize + + {-# INLINE readField #-} + readField = readVkSize + +instance {-# OVERLAPPING #-} HasVkAlignment VkMemoryRequirements + where + type VkAlignmentMType VkMemoryRequirements = VkDeviceSize + + {-# NOINLINE vkAlignment #-} + vkAlignment x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkMemoryRequirements, alignment}) + + {-# INLINE vkAlignmentByteOffset #-} + vkAlignmentByteOffset ~_ + = #{offset VkMemoryRequirements, alignment} + + {-# INLINE readVkAlignment #-} + readVkAlignment p + = peekByteOff p #{offset VkMemoryRequirements, alignment} + + {-# INLINE writeVkAlignment #-} + writeVkAlignment p + = pokeByteOff p #{offset VkMemoryRequirements, alignment} + +instance {-# OVERLAPPING #-} + HasField "alignment" VkMemoryRequirements where + type FieldType "alignment" VkMemoryRequirements = VkDeviceSize + type FieldOptional "alignment" VkMemoryRequirements = 'False -- ' closing tick for hsc2hs + type FieldOffset "alignment" VkMemoryRequirements = + #{offset VkMemoryRequirements, alignment} + type FieldIsArray "alignment" VkMemoryRequirements = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkMemoryRequirements, alignment} + +instance CanReadField "alignment" VkMemoryRequirements where + {-# INLINE getField #-} + getField = vkAlignment + + {-# INLINE readField #-} + readField = readVkAlignment + +instance {-# OVERLAPPING #-} + HasVkMemoryTypeBits VkMemoryRequirements where + type VkMemoryTypeBitsMType VkMemoryRequirements = Word32 + + {-# NOINLINE vkMemoryTypeBits #-} + vkMemoryTypeBits x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkMemoryRequirements, memoryTypeBits}) + + {-# INLINE vkMemoryTypeBitsByteOffset #-} + vkMemoryTypeBitsByteOffset ~_ + = #{offset VkMemoryRequirements, memoryTypeBits} + + {-# INLINE readVkMemoryTypeBits #-} + readVkMemoryTypeBits p + = peekByteOff p #{offset VkMemoryRequirements, memoryTypeBits} + + {-# INLINE writeVkMemoryTypeBits #-} + writeVkMemoryTypeBits p + = pokeByteOff p #{offset VkMemoryRequirements, memoryTypeBits} + +instance {-# OVERLAPPING #-} + HasField "memoryTypeBits" VkMemoryRequirements where + type FieldType "memoryTypeBits" VkMemoryRequirements = Word32 + type FieldOptional "memoryTypeBits" VkMemoryRequirements = 'False -- ' closing tick for hsc2hs + type FieldOffset "memoryTypeBits" VkMemoryRequirements = + #{offset VkMemoryRequirements, memoryTypeBits} + type FieldIsArray "memoryTypeBits" VkMemoryRequirements = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkMemoryRequirements, memoryTypeBits} + +instance CanReadField "memoryTypeBits" VkMemoryRequirements where + {-# INLINE getField #-} + getField = vkMemoryTypeBits + + {-# INLINE readField #-} + readField = readVkMemoryTypeBits + +instance Show VkMemoryRequirements where + showsPrec d x + = showString "VkMemoryRequirements {" . + showString "vkSize = " . + showsPrec d (vkSize x) . + showString ", " . + showString "vkAlignment = " . + showsPrec d (vkAlignment x) . + showString ", " . + showString "vkMemoryTypeBits = " . + showsPrec d (vkMemoryTypeBits x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkMemoryRequirements2KHR.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkMemoryRequirements2KHR.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkMemoryRequirements2KHR.hsc @@ -0,0 +1,218 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkMemoryRequirements2KHR + (VkMemoryRequirements2KHR(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Struct.VkMemoryRequirements (VkMemoryRequirements) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkMemoryRequirements2KHR { +-- > VkStructureType sType; +-- > void* pNext; +-- > VkMemoryRequirements memoryRequirements; +-- > } VkMemoryRequirements2KHR; +-- +-- +data VkMemoryRequirements2KHR = VkMemoryRequirements2KHR## Addr## + ByteArray## + +instance Eq VkMemoryRequirements2KHR where + (VkMemoryRequirements2KHR## a _) == + x@(VkMemoryRequirements2KHR## b _) = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkMemoryRequirements2KHR where + (VkMemoryRequirements2KHR## a _) `compare` + x@(VkMemoryRequirements2KHR## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkMemoryRequirements2KHR where + sizeOf ~_ = #{size VkMemoryRequirements2KHR} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkMemoryRequirements2KHR} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkMemoryRequirements2KHR where + unsafeAddr (VkMemoryRequirements2KHR## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkMemoryRequirements2KHR## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkMemoryRequirements2KHR## (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkMemoryRequirements2KHR where + type StructFields VkMemoryRequirements2KHR = + '["sType", "pNext", "memoryRequirements"] -- ' closing tick for hsc2hs + type CUnionType VkMemoryRequirements2KHR = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkMemoryRequirements2KHR = 'True -- ' closing tick for hsc2hs + type StructExtends VkMemoryRequirements2KHR = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkSType VkMemoryRequirements2KHR + where + type VkSTypeMType VkMemoryRequirements2KHR = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkMemoryRequirements2KHR, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkMemoryRequirements2KHR, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkMemoryRequirements2KHR, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkMemoryRequirements2KHR, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkMemoryRequirements2KHR where + type FieldType "sType" VkMemoryRequirements2KHR = VkStructureType + type FieldOptional "sType" VkMemoryRequirements2KHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkMemoryRequirements2KHR = + #{offset VkMemoryRequirements2KHR, sType} + type FieldIsArray "sType" VkMemoryRequirements2KHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkMemoryRequirements2KHR, sType} + +instance CanReadField "sType" VkMemoryRequirements2KHR where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance {-# OVERLAPPING #-} HasVkPNext VkMemoryRequirements2KHR + where + type VkPNextMType VkMemoryRequirements2KHR = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkMemoryRequirements2KHR, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkMemoryRequirements2KHR, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkMemoryRequirements2KHR, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkMemoryRequirements2KHR, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkMemoryRequirements2KHR where + type FieldType "pNext" VkMemoryRequirements2KHR = Ptr Void + type FieldOptional "pNext" VkMemoryRequirements2KHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkMemoryRequirements2KHR = + #{offset VkMemoryRequirements2KHR, pNext} + type FieldIsArray "pNext" VkMemoryRequirements2KHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkMemoryRequirements2KHR, pNext} + +instance CanReadField "pNext" VkMemoryRequirements2KHR where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance {-# OVERLAPPING #-} + HasVkMemoryRequirements VkMemoryRequirements2KHR where + type VkMemoryRequirementsMType VkMemoryRequirements2KHR = + VkMemoryRequirements + + {-# NOINLINE vkMemoryRequirements #-} + vkMemoryRequirements x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkMemoryRequirements2KHR, memoryRequirements}) + + {-# INLINE vkMemoryRequirementsByteOffset #-} + vkMemoryRequirementsByteOffset ~_ + = #{offset VkMemoryRequirements2KHR, memoryRequirements} + + {-# INLINE readVkMemoryRequirements #-} + readVkMemoryRequirements p + = peekByteOff p #{offset VkMemoryRequirements2KHR, memoryRequirements} + + {-# INLINE writeVkMemoryRequirements #-} + writeVkMemoryRequirements p + = pokeByteOff p #{offset VkMemoryRequirements2KHR, memoryRequirements} + +instance {-# OVERLAPPING #-} + HasField "memoryRequirements" VkMemoryRequirements2KHR where + type FieldType "memoryRequirements" VkMemoryRequirements2KHR = + VkMemoryRequirements + type FieldOptional "memoryRequirements" VkMemoryRequirements2KHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "memoryRequirements" VkMemoryRequirements2KHR = + #{offset VkMemoryRequirements2KHR, memoryRequirements} + type FieldIsArray "memoryRequirements" VkMemoryRequirements2KHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkMemoryRequirements2KHR, memoryRequirements} + +instance CanReadField "memoryRequirements" VkMemoryRequirements2KHR + where + {-# INLINE getField #-} + getField = vkMemoryRequirements + + {-# INLINE readField #-} + readField = readVkMemoryRequirements + +instance Show VkMemoryRequirements2KHR where + showsPrec d x + = showString "VkMemoryRequirements2KHR {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkMemoryRequirements = " . + showsPrec d (vkMemoryRequirements x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkMemoryType.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkMemoryType.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkMemoryType.hsc @@ -0,0 +1,160 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkMemoryType (VkMemoryType(..)) + where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkMemoryPropertyFlags (VkMemoryPropertyFlags) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkMemoryType { +-- > VkMemoryPropertyFlags propertyFlags; +-- > uint32_t heapIndex; +-- > } VkMemoryType; +-- +-- +data VkMemoryType = VkMemoryType## Addr## ByteArray## + +instance Eq VkMemoryType where + (VkMemoryType## a _) == x@(VkMemoryType## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkMemoryType where + (VkMemoryType## a _) `compare` x@(VkMemoryType## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkMemoryType where + sizeOf ~_ = #{size VkMemoryType} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkMemoryType} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkMemoryType where + unsafeAddr (VkMemoryType## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkMemoryType## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkMemoryType## (plusAddr## (byteArrayContents## b) off) b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkMemoryType where + type StructFields VkMemoryType = '["propertyFlags", "heapIndex"] -- ' closing tick for hsc2hs + type CUnionType VkMemoryType = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkMemoryType = 'True -- ' closing tick for hsc2hs + type StructExtends VkMemoryType = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkPropertyFlags VkMemoryType where + type VkPropertyFlagsMType VkMemoryType = VkMemoryPropertyFlags + + {-# NOINLINE vkPropertyFlags #-} + vkPropertyFlags x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkMemoryType, propertyFlags}) + + {-# INLINE vkPropertyFlagsByteOffset #-} + vkPropertyFlagsByteOffset ~_ + = #{offset VkMemoryType, propertyFlags} + + {-# INLINE readVkPropertyFlags #-} + readVkPropertyFlags p + = peekByteOff p #{offset VkMemoryType, propertyFlags} + + {-# INLINE writeVkPropertyFlags #-} + writeVkPropertyFlags p + = pokeByteOff p #{offset VkMemoryType, propertyFlags} + +instance {-# OVERLAPPING #-} HasField "propertyFlags" VkMemoryType + where + type FieldType "propertyFlags" VkMemoryType = VkMemoryPropertyFlags + type FieldOptional "propertyFlags" VkMemoryType = 'True -- ' closing tick for hsc2hs + type FieldOffset "propertyFlags" VkMemoryType = + #{offset VkMemoryType, propertyFlags} + type FieldIsArray "propertyFlags" VkMemoryType = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkMemoryType, propertyFlags} + +instance CanReadField "propertyFlags" VkMemoryType where + {-# INLINE getField #-} + getField = vkPropertyFlags + + {-# INLINE readField #-} + readField = readVkPropertyFlags + +instance {-# OVERLAPPING #-} HasVkHeapIndex VkMemoryType where + type VkHeapIndexMType VkMemoryType = Word32 + + {-# NOINLINE vkHeapIndex #-} + vkHeapIndex x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkMemoryType, heapIndex}) + + {-# INLINE vkHeapIndexByteOffset #-} + vkHeapIndexByteOffset ~_ + = #{offset VkMemoryType, heapIndex} + + {-# INLINE readVkHeapIndex #-} + readVkHeapIndex p + = peekByteOff p #{offset VkMemoryType, heapIndex} + + {-# INLINE writeVkHeapIndex #-} + writeVkHeapIndex p + = pokeByteOff p #{offset VkMemoryType, heapIndex} + +instance {-# OVERLAPPING #-} HasField "heapIndex" VkMemoryType + where + type FieldType "heapIndex" VkMemoryType = Word32 + type FieldOptional "heapIndex" VkMemoryType = 'False -- ' closing tick for hsc2hs + type FieldOffset "heapIndex" VkMemoryType = + #{offset VkMemoryType, heapIndex} + type FieldIsArray "heapIndex" VkMemoryType = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkMemoryType, heapIndex} + +instance CanReadField "heapIndex" VkMemoryType where + {-# INLINE getField #-} + getField = vkHeapIndex + + {-# INLINE readField #-} + readField = readVkHeapIndex + +instance Show VkMemoryType where + showsPrec d x + = showString "VkMemoryType {" . + showString "vkPropertyFlags = " . + showsPrec d (vkPropertyFlags x) . + showString ", " . + showString "vkHeapIndex = " . + showsPrec d (vkHeapIndex x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkMemoryWin32HandlePropertiesKHR.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkMemoryWin32HandlePropertiesKHR.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkMemoryWin32HandlePropertiesKHR.hsc @@ -0,0 +1,232 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkMemoryWin32HandlePropertiesKHR + (VkMemoryWin32HandlePropertiesKHR(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkMemoryWin32HandlePropertiesKHR { +-- > VkStructureType sType; +-- > void* pNext; +-- > uint32_t memoryTypeBits; +-- > } VkMemoryWin32HandlePropertiesKHR; +-- +-- +data VkMemoryWin32HandlePropertiesKHR = VkMemoryWin32HandlePropertiesKHR## Addr## + ByteArray## + +instance Eq VkMemoryWin32HandlePropertiesKHR where + (VkMemoryWin32HandlePropertiesKHR## a _) == + x@(VkMemoryWin32HandlePropertiesKHR## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkMemoryWin32HandlePropertiesKHR where + (VkMemoryWin32HandlePropertiesKHR## a _) `compare` + x@(VkMemoryWin32HandlePropertiesKHR## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkMemoryWin32HandlePropertiesKHR where + sizeOf ~_ = #{size VkMemoryWin32HandlePropertiesKHR} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkMemoryWin32HandlePropertiesKHR} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkMemoryWin32HandlePropertiesKHR where + unsafeAddr (VkMemoryWin32HandlePropertiesKHR## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkMemoryWin32HandlePropertiesKHR## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkMemoryWin32HandlePropertiesKHR## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkMemoryWin32HandlePropertiesKHR where + type StructFields VkMemoryWin32HandlePropertiesKHR = + '["sType", "pNext", "memoryTypeBits"] -- ' closing tick for hsc2hs + type CUnionType VkMemoryWin32HandlePropertiesKHR = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkMemoryWin32HandlePropertiesKHR = 'True -- ' closing tick for hsc2hs + type StructExtends VkMemoryWin32HandlePropertiesKHR = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkMemoryWin32HandlePropertiesKHR where + type VkSTypeMType VkMemoryWin32HandlePropertiesKHR = + VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkMemoryWin32HandlePropertiesKHR, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkMemoryWin32HandlePropertiesKHR, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkMemoryWin32HandlePropertiesKHR, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkMemoryWin32HandlePropertiesKHR, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkMemoryWin32HandlePropertiesKHR where + type FieldType "sType" VkMemoryWin32HandlePropertiesKHR = + VkStructureType + type FieldOptional "sType" VkMemoryWin32HandlePropertiesKHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkMemoryWin32HandlePropertiesKHR = + #{offset VkMemoryWin32HandlePropertiesKHR, sType} + type FieldIsArray "sType" VkMemoryWin32HandlePropertiesKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkMemoryWin32HandlePropertiesKHR, sType} + +instance CanReadField "sType" VkMemoryWin32HandlePropertiesKHR + where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkMemoryWin32HandlePropertiesKHR where + type VkPNextMType VkMemoryWin32HandlePropertiesKHR = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkMemoryWin32HandlePropertiesKHR, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkMemoryWin32HandlePropertiesKHR, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkMemoryWin32HandlePropertiesKHR, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkMemoryWin32HandlePropertiesKHR, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkMemoryWin32HandlePropertiesKHR where + type FieldType "pNext" VkMemoryWin32HandlePropertiesKHR = Ptr Void + type FieldOptional "pNext" VkMemoryWin32HandlePropertiesKHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkMemoryWin32HandlePropertiesKHR = + #{offset VkMemoryWin32HandlePropertiesKHR, pNext} + type FieldIsArray "pNext" VkMemoryWin32HandlePropertiesKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkMemoryWin32HandlePropertiesKHR, pNext} + +instance CanReadField "pNext" VkMemoryWin32HandlePropertiesKHR + where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance {-# OVERLAPPING #-} + HasVkMemoryTypeBits VkMemoryWin32HandlePropertiesKHR where + type VkMemoryTypeBitsMType VkMemoryWin32HandlePropertiesKHR = + Word32 + + {-# NOINLINE vkMemoryTypeBits #-} + vkMemoryTypeBits x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkMemoryWin32HandlePropertiesKHR, memoryTypeBits}) + + {-# INLINE vkMemoryTypeBitsByteOffset #-} + vkMemoryTypeBitsByteOffset ~_ + = #{offset VkMemoryWin32HandlePropertiesKHR, memoryTypeBits} + + {-# INLINE readVkMemoryTypeBits #-} + readVkMemoryTypeBits p + = peekByteOff p #{offset VkMemoryWin32HandlePropertiesKHR, memoryTypeBits} + + {-# INLINE writeVkMemoryTypeBits #-} + writeVkMemoryTypeBits p + = pokeByteOff p #{offset VkMemoryWin32HandlePropertiesKHR, memoryTypeBits} + +instance {-# OVERLAPPING #-} + HasField "memoryTypeBits" VkMemoryWin32HandlePropertiesKHR where + type FieldType "memoryTypeBits" VkMemoryWin32HandlePropertiesKHR = + Word32 + type FieldOptional "memoryTypeBits" + VkMemoryWin32HandlePropertiesKHR + = 'False -- ' closing tick for hsc2hs + type FieldOffset "memoryTypeBits" VkMemoryWin32HandlePropertiesKHR + = + #{offset VkMemoryWin32HandlePropertiesKHR, memoryTypeBits} + type FieldIsArray "memoryTypeBits" VkMemoryWin32HandlePropertiesKHR + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkMemoryWin32HandlePropertiesKHR, memoryTypeBits} + +instance CanReadField "memoryTypeBits" + VkMemoryWin32HandlePropertiesKHR + where + {-# INLINE getField #-} + getField = vkMemoryTypeBits + + {-# INLINE readField #-} + readField = readVkMemoryTypeBits + +instance Show VkMemoryWin32HandlePropertiesKHR where + showsPrec d x + = showString "VkMemoryWin32HandlePropertiesKHR {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkMemoryTypeBits = " . + showsPrec d (vkMemoryTypeBits x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkMirSurfaceCreateInfoKHR.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkMirSurfaceCreateInfoKHR.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkMirSurfaceCreateInfoKHR.hsc @@ -0,0 +1,336 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkMirSurfaceCreateInfoKHR + (VkMirSurfaceCreateInfoKHR(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Bitmasks (VkMirSurfaceCreateFlagsKHR) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Include (MirConnection, + MirSurface) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkMirSurfaceCreateInfoKHR { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkMirSurfaceCreateFlagsKHR flags; +-- > MirConnection* connection; +-- > MirSurface* mirSurface; +-- > } VkMirSurfaceCreateInfoKHR; +-- +-- +data VkMirSurfaceCreateInfoKHR = VkMirSurfaceCreateInfoKHR## Addr## + ByteArray## + +instance Eq VkMirSurfaceCreateInfoKHR where + (VkMirSurfaceCreateInfoKHR## a _) == + x@(VkMirSurfaceCreateInfoKHR## b _) = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkMirSurfaceCreateInfoKHR where + (VkMirSurfaceCreateInfoKHR## a _) `compare` + x@(VkMirSurfaceCreateInfoKHR## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkMirSurfaceCreateInfoKHR where + sizeOf ~_ = #{size VkMirSurfaceCreateInfoKHR} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkMirSurfaceCreateInfoKHR} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkMirSurfaceCreateInfoKHR where + unsafeAddr (VkMirSurfaceCreateInfoKHR## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkMirSurfaceCreateInfoKHR## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkMirSurfaceCreateInfoKHR## (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkMirSurfaceCreateInfoKHR where + type StructFields VkMirSurfaceCreateInfoKHR = + '["sType", "pNext", "flags", "connection", "mirSurface"] -- ' closing tick for hsc2hs + type CUnionType VkMirSurfaceCreateInfoKHR = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkMirSurfaceCreateInfoKHR = 'False -- ' closing tick for hsc2hs + type StructExtends VkMirSurfaceCreateInfoKHR = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkSType VkMirSurfaceCreateInfoKHR + where + type VkSTypeMType VkMirSurfaceCreateInfoKHR = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkMirSurfaceCreateInfoKHR, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkMirSurfaceCreateInfoKHR, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkMirSurfaceCreateInfoKHR, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkMirSurfaceCreateInfoKHR, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkMirSurfaceCreateInfoKHR where + type FieldType "sType" VkMirSurfaceCreateInfoKHR = VkStructureType + type FieldOptional "sType" VkMirSurfaceCreateInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkMirSurfaceCreateInfoKHR = + #{offset VkMirSurfaceCreateInfoKHR, sType} + type FieldIsArray "sType" VkMirSurfaceCreateInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkMirSurfaceCreateInfoKHR, sType} + +instance CanReadField "sType" VkMirSurfaceCreateInfoKHR where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkMirSurfaceCreateInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} HasVkPNext VkMirSurfaceCreateInfoKHR + where + type VkPNextMType VkMirSurfaceCreateInfoKHR = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkMirSurfaceCreateInfoKHR, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkMirSurfaceCreateInfoKHR, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkMirSurfaceCreateInfoKHR, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkMirSurfaceCreateInfoKHR, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkMirSurfaceCreateInfoKHR where + type FieldType "pNext" VkMirSurfaceCreateInfoKHR = Ptr Void + type FieldOptional "pNext" VkMirSurfaceCreateInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkMirSurfaceCreateInfoKHR = + #{offset VkMirSurfaceCreateInfoKHR, pNext} + type FieldIsArray "pNext" VkMirSurfaceCreateInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkMirSurfaceCreateInfoKHR, pNext} + +instance CanReadField "pNext" VkMirSurfaceCreateInfoKHR where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkMirSurfaceCreateInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} HasVkFlags VkMirSurfaceCreateInfoKHR + where + type VkFlagsMType VkMirSurfaceCreateInfoKHR = + VkMirSurfaceCreateFlagsKHR + + {-# NOINLINE vkFlags #-} + vkFlags x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkMirSurfaceCreateInfoKHR, flags}) + + {-# INLINE vkFlagsByteOffset #-} + vkFlagsByteOffset ~_ + = #{offset VkMirSurfaceCreateInfoKHR, flags} + + {-# INLINE readVkFlags #-} + readVkFlags p + = peekByteOff p #{offset VkMirSurfaceCreateInfoKHR, flags} + + {-# INLINE writeVkFlags #-} + writeVkFlags p + = pokeByteOff p #{offset VkMirSurfaceCreateInfoKHR, flags} + +instance {-# OVERLAPPING #-} + HasField "flags" VkMirSurfaceCreateInfoKHR where + type FieldType "flags" VkMirSurfaceCreateInfoKHR = + VkMirSurfaceCreateFlagsKHR + type FieldOptional "flags" VkMirSurfaceCreateInfoKHR = 'True -- ' closing tick for hsc2hs + type FieldOffset "flags" VkMirSurfaceCreateInfoKHR = + #{offset VkMirSurfaceCreateInfoKHR, flags} + type FieldIsArray "flags" VkMirSurfaceCreateInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkMirSurfaceCreateInfoKHR, flags} + +instance CanReadField "flags" VkMirSurfaceCreateInfoKHR where + {-# INLINE getField #-} + getField = vkFlags + + {-# INLINE readField #-} + readField = readVkFlags + +instance CanWriteField "flags" VkMirSurfaceCreateInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkFlags + +instance {-# OVERLAPPING #-} + HasVkConnection VkMirSurfaceCreateInfoKHR where + type VkConnectionMType VkMirSurfaceCreateInfoKHR = + Ptr MirConnection + + {-# NOINLINE vkConnection #-} + vkConnection x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkMirSurfaceCreateInfoKHR, connection}) + + {-# INLINE vkConnectionByteOffset #-} + vkConnectionByteOffset ~_ + = #{offset VkMirSurfaceCreateInfoKHR, connection} + + {-# INLINE readVkConnection #-} + readVkConnection p + = peekByteOff p #{offset VkMirSurfaceCreateInfoKHR, connection} + + {-# INLINE writeVkConnection #-} + writeVkConnection p + = pokeByteOff p #{offset VkMirSurfaceCreateInfoKHR, connection} + +instance {-# OVERLAPPING #-} + HasField "connection" VkMirSurfaceCreateInfoKHR where + type FieldType "connection" VkMirSurfaceCreateInfoKHR = + Ptr MirConnection + type FieldOptional "connection" VkMirSurfaceCreateInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "connection" VkMirSurfaceCreateInfoKHR = + #{offset VkMirSurfaceCreateInfoKHR, connection} + type FieldIsArray "connection" VkMirSurfaceCreateInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkMirSurfaceCreateInfoKHR, connection} + +instance CanReadField "connection" VkMirSurfaceCreateInfoKHR where + {-# INLINE getField #-} + getField = vkConnection + + {-# INLINE readField #-} + readField = readVkConnection + +instance CanWriteField "connection" VkMirSurfaceCreateInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkConnection + +instance {-# OVERLAPPING #-} + HasVkMirSurface VkMirSurfaceCreateInfoKHR where + type VkMirSurfaceMType VkMirSurfaceCreateInfoKHR = Ptr MirSurface + + {-# NOINLINE vkMirSurface #-} + vkMirSurface x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkMirSurfaceCreateInfoKHR, mirSurface}) + + {-# INLINE vkMirSurfaceByteOffset #-} + vkMirSurfaceByteOffset ~_ + = #{offset VkMirSurfaceCreateInfoKHR, mirSurface} + + {-# INLINE readVkMirSurface #-} + readVkMirSurface p + = peekByteOff p #{offset VkMirSurfaceCreateInfoKHR, mirSurface} + + {-# INLINE writeVkMirSurface #-} + writeVkMirSurface p + = pokeByteOff p #{offset VkMirSurfaceCreateInfoKHR, mirSurface} + +instance {-# OVERLAPPING #-} + HasField "mirSurface" VkMirSurfaceCreateInfoKHR where + type FieldType "mirSurface" VkMirSurfaceCreateInfoKHR = + Ptr MirSurface + type FieldOptional "mirSurface" VkMirSurfaceCreateInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "mirSurface" VkMirSurfaceCreateInfoKHR = + #{offset VkMirSurfaceCreateInfoKHR, mirSurface} + type FieldIsArray "mirSurface" VkMirSurfaceCreateInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkMirSurfaceCreateInfoKHR, mirSurface} + +instance CanReadField "mirSurface" VkMirSurfaceCreateInfoKHR where + {-# INLINE getField #-} + getField = vkMirSurface + + {-# INLINE readField #-} + readField = readVkMirSurface + +instance CanWriteField "mirSurface" VkMirSurfaceCreateInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkMirSurface + +instance Show VkMirSurfaceCreateInfoKHR where + showsPrec d x + = showString "VkMirSurfaceCreateInfoKHR {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkFlags = " . + showsPrec d (vkFlags x) . + showString ", " . + showString "vkConnection = " . + showsPrec d (vkConnection x) . + showString ", " . + showString "vkMirSurface = " . + showsPrec d (vkMirSurface x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkMultisamplePropertiesEXT.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkMultisamplePropertiesEXT.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkMultisamplePropertiesEXT.hsc @@ -0,0 +1,229 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkMultisamplePropertiesEXT + (VkMultisamplePropertiesEXT(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Struct.VkExtent2D (VkExtent2D) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkMultisamplePropertiesEXT { +-- > VkStructureType sType; +-- > void* pNext; +-- > VkExtent2D maxSampleLocationGridSize; +-- > } VkMultisamplePropertiesEXT; +-- +-- +data VkMultisamplePropertiesEXT = VkMultisamplePropertiesEXT## Addr## + ByteArray## + +instance Eq VkMultisamplePropertiesEXT where + (VkMultisamplePropertiesEXT## a _) == + x@(VkMultisamplePropertiesEXT## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkMultisamplePropertiesEXT where + (VkMultisamplePropertiesEXT## a _) `compare` + x@(VkMultisamplePropertiesEXT## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkMultisamplePropertiesEXT where + sizeOf ~_ = #{size VkMultisamplePropertiesEXT} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkMultisamplePropertiesEXT} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkMultisamplePropertiesEXT where + unsafeAddr (VkMultisamplePropertiesEXT## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkMultisamplePropertiesEXT## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkMultisamplePropertiesEXT## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkMultisamplePropertiesEXT where + type StructFields VkMultisamplePropertiesEXT = + '["sType", "pNext", "maxSampleLocationGridSize"] -- ' closing tick for hsc2hs + type CUnionType VkMultisamplePropertiesEXT = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkMultisamplePropertiesEXT = 'True -- ' closing tick for hsc2hs + type StructExtends VkMultisamplePropertiesEXT = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkSType VkMultisamplePropertiesEXT + where + type VkSTypeMType VkMultisamplePropertiesEXT = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkMultisamplePropertiesEXT, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkMultisamplePropertiesEXT, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkMultisamplePropertiesEXT, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkMultisamplePropertiesEXT, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkMultisamplePropertiesEXT where + type FieldType "sType" VkMultisamplePropertiesEXT = VkStructureType + type FieldOptional "sType" VkMultisamplePropertiesEXT = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkMultisamplePropertiesEXT = + #{offset VkMultisamplePropertiesEXT, sType} + type FieldIsArray "sType" VkMultisamplePropertiesEXT = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkMultisamplePropertiesEXT, sType} + +instance CanReadField "sType" VkMultisamplePropertiesEXT where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance {-# OVERLAPPING #-} HasVkPNext VkMultisamplePropertiesEXT + where + type VkPNextMType VkMultisamplePropertiesEXT = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkMultisamplePropertiesEXT, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkMultisamplePropertiesEXT, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkMultisamplePropertiesEXT, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkMultisamplePropertiesEXT, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkMultisamplePropertiesEXT where + type FieldType "pNext" VkMultisamplePropertiesEXT = Ptr Void + type FieldOptional "pNext" VkMultisamplePropertiesEXT = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkMultisamplePropertiesEXT = + #{offset VkMultisamplePropertiesEXT, pNext} + type FieldIsArray "pNext" VkMultisamplePropertiesEXT = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkMultisamplePropertiesEXT, pNext} + +instance CanReadField "pNext" VkMultisamplePropertiesEXT where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance {-# OVERLAPPING #-} + HasVkMaxSampleLocationGridSize VkMultisamplePropertiesEXT where + type VkMaxSampleLocationGridSizeMType VkMultisamplePropertiesEXT = + VkExtent2D + + {-# NOINLINE vkMaxSampleLocationGridSize #-} + vkMaxSampleLocationGridSize x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkMultisamplePropertiesEXT, maxSampleLocationGridSize}) + + {-# INLINE vkMaxSampleLocationGridSizeByteOffset #-} + vkMaxSampleLocationGridSizeByteOffset ~_ + = #{offset VkMultisamplePropertiesEXT, maxSampleLocationGridSize} + + {-# INLINE readVkMaxSampleLocationGridSize #-} + readVkMaxSampleLocationGridSize p + = peekByteOff p #{offset VkMultisamplePropertiesEXT, maxSampleLocationGridSize} + + {-# INLINE writeVkMaxSampleLocationGridSize #-} + writeVkMaxSampleLocationGridSize p + = pokeByteOff p #{offset VkMultisamplePropertiesEXT, maxSampleLocationGridSize} + +instance {-# OVERLAPPING #-} + HasField "maxSampleLocationGridSize" VkMultisamplePropertiesEXT + where + type FieldType "maxSampleLocationGridSize" + VkMultisamplePropertiesEXT + = VkExtent2D + type FieldOptional "maxSampleLocationGridSize" + VkMultisamplePropertiesEXT + = 'False -- ' closing tick for hsc2hs + type FieldOffset "maxSampleLocationGridSize" + VkMultisamplePropertiesEXT + = + #{offset VkMultisamplePropertiesEXT, maxSampleLocationGridSize} + type FieldIsArray "maxSampleLocationGridSize" + VkMultisamplePropertiesEXT + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkMultisamplePropertiesEXT, maxSampleLocationGridSize} + +instance CanReadField "maxSampleLocationGridSize" + VkMultisamplePropertiesEXT + where + {-# INLINE getField #-} + getField = vkMaxSampleLocationGridSize + + {-# INLINE readField #-} + readField = readVkMaxSampleLocationGridSize + +instance Show VkMultisamplePropertiesEXT where + showsPrec d x + = showString "VkMultisamplePropertiesEXT {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkMaxSampleLocationGridSize = " . + showsPrec d (vkMaxSampleLocationGridSize x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkObjectTableCreateInfoNVX.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkObjectTableCreateInfoNVX.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkObjectTableCreateInfoNVX.hsc @@ -0,0 +1,764 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkObjectTableCreateInfoNVX + (VkObjectTableCreateInfoNVX(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkObjectEntryTypeNVX (VkObjectEntryTypeNVX) +import Graphics.Vulkan.Types.Enum.VkObjectEntryUsageFlagsNVX (VkObjectEntryUsageFlagsNVX) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkObjectTableCreateInfoNVX { +-- > VkStructureType sType; +-- > const void* pNext; +-- > uint32_t objectCount; +-- > const VkObjectEntryTypeNVX* pObjectEntryTypes; +-- > const uint32_t* pObjectEntryCounts; +-- > const VkObjectEntryUsageFlagsNVX* pObjectEntryUsageFlags; +-- > uint32_t maxUniformBuffersPerDescriptor; +-- > uint32_t maxStorageBuffersPerDescriptor; +-- > uint32_t maxStorageImagesPerDescriptor; +-- > uint32_t maxSampledImagesPerDescriptor; +-- > uint32_t maxPipelineLayouts; +-- > } VkObjectTableCreateInfoNVX; +-- +-- +data VkObjectTableCreateInfoNVX = VkObjectTableCreateInfoNVX## Addr## + ByteArray## + +instance Eq VkObjectTableCreateInfoNVX where + (VkObjectTableCreateInfoNVX## a _) == + x@(VkObjectTableCreateInfoNVX## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkObjectTableCreateInfoNVX where + (VkObjectTableCreateInfoNVX## a _) `compare` + x@(VkObjectTableCreateInfoNVX## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkObjectTableCreateInfoNVX where + sizeOf ~_ = #{size VkObjectTableCreateInfoNVX} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkObjectTableCreateInfoNVX} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkObjectTableCreateInfoNVX where + unsafeAddr (VkObjectTableCreateInfoNVX## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkObjectTableCreateInfoNVX## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkObjectTableCreateInfoNVX## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkObjectTableCreateInfoNVX where + type StructFields VkObjectTableCreateInfoNVX = + '["sType", "pNext", "objectCount", "pObjectEntryTypes", -- ' closing tick for hsc2hs + "pObjectEntryCounts", "pObjectEntryUsageFlags", + "maxUniformBuffersPerDescriptor", "maxStorageBuffersPerDescriptor", + "maxStorageImagesPerDescriptor", "maxSampledImagesPerDescriptor", + "maxPipelineLayouts"] + type CUnionType VkObjectTableCreateInfoNVX = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkObjectTableCreateInfoNVX = 'False -- ' closing tick for hsc2hs + type StructExtends VkObjectTableCreateInfoNVX = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkSType VkObjectTableCreateInfoNVX + where + type VkSTypeMType VkObjectTableCreateInfoNVX = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkObjectTableCreateInfoNVX, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkObjectTableCreateInfoNVX, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkObjectTableCreateInfoNVX, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkObjectTableCreateInfoNVX, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkObjectTableCreateInfoNVX where + type FieldType "sType" VkObjectTableCreateInfoNVX = VkStructureType + type FieldOptional "sType" VkObjectTableCreateInfoNVX = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkObjectTableCreateInfoNVX = + #{offset VkObjectTableCreateInfoNVX, sType} + type FieldIsArray "sType" VkObjectTableCreateInfoNVX = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkObjectTableCreateInfoNVX, sType} + +instance CanReadField "sType" VkObjectTableCreateInfoNVX where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkObjectTableCreateInfoNVX where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} HasVkPNext VkObjectTableCreateInfoNVX + where + type VkPNextMType VkObjectTableCreateInfoNVX = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkObjectTableCreateInfoNVX, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkObjectTableCreateInfoNVX, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkObjectTableCreateInfoNVX, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkObjectTableCreateInfoNVX, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkObjectTableCreateInfoNVX where + type FieldType "pNext" VkObjectTableCreateInfoNVX = Ptr Void + type FieldOptional "pNext" VkObjectTableCreateInfoNVX = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkObjectTableCreateInfoNVX = + #{offset VkObjectTableCreateInfoNVX, pNext} + type FieldIsArray "pNext" VkObjectTableCreateInfoNVX = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkObjectTableCreateInfoNVX, pNext} + +instance CanReadField "pNext" VkObjectTableCreateInfoNVX where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkObjectTableCreateInfoNVX where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkObjectCount VkObjectTableCreateInfoNVX where + type VkObjectCountMType VkObjectTableCreateInfoNVX = Word32 + + {-# NOINLINE vkObjectCount #-} + vkObjectCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkObjectTableCreateInfoNVX, objectCount}) + + {-# INLINE vkObjectCountByteOffset #-} + vkObjectCountByteOffset ~_ + = #{offset VkObjectTableCreateInfoNVX, objectCount} + + {-# INLINE readVkObjectCount #-} + readVkObjectCount p + = peekByteOff p #{offset VkObjectTableCreateInfoNVX, objectCount} + + {-# INLINE writeVkObjectCount #-} + writeVkObjectCount p + = pokeByteOff p #{offset VkObjectTableCreateInfoNVX, objectCount} + +instance {-# OVERLAPPING #-} + HasField "objectCount" VkObjectTableCreateInfoNVX where + type FieldType "objectCount" VkObjectTableCreateInfoNVX = Word32 + type FieldOptional "objectCount" VkObjectTableCreateInfoNVX = + 'False -- ' closing tick for hsc2hs + type FieldOffset "objectCount" VkObjectTableCreateInfoNVX = + #{offset VkObjectTableCreateInfoNVX, objectCount} + type FieldIsArray "objectCount" VkObjectTableCreateInfoNVX = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkObjectTableCreateInfoNVX, objectCount} + +instance CanReadField "objectCount" VkObjectTableCreateInfoNVX + where + {-# INLINE getField #-} + getField = vkObjectCount + + {-# INLINE readField #-} + readField = readVkObjectCount + +instance CanWriteField "objectCount" VkObjectTableCreateInfoNVX + where + {-# INLINE writeField #-} + writeField = writeVkObjectCount + +instance {-# OVERLAPPING #-} + HasVkPObjectEntryTypes VkObjectTableCreateInfoNVX where + type VkPObjectEntryTypesMType VkObjectTableCreateInfoNVX = + Ptr VkObjectEntryTypeNVX + + {-# NOINLINE vkPObjectEntryTypes #-} + vkPObjectEntryTypes x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkObjectTableCreateInfoNVX, pObjectEntryTypes}) + + {-# INLINE vkPObjectEntryTypesByteOffset #-} + vkPObjectEntryTypesByteOffset ~_ + = #{offset VkObjectTableCreateInfoNVX, pObjectEntryTypes} + + {-# INLINE readVkPObjectEntryTypes #-} + readVkPObjectEntryTypes p + = peekByteOff p #{offset VkObjectTableCreateInfoNVX, pObjectEntryTypes} + + {-# INLINE writeVkPObjectEntryTypes #-} + writeVkPObjectEntryTypes p + = pokeByteOff p #{offset VkObjectTableCreateInfoNVX, pObjectEntryTypes} + +instance {-# OVERLAPPING #-} + HasField "pObjectEntryTypes" VkObjectTableCreateInfoNVX where + type FieldType "pObjectEntryTypes" VkObjectTableCreateInfoNVX = + Ptr VkObjectEntryTypeNVX + type FieldOptional "pObjectEntryTypes" VkObjectTableCreateInfoNVX = + 'False -- ' closing tick for hsc2hs + type FieldOffset "pObjectEntryTypes" VkObjectTableCreateInfoNVX = + #{offset VkObjectTableCreateInfoNVX, pObjectEntryTypes} + type FieldIsArray "pObjectEntryTypes" VkObjectTableCreateInfoNVX = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkObjectTableCreateInfoNVX, pObjectEntryTypes} + +instance CanReadField "pObjectEntryTypes" + VkObjectTableCreateInfoNVX + where + {-# INLINE getField #-} + getField = vkPObjectEntryTypes + + {-# INLINE readField #-} + readField = readVkPObjectEntryTypes + +instance CanWriteField "pObjectEntryTypes" + VkObjectTableCreateInfoNVX + where + {-# INLINE writeField #-} + writeField = writeVkPObjectEntryTypes + +instance {-# OVERLAPPING #-} + HasVkPObjectEntryCounts VkObjectTableCreateInfoNVX where + type VkPObjectEntryCountsMType VkObjectTableCreateInfoNVX = + Ptr Word32 + + {-# NOINLINE vkPObjectEntryCounts #-} + vkPObjectEntryCounts x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkObjectTableCreateInfoNVX, pObjectEntryCounts}) + + {-# INLINE vkPObjectEntryCountsByteOffset #-} + vkPObjectEntryCountsByteOffset ~_ + = #{offset VkObjectTableCreateInfoNVX, pObjectEntryCounts} + + {-# INLINE readVkPObjectEntryCounts #-} + readVkPObjectEntryCounts p + = peekByteOff p #{offset VkObjectTableCreateInfoNVX, pObjectEntryCounts} + + {-# INLINE writeVkPObjectEntryCounts #-} + writeVkPObjectEntryCounts p + = pokeByteOff p #{offset VkObjectTableCreateInfoNVX, pObjectEntryCounts} + +instance {-# OVERLAPPING #-} + HasField "pObjectEntryCounts" VkObjectTableCreateInfoNVX where + type FieldType "pObjectEntryCounts" VkObjectTableCreateInfoNVX = + Ptr Word32 + type FieldOptional "pObjectEntryCounts" VkObjectTableCreateInfoNVX + = 'False -- ' closing tick for hsc2hs + type FieldOffset "pObjectEntryCounts" VkObjectTableCreateInfoNVX = + #{offset VkObjectTableCreateInfoNVX, pObjectEntryCounts} + type FieldIsArray "pObjectEntryCounts" VkObjectTableCreateInfoNVX = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkObjectTableCreateInfoNVX, pObjectEntryCounts} + +instance CanReadField "pObjectEntryCounts" + VkObjectTableCreateInfoNVX + where + {-# INLINE getField #-} + getField = vkPObjectEntryCounts + + {-# INLINE readField #-} + readField = readVkPObjectEntryCounts + +instance CanWriteField "pObjectEntryCounts" + VkObjectTableCreateInfoNVX + where + {-# INLINE writeField #-} + writeField = writeVkPObjectEntryCounts + +instance {-# OVERLAPPING #-} + HasVkPObjectEntryUsageFlags VkObjectTableCreateInfoNVX where + type VkPObjectEntryUsageFlagsMType VkObjectTableCreateInfoNVX = + Ptr VkObjectEntryUsageFlagsNVX + + {-# NOINLINE vkPObjectEntryUsageFlags #-} + vkPObjectEntryUsageFlags x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkObjectTableCreateInfoNVX, pObjectEntryUsageFlags}) + + {-# INLINE vkPObjectEntryUsageFlagsByteOffset #-} + vkPObjectEntryUsageFlagsByteOffset ~_ + = #{offset VkObjectTableCreateInfoNVX, pObjectEntryUsageFlags} + + {-# INLINE readVkPObjectEntryUsageFlags #-} + readVkPObjectEntryUsageFlags p + = peekByteOff p #{offset VkObjectTableCreateInfoNVX, pObjectEntryUsageFlags} + + {-# INLINE writeVkPObjectEntryUsageFlags #-} + writeVkPObjectEntryUsageFlags p + = pokeByteOff p #{offset VkObjectTableCreateInfoNVX, pObjectEntryUsageFlags} + +instance {-# OVERLAPPING #-} + HasField "pObjectEntryUsageFlags" VkObjectTableCreateInfoNVX where + type FieldType "pObjectEntryUsageFlags" VkObjectTableCreateInfoNVX + = Ptr VkObjectEntryUsageFlagsNVX + type FieldOptional "pObjectEntryUsageFlags" + VkObjectTableCreateInfoNVX + = 'False -- ' closing tick for hsc2hs + type FieldOffset "pObjectEntryUsageFlags" + VkObjectTableCreateInfoNVX + = + #{offset VkObjectTableCreateInfoNVX, pObjectEntryUsageFlags} + type FieldIsArray "pObjectEntryUsageFlags" + VkObjectTableCreateInfoNVX + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkObjectTableCreateInfoNVX, pObjectEntryUsageFlags} + +instance CanReadField "pObjectEntryUsageFlags" + VkObjectTableCreateInfoNVX + where + {-# INLINE getField #-} + getField = vkPObjectEntryUsageFlags + + {-# INLINE readField #-} + readField = readVkPObjectEntryUsageFlags + +instance CanWriteField "pObjectEntryUsageFlags" + VkObjectTableCreateInfoNVX + where + {-# INLINE writeField #-} + writeField = writeVkPObjectEntryUsageFlags + +instance {-# OVERLAPPING #-} + HasVkMaxUniformBuffersPerDescriptor VkObjectTableCreateInfoNVX + where + type VkMaxUniformBuffersPerDescriptorMType + VkObjectTableCreateInfoNVX + = Word32 + + {-# NOINLINE vkMaxUniformBuffersPerDescriptor #-} + vkMaxUniformBuffersPerDescriptor x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkObjectTableCreateInfoNVX, maxUniformBuffersPerDescriptor}) + + {-# INLINE vkMaxUniformBuffersPerDescriptorByteOffset #-} + vkMaxUniformBuffersPerDescriptorByteOffset ~_ + = #{offset VkObjectTableCreateInfoNVX, maxUniformBuffersPerDescriptor} + + {-# INLINE readVkMaxUniformBuffersPerDescriptor #-} + readVkMaxUniformBuffersPerDescriptor p + = peekByteOff p #{offset VkObjectTableCreateInfoNVX, maxUniformBuffersPerDescriptor} + + {-# INLINE writeVkMaxUniformBuffersPerDescriptor #-} + writeVkMaxUniformBuffersPerDescriptor p + = pokeByteOff p #{offset VkObjectTableCreateInfoNVX, maxUniformBuffersPerDescriptor} + +instance {-# OVERLAPPING #-} + HasField "maxUniformBuffersPerDescriptor" + VkObjectTableCreateInfoNVX + where + type FieldType "maxUniformBuffersPerDescriptor" + VkObjectTableCreateInfoNVX + = Word32 + type FieldOptional "maxUniformBuffersPerDescriptor" + VkObjectTableCreateInfoNVX + = 'False -- ' closing tick for hsc2hs + type FieldOffset "maxUniformBuffersPerDescriptor" + VkObjectTableCreateInfoNVX + = + #{offset VkObjectTableCreateInfoNVX, maxUniformBuffersPerDescriptor} + type FieldIsArray "maxUniformBuffersPerDescriptor" + VkObjectTableCreateInfoNVX + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkObjectTableCreateInfoNVX, maxUniformBuffersPerDescriptor} + +instance CanReadField "maxUniformBuffersPerDescriptor" + VkObjectTableCreateInfoNVX + where + {-# INLINE getField #-} + getField = vkMaxUniformBuffersPerDescriptor + + {-# INLINE readField #-} + readField = readVkMaxUniformBuffersPerDescriptor + +instance CanWriteField "maxUniformBuffersPerDescriptor" + VkObjectTableCreateInfoNVX + where + {-# INLINE writeField #-} + writeField = writeVkMaxUniformBuffersPerDescriptor + +instance {-# OVERLAPPING #-} + HasVkMaxStorageBuffersPerDescriptor VkObjectTableCreateInfoNVX + where + type VkMaxStorageBuffersPerDescriptorMType + VkObjectTableCreateInfoNVX + = Word32 + + {-# NOINLINE vkMaxStorageBuffersPerDescriptor #-} + vkMaxStorageBuffersPerDescriptor x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkObjectTableCreateInfoNVX, maxStorageBuffersPerDescriptor}) + + {-# INLINE vkMaxStorageBuffersPerDescriptorByteOffset #-} + vkMaxStorageBuffersPerDescriptorByteOffset ~_ + = #{offset VkObjectTableCreateInfoNVX, maxStorageBuffersPerDescriptor} + + {-# INLINE readVkMaxStorageBuffersPerDescriptor #-} + readVkMaxStorageBuffersPerDescriptor p + = peekByteOff p #{offset VkObjectTableCreateInfoNVX, maxStorageBuffersPerDescriptor} + + {-# INLINE writeVkMaxStorageBuffersPerDescriptor #-} + writeVkMaxStorageBuffersPerDescriptor p + = pokeByteOff p #{offset VkObjectTableCreateInfoNVX, maxStorageBuffersPerDescriptor} + +instance {-# OVERLAPPING #-} + HasField "maxStorageBuffersPerDescriptor" + VkObjectTableCreateInfoNVX + where + type FieldType "maxStorageBuffersPerDescriptor" + VkObjectTableCreateInfoNVX + = Word32 + type FieldOptional "maxStorageBuffersPerDescriptor" + VkObjectTableCreateInfoNVX + = 'False -- ' closing tick for hsc2hs + type FieldOffset "maxStorageBuffersPerDescriptor" + VkObjectTableCreateInfoNVX + = + #{offset VkObjectTableCreateInfoNVX, maxStorageBuffersPerDescriptor} + type FieldIsArray "maxStorageBuffersPerDescriptor" + VkObjectTableCreateInfoNVX + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkObjectTableCreateInfoNVX, maxStorageBuffersPerDescriptor} + +instance CanReadField "maxStorageBuffersPerDescriptor" + VkObjectTableCreateInfoNVX + where + {-# INLINE getField #-} + getField = vkMaxStorageBuffersPerDescriptor + + {-# INLINE readField #-} + readField = readVkMaxStorageBuffersPerDescriptor + +instance CanWriteField "maxStorageBuffersPerDescriptor" + VkObjectTableCreateInfoNVX + where + {-# INLINE writeField #-} + writeField = writeVkMaxStorageBuffersPerDescriptor + +instance {-# OVERLAPPING #-} + HasVkMaxStorageImagesPerDescriptor VkObjectTableCreateInfoNVX where + type VkMaxStorageImagesPerDescriptorMType + VkObjectTableCreateInfoNVX + = Word32 + + {-# NOINLINE vkMaxStorageImagesPerDescriptor #-} + vkMaxStorageImagesPerDescriptor x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkObjectTableCreateInfoNVX, maxStorageImagesPerDescriptor}) + + {-# INLINE vkMaxStorageImagesPerDescriptorByteOffset #-} + vkMaxStorageImagesPerDescriptorByteOffset ~_ + = #{offset VkObjectTableCreateInfoNVX, maxStorageImagesPerDescriptor} + + {-# INLINE readVkMaxStorageImagesPerDescriptor #-} + readVkMaxStorageImagesPerDescriptor p + = peekByteOff p #{offset VkObjectTableCreateInfoNVX, maxStorageImagesPerDescriptor} + + {-# INLINE writeVkMaxStorageImagesPerDescriptor #-} + writeVkMaxStorageImagesPerDescriptor p + = pokeByteOff p #{offset VkObjectTableCreateInfoNVX, maxStorageImagesPerDescriptor} + +instance {-# OVERLAPPING #-} + HasField "maxStorageImagesPerDescriptor" VkObjectTableCreateInfoNVX + where + type FieldType "maxStorageImagesPerDescriptor" + VkObjectTableCreateInfoNVX + = Word32 + type FieldOptional "maxStorageImagesPerDescriptor" + VkObjectTableCreateInfoNVX + = 'False -- ' closing tick for hsc2hs + type FieldOffset "maxStorageImagesPerDescriptor" + VkObjectTableCreateInfoNVX + = + #{offset VkObjectTableCreateInfoNVX, maxStorageImagesPerDescriptor} + type FieldIsArray "maxStorageImagesPerDescriptor" + VkObjectTableCreateInfoNVX + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkObjectTableCreateInfoNVX, maxStorageImagesPerDescriptor} + +instance CanReadField "maxStorageImagesPerDescriptor" + VkObjectTableCreateInfoNVX + where + {-# INLINE getField #-} + getField = vkMaxStorageImagesPerDescriptor + + {-# INLINE readField #-} + readField = readVkMaxStorageImagesPerDescriptor + +instance CanWriteField "maxStorageImagesPerDescriptor" + VkObjectTableCreateInfoNVX + where + {-# INLINE writeField #-} + writeField = writeVkMaxStorageImagesPerDescriptor + +instance {-# OVERLAPPING #-} + HasVkMaxSampledImagesPerDescriptor VkObjectTableCreateInfoNVX where + type VkMaxSampledImagesPerDescriptorMType + VkObjectTableCreateInfoNVX + = Word32 + + {-# NOINLINE vkMaxSampledImagesPerDescriptor #-} + vkMaxSampledImagesPerDescriptor x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkObjectTableCreateInfoNVX, maxSampledImagesPerDescriptor}) + + {-# INLINE vkMaxSampledImagesPerDescriptorByteOffset #-} + vkMaxSampledImagesPerDescriptorByteOffset ~_ + = #{offset VkObjectTableCreateInfoNVX, maxSampledImagesPerDescriptor} + + {-# INLINE readVkMaxSampledImagesPerDescriptor #-} + readVkMaxSampledImagesPerDescriptor p + = peekByteOff p #{offset VkObjectTableCreateInfoNVX, maxSampledImagesPerDescriptor} + + {-# INLINE writeVkMaxSampledImagesPerDescriptor #-} + writeVkMaxSampledImagesPerDescriptor p + = pokeByteOff p #{offset VkObjectTableCreateInfoNVX, maxSampledImagesPerDescriptor} + +instance {-# OVERLAPPING #-} + HasField "maxSampledImagesPerDescriptor" VkObjectTableCreateInfoNVX + where + type FieldType "maxSampledImagesPerDescriptor" + VkObjectTableCreateInfoNVX + = Word32 + type FieldOptional "maxSampledImagesPerDescriptor" + VkObjectTableCreateInfoNVX + = 'False -- ' closing tick for hsc2hs + type FieldOffset "maxSampledImagesPerDescriptor" + VkObjectTableCreateInfoNVX + = + #{offset VkObjectTableCreateInfoNVX, maxSampledImagesPerDescriptor} + type FieldIsArray "maxSampledImagesPerDescriptor" + VkObjectTableCreateInfoNVX + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkObjectTableCreateInfoNVX, maxSampledImagesPerDescriptor} + +instance CanReadField "maxSampledImagesPerDescriptor" + VkObjectTableCreateInfoNVX + where + {-# INLINE getField #-} + getField = vkMaxSampledImagesPerDescriptor + + {-# INLINE readField #-} + readField = readVkMaxSampledImagesPerDescriptor + +instance CanWriteField "maxSampledImagesPerDescriptor" + VkObjectTableCreateInfoNVX + where + {-# INLINE writeField #-} + writeField = writeVkMaxSampledImagesPerDescriptor + +instance {-# OVERLAPPING #-} + HasVkMaxPipelineLayouts VkObjectTableCreateInfoNVX where + type VkMaxPipelineLayoutsMType VkObjectTableCreateInfoNVX = Word32 + + {-# NOINLINE vkMaxPipelineLayouts #-} + vkMaxPipelineLayouts x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkObjectTableCreateInfoNVX, maxPipelineLayouts}) + + {-# INLINE vkMaxPipelineLayoutsByteOffset #-} + vkMaxPipelineLayoutsByteOffset ~_ + = #{offset VkObjectTableCreateInfoNVX, maxPipelineLayouts} + + {-# INLINE readVkMaxPipelineLayouts #-} + readVkMaxPipelineLayouts p + = peekByteOff p #{offset VkObjectTableCreateInfoNVX, maxPipelineLayouts} + + {-# INLINE writeVkMaxPipelineLayouts #-} + writeVkMaxPipelineLayouts p + = pokeByteOff p #{offset VkObjectTableCreateInfoNVX, maxPipelineLayouts} + +instance {-# OVERLAPPING #-} + HasField "maxPipelineLayouts" VkObjectTableCreateInfoNVX where + type FieldType "maxPipelineLayouts" VkObjectTableCreateInfoNVX = + Word32 + type FieldOptional "maxPipelineLayouts" VkObjectTableCreateInfoNVX + = 'False -- ' closing tick for hsc2hs + type FieldOffset "maxPipelineLayouts" VkObjectTableCreateInfoNVX = + #{offset VkObjectTableCreateInfoNVX, maxPipelineLayouts} + type FieldIsArray "maxPipelineLayouts" VkObjectTableCreateInfoNVX = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkObjectTableCreateInfoNVX, maxPipelineLayouts} + +instance CanReadField "maxPipelineLayouts" + VkObjectTableCreateInfoNVX + where + {-# INLINE getField #-} + getField = vkMaxPipelineLayouts + + {-# INLINE readField #-} + readField = readVkMaxPipelineLayouts + +instance CanWriteField "maxPipelineLayouts" + VkObjectTableCreateInfoNVX + where + {-# INLINE writeField #-} + writeField = writeVkMaxPipelineLayouts + +instance Show VkObjectTableCreateInfoNVX where + showsPrec d x + = showString "VkObjectTableCreateInfoNVX {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkObjectCount = " . + showsPrec d (vkObjectCount x) . + showString ", " . + showString "vkPObjectEntryTypes = " . + showsPrec d (vkPObjectEntryTypes x) . + showString ", " . + showString "vkPObjectEntryCounts = " . + showsPrec d (vkPObjectEntryCounts x) . + showString ", " . + showString "vkPObjectEntryUsageFlags = " . + showsPrec d (vkPObjectEntryUsageFlags x) . + showString ", " . + showString "vkMaxUniformBuffersPerDescriptor = " . + showsPrec d (vkMaxUniformBuffersPerDescriptor x) + . + showString ", " . + showString + "vkMaxStorageBuffersPerDescriptor = " + . + showsPrec d + (vkMaxStorageBuffersPerDescriptor x) + . + showString ", " . + showString + "vkMaxStorageImagesPerDescriptor = " + . + showsPrec d + (vkMaxStorageImagesPerDescriptor + x) + . + showString ", " . + showString + "vkMaxSampledImagesPerDescriptor = " + . + showsPrec d + (vkMaxSampledImagesPerDescriptor + x) + . + showString ", " . + showString + "vkMaxPipelineLayouts = " + . + showsPrec d + (vkMaxPipelineLayouts + x) + . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkObjectTableDescriptorSetEntryNVX.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkObjectTableDescriptorSetEntryNVX.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkObjectTableDescriptorSetEntryNVX.hsc @@ -0,0 +1,319 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkObjectTableDescriptorSetEntryNVX + (VkObjectTableDescriptorSetEntryNVX(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkObjectEntryTypeNVX (VkObjectEntryTypeNVX) +import Graphics.Vulkan.Types.Enum.VkObjectEntryUsageFlagsNVX (VkObjectEntryUsageFlagsNVX) +import Graphics.Vulkan.Types.Handles (VkDescriptorSet, + VkPipelineLayout) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkObjectTableDescriptorSetEntryNVX { +-- > VkObjectEntryTypeNVX type; +-- > VkObjectEntryUsageFlagsNVX flags; +-- > VkPipelineLayout pipelineLayout; +-- > VkDescriptorSet descriptorSet; +-- > } VkObjectTableDescriptorSetEntryNVX; +-- +-- +data VkObjectTableDescriptorSetEntryNVX = VkObjectTableDescriptorSetEntryNVX## Addr## + ByteArray## + +instance Eq VkObjectTableDescriptorSetEntryNVX where + (VkObjectTableDescriptorSetEntryNVX## a _) == + x@(VkObjectTableDescriptorSetEntryNVX## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkObjectTableDescriptorSetEntryNVX where + (VkObjectTableDescriptorSetEntryNVX## a _) `compare` + x@(VkObjectTableDescriptorSetEntryNVX## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkObjectTableDescriptorSetEntryNVX where + sizeOf ~_ = #{size VkObjectTableDescriptorSetEntryNVX} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkObjectTableDescriptorSetEntryNVX} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkObjectTableDescriptorSetEntryNVX where + unsafeAddr (VkObjectTableDescriptorSetEntryNVX## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkObjectTableDescriptorSetEntryNVX## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkObjectTableDescriptorSetEntryNVX## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkObjectTableDescriptorSetEntryNVX where + type StructFields VkObjectTableDescriptorSetEntryNVX = + '["type", "flags", "pipelineLayout", "descriptorSet"] -- ' closing tick for hsc2hs + type CUnionType VkObjectTableDescriptorSetEntryNVX = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkObjectTableDescriptorSetEntryNVX = 'False -- ' closing tick for hsc2hs + type StructExtends VkObjectTableDescriptorSetEntryNVX = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkType VkObjectTableDescriptorSetEntryNVX where + type VkTypeMType VkObjectTableDescriptorSetEntryNVX = + VkObjectEntryTypeNVX + + {-# NOINLINE vkType #-} + vkType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkObjectTableDescriptorSetEntryNVX, type}) + + {-# INLINE vkTypeByteOffset #-} + vkTypeByteOffset ~_ + = #{offset VkObjectTableDescriptorSetEntryNVX, type} + + {-# INLINE readVkType #-} + readVkType p + = peekByteOff p #{offset VkObjectTableDescriptorSetEntryNVX, type} + + {-# INLINE writeVkType #-} + writeVkType p + = pokeByteOff p #{offset VkObjectTableDescriptorSetEntryNVX, type} + +instance {-# OVERLAPPING #-} + HasField "type" VkObjectTableDescriptorSetEntryNVX where + type FieldType "type" VkObjectTableDescriptorSetEntryNVX = + VkObjectEntryTypeNVX + type FieldOptional "type" VkObjectTableDescriptorSetEntryNVX = + 'False -- ' closing tick for hsc2hs + type FieldOffset "type" VkObjectTableDescriptorSetEntryNVX = + #{offset VkObjectTableDescriptorSetEntryNVX, type} + type FieldIsArray "type" VkObjectTableDescriptorSetEntryNVX = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkObjectTableDescriptorSetEntryNVX, type} + +instance CanReadField "type" VkObjectTableDescriptorSetEntryNVX + where + {-# INLINE getField #-} + getField = vkType + + {-# INLINE readField #-} + readField = readVkType + +instance CanWriteField "type" VkObjectTableDescriptorSetEntryNVX + where + {-# INLINE writeField #-} + writeField = writeVkType + +instance {-# OVERLAPPING #-} + HasVkFlags VkObjectTableDescriptorSetEntryNVX where + type VkFlagsMType VkObjectTableDescriptorSetEntryNVX = + VkObjectEntryUsageFlagsNVX + + {-# NOINLINE vkFlags #-} + vkFlags x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkObjectTableDescriptorSetEntryNVX, flags}) + + {-# INLINE vkFlagsByteOffset #-} + vkFlagsByteOffset ~_ + = #{offset VkObjectTableDescriptorSetEntryNVX, flags} + + {-# INLINE readVkFlags #-} + readVkFlags p + = peekByteOff p #{offset VkObjectTableDescriptorSetEntryNVX, flags} + + {-# INLINE writeVkFlags #-} + writeVkFlags p + = pokeByteOff p #{offset VkObjectTableDescriptorSetEntryNVX, flags} + +instance {-# OVERLAPPING #-} + HasField "flags" VkObjectTableDescriptorSetEntryNVX where + type FieldType "flags" VkObjectTableDescriptorSetEntryNVX = + VkObjectEntryUsageFlagsNVX + type FieldOptional "flags" VkObjectTableDescriptorSetEntryNVX = + 'False -- ' closing tick for hsc2hs + type FieldOffset "flags" VkObjectTableDescriptorSetEntryNVX = + #{offset VkObjectTableDescriptorSetEntryNVX, flags} + type FieldIsArray "flags" VkObjectTableDescriptorSetEntryNVX = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkObjectTableDescriptorSetEntryNVX, flags} + +instance CanReadField "flags" VkObjectTableDescriptorSetEntryNVX + where + {-# INLINE getField #-} + getField = vkFlags + + {-# INLINE readField #-} + readField = readVkFlags + +instance CanWriteField "flags" VkObjectTableDescriptorSetEntryNVX + where + {-# INLINE writeField #-} + writeField = writeVkFlags + +instance {-# OVERLAPPING #-} + HasVkPipelineLayout VkObjectTableDescriptorSetEntryNVX where + type VkPipelineLayoutMType VkObjectTableDescriptorSetEntryNVX = + VkPipelineLayout + + {-# NOINLINE vkPipelineLayout #-} + vkPipelineLayout x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkObjectTableDescriptorSetEntryNVX, pipelineLayout}) + + {-# INLINE vkPipelineLayoutByteOffset #-} + vkPipelineLayoutByteOffset ~_ + = #{offset VkObjectTableDescriptorSetEntryNVX, pipelineLayout} + + {-# INLINE readVkPipelineLayout #-} + readVkPipelineLayout p + = peekByteOff p #{offset VkObjectTableDescriptorSetEntryNVX, pipelineLayout} + + {-# INLINE writeVkPipelineLayout #-} + writeVkPipelineLayout p + = pokeByteOff p #{offset VkObjectTableDescriptorSetEntryNVX, pipelineLayout} + +instance {-# OVERLAPPING #-} + HasField "pipelineLayout" VkObjectTableDescriptorSetEntryNVX where + type FieldType "pipelineLayout" VkObjectTableDescriptorSetEntryNVX + = VkPipelineLayout + type FieldOptional "pipelineLayout" + VkObjectTableDescriptorSetEntryNVX + = 'False -- ' closing tick for hsc2hs + type FieldOffset "pipelineLayout" + VkObjectTableDescriptorSetEntryNVX + = + #{offset VkObjectTableDescriptorSetEntryNVX, pipelineLayout} + type FieldIsArray "pipelineLayout" + VkObjectTableDescriptorSetEntryNVX + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkObjectTableDescriptorSetEntryNVX, pipelineLayout} + +instance CanReadField "pipelineLayout" + VkObjectTableDescriptorSetEntryNVX + where + {-# INLINE getField #-} + getField = vkPipelineLayout + + {-# INLINE readField #-} + readField = readVkPipelineLayout + +instance CanWriteField "pipelineLayout" + VkObjectTableDescriptorSetEntryNVX + where + {-# INLINE writeField #-} + writeField = writeVkPipelineLayout + +instance {-# OVERLAPPING #-} + HasVkDescriptorSet VkObjectTableDescriptorSetEntryNVX where + type VkDescriptorSetMType VkObjectTableDescriptorSetEntryNVX = + VkDescriptorSet + + {-# NOINLINE vkDescriptorSet #-} + vkDescriptorSet x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkObjectTableDescriptorSetEntryNVX, descriptorSet}) + + {-# INLINE vkDescriptorSetByteOffset #-} + vkDescriptorSetByteOffset ~_ + = #{offset VkObjectTableDescriptorSetEntryNVX, descriptorSet} + + {-# INLINE readVkDescriptorSet #-} + readVkDescriptorSet p + = peekByteOff p #{offset VkObjectTableDescriptorSetEntryNVX, descriptorSet} + + {-# INLINE writeVkDescriptorSet #-} + writeVkDescriptorSet p + = pokeByteOff p #{offset VkObjectTableDescriptorSetEntryNVX, descriptorSet} + +instance {-# OVERLAPPING #-} + HasField "descriptorSet" VkObjectTableDescriptorSetEntryNVX where + type FieldType "descriptorSet" VkObjectTableDescriptorSetEntryNVX = + VkDescriptorSet + type FieldOptional "descriptorSet" + VkObjectTableDescriptorSetEntryNVX + = 'False -- ' closing tick for hsc2hs + type FieldOffset "descriptorSet" VkObjectTableDescriptorSetEntryNVX + = + #{offset VkObjectTableDescriptorSetEntryNVX, descriptorSet} + type FieldIsArray "descriptorSet" + VkObjectTableDescriptorSetEntryNVX + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkObjectTableDescriptorSetEntryNVX, descriptorSet} + +instance CanReadField "descriptorSet" + VkObjectTableDescriptorSetEntryNVX + where + {-# INLINE getField #-} + getField = vkDescriptorSet + + {-# INLINE readField #-} + readField = readVkDescriptorSet + +instance CanWriteField "descriptorSet" + VkObjectTableDescriptorSetEntryNVX + where + {-# INLINE writeField #-} + writeField = writeVkDescriptorSet + +instance Show VkObjectTableDescriptorSetEntryNVX where + showsPrec d x + = showString "VkObjectTableDescriptorSetEntryNVX {" . + showString "vkType = " . + showsPrec d (vkType x) . + showString ", " . + showString "vkFlags = " . + showsPrec d (vkFlags x) . + showString ", " . + showString "vkPipelineLayout = " . + showsPrec d (vkPipelineLayout x) . + showString ", " . + showString "vkDescriptorSet = " . + showsPrec d (vkDescriptorSet x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkObjectTableEntryNVX.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkObjectTableEntryNVX.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkObjectTableEntryNVX.hsc @@ -0,0 +1,171 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkObjectTableEntryNVX + (VkObjectTableEntryNVX(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkObjectEntryTypeNVX (VkObjectEntryTypeNVX) +import Graphics.Vulkan.Types.Enum.VkObjectEntryUsageFlagsNVX (VkObjectEntryUsageFlagsNVX) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkObjectTableEntryNVX { +-- > VkObjectEntryTypeNVX type; +-- > VkObjectEntryUsageFlagsNVX flags; +-- > } VkObjectTableEntryNVX; +-- +-- +data VkObjectTableEntryNVX = VkObjectTableEntryNVX## Addr## + ByteArray## + +instance Eq VkObjectTableEntryNVX where + (VkObjectTableEntryNVX## a _) == x@(VkObjectTableEntryNVX## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkObjectTableEntryNVX where + (VkObjectTableEntryNVX## a _) `compare` + x@(VkObjectTableEntryNVX## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkObjectTableEntryNVX where + sizeOf ~_ = #{size VkObjectTableEntryNVX} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkObjectTableEntryNVX} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkObjectTableEntryNVX where + unsafeAddr (VkObjectTableEntryNVX## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkObjectTableEntryNVX## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkObjectTableEntryNVX## (plusAddr## (byteArrayContents## b) off) b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkObjectTableEntryNVX where + type StructFields VkObjectTableEntryNVX = '["type", "flags"] -- ' closing tick for hsc2hs + type CUnionType VkObjectTableEntryNVX = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkObjectTableEntryNVX = 'False -- ' closing tick for hsc2hs + type StructExtends VkObjectTableEntryNVX = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkType VkObjectTableEntryNVX where + type VkTypeMType VkObjectTableEntryNVX = VkObjectEntryTypeNVX + + {-# NOINLINE vkType #-} + vkType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkObjectTableEntryNVX, type}) + + {-# INLINE vkTypeByteOffset #-} + vkTypeByteOffset ~_ + = #{offset VkObjectTableEntryNVX, type} + + {-# INLINE readVkType #-} + readVkType p + = peekByteOff p #{offset VkObjectTableEntryNVX, type} + + {-# INLINE writeVkType #-} + writeVkType p + = pokeByteOff p #{offset VkObjectTableEntryNVX, type} + +instance {-# OVERLAPPING #-} HasField "type" VkObjectTableEntryNVX + where + type FieldType "type" VkObjectTableEntryNVX = VkObjectEntryTypeNVX + type FieldOptional "type" VkObjectTableEntryNVX = 'False -- ' closing tick for hsc2hs + type FieldOffset "type" VkObjectTableEntryNVX = + #{offset VkObjectTableEntryNVX, type} + type FieldIsArray "type" VkObjectTableEntryNVX = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkObjectTableEntryNVX, type} + +instance CanReadField "type" VkObjectTableEntryNVX where + {-# INLINE getField #-} + getField = vkType + + {-# INLINE readField #-} + readField = readVkType + +instance CanWriteField "type" VkObjectTableEntryNVX where + {-# INLINE writeField #-} + writeField = writeVkType + +instance {-# OVERLAPPING #-} HasVkFlags VkObjectTableEntryNVX where + type VkFlagsMType VkObjectTableEntryNVX = + VkObjectEntryUsageFlagsNVX + + {-# NOINLINE vkFlags #-} + vkFlags x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkObjectTableEntryNVX, flags}) + + {-# INLINE vkFlagsByteOffset #-} + vkFlagsByteOffset ~_ + = #{offset VkObjectTableEntryNVX, flags} + + {-# INLINE readVkFlags #-} + readVkFlags p + = peekByteOff p #{offset VkObjectTableEntryNVX, flags} + + {-# INLINE writeVkFlags #-} + writeVkFlags p + = pokeByteOff p #{offset VkObjectTableEntryNVX, flags} + +instance {-# OVERLAPPING #-} HasField "flags" VkObjectTableEntryNVX + where + type FieldType "flags" VkObjectTableEntryNVX = + VkObjectEntryUsageFlagsNVX + type FieldOptional "flags" VkObjectTableEntryNVX = 'False -- ' closing tick for hsc2hs + type FieldOffset "flags" VkObjectTableEntryNVX = + #{offset VkObjectTableEntryNVX, flags} + type FieldIsArray "flags" VkObjectTableEntryNVX = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkObjectTableEntryNVX, flags} + +instance CanReadField "flags" VkObjectTableEntryNVX where + {-# INLINE getField #-} + getField = vkFlags + + {-# INLINE readField #-} + readField = readVkFlags + +instance CanWriteField "flags" VkObjectTableEntryNVX where + {-# INLINE writeField #-} + writeField = writeVkFlags + +instance Show VkObjectTableEntryNVX where + showsPrec d x + = showString "VkObjectTableEntryNVX {" . + showString "vkType = " . + showsPrec d (vkType x) . + showString ", " . + showString "vkFlags = " . showsPrec d (vkFlags x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkObjectTableIndexBufferEntryNVX.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkObjectTableIndexBufferEntryNVX.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkObjectTableIndexBufferEntryNVX.hsc @@ -0,0 +1,302 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkObjectTableIndexBufferEntryNVX + (VkObjectTableIndexBufferEntryNVX(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkIndexType (VkIndexType) +import Graphics.Vulkan.Types.Enum.VkObjectEntryTypeNVX (VkObjectEntryTypeNVX) +import Graphics.Vulkan.Types.Enum.VkObjectEntryUsageFlagsNVX (VkObjectEntryUsageFlagsNVX) +import Graphics.Vulkan.Types.Handles (VkBuffer) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkObjectTableIndexBufferEntryNVX { +-- > VkObjectEntryTypeNVX type; +-- > VkObjectEntryUsageFlagsNVX flags; +-- > VkBuffer buffer; +-- > VkIndexType indexType; +-- > } VkObjectTableIndexBufferEntryNVX; +-- +-- +data VkObjectTableIndexBufferEntryNVX = VkObjectTableIndexBufferEntryNVX## Addr## + ByteArray## + +instance Eq VkObjectTableIndexBufferEntryNVX where + (VkObjectTableIndexBufferEntryNVX## a _) == + x@(VkObjectTableIndexBufferEntryNVX## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkObjectTableIndexBufferEntryNVX where + (VkObjectTableIndexBufferEntryNVX## a _) `compare` + x@(VkObjectTableIndexBufferEntryNVX## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkObjectTableIndexBufferEntryNVX where + sizeOf ~_ = #{size VkObjectTableIndexBufferEntryNVX} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkObjectTableIndexBufferEntryNVX} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkObjectTableIndexBufferEntryNVX where + unsafeAddr (VkObjectTableIndexBufferEntryNVX## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkObjectTableIndexBufferEntryNVX## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkObjectTableIndexBufferEntryNVX## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkObjectTableIndexBufferEntryNVX where + type StructFields VkObjectTableIndexBufferEntryNVX = + '["type", "flags", "buffer", "indexType"] -- ' closing tick for hsc2hs + type CUnionType VkObjectTableIndexBufferEntryNVX = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkObjectTableIndexBufferEntryNVX = 'False -- ' closing tick for hsc2hs + type StructExtends VkObjectTableIndexBufferEntryNVX = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkType VkObjectTableIndexBufferEntryNVX where + type VkTypeMType VkObjectTableIndexBufferEntryNVX = + VkObjectEntryTypeNVX + + {-# NOINLINE vkType #-} + vkType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkObjectTableIndexBufferEntryNVX, type}) + + {-# INLINE vkTypeByteOffset #-} + vkTypeByteOffset ~_ + = #{offset VkObjectTableIndexBufferEntryNVX, type} + + {-# INLINE readVkType #-} + readVkType p + = peekByteOff p #{offset VkObjectTableIndexBufferEntryNVX, type} + + {-# INLINE writeVkType #-} + writeVkType p + = pokeByteOff p #{offset VkObjectTableIndexBufferEntryNVX, type} + +instance {-# OVERLAPPING #-} + HasField "type" VkObjectTableIndexBufferEntryNVX where + type FieldType "type" VkObjectTableIndexBufferEntryNVX = + VkObjectEntryTypeNVX + type FieldOptional "type" VkObjectTableIndexBufferEntryNVX = 'False -- ' closing tick for hsc2hs + type FieldOffset "type" VkObjectTableIndexBufferEntryNVX = + #{offset VkObjectTableIndexBufferEntryNVX, type} + type FieldIsArray "type" VkObjectTableIndexBufferEntryNVX = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkObjectTableIndexBufferEntryNVX, type} + +instance CanReadField "type" VkObjectTableIndexBufferEntryNVX where + {-# INLINE getField #-} + getField = vkType + + {-# INLINE readField #-} + readField = readVkType + +instance CanWriteField "type" VkObjectTableIndexBufferEntryNVX + where + {-# INLINE writeField #-} + writeField = writeVkType + +instance {-# OVERLAPPING #-} + HasVkFlags VkObjectTableIndexBufferEntryNVX where + type VkFlagsMType VkObjectTableIndexBufferEntryNVX = + VkObjectEntryUsageFlagsNVX + + {-# NOINLINE vkFlags #-} + vkFlags x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkObjectTableIndexBufferEntryNVX, flags}) + + {-# INLINE vkFlagsByteOffset #-} + vkFlagsByteOffset ~_ + = #{offset VkObjectTableIndexBufferEntryNVX, flags} + + {-# INLINE readVkFlags #-} + readVkFlags p + = peekByteOff p #{offset VkObjectTableIndexBufferEntryNVX, flags} + + {-# INLINE writeVkFlags #-} + writeVkFlags p + = pokeByteOff p #{offset VkObjectTableIndexBufferEntryNVX, flags} + +instance {-# OVERLAPPING #-} + HasField "flags" VkObjectTableIndexBufferEntryNVX where + type FieldType "flags" VkObjectTableIndexBufferEntryNVX = + VkObjectEntryUsageFlagsNVX + type FieldOptional "flags" VkObjectTableIndexBufferEntryNVX = + 'False -- ' closing tick for hsc2hs + type FieldOffset "flags" VkObjectTableIndexBufferEntryNVX = + #{offset VkObjectTableIndexBufferEntryNVX, flags} + type FieldIsArray "flags" VkObjectTableIndexBufferEntryNVX = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkObjectTableIndexBufferEntryNVX, flags} + +instance CanReadField "flags" VkObjectTableIndexBufferEntryNVX + where + {-# INLINE getField #-} + getField = vkFlags + + {-# INLINE readField #-} + readField = readVkFlags + +instance CanWriteField "flags" VkObjectTableIndexBufferEntryNVX + where + {-# INLINE writeField #-} + writeField = writeVkFlags + +instance {-# OVERLAPPING #-} + HasVkBuffer VkObjectTableIndexBufferEntryNVX where + type VkBufferMType VkObjectTableIndexBufferEntryNVX = VkBuffer + + {-# NOINLINE vkBuffer #-} + vkBuffer x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkObjectTableIndexBufferEntryNVX, buffer}) + + {-# INLINE vkBufferByteOffset #-} + vkBufferByteOffset ~_ + = #{offset VkObjectTableIndexBufferEntryNVX, buffer} + + {-# INLINE readVkBuffer #-} + readVkBuffer p + = peekByteOff p #{offset VkObjectTableIndexBufferEntryNVX, buffer} + + {-# INLINE writeVkBuffer #-} + writeVkBuffer p + = pokeByteOff p #{offset VkObjectTableIndexBufferEntryNVX, buffer} + +instance {-# OVERLAPPING #-} + HasField "buffer" VkObjectTableIndexBufferEntryNVX where + type FieldType "buffer" VkObjectTableIndexBufferEntryNVX = VkBuffer + type FieldOptional "buffer" VkObjectTableIndexBufferEntryNVX = + 'False -- ' closing tick for hsc2hs + type FieldOffset "buffer" VkObjectTableIndexBufferEntryNVX = + #{offset VkObjectTableIndexBufferEntryNVX, buffer} + type FieldIsArray "buffer" VkObjectTableIndexBufferEntryNVX = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkObjectTableIndexBufferEntryNVX, buffer} + +instance CanReadField "buffer" VkObjectTableIndexBufferEntryNVX + where + {-# INLINE getField #-} + getField = vkBuffer + + {-# INLINE readField #-} + readField = readVkBuffer + +instance CanWriteField "buffer" VkObjectTableIndexBufferEntryNVX + where + {-# INLINE writeField #-} + writeField = writeVkBuffer + +instance {-# OVERLAPPING #-} + HasVkIndexType VkObjectTableIndexBufferEntryNVX where + type VkIndexTypeMType VkObjectTableIndexBufferEntryNVX = + VkIndexType + + {-# NOINLINE vkIndexType #-} + vkIndexType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkObjectTableIndexBufferEntryNVX, indexType}) + + {-# INLINE vkIndexTypeByteOffset #-} + vkIndexTypeByteOffset ~_ + = #{offset VkObjectTableIndexBufferEntryNVX, indexType} + + {-# INLINE readVkIndexType #-} + readVkIndexType p + = peekByteOff p #{offset VkObjectTableIndexBufferEntryNVX, indexType} + + {-# INLINE writeVkIndexType #-} + writeVkIndexType p + = pokeByteOff p #{offset VkObjectTableIndexBufferEntryNVX, indexType} + +instance {-# OVERLAPPING #-} + HasField "indexType" VkObjectTableIndexBufferEntryNVX where + type FieldType "indexType" VkObjectTableIndexBufferEntryNVX = + VkIndexType + type FieldOptional "indexType" VkObjectTableIndexBufferEntryNVX = + 'False -- ' closing tick for hsc2hs + type FieldOffset "indexType" VkObjectTableIndexBufferEntryNVX = + #{offset VkObjectTableIndexBufferEntryNVX, indexType} + type FieldIsArray "indexType" VkObjectTableIndexBufferEntryNVX = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkObjectTableIndexBufferEntryNVX, indexType} + +instance CanReadField "indexType" VkObjectTableIndexBufferEntryNVX + where + {-# INLINE getField #-} + getField = vkIndexType + + {-# INLINE readField #-} + readField = readVkIndexType + +instance CanWriteField "indexType" VkObjectTableIndexBufferEntryNVX + where + {-# INLINE writeField #-} + writeField = writeVkIndexType + +instance Show VkObjectTableIndexBufferEntryNVX where + showsPrec d x + = showString "VkObjectTableIndexBufferEntryNVX {" . + showString "vkType = " . + showsPrec d (vkType x) . + showString ", " . + showString "vkFlags = " . + showsPrec d (vkFlags x) . + showString ", " . + showString "vkBuffer = " . + showsPrec d (vkBuffer x) . + showString ", " . + showString "vkIndexType = " . + showsPrec d (vkIndexType x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkObjectTablePipelineEntryNVX.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkObjectTablePipelineEntryNVX.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkObjectTablePipelineEntryNVX.hsc @@ -0,0 +1,239 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkObjectTablePipelineEntryNVX + (VkObjectTablePipelineEntryNVX(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkObjectEntryTypeNVX (VkObjectEntryTypeNVX) +import Graphics.Vulkan.Types.Enum.VkObjectEntryUsageFlagsNVX (VkObjectEntryUsageFlagsNVX) +import Graphics.Vulkan.Types.Handles (VkPipeline) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkObjectTablePipelineEntryNVX { +-- > VkObjectEntryTypeNVX type; +-- > VkObjectEntryUsageFlagsNVX flags; +-- > VkPipeline pipeline; +-- > } VkObjectTablePipelineEntryNVX; +-- +-- +data VkObjectTablePipelineEntryNVX = VkObjectTablePipelineEntryNVX## Addr## + ByteArray## + +instance Eq VkObjectTablePipelineEntryNVX where + (VkObjectTablePipelineEntryNVX## a _) == + x@(VkObjectTablePipelineEntryNVX## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkObjectTablePipelineEntryNVX where + (VkObjectTablePipelineEntryNVX## a _) `compare` + x@(VkObjectTablePipelineEntryNVX## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkObjectTablePipelineEntryNVX where + sizeOf ~_ = #{size VkObjectTablePipelineEntryNVX} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkObjectTablePipelineEntryNVX} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkObjectTablePipelineEntryNVX where + unsafeAddr (VkObjectTablePipelineEntryNVX## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkObjectTablePipelineEntryNVX## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkObjectTablePipelineEntryNVX## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkObjectTablePipelineEntryNVX where + type StructFields VkObjectTablePipelineEntryNVX = + '["type", "flags", "pipeline"] -- ' closing tick for hsc2hs + type CUnionType VkObjectTablePipelineEntryNVX = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkObjectTablePipelineEntryNVX = 'False -- ' closing tick for hsc2hs + type StructExtends VkObjectTablePipelineEntryNVX = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkType VkObjectTablePipelineEntryNVX where + type VkTypeMType VkObjectTablePipelineEntryNVX = + VkObjectEntryTypeNVX + + {-# NOINLINE vkType #-} + vkType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkObjectTablePipelineEntryNVX, type}) + + {-# INLINE vkTypeByteOffset #-} + vkTypeByteOffset ~_ + = #{offset VkObjectTablePipelineEntryNVX, type} + + {-# INLINE readVkType #-} + readVkType p + = peekByteOff p #{offset VkObjectTablePipelineEntryNVX, type} + + {-# INLINE writeVkType #-} + writeVkType p + = pokeByteOff p #{offset VkObjectTablePipelineEntryNVX, type} + +instance {-# OVERLAPPING #-} + HasField "type" VkObjectTablePipelineEntryNVX where + type FieldType "type" VkObjectTablePipelineEntryNVX = + VkObjectEntryTypeNVX + type FieldOptional "type" VkObjectTablePipelineEntryNVX = 'False -- ' closing tick for hsc2hs + type FieldOffset "type" VkObjectTablePipelineEntryNVX = + #{offset VkObjectTablePipelineEntryNVX, type} + type FieldIsArray "type" VkObjectTablePipelineEntryNVX = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkObjectTablePipelineEntryNVX, type} + +instance CanReadField "type" VkObjectTablePipelineEntryNVX where + {-# INLINE getField #-} + getField = vkType + + {-# INLINE readField #-} + readField = readVkType + +instance CanWriteField "type" VkObjectTablePipelineEntryNVX where + {-# INLINE writeField #-} + writeField = writeVkType + +instance {-# OVERLAPPING #-} + HasVkFlags VkObjectTablePipelineEntryNVX where + type VkFlagsMType VkObjectTablePipelineEntryNVX = + VkObjectEntryUsageFlagsNVX + + {-# NOINLINE vkFlags #-} + vkFlags x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkObjectTablePipelineEntryNVX, flags}) + + {-# INLINE vkFlagsByteOffset #-} + vkFlagsByteOffset ~_ + = #{offset VkObjectTablePipelineEntryNVX, flags} + + {-# INLINE readVkFlags #-} + readVkFlags p + = peekByteOff p #{offset VkObjectTablePipelineEntryNVX, flags} + + {-# INLINE writeVkFlags #-} + writeVkFlags p + = pokeByteOff p #{offset VkObjectTablePipelineEntryNVX, flags} + +instance {-# OVERLAPPING #-} + HasField "flags" VkObjectTablePipelineEntryNVX where + type FieldType "flags" VkObjectTablePipelineEntryNVX = + VkObjectEntryUsageFlagsNVX + type FieldOptional "flags" VkObjectTablePipelineEntryNVX = 'False -- ' closing tick for hsc2hs + type FieldOffset "flags" VkObjectTablePipelineEntryNVX = + #{offset VkObjectTablePipelineEntryNVX, flags} + type FieldIsArray "flags" VkObjectTablePipelineEntryNVX = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkObjectTablePipelineEntryNVX, flags} + +instance CanReadField "flags" VkObjectTablePipelineEntryNVX where + {-# INLINE getField #-} + getField = vkFlags + + {-# INLINE readField #-} + readField = readVkFlags + +instance CanWriteField "flags" VkObjectTablePipelineEntryNVX where + {-# INLINE writeField #-} + writeField = writeVkFlags + +instance {-# OVERLAPPING #-} + HasVkPipeline VkObjectTablePipelineEntryNVX where + type VkPipelineMType VkObjectTablePipelineEntryNVX = VkPipeline + + {-# NOINLINE vkPipeline #-} + vkPipeline x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkObjectTablePipelineEntryNVX, pipeline}) + + {-# INLINE vkPipelineByteOffset #-} + vkPipelineByteOffset ~_ + = #{offset VkObjectTablePipelineEntryNVX, pipeline} + + {-# INLINE readVkPipeline #-} + readVkPipeline p + = peekByteOff p #{offset VkObjectTablePipelineEntryNVX, pipeline} + + {-# INLINE writeVkPipeline #-} + writeVkPipeline p + = pokeByteOff p #{offset VkObjectTablePipelineEntryNVX, pipeline} + +instance {-# OVERLAPPING #-} + HasField "pipeline" VkObjectTablePipelineEntryNVX where + type FieldType "pipeline" VkObjectTablePipelineEntryNVX = + VkPipeline + type FieldOptional "pipeline" VkObjectTablePipelineEntryNVX = + 'False -- ' closing tick for hsc2hs + type FieldOffset "pipeline" VkObjectTablePipelineEntryNVX = + #{offset VkObjectTablePipelineEntryNVX, pipeline} + type FieldIsArray "pipeline" VkObjectTablePipelineEntryNVX = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkObjectTablePipelineEntryNVX, pipeline} + +instance CanReadField "pipeline" VkObjectTablePipelineEntryNVX + where + {-# INLINE getField #-} + getField = vkPipeline + + {-# INLINE readField #-} + readField = readVkPipeline + +instance CanWriteField "pipeline" VkObjectTablePipelineEntryNVX + where + {-# INLINE writeField #-} + writeField = writeVkPipeline + +instance Show VkObjectTablePipelineEntryNVX where + showsPrec d x + = showString "VkObjectTablePipelineEntryNVX {" . + showString "vkType = " . + showsPrec d (vkType x) . + showString ", " . + showString "vkFlags = " . + showsPrec d (vkFlags x) . + showString ", " . + showString "vkPipeline = " . + showsPrec d (vkPipeline x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkObjectTablePushConstantEntryNVX.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkObjectTablePushConstantEntryNVX.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkObjectTablePushConstantEntryNVX.hsc @@ -0,0 +1,314 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkObjectTablePushConstantEntryNVX + (VkObjectTablePushConstantEntryNVX(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkObjectEntryTypeNVX (VkObjectEntryTypeNVX) +import Graphics.Vulkan.Types.Enum.VkObjectEntryUsageFlagsNVX (VkObjectEntryUsageFlagsNVX) +import Graphics.Vulkan.Types.Enum.VkShaderStageFlags (VkShaderStageFlags) +import Graphics.Vulkan.Types.Handles (VkPipelineLayout) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkObjectTablePushConstantEntryNVX { +-- > VkObjectEntryTypeNVX type; +-- > VkObjectEntryUsageFlagsNVX flags; +-- > VkPipelineLayout pipelineLayout; +-- > VkShaderStageFlags stageFlags; +-- > } VkObjectTablePushConstantEntryNVX; +-- +-- +data VkObjectTablePushConstantEntryNVX = VkObjectTablePushConstantEntryNVX## Addr## + ByteArray## + +instance Eq VkObjectTablePushConstantEntryNVX where + (VkObjectTablePushConstantEntryNVX## a _) == + x@(VkObjectTablePushConstantEntryNVX## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkObjectTablePushConstantEntryNVX where + (VkObjectTablePushConstantEntryNVX## a _) `compare` + x@(VkObjectTablePushConstantEntryNVX## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkObjectTablePushConstantEntryNVX where + sizeOf ~_ = #{size VkObjectTablePushConstantEntryNVX} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkObjectTablePushConstantEntryNVX} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkObjectTablePushConstantEntryNVX where + unsafeAddr (VkObjectTablePushConstantEntryNVX## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkObjectTablePushConstantEntryNVX## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkObjectTablePushConstantEntryNVX## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkObjectTablePushConstantEntryNVX where + type StructFields VkObjectTablePushConstantEntryNVX = + '["type", "flags", "pipelineLayout", "stageFlags"] -- ' closing tick for hsc2hs + type CUnionType VkObjectTablePushConstantEntryNVX = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkObjectTablePushConstantEntryNVX = 'False -- ' closing tick for hsc2hs + type StructExtends VkObjectTablePushConstantEntryNVX = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkType VkObjectTablePushConstantEntryNVX where + type VkTypeMType VkObjectTablePushConstantEntryNVX = + VkObjectEntryTypeNVX + + {-# NOINLINE vkType #-} + vkType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkObjectTablePushConstantEntryNVX, type}) + + {-# INLINE vkTypeByteOffset #-} + vkTypeByteOffset ~_ + = #{offset VkObjectTablePushConstantEntryNVX, type} + + {-# INLINE readVkType #-} + readVkType p + = peekByteOff p #{offset VkObjectTablePushConstantEntryNVX, type} + + {-# INLINE writeVkType #-} + writeVkType p + = pokeByteOff p #{offset VkObjectTablePushConstantEntryNVX, type} + +instance {-# OVERLAPPING #-} + HasField "type" VkObjectTablePushConstantEntryNVX where + type FieldType "type" VkObjectTablePushConstantEntryNVX = + VkObjectEntryTypeNVX + type FieldOptional "type" VkObjectTablePushConstantEntryNVX = + 'False -- ' closing tick for hsc2hs + type FieldOffset "type" VkObjectTablePushConstantEntryNVX = + #{offset VkObjectTablePushConstantEntryNVX, type} + type FieldIsArray "type" VkObjectTablePushConstantEntryNVX = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkObjectTablePushConstantEntryNVX, type} + +instance CanReadField "type" VkObjectTablePushConstantEntryNVX + where + {-# INLINE getField #-} + getField = vkType + + {-# INLINE readField #-} + readField = readVkType + +instance CanWriteField "type" VkObjectTablePushConstantEntryNVX + where + {-# INLINE writeField #-} + writeField = writeVkType + +instance {-# OVERLAPPING #-} + HasVkFlags VkObjectTablePushConstantEntryNVX where + type VkFlagsMType VkObjectTablePushConstantEntryNVX = + VkObjectEntryUsageFlagsNVX + + {-# NOINLINE vkFlags #-} + vkFlags x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkObjectTablePushConstantEntryNVX, flags}) + + {-# INLINE vkFlagsByteOffset #-} + vkFlagsByteOffset ~_ + = #{offset VkObjectTablePushConstantEntryNVX, flags} + + {-# INLINE readVkFlags #-} + readVkFlags p + = peekByteOff p #{offset VkObjectTablePushConstantEntryNVX, flags} + + {-# INLINE writeVkFlags #-} + writeVkFlags p + = pokeByteOff p #{offset VkObjectTablePushConstantEntryNVX, flags} + +instance {-# OVERLAPPING #-} + HasField "flags" VkObjectTablePushConstantEntryNVX where + type FieldType "flags" VkObjectTablePushConstantEntryNVX = + VkObjectEntryUsageFlagsNVX + type FieldOptional "flags" VkObjectTablePushConstantEntryNVX = + 'False -- ' closing tick for hsc2hs + type FieldOffset "flags" VkObjectTablePushConstantEntryNVX = + #{offset VkObjectTablePushConstantEntryNVX, flags} + type FieldIsArray "flags" VkObjectTablePushConstantEntryNVX = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkObjectTablePushConstantEntryNVX, flags} + +instance CanReadField "flags" VkObjectTablePushConstantEntryNVX + where + {-# INLINE getField #-} + getField = vkFlags + + {-# INLINE readField #-} + readField = readVkFlags + +instance CanWriteField "flags" VkObjectTablePushConstantEntryNVX + where + {-# INLINE writeField #-} + writeField = writeVkFlags + +instance {-# OVERLAPPING #-} + HasVkPipelineLayout VkObjectTablePushConstantEntryNVX where + type VkPipelineLayoutMType VkObjectTablePushConstantEntryNVX = + VkPipelineLayout + + {-# NOINLINE vkPipelineLayout #-} + vkPipelineLayout x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkObjectTablePushConstantEntryNVX, pipelineLayout}) + + {-# INLINE vkPipelineLayoutByteOffset #-} + vkPipelineLayoutByteOffset ~_ + = #{offset VkObjectTablePushConstantEntryNVX, pipelineLayout} + + {-# INLINE readVkPipelineLayout #-} + readVkPipelineLayout p + = peekByteOff p #{offset VkObjectTablePushConstantEntryNVX, pipelineLayout} + + {-# INLINE writeVkPipelineLayout #-} + writeVkPipelineLayout p + = pokeByteOff p #{offset VkObjectTablePushConstantEntryNVX, pipelineLayout} + +instance {-# OVERLAPPING #-} + HasField "pipelineLayout" VkObjectTablePushConstantEntryNVX where + type FieldType "pipelineLayout" VkObjectTablePushConstantEntryNVX = + VkPipelineLayout + type FieldOptional "pipelineLayout" + VkObjectTablePushConstantEntryNVX + = 'False -- ' closing tick for hsc2hs + type FieldOffset "pipelineLayout" VkObjectTablePushConstantEntryNVX + = + #{offset VkObjectTablePushConstantEntryNVX, pipelineLayout} + type FieldIsArray "pipelineLayout" + VkObjectTablePushConstantEntryNVX + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkObjectTablePushConstantEntryNVX, pipelineLayout} + +instance CanReadField "pipelineLayout" + VkObjectTablePushConstantEntryNVX + where + {-# INLINE getField #-} + getField = vkPipelineLayout + + {-# INLINE readField #-} + readField = readVkPipelineLayout + +instance CanWriteField "pipelineLayout" + VkObjectTablePushConstantEntryNVX + where + {-# INLINE writeField #-} + writeField = writeVkPipelineLayout + +instance {-# OVERLAPPING #-} + HasVkStageFlags VkObjectTablePushConstantEntryNVX where + type VkStageFlagsMType VkObjectTablePushConstantEntryNVX = + VkShaderStageFlags + + {-# NOINLINE vkStageFlags #-} + vkStageFlags x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkObjectTablePushConstantEntryNVX, stageFlags}) + + {-# INLINE vkStageFlagsByteOffset #-} + vkStageFlagsByteOffset ~_ + = #{offset VkObjectTablePushConstantEntryNVX, stageFlags} + + {-# INLINE readVkStageFlags #-} + readVkStageFlags p + = peekByteOff p #{offset VkObjectTablePushConstantEntryNVX, stageFlags} + + {-# INLINE writeVkStageFlags #-} + writeVkStageFlags p + = pokeByteOff p #{offset VkObjectTablePushConstantEntryNVX, stageFlags} + +instance {-# OVERLAPPING #-} + HasField "stageFlags" VkObjectTablePushConstantEntryNVX where + type FieldType "stageFlags" VkObjectTablePushConstantEntryNVX = + VkShaderStageFlags + type FieldOptional "stageFlags" VkObjectTablePushConstantEntryNVX = + 'False -- ' closing tick for hsc2hs + type FieldOffset "stageFlags" VkObjectTablePushConstantEntryNVX = + #{offset VkObjectTablePushConstantEntryNVX, stageFlags} + type FieldIsArray "stageFlags" VkObjectTablePushConstantEntryNVX = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkObjectTablePushConstantEntryNVX, stageFlags} + +instance CanReadField "stageFlags" + VkObjectTablePushConstantEntryNVX + where + {-# INLINE getField #-} + getField = vkStageFlags + + {-# INLINE readField #-} + readField = readVkStageFlags + +instance CanWriteField "stageFlags" + VkObjectTablePushConstantEntryNVX + where + {-# INLINE writeField #-} + writeField = writeVkStageFlags + +instance Show VkObjectTablePushConstantEntryNVX where + showsPrec d x + = showString "VkObjectTablePushConstantEntryNVX {" . + showString "vkType = " . + showsPrec d (vkType x) . + showString ", " . + showString "vkFlags = " . + showsPrec d (vkFlags x) . + showString ", " . + showString "vkPipelineLayout = " . + showsPrec d (vkPipelineLayout x) . + showString ", " . + showString "vkStageFlags = " . + showsPrec d (vkStageFlags x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkObjectTableVertexBufferEntryNVX.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkObjectTableVertexBufferEntryNVX.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkObjectTableVertexBufferEntryNVX.hsc @@ -0,0 +1,247 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkObjectTableVertexBufferEntryNVX + (VkObjectTableVertexBufferEntryNVX(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkObjectEntryTypeNVX (VkObjectEntryTypeNVX) +import Graphics.Vulkan.Types.Enum.VkObjectEntryUsageFlagsNVX (VkObjectEntryUsageFlagsNVX) +import Graphics.Vulkan.Types.Handles (VkBuffer) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkObjectTableVertexBufferEntryNVX { +-- > VkObjectEntryTypeNVX type; +-- > VkObjectEntryUsageFlagsNVX flags; +-- > VkBuffer buffer; +-- > } VkObjectTableVertexBufferEntryNVX; +-- +-- +data VkObjectTableVertexBufferEntryNVX = VkObjectTableVertexBufferEntryNVX## Addr## + ByteArray## + +instance Eq VkObjectTableVertexBufferEntryNVX where + (VkObjectTableVertexBufferEntryNVX## a _) == + x@(VkObjectTableVertexBufferEntryNVX## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkObjectTableVertexBufferEntryNVX where + (VkObjectTableVertexBufferEntryNVX## a _) `compare` + x@(VkObjectTableVertexBufferEntryNVX## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkObjectTableVertexBufferEntryNVX where + sizeOf ~_ = #{size VkObjectTableVertexBufferEntryNVX} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkObjectTableVertexBufferEntryNVX} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkObjectTableVertexBufferEntryNVX where + unsafeAddr (VkObjectTableVertexBufferEntryNVX## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkObjectTableVertexBufferEntryNVX## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkObjectTableVertexBufferEntryNVX## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkObjectTableVertexBufferEntryNVX where + type StructFields VkObjectTableVertexBufferEntryNVX = + '["type", "flags", "buffer"] -- ' closing tick for hsc2hs + type CUnionType VkObjectTableVertexBufferEntryNVX = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkObjectTableVertexBufferEntryNVX = 'False -- ' closing tick for hsc2hs + type StructExtends VkObjectTableVertexBufferEntryNVX = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkType VkObjectTableVertexBufferEntryNVX where + type VkTypeMType VkObjectTableVertexBufferEntryNVX = + VkObjectEntryTypeNVX + + {-# NOINLINE vkType #-} + vkType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkObjectTableVertexBufferEntryNVX, type}) + + {-# INLINE vkTypeByteOffset #-} + vkTypeByteOffset ~_ + = #{offset VkObjectTableVertexBufferEntryNVX, type} + + {-# INLINE readVkType #-} + readVkType p + = peekByteOff p #{offset VkObjectTableVertexBufferEntryNVX, type} + + {-# INLINE writeVkType #-} + writeVkType p + = pokeByteOff p #{offset VkObjectTableVertexBufferEntryNVX, type} + +instance {-# OVERLAPPING #-} + HasField "type" VkObjectTableVertexBufferEntryNVX where + type FieldType "type" VkObjectTableVertexBufferEntryNVX = + VkObjectEntryTypeNVX + type FieldOptional "type" VkObjectTableVertexBufferEntryNVX = + 'False -- ' closing tick for hsc2hs + type FieldOffset "type" VkObjectTableVertexBufferEntryNVX = + #{offset VkObjectTableVertexBufferEntryNVX, type} + type FieldIsArray "type" VkObjectTableVertexBufferEntryNVX = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkObjectTableVertexBufferEntryNVX, type} + +instance CanReadField "type" VkObjectTableVertexBufferEntryNVX + where + {-# INLINE getField #-} + getField = vkType + + {-# INLINE readField #-} + readField = readVkType + +instance CanWriteField "type" VkObjectTableVertexBufferEntryNVX + where + {-# INLINE writeField #-} + writeField = writeVkType + +instance {-# OVERLAPPING #-} + HasVkFlags VkObjectTableVertexBufferEntryNVX where + type VkFlagsMType VkObjectTableVertexBufferEntryNVX = + VkObjectEntryUsageFlagsNVX + + {-# NOINLINE vkFlags #-} + vkFlags x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkObjectTableVertexBufferEntryNVX, flags}) + + {-# INLINE vkFlagsByteOffset #-} + vkFlagsByteOffset ~_ + = #{offset VkObjectTableVertexBufferEntryNVX, flags} + + {-# INLINE readVkFlags #-} + readVkFlags p + = peekByteOff p #{offset VkObjectTableVertexBufferEntryNVX, flags} + + {-# INLINE writeVkFlags #-} + writeVkFlags p + = pokeByteOff p #{offset VkObjectTableVertexBufferEntryNVX, flags} + +instance {-# OVERLAPPING #-} + HasField "flags" VkObjectTableVertexBufferEntryNVX where + type FieldType "flags" VkObjectTableVertexBufferEntryNVX = + VkObjectEntryUsageFlagsNVX + type FieldOptional "flags" VkObjectTableVertexBufferEntryNVX = + 'False -- ' closing tick for hsc2hs + type FieldOffset "flags" VkObjectTableVertexBufferEntryNVX = + #{offset VkObjectTableVertexBufferEntryNVX, flags} + type FieldIsArray "flags" VkObjectTableVertexBufferEntryNVX = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkObjectTableVertexBufferEntryNVX, flags} + +instance CanReadField "flags" VkObjectTableVertexBufferEntryNVX + where + {-# INLINE getField #-} + getField = vkFlags + + {-# INLINE readField #-} + readField = readVkFlags + +instance CanWriteField "flags" VkObjectTableVertexBufferEntryNVX + where + {-# INLINE writeField #-} + writeField = writeVkFlags + +instance {-# OVERLAPPING #-} + HasVkBuffer VkObjectTableVertexBufferEntryNVX where + type VkBufferMType VkObjectTableVertexBufferEntryNVX = VkBuffer + + {-# NOINLINE vkBuffer #-} + vkBuffer x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkObjectTableVertexBufferEntryNVX, buffer}) + + {-# INLINE vkBufferByteOffset #-} + vkBufferByteOffset ~_ + = #{offset VkObjectTableVertexBufferEntryNVX, buffer} + + {-# INLINE readVkBuffer #-} + readVkBuffer p + = peekByteOff p #{offset VkObjectTableVertexBufferEntryNVX, buffer} + + {-# INLINE writeVkBuffer #-} + writeVkBuffer p + = pokeByteOff p #{offset VkObjectTableVertexBufferEntryNVX, buffer} + +instance {-# OVERLAPPING #-} + HasField "buffer" VkObjectTableVertexBufferEntryNVX where + type FieldType "buffer" VkObjectTableVertexBufferEntryNVX = + VkBuffer + type FieldOptional "buffer" VkObjectTableVertexBufferEntryNVX = + 'False -- ' closing tick for hsc2hs + type FieldOffset "buffer" VkObjectTableVertexBufferEntryNVX = + #{offset VkObjectTableVertexBufferEntryNVX, buffer} + type FieldIsArray "buffer" VkObjectTableVertexBufferEntryNVX = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkObjectTableVertexBufferEntryNVX, buffer} + +instance CanReadField "buffer" VkObjectTableVertexBufferEntryNVX + where + {-# INLINE getField #-} + getField = vkBuffer + + {-# INLINE readField #-} + readField = readVkBuffer + +instance CanWriteField "buffer" VkObjectTableVertexBufferEntryNVX + where + {-# INLINE writeField #-} + writeField = writeVkBuffer + +instance Show VkObjectTableVertexBufferEntryNVX where + showsPrec d x + = showString "VkObjectTableVertexBufferEntryNVX {" . + showString "vkType = " . + showsPrec d (vkType x) . + showString ", " . + showString "vkFlags = " . + showsPrec d (vkFlags x) . + showString ", " . + showString "vkBuffer = " . showsPrec d (vkBuffer x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkOffset2D.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkOffset2D.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkOffset2D.hsc @@ -0,0 +1,158 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkOffset2D (VkOffset2D(..)) + where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkOffset2D { +-- > int32_t x; +-- > int32_t y; +-- > } VkOffset2D; +-- +-- +data VkOffset2D = VkOffset2D## Addr## ByteArray## + +instance Eq VkOffset2D where + (VkOffset2D## a _) == x@(VkOffset2D## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkOffset2D where + (VkOffset2D## a _) `compare` x@(VkOffset2D## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkOffset2D where + sizeOf ~_ = #{size VkOffset2D} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkOffset2D} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkOffset2D where + unsafeAddr (VkOffset2D## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkOffset2D## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkOffset2D## (plusAddr## (byteArrayContents## b) off) b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkOffset2D where + type StructFields VkOffset2D = '["x", "y"] -- ' closing tick for hsc2hs + type CUnionType VkOffset2D = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkOffset2D = 'False -- ' closing tick for hsc2hs + type StructExtends VkOffset2D = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkX VkOffset2D where + type VkXMType VkOffset2D = Int32 + + {-# NOINLINE vkX #-} + vkX x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkOffset2D, x}) + + {-# INLINE vkXByteOffset #-} + vkXByteOffset ~_ = #{offset VkOffset2D, x} + + {-# INLINE readVkX #-} + readVkX p = peekByteOff p #{offset VkOffset2D, x} + + {-# INLINE writeVkX #-} + writeVkX p = pokeByteOff p #{offset VkOffset2D, x} + +instance {-# OVERLAPPING #-} HasField "x" VkOffset2D where + type FieldType "x" VkOffset2D = Int32 + type FieldOptional "x" VkOffset2D = 'False -- ' closing tick for hsc2hs + type FieldOffset "x" VkOffset2D = + #{offset VkOffset2D, x} + type FieldIsArray "x" VkOffset2D = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkOffset2D, x} + +instance CanReadField "x" VkOffset2D where + {-# INLINE getField #-} + getField = vkX + + {-# INLINE readField #-} + readField = readVkX + +instance CanWriteField "x" VkOffset2D where + {-# INLINE writeField #-} + writeField = writeVkX + +instance {-# OVERLAPPING #-} HasVkY VkOffset2D where + type VkYMType VkOffset2D = Int32 + + {-# NOINLINE vkY #-} + vkY x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkOffset2D, y}) + + {-# INLINE vkYByteOffset #-} + vkYByteOffset ~_ = #{offset VkOffset2D, y} + + {-# INLINE readVkY #-} + readVkY p = peekByteOff p #{offset VkOffset2D, y} + + {-# INLINE writeVkY #-} + writeVkY p = pokeByteOff p #{offset VkOffset2D, y} + +instance {-# OVERLAPPING #-} HasField "y" VkOffset2D where + type FieldType "y" VkOffset2D = Int32 + type FieldOptional "y" VkOffset2D = 'False -- ' closing tick for hsc2hs + type FieldOffset "y" VkOffset2D = + #{offset VkOffset2D, y} + type FieldIsArray "y" VkOffset2D = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkOffset2D, y} + +instance CanReadField "y" VkOffset2D where + {-# INLINE getField #-} + getField = vkY + + {-# INLINE readField #-} + readField = readVkY + +instance CanWriteField "y" VkOffset2D where + {-# INLINE writeField #-} + writeField = writeVkY + +instance Show VkOffset2D where + showsPrec d x + = showString "VkOffset2D {" . + showString "vkX = " . + showsPrec d (vkX x) . + showString ", " . + showString "vkY = " . showsPrec d (vkY x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkOffset3D.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkOffset3D.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkOffset3D.hsc @@ -0,0 +1,203 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkOffset3D (VkOffset3D(..)) + where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkOffset3D { +-- > int32_t x; +-- > int32_t y; +-- > int32_t z; +-- > } VkOffset3D; +-- +-- +data VkOffset3D = VkOffset3D## Addr## ByteArray## + +instance Eq VkOffset3D where + (VkOffset3D## a _) == x@(VkOffset3D## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkOffset3D where + (VkOffset3D## a _) `compare` x@(VkOffset3D## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkOffset3D where + sizeOf ~_ = #{size VkOffset3D} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkOffset3D} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkOffset3D where + unsafeAddr (VkOffset3D## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkOffset3D## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkOffset3D## (plusAddr## (byteArrayContents## b) off) b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkOffset3D where + type StructFields VkOffset3D = '["x", "y", "z"] -- ' closing tick for hsc2hs + type CUnionType VkOffset3D = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkOffset3D = 'False -- ' closing tick for hsc2hs + type StructExtends VkOffset3D = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkX VkOffset3D where + type VkXMType VkOffset3D = Int32 + + {-# NOINLINE vkX #-} + vkX x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkOffset3D, x}) + + {-# INLINE vkXByteOffset #-} + vkXByteOffset ~_ = #{offset VkOffset3D, x} + + {-# INLINE readVkX #-} + readVkX p = peekByteOff p #{offset VkOffset3D, x} + + {-# INLINE writeVkX #-} + writeVkX p = pokeByteOff p #{offset VkOffset3D, x} + +instance {-# OVERLAPPING #-} HasField "x" VkOffset3D where + type FieldType "x" VkOffset3D = Int32 + type FieldOptional "x" VkOffset3D = 'False -- ' closing tick for hsc2hs + type FieldOffset "x" VkOffset3D = + #{offset VkOffset3D, x} + type FieldIsArray "x" VkOffset3D = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkOffset3D, x} + +instance CanReadField "x" VkOffset3D where + {-# INLINE getField #-} + getField = vkX + + {-# INLINE readField #-} + readField = readVkX + +instance CanWriteField "x" VkOffset3D where + {-# INLINE writeField #-} + writeField = writeVkX + +instance {-# OVERLAPPING #-} HasVkY VkOffset3D where + type VkYMType VkOffset3D = Int32 + + {-# NOINLINE vkY #-} + vkY x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkOffset3D, y}) + + {-# INLINE vkYByteOffset #-} + vkYByteOffset ~_ = #{offset VkOffset3D, y} + + {-# INLINE readVkY #-} + readVkY p = peekByteOff p #{offset VkOffset3D, y} + + {-# INLINE writeVkY #-} + writeVkY p = pokeByteOff p #{offset VkOffset3D, y} + +instance {-# OVERLAPPING #-} HasField "y" VkOffset3D where + type FieldType "y" VkOffset3D = Int32 + type FieldOptional "y" VkOffset3D = 'False -- ' closing tick for hsc2hs + type FieldOffset "y" VkOffset3D = + #{offset VkOffset3D, y} + type FieldIsArray "y" VkOffset3D = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkOffset3D, y} + +instance CanReadField "y" VkOffset3D where + {-# INLINE getField #-} + getField = vkY + + {-# INLINE readField #-} + readField = readVkY + +instance CanWriteField "y" VkOffset3D where + {-# INLINE writeField #-} + writeField = writeVkY + +instance {-# OVERLAPPING #-} HasVkZ VkOffset3D where + type VkZMType VkOffset3D = Int32 + + {-# NOINLINE vkZ #-} + vkZ x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkOffset3D, z}) + + {-# INLINE vkZByteOffset #-} + vkZByteOffset ~_ = #{offset VkOffset3D, z} + + {-# INLINE readVkZ #-} + readVkZ p = peekByteOff p #{offset VkOffset3D, z} + + {-# INLINE writeVkZ #-} + writeVkZ p = pokeByteOff p #{offset VkOffset3D, z} + +instance {-# OVERLAPPING #-} HasField "z" VkOffset3D where + type FieldType "z" VkOffset3D = Int32 + type FieldOptional "z" VkOffset3D = 'False -- ' closing tick for hsc2hs + type FieldOffset "z" VkOffset3D = + #{offset VkOffset3D, z} + type FieldIsArray "z" VkOffset3D = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkOffset3D, z} + +instance CanReadField "z" VkOffset3D where + {-# INLINE getField #-} + getField = vkZ + + {-# INLINE readField #-} + readField = readVkZ + +instance CanWriteField "z" VkOffset3D where + {-# INLINE writeField #-} + writeField = writeVkZ + +instance Show VkOffset3D where + showsPrec d x + = showString "VkOffset3D {" . + showString "vkX = " . + showsPrec d (vkX x) . + showString ", " . + showString "vkY = " . + showsPrec d (vkY x) . + showString ", " . + showString "vkZ = " . showsPrec d (vkZ x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkPastPresentationTimingGOOGLE.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkPastPresentationTimingGOOGLE.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkPastPresentationTimingGOOGLE.hsc @@ -0,0 +1,377 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkPastPresentationTimingGOOGLE + (VkPastPresentationTimingGOOGLE(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkPastPresentationTimingGOOGLE { +-- > uint32_t presentID; +-- > uint64_t desiredPresentTime; +-- > uint64_t actualPresentTime; +-- > uint64_t earliestPresentTime; +-- > uint64_t presentMargin; +-- > } VkPastPresentationTimingGOOGLE; +-- +-- +data VkPastPresentationTimingGOOGLE = VkPastPresentationTimingGOOGLE## Addr## + ByteArray## + +instance Eq VkPastPresentationTimingGOOGLE where + (VkPastPresentationTimingGOOGLE## a _) == + x@(VkPastPresentationTimingGOOGLE## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkPastPresentationTimingGOOGLE where + (VkPastPresentationTimingGOOGLE## a _) `compare` + x@(VkPastPresentationTimingGOOGLE## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkPastPresentationTimingGOOGLE where + sizeOf ~_ = #{size VkPastPresentationTimingGOOGLE} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkPastPresentationTimingGOOGLE} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkPastPresentationTimingGOOGLE where + unsafeAddr (VkPastPresentationTimingGOOGLE## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkPastPresentationTimingGOOGLE## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkPastPresentationTimingGOOGLE## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkPastPresentationTimingGOOGLE where + type StructFields VkPastPresentationTimingGOOGLE = + '["presentID", "desiredPresentTime", "actualPresentTime", -- ' closing tick for hsc2hs + "earliestPresentTime", "presentMargin"] + type CUnionType VkPastPresentationTimingGOOGLE = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkPastPresentationTimingGOOGLE = 'False -- ' closing tick for hsc2hs + type StructExtends VkPastPresentationTimingGOOGLE = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkPresentID VkPastPresentationTimingGOOGLE where + type VkPresentIDMType VkPastPresentationTimingGOOGLE = Word32 + + {-# NOINLINE vkPresentID #-} + vkPresentID x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPastPresentationTimingGOOGLE, presentID}) + + {-# INLINE vkPresentIDByteOffset #-} + vkPresentIDByteOffset ~_ + = #{offset VkPastPresentationTimingGOOGLE, presentID} + + {-# INLINE readVkPresentID #-} + readVkPresentID p + = peekByteOff p #{offset VkPastPresentationTimingGOOGLE, presentID} + + {-# INLINE writeVkPresentID #-} + writeVkPresentID p + = pokeByteOff p #{offset VkPastPresentationTimingGOOGLE, presentID} + +instance {-# OVERLAPPING #-} + HasField "presentID" VkPastPresentationTimingGOOGLE where + type FieldType "presentID" VkPastPresentationTimingGOOGLE = Word32 + type FieldOptional "presentID" VkPastPresentationTimingGOOGLE = + 'False -- ' closing tick for hsc2hs + type FieldOffset "presentID" VkPastPresentationTimingGOOGLE = + #{offset VkPastPresentationTimingGOOGLE, presentID} + type FieldIsArray "presentID" VkPastPresentationTimingGOOGLE = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPastPresentationTimingGOOGLE, presentID} + +instance CanReadField "presentID" VkPastPresentationTimingGOOGLE + where + {-# INLINE getField #-} + getField = vkPresentID + + {-# INLINE readField #-} + readField = readVkPresentID + +instance CanWriteField "presentID" VkPastPresentationTimingGOOGLE + where + {-# INLINE writeField #-} + writeField = writeVkPresentID + +instance {-# OVERLAPPING #-} + HasVkDesiredPresentTime VkPastPresentationTimingGOOGLE where + type VkDesiredPresentTimeMType VkPastPresentationTimingGOOGLE = + Word64 + + {-# NOINLINE vkDesiredPresentTime #-} + vkDesiredPresentTime x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPastPresentationTimingGOOGLE, desiredPresentTime}) + + {-# INLINE vkDesiredPresentTimeByteOffset #-} + vkDesiredPresentTimeByteOffset ~_ + = #{offset VkPastPresentationTimingGOOGLE, desiredPresentTime} + + {-# INLINE readVkDesiredPresentTime #-} + readVkDesiredPresentTime p + = peekByteOff p #{offset VkPastPresentationTimingGOOGLE, desiredPresentTime} + + {-# INLINE writeVkDesiredPresentTime #-} + writeVkDesiredPresentTime p + = pokeByteOff p #{offset VkPastPresentationTimingGOOGLE, desiredPresentTime} + +instance {-# OVERLAPPING #-} + HasField "desiredPresentTime" VkPastPresentationTimingGOOGLE where + type FieldType "desiredPresentTime" VkPastPresentationTimingGOOGLE + = Word64 + type FieldOptional "desiredPresentTime" + VkPastPresentationTimingGOOGLE + = 'False -- ' closing tick for hsc2hs + type FieldOffset "desiredPresentTime" + VkPastPresentationTimingGOOGLE + = + #{offset VkPastPresentationTimingGOOGLE, desiredPresentTime} + type FieldIsArray "desiredPresentTime" + VkPastPresentationTimingGOOGLE + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPastPresentationTimingGOOGLE, desiredPresentTime} + +instance CanReadField "desiredPresentTime" + VkPastPresentationTimingGOOGLE + where + {-# INLINE getField #-} + getField = vkDesiredPresentTime + + {-# INLINE readField #-} + readField = readVkDesiredPresentTime + +instance CanWriteField "desiredPresentTime" + VkPastPresentationTimingGOOGLE + where + {-# INLINE writeField #-} + writeField = writeVkDesiredPresentTime + +instance {-# OVERLAPPING #-} + HasVkActualPresentTime VkPastPresentationTimingGOOGLE where + type VkActualPresentTimeMType VkPastPresentationTimingGOOGLE = + Word64 + + {-# NOINLINE vkActualPresentTime #-} + vkActualPresentTime x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPastPresentationTimingGOOGLE, actualPresentTime}) + + {-# INLINE vkActualPresentTimeByteOffset #-} + vkActualPresentTimeByteOffset ~_ + = #{offset VkPastPresentationTimingGOOGLE, actualPresentTime} + + {-# INLINE readVkActualPresentTime #-} + readVkActualPresentTime p + = peekByteOff p #{offset VkPastPresentationTimingGOOGLE, actualPresentTime} + + {-# INLINE writeVkActualPresentTime #-} + writeVkActualPresentTime p + = pokeByteOff p #{offset VkPastPresentationTimingGOOGLE, actualPresentTime} + +instance {-# OVERLAPPING #-} + HasField "actualPresentTime" VkPastPresentationTimingGOOGLE where + type FieldType "actualPresentTime" VkPastPresentationTimingGOOGLE = + Word64 + type FieldOptional "actualPresentTime" + VkPastPresentationTimingGOOGLE + = 'False -- ' closing tick for hsc2hs + type FieldOffset "actualPresentTime" VkPastPresentationTimingGOOGLE + = + #{offset VkPastPresentationTimingGOOGLE, actualPresentTime} + type FieldIsArray "actualPresentTime" + VkPastPresentationTimingGOOGLE + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPastPresentationTimingGOOGLE, actualPresentTime} + +instance CanReadField "actualPresentTime" + VkPastPresentationTimingGOOGLE + where + {-# INLINE getField #-} + getField = vkActualPresentTime + + {-# INLINE readField #-} + readField = readVkActualPresentTime + +instance CanWriteField "actualPresentTime" + VkPastPresentationTimingGOOGLE + where + {-# INLINE writeField #-} + writeField = writeVkActualPresentTime + +instance {-# OVERLAPPING #-} + HasVkEarliestPresentTime VkPastPresentationTimingGOOGLE where + type VkEarliestPresentTimeMType VkPastPresentationTimingGOOGLE = + Word64 + + {-# NOINLINE vkEarliestPresentTime #-} + vkEarliestPresentTime x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPastPresentationTimingGOOGLE, earliestPresentTime}) + + {-# INLINE vkEarliestPresentTimeByteOffset #-} + vkEarliestPresentTimeByteOffset ~_ + = #{offset VkPastPresentationTimingGOOGLE, earliestPresentTime} + + {-# INLINE readVkEarliestPresentTime #-} + readVkEarliestPresentTime p + = peekByteOff p #{offset VkPastPresentationTimingGOOGLE, earliestPresentTime} + + {-# INLINE writeVkEarliestPresentTime #-} + writeVkEarliestPresentTime p + = pokeByteOff p #{offset VkPastPresentationTimingGOOGLE, earliestPresentTime} + +instance {-# OVERLAPPING #-} + HasField "earliestPresentTime" VkPastPresentationTimingGOOGLE where + type FieldType "earliestPresentTime" VkPastPresentationTimingGOOGLE + = Word64 + type FieldOptional "earliestPresentTime" + VkPastPresentationTimingGOOGLE + = 'False -- ' closing tick for hsc2hs + type FieldOffset "earliestPresentTime" + VkPastPresentationTimingGOOGLE + = + #{offset VkPastPresentationTimingGOOGLE, earliestPresentTime} + type FieldIsArray "earliestPresentTime" + VkPastPresentationTimingGOOGLE + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPastPresentationTimingGOOGLE, earliestPresentTime} + +instance CanReadField "earliestPresentTime" + VkPastPresentationTimingGOOGLE + where + {-# INLINE getField #-} + getField = vkEarliestPresentTime + + {-# INLINE readField #-} + readField = readVkEarliestPresentTime + +instance CanWriteField "earliestPresentTime" + VkPastPresentationTimingGOOGLE + where + {-# INLINE writeField #-} + writeField = writeVkEarliestPresentTime + +instance {-# OVERLAPPING #-} + HasVkPresentMargin VkPastPresentationTimingGOOGLE where + type VkPresentMarginMType VkPastPresentationTimingGOOGLE = Word64 + + {-# NOINLINE vkPresentMargin #-} + vkPresentMargin x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPastPresentationTimingGOOGLE, presentMargin}) + + {-# INLINE vkPresentMarginByteOffset #-} + vkPresentMarginByteOffset ~_ + = #{offset VkPastPresentationTimingGOOGLE, presentMargin} + + {-# INLINE readVkPresentMargin #-} + readVkPresentMargin p + = peekByteOff p #{offset VkPastPresentationTimingGOOGLE, presentMargin} + + {-# INLINE writeVkPresentMargin #-} + writeVkPresentMargin p + = pokeByteOff p #{offset VkPastPresentationTimingGOOGLE, presentMargin} + +instance {-# OVERLAPPING #-} + HasField "presentMargin" VkPastPresentationTimingGOOGLE where + type FieldType "presentMargin" VkPastPresentationTimingGOOGLE = + Word64 + type FieldOptional "presentMargin" VkPastPresentationTimingGOOGLE = + 'False -- ' closing tick for hsc2hs + type FieldOffset "presentMargin" VkPastPresentationTimingGOOGLE = + #{offset VkPastPresentationTimingGOOGLE, presentMargin} + type FieldIsArray "presentMargin" VkPastPresentationTimingGOOGLE = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPastPresentationTimingGOOGLE, presentMargin} + +instance CanReadField "presentMargin" + VkPastPresentationTimingGOOGLE + where + {-# INLINE getField #-} + getField = vkPresentMargin + + {-# INLINE readField #-} + readField = readVkPresentMargin + +instance CanWriteField "presentMargin" + VkPastPresentationTimingGOOGLE + where + {-# INLINE writeField #-} + writeField = writeVkPresentMargin + +instance Show VkPastPresentationTimingGOOGLE where + showsPrec d x + = showString "VkPastPresentationTimingGOOGLE {" . + showString "vkPresentID = " . + showsPrec d (vkPresentID x) . + showString ", " . + showString "vkDesiredPresentTime = " . + showsPrec d (vkDesiredPresentTime x) . + showString ", " . + showString "vkActualPresentTime = " . + showsPrec d (vkActualPresentTime x) . + showString ", " . + showString "vkEarliestPresentTime = " . + showsPrec d (vkEarliestPresentTime x) . + showString ", " . + showString "vkPresentMargin = " . + showsPrec d (vkPresentMargin x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkPhysicalDevice16BitStorageFeaturesKHR.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkPhysicalDevice16BitStorageFeaturesKHR.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkPhysicalDevice16BitStorageFeaturesKHR.hsc @@ -0,0 +1,478 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkPhysicalDevice16BitStorageFeaturesKHR + (VkPhysicalDevice16BitStorageFeaturesKHR(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.BaseTypes (VkBool32) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Struct.VkDeviceCreateInfo (VkDeviceCreateInfo) +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceFeatures2KHR (VkPhysicalDeviceFeatures2KHR) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkPhysicalDevice16BitStorageFeaturesKHR { +-- > VkStructureType sType; +-- > void* pNext; +-- > VkBool32 storageBuffer16BitAccess; +-- > VkBool32 uniformAndStorageBuffer16BitAccess; +-- > VkBool32 storagePushConstant16; +-- > VkBool32 storageInputOutput16; +-- > } VkPhysicalDevice16BitStorageFeaturesKHR; +-- +-- +data VkPhysicalDevice16BitStorageFeaturesKHR = VkPhysicalDevice16BitStorageFeaturesKHR## Addr## + ByteArray## + +instance Eq VkPhysicalDevice16BitStorageFeaturesKHR where + (VkPhysicalDevice16BitStorageFeaturesKHR## a _) == + x@(VkPhysicalDevice16BitStorageFeaturesKHR## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkPhysicalDevice16BitStorageFeaturesKHR where + (VkPhysicalDevice16BitStorageFeaturesKHR## a _) `compare` + x@(VkPhysicalDevice16BitStorageFeaturesKHR## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkPhysicalDevice16BitStorageFeaturesKHR where + sizeOf ~_ + = #{size VkPhysicalDevice16BitStorageFeaturesKHR} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkPhysicalDevice16BitStorageFeaturesKHR} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkPhysicalDevice16BitStorageFeaturesKHR + where + unsafeAddr (VkPhysicalDevice16BitStorageFeaturesKHR## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkPhysicalDevice16BitStorageFeaturesKHR## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkPhysicalDevice16BitStorageFeaturesKHR## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkPhysicalDevice16BitStorageFeaturesKHR + where + type StructFields VkPhysicalDevice16BitStorageFeaturesKHR = + '["sType", "pNext", "storageBuffer16BitAccess", -- ' closing tick for hsc2hs + "uniformAndStorageBuffer16BitAccess", "storagePushConstant16", + "storageInputOutput16"] + type CUnionType VkPhysicalDevice16BitStorageFeaturesKHR = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkPhysicalDevice16BitStorageFeaturesKHR = 'False -- ' closing tick for hsc2hs + type StructExtends VkPhysicalDevice16BitStorageFeaturesKHR = + '[VkPhysicalDeviceFeatures2KHR, VkDeviceCreateInfo] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkPhysicalDevice16BitStorageFeaturesKHR where + type VkSTypeMType VkPhysicalDevice16BitStorageFeaturesKHR = + VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDevice16BitStorageFeaturesKHR, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkPhysicalDevice16BitStorageFeaturesKHR, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkPhysicalDevice16BitStorageFeaturesKHR, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkPhysicalDevice16BitStorageFeaturesKHR, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkPhysicalDevice16BitStorageFeaturesKHR where + type FieldType "sType" VkPhysicalDevice16BitStorageFeaturesKHR = + VkStructureType + type FieldOptional "sType" VkPhysicalDevice16BitStorageFeaturesKHR + = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkPhysicalDevice16BitStorageFeaturesKHR = + #{offset VkPhysicalDevice16BitStorageFeaturesKHR, sType} + type FieldIsArray "sType" VkPhysicalDevice16BitStorageFeaturesKHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDevice16BitStorageFeaturesKHR, sType} + +instance CanReadField "sType" + VkPhysicalDevice16BitStorageFeaturesKHR + where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" + VkPhysicalDevice16BitStorageFeaturesKHR + where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkPhysicalDevice16BitStorageFeaturesKHR where + type VkPNextMType VkPhysicalDevice16BitStorageFeaturesKHR = + Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDevice16BitStorageFeaturesKHR, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkPhysicalDevice16BitStorageFeaturesKHR, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkPhysicalDevice16BitStorageFeaturesKHR, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkPhysicalDevice16BitStorageFeaturesKHR, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkPhysicalDevice16BitStorageFeaturesKHR where + type FieldType "pNext" VkPhysicalDevice16BitStorageFeaturesKHR = + Ptr Void + type FieldOptional "pNext" VkPhysicalDevice16BitStorageFeaturesKHR + = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkPhysicalDevice16BitStorageFeaturesKHR = + #{offset VkPhysicalDevice16BitStorageFeaturesKHR, pNext} + type FieldIsArray "pNext" VkPhysicalDevice16BitStorageFeaturesKHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDevice16BitStorageFeaturesKHR, pNext} + +instance CanReadField "pNext" + VkPhysicalDevice16BitStorageFeaturesKHR + where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" + VkPhysicalDevice16BitStorageFeaturesKHR + where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkStorageBuffer16BitAccess + VkPhysicalDevice16BitStorageFeaturesKHR + where + type VkStorageBuffer16BitAccessMType + VkPhysicalDevice16BitStorageFeaturesKHR + = VkBool32 + + {-# NOINLINE vkStorageBuffer16BitAccess #-} + vkStorageBuffer16BitAccess x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDevice16BitStorageFeaturesKHR, storageBuffer16BitAccess}) + + {-# INLINE vkStorageBuffer16BitAccessByteOffset #-} + vkStorageBuffer16BitAccessByteOffset ~_ + = #{offset VkPhysicalDevice16BitStorageFeaturesKHR, storageBuffer16BitAccess} + + {-# INLINE readVkStorageBuffer16BitAccess #-} + readVkStorageBuffer16BitAccess p + = peekByteOff p #{offset VkPhysicalDevice16BitStorageFeaturesKHR, storageBuffer16BitAccess} + + {-# INLINE writeVkStorageBuffer16BitAccess #-} + writeVkStorageBuffer16BitAccess p + = pokeByteOff p #{offset VkPhysicalDevice16BitStorageFeaturesKHR, storageBuffer16BitAccess} + +instance {-# OVERLAPPING #-} + HasField "storageBuffer16BitAccess" + VkPhysicalDevice16BitStorageFeaturesKHR + where + type FieldType "storageBuffer16BitAccess" + VkPhysicalDevice16BitStorageFeaturesKHR + = VkBool32 + type FieldOptional "storageBuffer16BitAccess" + VkPhysicalDevice16BitStorageFeaturesKHR + = 'False -- ' closing tick for hsc2hs + type FieldOffset "storageBuffer16BitAccess" + VkPhysicalDevice16BitStorageFeaturesKHR + = + #{offset VkPhysicalDevice16BitStorageFeaturesKHR, storageBuffer16BitAccess} + type FieldIsArray "storageBuffer16BitAccess" + VkPhysicalDevice16BitStorageFeaturesKHR + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDevice16BitStorageFeaturesKHR, storageBuffer16BitAccess} + +instance CanReadField "storageBuffer16BitAccess" + VkPhysicalDevice16BitStorageFeaturesKHR + where + {-# INLINE getField #-} + getField = vkStorageBuffer16BitAccess + + {-# INLINE readField #-} + readField = readVkStorageBuffer16BitAccess + +instance CanWriteField "storageBuffer16BitAccess" + VkPhysicalDevice16BitStorageFeaturesKHR + where + {-# INLINE writeField #-} + writeField = writeVkStorageBuffer16BitAccess + +instance {-# OVERLAPPING #-} + HasVkUniformAndStorageBuffer16BitAccess + VkPhysicalDevice16BitStorageFeaturesKHR + where + type VkUniformAndStorageBuffer16BitAccessMType + VkPhysicalDevice16BitStorageFeaturesKHR + = VkBool32 + + {-# NOINLINE vkUniformAndStorageBuffer16BitAccess #-} + vkUniformAndStorageBuffer16BitAccess x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDevice16BitStorageFeaturesKHR, uniformAndStorageBuffer16BitAccess}) + + {-# INLINE vkUniformAndStorageBuffer16BitAccessByteOffset #-} + vkUniformAndStorageBuffer16BitAccessByteOffset ~_ + = #{offset VkPhysicalDevice16BitStorageFeaturesKHR, uniformAndStorageBuffer16BitAccess} + + {-# INLINE readVkUniformAndStorageBuffer16BitAccess #-} + readVkUniformAndStorageBuffer16BitAccess p + = peekByteOff p #{offset VkPhysicalDevice16BitStorageFeaturesKHR, uniformAndStorageBuffer16BitAccess} + + {-# INLINE writeVkUniformAndStorageBuffer16BitAccess #-} + writeVkUniformAndStorageBuffer16BitAccess p + = pokeByteOff p #{offset VkPhysicalDevice16BitStorageFeaturesKHR, uniformAndStorageBuffer16BitAccess} + +instance {-# OVERLAPPING #-} + HasField "uniformAndStorageBuffer16BitAccess" + VkPhysicalDevice16BitStorageFeaturesKHR + where + type FieldType "uniformAndStorageBuffer16BitAccess" + VkPhysicalDevice16BitStorageFeaturesKHR + = VkBool32 + type FieldOptional "uniformAndStorageBuffer16BitAccess" + VkPhysicalDevice16BitStorageFeaturesKHR + = 'False -- ' closing tick for hsc2hs + type FieldOffset "uniformAndStorageBuffer16BitAccess" + VkPhysicalDevice16BitStorageFeaturesKHR + = + #{offset VkPhysicalDevice16BitStorageFeaturesKHR, uniformAndStorageBuffer16BitAccess} + type FieldIsArray "uniformAndStorageBuffer16BitAccess" + VkPhysicalDevice16BitStorageFeaturesKHR + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDevice16BitStorageFeaturesKHR, uniformAndStorageBuffer16BitAccess} + +instance CanReadField "uniformAndStorageBuffer16BitAccess" + VkPhysicalDevice16BitStorageFeaturesKHR + where + {-# INLINE getField #-} + getField = vkUniformAndStorageBuffer16BitAccess + + {-# INLINE readField #-} + readField = readVkUniformAndStorageBuffer16BitAccess + +instance CanWriteField "uniformAndStorageBuffer16BitAccess" + VkPhysicalDevice16BitStorageFeaturesKHR + where + {-# INLINE writeField #-} + writeField = writeVkUniformAndStorageBuffer16BitAccess + +instance {-# OVERLAPPING #-} + HasVkStoragePushConstant16 VkPhysicalDevice16BitStorageFeaturesKHR + where + type VkStoragePushConstant16MType + VkPhysicalDevice16BitStorageFeaturesKHR + = VkBool32 + + {-# NOINLINE vkStoragePushConstant16 #-} + vkStoragePushConstant16 x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDevice16BitStorageFeaturesKHR, storagePushConstant16}) + + {-# INLINE vkStoragePushConstant16ByteOffset #-} + vkStoragePushConstant16ByteOffset ~_ + = #{offset VkPhysicalDevice16BitStorageFeaturesKHR, storagePushConstant16} + + {-# INLINE readVkStoragePushConstant16 #-} + readVkStoragePushConstant16 p + = peekByteOff p #{offset VkPhysicalDevice16BitStorageFeaturesKHR, storagePushConstant16} + + {-# INLINE writeVkStoragePushConstant16 #-} + writeVkStoragePushConstant16 p + = pokeByteOff p #{offset VkPhysicalDevice16BitStorageFeaturesKHR, storagePushConstant16} + +instance {-# OVERLAPPING #-} + HasField "storagePushConstant16" + VkPhysicalDevice16BitStorageFeaturesKHR + where + type FieldType "storagePushConstant16" + VkPhysicalDevice16BitStorageFeaturesKHR + = VkBool32 + type FieldOptional "storagePushConstant16" + VkPhysicalDevice16BitStorageFeaturesKHR + = 'False -- ' closing tick for hsc2hs + type FieldOffset "storagePushConstant16" + VkPhysicalDevice16BitStorageFeaturesKHR + = + #{offset VkPhysicalDevice16BitStorageFeaturesKHR, storagePushConstant16} + type FieldIsArray "storagePushConstant16" + VkPhysicalDevice16BitStorageFeaturesKHR + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDevice16BitStorageFeaturesKHR, storagePushConstant16} + +instance CanReadField "storagePushConstant16" + VkPhysicalDevice16BitStorageFeaturesKHR + where + {-# INLINE getField #-} + getField = vkStoragePushConstant16 + + {-# INLINE readField #-} + readField = readVkStoragePushConstant16 + +instance CanWriteField "storagePushConstant16" + VkPhysicalDevice16BitStorageFeaturesKHR + where + {-# INLINE writeField #-} + writeField = writeVkStoragePushConstant16 + +instance {-# OVERLAPPING #-} + HasVkStorageInputOutput16 VkPhysicalDevice16BitStorageFeaturesKHR + where + type VkStorageInputOutput16MType + VkPhysicalDevice16BitStorageFeaturesKHR + = VkBool32 + + {-# NOINLINE vkStorageInputOutput16 #-} + vkStorageInputOutput16 x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDevice16BitStorageFeaturesKHR, storageInputOutput16}) + + {-# INLINE vkStorageInputOutput16ByteOffset #-} + vkStorageInputOutput16ByteOffset ~_ + = #{offset VkPhysicalDevice16BitStorageFeaturesKHR, storageInputOutput16} + + {-# INLINE readVkStorageInputOutput16 #-} + readVkStorageInputOutput16 p + = peekByteOff p #{offset VkPhysicalDevice16BitStorageFeaturesKHR, storageInputOutput16} + + {-# INLINE writeVkStorageInputOutput16 #-} + writeVkStorageInputOutput16 p + = pokeByteOff p #{offset VkPhysicalDevice16BitStorageFeaturesKHR, storageInputOutput16} + +instance {-# OVERLAPPING #-} + HasField "storageInputOutput16" + VkPhysicalDevice16BitStorageFeaturesKHR + where + type FieldType "storageInputOutput16" + VkPhysicalDevice16BitStorageFeaturesKHR + = VkBool32 + type FieldOptional "storageInputOutput16" + VkPhysicalDevice16BitStorageFeaturesKHR + = 'False -- ' closing tick for hsc2hs + type FieldOffset "storageInputOutput16" + VkPhysicalDevice16BitStorageFeaturesKHR + = + #{offset VkPhysicalDevice16BitStorageFeaturesKHR, storageInputOutput16} + type FieldIsArray "storageInputOutput16" + VkPhysicalDevice16BitStorageFeaturesKHR + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDevice16BitStorageFeaturesKHR, storageInputOutput16} + +instance CanReadField "storageInputOutput16" + VkPhysicalDevice16BitStorageFeaturesKHR + where + {-# INLINE getField #-} + getField = vkStorageInputOutput16 + + {-# INLINE readField #-} + readField = readVkStorageInputOutput16 + +instance CanWriteField "storageInputOutput16" + VkPhysicalDevice16BitStorageFeaturesKHR + where + {-# INLINE writeField #-} + writeField = writeVkStorageInputOutput16 + +instance Show VkPhysicalDevice16BitStorageFeaturesKHR where + showsPrec d x + = showString "VkPhysicalDevice16BitStorageFeaturesKHR {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkStorageBuffer16BitAccess = " . + showsPrec d (vkStorageBuffer16BitAccess x) . + showString ", " . + showString "vkUniformAndStorageBuffer16BitAccess = " . + showsPrec d (vkUniformAndStorageBuffer16BitAccess x) . + showString ", " . + showString "vkStoragePushConstant16 = " . + showsPrec d (vkStoragePushConstant16 x) . + showString ", " . + showString "vkStorageInputOutput16 = " . + showsPrec d (vkStorageInputOutput16 x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT.hsc @@ -0,0 +1,293 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT + (VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.BaseTypes (VkBool32) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceFeatures2KHR (VkPhysicalDeviceFeatures2KHR) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT { +-- > VkStructureType sType; +-- > void* pNext; +-- > VkBool32 advancedBlendCoherentOperations; +-- > } VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT; +-- +-- +data VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT = VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT## Addr## + ByteArray## + +instance Eq VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT where + (VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT## a _) == + x@(VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT + where + (VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT## a _) `compare` + x@(VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT + where + sizeOf ~_ + = #{size VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim + VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT + where + unsafeAddr (VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT## a _) + = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray + (VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal + VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT + where + type StructFields VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT + = '["sType", "pNext", "advancedBlendCoherentOperations"] -- ' closing tick for hsc2hs + type CUnionType VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT = + 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT + = 'False -- ' closing tick for hsc2hs + type StructExtends + VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT + = '[VkPhysicalDeviceFeatures2KHR] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT where + type VkSTypeMType VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT + = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT + where + type FieldType "sType" + VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT + = VkStructureType + type FieldOptional "sType" + VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT + = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" + VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT + = + #{offset VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT, sType} + type FieldIsArray "sType" + VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT, sType} + +instance CanReadField "sType" + VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT + where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" + VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT + where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT where + type VkPNextMType VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT + = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT + where + type FieldType "pNext" + VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT + = Ptr Void + type FieldOptional "pNext" + VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT + = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" + VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT + = + #{offset VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT, pNext} + type FieldIsArray "pNext" + VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT, pNext} + +instance CanReadField "pNext" + VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT + where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" + VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT + where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkAdvancedBlendCoherentOperations + VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT + where + type VkAdvancedBlendCoherentOperationsMType + VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT + = VkBool32 + + {-# NOINLINE vkAdvancedBlendCoherentOperations #-} + vkAdvancedBlendCoherentOperations x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT, advancedBlendCoherentOperations}) + + {-# INLINE vkAdvancedBlendCoherentOperationsByteOffset #-} + vkAdvancedBlendCoherentOperationsByteOffset ~_ + = #{offset VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT, advancedBlendCoherentOperations} + + {-# INLINE readVkAdvancedBlendCoherentOperations #-} + readVkAdvancedBlendCoherentOperations p + = peekByteOff p #{offset VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT, advancedBlendCoherentOperations} + + {-# INLINE writeVkAdvancedBlendCoherentOperations #-} + writeVkAdvancedBlendCoherentOperations p + = pokeByteOff p #{offset VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT, advancedBlendCoherentOperations} + +instance {-# OVERLAPPING #-} + HasField "advancedBlendCoherentOperations" + VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT + where + type FieldType "advancedBlendCoherentOperations" + VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT + = VkBool32 + type FieldOptional "advancedBlendCoherentOperations" + VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT + = 'False -- ' closing tick for hsc2hs + type FieldOffset "advancedBlendCoherentOperations" + VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT + = + #{offset VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT, advancedBlendCoherentOperations} + type FieldIsArray "advancedBlendCoherentOperations" + VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT, advancedBlendCoherentOperations} + +instance CanReadField "advancedBlendCoherentOperations" + VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT + where + {-# INLINE getField #-} + getField = vkAdvancedBlendCoherentOperations + + {-# INLINE readField #-} + readField = readVkAdvancedBlendCoherentOperations + +instance CanWriteField "advancedBlendCoherentOperations" + VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT + where + {-# INLINE writeField #-} + writeField = writeVkAdvancedBlendCoherentOperations + +instance Show VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT + where + showsPrec d x + = showString "VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT {" + . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkAdvancedBlendCoherentOperations = " . + showsPrec d (vkAdvancedBlendCoherentOperations x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT.hsc @@ -0,0 +1,614 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT + (VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.BaseTypes (VkBool32) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceProperties2KHR (VkPhysicalDeviceProperties2KHR) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT { +-- > VkStructureType sType; +-- > void* pNext; +-- > uint32_t advancedBlendMaxColorAttachments; +-- > VkBool32 advancedBlendIndependentBlend; +-- > VkBool32 advancedBlendNonPremultipliedSrcColor; +-- > VkBool32 advancedBlendNonPremultipliedDstColor; +-- > VkBool32 advancedBlendCorrelatedOverlap; +-- > VkBool32 advancedBlendAllOperations; +-- > } VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT; +-- +-- +data VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT = VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT## Addr## + ByteArray## + +instance Eq VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT + where + (VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT## a _) == + x@(VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT + where + (VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT## a _) + `compare` + x@(VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable + VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT + where + sizeOf ~_ + = #{size VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim + VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT + where + unsafeAddr + (VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray + (VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal + VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT + where + type StructFields + VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT + = + '["sType", "pNext", "advancedBlendMaxColorAttachments", -- ' closing tick for hsc2hs + "advancedBlendIndependentBlend", + "advancedBlendNonPremultipliedSrcColor", + "advancedBlendNonPremultipliedDstColor", + "advancedBlendCorrelatedOverlap", "advancedBlendAllOperations"] + type CUnionType VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT + = 'False -- ' closing tick for hsc2hs + type ReturnedOnly + VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT + = 'True -- ' closing tick for hsc2hs + type StructExtends + VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT + = '[VkPhysicalDeviceProperties2KHR] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT + where + type VkSTypeMType + VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT + = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" + VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT + where + type FieldType "sType" + VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT + = VkStructureType + type FieldOptional "sType" + VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT + = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" + VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT + = + #{offset VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT, sType} + type FieldIsArray "sType" + VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT, sType} + +instance CanReadField "sType" + VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT + where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT + where + type VkPNextMType + VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT + = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" + VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT + where + type FieldType "pNext" + VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT + = Ptr Void + type FieldOptional "pNext" + VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT + = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" + VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT + = + #{offset VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT, pNext} + type FieldIsArray "pNext" + VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT, pNext} + +instance CanReadField "pNext" + VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT + where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance {-# OVERLAPPING #-} + HasVkAdvancedBlendMaxColorAttachments + VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT + where + type VkAdvancedBlendMaxColorAttachmentsMType + VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT + = Word32 + + {-# NOINLINE vkAdvancedBlendMaxColorAttachments #-} + vkAdvancedBlendMaxColorAttachments x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT, advancedBlendMaxColorAttachments}) + + {-# INLINE vkAdvancedBlendMaxColorAttachmentsByteOffset #-} + vkAdvancedBlendMaxColorAttachmentsByteOffset ~_ + = #{offset VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT, advancedBlendMaxColorAttachments} + + {-# INLINE readVkAdvancedBlendMaxColorAttachments #-} + readVkAdvancedBlendMaxColorAttachments p + = peekByteOff p #{offset VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT, advancedBlendMaxColorAttachments} + + {-# INLINE writeVkAdvancedBlendMaxColorAttachments #-} + writeVkAdvancedBlendMaxColorAttachments p + = pokeByteOff p #{offset VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT, advancedBlendMaxColorAttachments} + +instance {-# OVERLAPPING #-} + HasField "advancedBlendMaxColorAttachments" + VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT + where + type FieldType "advancedBlendMaxColorAttachments" + VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT + = Word32 + type FieldOptional "advancedBlendMaxColorAttachments" + VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT + = 'False -- ' closing tick for hsc2hs + type FieldOffset "advancedBlendMaxColorAttachments" + VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT + = + #{offset VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT, advancedBlendMaxColorAttachments} + type FieldIsArray "advancedBlendMaxColorAttachments" + VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT, advancedBlendMaxColorAttachments} + +instance CanReadField "advancedBlendMaxColorAttachments" + VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT + where + {-# INLINE getField #-} + getField = vkAdvancedBlendMaxColorAttachments + + {-# INLINE readField #-} + readField = readVkAdvancedBlendMaxColorAttachments + +instance {-# OVERLAPPING #-} + HasVkAdvancedBlendIndependentBlend + VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT + where + type VkAdvancedBlendIndependentBlendMType + VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT + = VkBool32 + + {-# NOINLINE vkAdvancedBlendIndependentBlend #-} + vkAdvancedBlendIndependentBlend x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT, advancedBlendIndependentBlend}) + + {-# INLINE vkAdvancedBlendIndependentBlendByteOffset #-} + vkAdvancedBlendIndependentBlendByteOffset ~_ + = #{offset VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT, advancedBlendIndependentBlend} + + {-# INLINE readVkAdvancedBlendIndependentBlend #-} + readVkAdvancedBlendIndependentBlend p + = peekByteOff p #{offset VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT, advancedBlendIndependentBlend} + + {-# INLINE writeVkAdvancedBlendIndependentBlend #-} + writeVkAdvancedBlendIndependentBlend p + = pokeByteOff p #{offset VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT, advancedBlendIndependentBlend} + +instance {-# OVERLAPPING #-} + HasField "advancedBlendIndependentBlend" + VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT + where + type FieldType "advancedBlendIndependentBlend" + VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT + = VkBool32 + type FieldOptional "advancedBlendIndependentBlend" + VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT + = 'False -- ' closing tick for hsc2hs + type FieldOffset "advancedBlendIndependentBlend" + VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT + = + #{offset VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT, advancedBlendIndependentBlend} + type FieldIsArray "advancedBlendIndependentBlend" + VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT, advancedBlendIndependentBlend} + +instance CanReadField "advancedBlendIndependentBlend" + VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT + where + {-# INLINE getField #-} + getField = vkAdvancedBlendIndependentBlend + + {-# INLINE readField #-} + readField = readVkAdvancedBlendIndependentBlend + +instance {-# OVERLAPPING #-} + HasVkAdvancedBlendNonPremultipliedSrcColor + VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT + where + type VkAdvancedBlendNonPremultipliedSrcColorMType + VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT + = VkBool32 + + {-# NOINLINE vkAdvancedBlendNonPremultipliedSrcColor #-} + vkAdvancedBlendNonPremultipliedSrcColor x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT, advancedBlendNonPremultipliedSrcColor}) + + {-# INLINE vkAdvancedBlendNonPremultipliedSrcColorByteOffset #-} + vkAdvancedBlendNonPremultipliedSrcColorByteOffset ~_ + = #{offset VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT, advancedBlendNonPremultipliedSrcColor} + + {-# INLINE readVkAdvancedBlendNonPremultipliedSrcColor #-} + readVkAdvancedBlendNonPremultipliedSrcColor p + = peekByteOff p #{offset VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT, advancedBlendNonPremultipliedSrcColor} + + {-# INLINE writeVkAdvancedBlendNonPremultipliedSrcColor #-} + writeVkAdvancedBlendNonPremultipliedSrcColor p + = pokeByteOff p #{offset VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT, advancedBlendNonPremultipliedSrcColor} + +instance {-# OVERLAPPING #-} + HasField "advancedBlendNonPremultipliedSrcColor" + VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT + where + type FieldType "advancedBlendNonPremultipliedSrcColor" + VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT + = VkBool32 + type FieldOptional "advancedBlendNonPremultipliedSrcColor" + VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT + = 'False -- ' closing tick for hsc2hs + type FieldOffset "advancedBlendNonPremultipliedSrcColor" + VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT + = + #{offset VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT, advancedBlendNonPremultipliedSrcColor} + type FieldIsArray "advancedBlendNonPremultipliedSrcColor" + VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT, advancedBlendNonPremultipliedSrcColor} + +instance CanReadField "advancedBlendNonPremultipliedSrcColor" + VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT + where + {-# INLINE getField #-} + getField = vkAdvancedBlendNonPremultipliedSrcColor + + {-# INLINE readField #-} + readField = readVkAdvancedBlendNonPremultipliedSrcColor + +instance {-# OVERLAPPING #-} + HasVkAdvancedBlendNonPremultipliedDstColor + VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT + where + type VkAdvancedBlendNonPremultipliedDstColorMType + VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT + = VkBool32 + + {-# NOINLINE vkAdvancedBlendNonPremultipliedDstColor #-} + vkAdvancedBlendNonPremultipliedDstColor x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT, advancedBlendNonPremultipliedDstColor}) + + {-# INLINE vkAdvancedBlendNonPremultipliedDstColorByteOffset #-} + vkAdvancedBlendNonPremultipliedDstColorByteOffset ~_ + = #{offset VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT, advancedBlendNonPremultipliedDstColor} + + {-# INLINE readVkAdvancedBlendNonPremultipliedDstColor #-} + readVkAdvancedBlendNonPremultipliedDstColor p + = peekByteOff p #{offset VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT, advancedBlendNonPremultipliedDstColor} + + {-# INLINE writeVkAdvancedBlendNonPremultipliedDstColor #-} + writeVkAdvancedBlendNonPremultipliedDstColor p + = pokeByteOff p #{offset VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT, advancedBlendNonPremultipliedDstColor} + +instance {-# OVERLAPPING #-} + HasField "advancedBlendNonPremultipliedDstColor" + VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT + where + type FieldType "advancedBlendNonPremultipliedDstColor" + VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT + = VkBool32 + type FieldOptional "advancedBlendNonPremultipliedDstColor" + VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT + = 'False -- ' closing tick for hsc2hs + type FieldOffset "advancedBlendNonPremultipliedDstColor" + VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT + = + #{offset VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT, advancedBlendNonPremultipliedDstColor} + type FieldIsArray "advancedBlendNonPremultipliedDstColor" + VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT, advancedBlendNonPremultipliedDstColor} + +instance CanReadField "advancedBlendNonPremultipliedDstColor" + VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT + where + {-# INLINE getField #-} + getField = vkAdvancedBlendNonPremultipliedDstColor + + {-# INLINE readField #-} + readField = readVkAdvancedBlendNonPremultipliedDstColor + +instance {-# OVERLAPPING #-} + HasVkAdvancedBlendCorrelatedOverlap + VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT + where + type VkAdvancedBlendCorrelatedOverlapMType + VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT + = VkBool32 + + {-# NOINLINE vkAdvancedBlendCorrelatedOverlap #-} + vkAdvancedBlendCorrelatedOverlap x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT, advancedBlendCorrelatedOverlap}) + + {-# INLINE vkAdvancedBlendCorrelatedOverlapByteOffset #-} + vkAdvancedBlendCorrelatedOverlapByteOffset ~_ + = #{offset VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT, advancedBlendCorrelatedOverlap} + + {-# INLINE readVkAdvancedBlendCorrelatedOverlap #-} + readVkAdvancedBlendCorrelatedOverlap p + = peekByteOff p #{offset VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT, advancedBlendCorrelatedOverlap} + + {-# INLINE writeVkAdvancedBlendCorrelatedOverlap #-} + writeVkAdvancedBlendCorrelatedOverlap p + = pokeByteOff p #{offset VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT, advancedBlendCorrelatedOverlap} + +instance {-# OVERLAPPING #-} + HasField "advancedBlendCorrelatedOverlap" + VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT + where + type FieldType "advancedBlendCorrelatedOverlap" + VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT + = VkBool32 + type FieldOptional "advancedBlendCorrelatedOverlap" + VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT + = 'False -- ' closing tick for hsc2hs + type FieldOffset "advancedBlendCorrelatedOverlap" + VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT + = + #{offset VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT, advancedBlendCorrelatedOverlap} + type FieldIsArray "advancedBlendCorrelatedOverlap" + VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT, advancedBlendCorrelatedOverlap} + +instance CanReadField "advancedBlendCorrelatedOverlap" + VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT + where + {-# INLINE getField #-} + getField = vkAdvancedBlendCorrelatedOverlap + + {-# INLINE readField #-} + readField = readVkAdvancedBlendCorrelatedOverlap + +instance {-# OVERLAPPING #-} + HasVkAdvancedBlendAllOperations + VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT + where + type VkAdvancedBlendAllOperationsMType + VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT + = VkBool32 + + {-# NOINLINE vkAdvancedBlendAllOperations #-} + vkAdvancedBlendAllOperations x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT, advancedBlendAllOperations}) + + {-# INLINE vkAdvancedBlendAllOperationsByteOffset #-} + vkAdvancedBlendAllOperationsByteOffset ~_ + = #{offset VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT, advancedBlendAllOperations} + + {-# INLINE readVkAdvancedBlendAllOperations #-} + readVkAdvancedBlendAllOperations p + = peekByteOff p #{offset VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT, advancedBlendAllOperations} + + {-# INLINE writeVkAdvancedBlendAllOperations #-} + writeVkAdvancedBlendAllOperations p + = pokeByteOff p #{offset VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT, advancedBlendAllOperations} + +instance {-# OVERLAPPING #-} + HasField "advancedBlendAllOperations" + VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT + where + type FieldType "advancedBlendAllOperations" + VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT + = VkBool32 + type FieldOptional "advancedBlendAllOperations" + VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT + = 'False -- ' closing tick for hsc2hs + type FieldOffset "advancedBlendAllOperations" + VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT + = + #{offset VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT, advancedBlendAllOperations} + type FieldIsArray "advancedBlendAllOperations" + VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT, advancedBlendAllOperations} + +instance CanReadField "advancedBlendAllOperations" + VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT + where + {-# INLINE getField #-} + getField = vkAdvancedBlendAllOperations + + {-# INLINE readField #-} + readField = readVkAdvancedBlendAllOperations + +instance Show VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT + where + showsPrec d x + = showString + "VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT {" + . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkAdvancedBlendMaxColorAttachments = " . + showsPrec d (vkAdvancedBlendMaxColorAttachments x) . + showString ", " . + showString "vkAdvancedBlendIndependentBlend = " . + showsPrec d (vkAdvancedBlendIndependentBlend x) . + showString ", " . + showString "vkAdvancedBlendNonPremultipliedSrcColor = " . + showsPrec d (vkAdvancedBlendNonPremultipliedSrcColor x) . + showString ", " . + showString "vkAdvancedBlendNonPremultipliedDstColor = " + . + showsPrec d + (vkAdvancedBlendNonPremultipliedDstColor x) + . + showString ", " . + showString "vkAdvancedBlendCorrelatedOverlap = " . + showsPrec d (vkAdvancedBlendCorrelatedOverlap x) + . + showString ", " . + showString "vkAdvancedBlendAllOperations = " + . + showsPrec d + (vkAdvancedBlendAllOperations x) + . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkPhysicalDeviceConservativeRasterizationPropertiesEXT.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkPhysicalDeviceConservativeRasterizationPropertiesEXT.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkPhysicalDeviceConservativeRasterizationPropertiesEXT.hsc @@ -0,0 +1,895 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceConservativeRasterizationPropertiesEXT + (VkPhysicalDeviceConservativeRasterizationPropertiesEXT(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.BaseTypes (VkBool32) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceProperties2KHR (VkPhysicalDeviceProperties2KHR) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkPhysicalDeviceConservativeRasterizationPropertiesEXT { +-- > VkStructureType sType; +-- > void* pNext; +-- > float primitiveOverestimationSize; +-- > float maxExtraPrimitiveOverestimationSize; +-- > float extraPrimitiveOverestimationSizeGranularity; +-- > VkBool32 primitiveUnderestimation; +-- > VkBool32 conservativePointAndLineRasterization; +-- > VkBool32 degenerateTrianglesRasterized; +-- > VkBool32 degenerateLinesRasterized; +-- > VkBool32 fullyCoveredFragmentShaderInputVariable; +-- > VkBool32 conservativeRasterizationPostDepthCoverage; +-- > } VkPhysicalDeviceConservativeRasterizationPropertiesEXT; +-- +-- +data VkPhysicalDeviceConservativeRasterizationPropertiesEXT = VkPhysicalDeviceConservativeRasterizationPropertiesEXT## Addr## + ByteArray## + +instance Eq VkPhysicalDeviceConservativeRasterizationPropertiesEXT + where + (VkPhysicalDeviceConservativeRasterizationPropertiesEXT## a _) == + x@(VkPhysicalDeviceConservativeRasterizationPropertiesEXT## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkPhysicalDeviceConservativeRasterizationPropertiesEXT + where + (VkPhysicalDeviceConservativeRasterizationPropertiesEXT## a _) + `compare` + x@(VkPhysicalDeviceConservativeRasterizationPropertiesEXT## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable + VkPhysicalDeviceConservativeRasterizationPropertiesEXT + where + sizeOf ~_ + = #{size VkPhysicalDeviceConservativeRasterizationPropertiesEXT} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkPhysicalDeviceConservativeRasterizationPropertiesEXT} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim + VkPhysicalDeviceConservativeRasterizationPropertiesEXT + where + unsafeAddr + (VkPhysicalDeviceConservativeRasterizationPropertiesEXT## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray + (VkPhysicalDeviceConservativeRasterizationPropertiesEXT## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkPhysicalDeviceConservativeRasterizationPropertiesEXT## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal + VkPhysicalDeviceConservativeRasterizationPropertiesEXT + where + type StructFields + VkPhysicalDeviceConservativeRasterizationPropertiesEXT + = + '["sType", "pNext", "primitiveOverestimationSize", -- ' closing tick for hsc2hs + "maxExtraPrimitiveOverestimationSize", + "extraPrimitiveOverestimationSizeGranularity", + "primitiveUnderestimation", + "conservativePointAndLineRasterization", + "degenerateTrianglesRasterized", "degenerateLinesRasterized", + "fullyCoveredFragmentShaderInputVariable", + "conservativeRasterizationPostDepthCoverage"] + type CUnionType + VkPhysicalDeviceConservativeRasterizationPropertiesEXT + = 'False -- ' closing tick for hsc2hs + type ReturnedOnly + VkPhysicalDeviceConservativeRasterizationPropertiesEXT + = 'False -- ' closing tick for hsc2hs + type StructExtends + VkPhysicalDeviceConservativeRasterizationPropertiesEXT + = '[VkPhysicalDeviceProperties2KHR] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkPhysicalDeviceConservativeRasterizationPropertiesEXT + where + type VkSTypeMType + VkPhysicalDeviceConservativeRasterizationPropertiesEXT + = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceConservativeRasterizationPropertiesEXT, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkPhysicalDeviceConservativeRasterizationPropertiesEXT, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkPhysicalDeviceConservativeRasterizationPropertiesEXT, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkPhysicalDeviceConservativeRasterizationPropertiesEXT, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" + VkPhysicalDeviceConservativeRasterizationPropertiesEXT + where + type FieldType "sType" + VkPhysicalDeviceConservativeRasterizationPropertiesEXT + = VkStructureType + type FieldOptional "sType" + VkPhysicalDeviceConservativeRasterizationPropertiesEXT + = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" + VkPhysicalDeviceConservativeRasterizationPropertiesEXT + = + #{offset VkPhysicalDeviceConservativeRasterizationPropertiesEXT, sType} + type FieldIsArray "sType" + VkPhysicalDeviceConservativeRasterizationPropertiesEXT + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceConservativeRasterizationPropertiesEXT, sType} + +instance CanReadField "sType" + VkPhysicalDeviceConservativeRasterizationPropertiesEXT + where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" + VkPhysicalDeviceConservativeRasterizationPropertiesEXT + where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkPhysicalDeviceConservativeRasterizationPropertiesEXT + where + type VkPNextMType + VkPhysicalDeviceConservativeRasterizationPropertiesEXT + = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceConservativeRasterizationPropertiesEXT, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkPhysicalDeviceConservativeRasterizationPropertiesEXT, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkPhysicalDeviceConservativeRasterizationPropertiesEXT, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkPhysicalDeviceConservativeRasterizationPropertiesEXT, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" + VkPhysicalDeviceConservativeRasterizationPropertiesEXT + where + type FieldType "pNext" + VkPhysicalDeviceConservativeRasterizationPropertiesEXT + = Ptr Void + type FieldOptional "pNext" + VkPhysicalDeviceConservativeRasterizationPropertiesEXT + = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" + VkPhysicalDeviceConservativeRasterizationPropertiesEXT + = + #{offset VkPhysicalDeviceConservativeRasterizationPropertiesEXT, pNext} + type FieldIsArray "pNext" + VkPhysicalDeviceConservativeRasterizationPropertiesEXT + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceConservativeRasterizationPropertiesEXT, pNext} + +instance CanReadField "pNext" + VkPhysicalDeviceConservativeRasterizationPropertiesEXT + where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" + VkPhysicalDeviceConservativeRasterizationPropertiesEXT + where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkPrimitiveOverestimationSize + VkPhysicalDeviceConservativeRasterizationPropertiesEXT + where + type VkPrimitiveOverestimationSizeMType + VkPhysicalDeviceConservativeRasterizationPropertiesEXT + = #{type float} + + {-# NOINLINE vkPrimitiveOverestimationSize #-} + vkPrimitiveOverestimationSize x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceConservativeRasterizationPropertiesEXT, primitiveOverestimationSize}) + + {-# INLINE vkPrimitiveOverestimationSizeByteOffset #-} + vkPrimitiveOverestimationSizeByteOffset ~_ + = #{offset VkPhysicalDeviceConservativeRasterizationPropertiesEXT, primitiveOverestimationSize} + + {-# INLINE readVkPrimitiveOverestimationSize #-} + readVkPrimitiveOverestimationSize p + = peekByteOff p #{offset VkPhysicalDeviceConservativeRasterizationPropertiesEXT, primitiveOverestimationSize} + + {-# INLINE writeVkPrimitiveOverestimationSize #-} + writeVkPrimitiveOverestimationSize p + = pokeByteOff p #{offset VkPhysicalDeviceConservativeRasterizationPropertiesEXT, primitiveOverestimationSize} + +instance {-# OVERLAPPING #-} + HasField "primitiveOverestimationSize" + VkPhysicalDeviceConservativeRasterizationPropertiesEXT + where + type FieldType "primitiveOverestimationSize" + VkPhysicalDeviceConservativeRasterizationPropertiesEXT + = #{type float} + type FieldOptional "primitiveOverestimationSize" + VkPhysicalDeviceConservativeRasterizationPropertiesEXT + = 'False -- ' closing tick for hsc2hs + type FieldOffset "primitiveOverestimationSize" + VkPhysicalDeviceConservativeRasterizationPropertiesEXT + = + #{offset VkPhysicalDeviceConservativeRasterizationPropertiesEXT, primitiveOverestimationSize} + type FieldIsArray "primitiveOverestimationSize" + VkPhysicalDeviceConservativeRasterizationPropertiesEXT + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceConservativeRasterizationPropertiesEXT, primitiveOverestimationSize} + +instance CanReadField "primitiveOverestimationSize" + VkPhysicalDeviceConservativeRasterizationPropertiesEXT + where + {-# INLINE getField #-} + getField = vkPrimitiveOverestimationSize + + {-# INLINE readField #-} + readField = readVkPrimitiveOverestimationSize + +instance CanWriteField "primitiveOverestimationSize" + VkPhysicalDeviceConservativeRasterizationPropertiesEXT + where + {-# INLINE writeField #-} + writeField = writeVkPrimitiveOverestimationSize + +instance {-# OVERLAPPING #-} + HasVkMaxExtraPrimitiveOverestimationSize + VkPhysicalDeviceConservativeRasterizationPropertiesEXT + where + type VkMaxExtraPrimitiveOverestimationSizeMType + VkPhysicalDeviceConservativeRasterizationPropertiesEXT + = #{type float} + + {-# NOINLINE vkMaxExtraPrimitiveOverestimationSize #-} + vkMaxExtraPrimitiveOverestimationSize x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceConservativeRasterizationPropertiesEXT, maxExtraPrimitiveOverestimationSize}) + + {-# INLINE vkMaxExtraPrimitiveOverestimationSizeByteOffset #-} + vkMaxExtraPrimitiveOverestimationSizeByteOffset ~_ + = #{offset VkPhysicalDeviceConservativeRasterizationPropertiesEXT, maxExtraPrimitiveOverestimationSize} + + {-# INLINE readVkMaxExtraPrimitiveOverestimationSize #-} + readVkMaxExtraPrimitiveOverestimationSize p + = peekByteOff p #{offset VkPhysicalDeviceConservativeRasterizationPropertiesEXT, maxExtraPrimitiveOverestimationSize} + + {-# INLINE writeVkMaxExtraPrimitiveOverestimationSize #-} + writeVkMaxExtraPrimitiveOverestimationSize p + = pokeByteOff p #{offset VkPhysicalDeviceConservativeRasterizationPropertiesEXT, maxExtraPrimitiveOverestimationSize} + +instance {-# OVERLAPPING #-} + HasField "maxExtraPrimitiveOverestimationSize" + VkPhysicalDeviceConservativeRasterizationPropertiesEXT + where + type FieldType "maxExtraPrimitiveOverestimationSize" + VkPhysicalDeviceConservativeRasterizationPropertiesEXT + = #{type float} + type FieldOptional "maxExtraPrimitiveOverestimationSize" + VkPhysicalDeviceConservativeRasterizationPropertiesEXT + = 'False -- ' closing tick for hsc2hs + type FieldOffset "maxExtraPrimitiveOverestimationSize" + VkPhysicalDeviceConservativeRasterizationPropertiesEXT + = + #{offset VkPhysicalDeviceConservativeRasterizationPropertiesEXT, maxExtraPrimitiveOverestimationSize} + type FieldIsArray "maxExtraPrimitiveOverestimationSize" + VkPhysicalDeviceConservativeRasterizationPropertiesEXT + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceConservativeRasterizationPropertiesEXT, maxExtraPrimitiveOverestimationSize} + +instance CanReadField "maxExtraPrimitiveOverestimationSize" + VkPhysicalDeviceConservativeRasterizationPropertiesEXT + where + {-# INLINE getField #-} + getField = vkMaxExtraPrimitiveOverestimationSize + + {-# INLINE readField #-} + readField = readVkMaxExtraPrimitiveOverestimationSize + +instance CanWriteField "maxExtraPrimitiveOverestimationSize" + VkPhysicalDeviceConservativeRasterizationPropertiesEXT + where + {-# INLINE writeField #-} + writeField = writeVkMaxExtraPrimitiveOverestimationSize + +instance {-# OVERLAPPING #-} + HasVkExtraPrimitiveOverestimationSizeGranularity + VkPhysicalDeviceConservativeRasterizationPropertiesEXT + where + type VkExtraPrimitiveOverestimationSizeGranularityMType + VkPhysicalDeviceConservativeRasterizationPropertiesEXT + = #{type float} + + {-# NOINLINE vkExtraPrimitiveOverestimationSizeGranularity #-} + vkExtraPrimitiveOverestimationSizeGranularity x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceConservativeRasterizationPropertiesEXT, extraPrimitiveOverestimationSizeGranularity}) + + {-# INLINE vkExtraPrimitiveOverestimationSizeGranularityByteOffset + #-} + vkExtraPrimitiveOverestimationSizeGranularityByteOffset ~_ + = #{offset VkPhysicalDeviceConservativeRasterizationPropertiesEXT, extraPrimitiveOverestimationSizeGranularity} + + {-# INLINE readVkExtraPrimitiveOverestimationSizeGranularity #-} + readVkExtraPrimitiveOverestimationSizeGranularity p + = peekByteOff p #{offset VkPhysicalDeviceConservativeRasterizationPropertiesEXT, extraPrimitiveOverestimationSizeGranularity} + + {-# INLINE writeVkExtraPrimitiveOverestimationSizeGranularity #-} + writeVkExtraPrimitiveOverestimationSizeGranularity p + = pokeByteOff p #{offset VkPhysicalDeviceConservativeRasterizationPropertiesEXT, extraPrimitiveOverestimationSizeGranularity} + +instance {-# OVERLAPPING #-} + HasField "extraPrimitiveOverestimationSizeGranularity" + VkPhysicalDeviceConservativeRasterizationPropertiesEXT + where + type FieldType "extraPrimitiveOverestimationSizeGranularity" + VkPhysicalDeviceConservativeRasterizationPropertiesEXT + = #{type float} + type FieldOptional "extraPrimitiveOverestimationSizeGranularity" + VkPhysicalDeviceConservativeRasterizationPropertiesEXT + = 'False -- ' closing tick for hsc2hs + type FieldOffset "extraPrimitiveOverestimationSizeGranularity" + VkPhysicalDeviceConservativeRasterizationPropertiesEXT + = + #{offset VkPhysicalDeviceConservativeRasterizationPropertiesEXT, extraPrimitiveOverestimationSizeGranularity} + type FieldIsArray "extraPrimitiveOverestimationSizeGranularity" + VkPhysicalDeviceConservativeRasterizationPropertiesEXT + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceConservativeRasterizationPropertiesEXT, extraPrimitiveOverestimationSizeGranularity} + +instance CanReadField "extraPrimitiveOverestimationSizeGranularity" + VkPhysicalDeviceConservativeRasterizationPropertiesEXT + where + {-# INLINE getField #-} + getField = vkExtraPrimitiveOverestimationSizeGranularity + + {-# INLINE readField #-} + readField = readVkExtraPrimitiveOverestimationSizeGranularity + +instance CanWriteField + "extraPrimitiveOverestimationSizeGranularity" + VkPhysicalDeviceConservativeRasterizationPropertiesEXT + where + {-# INLINE writeField #-} + writeField = writeVkExtraPrimitiveOverestimationSizeGranularity + +instance {-# OVERLAPPING #-} + HasVkPrimitiveUnderestimation + VkPhysicalDeviceConservativeRasterizationPropertiesEXT + where + type VkPrimitiveUnderestimationMType + VkPhysicalDeviceConservativeRasterizationPropertiesEXT + = VkBool32 + + {-# NOINLINE vkPrimitiveUnderestimation #-} + vkPrimitiveUnderestimation x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceConservativeRasterizationPropertiesEXT, primitiveUnderestimation}) + + {-# INLINE vkPrimitiveUnderestimationByteOffset #-} + vkPrimitiveUnderestimationByteOffset ~_ + = #{offset VkPhysicalDeviceConservativeRasterizationPropertiesEXT, primitiveUnderestimation} + + {-# INLINE readVkPrimitiveUnderestimation #-} + readVkPrimitiveUnderestimation p + = peekByteOff p #{offset VkPhysicalDeviceConservativeRasterizationPropertiesEXT, primitiveUnderestimation} + + {-# INLINE writeVkPrimitiveUnderestimation #-} + writeVkPrimitiveUnderestimation p + = pokeByteOff p #{offset VkPhysicalDeviceConservativeRasterizationPropertiesEXT, primitiveUnderestimation} + +instance {-# OVERLAPPING #-} + HasField "primitiveUnderestimation" + VkPhysicalDeviceConservativeRasterizationPropertiesEXT + where + type FieldType "primitiveUnderestimation" + VkPhysicalDeviceConservativeRasterizationPropertiesEXT + = VkBool32 + type FieldOptional "primitiveUnderestimation" + VkPhysicalDeviceConservativeRasterizationPropertiesEXT + = 'False -- ' closing tick for hsc2hs + type FieldOffset "primitiveUnderestimation" + VkPhysicalDeviceConservativeRasterizationPropertiesEXT + = + #{offset VkPhysicalDeviceConservativeRasterizationPropertiesEXT, primitiveUnderestimation} + type FieldIsArray "primitiveUnderestimation" + VkPhysicalDeviceConservativeRasterizationPropertiesEXT + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceConservativeRasterizationPropertiesEXT, primitiveUnderestimation} + +instance CanReadField "primitiveUnderestimation" + VkPhysicalDeviceConservativeRasterizationPropertiesEXT + where + {-# INLINE getField #-} + getField = vkPrimitiveUnderestimation + + {-# INLINE readField #-} + readField = readVkPrimitiveUnderestimation + +instance CanWriteField "primitiveUnderestimation" + VkPhysicalDeviceConservativeRasterizationPropertiesEXT + where + {-# INLINE writeField #-} + writeField = writeVkPrimitiveUnderestimation + +instance {-# OVERLAPPING #-} + HasVkConservativePointAndLineRasterization + VkPhysicalDeviceConservativeRasterizationPropertiesEXT + where + type VkConservativePointAndLineRasterizationMType + VkPhysicalDeviceConservativeRasterizationPropertiesEXT + = VkBool32 + + {-# NOINLINE vkConservativePointAndLineRasterization #-} + vkConservativePointAndLineRasterization x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceConservativeRasterizationPropertiesEXT, conservativePointAndLineRasterization}) + + {-# INLINE vkConservativePointAndLineRasterizationByteOffset #-} + vkConservativePointAndLineRasterizationByteOffset ~_ + = #{offset VkPhysicalDeviceConservativeRasterizationPropertiesEXT, conservativePointAndLineRasterization} + + {-# INLINE readVkConservativePointAndLineRasterization #-} + readVkConservativePointAndLineRasterization p + = peekByteOff p #{offset VkPhysicalDeviceConservativeRasterizationPropertiesEXT, conservativePointAndLineRasterization} + + {-# INLINE writeVkConservativePointAndLineRasterization #-} + writeVkConservativePointAndLineRasterization p + = pokeByteOff p #{offset VkPhysicalDeviceConservativeRasterizationPropertiesEXT, conservativePointAndLineRasterization} + +instance {-# OVERLAPPING #-} + HasField "conservativePointAndLineRasterization" + VkPhysicalDeviceConservativeRasterizationPropertiesEXT + where + type FieldType "conservativePointAndLineRasterization" + VkPhysicalDeviceConservativeRasterizationPropertiesEXT + = VkBool32 + type FieldOptional "conservativePointAndLineRasterization" + VkPhysicalDeviceConservativeRasterizationPropertiesEXT + = 'False -- ' closing tick for hsc2hs + type FieldOffset "conservativePointAndLineRasterization" + VkPhysicalDeviceConservativeRasterizationPropertiesEXT + = + #{offset VkPhysicalDeviceConservativeRasterizationPropertiesEXT, conservativePointAndLineRasterization} + type FieldIsArray "conservativePointAndLineRasterization" + VkPhysicalDeviceConservativeRasterizationPropertiesEXT + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceConservativeRasterizationPropertiesEXT, conservativePointAndLineRasterization} + +instance CanReadField "conservativePointAndLineRasterization" + VkPhysicalDeviceConservativeRasterizationPropertiesEXT + where + {-# INLINE getField #-} + getField = vkConservativePointAndLineRasterization + + {-# INLINE readField #-} + readField = readVkConservativePointAndLineRasterization + +instance CanWriteField "conservativePointAndLineRasterization" + VkPhysicalDeviceConservativeRasterizationPropertiesEXT + where + {-# INLINE writeField #-} + writeField = writeVkConservativePointAndLineRasterization + +instance {-# OVERLAPPING #-} + HasVkDegenerateTrianglesRasterized + VkPhysicalDeviceConservativeRasterizationPropertiesEXT + where + type VkDegenerateTrianglesRasterizedMType + VkPhysicalDeviceConservativeRasterizationPropertiesEXT + = VkBool32 + + {-# NOINLINE vkDegenerateTrianglesRasterized #-} + vkDegenerateTrianglesRasterized x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceConservativeRasterizationPropertiesEXT, degenerateTrianglesRasterized}) + + {-# INLINE vkDegenerateTrianglesRasterizedByteOffset #-} + vkDegenerateTrianglesRasterizedByteOffset ~_ + = #{offset VkPhysicalDeviceConservativeRasterizationPropertiesEXT, degenerateTrianglesRasterized} + + {-# INLINE readVkDegenerateTrianglesRasterized #-} + readVkDegenerateTrianglesRasterized p + = peekByteOff p #{offset VkPhysicalDeviceConservativeRasterizationPropertiesEXT, degenerateTrianglesRasterized} + + {-# INLINE writeVkDegenerateTrianglesRasterized #-} + writeVkDegenerateTrianglesRasterized p + = pokeByteOff p #{offset VkPhysicalDeviceConservativeRasterizationPropertiesEXT, degenerateTrianglesRasterized} + +instance {-# OVERLAPPING #-} + HasField "degenerateTrianglesRasterized" + VkPhysicalDeviceConservativeRasterizationPropertiesEXT + where + type FieldType "degenerateTrianglesRasterized" + VkPhysicalDeviceConservativeRasterizationPropertiesEXT + = VkBool32 + type FieldOptional "degenerateTrianglesRasterized" + VkPhysicalDeviceConservativeRasterizationPropertiesEXT + = 'False -- ' closing tick for hsc2hs + type FieldOffset "degenerateTrianglesRasterized" + VkPhysicalDeviceConservativeRasterizationPropertiesEXT + = + #{offset VkPhysicalDeviceConservativeRasterizationPropertiesEXT, degenerateTrianglesRasterized} + type FieldIsArray "degenerateTrianglesRasterized" + VkPhysicalDeviceConservativeRasterizationPropertiesEXT + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceConservativeRasterizationPropertiesEXT, degenerateTrianglesRasterized} + +instance CanReadField "degenerateTrianglesRasterized" + VkPhysicalDeviceConservativeRasterizationPropertiesEXT + where + {-# INLINE getField #-} + getField = vkDegenerateTrianglesRasterized + + {-# INLINE readField #-} + readField = readVkDegenerateTrianglesRasterized + +instance CanWriteField "degenerateTrianglesRasterized" + VkPhysicalDeviceConservativeRasterizationPropertiesEXT + where + {-# INLINE writeField #-} + writeField = writeVkDegenerateTrianglesRasterized + +instance {-# OVERLAPPING #-} + HasVkDegenerateLinesRasterized + VkPhysicalDeviceConservativeRasterizationPropertiesEXT + where + type VkDegenerateLinesRasterizedMType + VkPhysicalDeviceConservativeRasterizationPropertiesEXT + = VkBool32 + + {-# NOINLINE vkDegenerateLinesRasterized #-} + vkDegenerateLinesRasterized x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceConservativeRasterizationPropertiesEXT, degenerateLinesRasterized}) + + {-# INLINE vkDegenerateLinesRasterizedByteOffset #-} + vkDegenerateLinesRasterizedByteOffset ~_ + = #{offset VkPhysicalDeviceConservativeRasterizationPropertiesEXT, degenerateLinesRasterized} + + {-# INLINE readVkDegenerateLinesRasterized #-} + readVkDegenerateLinesRasterized p + = peekByteOff p #{offset VkPhysicalDeviceConservativeRasterizationPropertiesEXT, degenerateLinesRasterized} + + {-# INLINE writeVkDegenerateLinesRasterized #-} + writeVkDegenerateLinesRasterized p + = pokeByteOff p #{offset VkPhysicalDeviceConservativeRasterizationPropertiesEXT, degenerateLinesRasterized} + +instance {-# OVERLAPPING #-} + HasField "degenerateLinesRasterized" + VkPhysicalDeviceConservativeRasterizationPropertiesEXT + where + type FieldType "degenerateLinesRasterized" + VkPhysicalDeviceConservativeRasterizationPropertiesEXT + = VkBool32 + type FieldOptional "degenerateLinesRasterized" + VkPhysicalDeviceConservativeRasterizationPropertiesEXT + = 'False -- ' closing tick for hsc2hs + type FieldOffset "degenerateLinesRasterized" + VkPhysicalDeviceConservativeRasterizationPropertiesEXT + = + #{offset VkPhysicalDeviceConservativeRasterizationPropertiesEXT, degenerateLinesRasterized} + type FieldIsArray "degenerateLinesRasterized" + VkPhysicalDeviceConservativeRasterizationPropertiesEXT + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceConservativeRasterizationPropertiesEXT, degenerateLinesRasterized} + +instance CanReadField "degenerateLinesRasterized" + VkPhysicalDeviceConservativeRasterizationPropertiesEXT + where + {-# INLINE getField #-} + getField = vkDegenerateLinesRasterized + + {-# INLINE readField #-} + readField = readVkDegenerateLinesRasterized + +instance CanWriteField "degenerateLinesRasterized" + VkPhysicalDeviceConservativeRasterizationPropertiesEXT + where + {-# INLINE writeField #-} + writeField = writeVkDegenerateLinesRasterized + +instance {-# OVERLAPPING #-} + HasVkFullyCoveredFragmentShaderInputVariable + VkPhysicalDeviceConservativeRasterizationPropertiesEXT + where + type VkFullyCoveredFragmentShaderInputVariableMType + VkPhysicalDeviceConservativeRasterizationPropertiesEXT + = VkBool32 + + {-# NOINLINE vkFullyCoveredFragmentShaderInputVariable #-} + vkFullyCoveredFragmentShaderInputVariable x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceConservativeRasterizationPropertiesEXT, fullyCoveredFragmentShaderInputVariable}) + + {-# INLINE vkFullyCoveredFragmentShaderInputVariableByteOffset #-} + vkFullyCoveredFragmentShaderInputVariableByteOffset ~_ + = #{offset VkPhysicalDeviceConservativeRasterizationPropertiesEXT, fullyCoveredFragmentShaderInputVariable} + + {-# INLINE readVkFullyCoveredFragmentShaderInputVariable #-} + readVkFullyCoveredFragmentShaderInputVariable p + = peekByteOff p #{offset VkPhysicalDeviceConservativeRasterizationPropertiesEXT, fullyCoveredFragmentShaderInputVariable} + + {-# INLINE writeVkFullyCoveredFragmentShaderInputVariable #-} + writeVkFullyCoveredFragmentShaderInputVariable p + = pokeByteOff p #{offset VkPhysicalDeviceConservativeRasterizationPropertiesEXT, fullyCoveredFragmentShaderInputVariable} + +instance {-# OVERLAPPING #-} + HasField "fullyCoveredFragmentShaderInputVariable" + VkPhysicalDeviceConservativeRasterizationPropertiesEXT + where + type FieldType "fullyCoveredFragmentShaderInputVariable" + VkPhysicalDeviceConservativeRasterizationPropertiesEXT + = VkBool32 + type FieldOptional "fullyCoveredFragmentShaderInputVariable" + VkPhysicalDeviceConservativeRasterizationPropertiesEXT + = 'False -- ' closing tick for hsc2hs + type FieldOffset "fullyCoveredFragmentShaderInputVariable" + VkPhysicalDeviceConservativeRasterizationPropertiesEXT + = + #{offset VkPhysicalDeviceConservativeRasterizationPropertiesEXT, fullyCoveredFragmentShaderInputVariable} + type FieldIsArray "fullyCoveredFragmentShaderInputVariable" + VkPhysicalDeviceConservativeRasterizationPropertiesEXT + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceConservativeRasterizationPropertiesEXT, fullyCoveredFragmentShaderInputVariable} + +instance CanReadField "fullyCoveredFragmentShaderInputVariable" + VkPhysicalDeviceConservativeRasterizationPropertiesEXT + where + {-# INLINE getField #-} + getField = vkFullyCoveredFragmentShaderInputVariable + + {-# INLINE readField #-} + readField = readVkFullyCoveredFragmentShaderInputVariable + +instance CanWriteField "fullyCoveredFragmentShaderInputVariable" + VkPhysicalDeviceConservativeRasterizationPropertiesEXT + where + {-# INLINE writeField #-} + writeField = writeVkFullyCoveredFragmentShaderInputVariable + +instance {-# OVERLAPPING #-} + HasVkConservativeRasterizationPostDepthCoverage + VkPhysicalDeviceConservativeRasterizationPropertiesEXT + where + type VkConservativeRasterizationPostDepthCoverageMType + VkPhysicalDeviceConservativeRasterizationPropertiesEXT + = VkBool32 + + {-# NOINLINE vkConservativeRasterizationPostDepthCoverage #-} + vkConservativeRasterizationPostDepthCoverage x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceConservativeRasterizationPropertiesEXT, conservativeRasterizationPostDepthCoverage}) + + {-# INLINE vkConservativeRasterizationPostDepthCoverageByteOffset + #-} + vkConservativeRasterizationPostDepthCoverageByteOffset ~_ + = #{offset VkPhysicalDeviceConservativeRasterizationPropertiesEXT, conservativeRasterizationPostDepthCoverage} + + {-# INLINE readVkConservativeRasterizationPostDepthCoverage #-} + readVkConservativeRasterizationPostDepthCoverage p + = peekByteOff p #{offset VkPhysicalDeviceConservativeRasterizationPropertiesEXT, conservativeRasterizationPostDepthCoverage} + + {-# INLINE writeVkConservativeRasterizationPostDepthCoverage #-} + writeVkConservativeRasterizationPostDepthCoverage p + = pokeByteOff p #{offset VkPhysicalDeviceConservativeRasterizationPropertiesEXT, conservativeRasterizationPostDepthCoverage} + +instance {-# OVERLAPPING #-} + HasField "conservativeRasterizationPostDepthCoverage" + VkPhysicalDeviceConservativeRasterizationPropertiesEXT + where + type FieldType "conservativeRasterizationPostDepthCoverage" + VkPhysicalDeviceConservativeRasterizationPropertiesEXT + = VkBool32 + type FieldOptional "conservativeRasterizationPostDepthCoverage" + VkPhysicalDeviceConservativeRasterizationPropertiesEXT + = 'False -- ' closing tick for hsc2hs + type FieldOffset "conservativeRasterizationPostDepthCoverage" + VkPhysicalDeviceConservativeRasterizationPropertiesEXT + = + #{offset VkPhysicalDeviceConservativeRasterizationPropertiesEXT, conservativeRasterizationPostDepthCoverage} + type FieldIsArray "conservativeRasterizationPostDepthCoverage" + VkPhysicalDeviceConservativeRasterizationPropertiesEXT + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceConservativeRasterizationPropertiesEXT, conservativeRasterizationPostDepthCoverage} + +instance CanReadField "conservativeRasterizationPostDepthCoverage" + VkPhysicalDeviceConservativeRasterizationPropertiesEXT + where + {-# INLINE getField #-} + getField = vkConservativeRasterizationPostDepthCoverage + + {-# INLINE readField #-} + readField = readVkConservativeRasterizationPostDepthCoverage + +instance CanWriteField "conservativeRasterizationPostDepthCoverage" + VkPhysicalDeviceConservativeRasterizationPropertiesEXT + where + {-# INLINE writeField #-} + writeField = writeVkConservativeRasterizationPostDepthCoverage + +instance Show + VkPhysicalDeviceConservativeRasterizationPropertiesEXT + where + showsPrec d x + = showString + "VkPhysicalDeviceConservativeRasterizationPropertiesEXT {" + . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkPrimitiveOverestimationSize = " . + showsPrec d (vkPrimitiveOverestimationSize x) . + showString ", " . + showString "vkMaxExtraPrimitiveOverestimationSize = " . + showsPrec d (vkMaxExtraPrimitiveOverestimationSize x) . + showString ", " . + showString "vkExtraPrimitiveOverestimationSizeGranularity = " + . + showsPrec d + (vkExtraPrimitiveOverestimationSizeGranularity x) + . + showString ", " . + showString "vkPrimitiveUnderestimation = " . + showsPrec d (vkPrimitiveUnderestimation x) . + showString ", " . + showString + "vkConservativePointAndLineRasterization = " + . + showsPrec d + (vkConservativePointAndLineRasterization x) + . + showString ", " . + showString + "vkDegenerateTrianglesRasterized = " + . + showsPrec d + (vkDegenerateTrianglesRasterized x) + . + showString ", " . + showString + "vkDegenerateLinesRasterized = " + . + showsPrec d + (vkDegenerateLinesRasterized x) + . + showString ", " . + showString + "vkFullyCoveredFragmentShaderInputVariable = " + . + showsPrec d + (vkFullyCoveredFragmentShaderInputVariable + x) + . + showString ", " . + showString + "vkConservativeRasterizationPostDepthCoverage = " + . + showsPrec d + (vkConservativeRasterizationPostDepthCoverage + x) + . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkPhysicalDeviceDiscardRectanglePropertiesEXT.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkPhysicalDeviceDiscardRectanglePropertiesEXT.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkPhysicalDeviceDiscardRectanglePropertiesEXT.hsc @@ -0,0 +1,287 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceDiscardRectanglePropertiesEXT + (VkPhysicalDeviceDiscardRectanglePropertiesEXT(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceProperties2KHR (VkPhysicalDeviceProperties2KHR) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkPhysicalDeviceDiscardRectanglePropertiesEXT { +-- > VkStructureType sType; +-- > void* pNext; +-- > uint32_t maxDiscardRectangles; +-- > } VkPhysicalDeviceDiscardRectanglePropertiesEXT; +-- +-- +data VkPhysicalDeviceDiscardRectanglePropertiesEXT = VkPhysicalDeviceDiscardRectanglePropertiesEXT## Addr## + ByteArray## + +instance Eq VkPhysicalDeviceDiscardRectanglePropertiesEXT where + (VkPhysicalDeviceDiscardRectanglePropertiesEXT## a _) == + x@(VkPhysicalDeviceDiscardRectanglePropertiesEXT## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkPhysicalDeviceDiscardRectanglePropertiesEXT where + (VkPhysicalDeviceDiscardRectanglePropertiesEXT## a _) `compare` + x@(VkPhysicalDeviceDiscardRectanglePropertiesEXT## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkPhysicalDeviceDiscardRectanglePropertiesEXT + where + sizeOf ~_ + = #{size VkPhysicalDeviceDiscardRectanglePropertiesEXT} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkPhysicalDeviceDiscardRectanglePropertiesEXT} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim + VkPhysicalDeviceDiscardRectanglePropertiesEXT + where + unsafeAddr (VkPhysicalDeviceDiscardRectanglePropertiesEXT## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray + (VkPhysicalDeviceDiscardRectanglePropertiesEXT## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkPhysicalDeviceDiscardRectanglePropertiesEXT## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal + VkPhysicalDeviceDiscardRectanglePropertiesEXT + where + type StructFields VkPhysicalDeviceDiscardRectanglePropertiesEXT = + '["sType", "pNext", "maxDiscardRectangles"] -- ' closing tick for hsc2hs + type CUnionType VkPhysicalDeviceDiscardRectanglePropertiesEXT = + 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkPhysicalDeviceDiscardRectanglePropertiesEXT = + 'False -- ' closing tick for hsc2hs + type StructExtends VkPhysicalDeviceDiscardRectanglePropertiesEXT = + '[VkPhysicalDeviceProperties2KHR] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkPhysicalDeviceDiscardRectanglePropertiesEXT where + type VkSTypeMType VkPhysicalDeviceDiscardRectanglePropertiesEXT = + VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceDiscardRectanglePropertiesEXT, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkPhysicalDeviceDiscardRectanglePropertiesEXT, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkPhysicalDeviceDiscardRectanglePropertiesEXT, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkPhysicalDeviceDiscardRectanglePropertiesEXT, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkPhysicalDeviceDiscardRectanglePropertiesEXT + where + type FieldType "sType" + VkPhysicalDeviceDiscardRectanglePropertiesEXT + = VkStructureType + type FieldOptional "sType" + VkPhysicalDeviceDiscardRectanglePropertiesEXT + = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" + VkPhysicalDeviceDiscardRectanglePropertiesEXT + = + #{offset VkPhysicalDeviceDiscardRectanglePropertiesEXT, sType} + type FieldIsArray "sType" + VkPhysicalDeviceDiscardRectanglePropertiesEXT + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceDiscardRectanglePropertiesEXT, sType} + +instance CanReadField "sType" + VkPhysicalDeviceDiscardRectanglePropertiesEXT + where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" + VkPhysicalDeviceDiscardRectanglePropertiesEXT + where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkPhysicalDeviceDiscardRectanglePropertiesEXT where + type VkPNextMType VkPhysicalDeviceDiscardRectanglePropertiesEXT = + Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceDiscardRectanglePropertiesEXT, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkPhysicalDeviceDiscardRectanglePropertiesEXT, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkPhysicalDeviceDiscardRectanglePropertiesEXT, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkPhysicalDeviceDiscardRectanglePropertiesEXT, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkPhysicalDeviceDiscardRectanglePropertiesEXT + where + type FieldType "pNext" + VkPhysicalDeviceDiscardRectanglePropertiesEXT + = Ptr Void + type FieldOptional "pNext" + VkPhysicalDeviceDiscardRectanglePropertiesEXT + = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" + VkPhysicalDeviceDiscardRectanglePropertiesEXT + = + #{offset VkPhysicalDeviceDiscardRectanglePropertiesEXT, pNext} + type FieldIsArray "pNext" + VkPhysicalDeviceDiscardRectanglePropertiesEXT + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceDiscardRectanglePropertiesEXT, pNext} + +instance CanReadField "pNext" + VkPhysicalDeviceDiscardRectanglePropertiesEXT + where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" + VkPhysicalDeviceDiscardRectanglePropertiesEXT + where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkMaxDiscardRectangles + VkPhysicalDeviceDiscardRectanglePropertiesEXT + where + type VkMaxDiscardRectanglesMType + VkPhysicalDeviceDiscardRectanglePropertiesEXT + = Word32 + + {-# NOINLINE vkMaxDiscardRectangles #-} + vkMaxDiscardRectangles x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceDiscardRectanglePropertiesEXT, maxDiscardRectangles}) + + {-# INLINE vkMaxDiscardRectanglesByteOffset #-} + vkMaxDiscardRectanglesByteOffset ~_ + = #{offset VkPhysicalDeviceDiscardRectanglePropertiesEXT, maxDiscardRectangles} + + {-# INLINE readVkMaxDiscardRectangles #-} + readVkMaxDiscardRectangles p + = peekByteOff p #{offset VkPhysicalDeviceDiscardRectanglePropertiesEXT, maxDiscardRectangles} + + {-# INLINE writeVkMaxDiscardRectangles #-} + writeVkMaxDiscardRectangles p + = pokeByteOff p #{offset VkPhysicalDeviceDiscardRectanglePropertiesEXT, maxDiscardRectangles} + +instance {-# OVERLAPPING #-} + HasField "maxDiscardRectangles" + VkPhysicalDeviceDiscardRectanglePropertiesEXT + where + type FieldType "maxDiscardRectangles" + VkPhysicalDeviceDiscardRectanglePropertiesEXT + = Word32 + type FieldOptional "maxDiscardRectangles" + VkPhysicalDeviceDiscardRectanglePropertiesEXT + = 'False -- ' closing tick for hsc2hs + type FieldOffset "maxDiscardRectangles" + VkPhysicalDeviceDiscardRectanglePropertiesEXT + = + #{offset VkPhysicalDeviceDiscardRectanglePropertiesEXT, maxDiscardRectangles} + type FieldIsArray "maxDiscardRectangles" + VkPhysicalDeviceDiscardRectanglePropertiesEXT + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceDiscardRectanglePropertiesEXT, maxDiscardRectangles} + +instance CanReadField "maxDiscardRectangles" + VkPhysicalDeviceDiscardRectanglePropertiesEXT + where + {-# INLINE getField #-} + getField = vkMaxDiscardRectangles + + {-# INLINE readField #-} + readField = readVkMaxDiscardRectangles + +instance CanWriteField "maxDiscardRectangles" + VkPhysicalDeviceDiscardRectanglePropertiesEXT + where + {-# INLINE writeField #-} + writeField = writeVkMaxDiscardRectangles + +instance Show VkPhysicalDeviceDiscardRectanglePropertiesEXT where + showsPrec d x + = showString "VkPhysicalDeviceDiscardRectanglePropertiesEXT {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkMaxDiscardRectangles = " . + showsPrec d (vkMaxDiscardRectangles x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkPhysicalDeviceExternalBufferInfoKHR.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkPhysicalDeviceExternalBufferInfoKHR.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkPhysicalDeviceExternalBufferInfoKHR.hsc @@ -0,0 +1,375 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceExternalBufferInfoKHR + (VkPhysicalDeviceExternalBufferInfoKHR(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkBufferCreateFlags (VkBufferCreateFlags) +import Graphics.Vulkan.Types.Enum.VkBufferUsageFlags (VkBufferUsageFlags) +import Graphics.Vulkan.Types.Enum.VkExternalMemoryHandleTypeFlagsKHR (VkExternalMemoryHandleTypeFlagBitsKHR) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkPhysicalDeviceExternalBufferInfoKHR { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkBufferCreateFlags flags; +-- > VkBufferUsageFlags usage; +-- > VkExternalMemoryHandleTypeFlagBitsKHR handleType; +-- > } VkPhysicalDeviceExternalBufferInfoKHR; +-- +-- +data VkPhysicalDeviceExternalBufferInfoKHR = VkPhysicalDeviceExternalBufferInfoKHR## Addr## + ByteArray## + +instance Eq VkPhysicalDeviceExternalBufferInfoKHR where + (VkPhysicalDeviceExternalBufferInfoKHR## a _) == + x@(VkPhysicalDeviceExternalBufferInfoKHR## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkPhysicalDeviceExternalBufferInfoKHR where + (VkPhysicalDeviceExternalBufferInfoKHR## a _) `compare` + x@(VkPhysicalDeviceExternalBufferInfoKHR## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkPhysicalDeviceExternalBufferInfoKHR where + sizeOf ~_ + = #{size VkPhysicalDeviceExternalBufferInfoKHR} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkPhysicalDeviceExternalBufferInfoKHR} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkPhysicalDeviceExternalBufferInfoKHR + where + unsafeAddr (VkPhysicalDeviceExternalBufferInfoKHR## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkPhysicalDeviceExternalBufferInfoKHR## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkPhysicalDeviceExternalBufferInfoKHR## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkPhysicalDeviceExternalBufferInfoKHR where + type StructFields VkPhysicalDeviceExternalBufferInfoKHR = + '["sType", "pNext", "flags", "usage", "handleType"] -- ' closing tick for hsc2hs + type CUnionType VkPhysicalDeviceExternalBufferInfoKHR = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkPhysicalDeviceExternalBufferInfoKHR = 'False -- ' closing tick for hsc2hs + type StructExtends VkPhysicalDeviceExternalBufferInfoKHR = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkPhysicalDeviceExternalBufferInfoKHR where + type VkSTypeMType VkPhysicalDeviceExternalBufferInfoKHR = + VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceExternalBufferInfoKHR, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkPhysicalDeviceExternalBufferInfoKHR, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkPhysicalDeviceExternalBufferInfoKHR, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkPhysicalDeviceExternalBufferInfoKHR, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkPhysicalDeviceExternalBufferInfoKHR where + type FieldType "sType" VkPhysicalDeviceExternalBufferInfoKHR = + VkStructureType + type FieldOptional "sType" VkPhysicalDeviceExternalBufferInfoKHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkPhysicalDeviceExternalBufferInfoKHR = + #{offset VkPhysicalDeviceExternalBufferInfoKHR, sType} + type FieldIsArray "sType" VkPhysicalDeviceExternalBufferInfoKHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceExternalBufferInfoKHR, sType} + +instance CanReadField "sType" VkPhysicalDeviceExternalBufferInfoKHR + where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" + VkPhysicalDeviceExternalBufferInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkPhysicalDeviceExternalBufferInfoKHR where + type VkPNextMType VkPhysicalDeviceExternalBufferInfoKHR = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceExternalBufferInfoKHR, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkPhysicalDeviceExternalBufferInfoKHR, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkPhysicalDeviceExternalBufferInfoKHR, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkPhysicalDeviceExternalBufferInfoKHR, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkPhysicalDeviceExternalBufferInfoKHR where + type FieldType "pNext" VkPhysicalDeviceExternalBufferInfoKHR = + Ptr Void + type FieldOptional "pNext" VkPhysicalDeviceExternalBufferInfoKHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkPhysicalDeviceExternalBufferInfoKHR = + #{offset VkPhysicalDeviceExternalBufferInfoKHR, pNext} + type FieldIsArray "pNext" VkPhysicalDeviceExternalBufferInfoKHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceExternalBufferInfoKHR, pNext} + +instance CanReadField "pNext" VkPhysicalDeviceExternalBufferInfoKHR + where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" + VkPhysicalDeviceExternalBufferInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkFlags VkPhysicalDeviceExternalBufferInfoKHR where + type VkFlagsMType VkPhysicalDeviceExternalBufferInfoKHR = + VkBufferCreateFlags + + {-# NOINLINE vkFlags #-} + vkFlags x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceExternalBufferInfoKHR, flags}) + + {-# INLINE vkFlagsByteOffset #-} + vkFlagsByteOffset ~_ + = #{offset VkPhysicalDeviceExternalBufferInfoKHR, flags} + + {-# INLINE readVkFlags #-} + readVkFlags p + = peekByteOff p #{offset VkPhysicalDeviceExternalBufferInfoKHR, flags} + + {-# INLINE writeVkFlags #-} + writeVkFlags p + = pokeByteOff p #{offset VkPhysicalDeviceExternalBufferInfoKHR, flags} + +instance {-# OVERLAPPING #-} + HasField "flags" VkPhysicalDeviceExternalBufferInfoKHR where + type FieldType "flags" VkPhysicalDeviceExternalBufferInfoKHR = + VkBufferCreateFlags + type FieldOptional "flags" VkPhysicalDeviceExternalBufferInfoKHR = + 'True -- ' closing tick for hsc2hs + type FieldOffset "flags" VkPhysicalDeviceExternalBufferInfoKHR = + #{offset VkPhysicalDeviceExternalBufferInfoKHR, flags} + type FieldIsArray "flags" VkPhysicalDeviceExternalBufferInfoKHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceExternalBufferInfoKHR, flags} + +instance CanReadField "flags" VkPhysicalDeviceExternalBufferInfoKHR + where + {-# INLINE getField #-} + getField = vkFlags + + {-# INLINE readField #-} + readField = readVkFlags + +instance CanWriteField "flags" + VkPhysicalDeviceExternalBufferInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkFlags + +instance {-# OVERLAPPING #-} + HasVkUsage VkPhysicalDeviceExternalBufferInfoKHR where + type VkUsageMType VkPhysicalDeviceExternalBufferInfoKHR = + VkBufferUsageFlags + + {-# NOINLINE vkUsage #-} + vkUsage x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceExternalBufferInfoKHR, usage}) + + {-# INLINE vkUsageByteOffset #-} + vkUsageByteOffset ~_ + = #{offset VkPhysicalDeviceExternalBufferInfoKHR, usage} + + {-# INLINE readVkUsage #-} + readVkUsage p + = peekByteOff p #{offset VkPhysicalDeviceExternalBufferInfoKHR, usage} + + {-# INLINE writeVkUsage #-} + writeVkUsage p + = pokeByteOff p #{offset VkPhysicalDeviceExternalBufferInfoKHR, usage} + +instance {-# OVERLAPPING #-} + HasField "usage" VkPhysicalDeviceExternalBufferInfoKHR where + type FieldType "usage" VkPhysicalDeviceExternalBufferInfoKHR = + VkBufferUsageFlags + type FieldOptional "usage" VkPhysicalDeviceExternalBufferInfoKHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "usage" VkPhysicalDeviceExternalBufferInfoKHR = + #{offset VkPhysicalDeviceExternalBufferInfoKHR, usage} + type FieldIsArray "usage" VkPhysicalDeviceExternalBufferInfoKHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceExternalBufferInfoKHR, usage} + +instance CanReadField "usage" VkPhysicalDeviceExternalBufferInfoKHR + where + {-# INLINE getField #-} + getField = vkUsage + + {-# INLINE readField #-} + readField = readVkUsage + +instance CanWriteField "usage" + VkPhysicalDeviceExternalBufferInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkUsage + +instance {-# OVERLAPPING #-} + HasVkHandleType VkPhysicalDeviceExternalBufferInfoKHR where + type VkHandleTypeMType VkPhysicalDeviceExternalBufferInfoKHR = + VkExternalMemoryHandleTypeFlagBitsKHR + + {-# NOINLINE vkHandleType #-} + vkHandleType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceExternalBufferInfoKHR, handleType}) + + {-# INLINE vkHandleTypeByteOffset #-} + vkHandleTypeByteOffset ~_ + = #{offset VkPhysicalDeviceExternalBufferInfoKHR, handleType} + + {-# INLINE readVkHandleType #-} + readVkHandleType p + = peekByteOff p #{offset VkPhysicalDeviceExternalBufferInfoKHR, handleType} + + {-# INLINE writeVkHandleType #-} + writeVkHandleType p + = pokeByteOff p #{offset VkPhysicalDeviceExternalBufferInfoKHR, handleType} + +instance {-# OVERLAPPING #-} + HasField "handleType" VkPhysicalDeviceExternalBufferInfoKHR where + type FieldType "handleType" VkPhysicalDeviceExternalBufferInfoKHR = + VkExternalMemoryHandleTypeFlagBitsKHR + type FieldOptional "handleType" + VkPhysicalDeviceExternalBufferInfoKHR + = 'False -- ' closing tick for hsc2hs + type FieldOffset "handleType" VkPhysicalDeviceExternalBufferInfoKHR + = + #{offset VkPhysicalDeviceExternalBufferInfoKHR, handleType} + type FieldIsArray "handleType" + VkPhysicalDeviceExternalBufferInfoKHR + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceExternalBufferInfoKHR, handleType} + +instance CanReadField "handleType" + VkPhysicalDeviceExternalBufferInfoKHR + where + {-# INLINE getField #-} + getField = vkHandleType + + {-# INLINE readField #-} + readField = readVkHandleType + +instance CanWriteField "handleType" + VkPhysicalDeviceExternalBufferInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkHandleType + +instance Show VkPhysicalDeviceExternalBufferInfoKHR where + showsPrec d x + = showString "VkPhysicalDeviceExternalBufferInfoKHR {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkFlags = " . + showsPrec d (vkFlags x) . + showString ", " . + showString "vkUsage = " . + showsPrec d (vkUsage x) . + showString ", " . + showString "vkHandleType = " . + showsPrec d (vkHandleType x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkPhysicalDeviceExternalFenceInfoKHR.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkPhysicalDeviceExternalFenceInfoKHR.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkPhysicalDeviceExternalFenceInfoKHR.hsc @@ -0,0 +1,254 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceExternalFenceInfoKHR + (VkPhysicalDeviceExternalFenceInfoKHR(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkExternalFenceHandleTypeFlagsKHR (VkExternalFenceHandleTypeFlagBitsKHR) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkPhysicalDeviceExternalFenceInfoKHR { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkExternalFenceHandleTypeFlagBitsKHR handleType; +-- > } VkPhysicalDeviceExternalFenceInfoKHR; +-- +-- +data VkPhysicalDeviceExternalFenceInfoKHR = VkPhysicalDeviceExternalFenceInfoKHR## Addr## + ByteArray## + +instance Eq VkPhysicalDeviceExternalFenceInfoKHR where + (VkPhysicalDeviceExternalFenceInfoKHR## a _) == + x@(VkPhysicalDeviceExternalFenceInfoKHR## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkPhysicalDeviceExternalFenceInfoKHR where + (VkPhysicalDeviceExternalFenceInfoKHR## a _) `compare` + x@(VkPhysicalDeviceExternalFenceInfoKHR## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkPhysicalDeviceExternalFenceInfoKHR where + sizeOf ~_ + = #{size VkPhysicalDeviceExternalFenceInfoKHR} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkPhysicalDeviceExternalFenceInfoKHR} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkPhysicalDeviceExternalFenceInfoKHR + where + unsafeAddr (VkPhysicalDeviceExternalFenceInfoKHR## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkPhysicalDeviceExternalFenceInfoKHR## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkPhysicalDeviceExternalFenceInfoKHR## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkPhysicalDeviceExternalFenceInfoKHR where + type StructFields VkPhysicalDeviceExternalFenceInfoKHR = + '["sType", "pNext", "handleType"] -- ' closing tick for hsc2hs + type CUnionType VkPhysicalDeviceExternalFenceInfoKHR = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkPhysicalDeviceExternalFenceInfoKHR = 'False -- ' closing tick for hsc2hs + type StructExtends VkPhysicalDeviceExternalFenceInfoKHR = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkPhysicalDeviceExternalFenceInfoKHR where + type VkSTypeMType VkPhysicalDeviceExternalFenceInfoKHR = + VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceExternalFenceInfoKHR, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkPhysicalDeviceExternalFenceInfoKHR, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkPhysicalDeviceExternalFenceInfoKHR, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkPhysicalDeviceExternalFenceInfoKHR, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkPhysicalDeviceExternalFenceInfoKHR where + type FieldType "sType" VkPhysicalDeviceExternalFenceInfoKHR = + VkStructureType + type FieldOptional "sType" VkPhysicalDeviceExternalFenceInfoKHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkPhysicalDeviceExternalFenceInfoKHR = + #{offset VkPhysicalDeviceExternalFenceInfoKHR, sType} + type FieldIsArray "sType" VkPhysicalDeviceExternalFenceInfoKHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceExternalFenceInfoKHR, sType} + +instance CanReadField "sType" VkPhysicalDeviceExternalFenceInfoKHR + where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkPhysicalDeviceExternalFenceInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkPhysicalDeviceExternalFenceInfoKHR where + type VkPNextMType VkPhysicalDeviceExternalFenceInfoKHR = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceExternalFenceInfoKHR, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkPhysicalDeviceExternalFenceInfoKHR, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkPhysicalDeviceExternalFenceInfoKHR, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkPhysicalDeviceExternalFenceInfoKHR, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkPhysicalDeviceExternalFenceInfoKHR where + type FieldType "pNext" VkPhysicalDeviceExternalFenceInfoKHR = + Ptr Void + type FieldOptional "pNext" VkPhysicalDeviceExternalFenceInfoKHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkPhysicalDeviceExternalFenceInfoKHR = + #{offset VkPhysicalDeviceExternalFenceInfoKHR, pNext} + type FieldIsArray "pNext" VkPhysicalDeviceExternalFenceInfoKHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceExternalFenceInfoKHR, pNext} + +instance CanReadField "pNext" VkPhysicalDeviceExternalFenceInfoKHR + where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkPhysicalDeviceExternalFenceInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkHandleType VkPhysicalDeviceExternalFenceInfoKHR where + type VkHandleTypeMType VkPhysicalDeviceExternalFenceInfoKHR = + VkExternalFenceHandleTypeFlagBitsKHR + + {-# NOINLINE vkHandleType #-} + vkHandleType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceExternalFenceInfoKHR, handleType}) + + {-# INLINE vkHandleTypeByteOffset #-} + vkHandleTypeByteOffset ~_ + = #{offset VkPhysicalDeviceExternalFenceInfoKHR, handleType} + + {-# INLINE readVkHandleType #-} + readVkHandleType p + = peekByteOff p #{offset VkPhysicalDeviceExternalFenceInfoKHR, handleType} + + {-# INLINE writeVkHandleType #-} + writeVkHandleType p + = pokeByteOff p #{offset VkPhysicalDeviceExternalFenceInfoKHR, handleType} + +instance {-# OVERLAPPING #-} + HasField "handleType" VkPhysicalDeviceExternalFenceInfoKHR where + type FieldType "handleType" VkPhysicalDeviceExternalFenceInfoKHR = + VkExternalFenceHandleTypeFlagBitsKHR + type FieldOptional "handleType" + VkPhysicalDeviceExternalFenceInfoKHR + = 'False -- ' closing tick for hsc2hs + type FieldOffset "handleType" VkPhysicalDeviceExternalFenceInfoKHR + = + #{offset VkPhysicalDeviceExternalFenceInfoKHR, handleType} + type FieldIsArray "handleType" VkPhysicalDeviceExternalFenceInfoKHR + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceExternalFenceInfoKHR, handleType} + +instance CanReadField "handleType" + VkPhysicalDeviceExternalFenceInfoKHR + where + {-# INLINE getField #-} + getField = vkHandleType + + {-# INLINE readField #-} + readField = readVkHandleType + +instance CanWriteField "handleType" + VkPhysicalDeviceExternalFenceInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkHandleType + +instance Show VkPhysicalDeviceExternalFenceInfoKHR where + showsPrec d x + = showString "VkPhysicalDeviceExternalFenceInfoKHR {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkHandleType = " . + showsPrec d (vkHandleType x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkPhysicalDeviceExternalImageFormatInfoKHR.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkPhysicalDeviceExternalImageFormatInfoKHR.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkPhysicalDeviceExternalImageFormatInfoKHR.hsc @@ -0,0 +1,280 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceExternalImageFormatInfoKHR + (VkPhysicalDeviceExternalImageFormatInfoKHR(..)) where +import Foreign.Storable + (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkExternalMemoryHandleTypeFlagsKHR + (VkExternalMemoryHandleTypeFlagBitsKHR) +import Graphics.Vulkan.Types.Enum.VkStructureType + (VkStructureType) +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceImageFormatInfo2KHR + (VkPhysicalDeviceImageFormatInfo2KHR) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe + (unsafeDupablePerformIO) + +-- | > typedef struct VkPhysicalDeviceExternalImageFormatInfoKHR { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkExternalMemoryHandleTypeFlagBitsKHR handleType; +-- > } VkPhysicalDeviceExternalImageFormatInfoKHR; +-- +-- +data VkPhysicalDeviceExternalImageFormatInfoKHR = VkPhysicalDeviceExternalImageFormatInfoKHR## Addr## + ByteArray## + +instance Eq VkPhysicalDeviceExternalImageFormatInfoKHR where + (VkPhysicalDeviceExternalImageFormatInfoKHR## a _) == + x@(VkPhysicalDeviceExternalImageFormatInfoKHR## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkPhysicalDeviceExternalImageFormatInfoKHR where + (VkPhysicalDeviceExternalImageFormatInfoKHR## a _) `compare` + x@(VkPhysicalDeviceExternalImageFormatInfoKHR## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkPhysicalDeviceExternalImageFormatInfoKHR where + sizeOf ~_ + = #{size VkPhysicalDeviceExternalImageFormatInfoKHR} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkPhysicalDeviceExternalImageFormatInfoKHR} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim + VkPhysicalDeviceExternalImageFormatInfoKHR + where + unsafeAddr (VkPhysicalDeviceExternalImageFormatInfoKHR## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkPhysicalDeviceExternalImageFormatInfoKHR## _ b) + = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkPhysicalDeviceExternalImageFormatInfoKHR## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkPhysicalDeviceExternalImageFormatInfoKHR + where + type StructFields VkPhysicalDeviceExternalImageFormatInfoKHR = + '["sType", "pNext", "handleType"] -- ' closing tick for hsc2hs + type CUnionType VkPhysicalDeviceExternalImageFormatInfoKHR = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkPhysicalDeviceExternalImageFormatInfoKHR = + 'False -- ' closing tick for hsc2hs + type StructExtends VkPhysicalDeviceExternalImageFormatInfoKHR = + '[VkPhysicalDeviceImageFormatInfo2KHR] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkPhysicalDeviceExternalImageFormatInfoKHR where + type VkSTypeMType VkPhysicalDeviceExternalImageFormatInfoKHR = + VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceExternalImageFormatInfoKHR, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkPhysicalDeviceExternalImageFormatInfoKHR, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkPhysicalDeviceExternalImageFormatInfoKHR, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkPhysicalDeviceExternalImageFormatInfoKHR, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkPhysicalDeviceExternalImageFormatInfoKHR where + type FieldType "sType" VkPhysicalDeviceExternalImageFormatInfoKHR = + VkStructureType + type FieldOptional "sType" + VkPhysicalDeviceExternalImageFormatInfoKHR + = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkPhysicalDeviceExternalImageFormatInfoKHR + = + #{offset VkPhysicalDeviceExternalImageFormatInfoKHR, sType} + type FieldIsArray "sType" + VkPhysicalDeviceExternalImageFormatInfoKHR + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceExternalImageFormatInfoKHR, sType} + +instance CanReadField "sType" + VkPhysicalDeviceExternalImageFormatInfoKHR + where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" + VkPhysicalDeviceExternalImageFormatInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkPhysicalDeviceExternalImageFormatInfoKHR where + type VkPNextMType VkPhysicalDeviceExternalImageFormatInfoKHR = + Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceExternalImageFormatInfoKHR, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkPhysicalDeviceExternalImageFormatInfoKHR, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkPhysicalDeviceExternalImageFormatInfoKHR, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkPhysicalDeviceExternalImageFormatInfoKHR, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkPhysicalDeviceExternalImageFormatInfoKHR where + type FieldType "pNext" VkPhysicalDeviceExternalImageFormatInfoKHR = + Ptr Void + type FieldOptional "pNext" + VkPhysicalDeviceExternalImageFormatInfoKHR + = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkPhysicalDeviceExternalImageFormatInfoKHR + = + #{offset VkPhysicalDeviceExternalImageFormatInfoKHR, pNext} + type FieldIsArray "pNext" + VkPhysicalDeviceExternalImageFormatInfoKHR + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceExternalImageFormatInfoKHR, pNext} + +instance CanReadField "pNext" + VkPhysicalDeviceExternalImageFormatInfoKHR + where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" + VkPhysicalDeviceExternalImageFormatInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkHandleType VkPhysicalDeviceExternalImageFormatInfoKHR where + type VkHandleTypeMType VkPhysicalDeviceExternalImageFormatInfoKHR = + VkExternalMemoryHandleTypeFlagBitsKHR + + {-# NOINLINE vkHandleType #-} + vkHandleType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceExternalImageFormatInfoKHR, handleType}) + + {-# INLINE vkHandleTypeByteOffset #-} + vkHandleTypeByteOffset ~_ + = #{offset VkPhysicalDeviceExternalImageFormatInfoKHR, handleType} + + {-# INLINE readVkHandleType #-} + readVkHandleType p + = peekByteOff p #{offset VkPhysicalDeviceExternalImageFormatInfoKHR, handleType} + + {-# INLINE writeVkHandleType #-} + writeVkHandleType p + = pokeByteOff p #{offset VkPhysicalDeviceExternalImageFormatInfoKHR, handleType} + +instance {-# OVERLAPPING #-} + HasField "handleType" VkPhysicalDeviceExternalImageFormatInfoKHR + where + type FieldType "handleType" + VkPhysicalDeviceExternalImageFormatInfoKHR + = VkExternalMemoryHandleTypeFlagBitsKHR + type FieldOptional "handleType" + VkPhysicalDeviceExternalImageFormatInfoKHR + = 'True -- ' closing tick for hsc2hs + type FieldOffset "handleType" + VkPhysicalDeviceExternalImageFormatInfoKHR + = + #{offset VkPhysicalDeviceExternalImageFormatInfoKHR, handleType} + type FieldIsArray "handleType" + VkPhysicalDeviceExternalImageFormatInfoKHR + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceExternalImageFormatInfoKHR, handleType} + +instance CanReadField "handleType" + VkPhysicalDeviceExternalImageFormatInfoKHR + where + {-# INLINE getField #-} + getField = vkHandleType + + {-# INLINE readField #-} + readField = readVkHandleType + +instance CanWriteField "handleType" + VkPhysicalDeviceExternalImageFormatInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkHandleType + +instance Show VkPhysicalDeviceExternalImageFormatInfoKHR where + showsPrec d x + = showString "VkPhysicalDeviceExternalImageFormatInfoKHR {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkHandleType = " . + showsPrec d (vkHandleType x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkPhysicalDeviceExternalMemoryHostPropertiesEXT.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkPhysicalDeviceExternalMemoryHostPropertiesEXT.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkPhysicalDeviceExternalMemoryHostPropertiesEXT.hsc @@ -0,0 +1,289 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceExternalMemoryHostPropertiesEXT + (VkPhysicalDeviceExternalMemoryHostPropertiesEXT(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.BaseTypes (VkDeviceSize) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceProperties2KHR (VkPhysicalDeviceProperties2KHR) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkPhysicalDeviceExternalMemoryHostPropertiesEXT { +-- > VkStructureType sType; +-- > void* pNext; +-- > VkDeviceSize minImportedHostPointerAlignment; +-- > } VkPhysicalDeviceExternalMemoryHostPropertiesEXT; +-- +-- +data VkPhysicalDeviceExternalMemoryHostPropertiesEXT = VkPhysicalDeviceExternalMemoryHostPropertiesEXT## Addr## + ByteArray## + +instance Eq VkPhysicalDeviceExternalMemoryHostPropertiesEXT where + (VkPhysicalDeviceExternalMemoryHostPropertiesEXT## a _) == + x@(VkPhysicalDeviceExternalMemoryHostPropertiesEXT## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkPhysicalDeviceExternalMemoryHostPropertiesEXT where + (VkPhysicalDeviceExternalMemoryHostPropertiesEXT## a _) `compare` + x@(VkPhysicalDeviceExternalMemoryHostPropertiesEXT## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkPhysicalDeviceExternalMemoryHostPropertiesEXT + where + sizeOf ~_ + = #{size VkPhysicalDeviceExternalMemoryHostPropertiesEXT} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkPhysicalDeviceExternalMemoryHostPropertiesEXT} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim + VkPhysicalDeviceExternalMemoryHostPropertiesEXT + where + unsafeAddr (VkPhysicalDeviceExternalMemoryHostPropertiesEXT## a _) + = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray + (VkPhysicalDeviceExternalMemoryHostPropertiesEXT## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkPhysicalDeviceExternalMemoryHostPropertiesEXT## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal + VkPhysicalDeviceExternalMemoryHostPropertiesEXT + where + type StructFields VkPhysicalDeviceExternalMemoryHostPropertiesEXT = + '["sType", "pNext", "minImportedHostPointerAlignment"] -- ' closing tick for hsc2hs + type CUnionType VkPhysicalDeviceExternalMemoryHostPropertiesEXT = + 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkPhysicalDeviceExternalMemoryHostPropertiesEXT = + 'False -- ' closing tick for hsc2hs + type StructExtends VkPhysicalDeviceExternalMemoryHostPropertiesEXT + = '[VkPhysicalDeviceProperties2KHR] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkPhysicalDeviceExternalMemoryHostPropertiesEXT where + type VkSTypeMType VkPhysicalDeviceExternalMemoryHostPropertiesEXT = + VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceExternalMemoryHostPropertiesEXT, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkPhysicalDeviceExternalMemoryHostPropertiesEXT, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkPhysicalDeviceExternalMemoryHostPropertiesEXT, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkPhysicalDeviceExternalMemoryHostPropertiesEXT, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkPhysicalDeviceExternalMemoryHostPropertiesEXT + where + type FieldType "sType" + VkPhysicalDeviceExternalMemoryHostPropertiesEXT + = VkStructureType + type FieldOptional "sType" + VkPhysicalDeviceExternalMemoryHostPropertiesEXT + = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" + VkPhysicalDeviceExternalMemoryHostPropertiesEXT + = + #{offset VkPhysicalDeviceExternalMemoryHostPropertiesEXT, sType} + type FieldIsArray "sType" + VkPhysicalDeviceExternalMemoryHostPropertiesEXT + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceExternalMemoryHostPropertiesEXT, sType} + +instance CanReadField "sType" + VkPhysicalDeviceExternalMemoryHostPropertiesEXT + where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" + VkPhysicalDeviceExternalMemoryHostPropertiesEXT + where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkPhysicalDeviceExternalMemoryHostPropertiesEXT where + type VkPNextMType VkPhysicalDeviceExternalMemoryHostPropertiesEXT = + Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceExternalMemoryHostPropertiesEXT, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkPhysicalDeviceExternalMemoryHostPropertiesEXT, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkPhysicalDeviceExternalMemoryHostPropertiesEXT, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkPhysicalDeviceExternalMemoryHostPropertiesEXT, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkPhysicalDeviceExternalMemoryHostPropertiesEXT + where + type FieldType "pNext" + VkPhysicalDeviceExternalMemoryHostPropertiesEXT + = Ptr Void + type FieldOptional "pNext" + VkPhysicalDeviceExternalMemoryHostPropertiesEXT + = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" + VkPhysicalDeviceExternalMemoryHostPropertiesEXT + = + #{offset VkPhysicalDeviceExternalMemoryHostPropertiesEXT, pNext} + type FieldIsArray "pNext" + VkPhysicalDeviceExternalMemoryHostPropertiesEXT + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceExternalMemoryHostPropertiesEXT, pNext} + +instance CanReadField "pNext" + VkPhysicalDeviceExternalMemoryHostPropertiesEXT + where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" + VkPhysicalDeviceExternalMemoryHostPropertiesEXT + where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkMinImportedHostPointerAlignment + VkPhysicalDeviceExternalMemoryHostPropertiesEXT + where + type VkMinImportedHostPointerAlignmentMType + VkPhysicalDeviceExternalMemoryHostPropertiesEXT + = VkDeviceSize + + {-# NOINLINE vkMinImportedHostPointerAlignment #-} + vkMinImportedHostPointerAlignment x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceExternalMemoryHostPropertiesEXT, minImportedHostPointerAlignment}) + + {-# INLINE vkMinImportedHostPointerAlignmentByteOffset #-} + vkMinImportedHostPointerAlignmentByteOffset ~_ + = #{offset VkPhysicalDeviceExternalMemoryHostPropertiesEXT, minImportedHostPointerAlignment} + + {-# INLINE readVkMinImportedHostPointerAlignment #-} + readVkMinImportedHostPointerAlignment p + = peekByteOff p #{offset VkPhysicalDeviceExternalMemoryHostPropertiesEXT, minImportedHostPointerAlignment} + + {-# INLINE writeVkMinImportedHostPointerAlignment #-} + writeVkMinImportedHostPointerAlignment p + = pokeByteOff p #{offset VkPhysicalDeviceExternalMemoryHostPropertiesEXT, minImportedHostPointerAlignment} + +instance {-# OVERLAPPING #-} + HasField "minImportedHostPointerAlignment" + VkPhysicalDeviceExternalMemoryHostPropertiesEXT + where + type FieldType "minImportedHostPointerAlignment" + VkPhysicalDeviceExternalMemoryHostPropertiesEXT + = VkDeviceSize + type FieldOptional "minImportedHostPointerAlignment" + VkPhysicalDeviceExternalMemoryHostPropertiesEXT + = 'False -- ' closing tick for hsc2hs + type FieldOffset "minImportedHostPointerAlignment" + VkPhysicalDeviceExternalMemoryHostPropertiesEXT + = + #{offset VkPhysicalDeviceExternalMemoryHostPropertiesEXT, minImportedHostPointerAlignment} + type FieldIsArray "minImportedHostPointerAlignment" + VkPhysicalDeviceExternalMemoryHostPropertiesEXT + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceExternalMemoryHostPropertiesEXT, minImportedHostPointerAlignment} + +instance CanReadField "minImportedHostPointerAlignment" + VkPhysicalDeviceExternalMemoryHostPropertiesEXT + where + {-# INLINE getField #-} + getField = vkMinImportedHostPointerAlignment + + {-# INLINE readField #-} + readField = readVkMinImportedHostPointerAlignment + +instance CanWriteField "minImportedHostPointerAlignment" + VkPhysicalDeviceExternalMemoryHostPropertiesEXT + where + {-# INLINE writeField #-} + writeField = writeVkMinImportedHostPointerAlignment + +instance Show VkPhysicalDeviceExternalMemoryHostPropertiesEXT where + showsPrec d x + = showString "VkPhysicalDeviceExternalMemoryHostPropertiesEXT {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkMinImportedHostPointerAlignment = " . + showsPrec d (vkMinImportedHostPointerAlignment x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkPhysicalDeviceExternalSemaphoreInfoKHR.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkPhysicalDeviceExternalSemaphoreInfoKHR.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkPhysicalDeviceExternalSemaphoreInfoKHR.hsc @@ -0,0 +1,268 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceExternalSemaphoreInfoKHR + (VkPhysicalDeviceExternalSemaphoreInfoKHR(..)) where +import Foreign.Storable + (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkExternalSemaphoreHandleTypeFlagsKHR + (VkExternalSemaphoreHandleTypeFlagBitsKHR) +import Graphics.Vulkan.Types.Enum.VkStructureType + (VkStructureType) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe + (unsafeDupablePerformIO) + +-- | > typedef struct VkPhysicalDeviceExternalSemaphoreInfoKHR { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkExternalSemaphoreHandleTypeFlagBitsKHR handleType; +-- > } VkPhysicalDeviceExternalSemaphoreInfoKHR; +-- +-- +data VkPhysicalDeviceExternalSemaphoreInfoKHR = VkPhysicalDeviceExternalSemaphoreInfoKHR## Addr## + ByteArray## + +instance Eq VkPhysicalDeviceExternalSemaphoreInfoKHR where + (VkPhysicalDeviceExternalSemaphoreInfoKHR## a _) == + x@(VkPhysicalDeviceExternalSemaphoreInfoKHR## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkPhysicalDeviceExternalSemaphoreInfoKHR where + (VkPhysicalDeviceExternalSemaphoreInfoKHR## a _) `compare` + x@(VkPhysicalDeviceExternalSemaphoreInfoKHR## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkPhysicalDeviceExternalSemaphoreInfoKHR where + sizeOf ~_ + = #{size VkPhysicalDeviceExternalSemaphoreInfoKHR} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkPhysicalDeviceExternalSemaphoreInfoKHR} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkPhysicalDeviceExternalSemaphoreInfoKHR + where + unsafeAddr (VkPhysicalDeviceExternalSemaphoreInfoKHR## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkPhysicalDeviceExternalSemaphoreInfoKHR## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkPhysicalDeviceExternalSemaphoreInfoKHR## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkPhysicalDeviceExternalSemaphoreInfoKHR + where + type StructFields VkPhysicalDeviceExternalSemaphoreInfoKHR = + '["sType", "pNext", "handleType"] -- ' closing tick for hsc2hs + type CUnionType VkPhysicalDeviceExternalSemaphoreInfoKHR = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkPhysicalDeviceExternalSemaphoreInfoKHR = 'False -- ' closing tick for hsc2hs + type StructExtends VkPhysicalDeviceExternalSemaphoreInfoKHR = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkPhysicalDeviceExternalSemaphoreInfoKHR where + type VkSTypeMType VkPhysicalDeviceExternalSemaphoreInfoKHR = + VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceExternalSemaphoreInfoKHR, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkPhysicalDeviceExternalSemaphoreInfoKHR, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkPhysicalDeviceExternalSemaphoreInfoKHR, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkPhysicalDeviceExternalSemaphoreInfoKHR, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkPhysicalDeviceExternalSemaphoreInfoKHR where + type FieldType "sType" VkPhysicalDeviceExternalSemaphoreInfoKHR = + VkStructureType + type FieldOptional "sType" VkPhysicalDeviceExternalSemaphoreInfoKHR + = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkPhysicalDeviceExternalSemaphoreInfoKHR = + #{offset VkPhysicalDeviceExternalSemaphoreInfoKHR, sType} + type FieldIsArray "sType" VkPhysicalDeviceExternalSemaphoreInfoKHR + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceExternalSemaphoreInfoKHR, sType} + +instance CanReadField "sType" + VkPhysicalDeviceExternalSemaphoreInfoKHR + where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" + VkPhysicalDeviceExternalSemaphoreInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkPhysicalDeviceExternalSemaphoreInfoKHR where + type VkPNextMType VkPhysicalDeviceExternalSemaphoreInfoKHR = + Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceExternalSemaphoreInfoKHR, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkPhysicalDeviceExternalSemaphoreInfoKHR, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkPhysicalDeviceExternalSemaphoreInfoKHR, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkPhysicalDeviceExternalSemaphoreInfoKHR, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkPhysicalDeviceExternalSemaphoreInfoKHR where + type FieldType "pNext" VkPhysicalDeviceExternalSemaphoreInfoKHR = + Ptr Void + type FieldOptional "pNext" VkPhysicalDeviceExternalSemaphoreInfoKHR + = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkPhysicalDeviceExternalSemaphoreInfoKHR = + #{offset VkPhysicalDeviceExternalSemaphoreInfoKHR, pNext} + type FieldIsArray "pNext" VkPhysicalDeviceExternalSemaphoreInfoKHR + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceExternalSemaphoreInfoKHR, pNext} + +instance CanReadField "pNext" + VkPhysicalDeviceExternalSemaphoreInfoKHR + where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" + VkPhysicalDeviceExternalSemaphoreInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkHandleType VkPhysicalDeviceExternalSemaphoreInfoKHR where + type VkHandleTypeMType VkPhysicalDeviceExternalSemaphoreInfoKHR = + VkExternalSemaphoreHandleTypeFlagBitsKHR + + {-# NOINLINE vkHandleType #-} + vkHandleType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceExternalSemaphoreInfoKHR, handleType}) + + {-# INLINE vkHandleTypeByteOffset #-} + vkHandleTypeByteOffset ~_ + = #{offset VkPhysicalDeviceExternalSemaphoreInfoKHR, handleType} + + {-# INLINE readVkHandleType #-} + readVkHandleType p + = peekByteOff p #{offset VkPhysicalDeviceExternalSemaphoreInfoKHR, handleType} + + {-# INLINE writeVkHandleType #-} + writeVkHandleType p + = pokeByteOff p #{offset VkPhysicalDeviceExternalSemaphoreInfoKHR, handleType} + +instance {-# OVERLAPPING #-} + HasField "handleType" VkPhysicalDeviceExternalSemaphoreInfoKHR + where + type FieldType "handleType" + VkPhysicalDeviceExternalSemaphoreInfoKHR + = VkExternalSemaphoreHandleTypeFlagBitsKHR + type FieldOptional "handleType" + VkPhysicalDeviceExternalSemaphoreInfoKHR + = 'False -- ' closing tick for hsc2hs + type FieldOffset "handleType" + VkPhysicalDeviceExternalSemaphoreInfoKHR + = + #{offset VkPhysicalDeviceExternalSemaphoreInfoKHR, handleType} + type FieldIsArray "handleType" + VkPhysicalDeviceExternalSemaphoreInfoKHR + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceExternalSemaphoreInfoKHR, handleType} + +instance CanReadField "handleType" + VkPhysicalDeviceExternalSemaphoreInfoKHR + where + {-# INLINE getField #-} + getField = vkHandleType + + {-# INLINE readField #-} + readField = readVkHandleType + +instance CanWriteField "handleType" + VkPhysicalDeviceExternalSemaphoreInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkHandleType + +instance Show VkPhysicalDeviceExternalSemaphoreInfoKHR where + showsPrec d x + = showString "VkPhysicalDeviceExternalSemaphoreInfoKHR {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkHandleType = " . + showsPrec d (vkHandleType x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkPhysicalDeviceFeatures.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkPhysicalDeviceFeatures.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkPhysicalDeviceFeatures.hsc @@ -0,0 +1,3712 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceFeatures + (VkPhysicalDeviceFeatures(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.BaseTypes (VkBool32) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkPhysicalDeviceFeatures { +-- > VkBool32 robustBufferAccess; +-- > VkBool32 fullDrawIndexUint32; +-- > VkBool32 imageCubeArray; +-- > VkBool32 independentBlend; +-- > VkBool32 geometryShader; +-- > VkBool32 tessellationShader; +-- > VkBool32 sampleRateShading; +-- > VkBool32 dualSrcBlend; +-- > VkBool32 logicOp; +-- > VkBool32 multiDrawIndirect; +-- > VkBool32 drawIndirectFirstInstance; +-- > VkBool32 depthClamp; +-- > VkBool32 depthBiasClamp; +-- > VkBool32 fillModeNonSolid; +-- > VkBool32 depthBounds; +-- > VkBool32 wideLines; +-- > VkBool32 largePoints; +-- > VkBool32 alphaToOne; +-- > VkBool32 multiViewport; +-- > VkBool32 samplerAnisotropy; +-- > VkBool32 textureCompressionETC2; +-- > VkBool32 textureCompressionASTC_LDR; +-- > VkBool32 textureCompressionBC; +-- > VkBool32 occlusionQueryPrecise; +-- > VkBool32 pipelineStatisticsQuery; +-- > VkBool32 vertexPipelineStoresAndAtomics; +-- > VkBool32 fragmentStoresAndAtomics; +-- > VkBool32 shaderTessellationAndGeometryPointSize; +-- > VkBool32 shaderImageGatherExtended; +-- > VkBool32 shaderStorageImageExtendedFormats; +-- > VkBool32 shaderStorageImageMultisample; +-- > VkBool32 shaderStorageImageReadWithoutFormat; +-- > VkBool32 shaderStorageImageWriteWithoutFormat; +-- > VkBool32 shaderUniformBufferArrayDynamicIndexing; +-- > VkBool32 shaderSampledImageArrayDynamicIndexing; +-- > VkBool32 shaderStorageBufferArrayDynamicIndexing; +-- > VkBool32 shaderStorageImageArrayDynamicIndexing; +-- > VkBool32 shaderClipDistance; +-- > VkBool32 shaderCullDistance; +-- > VkBool32 shaderFloat64; +-- > VkBool32 shaderInt64; +-- > VkBool32 shaderInt16; +-- > VkBool32 shaderResourceResidency; +-- > VkBool32 shaderResourceMinLod; +-- > VkBool32 sparseBinding; +-- > VkBool32 sparseResidencyBuffer; +-- > VkBool32 sparseResidencyImage2D; +-- > VkBool32 sparseResidencyImage3D; +-- > VkBool32 sparseResidency2Samples; +-- > VkBool32 sparseResidency4Samples; +-- > VkBool32 sparseResidency8Samples; +-- > VkBool32 sparseResidency16Samples; +-- > VkBool32 sparseResidencyAliased; +-- > VkBool32 variableMultisampleRate; +-- > VkBool32 inheritedQueries; +-- > } VkPhysicalDeviceFeatures; +-- +-- +data VkPhysicalDeviceFeatures = VkPhysicalDeviceFeatures## Addr## + ByteArray## + +instance Eq VkPhysicalDeviceFeatures where + (VkPhysicalDeviceFeatures## a _) == + x@(VkPhysicalDeviceFeatures## b _) = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkPhysicalDeviceFeatures where + (VkPhysicalDeviceFeatures## a _) `compare` + x@(VkPhysicalDeviceFeatures## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkPhysicalDeviceFeatures where + sizeOf ~_ = #{size VkPhysicalDeviceFeatures} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkPhysicalDeviceFeatures} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkPhysicalDeviceFeatures where + unsafeAddr (VkPhysicalDeviceFeatures## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkPhysicalDeviceFeatures## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkPhysicalDeviceFeatures## (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkPhysicalDeviceFeatures where + type StructFields VkPhysicalDeviceFeatures = + '["robustBufferAccess", "fullDrawIndexUint32", "imageCubeArray", -- ' closing tick for hsc2hs + "independentBlend", "geometryShader", "tessellationShader", + "sampleRateShading", "dualSrcBlend", "logicOp", + "multiDrawIndirect", "drawIndirectFirstInstance", "depthClamp", + "depthBiasClamp", "fillModeNonSolid", "depthBounds", "wideLines", + "largePoints", "alphaToOne", "multiViewport", "samplerAnisotropy", + "textureCompressionETC2", "textureCompressionASTC_LDR", + "textureCompressionBC", "occlusionQueryPrecise", + "pipelineStatisticsQuery", "vertexPipelineStoresAndAtomics", + "fragmentStoresAndAtomics", + "shaderTessellationAndGeometryPointSize", + "shaderImageGatherExtended", "shaderStorageImageExtendedFormats", + "shaderStorageImageMultisample", + "shaderStorageImageReadWithoutFormat", + "shaderStorageImageWriteWithoutFormat", + "shaderUniformBufferArrayDynamicIndexing", + "shaderSampledImageArrayDynamicIndexing", + "shaderStorageBufferArrayDynamicIndexing", + "shaderStorageImageArrayDynamicIndexing", "shaderClipDistance", + "shaderCullDistance", "shaderFloat64", "shaderInt64", + "shaderInt16", "shaderResourceResidency", "shaderResourceMinLod", + "sparseBinding", "sparseResidencyBuffer", "sparseResidencyImage2D", + "sparseResidencyImage3D", "sparseResidency2Samples", + "sparseResidency4Samples", "sparseResidency8Samples", + "sparseResidency16Samples", "sparseResidencyAliased", + "variableMultisampleRate", "inheritedQueries"] + type CUnionType VkPhysicalDeviceFeatures = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkPhysicalDeviceFeatures = 'False -- ' closing tick for hsc2hs + type StructExtends VkPhysicalDeviceFeatures = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkRobustBufferAccess VkPhysicalDeviceFeatures where + type VkRobustBufferAccessMType VkPhysicalDeviceFeatures = VkBool32 + + {-# NOINLINE vkRobustBufferAccess #-} + vkRobustBufferAccess x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceFeatures, robustBufferAccess}) + + {-# INLINE vkRobustBufferAccessByteOffset #-} + vkRobustBufferAccessByteOffset ~_ + = #{offset VkPhysicalDeviceFeatures, robustBufferAccess} + + {-# INLINE readVkRobustBufferAccess #-} + readVkRobustBufferAccess p + = peekByteOff p #{offset VkPhysicalDeviceFeatures, robustBufferAccess} + + {-# INLINE writeVkRobustBufferAccess #-} + writeVkRobustBufferAccess p + = pokeByteOff p #{offset VkPhysicalDeviceFeatures, robustBufferAccess} + +instance {-# OVERLAPPING #-} + HasField "robustBufferAccess" VkPhysicalDeviceFeatures where + type FieldType "robustBufferAccess" VkPhysicalDeviceFeatures = + VkBool32 + type FieldOptional "robustBufferAccess" VkPhysicalDeviceFeatures = + 'False -- ' closing tick for hsc2hs + type FieldOffset "robustBufferAccess" VkPhysicalDeviceFeatures = + #{offset VkPhysicalDeviceFeatures, robustBufferAccess} + type FieldIsArray "robustBufferAccess" VkPhysicalDeviceFeatures = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceFeatures, robustBufferAccess} + +instance CanReadField "robustBufferAccess" VkPhysicalDeviceFeatures + where + {-# INLINE getField #-} + getField = vkRobustBufferAccess + + {-# INLINE readField #-} + readField = readVkRobustBufferAccess + +instance CanWriteField "robustBufferAccess" + VkPhysicalDeviceFeatures + where + {-# INLINE writeField #-} + writeField = writeVkRobustBufferAccess + +instance {-# OVERLAPPING #-} + HasVkFullDrawIndexUint32 VkPhysicalDeviceFeatures where + type VkFullDrawIndexUint32MType VkPhysicalDeviceFeatures = VkBool32 + + {-# NOINLINE vkFullDrawIndexUint32 #-} + vkFullDrawIndexUint32 x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceFeatures, fullDrawIndexUint32}) + + {-# INLINE vkFullDrawIndexUint32ByteOffset #-} + vkFullDrawIndexUint32ByteOffset ~_ + = #{offset VkPhysicalDeviceFeatures, fullDrawIndexUint32} + + {-# INLINE readVkFullDrawIndexUint32 #-} + readVkFullDrawIndexUint32 p + = peekByteOff p #{offset VkPhysicalDeviceFeatures, fullDrawIndexUint32} + + {-# INLINE writeVkFullDrawIndexUint32 #-} + writeVkFullDrawIndexUint32 p + = pokeByteOff p #{offset VkPhysicalDeviceFeatures, fullDrawIndexUint32} + +instance {-# OVERLAPPING #-} + HasField "fullDrawIndexUint32" VkPhysicalDeviceFeatures where + type FieldType "fullDrawIndexUint32" VkPhysicalDeviceFeatures = + VkBool32 + type FieldOptional "fullDrawIndexUint32" VkPhysicalDeviceFeatures = + 'False -- ' closing tick for hsc2hs + type FieldOffset "fullDrawIndexUint32" VkPhysicalDeviceFeatures = + #{offset VkPhysicalDeviceFeatures, fullDrawIndexUint32} + type FieldIsArray "fullDrawIndexUint32" VkPhysicalDeviceFeatures = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceFeatures, fullDrawIndexUint32} + +instance CanReadField "fullDrawIndexUint32" + VkPhysicalDeviceFeatures + where + {-# INLINE getField #-} + getField = vkFullDrawIndexUint32 + + {-# INLINE readField #-} + readField = readVkFullDrawIndexUint32 + +instance CanWriteField "fullDrawIndexUint32" + VkPhysicalDeviceFeatures + where + {-# INLINE writeField #-} + writeField = writeVkFullDrawIndexUint32 + +instance {-# OVERLAPPING #-} + HasVkImageCubeArray VkPhysicalDeviceFeatures where + type VkImageCubeArrayMType VkPhysicalDeviceFeatures = VkBool32 + + {-# NOINLINE vkImageCubeArray #-} + vkImageCubeArray x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceFeatures, imageCubeArray}) + + {-# INLINE vkImageCubeArrayByteOffset #-} + vkImageCubeArrayByteOffset ~_ + = #{offset VkPhysicalDeviceFeatures, imageCubeArray} + + {-# INLINE readVkImageCubeArray #-} + readVkImageCubeArray p + = peekByteOff p #{offset VkPhysicalDeviceFeatures, imageCubeArray} + + {-# INLINE writeVkImageCubeArray #-} + writeVkImageCubeArray p + = pokeByteOff p #{offset VkPhysicalDeviceFeatures, imageCubeArray} + +instance {-# OVERLAPPING #-} + HasField "imageCubeArray" VkPhysicalDeviceFeatures where + type FieldType "imageCubeArray" VkPhysicalDeviceFeatures = VkBool32 + type FieldOptional "imageCubeArray" VkPhysicalDeviceFeatures = + 'False -- ' closing tick for hsc2hs + type FieldOffset "imageCubeArray" VkPhysicalDeviceFeatures = + #{offset VkPhysicalDeviceFeatures, imageCubeArray} + type FieldIsArray "imageCubeArray" VkPhysicalDeviceFeatures = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceFeatures, imageCubeArray} + +instance CanReadField "imageCubeArray" VkPhysicalDeviceFeatures + where + {-# INLINE getField #-} + getField = vkImageCubeArray + + {-# INLINE readField #-} + readField = readVkImageCubeArray + +instance CanWriteField "imageCubeArray" VkPhysicalDeviceFeatures + where + {-# INLINE writeField #-} + writeField = writeVkImageCubeArray + +instance {-# OVERLAPPING #-} + HasVkIndependentBlend VkPhysicalDeviceFeatures where + type VkIndependentBlendMType VkPhysicalDeviceFeatures = VkBool32 + + {-# NOINLINE vkIndependentBlend #-} + vkIndependentBlend x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceFeatures, independentBlend}) + + {-# INLINE vkIndependentBlendByteOffset #-} + vkIndependentBlendByteOffset ~_ + = #{offset VkPhysicalDeviceFeatures, independentBlend} + + {-# INLINE readVkIndependentBlend #-} + readVkIndependentBlend p + = peekByteOff p #{offset VkPhysicalDeviceFeatures, independentBlend} + + {-# INLINE writeVkIndependentBlend #-} + writeVkIndependentBlend p + = pokeByteOff p #{offset VkPhysicalDeviceFeatures, independentBlend} + +instance {-# OVERLAPPING #-} + HasField "independentBlend" VkPhysicalDeviceFeatures where + type FieldType "independentBlend" VkPhysicalDeviceFeatures = + VkBool32 + type FieldOptional "independentBlend" VkPhysicalDeviceFeatures = + 'False -- ' closing tick for hsc2hs + type FieldOffset "independentBlend" VkPhysicalDeviceFeatures = + #{offset VkPhysicalDeviceFeatures, independentBlend} + type FieldIsArray "independentBlend" VkPhysicalDeviceFeatures = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceFeatures, independentBlend} + +instance CanReadField "independentBlend" VkPhysicalDeviceFeatures + where + {-# INLINE getField #-} + getField = vkIndependentBlend + + {-# INLINE readField #-} + readField = readVkIndependentBlend + +instance CanWriteField "independentBlend" VkPhysicalDeviceFeatures + where + {-# INLINE writeField #-} + writeField = writeVkIndependentBlend + +instance {-# OVERLAPPING #-} + HasVkGeometryShader VkPhysicalDeviceFeatures where + type VkGeometryShaderMType VkPhysicalDeviceFeatures = VkBool32 + + {-# NOINLINE vkGeometryShader #-} + vkGeometryShader x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceFeatures, geometryShader}) + + {-# INLINE vkGeometryShaderByteOffset #-} + vkGeometryShaderByteOffset ~_ + = #{offset VkPhysicalDeviceFeatures, geometryShader} + + {-# INLINE readVkGeometryShader #-} + readVkGeometryShader p + = peekByteOff p #{offset VkPhysicalDeviceFeatures, geometryShader} + + {-# INLINE writeVkGeometryShader #-} + writeVkGeometryShader p + = pokeByteOff p #{offset VkPhysicalDeviceFeatures, geometryShader} + +instance {-# OVERLAPPING #-} + HasField "geometryShader" VkPhysicalDeviceFeatures where + type FieldType "geometryShader" VkPhysicalDeviceFeatures = VkBool32 + type FieldOptional "geometryShader" VkPhysicalDeviceFeatures = + 'False -- ' closing tick for hsc2hs + type FieldOffset "geometryShader" VkPhysicalDeviceFeatures = + #{offset VkPhysicalDeviceFeatures, geometryShader} + type FieldIsArray "geometryShader" VkPhysicalDeviceFeatures = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceFeatures, geometryShader} + +instance CanReadField "geometryShader" VkPhysicalDeviceFeatures + where + {-# INLINE getField #-} + getField = vkGeometryShader + + {-# INLINE readField #-} + readField = readVkGeometryShader + +instance CanWriteField "geometryShader" VkPhysicalDeviceFeatures + where + {-# INLINE writeField #-} + writeField = writeVkGeometryShader + +instance {-# OVERLAPPING #-} + HasVkTessellationShader VkPhysicalDeviceFeatures where + type VkTessellationShaderMType VkPhysicalDeviceFeatures = VkBool32 + + {-# NOINLINE vkTessellationShader #-} + vkTessellationShader x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceFeatures, tessellationShader}) + + {-# INLINE vkTessellationShaderByteOffset #-} + vkTessellationShaderByteOffset ~_ + = #{offset VkPhysicalDeviceFeatures, tessellationShader} + + {-# INLINE readVkTessellationShader #-} + readVkTessellationShader p + = peekByteOff p #{offset VkPhysicalDeviceFeatures, tessellationShader} + + {-# INLINE writeVkTessellationShader #-} + writeVkTessellationShader p + = pokeByteOff p #{offset VkPhysicalDeviceFeatures, tessellationShader} + +instance {-# OVERLAPPING #-} + HasField "tessellationShader" VkPhysicalDeviceFeatures where + type FieldType "tessellationShader" VkPhysicalDeviceFeatures = + VkBool32 + type FieldOptional "tessellationShader" VkPhysicalDeviceFeatures = + 'False -- ' closing tick for hsc2hs + type FieldOffset "tessellationShader" VkPhysicalDeviceFeatures = + #{offset VkPhysicalDeviceFeatures, tessellationShader} + type FieldIsArray "tessellationShader" VkPhysicalDeviceFeatures = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceFeatures, tessellationShader} + +instance CanReadField "tessellationShader" VkPhysicalDeviceFeatures + where + {-# INLINE getField #-} + getField = vkTessellationShader + + {-# INLINE readField #-} + readField = readVkTessellationShader + +instance CanWriteField "tessellationShader" + VkPhysicalDeviceFeatures + where + {-# INLINE writeField #-} + writeField = writeVkTessellationShader + +instance {-# OVERLAPPING #-} + HasVkSampleRateShading VkPhysicalDeviceFeatures where + type VkSampleRateShadingMType VkPhysicalDeviceFeatures = VkBool32 + + {-# NOINLINE vkSampleRateShading #-} + vkSampleRateShading x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceFeatures, sampleRateShading}) + + {-# INLINE vkSampleRateShadingByteOffset #-} + vkSampleRateShadingByteOffset ~_ + = #{offset VkPhysicalDeviceFeatures, sampleRateShading} + + {-# INLINE readVkSampleRateShading #-} + readVkSampleRateShading p + = peekByteOff p #{offset VkPhysicalDeviceFeatures, sampleRateShading} + + {-# INLINE writeVkSampleRateShading #-} + writeVkSampleRateShading p + = pokeByteOff p #{offset VkPhysicalDeviceFeatures, sampleRateShading} + +instance {-# OVERLAPPING #-} + HasField "sampleRateShading" VkPhysicalDeviceFeatures where + type FieldType "sampleRateShading" VkPhysicalDeviceFeatures = + VkBool32 + type FieldOptional "sampleRateShading" VkPhysicalDeviceFeatures = + 'False -- ' closing tick for hsc2hs + type FieldOffset "sampleRateShading" VkPhysicalDeviceFeatures = + #{offset VkPhysicalDeviceFeatures, sampleRateShading} + type FieldIsArray "sampleRateShading" VkPhysicalDeviceFeatures = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceFeatures, sampleRateShading} + +instance CanReadField "sampleRateShading" VkPhysicalDeviceFeatures + where + {-# INLINE getField #-} + getField = vkSampleRateShading + + {-# INLINE readField #-} + readField = readVkSampleRateShading + +instance CanWriteField "sampleRateShading" VkPhysicalDeviceFeatures + where + {-# INLINE writeField #-} + writeField = writeVkSampleRateShading + +instance {-# OVERLAPPING #-} + HasVkDualSrcBlend VkPhysicalDeviceFeatures where + type VkDualSrcBlendMType VkPhysicalDeviceFeatures = VkBool32 + + {-# NOINLINE vkDualSrcBlend #-} + vkDualSrcBlend x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceFeatures, dualSrcBlend}) + + {-# INLINE vkDualSrcBlendByteOffset #-} + vkDualSrcBlendByteOffset ~_ + = #{offset VkPhysicalDeviceFeatures, dualSrcBlend} + + {-# INLINE readVkDualSrcBlend #-} + readVkDualSrcBlend p + = peekByteOff p #{offset VkPhysicalDeviceFeatures, dualSrcBlend} + + {-# INLINE writeVkDualSrcBlend #-} + writeVkDualSrcBlend p + = pokeByteOff p #{offset VkPhysicalDeviceFeatures, dualSrcBlend} + +instance {-# OVERLAPPING #-} + HasField "dualSrcBlend" VkPhysicalDeviceFeatures where + type FieldType "dualSrcBlend" VkPhysicalDeviceFeatures = VkBool32 + type FieldOptional "dualSrcBlend" VkPhysicalDeviceFeatures = 'False -- ' closing tick for hsc2hs + type FieldOffset "dualSrcBlend" VkPhysicalDeviceFeatures = + #{offset VkPhysicalDeviceFeatures, dualSrcBlend} + type FieldIsArray "dualSrcBlend" VkPhysicalDeviceFeatures = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceFeatures, dualSrcBlend} + +instance CanReadField "dualSrcBlend" VkPhysicalDeviceFeatures where + {-# INLINE getField #-} + getField = vkDualSrcBlend + + {-# INLINE readField #-} + readField = readVkDualSrcBlend + +instance CanWriteField "dualSrcBlend" VkPhysicalDeviceFeatures + where + {-# INLINE writeField #-} + writeField = writeVkDualSrcBlend + +instance {-# OVERLAPPING #-} HasVkLogicOp VkPhysicalDeviceFeatures + where + type VkLogicOpMType VkPhysicalDeviceFeatures = VkBool32 + + {-# NOINLINE vkLogicOp #-} + vkLogicOp x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceFeatures, logicOp}) + + {-# INLINE vkLogicOpByteOffset #-} + vkLogicOpByteOffset ~_ + = #{offset VkPhysicalDeviceFeatures, logicOp} + + {-# INLINE readVkLogicOp #-} + readVkLogicOp p + = peekByteOff p #{offset VkPhysicalDeviceFeatures, logicOp} + + {-# INLINE writeVkLogicOp #-} + writeVkLogicOp p + = pokeByteOff p #{offset VkPhysicalDeviceFeatures, logicOp} + +instance {-# OVERLAPPING #-} + HasField "logicOp" VkPhysicalDeviceFeatures where + type FieldType "logicOp" VkPhysicalDeviceFeatures = VkBool32 + type FieldOptional "logicOp" VkPhysicalDeviceFeatures = 'False -- ' closing tick for hsc2hs + type FieldOffset "logicOp" VkPhysicalDeviceFeatures = + #{offset VkPhysicalDeviceFeatures, logicOp} + type FieldIsArray "logicOp" VkPhysicalDeviceFeatures = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceFeatures, logicOp} + +instance CanReadField "logicOp" VkPhysicalDeviceFeatures where + {-# INLINE getField #-} + getField = vkLogicOp + + {-# INLINE readField #-} + readField = readVkLogicOp + +instance CanWriteField "logicOp" VkPhysicalDeviceFeatures where + {-# INLINE writeField #-} + writeField = writeVkLogicOp + +instance {-# OVERLAPPING #-} + HasVkMultiDrawIndirect VkPhysicalDeviceFeatures where + type VkMultiDrawIndirectMType VkPhysicalDeviceFeatures = VkBool32 + + {-# NOINLINE vkMultiDrawIndirect #-} + vkMultiDrawIndirect x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceFeatures, multiDrawIndirect}) + + {-# INLINE vkMultiDrawIndirectByteOffset #-} + vkMultiDrawIndirectByteOffset ~_ + = #{offset VkPhysicalDeviceFeatures, multiDrawIndirect} + + {-# INLINE readVkMultiDrawIndirect #-} + readVkMultiDrawIndirect p + = peekByteOff p #{offset VkPhysicalDeviceFeatures, multiDrawIndirect} + + {-# INLINE writeVkMultiDrawIndirect #-} + writeVkMultiDrawIndirect p + = pokeByteOff p #{offset VkPhysicalDeviceFeatures, multiDrawIndirect} + +instance {-# OVERLAPPING #-} + HasField "multiDrawIndirect" VkPhysicalDeviceFeatures where + type FieldType "multiDrawIndirect" VkPhysicalDeviceFeatures = + VkBool32 + type FieldOptional "multiDrawIndirect" VkPhysicalDeviceFeatures = + 'False -- ' closing tick for hsc2hs + type FieldOffset "multiDrawIndirect" VkPhysicalDeviceFeatures = + #{offset VkPhysicalDeviceFeatures, multiDrawIndirect} + type FieldIsArray "multiDrawIndirect" VkPhysicalDeviceFeatures = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceFeatures, multiDrawIndirect} + +instance CanReadField "multiDrawIndirect" VkPhysicalDeviceFeatures + where + {-# INLINE getField #-} + getField = vkMultiDrawIndirect + + {-# INLINE readField #-} + readField = readVkMultiDrawIndirect + +instance CanWriteField "multiDrawIndirect" VkPhysicalDeviceFeatures + where + {-# INLINE writeField #-} + writeField = writeVkMultiDrawIndirect + +instance {-# OVERLAPPING #-} + HasVkDrawIndirectFirstInstance VkPhysicalDeviceFeatures where + type VkDrawIndirectFirstInstanceMType VkPhysicalDeviceFeatures = + VkBool32 + + {-# NOINLINE vkDrawIndirectFirstInstance #-} + vkDrawIndirectFirstInstance x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceFeatures, drawIndirectFirstInstance}) + + {-# INLINE vkDrawIndirectFirstInstanceByteOffset #-} + vkDrawIndirectFirstInstanceByteOffset ~_ + = #{offset VkPhysicalDeviceFeatures, drawIndirectFirstInstance} + + {-# INLINE readVkDrawIndirectFirstInstance #-} + readVkDrawIndirectFirstInstance p + = peekByteOff p #{offset VkPhysicalDeviceFeatures, drawIndirectFirstInstance} + + {-# INLINE writeVkDrawIndirectFirstInstance #-} + writeVkDrawIndirectFirstInstance p + = pokeByteOff p #{offset VkPhysicalDeviceFeatures, drawIndirectFirstInstance} + +instance {-# OVERLAPPING #-} + HasField "drawIndirectFirstInstance" VkPhysicalDeviceFeatures where + type FieldType "drawIndirectFirstInstance" VkPhysicalDeviceFeatures + = VkBool32 + type FieldOptional "drawIndirectFirstInstance" + VkPhysicalDeviceFeatures + = 'False -- ' closing tick for hsc2hs + type FieldOffset "drawIndirectFirstInstance" + VkPhysicalDeviceFeatures + = + #{offset VkPhysicalDeviceFeatures, drawIndirectFirstInstance} + type FieldIsArray "drawIndirectFirstInstance" + VkPhysicalDeviceFeatures + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceFeatures, drawIndirectFirstInstance} + +instance CanReadField "drawIndirectFirstInstance" + VkPhysicalDeviceFeatures + where + {-# INLINE getField #-} + getField = vkDrawIndirectFirstInstance + + {-# INLINE readField #-} + readField = readVkDrawIndirectFirstInstance + +instance CanWriteField "drawIndirectFirstInstance" + VkPhysicalDeviceFeatures + where + {-# INLINE writeField #-} + writeField = writeVkDrawIndirectFirstInstance + +instance {-# OVERLAPPING #-} + HasVkDepthClamp VkPhysicalDeviceFeatures where + type VkDepthClampMType VkPhysicalDeviceFeatures = VkBool32 + + {-# NOINLINE vkDepthClamp #-} + vkDepthClamp x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceFeatures, depthClamp}) + + {-# INLINE vkDepthClampByteOffset #-} + vkDepthClampByteOffset ~_ + = #{offset VkPhysicalDeviceFeatures, depthClamp} + + {-# INLINE readVkDepthClamp #-} + readVkDepthClamp p + = peekByteOff p #{offset VkPhysicalDeviceFeatures, depthClamp} + + {-# INLINE writeVkDepthClamp #-} + writeVkDepthClamp p + = pokeByteOff p #{offset VkPhysicalDeviceFeatures, depthClamp} + +instance {-# OVERLAPPING #-} + HasField "depthClamp" VkPhysicalDeviceFeatures where + type FieldType "depthClamp" VkPhysicalDeviceFeatures = VkBool32 + type FieldOptional "depthClamp" VkPhysicalDeviceFeatures = 'False -- ' closing tick for hsc2hs + type FieldOffset "depthClamp" VkPhysicalDeviceFeatures = + #{offset VkPhysicalDeviceFeatures, depthClamp} + type FieldIsArray "depthClamp" VkPhysicalDeviceFeatures = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceFeatures, depthClamp} + +instance CanReadField "depthClamp" VkPhysicalDeviceFeatures where + {-# INLINE getField #-} + getField = vkDepthClamp + + {-# INLINE readField #-} + readField = readVkDepthClamp + +instance CanWriteField "depthClamp" VkPhysicalDeviceFeatures where + {-# INLINE writeField #-} + writeField = writeVkDepthClamp + +instance {-# OVERLAPPING #-} + HasVkDepthBiasClamp VkPhysicalDeviceFeatures where + type VkDepthBiasClampMType VkPhysicalDeviceFeatures = VkBool32 + + {-# NOINLINE vkDepthBiasClamp #-} + vkDepthBiasClamp x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceFeatures, depthBiasClamp}) + + {-# INLINE vkDepthBiasClampByteOffset #-} + vkDepthBiasClampByteOffset ~_ + = #{offset VkPhysicalDeviceFeatures, depthBiasClamp} + + {-# INLINE readVkDepthBiasClamp #-} + readVkDepthBiasClamp p + = peekByteOff p #{offset VkPhysicalDeviceFeatures, depthBiasClamp} + + {-# INLINE writeVkDepthBiasClamp #-} + writeVkDepthBiasClamp p + = pokeByteOff p #{offset VkPhysicalDeviceFeatures, depthBiasClamp} + +instance {-# OVERLAPPING #-} + HasField "depthBiasClamp" VkPhysicalDeviceFeatures where + type FieldType "depthBiasClamp" VkPhysicalDeviceFeatures = VkBool32 + type FieldOptional "depthBiasClamp" VkPhysicalDeviceFeatures = + 'False -- ' closing tick for hsc2hs + type FieldOffset "depthBiasClamp" VkPhysicalDeviceFeatures = + #{offset VkPhysicalDeviceFeatures, depthBiasClamp} + type FieldIsArray "depthBiasClamp" VkPhysicalDeviceFeatures = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceFeatures, depthBiasClamp} + +instance CanReadField "depthBiasClamp" VkPhysicalDeviceFeatures + where + {-# INLINE getField #-} + getField = vkDepthBiasClamp + + {-# INLINE readField #-} + readField = readVkDepthBiasClamp + +instance CanWriteField "depthBiasClamp" VkPhysicalDeviceFeatures + where + {-# INLINE writeField #-} + writeField = writeVkDepthBiasClamp + +instance {-# OVERLAPPING #-} + HasVkFillModeNonSolid VkPhysicalDeviceFeatures where + type VkFillModeNonSolidMType VkPhysicalDeviceFeatures = VkBool32 + + {-# NOINLINE vkFillModeNonSolid #-} + vkFillModeNonSolid x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceFeatures, fillModeNonSolid}) + + {-# INLINE vkFillModeNonSolidByteOffset #-} + vkFillModeNonSolidByteOffset ~_ + = #{offset VkPhysicalDeviceFeatures, fillModeNonSolid} + + {-# INLINE readVkFillModeNonSolid #-} + readVkFillModeNonSolid p + = peekByteOff p #{offset VkPhysicalDeviceFeatures, fillModeNonSolid} + + {-# INLINE writeVkFillModeNonSolid #-} + writeVkFillModeNonSolid p + = pokeByteOff p #{offset VkPhysicalDeviceFeatures, fillModeNonSolid} + +instance {-# OVERLAPPING #-} + HasField "fillModeNonSolid" VkPhysicalDeviceFeatures where + type FieldType "fillModeNonSolid" VkPhysicalDeviceFeatures = + VkBool32 + type FieldOptional "fillModeNonSolid" VkPhysicalDeviceFeatures = + 'False -- ' closing tick for hsc2hs + type FieldOffset "fillModeNonSolid" VkPhysicalDeviceFeatures = + #{offset VkPhysicalDeviceFeatures, fillModeNonSolid} + type FieldIsArray "fillModeNonSolid" VkPhysicalDeviceFeatures = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceFeatures, fillModeNonSolid} + +instance CanReadField "fillModeNonSolid" VkPhysicalDeviceFeatures + where + {-# INLINE getField #-} + getField = vkFillModeNonSolid + + {-# INLINE readField #-} + readField = readVkFillModeNonSolid + +instance CanWriteField "fillModeNonSolid" VkPhysicalDeviceFeatures + where + {-# INLINE writeField #-} + writeField = writeVkFillModeNonSolid + +instance {-# OVERLAPPING #-} + HasVkDepthBounds VkPhysicalDeviceFeatures where + type VkDepthBoundsMType VkPhysicalDeviceFeatures = VkBool32 + + {-# NOINLINE vkDepthBounds #-} + vkDepthBounds x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceFeatures, depthBounds}) + + {-# INLINE vkDepthBoundsByteOffset #-} + vkDepthBoundsByteOffset ~_ + = #{offset VkPhysicalDeviceFeatures, depthBounds} + + {-# INLINE readVkDepthBounds #-} + readVkDepthBounds p + = peekByteOff p #{offset VkPhysicalDeviceFeatures, depthBounds} + + {-# INLINE writeVkDepthBounds #-} + writeVkDepthBounds p + = pokeByteOff p #{offset VkPhysicalDeviceFeatures, depthBounds} + +instance {-# OVERLAPPING #-} + HasField "depthBounds" VkPhysicalDeviceFeatures where + type FieldType "depthBounds" VkPhysicalDeviceFeatures = VkBool32 + type FieldOptional "depthBounds" VkPhysicalDeviceFeatures = 'False -- ' closing tick for hsc2hs + type FieldOffset "depthBounds" VkPhysicalDeviceFeatures = + #{offset VkPhysicalDeviceFeatures, depthBounds} + type FieldIsArray "depthBounds" VkPhysicalDeviceFeatures = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceFeatures, depthBounds} + +instance CanReadField "depthBounds" VkPhysicalDeviceFeatures where + {-# INLINE getField #-} + getField = vkDepthBounds + + {-# INLINE readField #-} + readField = readVkDepthBounds + +instance CanWriteField "depthBounds" VkPhysicalDeviceFeatures where + {-# INLINE writeField #-} + writeField = writeVkDepthBounds + +instance {-# OVERLAPPING #-} + HasVkWideLines VkPhysicalDeviceFeatures where + type VkWideLinesMType VkPhysicalDeviceFeatures = VkBool32 + + {-# NOINLINE vkWideLines #-} + vkWideLines x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceFeatures, wideLines}) + + {-# INLINE vkWideLinesByteOffset #-} + vkWideLinesByteOffset ~_ + = #{offset VkPhysicalDeviceFeatures, wideLines} + + {-# INLINE readVkWideLines #-} + readVkWideLines p + = peekByteOff p #{offset VkPhysicalDeviceFeatures, wideLines} + + {-# INLINE writeVkWideLines #-} + writeVkWideLines p + = pokeByteOff p #{offset VkPhysicalDeviceFeatures, wideLines} + +instance {-# OVERLAPPING #-} + HasField "wideLines" VkPhysicalDeviceFeatures where + type FieldType "wideLines" VkPhysicalDeviceFeatures = VkBool32 + type FieldOptional "wideLines" VkPhysicalDeviceFeatures = 'False -- ' closing tick for hsc2hs + type FieldOffset "wideLines" VkPhysicalDeviceFeatures = + #{offset VkPhysicalDeviceFeatures, wideLines} + type FieldIsArray "wideLines" VkPhysicalDeviceFeatures = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceFeatures, wideLines} + +instance CanReadField "wideLines" VkPhysicalDeviceFeatures where + {-# INLINE getField #-} + getField = vkWideLines + + {-# INLINE readField #-} + readField = readVkWideLines + +instance CanWriteField "wideLines" VkPhysicalDeviceFeatures where + {-# INLINE writeField #-} + writeField = writeVkWideLines + +instance {-# OVERLAPPING #-} + HasVkLargePoints VkPhysicalDeviceFeatures where + type VkLargePointsMType VkPhysicalDeviceFeatures = VkBool32 + + {-# NOINLINE vkLargePoints #-} + vkLargePoints x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceFeatures, largePoints}) + + {-# INLINE vkLargePointsByteOffset #-} + vkLargePointsByteOffset ~_ + = #{offset VkPhysicalDeviceFeatures, largePoints} + + {-# INLINE readVkLargePoints #-} + readVkLargePoints p + = peekByteOff p #{offset VkPhysicalDeviceFeatures, largePoints} + + {-# INLINE writeVkLargePoints #-} + writeVkLargePoints p + = pokeByteOff p #{offset VkPhysicalDeviceFeatures, largePoints} + +instance {-# OVERLAPPING #-} + HasField "largePoints" VkPhysicalDeviceFeatures where + type FieldType "largePoints" VkPhysicalDeviceFeatures = VkBool32 + type FieldOptional "largePoints" VkPhysicalDeviceFeatures = 'False -- ' closing tick for hsc2hs + type FieldOffset "largePoints" VkPhysicalDeviceFeatures = + #{offset VkPhysicalDeviceFeatures, largePoints} + type FieldIsArray "largePoints" VkPhysicalDeviceFeatures = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceFeatures, largePoints} + +instance CanReadField "largePoints" VkPhysicalDeviceFeatures where + {-# INLINE getField #-} + getField = vkLargePoints + + {-# INLINE readField #-} + readField = readVkLargePoints + +instance CanWriteField "largePoints" VkPhysicalDeviceFeatures where + {-# INLINE writeField #-} + writeField = writeVkLargePoints + +instance {-# OVERLAPPING #-} + HasVkAlphaToOne VkPhysicalDeviceFeatures where + type VkAlphaToOneMType VkPhysicalDeviceFeatures = VkBool32 + + {-# NOINLINE vkAlphaToOne #-} + vkAlphaToOne x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceFeatures, alphaToOne}) + + {-# INLINE vkAlphaToOneByteOffset #-} + vkAlphaToOneByteOffset ~_ + = #{offset VkPhysicalDeviceFeatures, alphaToOne} + + {-# INLINE readVkAlphaToOne #-} + readVkAlphaToOne p + = peekByteOff p #{offset VkPhysicalDeviceFeatures, alphaToOne} + + {-# INLINE writeVkAlphaToOne #-} + writeVkAlphaToOne p + = pokeByteOff p #{offset VkPhysicalDeviceFeatures, alphaToOne} + +instance {-# OVERLAPPING #-} + HasField "alphaToOne" VkPhysicalDeviceFeatures where + type FieldType "alphaToOne" VkPhysicalDeviceFeatures = VkBool32 + type FieldOptional "alphaToOne" VkPhysicalDeviceFeatures = 'False -- ' closing tick for hsc2hs + type FieldOffset "alphaToOne" VkPhysicalDeviceFeatures = + #{offset VkPhysicalDeviceFeatures, alphaToOne} + type FieldIsArray "alphaToOne" VkPhysicalDeviceFeatures = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceFeatures, alphaToOne} + +instance CanReadField "alphaToOne" VkPhysicalDeviceFeatures where + {-# INLINE getField #-} + getField = vkAlphaToOne + + {-# INLINE readField #-} + readField = readVkAlphaToOne + +instance CanWriteField "alphaToOne" VkPhysicalDeviceFeatures where + {-# INLINE writeField #-} + writeField = writeVkAlphaToOne + +instance {-# OVERLAPPING #-} + HasVkMultiViewport VkPhysicalDeviceFeatures where + type VkMultiViewportMType VkPhysicalDeviceFeatures = VkBool32 + + {-# NOINLINE vkMultiViewport #-} + vkMultiViewport x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceFeatures, multiViewport}) + + {-# INLINE vkMultiViewportByteOffset #-} + vkMultiViewportByteOffset ~_ + = #{offset VkPhysicalDeviceFeatures, multiViewport} + + {-# INLINE readVkMultiViewport #-} + readVkMultiViewport p + = peekByteOff p #{offset VkPhysicalDeviceFeatures, multiViewport} + + {-# INLINE writeVkMultiViewport #-} + writeVkMultiViewport p + = pokeByteOff p #{offset VkPhysicalDeviceFeatures, multiViewport} + +instance {-# OVERLAPPING #-} + HasField "multiViewport" VkPhysicalDeviceFeatures where + type FieldType "multiViewport" VkPhysicalDeviceFeatures = VkBool32 + type FieldOptional "multiViewport" VkPhysicalDeviceFeatures = + 'False -- ' closing tick for hsc2hs + type FieldOffset "multiViewport" VkPhysicalDeviceFeatures = + #{offset VkPhysicalDeviceFeatures, multiViewport} + type FieldIsArray "multiViewport" VkPhysicalDeviceFeatures = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceFeatures, multiViewport} + +instance CanReadField "multiViewport" VkPhysicalDeviceFeatures + where + {-# INLINE getField #-} + getField = vkMultiViewport + + {-# INLINE readField #-} + readField = readVkMultiViewport + +instance CanWriteField "multiViewport" VkPhysicalDeviceFeatures + where + {-# INLINE writeField #-} + writeField = writeVkMultiViewport + +instance {-# OVERLAPPING #-} + HasVkSamplerAnisotropy VkPhysicalDeviceFeatures where + type VkSamplerAnisotropyMType VkPhysicalDeviceFeatures = VkBool32 + + {-# NOINLINE vkSamplerAnisotropy #-} + vkSamplerAnisotropy x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceFeatures, samplerAnisotropy}) + + {-# INLINE vkSamplerAnisotropyByteOffset #-} + vkSamplerAnisotropyByteOffset ~_ + = #{offset VkPhysicalDeviceFeatures, samplerAnisotropy} + + {-# INLINE readVkSamplerAnisotropy #-} + readVkSamplerAnisotropy p + = peekByteOff p #{offset VkPhysicalDeviceFeatures, samplerAnisotropy} + + {-# INLINE writeVkSamplerAnisotropy #-} + writeVkSamplerAnisotropy p + = pokeByteOff p #{offset VkPhysicalDeviceFeatures, samplerAnisotropy} + +instance {-# OVERLAPPING #-} + HasField "samplerAnisotropy" VkPhysicalDeviceFeatures where + type FieldType "samplerAnisotropy" VkPhysicalDeviceFeatures = + VkBool32 + type FieldOptional "samplerAnisotropy" VkPhysicalDeviceFeatures = + 'False -- ' closing tick for hsc2hs + type FieldOffset "samplerAnisotropy" VkPhysicalDeviceFeatures = + #{offset VkPhysicalDeviceFeatures, samplerAnisotropy} + type FieldIsArray "samplerAnisotropy" VkPhysicalDeviceFeatures = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceFeatures, samplerAnisotropy} + +instance CanReadField "samplerAnisotropy" VkPhysicalDeviceFeatures + where + {-# INLINE getField #-} + getField = vkSamplerAnisotropy + + {-# INLINE readField #-} + readField = readVkSamplerAnisotropy + +instance CanWriteField "samplerAnisotropy" VkPhysicalDeviceFeatures + where + {-# INLINE writeField #-} + writeField = writeVkSamplerAnisotropy + +instance {-# OVERLAPPING #-} + HasVkTextureCompressionETC2 VkPhysicalDeviceFeatures where + type VkTextureCompressionETC2MType VkPhysicalDeviceFeatures = + VkBool32 + + {-# NOINLINE vkTextureCompressionETC2 #-} + vkTextureCompressionETC2 x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceFeatures, textureCompressionETC2}) + + {-# INLINE vkTextureCompressionETC2ByteOffset #-} + vkTextureCompressionETC2ByteOffset ~_ + = #{offset VkPhysicalDeviceFeatures, textureCompressionETC2} + + {-# INLINE readVkTextureCompressionETC2 #-} + readVkTextureCompressionETC2 p + = peekByteOff p #{offset VkPhysicalDeviceFeatures, textureCompressionETC2} + + {-# INLINE writeVkTextureCompressionETC2 #-} + writeVkTextureCompressionETC2 p + = pokeByteOff p #{offset VkPhysicalDeviceFeatures, textureCompressionETC2} + +instance {-# OVERLAPPING #-} + HasField "textureCompressionETC2" VkPhysicalDeviceFeatures where + type FieldType "textureCompressionETC2" VkPhysicalDeviceFeatures = + VkBool32 + type FieldOptional "textureCompressionETC2" + VkPhysicalDeviceFeatures + = 'False -- ' closing tick for hsc2hs + type FieldOffset "textureCompressionETC2" VkPhysicalDeviceFeatures + = + #{offset VkPhysicalDeviceFeatures, textureCompressionETC2} + type FieldIsArray "textureCompressionETC2" VkPhysicalDeviceFeatures + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceFeatures, textureCompressionETC2} + +instance CanReadField "textureCompressionETC2" + VkPhysicalDeviceFeatures + where + {-# INLINE getField #-} + getField = vkTextureCompressionETC2 + + {-# INLINE readField #-} + readField = readVkTextureCompressionETC2 + +instance CanWriteField "textureCompressionETC2" + VkPhysicalDeviceFeatures + where + {-# INLINE writeField #-} + writeField = writeVkTextureCompressionETC2 + +instance {-# OVERLAPPING #-} + HasVkTextureCompressionASTC_LDR VkPhysicalDeviceFeatures where + type VkTextureCompressionASTC_LDRMType VkPhysicalDeviceFeatures = + VkBool32 + + {-# NOINLINE vkTextureCompressionASTC_LDR #-} + vkTextureCompressionASTC_LDR x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceFeatures, textureCompressionASTC_LDR}) + + {-# INLINE vkTextureCompressionASTC_LDRByteOffset #-} + vkTextureCompressionASTC_LDRByteOffset ~_ + = #{offset VkPhysicalDeviceFeatures, textureCompressionASTC_LDR} + + {-# INLINE readVkTextureCompressionASTC_LDR #-} + readVkTextureCompressionASTC_LDR p + = peekByteOff p #{offset VkPhysicalDeviceFeatures, textureCompressionASTC_LDR} + + {-# INLINE writeVkTextureCompressionASTC_LDR #-} + writeVkTextureCompressionASTC_LDR p + = pokeByteOff p #{offset VkPhysicalDeviceFeatures, textureCompressionASTC_LDR} + +instance {-# OVERLAPPING #-} + HasField "textureCompressionASTC_LDR" VkPhysicalDeviceFeatures + where + type FieldType "textureCompressionASTC_LDR" + VkPhysicalDeviceFeatures + = VkBool32 + type FieldOptional "textureCompressionASTC_LDR" + VkPhysicalDeviceFeatures + = 'False -- ' closing tick for hsc2hs + type FieldOffset "textureCompressionASTC_LDR" + VkPhysicalDeviceFeatures + = + #{offset VkPhysicalDeviceFeatures, textureCompressionASTC_LDR} + type FieldIsArray "textureCompressionASTC_LDR" + VkPhysicalDeviceFeatures + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceFeatures, textureCompressionASTC_LDR} + +instance CanReadField "textureCompressionASTC_LDR" + VkPhysicalDeviceFeatures + where + {-# INLINE getField #-} + getField = vkTextureCompressionASTC_LDR + + {-# INLINE readField #-} + readField = readVkTextureCompressionASTC_LDR + +instance CanWriteField "textureCompressionASTC_LDR" + VkPhysicalDeviceFeatures + where + {-# INLINE writeField #-} + writeField = writeVkTextureCompressionASTC_LDR + +instance {-# OVERLAPPING #-} + HasVkTextureCompressionBC VkPhysicalDeviceFeatures where + type VkTextureCompressionBCMType VkPhysicalDeviceFeatures = + VkBool32 + + {-# NOINLINE vkTextureCompressionBC #-} + vkTextureCompressionBC x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceFeatures, textureCompressionBC}) + + {-# INLINE vkTextureCompressionBCByteOffset #-} + vkTextureCompressionBCByteOffset ~_ + = #{offset VkPhysicalDeviceFeatures, textureCompressionBC} + + {-# INLINE readVkTextureCompressionBC #-} + readVkTextureCompressionBC p + = peekByteOff p #{offset VkPhysicalDeviceFeatures, textureCompressionBC} + + {-# INLINE writeVkTextureCompressionBC #-} + writeVkTextureCompressionBC p + = pokeByteOff p #{offset VkPhysicalDeviceFeatures, textureCompressionBC} + +instance {-# OVERLAPPING #-} + HasField "textureCompressionBC" VkPhysicalDeviceFeatures where + type FieldType "textureCompressionBC" VkPhysicalDeviceFeatures = + VkBool32 + type FieldOptional "textureCompressionBC" VkPhysicalDeviceFeatures + = 'False -- ' closing tick for hsc2hs + type FieldOffset "textureCompressionBC" VkPhysicalDeviceFeatures = + #{offset VkPhysicalDeviceFeatures, textureCompressionBC} + type FieldIsArray "textureCompressionBC" VkPhysicalDeviceFeatures = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceFeatures, textureCompressionBC} + +instance CanReadField "textureCompressionBC" + VkPhysicalDeviceFeatures + where + {-# INLINE getField #-} + getField = vkTextureCompressionBC + + {-# INLINE readField #-} + readField = readVkTextureCompressionBC + +instance CanWriteField "textureCompressionBC" + VkPhysicalDeviceFeatures + where + {-# INLINE writeField #-} + writeField = writeVkTextureCompressionBC + +instance {-# OVERLAPPING #-} + HasVkOcclusionQueryPrecise VkPhysicalDeviceFeatures where + type VkOcclusionQueryPreciseMType VkPhysicalDeviceFeatures = + VkBool32 + + {-# NOINLINE vkOcclusionQueryPrecise #-} + vkOcclusionQueryPrecise x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceFeatures, occlusionQueryPrecise}) + + {-# INLINE vkOcclusionQueryPreciseByteOffset #-} + vkOcclusionQueryPreciseByteOffset ~_ + = #{offset VkPhysicalDeviceFeatures, occlusionQueryPrecise} + + {-# INLINE readVkOcclusionQueryPrecise #-} + readVkOcclusionQueryPrecise p + = peekByteOff p #{offset VkPhysicalDeviceFeatures, occlusionQueryPrecise} + + {-# INLINE writeVkOcclusionQueryPrecise #-} + writeVkOcclusionQueryPrecise p + = pokeByteOff p #{offset VkPhysicalDeviceFeatures, occlusionQueryPrecise} + +instance {-# OVERLAPPING #-} + HasField "occlusionQueryPrecise" VkPhysicalDeviceFeatures where + type FieldType "occlusionQueryPrecise" VkPhysicalDeviceFeatures = + VkBool32 + type FieldOptional "occlusionQueryPrecise" VkPhysicalDeviceFeatures + = 'False -- ' closing tick for hsc2hs + type FieldOffset "occlusionQueryPrecise" VkPhysicalDeviceFeatures = + #{offset VkPhysicalDeviceFeatures, occlusionQueryPrecise} + type FieldIsArray "occlusionQueryPrecise" VkPhysicalDeviceFeatures + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceFeatures, occlusionQueryPrecise} + +instance CanReadField "occlusionQueryPrecise" + VkPhysicalDeviceFeatures + where + {-# INLINE getField #-} + getField = vkOcclusionQueryPrecise + + {-# INLINE readField #-} + readField = readVkOcclusionQueryPrecise + +instance CanWriteField "occlusionQueryPrecise" + VkPhysicalDeviceFeatures + where + {-# INLINE writeField #-} + writeField = writeVkOcclusionQueryPrecise + +instance {-# OVERLAPPING #-} + HasVkPipelineStatisticsQuery VkPhysicalDeviceFeatures where + type VkPipelineStatisticsQueryMType VkPhysicalDeviceFeatures = + VkBool32 + + {-# NOINLINE vkPipelineStatisticsQuery #-} + vkPipelineStatisticsQuery x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceFeatures, pipelineStatisticsQuery}) + + {-# INLINE vkPipelineStatisticsQueryByteOffset #-} + vkPipelineStatisticsQueryByteOffset ~_ + = #{offset VkPhysicalDeviceFeatures, pipelineStatisticsQuery} + + {-# INLINE readVkPipelineStatisticsQuery #-} + readVkPipelineStatisticsQuery p + = peekByteOff p #{offset VkPhysicalDeviceFeatures, pipelineStatisticsQuery} + + {-# INLINE writeVkPipelineStatisticsQuery #-} + writeVkPipelineStatisticsQuery p + = pokeByteOff p #{offset VkPhysicalDeviceFeatures, pipelineStatisticsQuery} + +instance {-# OVERLAPPING #-} + HasField "pipelineStatisticsQuery" VkPhysicalDeviceFeatures where + type FieldType "pipelineStatisticsQuery" VkPhysicalDeviceFeatures = + VkBool32 + type FieldOptional "pipelineStatisticsQuery" + VkPhysicalDeviceFeatures + = 'False -- ' closing tick for hsc2hs + type FieldOffset "pipelineStatisticsQuery" VkPhysicalDeviceFeatures + = + #{offset VkPhysicalDeviceFeatures, pipelineStatisticsQuery} + type FieldIsArray "pipelineStatisticsQuery" + VkPhysicalDeviceFeatures + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceFeatures, pipelineStatisticsQuery} + +instance CanReadField "pipelineStatisticsQuery" + VkPhysicalDeviceFeatures + where + {-# INLINE getField #-} + getField = vkPipelineStatisticsQuery + + {-# INLINE readField #-} + readField = readVkPipelineStatisticsQuery + +instance CanWriteField "pipelineStatisticsQuery" + VkPhysicalDeviceFeatures + where + {-# INLINE writeField #-} + writeField = writeVkPipelineStatisticsQuery + +instance {-# OVERLAPPING #-} + HasVkVertexPipelineStoresAndAtomics VkPhysicalDeviceFeatures where + type VkVertexPipelineStoresAndAtomicsMType VkPhysicalDeviceFeatures + = VkBool32 + + {-# NOINLINE vkVertexPipelineStoresAndAtomics #-} + vkVertexPipelineStoresAndAtomics x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceFeatures, vertexPipelineStoresAndAtomics}) + + {-# INLINE vkVertexPipelineStoresAndAtomicsByteOffset #-} + vkVertexPipelineStoresAndAtomicsByteOffset ~_ + = #{offset VkPhysicalDeviceFeatures, vertexPipelineStoresAndAtomics} + + {-# INLINE readVkVertexPipelineStoresAndAtomics #-} + readVkVertexPipelineStoresAndAtomics p + = peekByteOff p #{offset VkPhysicalDeviceFeatures, vertexPipelineStoresAndAtomics} + + {-# INLINE writeVkVertexPipelineStoresAndAtomics #-} + writeVkVertexPipelineStoresAndAtomics p + = pokeByteOff p #{offset VkPhysicalDeviceFeatures, vertexPipelineStoresAndAtomics} + +instance {-# OVERLAPPING #-} + HasField "vertexPipelineStoresAndAtomics" VkPhysicalDeviceFeatures + where + type FieldType "vertexPipelineStoresAndAtomics" + VkPhysicalDeviceFeatures + = VkBool32 + type FieldOptional "vertexPipelineStoresAndAtomics" + VkPhysicalDeviceFeatures + = 'False -- ' closing tick for hsc2hs + type FieldOffset "vertexPipelineStoresAndAtomics" + VkPhysicalDeviceFeatures + = + #{offset VkPhysicalDeviceFeatures, vertexPipelineStoresAndAtomics} + type FieldIsArray "vertexPipelineStoresAndAtomics" + VkPhysicalDeviceFeatures + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceFeatures, vertexPipelineStoresAndAtomics} + +instance CanReadField "vertexPipelineStoresAndAtomics" + VkPhysicalDeviceFeatures + where + {-# INLINE getField #-} + getField = vkVertexPipelineStoresAndAtomics + + {-# INLINE readField #-} + readField = readVkVertexPipelineStoresAndAtomics + +instance CanWriteField "vertexPipelineStoresAndAtomics" + VkPhysicalDeviceFeatures + where + {-# INLINE writeField #-} + writeField = writeVkVertexPipelineStoresAndAtomics + +instance {-# OVERLAPPING #-} + HasVkFragmentStoresAndAtomics VkPhysicalDeviceFeatures where + type VkFragmentStoresAndAtomicsMType VkPhysicalDeviceFeatures = + VkBool32 + + {-# NOINLINE vkFragmentStoresAndAtomics #-} + vkFragmentStoresAndAtomics x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceFeatures, fragmentStoresAndAtomics}) + + {-# INLINE vkFragmentStoresAndAtomicsByteOffset #-} + vkFragmentStoresAndAtomicsByteOffset ~_ + = #{offset VkPhysicalDeviceFeatures, fragmentStoresAndAtomics} + + {-# INLINE readVkFragmentStoresAndAtomics #-} + readVkFragmentStoresAndAtomics p + = peekByteOff p #{offset VkPhysicalDeviceFeatures, fragmentStoresAndAtomics} + + {-# INLINE writeVkFragmentStoresAndAtomics #-} + writeVkFragmentStoresAndAtomics p + = pokeByteOff p #{offset VkPhysicalDeviceFeatures, fragmentStoresAndAtomics} + +instance {-# OVERLAPPING #-} + HasField "fragmentStoresAndAtomics" VkPhysicalDeviceFeatures where + type FieldType "fragmentStoresAndAtomics" VkPhysicalDeviceFeatures + = VkBool32 + type FieldOptional "fragmentStoresAndAtomics" + VkPhysicalDeviceFeatures + = 'False -- ' closing tick for hsc2hs + type FieldOffset "fragmentStoresAndAtomics" + VkPhysicalDeviceFeatures + = + #{offset VkPhysicalDeviceFeatures, fragmentStoresAndAtomics} + type FieldIsArray "fragmentStoresAndAtomics" + VkPhysicalDeviceFeatures + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceFeatures, fragmentStoresAndAtomics} + +instance CanReadField "fragmentStoresAndAtomics" + VkPhysicalDeviceFeatures + where + {-# INLINE getField #-} + getField = vkFragmentStoresAndAtomics + + {-# INLINE readField #-} + readField = readVkFragmentStoresAndAtomics + +instance CanWriteField "fragmentStoresAndAtomics" + VkPhysicalDeviceFeatures + where + {-# INLINE writeField #-} + writeField = writeVkFragmentStoresAndAtomics + +instance {-# OVERLAPPING #-} + HasVkShaderTessellationAndGeometryPointSize + VkPhysicalDeviceFeatures + where + type VkShaderTessellationAndGeometryPointSizeMType + VkPhysicalDeviceFeatures + = VkBool32 + + {-# NOINLINE vkShaderTessellationAndGeometryPointSize #-} + vkShaderTessellationAndGeometryPointSize x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceFeatures, shaderTessellationAndGeometryPointSize}) + + {-# INLINE vkShaderTessellationAndGeometryPointSizeByteOffset #-} + vkShaderTessellationAndGeometryPointSizeByteOffset ~_ + = #{offset VkPhysicalDeviceFeatures, shaderTessellationAndGeometryPointSize} + + {-# INLINE readVkShaderTessellationAndGeometryPointSize #-} + readVkShaderTessellationAndGeometryPointSize p + = peekByteOff p #{offset VkPhysicalDeviceFeatures, shaderTessellationAndGeometryPointSize} + + {-# INLINE writeVkShaderTessellationAndGeometryPointSize #-} + writeVkShaderTessellationAndGeometryPointSize p + = pokeByteOff p #{offset VkPhysicalDeviceFeatures, shaderTessellationAndGeometryPointSize} + +instance {-# OVERLAPPING #-} + HasField "shaderTessellationAndGeometryPointSize" + VkPhysicalDeviceFeatures + where + type FieldType "shaderTessellationAndGeometryPointSize" + VkPhysicalDeviceFeatures + = VkBool32 + type FieldOptional "shaderTessellationAndGeometryPointSize" + VkPhysicalDeviceFeatures + = 'False -- ' closing tick for hsc2hs + type FieldOffset "shaderTessellationAndGeometryPointSize" + VkPhysicalDeviceFeatures + = + #{offset VkPhysicalDeviceFeatures, shaderTessellationAndGeometryPointSize} + type FieldIsArray "shaderTessellationAndGeometryPointSize" + VkPhysicalDeviceFeatures + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceFeatures, shaderTessellationAndGeometryPointSize} + +instance CanReadField "shaderTessellationAndGeometryPointSize" + VkPhysicalDeviceFeatures + where + {-# INLINE getField #-} + getField = vkShaderTessellationAndGeometryPointSize + + {-# INLINE readField #-} + readField = readVkShaderTessellationAndGeometryPointSize + +instance CanWriteField "shaderTessellationAndGeometryPointSize" + VkPhysicalDeviceFeatures + where + {-# INLINE writeField #-} + writeField = writeVkShaderTessellationAndGeometryPointSize + +instance {-# OVERLAPPING #-} + HasVkShaderImageGatherExtended VkPhysicalDeviceFeatures where + type VkShaderImageGatherExtendedMType VkPhysicalDeviceFeatures = + VkBool32 + + {-# NOINLINE vkShaderImageGatherExtended #-} + vkShaderImageGatherExtended x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceFeatures, shaderImageGatherExtended}) + + {-# INLINE vkShaderImageGatherExtendedByteOffset #-} + vkShaderImageGatherExtendedByteOffset ~_ + = #{offset VkPhysicalDeviceFeatures, shaderImageGatherExtended} + + {-# INLINE readVkShaderImageGatherExtended #-} + readVkShaderImageGatherExtended p + = peekByteOff p #{offset VkPhysicalDeviceFeatures, shaderImageGatherExtended} + + {-# INLINE writeVkShaderImageGatherExtended #-} + writeVkShaderImageGatherExtended p + = pokeByteOff p #{offset VkPhysicalDeviceFeatures, shaderImageGatherExtended} + +instance {-# OVERLAPPING #-} + HasField "shaderImageGatherExtended" VkPhysicalDeviceFeatures where + type FieldType "shaderImageGatherExtended" VkPhysicalDeviceFeatures + = VkBool32 + type FieldOptional "shaderImageGatherExtended" + VkPhysicalDeviceFeatures + = 'False -- ' closing tick for hsc2hs + type FieldOffset "shaderImageGatherExtended" + VkPhysicalDeviceFeatures + = + #{offset VkPhysicalDeviceFeatures, shaderImageGatherExtended} + type FieldIsArray "shaderImageGatherExtended" + VkPhysicalDeviceFeatures + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceFeatures, shaderImageGatherExtended} + +instance CanReadField "shaderImageGatherExtended" + VkPhysicalDeviceFeatures + where + {-# INLINE getField #-} + getField = vkShaderImageGatherExtended + + {-# INLINE readField #-} + readField = readVkShaderImageGatherExtended + +instance CanWriteField "shaderImageGatherExtended" + VkPhysicalDeviceFeatures + where + {-# INLINE writeField #-} + writeField = writeVkShaderImageGatherExtended + +instance {-# OVERLAPPING #-} + HasVkShaderStorageImageExtendedFormats VkPhysicalDeviceFeatures + where + type VkShaderStorageImageExtendedFormatsMType + VkPhysicalDeviceFeatures + = VkBool32 + + {-# NOINLINE vkShaderStorageImageExtendedFormats #-} + vkShaderStorageImageExtendedFormats x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceFeatures, shaderStorageImageExtendedFormats}) + + {-# INLINE vkShaderStorageImageExtendedFormatsByteOffset #-} + vkShaderStorageImageExtendedFormatsByteOffset ~_ + = #{offset VkPhysicalDeviceFeatures, shaderStorageImageExtendedFormats} + + {-# INLINE readVkShaderStorageImageExtendedFormats #-} + readVkShaderStorageImageExtendedFormats p + = peekByteOff p #{offset VkPhysicalDeviceFeatures, shaderStorageImageExtendedFormats} + + {-# INLINE writeVkShaderStorageImageExtendedFormats #-} + writeVkShaderStorageImageExtendedFormats p + = pokeByteOff p #{offset VkPhysicalDeviceFeatures, shaderStorageImageExtendedFormats} + +instance {-# OVERLAPPING #-} + HasField "shaderStorageImageExtendedFormats" + VkPhysicalDeviceFeatures + where + type FieldType "shaderStorageImageExtendedFormats" + VkPhysicalDeviceFeatures + = VkBool32 + type FieldOptional "shaderStorageImageExtendedFormats" + VkPhysicalDeviceFeatures + = 'False -- ' closing tick for hsc2hs + type FieldOffset "shaderStorageImageExtendedFormats" + VkPhysicalDeviceFeatures + = + #{offset VkPhysicalDeviceFeatures, shaderStorageImageExtendedFormats} + type FieldIsArray "shaderStorageImageExtendedFormats" + VkPhysicalDeviceFeatures + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceFeatures, shaderStorageImageExtendedFormats} + +instance CanReadField "shaderStorageImageExtendedFormats" + VkPhysicalDeviceFeatures + where + {-# INLINE getField #-} + getField = vkShaderStorageImageExtendedFormats + + {-# INLINE readField #-} + readField = readVkShaderStorageImageExtendedFormats + +instance CanWriteField "shaderStorageImageExtendedFormats" + VkPhysicalDeviceFeatures + where + {-# INLINE writeField #-} + writeField = writeVkShaderStorageImageExtendedFormats + +instance {-# OVERLAPPING #-} + HasVkShaderStorageImageMultisample VkPhysicalDeviceFeatures where + type VkShaderStorageImageMultisampleMType VkPhysicalDeviceFeatures + = VkBool32 + + {-# NOINLINE vkShaderStorageImageMultisample #-} + vkShaderStorageImageMultisample x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceFeatures, shaderStorageImageMultisample}) + + {-# INLINE vkShaderStorageImageMultisampleByteOffset #-} + vkShaderStorageImageMultisampleByteOffset ~_ + = #{offset VkPhysicalDeviceFeatures, shaderStorageImageMultisample} + + {-# INLINE readVkShaderStorageImageMultisample #-} + readVkShaderStorageImageMultisample p + = peekByteOff p #{offset VkPhysicalDeviceFeatures, shaderStorageImageMultisample} + + {-# INLINE writeVkShaderStorageImageMultisample #-} + writeVkShaderStorageImageMultisample p + = pokeByteOff p #{offset VkPhysicalDeviceFeatures, shaderStorageImageMultisample} + +instance {-# OVERLAPPING #-} + HasField "shaderStorageImageMultisample" VkPhysicalDeviceFeatures + where + type FieldType "shaderStorageImageMultisample" + VkPhysicalDeviceFeatures + = VkBool32 + type FieldOptional "shaderStorageImageMultisample" + VkPhysicalDeviceFeatures + = 'False -- ' closing tick for hsc2hs + type FieldOffset "shaderStorageImageMultisample" + VkPhysicalDeviceFeatures + = + #{offset VkPhysicalDeviceFeatures, shaderStorageImageMultisample} + type FieldIsArray "shaderStorageImageMultisample" + VkPhysicalDeviceFeatures + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceFeatures, shaderStorageImageMultisample} + +instance CanReadField "shaderStorageImageMultisample" + VkPhysicalDeviceFeatures + where + {-# INLINE getField #-} + getField = vkShaderStorageImageMultisample + + {-# INLINE readField #-} + readField = readVkShaderStorageImageMultisample + +instance CanWriteField "shaderStorageImageMultisample" + VkPhysicalDeviceFeatures + where + {-# INLINE writeField #-} + writeField = writeVkShaderStorageImageMultisample + +instance {-# OVERLAPPING #-} + HasVkShaderStorageImageReadWithoutFormat VkPhysicalDeviceFeatures + where + type VkShaderStorageImageReadWithoutFormatMType + VkPhysicalDeviceFeatures + = VkBool32 + + {-# NOINLINE vkShaderStorageImageReadWithoutFormat #-} + vkShaderStorageImageReadWithoutFormat x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceFeatures, shaderStorageImageReadWithoutFormat}) + + {-# INLINE vkShaderStorageImageReadWithoutFormatByteOffset #-} + vkShaderStorageImageReadWithoutFormatByteOffset ~_ + = #{offset VkPhysicalDeviceFeatures, shaderStorageImageReadWithoutFormat} + + {-# INLINE readVkShaderStorageImageReadWithoutFormat #-} + readVkShaderStorageImageReadWithoutFormat p + = peekByteOff p #{offset VkPhysicalDeviceFeatures, shaderStorageImageReadWithoutFormat} + + {-# INLINE writeVkShaderStorageImageReadWithoutFormat #-} + writeVkShaderStorageImageReadWithoutFormat p + = pokeByteOff p #{offset VkPhysicalDeviceFeatures, shaderStorageImageReadWithoutFormat} + +instance {-# OVERLAPPING #-} + HasField "shaderStorageImageReadWithoutFormat" + VkPhysicalDeviceFeatures + where + type FieldType "shaderStorageImageReadWithoutFormat" + VkPhysicalDeviceFeatures + = VkBool32 + type FieldOptional "shaderStorageImageReadWithoutFormat" + VkPhysicalDeviceFeatures + = 'False -- ' closing tick for hsc2hs + type FieldOffset "shaderStorageImageReadWithoutFormat" + VkPhysicalDeviceFeatures + = + #{offset VkPhysicalDeviceFeatures, shaderStorageImageReadWithoutFormat} + type FieldIsArray "shaderStorageImageReadWithoutFormat" + VkPhysicalDeviceFeatures + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceFeatures, shaderStorageImageReadWithoutFormat} + +instance CanReadField "shaderStorageImageReadWithoutFormat" + VkPhysicalDeviceFeatures + where + {-# INLINE getField #-} + getField = vkShaderStorageImageReadWithoutFormat + + {-# INLINE readField #-} + readField = readVkShaderStorageImageReadWithoutFormat + +instance CanWriteField "shaderStorageImageReadWithoutFormat" + VkPhysicalDeviceFeatures + where + {-# INLINE writeField #-} + writeField = writeVkShaderStorageImageReadWithoutFormat + +instance {-# OVERLAPPING #-} + HasVkShaderStorageImageWriteWithoutFormat VkPhysicalDeviceFeatures + where + type VkShaderStorageImageWriteWithoutFormatMType + VkPhysicalDeviceFeatures + = VkBool32 + + {-# NOINLINE vkShaderStorageImageWriteWithoutFormat #-} + vkShaderStorageImageWriteWithoutFormat x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceFeatures, shaderStorageImageWriteWithoutFormat}) + + {-# INLINE vkShaderStorageImageWriteWithoutFormatByteOffset #-} + vkShaderStorageImageWriteWithoutFormatByteOffset ~_ + = #{offset VkPhysicalDeviceFeatures, shaderStorageImageWriteWithoutFormat} + + {-# INLINE readVkShaderStorageImageWriteWithoutFormat #-} + readVkShaderStorageImageWriteWithoutFormat p + = peekByteOff p #{offset VkPhysicalDeviceFeatures, shaderStorageImageWriteWithoutFormat} + + {-# INLINE writeVkShaderStorageImageWriteWithoutFormat #-} + writeVkShaderStorageImageWriteWithoutFormat p + = pokeByteOff p #{offset VkPhysicalDeviceFeatures, shaderStorageImageWriteWithoutFormat} + +instance {-# OVERLAPPING #-} + HasField "shaderStorageImageWriteWithoutFormat" + VkPhysicalDeviceFeatures + where + type FieldType "shaderStorageImageWriteWithoutFormat" + VkPhysicalDeviceFeatures + = VkBool32 + type FieldOptional "shaderStorageImageWriteWithoutFormat" + VkPhysicalDeviceFeatures + = 'False -- ' closing tick for hsc2hs + type FieldOffset "shaderStorageImageWriteWithoutFormat" + VkPhysicalDeviceFeatures + = + #{offset VkPhysicalDeviceFeatures, shaderStorageImageWriteWithoutFormat} + type FieldIsArray "shaderStorageImageWriteWithoutFormat" + VkPhysicalDeviceFeatures + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceFeatures, shaderStorageImageWriteWithoutFormat} + +instance CanReadField "shaderStorageImageWriteWithoutFormat" + VkPhysicalDeviceFeatures + where + {-# INLINE getField #-} + getField = vkShaderStorageImageWriteWithoutFormat + + {-# INLINE readField #-} + readField = readVkShaderStorageImageWriteWithoutFormat + +instance CanWriteField "shaderStorageImageWriteWithoutFormat" + VkPhysicalDeviceFeatures + where + {-# INLINE writeField #-} + writeField = writeVkShaderStorageImageWriteWithoutFormat + +instance {-# OVERLAPPING #-} + HasVkShaderUniformBufferArrayDynamicIndexing + VkPhysicalDeviceFeatures + where + type VkShaderUniformBufferArrayDynamicIndexingMType + VkPhysicalDeviceFeatures + = VkBool32 + + {-# NOINLINE vkShaderUniformBufferArrayDynamicIndexing #-} + vkShaderUniformBufferArrayDynamicIndexing x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceFeatures, shaderUniformBufferArrayDynamicIndexing}) + + {-# INLINE vkShaderUniformBufferArrayDynamicIndexingByteOffset #-} + vkShaderUniformBufferArrayDynamicIndexingByteOffset ~_ + = #{offset VkPhysicalDeviceFeatures, shaderUniformBufferArrayDynamicIndexing} + + {-# INLINE readVkShaderUniformBufferArrayDynamicIndexing #-} + readVkShaderUniformBufferArrayDynamicIndexing p + = peekByteOff p #{offset VkPhysicalDeviceFeatures, shaderUniformBufferArrayDynamicIndexing} + + {-# INLINE writeVkShaderUniformBufferArrayDynamicIndexing #-} + writeVkShaderUniformBufferArrayDynamicIndexing p + = pokeByteOff p #{offset VkPhysicalDeviceFeatures, shaderUniformBufferArrayDynamicIndexing} + +instance {-# OVERLAPPING #-} + HasField "shaderUniformBufferArrayDynamicIndexing" + VkPhysicalDeviceFeatures + where + type FieldType "shaderUniformBufferArrayDynamicIndexing" + VkPhysicalDeviceFeatures + = VkBool32 + type FieldOptional "shaderUniformBufferArrayDynamicIndexing" + VkPhysicalDeviceFeatures + = 'False -- ' closing tick for hsc2hs + type FieldOffset "shaderUniformBufferArrayDynamicIndexing" + VkPhysicalDeviceFeatures + = + #{offset VkPhysicalDeviceFeatures, shaderUniformBufferArrayDynamicIndexing} + type FieldIsArray "shaderUniformBufferArrayDynamicIndexing" + VkPhysicalDeviceFeatures + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceFeatures, shaderUniformBufferArrayDynamicIndexing} + +instance CanReadField "shaderUniformBufferArrayDynamicIndexing" + VkPhysicalDeviceFeatures + where + {-# INLINE getField #-} + getField = vkShaderUniformBufferArrayDynamicIndexing + + {-# INLINE readField #-} + readField = readVkShaderUniformBufferArrayDynamicIndexing + +instance CanWriteField "shaderUniformBufferArrayDynamicIndexing" + VkPhysicalDeviceFeatures + where + {-# INLINE writeField #-} + writeField = writeVkShaderUniformBufferArrayDynamicIndexing + +instance {-# OVERLAPPING #-} + HasVkShaderSampledImageArrayDynamicIndexing + VkPhysicalDeviceFeatures + where + type VkShaderSampledImageArrayDynamicIndexingMType + VkPhysicalDeviceFeatures + = VkBool32 + + {-# NOINLINE vkShaderSampledImageArrayDynamicIndexing #-} + vkShaderSampledImageArrayDynamicIndexing x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceFeatures, shaderSampledImageArrayDynamicIndexing}) + + {-# INLINE vkShaderSampledImageArrayDynamicIndexingByteOffset #-} + vkShaderSampledImageArrayDynamicIndexingByteOffset ~_ + = #{offset VkPhysicalDeviceFeatures, shaderSampledImageArrayDynamicIndexing} + + {-# INLINE readVkShaderSampledImageArrayDynamicIndexing #-} + readVkShaderSampledImageArrayDynamicIndexing p + = peekByteOff p #{offset VkPhysicalDeviceFeatures, shaderSampledImageArrayDynamicIndexing} + + {-# INLINE writeVkShaderSampledImageArrayDynamicIndexing #-} + writeVkShaderSampledImageArrayDynamicIndexing p + = pokeByteOff p #{offset VkPhysicalDeviceFeatures, shaderSampledImageArrayDynamicIndexing} + +instance {-# OVERLAPPING #-} + HasField "shaderSampledImageArrayDynamicIndexing" + VkPhysicalDeviceFeatures + where + type FieldType "shaderSampledImageArrayDynamicIndexing" + VkPhysicalDeviceFeatures + = VkBool32 + type FieldOptional "shaderSampledImageArrayDynamicIndexing" + VkPhysicalDeviceFeatures + = 'False -- ' closing tick for hsc2hs + type FieldOffset "shaderSampledImageArrayDynamicIndexing" + VkPhysicalDeviceFeatures + = + #{offset VkPhysicalDeviceFeatures, shaderSampledImageArrayDynamicIndexing} + type FieldIsArray "shaderSampledImageArrayDynamicIndexing" + VkPhysicalDeviceFeatures + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceFeatures, shaderSampledImageArrayDynamicIndexing} + +instance CanReadField "shaderSampledImageArrayDynamicIndexing" + VkPhysicalDeviceFeatures + where + {-# INLINE getField #-} + getField = vkShaderSampledImageArrayDynamicIndexing + + {-# INLINE readField #-} + readField = readVkShaderSampledImageArrayDynamicIndexing + +instance CanWriteField "shaderSampledImageArrayDynamicIndexing" + VkPhysicalDeviceFeatures + where + {-# INLINE writeField #-} + writeField = writeVkShaderSampledImageArrayDynamicIndexing + +instance {-# OVERLAPPING #-} + HasVkShaderStorageBufferArrayDynamicIndexing + VkPhysicalDeviceFeatures + where + type VkShaderStorageBufferArrayDynamicIndexingMType + VkPhysicalDeviceFeatures + = VkBool32 + + {-# NOINLINE vkShaderStorageBufferArrayDynamicIndexing #-} + vkShaderStorageBufferArrayDynamicIndexing x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceFeatures, shaderStorageBufferArrayDynamicIndexing}) + + {-# INLINE vkShaderStorageBufferArrayDynamicIndexingByteOffset #-} + vkShaderStorageBufferArrayDynamicIndexingByteOffset ~_ + = #{offset VkPhysicalDeviceFeatures, shaderStorageBufferArrayDynamicIndexing} + + {-# INLINE readVkShaderStorageBufferArrayDynamicIndexing #-} + readVkShaderStorageBufferArrayDynamicIndexing p + = peekByteOff p #{offset VkPhysicalDeviceFeatures, shaderStorageBufferArrayDynamicIndexing} + + {-# INLINE writeVkShaderStorageBufferArrayDynamicIndexing #-} + writeVkShaderStorageBufferArrayDynamicIndexing p + = pokeByteOff p #{offset VkPhysicalDeviceFeatures, shaderStorageBufferArrayDynamicIndexing} + +instance {-# OVERLAPPING #-} + HasField "shaderStorageBufferArrayDynamicIndexing" + VkPhysicalDeviceFeatures + where + type FieldType "shaderStorageBufferArrayDynamicIndexing" + VkPhysicalDeviceFeatures + = VkBool32 + type FieldOptional "shaderStorageBufferArrayDynamicIndexing" + VkPhysicalDeviceFeatures + = 'False -- ' closing tick for hsc2hs + type FieldOffset "shaderStorageBufferArrayDynamicIndexing" + VkPhysicalDeviceFeatures + = + #{offset VkPhysicalDeviceFeatures, shaderStorageBufferArrayDynamicIndexing} + type FieldIsArray "shaderStorageBufferArrayDynamicIndexing" + VkPhysicalDeviceFeatures + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceFeatures, shaderStorageBufferArrayDynamicIndexing} + +instance CanReadField "shaderStorageBufferArrayDynamicIndexing" + VkPhysicalDeviceFeatures + where + {-# INLINE getField #-} + getField = vkShaderStorageBufferArrayDynamicIndexing + + {-# INLINE readField #-} + readField = readVkShaderStorageBufferArrayDynamicIndexing + +instance CanWriteField "shaderStorageBufferArrayDynamicIndexing" + VkPhysicalDeviceFeatures + where + {-# INLINE writeField #-} + writeField = writeVkShaderStorageBufferArrayDynamicIndexing + +instance {-# OVERLAPPING #-} + HasVkShaderStorageImageArrayDynamicIndexing + VkPhysicalDeviceFeatures + where + type VkShaderStorageImageArrayDynamicIndexingMType + VkPhysicalDeviceFeatures + = VkBool32 + + {-# NOINLINE vkShaderStorageImageArrayDynamicIndexing #-} + vkShaderStorageImageArrayDynamicIndexing x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceFeatures, shaderStorageImageArrayDynamicIndexing}) + + {-# INLINE vkShaderStorageImageArrayDynamicIndexingByteOffset #-} + vkShaderStorageImageArrayDynamicIndexingByteOffset ~_ + = #{offset VkPhysicalDeviceFeatures, shaderStorageImageArrayDynamicIndexing} + + {-# INLINE readVkShaderStorageImageArrayDynamicIndexing #-} + readVkShaderStorageImageArrayDynamicIndexing p + = peekByteOff p #{offset VkPhysicalDeviceFeatures, shaderStorageImageArrayDynamicIndexing} + + {-# INLINE writeVkShaderStorageImageArrayDynamicIndexing #-} + writeVkShaderStorageImageArrayDynamicIndexing p + = pokeByteOff p #{offset VkPhysicalDeviceFeatures, shaderStorageImageArrayDynamicIndexing} + +instance {-# OVERLAPPING #-} + HasField "shaderStorageImageArrayDynamicIndexing" + VkPhysicalDeviceFeatures + where + type FieldType "shaderStorageImageArrayDynamicIndexing" + VkPhysicalDeviceFeatures + = VkBool32 + type FieldOptional "shaderStorageImageArrayDynamicIndexing" + VkPhysicalDeviceFeatures + = 'False -- ' closing tick for hsc2hs + type FieldOffset "shaderStorageImageArrayDynamicIndexing" + VkPhysicalDeviceFeatures + = + #{offset VkPhysicalDeviceFeatures, shaderStorageImageArrayDynamicIndexing} + type FieldIsArray "shaderStorageImageArrayDynamicIndexing" + VkPhysicalDeviceFeatures + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceFeatures, shaderStorageImageArrayDynamicIndexing} + +instance CanReadField "shaderStorageImageArrayDynamicIndexing" + VkPhysicalDeviceFeatures + where + {-# INLINE getField #-} + getField = vkShaderStorageImageArrayDynamicIndexing + + {-# INLINE readField #-} + readField = readVkShaderStorageImageArrayDynamicIndexing + +instance CanWriteField "shaderStorageImageArrayDynamicIndexing" + VkPhysicalDeviceFeatures + where + {-# INLINE writeField #-} + writeField = writeVkShaderStorageImageArrayDynamicIndexing + +instance {-# OVERLAPPING #-} + HasVkShaderClipDistance VkPhysicalDeviceFeatures where + type VkShaderClipDistanceMType VkPhysicalDeviceFeatures = VkBool32 + + {-# NOINLINE vkShaderClipDistance #-} + vkShaderClipDistance x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceFeatures, shaderClipDistance}) + + {-# INLINE vkShaderClipDistanceByteOffset #-} + vkShaderClipDistanceByteOffset ~_ + = #{offset VkPhysicalDeviceFeatures, shaderClipDistance} + + {-# INLINE readVkShaderClipDistance #-} + readVkShaderClipDistance p + = peekByteOff p #{offset VkPhysicalDeviceFeatures, shaderClipDistance} + + {-# INLINE writeVkShaderClipDistance #-} + writeVkShaderClipDistance p + = pokeByteOff p #{offset VkPhysicalDeviceFeatures, shaderClipDistance} + +instance {-# OVERLAPPING #-} + HasField "shaderClipDistance" VkPhysicalDeviceFeatures where + type FieldType "shaderClipDistance" VkPhysicalDeviceFeatures = + VkBool32 + type FieldOptional "shaderClipDistance" VkPhysicalDeviceFeatures = + 'False -- ' closing tick for hsc2hs + type FieldOffset "shaderClipDistance" VkPhysicalDeviceFeatures = + #{offset VkPhysicalDeviceFeatures, shaderClipDistance} + type FieldIsArray "shaderClipDistance" VkPhysicalDeviceFeatures = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceFeatures, shaderClipDistance} + +instance CanReadField "shaderClipDistance" VkPhysicalDeviceFeatures + where + {-# INLINE getField #-} + getField = vkShaderClipDistance + + {-# INLINE readField #-} + readField = readVkShaderClipDistance + +instance CanWriteField "shaderClipDistance" + VkPhysicalDeviceFeatures + where + {-# INLINE writeField #-} + writeField = writeVkShaderClipDistance + +instance {-# OVERLAPPING #-} + HasVkShaderCullDistance VkPhysicalDeviceFeatures where + type VkShaderCullDistanceMType VkPhysicalDeviceFeatures = VkBool32 + + {-# NOINLINE vkShaderCullDistance #-} + vkShaderCullDistance x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceFeatures, shaderCullDistance}) + + {-# INLINE vkShaderCullDistanceByteOffset #-} + vkShaderCullDistanceByteOffset ~_ + = #{offset VkPhysicalDeviceFeatures, shaderCullDistance} + + {-# INLINE readVkShaderCullDistance #-} + readVkShaderCullDistance p + = peekByteOff p #{offset VkPhysicalDeviceFeatures, shaderCullDistance} + + {-# INLINE writeVkShaderCullDistance #-} + writeVkShaderCullDistance p + = pokeByteOff p #{offset VkPhysicalDeviceFeatures, shaderCullDistance} + +instance {-# OVERLAPPING #-} + HasField "shaderCullDistance" VkPhysicalDeviceFeatures where + type FieldType "shaderCullDistance" VkPhysicalDeviceFeatures = + VkBool32 + type FieldOptional "shaderCullDistance" VkPhysicalDeviceFeatures = + 'False -- ' closing tick for hsc2hs + type FieldOffset "shaderCullDistance" VkPhysicalDeviceFeatures = + #{offset VkPhysicalDeviceFeatures, shaderCullDistance} + type FieldIsArray "shaderCullDistance" VkPhysicalDeviceFeatures = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceFeatures, shaderCullDistance} + +instance CanReadField "shaderCullDistance" VkPhysicalDeviceFeatures + where + {-# INLINE getField #-} + getField = vkShaderCullDistance + + {-# INLINE readField #-} + readField = readVkShaderCullDistance + +instance CanWriteField "shaderCullDistance" + VkPhysicalDeviceFeatures + where + {-# INLINE writeField #-} + writeField = writeVkShaderCullDistance + +instance {-# OVERLAPPING #-} + HasVkShaderFloat64 VkPhysicalDeviceFeatures where + type VkShaderFloat64MType VkPhysicalDeviceFeatures = VkBool32 + + {-# NOINLINE vkShaderFloat64 #-} + vkShaderFloat64 x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceFeatures, shaderFloat64}) + + {-# INLINE vkShaderFloat64ByteOffset #-} + vkShaderFloat64ByteOffset ~_ + = #{offset VkPhysicalDeviceFeatures, shaderFloat64} + + {-# INLINE readVkShaderFloat64 #-} + readVkShaderFloat64 p + = peekByteOff p #{offset VkPhysicalDeviceFeatures, shaderFloat64} + + {-# INLINE writeVkShaderFloat64 #-} + writeVkShaderFloat64 p + = pokeByteOff p #{offset VkPhysicalDeviceFeatures, shaderFloat64} + +instance {-# OVERLAPPING #-} + HasField "shaderFloat64" VkPhysicalDeviceFeatures where + type FieldType "shaderFloat64" VkPhysicalDeviceFeatures = VkBool32 + type FieldOptional "shaderFloat64" VkPhysicalDeviceFeatures = + 'False -- ' closing tick for hsc2hs + type FieldOffset "shaderFloat64" VkPhysicalDeviceFeatures = + #{offset VkPhysicalDeviceFeatures, shaderFloat64} + type FieldIsArray "shaderFloat64" VkPhysicalDeviceFeatures = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceFeatures, shaderFloat64} + +instance CanReadField "shaderFloat64" VkPhysicalDeviceFeatures + where + {-# INLINE getField #-} + getField = vkShaderFloat64 + + {-# INLINE readField #-} + readField = readVkShaderFloat64 + +instance CanWriteField "shaderFloat64" VkPhysicalDeviceFeatures + where + {-# INLINE writeField #-} + writeField = writeVkShaderFloat64 + +instance {-# OVERLAPPING #-} + HasVkShaderInt64 VkPhysicalDeviceFeatures where + type VkShaderInt64MType VkPhysicalDeviceFeatures = VkBool32 + + {-# NOINLINE vkShaderInt64 #-} + vkShaderInt64 x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceFeatures, shaderInt64}) + + {-# INLINE vkShaderInt64ByteOffset #-} + vkShaderInt64ByteOffset ~_ + = #{offset VkPhysicalDeviceFeatures, shaderInt64} + + {-# INLINE readVkShaderInt64 #-} + readVkShaderInt64 p + = peekByteOff p #{offset VkPhysicalDeviceFeatures, shaderInt64} + + {-# INLINE writeVkShaderInt64 #-} + writeVkShaderInt64 p + = pokeByteOff p #{offset VkPhysicalDeviceFeatures, shaderInt64} + +instance {-# OVERLAPPING #-} + HasField "shaderInt64" VkPhysicalDeviceFeatures where + type FieldType "shaderInt64" VkPhysicalDeviceFeatures = VkBool32 + type FieldOptional "shaderInt64" VkPhysicalDeviceFeatures = 'False -- ' closing tick for hsc2hs + type FieldOffset "shaderInt64" VkPhysicalDeviceFeatures = + #{offset VkPhysicalDeviceFeatures, shaderInt64} + type FieldIsArray "shaderInt64" VkPhysicalDeviceFeatures = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceFeatures, shaderInt64} + +instance CanReadField "shaderInt64" VkPhysicalDeviceFeatures where + {-# INLINE getField #-} + getField = vkShaderInt64 + + {-# INLINE readField #-} + readField = readVkShaderInt64 + +instance CanWriteField "shaderInt64" VkPhysicalDeviceFeatures where + {-# INLINE writeField #-} + writeField = writeVkShaderInt64 + +instance {-# OVERLAPPING #-} + HasVkShaderInt16 VkPhysicalDeviceFeatures where + type VkShaderInt16MType VkPhysicalDeviceFeatures = VkBool32 + + {-# NOINLINE vkShaderInt16 #-} + vkShaderInt16 x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceFeatures, shaderInt16}) + + {-# INLINE vkShaderInt16ByteOffset #-} + vkShaderInt16ByteOffset ~_ + = #{offset VkPhysicalDeviceFeatures, shaderInt16} + + {-# INLINE readVkShaderInt16 #-} + readVkShaderInt16 p + = peekByteOff p #{offset VkPhysicalDeviceFeatures, shaderInt16} + + {-# INLINE writeVkShaderInt16 #-} + writeVkShaderInt16 p + = pokeByteOff p #{offset VkPhysicalDeviceFeatures, shaderInt16} + +instance {-# OVERLAPPING #-} + HasField "shaderInt16" VkPhysicalDeviceFeatures where + type FieldType "shaderInt16" VkPhysicalDeviceFeatures = VkBool32 + type FieldOptional "shaderInt16" VkPhysicalDeviceFeatures = 'False -- ' closing tick for hsc2hs + type FieldOffset "shaderInt16" VkPhysicalDeviceFeatures = + #{offset VkPhysicalDeviceFeatures, shaderInt16} + type FieldIsArray "shaderInt16" VkPhysicalDeviceFeatures = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceFeatures, shaderInt16} + +instance CanReadField "shaderInt16" VkPhysicalDeviceFeatures where + {-# INLINE getField #-} + getField = vkShaderInt16 + + {-# INLINE readField #-} + readField = readVkShaderInt16 + +instance CanWriteField "shaderInt16" VkPhysicalDeviceFeatures where + {-# INLINE writeField #-} + writeField = writeVkShaderInt16 + +instance {-# OVERLAPPING #-} + HasVkShaderResourceResidency VkPhysicalDeviceFeatures where + type VkShaderResourceResidencyMType VkPhysicalDeviceFeatures = + VkBool32 + + {-# NOINLINE vkShaderResourceResidency #-} + vkShaderResourceResidency x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceFeatures, shaderResourceResidency}) + + {-# INLINE vkShaderResourceResidencyByteOffset #-} + vkShaderResourceResidencyByteOffset ~_ + = #{offset VkPhysicalDeviceFeatures, shaderResourceResidency} + + {-# INLINE readVkShaderResourceResidency #-} + readVkShaderResourceResidency p + = peekByteOff p #{offset VkPhysicalDeviceFeatures, shaderResourceResidency} + + {-# INLINE writeVkShaderResourceResidency #-} + writeVkShaderResourceResidency p + = pokeByteOff p #{offset VkPhysicalDeviceFeatures, shaderResourceResidency} + +instance {-# OVERLAPPING #-} + HasField "shaderResourceResidency" VkPhysicalDeviceFeatures where + type FieldType "shaderResourceResidency" VkPhysicalDeviceFeatures = + VkBool32 + type FieldOptional "shaderResourceResidency" + VkPhysicalDeviceFeatures + = 'False -- ' closing tick for hsc2hs + type FieldOffset "shaderResourceResidency" VkPhysicalDeviceFeatures + = + #{offset VkPhysicalDeviceFeatures, shaderResourceResidency} + type FieldIsArray "shaderResourceResidency" + VkPhysicalDeviceFeatures + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceFeatures, shaderResourceResidency} + +instance CanReadField "shaderResourceResidency" + VkPhysicalDeviceFeatures + where + {-# INLINE getField #-} + getField = vkShaderResourceResidency + + {-# INLINE readField #-} + readField = readVkShaderResourceResidency + +instance CanWriteField "shaderResourceResidency" + VkPhysicalDeviceFeatures + where + {-# INLINE writeField #-} + writeField = writeVkShaderResourceResidency + +instance {-# OVERLAPPING #-} + HasVkShaderResourceMinLod VkPhysicalDeviceFeatures where + type VkShaderResourceMinLodMType VkPhysicalDeviceFeatures = + VkBool32 + + {-# NOINLINE vkShaderResourceMinLod #-} + vkShaderResourceMinLod x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceFeatures, shaderResourceMinLod}) + + {-# INLINE vkShaderResourceMinLodByteOffset #-} + vkShaderResourceMinLodByteOffset ~_ + = #{offset VkPhysicalDeviceFeatures, shaderResourceMinLod} + + {-# INLINE readVkShaderResourceMinLod #-} + readVkShaderResourceMinLod p + = peekByteOff p #{offset VkPhysicalDeviceFeatures, shaderResourceMinLod} + + {-# INLINE writeVkShaderResourceMinLod #-} + writeVkShaderResourceMinLod p + = pokeByteOff p #{offset VkPhysicalDeviceFeatures, shaderResourceMinLod} + +instance {-# OVERLAPPING #-} + HasField "shaderResourceMinLod" VkPhysicalDeviceFeatures where + type FieldType "shaderResourceMinLod" VkPhysicalDeviceFeatures = + VkBool32 + type FieldOptional "shaderResourceMinLod" VkPhysicalDeviceFeatures + = 'False -- ' closing tick for hsc2hs + type FieldOffset "shaderResourceMinLod" VkPhysicalDeviceFeatures = + #{offset VkPhysicalDeviceFeatures, shaderResourceMinLod} + type FieldIsArray "shaderResourceMinLod" VkPhysicalDeviceFeatures = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceFeatures, shaderResourceMinLod} + +instance CanReadField "shaderResourceMinLod" + VkPhysicalDeviceFeatures + where + {-# INLINE getField #-} + getField = vkShaderResourceMinLod + + {-# INLINE readField #-} + readField = readVkShaderResourceMinLod + +instance CanWriteField "shaderResourceMinLod" + VkPhysicalDeviceFeatures + where + {-# INLINE writeField #-} + writeField = writeVkShaderResourceMinLod + +instance {-# OVERLAPPING #-} + HasVkSparseBinding VkPhysicalDeviceFeatures where + type VkSparseBindingMType VkPhysicalDeviceFeatures = VkBool32 + + {-# NOINLINE vkSparseBinding #-} + vkSparseBinding x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceFeatures, sparseBinding}) + + {-# INLINE vkSparseBindingByteOffset #-} + vkSparseBindingByteOffset ~_ + = #{offset VkPhysicalDeviceFeatures, sparseBinding} + + {-# INLINE readVkSparseBinding #-} + readVkSparseBinding p + = peekByteOff p #{offset VkPhysicalDeviceFeatures, sparseBinding} + + {-# INLINE writeVkSparseBinding #-} + writeVkSparseBinding p + = pokeByteOff p #{offset VkPhysicalDeviceFeatures, sparseBinding} + +instance {-# OVERLAPPING #-} + HasField "sparseBinding" VkPhysicalDeviceFeatures where + type FieldType "sparseBinding" VkPhysicalDeviceFeatures = VkBool32 + type FieldOptional "sparseBinding" VkPhysicalDeviceFeatures = + 'False -- ' closing tick for hsc2hs + type FieldOffset "sparseBinding" VkPhysicalDeviceFeatures = + #{offset VkPhysicalDeviceFeatures, sparseBinding} + type FieldIsArray "sparseBinding" VkPhysicalDeviceFeatures = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceFeatures, sparseBinding} + +instance CanReadField "sparseBinding" VkPhysicalDeviceFeatures + where + {-# INLINE getField #-} + getField = vkSparseBinding + + {-# INLINE readField #-} + readField = readVkSparseBinding + +instance CanWriteField "sparseBinding" VkPhysicalDeviceFeatures + where + {-# INLINE writeField #-} + writeField = writeVkSparseBinding + +instance {-# OVERLAPPING #-} + HasVkSparseResidencyBuffer VkPhysicalDeviceFeatures where + type VkSparseResidencyBufferMType VkPhysicalDeviceFeatures = + VkBool32 + + {-# NOINLINE vkSparseResidencyBuffer #-} + vkSparseResidencyBuffer x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceFeatures, sparseResidencyBuffer}) + + {-# INLINE vkSparseResidencyBufferByteOffset #-} + vkSparseResidencyBufferByteOffset ~_ + = #{offset VkPhysicalDeviceFeatures, sparseResidencyBuffer} + + {-# INLINE readVkSparseResidencyBuffer #-} + readVkSparseResidencyBuffer p + = peekByteOff p #{offset VkPhysicalDeviceFeatures, sparseResidencyBuffer} + + {-# INLINE writeVkSparseResidencyBuffer #-} + writeVkSparseResidencyBuffer p + = pokeByteOff p #{offset VkPhysicalDeviceFeatures, sparseResidencyBuffer} + +instance {-# OVERLAPPING #-} + HasField "sparseResidencyBuffer" VkPhysicalDeviceFeatures where + type FieldType "sparseResidencyBuffer" VkPhysicalDeviceFeatures = + VkBool32 + type FieldOptional "sparseResidencyBuffer" VkPhysicalDeviceFeatures + = 'False -- ' closing tick for hsc2hs + type FieldOffset "sparseResidencyBuffer" VkPhysicalDeviceFeatures = + #{offset VkPhysicalDeviceFeatures, sparseResidencyBuffer} + type FieldIsArray "sparseResidencyBuffer" VkPhysicalDeviceFeatures + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceFeatures, sparseResidencyBuffer} + +instance CanReadField "sparseResidencyBuffer" + VkPhysicalDeviceFeatures + where + {-# INLINE getField #-} + getField = vkSparseResidencyBuffer + + {-# INLINE readField #-} + readField = readVkSparseResidencyBuffer + +instance CanWriteField "sparseResidencyBuffer" + VkPhysicalDeviceFeatures + where + {-# INLINE writeField #-} + writeField = writeVkSparseResidencyBuffer + +instance {-# OVERLAPPING #-} + HasVkSparseResidencyImage2D VkPhysicalDeviceFeatures where + type VkSparseResidencyImage2DMType VkPhysicalDeviceFeatures = + VkBool32 + + {-# NOINLINE vkSparseResidencyImage2D #-} + vkSparseResidencyImage2D x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceFeatures, sparseResidencyImage2D}) + + {-# INLINE vkSparseResidencyImage2DByteOffset #-} + vkSparseResidencyImage2DByteOffset ~_ + = #{offset VkPhysicalDeviceFeatures, sparseResidencyImage2D} + + {-# INLINE readVkSparseResidencyImage2D #-} + readVkSparseResidencyImage2D p + = peekByteOff p #{offset VkPhysicalDeviceFeatures, sparseResidencyImage2D} + + {-# INLINE writeVkSparseResidencyImage2D #-} + writeVkSparseResidencyImage2D p + = pokeByteOff p #{offset VkPhysicalDeviceFeatures, sparseResidencyImage2D} + +instance {-# OVERLAPPING #-} + HasField "sparseResidencyImage2D" VkPhysicalDeviceFeatures where + type FieldType "sparseResidencyImage2D" VkPhysicalDeviceFeatures = + VkBool32 + type FieldOptional "sparseResidencyImage2D" + VkPhysicalDeviceFeatures + = 'False -- ' closing tick for hsc2hs + type FieldOffset "sparseResidencyImage2D" VkPhysicalDeviceFeatures + = + #{offset VkPhysicalDeviceFeatures, sparseResidencyImage2D} + type FieldIsArray "sparseResidencyImage2D" VkPhysicalDeviceFeatures + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceFeatures, sparseResidencyImage2D} + +instance CanReadField "sparseResidencyImage2D" + VkPhysicalDeviceFeatures + where + {-# INLINE getField #-} + getField = vkSparseResidencyImage2D + + {-# INLINE readField #-} + readField = readVkSparseResidencyImage2D + +instance CanWriteField "sparseResidencyImage2D" + VkPhysicalDeviceFeatures + where + {-# INLINE writeField #-} + writeField = writeVkSparseResidencyImage2D + +instance {-# OVERLAPPING #-} + HasVkSparseResidencyImage3D VkPhysicalDeviceFeatures where + type VkSparseResidencyImage3DMType VkPhysicalDeviceFeatures = + VkBool32 + + {-# NOINLINE vkSparseResidencyImage3D #-} + vkSparseResidencyImage3D x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceFeatures, sparseResidencyImage3D}) + + {-# INLINE vkSparseResidencyImage3DByteOffset #-} + vkSparseResidencyImage3DByteOffset ~_ + = #{offset VkPhysicalDeviceFeatures, sparseResidencyImage3D} + + {-# INLINE readVkSparseResidencyImage3D #-} + readVkSparseResidencyImage3D p + = peekByteOff p #{offset VkPhysicalDeviceFeatures, sparseResidencyImage3D} + + {-# INLINE writeVkSparseResidencyImage3D #-} + writeVkSparseResidencyImage3D p + = pokeByteOff p #{offset VkPhysicalDeviceFeatures, sparseResidencyImage3D} + +instance {-# OVERLAPPING #-} + HasField "sparseResidencyImage3D" VkPhysicalDeviceFeatures where + type FieldType "sparseResidencyImage3D" VkPhysicalDeviceFeatures = + VkBool32 + type FieldOptional "sparseResidencyImage3D" + VkPhysicalDeviceFeatures + = 'False -- ' closing tick for hsc2hs + type FieldOffset "sparseResidencyImage3D" VkPhysicalDeviceFeatures + = + #{offset VkPhysicalDeviceFeatures, sparseResidencyImage3D} + type FieldIsArray "sparseResidencyImage3D" VkPhysicalDeviceFeatures + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceFeatures, sparseResidencyImage3D} + +instance CanReadField "sparseResidencyImage3D" + VkPhysicalDeviceFeatures + where + {-# INLINE getField #-} + getField = vkSparseResidencyImage3D + + {-# INLINE readField #-} + readField = readVkSparseResidencyImage3D + +instance CanWriteField "sparseResidencyImage3D" + VkPhysicalDeviceFeatures + where + {-# INLINE writeField #-} + writeField = writeVkSparseResidencyImage3D + +instance {-# OVERLAPPING #-} + HasVkSparseResidency2Samples VkPhysicalDeviceFeatures where + type VkSparseResidency2SamplesMType VkPhysicalDeviceFeatures = + VkBool32 + + {-# NOINLINE vkSparseResidency2Samples #-} + vkSparseResidency2Samples x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceFeatures, sparseResidency2Samples}) + + {-# INLINE vkSparseResidency2SamplesByteOffset #-} + vkSparseResidency2SamplesByteOffset ~_ + = #{offset VkPhysicalDeviceFeatures, sparseResidency2Samples} + + {-# INLINE readVkSparseResidency2Samples #-} + readVkSparseResidency2Samples p + = peekByteOff p #{offset VkPhysicalDeviceFeatures, sparseResidency2Samples} + + {-# INLINE writeVkSparseResidency2Samples #-} + writeVkSparseResidency2Samples p + = pokeByteOff p #{offset VkPhysicalDeviceFeatures, sparseResidency2Samples} + +instance {-# OVERLAPPING #-} + HasField "sparseResidency2Samples" VkPhysicalDeviceFeatures where + type FieldType "sparseResidency2Samples" VkPhysicalDeviceFeatures = + VkBool32 + type FieldOptional "sparseResidency2Samples" + VkPhysicalDeviceFeatures + = 'False -- ' closing tick for hsc2hs + type FieldOffset "sparseResidency2Samples" VkPhysicalDeviceFeatures + = + #{offset VkPhysicalDeviceFeatures, sparseResidency2Samples} + type FieldIsArray "sparseResidency2Samples" + VkPhysicalDeviceFeatures + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceFeatures, sparseResidency2Samples} + +instance CanReadField "sparseResidency2Samples" + VkPhysicalDeviceFeatures + where + {-# INLINE getField #-} + getField = vkSparseResidency2Samples + + {-# INLINE readField #-} + readField = readVkSparseResidency2Samples + +instance CanWriteField "sparseResidency2Samples" + VkPhysicalDeviceFeatures + where + {-# INLINE writeField #-} + writeField = writeVkSparseResidency2Samples + +instance {-# OVERLAPPING #-} + HasVkSparseResidency4Samples VkPhysicalDeviceFeatures where + type VkSparseResidency4SamplesMType VkPhysicalDeviceFeatures = + VkBool32 + + {-# NOINLINE vkSparseResidency4Samples #-} + vkSparseResidency4Samples x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceFeatures, sparseResidency4Samples}) + + {-# INLINE vkSparseResidency4SamplesByteOffset #-} + vkSparseResidency4SamplesByteOffset ~_ + = #{offset VkPhysicalDeviceFeatures, sparseResidency4Samples} + + {-# INLINE readVkSparseResidency4Samples #-} + readVkSparseResidency4Samples p + = peekByteOff p #{offset VkPhysicalDeviceFeatures, sparseResidency4Samples} + + {-# INLINE writeVkSparseResidency4Samples #-} + writeVkSparseResidency4Samples p + = pokeByteOff p #{offset VkPhysicalDeviceFeatures, sparseResidency4Samples} + +instance {-# OVERLAPPING #-} + HasField "sparseResidency4Samples" VkPhysicalDeviceFeatures where + type FieldType "sparseResidency4Samples" VkPhysicalDeviceFeatures = + VkBool32 + type FieldOptional "sparseResidency4Samples" + VkPhysicalDeviceFeatures + = 'False -- ' closing tick for hsc2hs + type FieldOffset "sparseResidency4Samples" VkPhysicalDeviceFeatures + = + #{offset VkPhysicalDeviceFeatures, sparseResidency4Samples} + type FieldIsArray "sparseResidency4Samples" + VkPhysicalDeviceFeatures + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceFeatures, sparseResidency4Samples} + +instance CanReadField "sparseResidency4Samples" + VkPhysicalDeviceFeatures + where + {-# INLINE getField #-} + getField = vkSparseResidency4Samples + + {-# INLINE readField #-} + readField = readVkSparseResidency4Samples + +instance CanWriteField "sparseResidency4Samples" + VkPhysicalDeviceFeatures + where + {-# INLINE writeField #-} + writeField = writeVkSparseResidency4Samples + +instance {-# OVERLAPPING #-} + HasVkSparseResidency8Samples VkPhysicalDeviceFeatures where + type VkSparseResidency8SamplesMType VkPhysicalDeviceFeatures = + VkBool32 + + {-# NOINLINE vkSparseResidency8Samples #-} + vkSparseResidency8Samples x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceFeatures, sparseResidency8Samples}) + + {-# INLINE vkSparseResidency8SamplesByteOffset #-} + vkSparseResidency8SamplesByteOffset ~_ + = #{offset VkPhysicalDeviceFeatures, sparseResidency8Samples} + + {-# INLINE readVkSparseResidency8Samples #-} + readVkSparseResidency8Samples p + = peekByteOff p #{offset VkPhysicalDeviceFeatures, sparseResidency8Samples} + + {-# INLINE writeVkSparseResidency8Samples #-} + writeVkSparseResidency8Samples p + = pokeByteOff p #{offset VkPhysicalDeviceFeatures, sparseResidency8Samples} + +instance {-# OVERLAPPING #-} + HasField "sparseResidency8Samples" VkPhysicalDeviceFeatures where + type FieldType "sparseResidency8Samples" VkPhysicalDeviceFeatures = + VkBool32 + type FieldOptional "sparseResidency8Samples" + VkPhysicalDeviceFeatures + = 'False -- ' closing tick for hsc2hs + type FieldOffset "sparseResidency8Samples" VkPhysicalDeviceFeatures + = + #{offset VkPhysicalDeviceFeatures, sparseResidency8Samples} + type FieldIsArray "sparseResidency8Samples" + VkPhysicalDeviceFeatures + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceFeatures, sparseResidency8Samples} + +instance CanReadField "sparseResidency8Samples" + VkPhysicalDeviceFeatures + where + {-# INLINE getField #-} + getField = vkSparseResidency8Samples + + {-# INLINE readField #-} + readField = readVkSparseResidency8Samples + +instance CanWriteField "sparseResidency8Samples" + VkPhysicalDeviceFeatures + where + {-# INLINE writeField #-} + writeField = writeVkSparseResidency8Samples + +instance {-# OVERLAPPING #-} + HasVkSparseResidency16Samples VkPhysicalDeviceFeatures where + type VkSparseResidency16SamplesMType VkPhysicalDeviceFeatures = + VkBool32 + + {-# NOINLINE vkSparseResidency16Samples #-} + vkSparseResidency16Samples x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceFeatures, sparseResidency16Samples}) + + {-# INLINE vkSparseResidency16SamplesByteOffset #-} + vkSparseResidency16SamplesByteOffset ~_ + = #{offset VkPhysicalDeviceFeatures, sparseResidency16Samples} + + {-# INLINE readVkSparseResidency16Samples #-} + readVkSparseResidency16Samples p + = peekByteOff p #{offset VkPhysicalDeviceFeatures, sparseResidency16Samples} + + {-# INLINE writeVkSparseResidency16Samples #-} + writeVkSparseResidency16Samples p + = pokeByteOff p #{offset VkPhysicalDeviceFeatures, sparseResidency16Samples} + +instance {-# OVERLAPPING #-} + HasField "sparseResidency16Samples" VkPhysicalDeviceFeatures where + type FieldType "sparseResidency16Samples" VkPhysicalDeviceFeatures + = VkBool32 + type FieldOptional "sparseResidency16Samples" + VkPhysicalDeviceFeatures + = 'False -- ' closing tick for hsc2hs + type FieldOffset "sparseResidency16Samples" + VkPhysicalDeviceFeatures + = + #{offset VkPhysicalDeviceFeatures, sparseResidency16Samples} + type FieldIsArray "sparseResidency16Samples" + VkPhysicalDeviceFeatures + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceFeatures, sparseResidency16Samples} + +instance CanReadField "sparseResidency16Samples" + VkPhysicalDeviceFeatures + where + {-# INLINE getField #-} + getField = vkSparseResidency16Samples + + {-# INLINE readField #-} + readField = readVkSparseResidency16Samples + +instance CanWriteField "sparseResidency16Samples" + VkPhysicalDeviceFeatures + where + {-# INLINE writeField #-} + writeField = writeVkSparseResidency16Samples + +instance {-# OVERLAPPING #-} + HasVkSparseResidencyAliased VkPhysicalDeviceFeatures where + type VkSparseResidencyAliasedMType VkPhysicalDeviceFeatures = + VkBool32 + + {-# NOINLINE vkSparseResidencyAliased #-} + vkSparseResidencyAliased x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceFeatures, sparseResidencyAliased}) + + {-# INLINE vkSparseResidencyAliasedByteOffset #-} + vkSparseResidencyAliasedByteOffset ~_ + = #{offset VkPhysicalDeviceFeatures, sparseResidencyAliased} + + {-# INLINE readVkSparseResidencyAliased #-} + readVkSparseResidencyAliased p + = peekByteOff p #{offset VkPhysicalDeviceFeatures, sparseResidencyAliased} + + {-# INLINE writeVkSparseResidencyAliased #-} + writeVkSparseResidencyAliased p + = pokeByteOff p #{offset VkPhysicalDeviceFeatures, sparseResidencyAliased} + +instance {-# OVERLAPPING #-} + HasField "sparseResidencyAliased" VkPhysicalDeviceFeatures where + type FieldType "sparseResidencyAliased" VkPhysicalDeviceFeatures = + VkBool32 + type FieldOptional "sparseResidencyAliased" + VkPhysicalDeviceFeatures + = 'False -- ' closing tick for hsc2hs + type FieldOffset "sparseResidencyAliased" VkPhysicalDeviceFeatures + = + #{offset VkPhysicalDeviceFeatures, sparseResidencyAliased} + type FieldIsArray "sparseResidencyAliased" VkPhysicalDeviceFeatures + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceFeatures, sparseResidencyAliased} + +instance CanReadField "sparseResidencyAliased" + VkPhysicalDeviceFeatures + where + {-# INLINE getField #-} + getField = vkSparseResidencyAliased + + {-# INLINE readField #-} + readField = readVkSparseResidencyAliased + +instance CanWriteField "sparseResidencyAliased" + VkPhysicalDeviceFeatures + where + {-# INLINE writeField #-} + writeField = writeVkSparseResidencyAliased + +instance {-# OVERLAPPING #-} + HasVkVariableMultisampleRate VkPhysicalDeviceFeatures where + type VkVariableMultisampleRateMType VkPhysicalDeviceFeatures = + VkBool32 + + {-# NOINLINE vkVariableMultisampleRate #-} + vkVariableMultisampleRate x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceFeatures, variableMultisampleRate}) + + {-# INLINE vkVariableMultisampleRateByteOffset #-} + vkVariableMultisampleRateByteOffset ~_ + = #{offset VkPhysicalDeviceFeatures, variableMultisampleRate} + + {-# INLINE readVkVariableMultisampleRate #-} + readVkVariableMultisampleRate p + = peekByteOff p #{offset VkPhysicalDeviceFeatures, variableMultisampleRate} + + {-# INLINE writeVkVariableMultisampleRate #-} + writeVkVariableMultisampleRate p + = pokeByteOff p #{offset VkPhysicalDeviceFeatures, variableMultisampleRate} + +instance {-# OVERLAPPING #-} + HasField "variableMultisampleRate" VkPhysicalDeviceFeatures where + type FieldType "variableMultisampleRate" VkPhysicalDeviceFeatures = + VkBool32 + type FieldOptional "variableMultisampleRate" + VkPhysicalDeviceFeatures + = 'False -- ' closing tick for hsc2hs + type FieldOffset "variableMultisampleRate" VkPhysicalDeviceFeatures + = + #{offset VkPhysicalDeviceFeatures, variableMultisampleRate} + type FieldIsArray "variableMultisampleRate" + VkPhysicalDeviceFeatures + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceFeatures, variableMultisampleRate} + +instance CanReadField "variableMultisampleRate" + VkPhysicalDeviceFeatures + where + {-# INLINE getField #-} + getField = vkVariableMultisampleRate + + {-# INLINE readField #-} + readField = readVkVariableMultisampleRate + +instance CanWriteField "variableMultisampleRate" + VkPhysicalDeviceFeatures + where + {-# INLINE writeField #-} + writeField = writeVkVariableMultisampleRate + +instance {-# OVERLAPPING #-} + HasVkInheritedQueries VkPhysicalDeviceFeatures where + type VkInheritedQueriesMType VkPhysicalDeviceFeatures = VkBool32 + + {-# NOINLINE vkInheritedQueries #-} + vkInheritedQueries x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceFeatures, inheritedQueries}) + + {-# INLINE vkInheritedQueriesByteOffset #-} + vkInheritedQueriesByteOffset ~_ + = #{offset VkPhysicalDeviceFeatures, inheritedQueries} + + {-# INLINE readVkInheritedQueries #-} + readVkInheritedQueries p + = peekByteOff p #{offset VkPhysicalDeviceFeatures, inheritedQueries} + + {-# INLINE writeVkInheritedQueries #-} + writeVkInheritedQueries p + = pokeByteOff p #{offset VkPhysicalDeviceFeatures, inheritedQueries} + +instance {-# OVERLAPPING #-} + HasField "inheritedQueries" VkPhysicalDeviceFeatures where + type FieldType "inheritedQueries" VkPhysicalDeviceFeatures = + VkBool32 + type FieldOptional "inheritedQueries" VkPhysicalDeviceFeatures = + 'False -- ' closing tick for hsc2hs + type FieldOffset "inheritedQueries" VkPhysicalDeviceFeatures = + #{offset VkPhysicalDeviceFeatures, inheritedQueries} + type FieldIsArray "inheritedQueries" VkPhysicalDeviceFeatures = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceFeatures, inheritedQueries} + +instance CanReadField "inheritedQueries" VkPhysicalDeviceFeatures + where + {-# INLINE getField #-} + getField = vkInheritedQueries + + {-# INLINE readField #-} + readField = readVkInheritedQueries + +instance CanWriteField "inheritedQueries" VkPhysicalDeviceFeatures + where + {-# INLINE writeField #-} + writeField = writeVkInheritedQueries + +instance Show VkPhysicalDeviceFeatures where + showsPrec d x + = showString "VkPhysicalDeviceFeatures {" . + showString "vkRobustBufferAccess = " . + showsPrec d (vkRobustBufferAccess x) . + showString ", " . + showString "vkFullDrawIndexUint32 = " . + showsPrec d (vkFullDrawIndexUint32 x) . + showString ", " . + showString "vkImageCubeArray = " . + showsPrec d (vkImageCubeArray x) . + showString ", " . + showString "vkIndependentBlend = " . + showsPrec d (vkIndependentBlend x) . + showString ", " . + showString "vkGeometryShader = " . + showsPrec d (vkGeometryShader x) . + showString ", " . + showString "vkTessellationShader = " . + showsPrec d (vkTessellationShader x) . + showString ", " . + showString "vkSampleRateShading = " . + showsPrec d (vkSampleRateShading x) . + showString ", " . + showString "vkDualSrcBlend = " . + showsPrec d (vkDualSrcBlend x) . + showString ", " . + showString "vkLogicOp = " . + showsPrec d (vkLogicOp x) . + showString ", " . + showString + "vkMultiDrawIndirect = " + . + showsPrec d + (vkMultiDrawIndirect x) + . + showString ", " . + showString + "vkDrawIndirectFirstInstance = " + . + showsPrec d + (vkDrawIndirectFirstInstance + x) + . + showString ", " . + showString + "vkDepthClamp = " + . + showsPrec d + (vkDepthClamp x) + . + showString ", " + . + showString + "vkDepthBiasClamp = " + . + showsPrec d + (vkDepthBiasClamp + x) + . + showString + ", " + . + showString + "vkFillModeNonSolid = " + . + showsPrec + d + (vkFillModeNonSolid + x) + . + showString + ", " + . + showString + "vkDepthBounds = " + . + showsPrec + d + (vkDepthBounds + x) + . + showString + ", " + . + showString + "vkWideLines = " + . + showsPrec + d + (vkWideLines + x) + . + showString + ", " + . + showString + "vkLargePoints = " + . + showsPrec + d + (vkLargePoints + x) + . + showString + ", " + . + showString + "vkAlphaToOne = " + . + showsPrec + d + (vkAlphaToOne + x) + . + showString + ", " + . + showString + "vkMultiViewport = " + . + showsPrec + d + (vkMultiViewport + x) + . + showString + ", " + . + showString + "vkSamplerAnisotropy = " + . + showsPrec + d + (vkSamplerAnisotropy + x) + . + showString + ", " + . + showString + "vkTextureCompressionETC2 = " + . + showsPrec + d + (vkTextureCompressionETC2 + x) + . + showString + ", " + . + showString + "vkTextureCompressionASTC_LDR = " + . + showsPrec + d + (vkTextureCompressionASTC_LDR + x) + . + showString + ", " + . + showString + "vkTextureCompressionBC = " + . + showsPrec + d + (vkTextureCompressionBC + x) + . + showString + ", " + . + showString + "vkOcclusionQueryPrecise = " + . + showsPrec + d + (vkOcclusionQueryPrecise + x) + . + showString + ", " + . + showString + "vkPipelineStatisticsQuery = " + . + showsPrec + d + (vkPipelineStatisticsQuery + x) + . + showString + ", " + . + showString + "vkVertexPipelineStoresAndAtomics = " + . + showsPrec + d + (vkVertexPipelineStoresAndAtomics + x) + . + showString + ", " + . + showString + "vkFragmentStoresAndAtomics = " + . + showsPrec + d + (vkFragmentStoresAndAtomics + x) + . + showString + ", " + . + showString + "vkShaderTessellationAndGeometryPointSize = " + . + showsPrec + d + (vkShaderTessellationAndGeometryPointSize + x) + . + showString + ", " + . + showString + "vkShaderImageGatherExtended = " + . + showsPrec + d + (vkShaderImageGatherExtended + x) + . + showString + ", " + . + showString + "vkShaderStorageImageExtendedFormats = " + . + showsPrec + d + (vkShaderStorageImageExtendedFormats + x) + . + showString + ", " + . + showString + "vkShaderStorageImageMultisample = " + . + showsPrec + d + (vkShaderStorageImageMultisample + x) + . + showString + ", " + . + showString + "vkShaderStorageImageReadWithoutFormat = " + . + showsPrec + d + (vkShaderStorageImageReadWithoutFormat + x) + . + showString + ", " + . + showString + "vkShaderStorageImageWriteWithoutFormat = " + . + showsPrec + d + (vkShaderStorageImageWriteWithoutFormat + x) + . + showString + ", " + . + showString + "vkShaderUniformBufferArrayDynamicIndexing = " + . + showsPrec + d + (vkShaderUniformBufferArrayDynamicIndexing + x) + . + showString + ", " + . + showString + "vkShaderSampledImageArrayDynamicIndexing = " + . + showsPrec + d + (vkShaderSampledImageArrayDynamicIndexing + x) + . + showString + ", " + . + showString + "vkShaderStorageBufferArrayDynamicIndexing = " + . + showsPrec + d + (vkShaderStorageBufferArrayDynamicIndexing + x) + . + showString + ", " + . + showString + "vkShaderStorageImageArrayDynamicIndexing = " + . + showsPrec + d + (vkShaderStorageImageArrayDynamicIndexing + x) + . + showString + ", " + . + showString + "vkShaderClipDistance = " + . + showsPrec + d + (vkShaderClipDistance + x) + . + showString + ", " + . + showString + "vkShaderCullDistance = " + . + showsPrec + d + (vkShaderCullDistance + x) + . + showString + ", " + . + showString + "vkShaderFloat64 = " + . + showsPrec + d + (vkShaderFloat64 + x) + . + showString + ", " + . + showString + "vkShaderInt64 = " + . + showsPrec + d + (vkShaderInt64 + x) + . + showString + ", " + . + showString + "vkShaderInt16 = " + . + showsPrec + d + (vkShaderInt16 + x) + . + showString + ", " + . + showString + "vkShaderResourceResidency = " + . + showsPrec + d + (vkShaderResourceResidency + x) + . + showString + ", " + . + showString + "vkShaderResourceMinLod = " + . + showsPrec + d + (vkShaderResourceMinLod + x) + . + showString + ", " + . + showString + "vkSparseBinding = " + . + showsPrec + d + (vkSparseBinding + x) + . + showString + ", " + . + showString + "vkSparseResidencyBuffer = " + . + showsPrec + d + (vkSparseResidencyBuffer + x) + . + showString + ", " + . + showString + "vkSparseResidencyImage2D = " + . + showsPrec + d + (vkSparseResidencyImage2D + x) + . + showString + ", " + . + showString + "vkSparseResidencyImage3D = " + . + showsPrec + d + (vkSparseResidencyImage3D + x) + . + showString + ", " + . + showString + "vkSparseResidency2Samples = " + . + showsPrec + d + (vkSparseResidency2Samples + x) + . + showString + ", " + . + showString + "vkSparseResidency4Samples = " + . + showsPrec + d + (vkSparseResidency4Samples + x) + . + showString + ", " + . + showString + "vkSparseResidency8Samples = " + . + showsPrec + d + (vkSparseResidency8Samples + x) + . + showString + ", " + . + showString + "vkSparseResidency16Samples = " + . + showsPrec + d + (vkSparseResidency16Samples + x) + . + showString + ", " + . + showString + "vkSparseResidencyAliased = " + . + showsPrec + d + (vkSparseResidencyAliased + x) + . + showString + ", " + . + showString + "vkVariableMultisampleRate = " + . + showsPrec + d + (vkVariableMultisampleRate + x) + . + showString + ", " + . + showString + "vkInheritedQueries = " + . + showsPrec + d + (vkInheritedQueries + x) + . + showChar + '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkPhysicalDeviceFeatures2KHR.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkPhysicalDeviceFeatures2KHR.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkPhysicalDeviceFeatures2KHR.hsc @@ -0,0 +1,236 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceFeatures2KHR + (VkPhysicalDeviceFeatures2KHR(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Struct.VkDeviceCreateInfo (VkDeviceCreateInfo) +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceFeatures (VkPhysicalDeviceFeatures) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkPhysicalDeviceFeatures2KHR { +-- > VkStructureType sType; +-- > void* pNext; +-- > VkPhysicalDeviceFeatures features; +-- > } VkPhysicalDeviceFeatures2KHR; +-- +-- +data VkPhysicalDeviceFeatures2KHR = VkPhysicalDeviceFeatures2KHR## Addr## + ByteArray## + +instance Eq VkPhysicalDeviceFeatures2KHR where + (VkPhysicalDeviceFeatures2KHR## a _) == + x@(VkPhysicalDeviceFeatures2KHR## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkPhysicalDeviceFeatures2KHR where + (VkPhysicalDeviceFeatures2KHR## a _) `compare` + x@(VkPhysicalDeviceFeatures2KHR## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkPhysicalDeviceFeatures2KHR where + sizeOf ~_ = #{size VkPhysicalDeviceFeatures2KHR} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkPhysicalDeviceFeatures2KHR} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkPhysicalDeviceFeatures2KHR where + unsafeAddr (VkPhysicalDeviceFeatures2KHR## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkPhysicalDeviceFeatures2KHR## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkPhysicalDeviceFeatures2KHR## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkPhysicalDeviceFeatures2KHR where + type StructFields VkPhysicalDeviceFeatures2KHR = + '["sType", "pNext", "features"] -- ' closing tick for hsc2hs + type CUnionType VkPhysicalDeviceFeatures2KHR = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkPhysicalDeviceFeatures2KHR = 'False -- ' closing tick for hsc2hs + type StructExtends VkPhysicalDeviceFeatures2KHR = + '[VkDeviceCreateInfo] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkPhysicalDeviceFeatures2KHR where + type VkSTypeMType VkPhysicalDeviceFeatures2KHR = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceFeatures2KHR, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkPhysicalDeviceFeatures2KHR, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkPhysicalDeviceFeatures2KHR, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkPhysicalDeviceFeatures2KHR, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkPhysicalDeviceFeatures2KHR where + type FieldType "sType" VkPhysicalDeviceFeatures2KHR = + VkStructureType + type FieldOptional "sType" VkPhysicalDeviceFeatures2KHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkPhysicalDeviceFeatures2KHR = + #{offset VkPhysicalDeviceFeatures2KHR, sType} + type FieldIsArray "sType" VkPhysicalDeviceFeatures2KHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceFeatures2KHR, sType} + +instance CanReadField "sType" VkPhysicalDeviceFeatures2KHR where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkPhysicalDeviceFeatures2KHR where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkPhysicalDeviceFeatures2KHR where + type VkPNextMType VkPhysicalDeviceFeatures2KHR = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceFeatures2KHR, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkPhysicalDeviceFeatures2KHR, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkPhysicalDeviceFeatures2KHR, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkPhysicalDeviceFeatures2KHR, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkPhysicalDeviceFeatures2KHR where + type FieldType "pNext" VkPhysicalDeviceFeatures2KHR = Ptr Void + type FieldOptional "pNext" VkPhysicalDeviceFeatures2KHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkPhysicalDeviceFeatures2KHR = + #{offset VkPhysicalDeviceFeatures2KHR, pNext} + type FieldIsArray "pNext" VkPhysicalDeviceFeatures2KHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceFeatures2KHR, pNext} + +instance CanReadField "pNext" VkPhysicalDeviceFeatures2KHR where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkPhysicalDeviceFeatures2KHR where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkFeatures VkPhysicalDeviceFeatures2KHR where + type VkFeaturesMType VkPhysicalDeviceFeatures2KHR = + VkPhysicalDeviceFeatures + + {-# NOINLINE vkFeatures #-} + vkFeatures x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceFeatures2KHR, features}) + + {-# INLINE vkFeaturesByteOffset #-} + vkFeaturesByteOffset ~_ + = #{offset VkPhysicalDeviceFeatures2KHR, features} + + {-# INLINE readVkFeatures #-} + readVkFeatures p + = peekByteOff p #{offset VkPhysicalDeviceFeatures2KHR, features} + + {-# INLINE writeVkFeatures #-} + writeVkFeatures p + = pokeByteOff p #{offset VkPhysicalDeviceFeatures2KHR, features} + +instance {-# OVERLAPPING #-} + HasField "features" VkPhysicalDeviceFeatures2KHR where + type FieldType "features" VkPhysicalDeviceFeatures2KHR = + VkPhysicalDeviceFeatures + type FieldOptional "features" VkPhysicalDeviceFeatures2KHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "features" VkPhysicalDeviceFeatures2KHR = + #{offset VkPhysicalDeviceFeatures2KHR, features} + type FieldIsArray "features" VkPhysicalDeviceFeatures2KHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceFeatures2KHR, features} + +instance CanReadField "features" VkPhysicalDeviceFeatures2KHR where + {-# INLINE getField #-} + getField = vkFeatures + + {-# INLINE readField #-} + readField = readVkFeatures + +instance CanWriteField "features" VkPhysicalDeviceFeatures2KHR + where + {-# INLINE writeField #-} + writeField = writeVkFeatures + +instance Show VkPhysicalDeviceFeatures2KHR where + showsPrec d x + = showString "VkPhysicalDeviceFeatures2KHR {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkFeatures = " . + showsPrec d (vkFeatures x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkPhysicalDeviceGroupPropertiesKHX.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkPhysicalDeviceGroupPropertiesKHX.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkPhysicalDeviceGroupPropertiesKHX.hsc @@ -0,0 +1,408 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleContexts #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE ScopedTypeVariables #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +{-# LANGUAGE UndecidableInstances #-} +module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceGroupPropertiesKHX + (VkPhysicalDeviceGroupPropertiesKHX(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import GHC.TypeLits (KnownNat, natVal') -- ' closing tick for hsc2hs +import Graphics.Vulkan.Constants (VK_MAX_DEVICE_GROUP_SIZE_KHX, + pattern VK_MAX_DEVICE_GROUP_SIZE_KHX) +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.BaseTypes (VkBool32) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Handles (VkPhysicalDevice) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkPhysicalDeviceGroupPropertiesKHX { +-- > VkStructureType sType; +-- > void* pNext; +-- > uint32_t physicalDeviceCount; +-- > VkPhysicalDevice physicalDevices[VK_MAX_DEVICE_GROUP_SIZE_KHX]; +-- > VkBool32 subsetAllocation; +-- > } VkPhysicalDeviceGroupPropertiesKHX; +-- +-- +data VkPhysicalDeviceGroupPropertiesKHX = VkPhysicalDeviceGroupPropertiesKHX## Addr## + ByteArray## + +instance Eq VkPhysicalDeviceGroupPropertiesKHX where + (VkPhysicalDeviceGroupPropertiesKHX## a _) == + x@(VkPhysicalDeviceGroupPropertiesKHX## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkPhysicalDeviceGroupPropertiesKHX where + (VkPhysicalDeviceGroupPropertiesKHX## a _) `compare` + x@(VkPhysicalDeviceGroupPropertiesKHX## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkPhysicalDeviceGroupPropertiesKHX where + sizeOf ~_ = #{size VkPhysicalDeviceGroupPropertiesKHX} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkPhysicalDeviceGroupPropertiesKHX} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkPhysicalDeviceGroupPropertiesKHX where + unsafeAddr (VkPhysicalDeviceGroupPropertiesKHX## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkPhysicalDeviceGroupPropertiesKHX## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkPhysicalDeviceGroupPropertiesKHX## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkPhysicalDeviceGroupPropertiesKHX where + type StructFields VkPhysicalDeviceGroupPropertiesKHX = + '["sType", "pNext", "physicalDeviceCount", "physicalDevices", -- ' closing tick for hsc2hs + "subsetAllocation"] + type CUnionType VkPhysicalDeviceGroupPropertiesKHX = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkPhysicalDeviceGroupPropertiesKHX = 'True -- ' closing tick for hsc2hs + type StructExtends VkPhysicalDeviceGroupPropertiesKHX = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkPhysicalDeviceGroupPropertiesKHX where + type VkSTypeMType VkPhysicalDeviceGroupPropertiesKHX = + VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceGroupPropertiesKHX, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkPhysicalDeviceGroupPropertiesKHX, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkPhysicalDeviceGroupPropertiesKHX, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkPhysicalDeviceGroupPropertiesKHX, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkPhysicalDeviceGroupPropertiesKHX where + type FieldType "sType" VkPhysicalDeviceGroupPropertiesKHX = + VkStructureType + type FieldOptional "sType" VkPhysicalDeviceGroupPropertiesKHX = + 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkPhysicalDeviceGroupPropertiesKHX = + #{offset VkPhysicalDeviceGroupPropertiesKHX, sType} + type FieldIsArray "sType" VkPhysicalDeviceGroupPropertiesKHX = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceGroupPropertiesKHX, sType} + +instance CanReadField "sType" VkPhysicalDeviceGroupPropertiesKHX + where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkPhysicalDeviceGroupPropertiesKHX where + type VkPNextMType VkPhysicalDeviceGroupPropertiesKHX = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceGroupPropertiesKHX, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkPhysicalDeviceGroupPropertiesKHX, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkPhysicalDeviceGroupPropertiesKHX, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkPhysicalDeviceGroupPropertiesKHX, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkPhysicalDeviceGroupPropertiesKHX where + type FieldType "pNext" VkPhysicalDeviceGroupPropertiesKHX = + Ptr Void + type FieldOptional "pNext" VkPhysicalDeviceGroupPropertiesKHX = + 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkPhysicalDeviceGroupPropertiesKHX = + #{offset VkPhysicalDeviceGroupPropertiesKHX, pNext} + type FieldIsArray "pNext" VkPhysicalDeviceGroupPropertiesKHX = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceGroupPropertiesKHX, pNext} + +instance CanReadField "pNext" VkPhysicalDeviceGroupPropertiesKHX + where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance {-# OVERLAPPING #-} + HasVkPhysicalDeviceCount VkPhysicalDeviceGroupPropertiesKHX where + type VkPhysicalDeviceCountMType VkPhysicalDeviceGroupPropertiesKHX + = Word32 + + {-# NOINLINE vkPhysicalDeviceCount #-} + vkPhysicalDeviceCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceGroupPropertiesKHX, physicalDeviceCount}) + + {-# INLINE vkPhysicalDeviceCountByteOffset #-} + vkPhysicalDeviceCountByteOffset ~_ + = #{offset VkPhysicalDeviceGroupPropertiesKHX, physicalDeviceCount} + + {-# INLINE readVkPhysicalDeviceCount #-} + readVkPhysicalDeviceCount p + = peekByteOff p #{offset VkPhysicalDeviceGroupPropertiesKHX, physicalDeviceCount} + + {-# INLINE writeVkPhysicalDeviceCount #-} + writeVkPhysicalDeviceCount p + = pokeByteOff p #{offset VkPhysicalDeviceGroupPropertiesKHX, physicalDeviceCount} + +instance {-# OVERLAPPING #-} + HasField "physicalDeviceCount" VkPhysicalDeviceGroupPropertiesKHX + where + type FieldType "physicalDeviceCount" + VkPhysicalDeviceGroupPropertiesKHX + = Word32 + type FieldOptional "physicalDeviceCount" + VkPhysicalDeviceGroupPropertiesKHX + = 'False -- ' closing tick for hsc2hs + type FieldOffset "physicalDeviceCount" + VkPhysicalDeviceGroupPropertiesKHX + = + #{offset VkPhysicalDeviceGroupPropertiesKHX, physicalDeviceCount} + type FieldIsArray "physicalDeviceCount" + VkPhysicalDeviceGroupPropertiesKHX + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceGroupPropertiesKHX, physicalDeviceCount} + +instance CanReadField "physicalDeviceCount" + VkPhysicalDeviceGroupPropertiesKHX + where + {-# INLINE getField #-} + getField = vkPhysicalDeviceCount + + {-# INLINE readField #-} + readField = readVkPhysicalDeviceCount + +instance {-# OVERLAPPING #-} + HasVkPhysicalDevicesArray VkPhysicalDeviceGroupPropertiesKHX where + type VkPhysicalDevicesArrayMType VkPhysicalDeviceGroupPropertiesKHX + = VkPhysicalDevice + + {-# NOINLINE vkPhysicalDevicesArray #-} + vkPhysicalDevicesArray x idx + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) + (idx * sizeOf (undefined :: VkPhysicalDevice) + + #{offset VkPhysicalDeviceGroupPropertiesKHX, physicalDevices})) + + {-# INLINE vkPhysicalDevicesArrayByteOffset #-} + vkPhysicalDevicesArrayByteOffset ~_ + = #{offset VkPhysicalDeviceGroupPropertiesKHX, physicalDevices} + + {-# INLINE readVkPhysicalDevicesArray #-} + readVkPhysicalDevicesArray p idx + = peekByteOff p + (idx * sizeOf (undefined :: VkPhysicalDevice) + + #{offset VkPhysicalDeviceGroupPropertiesKHX, physicalDevices}) + + {-# INLINE writeVkPhysicalDevicesArray #-} + writeVkPhysicalDevicesArray p idx + = pokeByteOff p + (idx * sizeOf (undefined :: VkPhysicalDevice) + + #{offset VkPhysicalDeviceGroupPropertiesKHX, physicalDevices}) + +instance {-# OVERLAPPING #-} + HasField "physicalDevices" VkPhysicalDeviceGroupPropertiesKHX where + type FieldType "physicalDevices" VkPhysicalDeviceGroupPropertiesKHX + = VkPhysicalDevice + type FieldOptional "physicalDevices" + VkPhysicalDeviceGroupPropertiesKHX + = 'False -- ' closing tick for hsc2hs + type FieldOffset "physicalDevices" + VkPhysicalDeviceGroupPropertiesKHX + = + #{offset VkPhysicalDeviceGroupPropertiesKHX, physicalDevices} + type FieldIsArray "physicalDevices" + VkPhysicalDeviceGroupPropertiesKHX + = 'True -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceGroupPropertiesKHX, physicalDevices} + +instance (KnownNat idx, + IndexInBounds "physicalDevices" idx + VkPhysicalDeviceGroupPropertiesKHX) => + CanReadFieldArray "physicalDevices" idx + VkPhysicalDeviceGroupPropertiesKHX + where + {-# SPECIALISE instance + CanReadFieldArray "physicalDevices" 0 + VkPhysicalDeviceGroupPropertiesKHX + #-} + + {-# SPECIALISE instance + CanReadFieldArray "physicalDevices" 1 + VkPhysicalDeviceGroupPropertiesKHX + #-} + + {-# SPECIALISE instance + CanReadFieldArray "physicalDevices" 2 + VkPhysicalDeviceGroupPropertiesKHX + #-} + + {-# SPECIALISE instance + CanReadFieldArray "physicalDevices" 3 + VkPhysicalDeviceGroupPropertiesKHX + #-} + type FieldArrayLength "physicalDevices" + VkPhysicalDeviceGroupPropertiesKHX + = VK_MAX_DEVICE_GROUP_SIZE_KHX + + {-# INLINE fieldArrayLength #-} + fieldArrayLength = VK_MAX_DEVICE_GROUP_SIZE_KHX + + {-# INLINE getFieldArray #-} + getFieldArray x + = vkPhysicalDevicesArray x + (fromInteger $ natVal' (proxy## :: Proxy## idx)) -- ' closing tick for hsc2hs + + {-# INLINE readFieldArray #-} + readFieldArray x + = readVkPhysicalDevicesArray x + (fromInteger $ natVal' (proxy## :: Proxy## idx)) -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSubsetAllocation VkPhysicalDeviceGroupPropertiesKHX where + type VkSubsetAllocationMType VkPhysicalDeviceGroupPropertiesKHX = + VkBool32 + + {-# NOINLINE vkSubsetAllocation #-} + vkSubsetAllocation x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceGroupPropertiesKHX, subsetAllocation}) + + {-# INLINE vkSubsetAllocationByteOffset #-} + vkSubsetAllocationByteOffset ~_ + = #{offset VkPhysicalDeviceGroupPropertiesKHX, subsetAllocation} + + {-# INLINE readVkSubsetAllocation #-} + readVkSubsetAllocation p + = peekByteOff p #{offset VkPhysicalDeviceGroupPropertiesKHX, subsetAllocation} + + {-# INLINE writeVkSubsetAllocation #-} + writeVkSubsetAllocation p + = pokeByteOff p #{offset VkPhysicalDeviceGroupPropertiesKHX, subsetAllocation} + +instance {-# OVERLAPPING #-} + HasField "subsetAllocation" VkPhysicalDeviceGroupPropertiesKHX + where + type FieldType "subsetAllocation" + VkPhysicalDeviceGroupPropertiesKHX + = VkBool32 + type FieldOptional "subsetAllocation" + VkPhysicalDeviceGroupPropertiesKHX + = 'False -- ' closing tick for hsc2hs + type FieldOffset "subsetAllocation" + VkPhysicalDeviceGroupPropertiesKHX + = + #{offset VkPhysicalDeviceGroupPropertiesKHX, subsetAllocation} + type FieldIsArray "subsetAllocation" + VkPhysicalDeviceGroupPropertiesKHX + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceGroupPropertiesKHX, subsetAllocation} + +instance CanReadField "subsetAllocation" + VkPhysicalDeviceGroupPropertiesKHX + where + {-# INLINE getField #-} + getField = vkSubsetAllocation + + {-# INLINE readField #-} + readField = readVkSubsetAllocation + +instance Show VkPhysicalDeviceGroupPropertiesKHX where + showsPrec d x + = showString "VkPhysicalDeviceGroupPropertiesKHX {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkPhysicalDeviceCount = " . + showsPrec d (vkPhysicalDeviceCount x) . + showString ", " . + showString "vkPhysicalDevicesArray = [" . + showsPrec d + (map (vkPhysicalDevicesArray x) + [1 .. VK_MAX_DEVICE_GROUP_SIZE_KHX]) + . + showChar ']' . + showString ", " . + showString "vkSubsetAllocation = " . + showsPrec d (vkSubsetAllocation x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkPhysicalDeviceIDPropertiesKHR.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkPhysicalDeviceIDPropertiesKHR.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkPhysicalDeviceIDPropertiesKHR.hsc @@ -0,0 +1,547 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleContexts #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE ScopedTypeVariables #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +{-# LANGUAGE UndecidableInstances #-} +module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceIDPropertiesKHR + (VkPhysicalDeviceIDPropertiesKHR(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import GHC.TypeLits (KnownNat, + natVal') -- ' closing tick for hsc2hs +import Graphics.Vulkan.Constants (VK_LUID_SIZE_KHR, + pattern VK_LUID_SIZE_KHR, + VK_UUID_SIZE, + pattern VK_UUID_SIZE) +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.BaseTypes (VkBool32) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceProperties2KHR (VkPhysicalDeviceProperties2KHR) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkPhysicalDeviceIDPropertiesKHR { +-- > VkStructureType sType; +-- > void* pNext; +-- > uint8_t deviceUUID[VK_UUID_SIZE]; +-- > uint8_t driverUUID[VK_UUID_SIZE]; +-- > uint8_t deviceLUID[VK_LUID_SIZE_KHR]; +-- > uint32_t deviceNodeMask; +-- > VkBool32 deviceLUIDValid; +-- > } VkPhysicalDeviceIDPropertiesKHR; +-- +-- +data VkPhysicalDeviceIDPropertiesKHR = VkPhysicalDeviceIDPropertiesKHR## Addr## + ByteArray## + +instance Eq VkPhysicalDeviceIDPropertiesKHR where + (VkPhysicalDeviceIDPropertiesKHR## a _) == + x@(VkPhysicalDeviceIDPropertiesKHR## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkPhysicalDeviceIDPropertiesKHR where + (VkPhysicalDeviceIDPropertiesKHR## a _) `compare` + x@(VkPhysicalDeviceIDPropertiesKHR## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkPhysicalDeviceIDPropertiesKHR where + sizeOf ~_ = #{size VkPhysicalDeviceIDPropertiesKHR} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkPhysicalDeviceIDPropertiesKHR} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkPhysicalDeviceIDPropertiesKHR where + unsafeAddr (VkPhysicalDeviceIDPropertiesKHR## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkPhysicalDeviceIDPropertiesKHR## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkPhysicalDeviceIDPropertiesKHR## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkPhysicalDeviceIDPropertiesKHR where + type StructFields VkPhysicalDeviceIDPropertiesKHR = + '["sType", "pNext", "deviceUUID", "driverUUID", "deviceLUID", -- ' closing tick for hsc2hs + "deviceNodeMask", "deviceLUIDValid"] + type CUnionType VkPhysicalDeviceIDPropertiesKHR = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkPhysicalDeviceIDPropertiesKHR = 'True -- ' closing tick for hsc2hs + type StructExtends VkPhysicalDeviceIDPropertiesKHR = + '[VkPhysicalDeviceProperties2KHR] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkPhysicalDeviceIDPropertiesKHR where + type VkSTypeMType VkPhysicalDeviceIDPropertiesKHR = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceIDPropertiesKHR, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkPhysicalDeviceIDPropertiesKHR, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkPhysicalDeviceIDPropertiesKHR, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkPhysicalDeviceIDPropertiesKHR, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkPhysicalDeviceIDPropertiesKHR where + type FieldType "sType" VkPhysicalDeviceIDPropertiesKHR = + VkStructureType + type FieldOptional "sType" VkPhysicalDeviceIDPropertiesKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkPhysicalDeviceIDPropertiesKHR = + #{offset VkPhysicalDeviceIDPropertiesKHR, sType} + type FieldIsArray "sType" VkPhysicalDeviceIDPropertiesKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceIDPropertiesKHR, sType} + +instance CanReadField "sType" VkPhysicalDeviceIDPropertiesKHR where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkPhysicalDeviceIDPropertiesKHR where + type VkPNextMType VkPhysicalDeviceIDPropertiesKHR = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceIDPropertiesKHR, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkPhysicalDeviceIDPropertiesKHR, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkPhysicalDeviceIDPropertiesKHR, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkPhysicalDeviceIDPropertiesKHR, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkPhysicalDeviceIDPropertiesKHR where + type FieldType "pNext" VkPhysicalDeviceIDPropertiesKHR = Ptr Void + type FieldOptional "pNext" VkPhysicalDeviceIDPropertiesKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkPhysicalDeviceIDPropertiesKHR = + #{offset VkPhysicalDeviceIDPropertiesKHR, pNext} + type FieldIsArray "pNext" VkPhysicalDeviceIDPropertiesKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceIDPropertiesKHR, pNext} + +instance CanReadField "pNext" VkPhysicalDeviceIDPropertiesKHR where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance {-# OVERLAPPING #-} + HasVkDeviceUUIDArray VkPhysicalDeviceIDPropertiesKHR where + type VkDeviceUUIDArrayMType VkPhysicalDeviceIDPropertiesKHR = Word8 + + {-# NOINLINE vkDeviceUUIDArray #-} + vkDeviceUUIDArray x idx + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) + (idx * sizeOf (undefined :: Word8) + + #{offset VkPhysicalDeviceIDPropertiesKHR, deviceUUID})) + + {-# INLINE vkDeviceUUIDArrayByteOffset #-} + vkDeviceUUIDArrayByteOffset ~_ + = #{offset VkPhysicalDeviceIDPropertiesKHR, deviceUUID} + + {-# INLINE readVkDeviceUUIDArray #-} + readVkDeviceUUIDArray p idx + = peekByteOff p + (idx * sizeOf (undefined :: Word8) + + #{offset VkPhysicalDeviceIDPropertiesKHR, deviceUUID}) + + {-# INLINE writeVkDeviceUUIDArray #-} + writeVkDeviceUUIDArray p idx + = pokeByteOff p + (idx * sizeOf (undefined :: Word8) + + #{offset VkPhysicalDeviceIDPropertiesKHR, deviceUUID}) + +instance {-# OVERLAPPING #-} + HasField "deviceUUID" VkPhysicalDeviceIDPropertiesKHR where + type FieldType "deviceUUID" VkPhysicalDeviceIDPropertiesKHR = Word8 + type FieldOptional "deviceUUID" VkPhysicalDeviceIDPropertiesKHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "deviceUUID" VkPhysicalDeviceIDPropertiesKHR = + #{offset VkPhysicalDeviceIDPropertiesKHR, deviceUUID} + type FieldIsArray "deviceUUID" VkPhysicalDeviceIDPropertiesKHR = + 'True -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceIDPropertiesKHR, deviceUUID} + +instance (KnownNat idx, + IndexInBounds "deviceUUID" idx VkPhysicalDeviceIDPropertiesKHR) => + CanReadFieldArray "deviceUUID" idx VkPhysicalDeviceIDPropertiesKHR + where + {-# SPECIALISE instance + CanReadFieldArray "deviceUUID" 0 VkPhysicalDeviceIDPropertiesKHR + #-} + + {-# SPECIALISE instance + CanReadFieldArray "deviceUUID" 1 VkPhysicalDeviceIDPropertiesKHR + #-} + + {-# SPECIALISE instance + CanReadFieldArray "deviceUUID" 2 VkPhysicalDeviceIDPropertiesKHR + #-} + + {-# SPECIALISE instance + CanReadFieldArray "deviceUUID" 3 VkPhysicalDeviceIDPropertiesKHR + #-} + type FieldArrayLength "deviceUUID" VkPhysicalDeviceIDPropertiesKHR + = VK_UUID_SIZE + + {-# INLINE fieldArrayLength #-} + fieldArrayLength = VK_UUID_SIZE + + {-# INLINE getFieldArray #-} + getFieldArray x + = vkDeviceUUIDArray x + (fromInteger $ natVal' (proxy## :: Proxy## idx)) -- ' closing tick for hsc2hs + + {-# INLINE readFieldArray #-} + readFieldArray x + = readVkDeviceUUIDArray x + (fromInteger $ natVal' (proxy## :: Proxy## idx)) -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkDriverUUIDArray VkPhysicalDeviceIDPropertiesKHR where + type VkDriverUUIDArrayMType VkPhysicalDeviceIDPropertiesKHR = Word8 + + {-# NOINLINE vkDriverUUIDArray #-} + vkDriverUUIDArray x idx + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) + (idx * sizeOf (undefined :: Word8) + + #{offset VkPhysicalDeviceIDPropertiesKHR, driverUUID})) + + {-# INLINE vkDriverUUIDArrayByteOffset #-} + vkDriverUUIDArrayByteOffset ~_ + = #{offset VkPhysicalDeviceIDPropertiesKHR, driverUUID} + + {-# INLINE readVkDriverUUIDArray #-} + readVkDriverUUIDArray p idx + = peekByteOff p + (idx * sizeOf (undefined :: Word8) + + #{offset VkPhysicalDeviceIDPropertiesKHR, driverUUID}) + + {-# INLINE writeVkDriverUUIDArray #-} + writeVkDriverUUIDArray p idx + = pokeByteOff p + (idx * sizeOf (undefined :: Word8) + + #{offset VkPhysicalDeviceIDPropertiesKHR, driverUUID}) + +instance {-# OVERLAPPING #-} + HasField "driverUUID" VkPhysicalDeviceIDPropertiesKHR where + type FieldType "driverUUID" VkPhysicalDeviceIDPropertiesKHR = Word8 + type FieldOptional "driverUUID" VkPhysicalDeviceIDPropertiesKHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "driverUUID" VkPhysicalDeviceIDPropertiesKHR = + #{offset VkPhysicalDeviceIDPropertiesKHR, driverUUID} + type FieldIsArray "driverUUID" VkPhysicalDeviceIDPropertiesKHR = + 'True -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceIDPropertiesKHR, driverUUID} + +instance (KnownNat idx, + IndexInBounds "driverUUID" idx VkPhysicalDeviceIDPropertiesKHR) => + CanReadFieldArray "driverUUID" idx VkPhysicalDeviceIDPropertiesKHR + where + {-# SPECIALISE instance + CanReadFieldArray "driverUUID" 0 VkPhysicalDeviceIDPropertiesKHR + #-} + + {-# SPECIALISE instance + CanReadFieldArray "driverUUID" 1 VkPhysicalDeviceIDPropertiesKHR + #-} + + {-# SPECIALISE instance + CanReadFieldArray "driverUUID" 2 VkPhysicalDeviceIDPropertiesKHR + #-} + + {-# SPECIALISE instance + CanReadFieldArray "driverUUID" 3 VkPhysicalDeviceIDPropertiesKHR + #-} + type FieldArrayLength "driverUUID" VkPhysicalDeviceIDPropertiesKHR + = VK_UUID_SIZE + + {-# INLINE fieldArrayLength #-} + fieldArrayLength = VK_UUID_SIZE + + {-# INLINE getFieldArray #-} + getFieldArray x + = vkDriverUUIDArray x + (fromInteger $ natVal' (proxy## :: Proxy## idx)) -- ' closing tick for hsc2hs + + {-# INLINE readFieldArray #-} + readFieldArray x + = readVkDriverUUIDArray x + (fromInteger $ natVal' (proxy## :: Proxy## idx)) -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkDeviceLUIDArray VkPhysicalDeviceIDPropertiesKHR where + type VkDeviceLUIDArrayMType VkPhysicalDeviceIDPropertiesKHR = Word8 + + {-# NOINLINE vkDeviceLUIDArray #-} + vkDeviceLUIDArray x idx + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) + (idx * sizeOf (undefined :: Word8) + + #{offset VkPhysicalDeviceIDPropertiesKHR, deviceLUID})) + + {-# INLINE vkDeviceLUIDArrayByteOffset #-} + vkDeviceLUIDArrayByteOffset ~_ + = #{offset VkPhysicalDeviceIDPropertiesKHR, deviceLUID} + + {-# INLINE readVkDeviceLUIDArray #-} + readVkDeviceLUIDArray p idx + = peekByteOff p + (idx * sizeOf (undefined :: Word8) + + #{offset VkPhysicalDeviceIDPropertiesKHR, deviceLUID}) + + {-# INLINE writeVkDeviceLUIDArray #-} + writeVkDeviceLUIDArray p idx + = pokeByteOff p + (idx * sizeOf (undefined :: Word8) + + #{offset VkPhysicalDeviceIDPropertiesKHR, deviceLUID}) + +instance {-# OVERLAPPING #-} + HasField "deviceLUID" VkPhysicalDeviceIDPropertiesKHR where + type FieldType "deviceLUID" VkPhysicalDeviceIDPropertiesKHR = Word8 + type FieldOptional "deviceLUID" VkPhysicalDeviceIDPropertiesKHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "deviceLUID" VkPhysicalDeviceIDPropertiesKHR = + #{offset VkPhysicalDeviceIDPropertiesKHR, deviceLUID} + type FieldIsArray "deviceLUID" VkPhysicalDeviceIDPropertiesKHR = + 'True -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceIDPropertiesKHR, deviceLUID} + +instance (KnownNat idx, + IndexInBounds "deviceLUID" idx VkPhysicalDeviceIDPropertiesKHR) => + CanReadFieldArray "deviceLUID" idx VkPhysicalDeviceIDPropertiesKHR + where + {-# SPECIALISE instance + CanReadFieldArray "deviceLUID" 0 VkPhysicalDeviceIDPropertiesKHR + #-} + + {-# SPECIALISE instance + CanReadFieldArray "deviceLUID" 1 VkPhysicalDeviceIDPropertiesKHR + #-} + + {-# SPECIALISE instance + CanReadFieldArray "deviceLUID" 2 VkPhysicalDeviceIDPropertiesKHR + #-} + + {-# SPECIALISE instance + CanReadFieldArray "deviceLUID" 3 VkPhysicalDeviceIDPropertiesKHR + #-} + type FieldArrayLength "deviceLUID" VkPhysicalDeviceIDPropertiesKHR + = VK_LUID_SIZE_KHR + + {-# INLINE fieldArrayLength #-} + fieldArrayLength = VK_LUID_SIZE_KHR + + {-# INLINE getFieldArray #-} + getFieldArray x + = vkDeviceLUIDArray x + (fromInteger $ natVal' (proxy## :: Proxy## idx)) -- ' closing tick for hsc2hs + + {-# INLINE readFieldArray #-} + readFieldArray x + = readVkDeviceLUIDArray x + (fromInteger $ natVal' (proxy## :: Proxy## idx)) -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkDeviceNodeMask VkPhysicalDeviceIDPropertiesKHR where + type VkDeviceNodeMaskMType VkPhysicalDeviceIDPropertiesKHR = Word32 + + {-# NOINLINE vkDeviceNodeMask #-} + vkDeviceNodeMask x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceIDPropertiesKHR, deviceNodeMask}) + + {-# INLINE vkDeviceNodeMaskByteOffset #-} + vkDeviceNodeMaskByteOffset ~_ + = #{offset VkPhysicalDeviceIDPropertiesKHR, deviceNodeMask} + + {-# INLINE readVkDeviceNodeMask #-} + readVkDeviceNodeMask p + = peekByteOff p #{offset VkPhysicalDeviceIDPropertiesKHR, deviceNodeMask} + + {-# INLINE writeVkDeviceNodeMask #-} + writeVkDeviceNodeMask p + = pokeByteOff p #{offset VkPhysicalDeviceIDPropertiesKHR, deviceNodeMask} + +instance {-# OVERLAPPING #-} + HasField "deviceNodeMask" VkPhysicalDeviceIDPropertiesKHR where + type FieldType "deviceNodeMask" VkPhysicalDeviceIDPropertiesKHR = + Word32 + type FieldOptional "deviceNodeMask" VkPhysicalDeviceIDPropertiesKHR + = 'False -- ' closing tick for hsc2hs + type FieldOffset "deviceNodeMask" VkPhysicalDeviceIDPropertiesKHR = + #{offset VkPhysicalDeviceIDPropertiesKHR, deviceNodeMask} + type FieldIsArray "deviceNodeMask" VkPhysicalDeviceIDPropertiesKHR + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceIDPropertiesKHR, deviceNodeMask} + +instance CanReadField "deviceNodeMask" + VkPhysicalDeviceIDPropertiesKHR + where + {-# INLINE getField #-} + getField = vkDeviceNodeMask + + {-# INLINE readField #-} + readField = readVkDeviceNodeMask + +instance {-# OVERLAPPING #-} + HasVkDeviceLUIDValid VkPhysicalDeviceIDPropertiesKHR where + type VkDeviceLUIDValidMType VkPhysicalDeviceIDPropertiesKHR = + VkBool32 + + {-# NOINLINE vkDeviceLUIDValid #-} + vkDeviceLUIDValid x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceIDPropertiesKHR, deviceLUIDValid}) + + {-# INLINE vkDeviceLUIDValidByteOffset #-} + vkDeviceLUIDValidByteOffset ~_ + = #{offset VkPhysicalDeviceIDPropertiesKHR, deviceLUIDValid} + + {-# INLINE readVkDeviceLUIDValid #-} + readVkDeviceLUIDValid p + = peekByteOff p #{offset VkPhysicalDeviceIDPropertiesKHR, deviceLUIDValid} + + {-# INLINE writeVkDeviceLUIDValid #-} + writeVkDeviceLUIDValid p + = pokeByteOff p #{offset VkPhysicalDeviceIDPropertiesKHR, deviceLUIDValid} + +instance {-# OVERLAPPING #-} + HasField "deviceLUIDValid" VkPhysicalDeviceIDPropertiesKHR where + type FieldType "deviceLUIDValid" VkPhysicalDeviceIDPropertiesKHR = + VkBool32 + type FieldOptional "deviceLUIDValid" + VkPhysicalDeviceIDPropertiesKHR + = 'False -- ' closing tick for hsc2hs + type FieldOffset "deviceLUIDValid" VkPhysicalDeviceIDPropertiesKHR + = + #{offset VkPhysicalDeviceIDPropertiesKHR, deviceLUIDValid} + type FieldIsArray "deviceLUIDValid" VkPhysicalDeviceIDPropertiesKHR + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceIDPropertiesKHR, deviceLUIDValid} + +instance CanReadField "deviceLUIDValid" + VkPhysicalDeviceIDPropertiesKHR + where + {-# INLINE getField #-} + getField = vkDeviceLUIDValid + + {-# INLINE readField #-} + readField = readVkDeviceLUIDValid + +instance Show VkPhysicalDeviceIDPropertiesKHR where + showsPrec d x + = showString "VkPhysicalDeviceIDPropertiesKHR {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkDeviceUUIDArray = [" . + showsPrec d (map (vkDeviceUUIDArray x) [1 .. VK_UUID_SIZE]) . + showChar ']' . + showString ", " . + showString "vkDriverUUIDArray = [" . + showsPrec d (map (vkDriverUUIDArray x) [1 .. VK_UUID_SIZE]) . + showChar ']' . + showString ", " . + showString "vkDeviceLUIDArray = [" . + showsPrec d + (map (vkDeviceLUIDArray x) [1 .. VK_LUID_SIZE_KHR]) + . + showChar ']' . + showString ", " . + showString "vkDeviceNodeMask = " . + showsPrec d (vkDeviceNodeMask x) . + showString ", " . + showString "vkDeviceLUIDValid = " . + showsPrec d (vkDeviceLUIDValid x) . + showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkPhysicalDeviceImageFormatInfo2KHR.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkPhysicalDeviceImageFormatInfo2KHR.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkPhysicalDeviceImageFormatInfo2KHR.hsc @@ -0,0 +1,479 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceImageFormatInfo2KHR + (VkPhysicalDeviceImageFormatInfo2KHR(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkFormat (VkFormat) +import Graphics.Vulkan.Types.Enum.VkImageCreateFlags (VkImageCreateFlags) +import Graphics.Vulkan.Types.Enum.VkImageTiling (VkImageTiling) +import Graphics.Vulkan.Types.Enum.VkImageType (VkImageType) +import Graphics.Vulkan.Types.Enum.VkImageUsageFlags (VkImageUsageFlags) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkPhysicalDeviceImageFormatInfo2KHR { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkFormat format; +-- > VkImageType type; +-- > VkImageTiling tiling; +-- > VkImageUsageFlags usage; +-- > VkImageCreateFlags flags; +-- > } VkPhysicalDeviceImageFormatInfo2KHR; +-- +-- +data VkPhysicalDeviceImageFormatInfo2KHR = VkPhysicalDeviceImageFormatInfo2KHR## Addr## + ByteArray## + +instance Eq VkPhysicalDeviceImageFormatInfo2KHR where + (VkPhysicalDeviceImageFormatInfo2KHR## a _) == + x@(VkPhysicalDeviceImageFormatInfo2KHR## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkPhysicalDeviceImageFormatInfo2KHR where + (VkPhysicalDeviceImageFormatInfo2KHR## a _) `compare` + x@(VkPhysicalDeviceImageFormatInfo2KHR## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkPhysicalDeviceImageFormatInfo2KHR where + sizeOf ~_ = #{size VkPhysicalDeviceImageFormatInfo2KHR} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkPhysicalDeviceImageFormatInfo2KHR} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkPhysicalDeviceImageFormatInfo2KHR + where + unsafeAddr (VkPhysicalDeviceImageFormatInfo2KHR## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkPhysicalDeviceImageFormatInfo2KHR## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkPhysicalDeviceImageFormatInfo2KHR## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkPhysicalDeviceImageFormatInfo2KHR where + type StructFields VkPhysicalDeviceImageFormatInfo2KHR = + '["sType", "pNext", "format", "type", "tiling", "usage", "flags"] -- ' closing tick for hsc2hs + type CUnionType VkPhysicalDeviceImageFormatInfo2KHR = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkPhysicalDeviceImageFormatInfo2KHR = 'False -- ' closing tick for hsc2hs + type StructExtends VkPhysicalDeviceImageFormatInfo2KHR = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkPhysicalDeviceImageFormatInfo2KHR where + type VkSTypeMType VkPhysicalDeviceImageFormatInfo2KHR = + VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceImageFormatInfo2KHR, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkPhysicalDeviceImageFormatInfo2KHR, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkPhysicalDeviceImageFormatInfo2KHR, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkPhysicalDeviceImageFormatInfo2KHR, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkPhysicalDeviceImageFormatInfo2KHR where + type FieldType "sType" VkPhysicalDeviceImageFormatInfo2KHR = + VkStructureType + type FieldOptional "sType" VkPhysicalDeviceImageFormatInfo2KHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkPhysicalDeviceImageFormatInfo2KHR = + #{offset VkPhysicalDeviceImageFormatInfo2KHR, sType} + type FieldIsArray "sType" VkPhysicalDeviceImageFormatInfo2KHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceImageFormatInfo2KHR, sType} + +instance CanReadField "sType" VkPhysicalDeviceImageFormatInfo2KHR + where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkPhysicalDeviceImageFormatInfo2KHR + where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkPhysicalDeviceImageFormatInfo2KHR where + type VkPNextMType VkPhysicalDeviceImageFormatInfo2KHR = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceImageFormatInfo2KHR, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkPhysicalDeviceImageFormatInfo2KHR, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkPhysicalDeviceImageFormatInfo2KHR, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkPhysicalDeviceImageFormatInfo2KHR, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkPhysicalDeviceImageFormatInfo2KHR where + type FieldType "pNext" VkPhysicalDeviceImageFormatInfo2KHR = + Ptr Void + type FieldOptional "pNext" VkPhysicalDeviceImageFormatInfo2KHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkPhysicalDeviceImageFormatInfo2KHR = + #{offset VkPhysicalDeviceImageFormatInfo2KHR, pNext} + type FieldIsArray "pNext" VkPhysicalDeviceImageFormatInfo2KHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceImageFormatInfo2KHR, pNext} + +instance CanReadField "pNext" VkPhysicalDeviceImageFormatInfo2KHR + where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkPhysicalDeviceImageFormatInfo2KHR + where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkFormat VkPhysicalDeviceImageFormatInfo2KHR where + type VkFormatMType VkPhysicalDeviceImageFormatInfo2KHR = VkFormat + + {-# NOINLINE vkFormat #-} + vkFormat x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceImageFormatInfo2KHR, format}) + + {-# INLINE vkFormatByteOffset #-} + vkFormatByteOffset ~_ + = #{offset VkPhysicalDeviceImageFormatInfo2KHR, format} + + {-# INLINE readVkFormat #-} + readVkFormat p + = peekByteOff p #{offset VkPhysicalDeviceImageFormatInfo2KHR, format} + + {-# INLINE writeVkFormat #-} + writeVkFormat p + = pokeByteOff p #{offset VkPhysicalDeviceImageFormatInfo2KHR, format} + +instance {-# OVERLAPPING #-} + HasField "format" VkPhysicalDeviceImageFormatInfo2KHR where + type FieldType "format" VkPhysicalDeviceImageFormatInfo2KHR = + VkFormat + type FieldOptional "format" VkPhysicalDeviceImageFormatInfo2KHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "format" VkPhysicalDeviceImageFormatInfo2KHR = + #{offset VkPhysicalDeviceImageFormatInfo2KHR, format} + type FieldIsArray "format" VkPhysicalDeviceImageFormatInfo2KHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceImageFormatInfo2KHR, format} + +instance CanReadField "format" VkPhysicalDeviceImageFormatInfo2KHR + where + {-# INLINE getField #-} + getField = vkFormat + + {-# INLINE readField #-} + readField = readVkFormat + +instance CanWriteField "format" VkPhysicalDeviceImageFormatInfo2KHR + where + {-# INLINE writeField #-} + writeField = writeVkFormat + +instance {-# OVERLAPPING #-} + HasVkType VkPhysicalDeviceImageFormatInfo2KHR where + type VkTypeMType VkPhysicalDeviceImageFormatInfo2KHR = VkImageType + + {-# NOINLINE vkType #-} + vkType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceImageFormatInfo2KHR, type}) + + {-# INLINE vkTypeByteOffset #-} + vkTypeByteOffset ~_ + = #{offset VkPhysicalDeviceImageFormatInfo2KHR, type} + + {-# INLINE readVkType #-} + readVkType p + = peekByteOff p #{offset VkPhysicalDeviceImageFormatInfo2KHR, type} + + {-# INLINE writeVkType #-} + writeVkType p + = pokeByteOff p #{offset VkPhysicalDeviceImageFormatInfo2KHR, type} + +instance {-# OVERLAPPING #-} + HasField "type" VkPhysicalDeviceImageFormatInfo2KHR where + type FieldType "type" VkPhysicalDeviceImageFormatInfo2KHR = + VkImageType + type FieldOptional "type" VkPhysicalDeviceImageFormatInfo2KHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "type" VkPhysicalDeviceImageFormatInfo2KHR = + #{offset VkPhysicalDeviceImageFormatInfo2KHR, type} + type FieldIsArray "type" VkPhysicalDeviceImageFormatInfo2KHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceImageFormatInfo2KHR, type} + +instance CanReadField "type" VkPhysicalDeviceImageFormatInfo2KHR + where + {-# INLINE getField #-} + getField = vkType + + {-# INLINE readField #-} + readField = readVkType + +instance CanWriteField "type" VkPhysicalDeviceImageFormatInfo2KHR + where + {-# INLINE writeField #-} + writeField = writeVkType + +instance {-# OVERLAPPING #-} + HasVkTiling VkPhysicalDeviceImageFormatInfo2KHR where + type VkTilingMType VkPhysicalDeviceImageFormatInfo2KHR = + VkImageTiling + + {-# NOINLINE vkTiling #-} + vkTiling x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceImageFormatInfo2KHR, tiling}) + + {-# INLINE vkTilingByteOffset #-} + vkTilingByteOffset ~_ + = #{offset VkPhysicalDeviceImageFormatInfo2KHR, tiling} + + {-# INLINE readVkTiling #-} + readVkTiling p + = peekByteOff p #{offset VkPhysicalDeviceImageFormatInfo2KHR, tiling} + + {-# INLINE writeVkTiling #-} + writeVkTiling p + = pokeByteOff p #{offset VkPhysicalDeviceImageFormatInfo2KHR, tiling} + +instance {-# OVERLAPPING #-} + HasField "tiling" VkPhysicalDeviceImageFormatInfo2KHR where + type FieldType "tiling" VkPhysicalDeviceImageFormatInfo2KHR = + VkImageTiling + type FieldOptional "tiling" VkPhysicalDeviceImageFormatInfo2KHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "tiling" VkPhysicalDeviceImageFormatInfo2KHR = + #{offset VkPhysicalDeviceImageFormatInfo2KHR, tiling} + type FieldIsArray "tiling" VkPhysicalDeviceImageFormatInfo2KHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceImageFormatInfo2KHR, tiling} + +instance CanReadField "tiling" VkPhysicalDeviceImageFormatInfo2KHR + where + {-# INLINE getField #-} + getField = vkTiling + + {-# INLINE readField #-} + readField = readVkTiling + +instance CanWriteField "tiling" VkPhysicalDeviceImageFormatInfo2KHR + where + {-# INLINE writeField #-} + writeField = writeVkTiling + +instance {-# OVERLAPPING #-} + HasVkUsage VkPhysicalDeviceImageFormatInfo2KHR where + type VkUsageMType VkPhysicalDeviceImageFormatInfo2KHR = + VkImageUsageFlags + + {-# NOINLINE vkUsage #-} + vkUsage x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceImageFormatInfo2KHR, usage}) + + {-# INLINE vkUsageByteOffset #-} + vkUsageByteOffset ~_ + = #{offset VkPhysicalDeviceImageFormatInfo2KHR, usage} + + {-# INLINE readVkUsage #-} + readVkUsage p + = peekByteOff p #{offset VkPhysicalDeviceImageFormatInfo2KHR, usage} + + {-# INLINE writeVkUsage #-} + writeVkUsage p + = pokeByteOff p #{offset VkPhysicalDeviceImageFormatInfo2KHR, usage} + +instance {-# OVERLAPPING #-} + HasField "usage" VkPhysicalDeviceImageFormatInfo2KHR where + type FieldType "usage" VkPhysicalDeviceImageFormatInfo2KHR = + VkImageUsageFlags + type FieldOptional "usage" VkPhysicalDeviceImageFormatInfo2KHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "usage" VkPhysicalDeviceImageFormatInfo2KHR = + #{offset VkPhysicalDeviceImageFormatInfo2KHR, usage} + type FieldIsArray "usage" VkPhysicalDeviceImageFormatInfo2KHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceImageFormatInfo2KHR, usage} + +instance CanReadField "usage" VkPhysicalDeviceImageFormatInfo2KHR + where + {-# INLINE getField #-} + getField = vkUsage + + {-# INLINE readField #-} + readField = readVkUsage + +instance CanWriteField "usage" VkPhysicalDeviceImageFormatInfo2KHR + where + {-# INLINE writeField #-} + writeField = writeVkUsage + +instance {-# OVERLAPPING #-} + HasVkFlags VkPhysicalDeviceImageFormatInfo2KHR where + type VkFlagsMType VkPhysicalDeviceImageFormatInfo2KHR = + VkImageCreateFlags + + {-# NOINLINE vkFlags #-} + vkFlags x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceImageFormatInfo2KHR, flags}) + + {-# INLINE vkFlagsByteOffset #-} + vkFlagsByteOffset ~_ + = #{offset VkPhysicalDeviceImageFormatInfo2KHR, flags} + + {-# INLINE readVkFlags #-} + readVkFlags p + = peekByteOff p #{offset VkPhysicalDeviceImageFormatInfo2KHR, flags} + + {-# INLINE writeVkFlags #-} + writeVkFlags p + = pokeByteOff p #{offset VkPhysicalDeviceImageFormatInfo2KHR, flags} + +instance {-# OVERLAPPING #-} + HasField "flags" VkPhysicalDeviceImageFormatInfo2KHR where + type FieldType "flags" VkPhysicalDeviceImageFormatInfo2KHR = + VkImageCreateFlags + type FieldOptional "flags" VkPhysicalDeviceImageFormatInfo2KHR = + 'True -- ' closing tick for hsc2hs + type FieldOffset "flags" VkPhysicalDeviceImageFormatInfo2KHR = + #{offset VkPhysicalDeviceImageFormatInfo2KHR, flags} + type FieldIsArray "flags" VkPhysicalDeviceImageFormatInfo2KHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceImageFormatInfo2KHR, flags} + +instance CanReadField "flags" VkPhysicalDeviceImageFormatInfo2KHR + where + {-# INLINE getField #-} + getField = vkFlags + + {-# INLINE readField #-} + readField = readVkFlags + +instance CanWriteField "flags" VkPhysicalDeviceImageFormatInfo2KHR + where + {-# INLINE writeField #-} + writeField = writeVkFlags + +instance Show VkPhysicalDeviceImageFormatInfo2KHR where + showsPrec d x + = showString "VkPhysicalDeviceImageFormatInfo2KHR {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkFormat = " . + showsPrec d (vkFormat x) . + showString ", " . + showString "vkType = " . + showsPrec d (vkType x) . + showString ", " . + showString "vkTiling = " . + showsPrec d (vkTiling x) . + showString ", " . + showString "vkUsage = " . + showsPrec d (vkUsage x) . + showString ", " . + showString "vkFlags = " . + showsPrec d (vkFlags x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkPhysicalDeviceLimits.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkPhysicalDeviceLimits.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkPhysicalDeviceLimits.hsc @@ -0,0 +1,7011 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleContexts #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE ScopedTypeVariables #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +{-# LANGUAGE UndecidableInstances #-} +module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceLimits + (VkPhysicalDeviceLimits(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import GHC.TypeLits (KnownNat, + natVal') -- ' closing tick for hsc2hs +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.BaseTypes (VkBool32, + VkDeviceSize) +import Graphics.Vulkan.Types.Enum.VkSampleCountFlags (VkSampleCountFlags) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef 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; +-- > } VkPhysicalDeviceLimits; +-- +-- +data VkPhysicalDeviceLimits = VkPhysicalDeviceLimits## Addr## + ByteArray## + +instance Eq VkPhysicalDeviceLimits where + (VkPhysicalDeviceLimits## a _) == x@(VkPhysicalDeviceLimits## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkPhysicalDeviceLimits where + (VkPhysicalDeviceLimits## a _) `compare` + x@(VkPhysicalDeviceLimits## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkPhysicalDeviceLimits where + sizeOf ~_ = #{size VkPhysicalDeviceLimits} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkPhysicalDeviceLimits} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkPhysicalDeviceLimits where + unsafeAddr (VkPhysicalDeviceLimits## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkPhysicalDeviceLimits## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkPhysicalDeviceLimits## (plusAddr## (byteArrayContents## b) off) b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkPhysicalDeviceLimits where + type StructFields VkPhysicalDeviceLimits = + '["maxImageDimension1D", "maxImageDimension2D", -- ' closing tick for hsc2hs + "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"] + type CUnionType VkPhysicalDeviceLimits = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkPhysicalDeviceLimits = 'True -- ' closing tick for hsc2hs + type StructExtends VkPhysicalDeviceLimits = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkMaxImageDimension1D VkPhysicalDeviceLimits where + type VkMaxImageDimension1DMType VkPhysicalDeviceLimits = Word32 + + {-# NOINLINE vkMaxImageDimension1D #-} + vkMaxImageDimension1D x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceLimits, maxImageDimension1D}) + + {-# INLINE vkMaxImageDimension1DByteOffset #-} + vkMaxImageDimension1DByteOffset ~_ + = #{offset VkPhysicalDeviceLimits, maxImageDimension1D} + + {-# INLINE readVkMaxImageDimension1D #-} + readVkMaxImageDimension1D p + = peekByteOff p #{offset VkPhysicalDeviceLimits, maxImageDimension1D} + + {-# INLINE writeVkMaxImageDimension1D #-} + writeVkMaxImageDimension1D p + = pokeByteOff p #{offset VkPhysicalDeviceLimits, maxImageDimension1D} + +instance {-# OVERLAPPING #-} + HasField "maxImageDimension1D" VkPhysicalDeviceLimits where + type FieldType "maxImageDimension1D" VkPhysicalDeviceLimits = + Word32 + type FieldOptional "maxImageDimension1D" VkPhysicalDeviceLimits = + 'False -- ' closing tick for hsc2hs + type FieldOffset "maxImageDimension1D" VkPhysicalDeviceLimits = + #{offset VkPhysicalDeviceLimits, maxImageDimension1D} + type FieldIsArray "maxImageDimension1D" VkPhysicalDeviceLimits = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceLimits, maxImageDimension1D} + +instance CanReadField "maxImageDimension1D" VkPhysicalDeviceLimits + where + {-# INLINE getField #-} + getField = vkMaxImageDimension1D + + {-# INLINE readField #-} + readField = readVkMaxImageDimension1D + +instance {-# OVERLAPPING #-} + HasVkMaxImageDimension2D VkPhysicalDeviceLimits where + type VkMaxImageDimension2DMType VkPhysicalDeviceLimits = Word32 + + {-# NOINLINE vkMaxImageDimension2D #-} + vkMaxImageDimension2D x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceLimits, maxImageDimension2D}) + + {-# INLINE vkMaxImageDimension2DByteOffset #-} + vkMaxImageDimension2DByteOffset ~_ + = #{offset VkPhysicalDeviceLimits, maxImageDimension2D} + + {-# INLINE readVkMaxImageDimension2D #-} + readVkMaxImageDimension2D p + = peekByteOff p #{offset VkPhysicalDeviceLimits, maxImageDimension2D} + + {-# INLINE writeVkMaxImageDimension2D #-} + writeVkMaxImageDimension2D p + = pokeByteOff p #{offset VkPhysicalDeviceLimits, maxImageDimension2D} + +instance {-# OVERLAPPING #-} + HasField "maxImageDimension2D" VkPhysicalDeviceLimits where + type FieldType "maxImageDimension2D" VkPhysicalDeviceLimits = + Word32 + type FieldOptional "maxImageDimension2D" VkPhysicalDeviceLimits = + 'False -- ' closing tick for hsc2hs + type FieldOffset "maxImageDimension2D" VkPhysicalDeviceLimits = + #{offset VkPhysicalDeviceLimits, maxImageDimension2D} + type FieldIsArray "maxImageDimension2D" VkPhysicalDeviceLimits = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceLimits, maxImageDimension2D} + +instance CanReadField "maxImageDimension2D" VkPhysicalDeviceLimits + where + {-# INLINE getField #-} + getField = vkMaxImageDimension2D + + {-# INLINE readField #-} + readField = readVkMaxImageDimension2D + +instance {-# OVERLAPPING #-} + HasVkMaxImageDimension3D VkPhysicalDeviceLimits where + type VkMaxImageDimension3DMType VkPhysicalDeviceLimits = Word32 + + {-# NOINLINE vkMaxImageDimension3D #-} + vkMaxImageDimension3D x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceLimits, maxImageDimension3D}) + + {-# INLINE vkMaxImageDimension3DByteOffset #-} + vkMaxImageDimension3DByteOffset ~_ + = #{offset VkPhysicalDeviceLimits, maxImageDimension3D} + + {-# INLINE readVkMaxImageDimension3D #-} + readVkMaxImageDimension3D p + = peekByteOff p #{offset VkPhysicalDeviceLimits, maxImageDimension3D} + + {-# INLINE writeVkMaxImageDimension3D #-} + writeVkMaxImageDimension3D p + = pokeByteOff p #{offset VkPhysicalDeviceLimits, maxImageDimension3D} + +instance {-# OVERLAPPING #-} + HasField "maxImageDimension3D" VkPhysicalDeviceLimits where + type FieldType "maxImageDimension3D" VkPhysicalDeviceLimits = + Word32 + type FieldOptional "maxImageDimension3D" VkPhysicalDeviceLimits = + 'False -- ' closing tick for hsc2hs + type FieldOffset "maxImageDimension3D" VkPhysicalDeviceLimits = + #{offset VkPhysicalDeviceLimits, maxImageDimension3D} + type FieldIsArray "maxImageDimension3D" VkPhysicalDeviceLimits = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceLimits, maxImageDimension3D} + +instance CanReadField "maxImageDimension3D" VkPhysicalDeviceLimits + where + {-# INLINE getField #-} + getField = vkMaxImageDimension3D + + {-# INLINE readField #-} + readField = readVkMaxImageDimension3D + +instance {-# OVERLAPPING #-} + HasVkMaxImageDimensionCube VkPhysicalDeviceLimits where + type VkMaxImageDimensionCubeMType VkPhysicalDeviceLimits = Word32 + + {-# NOINLINE vkMaxImageDimensionCube #-} + vkMaxImageDimensionCube x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceLimits, maxImageDimensionCube}) + + {-# INLINE vkMaxImageDimensionCubeByteOffset #-} + vkMaxImageDimensionCubeByteOffset ~_ + = #{offset VkPhysicalDeviceLimits, maxImageDimensionCube} + + {-# INLINE readVkMaxImageDimensionCube #-} + readVkMaxImageDimensionCube p + = peekByteOff p #{offset VkPhysicalDeviceLimits, maxImageDimensionCube} + + {-# INLINE writeVkMaxImageDimensionCube #-} + writeVkMaxImageDimensionCube p + = pokeByteOff p #{offset VkPhysicalDeviceLimits, maxImageDimensionCube} + +instance {-# OVERLAPPING #-} + HasField "maxImageDimensionCube" VkPhysicalDeviceLimits where + type FieldType "maxImageDimensionCube" VkPhysicalDeviceLimits = + Word32 + type FieldOptional "maxImageDimensionCube" VkPhysicalDeviceLimits = + 'False -- ' closing tick for hsc2hs + type FieldOffset "maxImageDimensionCube" VkPhysicalDeviceLimits = + #{offset VkPhysicalDeviceLimits, maxImageDimensionCube} + type FieldIsArray "maxImageDimensionCube" VkPhysicalDeviceLimits = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceLimits, maxImageDimensionCube} + +instance CanReadField "maxImageDimensionCube" + VkPhysicalDeviceLimits + where + {-# INLINE getField #-} + getField = vkMaxImageDimensionCube + + {-# INLINE readField #-} + readField = readVkMaxImageDimensionCube + +instance {-# OVERLAPPING #-} + HasVkMaxImageArrayLayers VkPhysicalDeviceLimits where + type VkMaxImageArrayLayersMType VkPhysicalDeviceLimits = Word32 + + {-# NOINLINE vkMaxImageArrayLayers #-} + vkMaxImageArrayLayers x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceLimits, maxImageArrayLayers}) + + {-# INLINE vkMaxImageArrayLayersByteOffset #-} + vkMaxImageArrayLayersByteOffset ~_ + = #{offset VkPhysicalDeviceLimits, maxImageArrayLayers} + + {-# INLINE readVkMaxImageArrayLayers #-} + readVkMaxImageArrayLayers p + = peekByteOff p #{offset VkPhysicalDeviceLimits, maxImageArrayLayers} + + {-# INLINE writeVkMaxImageArrayLayers #-} + writeVkMaxImageArrayLayers p + = pokeByteOff p #{offset VkPhysicalDeviceLimits, maxImageArrayLayers} + +instance {-# OVERLAPPING #-} + HasField "maxImageArrayLayers" VkPhysicalDeviceLimits where + type FieldType "maxImageArrayLayers" VkPhysicalDeviceLimits = + Word32 + type FieldOptional "maxImageArrayLayers" VkPhysicalDeviceLimits = + 'False -- ' closing tick for hsc2hs + type FieldOffset "maxImageArrayLayers" VkPhysicalDeviceLimits = + #{offset VkPhysicalDeviceLimits, maxImageArrayLayers} + type FieldIsArray "maxImageArrayLayers" VkPhysicalDeviceLimits = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceLimits, maxImageArrayLayers} + +instance CanReadField "maxImageArrayLayers" VkPhysicalDeviceLimits + where + {-# INLINE getField #-} + getField = vkMaxImageArrayLayers + + {-# INLINE readField #-} + readField = readVkMaxImageArrayLayers + +instance {-# OVERLAPPING #-} + HasVkMaxTexelBufferElements VkPhysicalDeviceLimits where + type VkMaxTexelBufferElementsMType VkPhysicalDeviceLimits = Word32 + + {-# NOINLINE vkMaxTexelBufferElements #-} + vkMaxTexelBufferElements x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceLimits, maxTexelBufferElements}) + + {-# INLINE vkMaxTexelBufferElementsByteOffset #-} + vkMaxTexelBufferElementsByteOffset ~_ + = #{offset VkPhysicalDeviceLimits, maxTexelBufferElements} + + {-# INLINE readVkMaxTexelBufferElements #-} + readVkMaxTexelBufferElements p + = peekByteOff p #{offset VkPhysicalDeviceLimits, maxTexelBufferElements} + + {-# INLINE writeVkMaxTexelBufferElements #-} + writeVkMaxTexelBufferElements p + = pokeByteOff p #{offset VkPhysicalDeviceLimits, maxTexelBufferElements} + +instance {-# OVERLAPPING #-} + HasField "maxTexelBufferElements" VkPhysicalDeviceLimits where + type FieldType "maxTexelBufferElements" VkPhysicalDeviceLimits = + Word32 + type FieldOptional "maxTexelBufferElements" VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + type FieldOffset "maxTexelBufferElements" VkPhysicalDeviceLimits = + #{offset VkPhysicalDeviceLimits, maxTexelBufferElements} + type FieldIsArray "maxTexelBufferElements" VkPhysicalDeviceLimits = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceLimits, maxTexelBufferElements} + +instance CanReadField "maxTexelBufferElements" + VkPhysicalDeviceLimits + where + {-# INLINE getField #-} + getField = vkMaxTexelBufferElements + + {-# INLINE readField #-} + readField = readVkMaxTexelBufferElements + +instance {-# OVERLAPPING #-} + HasVkMaxUniformBufferRange VkPhysicalDeviceLimits where + type VkMaxUniformBufferRangeMType VkPhysicalDeviceLimits = Word32 + + {-# NOINLINE vkMaxUniformBufferRange #-} + vkMaxUniformBufferRange x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceLimits, maxUniformBufferRange}) + + {-# INLINE vkMaxUniformBufferRangeByteOffset #-} + vkMaxUniformBufferRangeByteOffset ~_ + = #{offset VkPhysicalDeviceLimits, maxUniformBufferRange} + + {-# INLINE readVkMaxUniformBufferRange #-} + readVkMaxUniformBufferRange p + = peekByteOff p #{offset VkPhysicalDeviceLimits, maxUniformBufferRange} + + {-# INLINE writeVkMaxUniformBufferRange #-} + writeVkMaxUniformBufferRange p + = pokeByteOff p #{offset VkPhysicalDeviceLimits, maxUniformBufferRange} + +instance {-# OVERLAPPING #-} + HasField "maxUniformBufferRange" VkPhysicalDeviceLimits where + type FieldType "maxUniformBufferRange" VkPhysicalDeviceLimits = + Word32 + type FieldOptional "maxUniformBufferRange" VkPhysicalDeviceLimits = + 'False -- ' closing tick for hsc2hs + type FieldOffset "maxUniformBufferRange" VkPhysicalDeviceLimits = + #{offset VkPhysicalDeviceLimits, maxUniformBufferRange} + type FieldIsArray "maxUniformBufferRange" VkPhysicalDeviceLimits = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceLimits, maxUniformBufferRange} + +instance CanReadField "maxUniformBufferRange" + VkPhysicalDeviceLimits + where + {-# INLINE getField #-} + getField = vkMaxUniformBufferRange + + {-# INLINE readField #-} + readField = readVkMaxUniformBufferRange + +instance {-# OVERLAPPING #-} + HasVkMaxStorageBufferRange VkPhysicalDeviceLimits where + type VkMaxStorageBufferRangeMType VkPhysicalDeviceLimits = Word32 + + {-# NOINLINE vkMaxStorageBufferRange #-} + vkMaxStorageBufferRange x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceLimits, maxStorageBufferRange}) + + {-# INLINE vkMaxStorageBufferRangeByteOffset #-} + vkMaxStorageBufferRangeByteOffset ~_ + = #{offset VkPhysicalDeviceLimits, maxStorageBufferRange} + + {-# INLINE readVkMaxStorageBufferRange #-} + readVkMaxStorageBufferRange p + = peekByteOff p #{offset VkPhysicalDeviceLimits, maxStorageBufferRange} + + {-# INLINE writeVkMaxStorageBufferRange #-} + writeVkMaxStorageBufferRange p + = pokeByteOff p #{offset VkPhysicalDeviceLimits, maxStorageBufferRange} + +instance {-# OVERLAPPING #-} + HasField "maxStorageBufferRange" VkPhysicalDeviceLimits where + type FieldType "maxStorageBufferRange" VkPhysicalDeviceLimits = + Word32 + type FieldOptional "maxStorageBufferRange" VkPhysicalDeviceLimits = + 'False -- ' closing tick for hsc2hs + type FieldOffset "maxStorageBufferRange" VkPhysicalDeviceLimits = + #{offset VkPhysicalDeviceLimits, maxStorageBufferRange} + type FieldIsArray "maxStorageBufferRange" VkPhysicalDeviceLimits = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceLimits, maxStorageBufferRange} + +instance CanReadField "maxStorageBufferRange" + VkPhysicalDeviceLimits + where + {-# INLINE getField #-} + getField = vkMaxStorageBufferRange + + {-# INLINE readField #-} + readField = readVkMaxStorageBufferRange + +instance {-# OVERLAPPING #-} + HasVkMaxPushConstantsSize VkPhysicalDeviceLimits where + type VkMaxPushConstantsSizeMType VkPhysicalDeviceLimits = Word32 + + {-# NOINLINE vkMaxPushConstantsSize #-} + vkMaxPushConstantsSize x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceLimits, maxPushConstantsSize}) + + {-# INLINE vkMaxPushConstantsSizeByteOffset #-} + vkMaxPushConstantsSizeByteOffset ~_ + = #{offset VkPhysicalDeviceLimits, maxPushConstantsSize} + + {-# INLINE readVkMaxPushConstantsSize #-} + readVkMaxPushConstantsSize p + = peekByteOff p #{offset VkPhysicalDeviceLimits, maxPushConstantsSize} + + {-# INLINE writeVkMaxPushConstantsSize #-} + writeVkMaxPushConstantsSize p + = pokeByteOff p #{offset VkPhysicalDeviceLimits, maxPushConstantsSize} + +instance {-# OVERLAPPING #-} + HasField "maxPushConstantsSize" VkPhysicalDeviceLimits where + type FieldType "maxPushConstantsSize" VkPhysicalDeviceLimits = + Word32 + type FieldOptional "maxPushConstantsSize" VkPhysicalDeviceLimits = + 'False -- ' closing tick for hsc2hs + type FieldOffset "maxPushConstantsSize" VkPhysicalDeviceLimits = + #{offset VkPhysicalDeviceLimits, maxPushConstantsSize} + type FieldIsArray "maxPushConstantsSize" VkPhysicalDeviceLimits = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceLimits, maxPushConstantsSize} + +instance CanReadField "maxPushConstantsSize" VkPhysicalDeviceLimits + where + {-# INLINE getField #-} + getField = vkMaxPushConstantsSize + + {-# INLINE readField #-} + readField = readVkMaxPushConstantsSize + +instance {-# OVERLAPPING #-} + HasVkMaxMemoryAllocationCount VkPhysicalDeviceLimits where + type VkMaxMemoryAllocationCountMType VkPhysicalDeviceLimits = + Word32 + + {-# NOINLINE vkMaxMemoryAllocationCount #-} + vkMaxMemoryAllocationCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceLimits, maxMemoryAllocationCount}) + + {-# INLINE vkMaxMemoryAllocationCountByteOffset #-} + vkMaxMemoryAllocationCountByteOffset ~_ + = #{offset VkPhysicalDeviceLimits, maxMemoryAllocationCount} + + {-# INLINE readVkMaxMemoryAllocationCount #-} + readVkMaxMemoryAllocationCount p + = peekByteOff p #{offset VkPhysicalDeviceLimits, maxMemoryAllocationCount} + + {-# INLINE writeVkMaxMemoryAllocationCount #-} + writeVkMaxMemoryAllocationCount p + = pokeByteOff p #{offset VkPhysicalDeviceLimits, maxMemoryAllocationCount} + +instance {-# OVERLAPPING #-} + HasField "maxMemoryAllocationCount" VkPhysicalDeviceLimits where + type FieldType "maxMemoryAllocationCount" VkPhysicalDeviceLimits = + Word32 + type FieldOptional "maxMemoryAllocationCount" + VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + type FieldOffset "maxMemoryAllocationCount" VkPhysicalDeviceLimits + = + #{offset VkPhysicalDeviceLimits, maxMemoryAllocationCount} + type FieldIsArray "maxMemoryAllocationCount" VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceLimits, maxMemoryAllocationCount} + +instance CanReadField "maxMemoryAllocationCount" + VkPhysicalDeviceLimits + where + {-# INLINE getField #-} + getField = vkMaxMemoryAllocationCount + + {-# INLINE readField #-} + readField = readVkMaxMemoryAllocationCount + +instance {-# OVERLAPPING #-} + HasVkMaxSamplerAllocationCount VkPhysicalDeviceLimits where + type VkMaxSamplerAllocationCountMType VkPhysicalDeviceLimits = + Word32 + + {-# NOINLINE vkMaxSamplerAllocationCount #-} + vkMaxSamplerAllocationCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceLimits, maxSamplerAllocationCount}) + + {-# INLINE vkMaxSamplerAllocationCountByteOffset #-} + vkMaxSamplerAllocationCountByteOffset ~_ + = #{offset VkPhysicalDeviceLimits, maxSamplerAllocationCount} + + {-# INLINE readVkMaxSamplerAllocationCount #-} + readVkMaxSamplerAllocationCount p + = peekByteOff p #{offset VkPhysicalDeviceLimits, maxSamplerAllocationCount} + + {-# INLINE writeVkMaxSamplerAllocationCount #-} + writeVkMaxSamplerAllocationCount p + = pokeByteOff p #{offset VkPhysicalDeviceLimits, maxSamplerAllocationCount} + +instance {-# OVERLAPPING #-} + HasField "maxSamplerAllocationCount" VkPhysicalDeviceLimits where + type FieldType "maxSamplerAllocationCount" VkPhysicalDeviceLimits = + Word32 + type FieldOptional "maxSamplerAllocationCount" + VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + type FieldOffset "maxSamplerAllocationCount" VkPhysicalDeviceLimits + = + #{offset VkPhysicalDeviceLimits, maxSamplerAllocationCount} + type FieldIsArray "maxSamplerAllocationCount" + VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceLimits, maxSamplerAllocationCount} + +instance CanReadField "maxSamplerAllocationCount" + VkPhysicalDeviceLimits + where + {-# INLINE getField #-} + getField = vkMaxSamplerAllocationCount + + {-# INLINE readField #-} + readField = readVkMaxSamplerAllocationCount + +instance {-# OVERLAPPING #-} + HasVkBufferImageGranularity VkPhysicalDeviceLimits where + type VkBufferImageGranularityMType VkPhysicalDeviceLimits = + VkDeviceSize + + {-# NOINLINE vkBufferImageGranularity #-} + vkBufferImageGranularity x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceLimits, bufferImageGranularity}) + + {-# INLINE vkBufferImageGranularityByteOffset #-} + vkBufferImageGranularityByteOffset ~_ + = #{offset VkPhysicalDeviceLimits, bufferImageGranularity} + + {-# INLINE readVkBufferImageGranularity #-} + readVkBufferImageGranularity p + = peekByteOff p #{offset VkPhysicalDeviceLimits, bufferImageGranularity} + + {-# INLINE writeVkBufferImageGranularity #-} + writeVkBufferImageGranularity p + = pokeByteOff p #{offset VkPhysicalDeviceLimits, bufferImageGranularity} + +instance {-# OVERLAPPING #-} + HasField "bufferImageGranularity" VkPhysicalDeviceLimits where + type FieldType "bufferImageGranularity" VkPhysicalDeviceLimits = + VkDeviceSize + type FieldOptional "bufferImageGranularity" VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + type FieldOffset "bufferImageGranularity" VkPhysicalDeviceLimits = + #{offset VkPhysicalDeviceLimits, bufferImageGranularity} + type FieldIsArray "bufferImageGranularity" VkPhysicalDeviceLimits = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceLimits, bufferImageGranularity} + +instance CanReadField "bufferImageGranularity" + VkPhysicalDeviceLimits + where + {-# INLINE getField #-} + getField = vkBufferImageGranularity + + {-# INLINE readField #-} + readField = readVkBufferImageGranularity + +instance {-# OVERLAPPING #-} + HasVkSparseAddressSpaceSize VkPhysicalDeviceLimits where + type VkSparseAddressSpaceSizeMType VkPhysicalDeviceLimits = + VkDeviceSize + + {-# NOINLINE vkSparseAddressSpaceSize #-} + vkSparseAddressSpaceSize x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceLimits, sparseAddressSpaceSize}) + + {-# INLINE vkSparseAddressSpaceSizeByteOffset #-} + vkSparseAddressSpaceSizeByteOffset ~_ + = #{offset VkPhysicalDeviceLimits, sparseAddressSpaceSize} + + {-# INLINE readVkSparseAddressSpaceSize #-} + readVkSparseAddressSpaceSize p + = peekByteOff p #{offset VkPhysicalDeviceLimits, sparseAddressSpaceSize} + + {-# INLINE writeVkSparseAddressSpaceSize #-} + writeVkSparseAddressSpaceSize p + = pokeByteOff p #{offset VkPhysicalDeviceLimits, sparseAddressSpaceSize} + +instance {-# OVERLAPPING #-} + HasField "sparseAddressSpaceSize" VkPhysicalDeviceLimits where + type FieldType "sparseAddressSpaceSize" VkPhysicalDeviceLimits = + VkDeviceSize + type FieldOptional "sparseAddressSpaceSize" VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + type FieldOffset "sparseAddressSpaceSize" VkPhysicalDeviceLimits = + #{offset VkPhysicalDeviceLimits, sparseAddressSpaceSize} + type FieldIsArray "sparseAddressSpaceSize" VkPhysicalDeviceLimits = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceLimits, sparseAddressSpaceSize} + +instance CanReadField "sparseAddressSpaceSize" + VkPhysicalDeviceLimits + where + {-# INLINE getField #-} + getField = vkSparseAddressSpaceSize + + {-# INLINE readField #-} + readField = readVkSparseAddressSpaceSize + +instance {-# OVERLAPPING #-} + HasVkMaxBoundDescriptorSets VkPhysicalDeviceLimits where + type VkMaxBoundDescriptorSetsMType VkPhysicalDeviceLimits = Word32 + + {-# NOINLINE vkMaxBoundDescriptorSets #-} + vkMaxBoundDescriptorSets x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceLimits, maxBoundDescriptorSets}) + + {-# INLINE vkMaxBoundDescriptorSetsByteOffset #-} + vkMaxBoundDescriptorSetsByteOffset ~_ + = #{offset VkPhysicalDeviceLimits, maxBoundDescriptorSets} + + {-# INLINE readVkMaxBoundDescriptorSets #-} + readVkMaxBoundDescriptorSets p + = peekByteOff p #{offset VkPhysicalDeviceLimits, maxBoundDescriptorSets} + + {-# INLINE writeVkMaxBoundDescriptorSets #-} + writeVkMaxBoundDescriptorSets p + = pokeByteOff p #{offset VkPhysicalDeviceLimits, maxBoundDescriptorSets} + +instance {-# OVERLAPPING #-} + HasField "maxBoundDescriptorSets" VkPhysicalDeviceLimits where + type FieldType "maxBoundDescriptorSets" VkPhysicalDeviceLimits = + Word32 + type FieldOptional "maxBoundDescriptorSets" VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + type FieldOffset "maxBoundDescriptorSets" VkPhysicalDeviceLimits = + #{offset VkPhysicalDeviceLimits, maxBoundDescriptorSets} + type FieldIsArray "maxBoundDescriptorSets" VkPhysicalDeviceLimits = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceLimits, maxBoundDescriptorSets} + +instance CanReadField "maxBoundDescriptorSets" + VkPhysicalDeviceLimits + where + {-# INLINE getField #-} + getField = vkMaxBoundDescriptorSets + + {-# INLINE readField #-} + readField = readVkMaxBoundDescriptorSets + +instance {-# OVERLAPPING #-} + HasVkMaxPerStageDescriptorSamplers VkPhysicalDeviceLimits where + type VkMaxPerStageDescriptorSamplersMType VkPhysicalDeviceLimits = + Word32 + + {-# NOINLINE vkMaxPerStageDescriptorSamplers #-} + vkMaxPerStageDescriptorSamplers x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceLimits, maxPerStageDescriptorSamplers}) + + {-# INLINE vkMaxPerStageDescriptorSamplersByteOffset #-} + vkMaxPerStageDescriptorSamplersByteOffset ~_ + = #{offset VkPhysicalDeviceLimits, maxPerStageDescriptorSamplers} + + {-# INLINE readVkMaxPerStageDescriptorSamplers #-} + readVkMaxPerStageDescriptorSamplers p + = peekByteOff p #{offset VkPhysicalDeviceLimits, maxPerStageDescriptorSamplers} + + {-# INLINE writeVkMaxPerStageDescriptorSamplers #-} + writeVkMaxPerStageDescriptorSamplers p + = pokeByteOff p #{offset VkPhysicalDeviceLimits, maxPerStageDescriptorSamplers} + +instance {-# OVERLAPPING #-} + HasField "maxPerStageDescriptorSamplers" VkPhysicalDeviceLimits + where + type FieldType "maxPerStageDescriptorSamplers" + VkPhysicalDeviceLimits + = Word32 + type FieldOptional "maxPerStageDescriptorSamplers" + VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + type FieldOffset "maxPerStageDescriptorSamplers" + VkPhysicalDeviceLimits + = + #{offset VkPhysicalDeviceLimits, maxPerStageDescriptorSamplers} + type FieldIsArray "maxPerStageDescriptorSamplers" + VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceLimits, maxPerStageDescriptorSamplers} + +instance CanReadField "maxPerStageDescriptorSamplers" + VkPhysicalDeviceLimits + where + {-# INLINE getField #-} + getField = vkMaxPerStageDescriptorSamplers + + {-# INLINE readField #-} + readField = readVkMaxPerStageDescriptorSamplers + +instance {-# OVERLAPPING #-} + HasVkMaxPerStageDescriptorUniformBuffers VkPhysicalDeviceLimits + where + type VkMaxPerStageDescriptorUniformBuffersMType + VkPhysicalDeviceLimits + = Word32 + + {-# NOINLINE vkMaxPerStageDescriptorUniformBuffers #-} + vkMaxPerStageDescriptorUniformBuffers x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceLimits, maxPerStageDescriptorUniformBuffers}) + + {-# INLINE vkMaxPerStageDescriptorUniformBuffersByteOffset #-} + vkMaxPerStageDescriptorUniformBuffersByteOffset ~_ + = #{offset VkPhysicalDeviceLimits, maxPerStageDescriptorUniformBuffers} + + {-# INLINE readVkMaxPerStageDescriptorUniformBuffers #-} + readVkMaxPerStageDescriptorUniformBuffers p + = peekByteOff p #{offset VkPhysicalDeviceLimits, maxPerStageDescriptorUniformBuffers} + + {-# INLINE writeVkMaxPerStageDescriptorUniformBuffers #-} + writeVkMaxPerStageDescriptorUniformBuffers p + = pokeByteOff p #{offset VkPhysicalDeviceLimits, maxPerStageDescriptorUniformBuffers} + +instance {-# OVERLAPPING #-} + HasField "maxPerStageDescriptorUniformBuffers" + VkPhysicalDeviceLimits + where + type FieldType "maxPerStageDescriptorUniformBuffers" + VkPhysicalDeviceLimits + = Word32 + type FieldOptional "maxPerStageDescriptorUniformBuffers" + VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + type FieldOffset "maxPerStageDescriptorUniformBuffers" + VkPhysicalDeviceLimits + = + #{offset VkPhysicalDeviceLimits, maxPerStageDescriptorUniformBuffers} + type FieldIsArray "maxPerStageDescriptorUniformBuffers" + VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceLimits, maxPerStageDescriptorUniformBuffers} + +instance CanReadField "maxPerStageDescriptorUniformBuffers" + VkPhysicalDeviceLimits + where + {-# INLINE getField #-} + getField = vkMaxPerStageDescriptorUniformBuffers + + {-# INLINE readField #-} + readField = readVkMaxPerStageDescriptorUniformBuffers + +instance {-# OVERLAPPING #-} + HasVkMaxPerStageDescriptorStorageBuffers VkPhysicalDeviceLimits + where + type VkMaxPerStageDescriptorStorageBuffersMType + VkPhysicalDeviceLimits + = Word32 + + {-# NOINLINE vkMaxPerStageDescriptorStorageBuffers #-} + vkMaxPerStageDescriptorStorageBuffers x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceLimits, maxPerStageDescriptorStorageBuffers}) + + {-# INLINE vkMaxPerStageDescriptorStorageBuffersByteOffset #-} + vkMaxPerStageDescriptorStorageBuffersByteOffset ~_ + = #{offset VkPhysicalDeviceLimits, maxPerStageDescriptorStorageBuffers} + + {-# INLINE readVkMaxPerStageDescriptorStorageBuffers #-} + readVkMaxPerStageDescriptorStorageBuffers p + = peekByteOff p #{offset VkPhysicalDeviceLimits, maxPerStageDescriptorStorageBuffers} + + {-# INLINE writeVkMaxPerStageDescriptorStorageBuffers #-} + writeVkMaxPerStageDescriptorStorageBuffers p + = pokeByteOff p #{offset VkPhysicalDeviceLimits, maxPerStageDescriptorStorageBuffers} + +instance {-# OVERLAPPING #-} + HasField "maxPerStageDescriptorStorageBuffers" + VkPhysicalDeviceLimits + where + type FieldType "maxPerStageDescriptorStorageBuffers" + VkPhysicalDeviceLimits + = Word32 + type FieldOptional "maxPerStageDescriptorStorageBuffers" + VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + type FieldOffset "maxPerStageDescriptorStorageBuffers" + VkPhysicalDeviceLimits + = + #{offset VkPhysicalDeviceLimits, maxPerStageDescriptorStorageBuffers} + type FieldIsArray "maxPerStageDescriptorStorageBuffers" + VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceLimits, maxPerStageDescriptorStorageBuffers} + +instance CanReadField "maxPerStageDescriptorStorageBuffers" + VkPhysicalDeviceLimits + where + {-# INLINE getField #-} + getField = vkMaxPerStageDescriptorStorageBuffers + + {-# INLINE readField #-} + readField = readVkMaxPerStageDescriptorStorageBuffers + +instance {-# OVERLAPPING #-} + HasVkMaxPerStageDescriptorSampledImages VkPhysicalDeviceLimits + where + type VkMaxPerStageDescriptorSampledImagesMType + VkPhysicalDeviceLimits + = Word32 + + {-# NOINLINE vkMaxPerStageDescriptorSampledImages #-} + vkMaxPerStageDescriptorSampledImages x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceLimits, maxPerStageDescriptorSampledImages}) + + {-# INLINE vkMaxPerStageDescriptorSampledImagesByteOffset #-} + vkMaxPerStageDescriptorSampledImagesByteOffset ~_ + = #{offset VkPhysicalDeviceLimits, maxPerStageDescriptorSampledImages} + + {-# INLINE readVkMaxPerStageDescriptorSampledImages #-} + readVkMaxPerStageDescriptorSampledImages p + = peekByteOff p #{offset VkPhysicalDeviceLimits, maxPerStageDescriptorSampledImages} + + {-# INLINE writeVkMaxPerStageDescriptorSampledImages #-} + writeVkMaxPerStageDescriptorSampledImages p + = pokeByteOff p #{offset VkPhysicalDeviceLimits, maxPerStageDescriptorSampledImages} + +instance {-# OVERLAPPING #-} + HasField "maxPerStageDescriptorSampledImages" + VkPhysicalDeviceLimits + where + type FieldType "maxPerStageDescriptorSampledImages" + VkPhysicalDeviceLimits + = Word32 + type FieldOptional "maxPerStageDescriptorSampledImages" + VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + type FieldOffset "maxPerStageDescriptorSampledImages" + VkPhysicalDeviceLimits + = + #{offset VkPhysicalDeviceLimits, maxPerStageDescriptorSampledImages} + type FieldIsArray "maxPerStageDescriptorSampledImages" + VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceLimits, maxPerStageDescriptorSampledImages} + +instance CanReadField "maxPerStageDescriptorSampledImages" + VkPhysicalDeviceLimits + where + {-# INLINE getField #-} + getField = vkMaxPerStageDescriptorSampledImages + + {-# INLINE readField #-} + readField = readVkMaxPerStageDescriptorSampledImages + +instance {-# OVERLAPPING #-} + HasVkMaxPerStageDescriptorStorageImages VkPhysicalDeviceLimits + where + type VkMaxPerStageDescriptorStorageImagesMType + VkPhysicalDeviceLimits + = Word32 + + {-# NOINLINE vkMaxPerStageDescriptorStorageImages #-} + vkMaxPerStageDescriptorStorageImages x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceLimits, maxPerStageDescriptorStorageImages}) + + {-# INLINE vkMaxPerStageDescriptorStorageImagesByteOffset #-} + vkMaxPerStageDescriptorStorageImagesByteOffset ~_ + = #{offset VkPhysicalDeviceLimits, maxPerStageDescriptorStorageImages} + + {-# INLINE readVkMaxPerStageDescriptorStorageImages #-} + readVkMaxPerStageDescriptorStorageImages p + = peekByteOff p #{offset VkPhysicalDeviceLimits, maxPerStageDescriptorStorageImages} + + {-# INLINE writeVkMaxPerStageDescriptorStorageImages #-} + writeVkMaxPerStageDescriptorStorageImages p + = pokeByteOff p #{offset VkPhysicalDeviceLimits, maxPerStageDescriptorStorageImages} + +instance {-# OVERLAPPING #-} + HasField "maxPerStageDescriptorStorageImages" + VkPhysicalDeviceLimits + where + type FieldType "maxPerStageDescriptorStorageImages" + VkPhysicalDeviceLimits + = Word32 + type FieldOptional "maxPerStageDescriptorStorageImages" + VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + type FieldOffset "maxPerStageDescriptorStorageImages" + VkPhysicalDeviceLimits + = + #{offset VkPhysicalDeviceLimits, maxPerStageDescriptorStorageImages} + type FieldIsArray "maxPerStageDescriptorStorageImages" + VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceLimits, maxPerStageDescriptorStorageImages} + +instance CanReadField "maxPerStageDescriptorStorageImages" + VkPhysicalDeviceLimits + where + {-# INLINE getField #-} + getField = vkMaxPerStageDescriptorStorageImages + + {-# INLINE readField #-} + readField = readVkMaxPerStageDescriptorStorageImages + +instance {-# OVERLAPPING #-} + HasVkMaxPerStageDescriptorInputAttachments VkPhysicalDeviceLimits + where + type VkMaxPerStageDescriptorInputAttachmentsMType + VkPhysicalDeviceLimits + = Word32 + + {-# NOINLINE vkMaxPerStageDescriptorInputAttachments #-} + vkMaxPerStageDescriptorInputAttachments x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceLimits, maxPerStageDescriptorInputAttachments}) + + {-# INLINE vkMaxPerStageDescriptorInputAttachmentsByteOffset #-} + vkMaxPerStageDescriptorInputAttachmentsByteOffset ~_ + = #{offset VkPhysicalDeviceLimits, maxPerStageDescriptorInputAttachments} + + {-# INLINE readVkMaxPerStageDescriptorInputAttachments #-} + readVkMaxPerStageDescriptorInputAttachments p + = peekByteOff p #{offset VkPhysicalDeviceLimits, maxPerStageDescriptorInputAttachments} + + {-# INLINE writeVkMaxPerStageDescriptorInputAttachments #-} + writeVkMaxPerStageDescriptorInputAttachments p + = pokeByteOff p #{offset VkPhysicalDeviceLimits, maxPerStageDescriptorInputAttachments} + +instance {-# OVERLAPPING #-} + HasField "maxPerStageDescriptorInputAttachments" + VkPhysicalDeviceLimits + where + type FieldType "maxPerStageDescriptorInputAttachments" + VkPhysicalDeviceLimits + = Word32 + type FieldOptional "maxPerStageDescriptorInputAttachments" + VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + type FieldOffset "maxPerStageDescriptorInputAttachments" + VkPhysicalDeviceLimits + = + #{offset VkPhysicalDeviceLimits, maxPerStageDescriptorInputAttachments} + type FieldIsArray "maxPerStageDescriptorInputAttachments" + VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceLimits, maxPerStageDescriptorInputAttachments} + +instance CanReadField "maxPerStageDescriptorInputAttachments" + VkPhysicalDeviceLimits + where + {-# INLINE getField #-} + getField = vkMaxPerStageDescriptorInputAttachments + + {-# INLINE readField #-} + readField = readVkMaxPerStageDescriptorInputAttachments + +instance {-# OVERLAPPING #-} + HasVkMaxPerStageResources VkPhysicalDeviceLimits where + type VkMaxPerStageResourcesMType VkPhysicalDeviceLimits = Word32 + + {-# NOINLINE vkMaxPerStageResources #-} + vkMaxPerStageResources x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceLimits, maxPerStageResources}) + + {-# INLINE vkMaxPerStageResourcesByteOffset #-} + vkMaxPerStageResourcesByteOffset ~_ + = #{offset VkPhysicalDeviceLimits, maxPerStageResources} + + {-# INLINE readVkMaxPerStageResources #-} + readVkMaxPerStageResources p + = peekByteOff p #{offset VkPhysicalDeviceLimits, maxPerStageResources} + + {-# INLINE writeVkMaxPerStageResources #-} + writeVkMaxPerStageResources p + = pokeByteOff p #{offset VkPhysicalDeviceLimits, maxPerStageResources} + +instance {-# OVERLAPPING #-} + HasField "maxPerStageResources" VkPhysicalDeviceLimits where + type FieldType "maxPerStageResources" VkPhysicalDeviceLimits = + Word32 + type FieldOptional "maxPerStageResources" VkPhysicalDeviceLimits = + 'False -- ' closing tick for hsc2hs + type FieldOffset "maxPerStageResources" VkPhysicalDeviceLimits = + #{offset VkPhysicalDeviceLimits, maxPerStageResources} + type FieldIsArray "maxPerStageResources" VkPhysicalDeviceLimits = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceLimits, maxPerStageResources} + +instance CanReadField "maxPerStageResources" VkPhysicalDeviceLimits + where + {-# INLINE getField #-} + getField = vkMaxPerStageResources + + {-# INLINE readField #-} + readField = readVkMaxPerStageResources + +instance {-# OVERLAPPING #-} + HasVkMaxDescriptorSetSamplers VkPhysicalDeviceLimits where + type VkMaxDescriptorSetSamplersMType VkPhysicalDeviceLimits = + Word32 + + {-# NOINLINE vkMaxDescriptorSetSamplers #-} + vkMaxDescriptorSetSamplers x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceLimits, maxDescriptorSetSamplers}) + + {-# INLINE vkMaxDescriptorSetSamplersByteOffset #-} + vkMaxDescriptorSetSamplersByteOffset ~_ + = #{offset VkPhysicalDeviceLimits, maxDescriptorSetSamplers} + + {-# INLINE readVkMaxDescriptorSetSamplers #-} + readVkMaxDescriptorSetSamplers p + = peekByteOff p #{offset VkPhysicalDeviceLimits, maxDescriptorSetSamplers} + + {-# INLINE writeVkMaxDescriptorSetSamplers #-} + writeVkMaxDescriptorSetSamplers p + = pokeByteOff p #{offset VkPhysicalDeviceLimits, maxDescriptorSetSamplers} + +instance {-# OVERLAPPING #-} + HasField "maxDescriptorSetSamplers" VkPhysicalDeviceLimits where + type FieldType "maxDescriptorSetSamplers" VkPhysicalDeviceLimits = + Word32 + type FieldOptional "maxDescriptorSetSamplers" + VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + type FieldOffset "maxDescriptorSetSamplers" VkPhysicalDeviceLimits + = + #{offset VkPhysicalDeviceLimits, maxDescriptorSetSamplers} + type FieldIsArray "maxDescriptorSetSamplers" VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceLimits, maxDescriptorSetSamplers} + +instance CanReadField "maxDescriptorSetSamplers" + VkPhysicalDeviceLimits + where + {-# INLINE getField #-} + getField = vkMaxDescriptorSetSamplers + + {-# INLINE readField #-} + readField = readVkMaxDescriptorSetSamplers + +instance {-# OVERLAPPING #-} + HasVkMaxDescriptorSetUniformBuffers VkPhysicalDeviceLimits where + type VkMaxDescriptorSetUniformBuffersMType VkPhysicalDeviceLimits = + Word32 + + {-# NOINLINE vkMaxDescriptorSetUniformBuffers #-} + vkMaxDescriptorSetUniformBuffers x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceLimits, maxDescriptorSetUniformBuffers}) + + {-# INLINE vkMaxDescriptorSetUniformBuffersByteOffset #-} + vkMaxDescriptorSetUniformBuffersByteOffset ~_ + = #{offset VkPhysicalDeviceLimits, maxDescriptorSetUniformBuffers} + + {-# INLINE readVkMaxDescriptorSetUniformBuffers #-} + readVkMaxDescriptorSetUniformBuffers p + = peekByteOff p #{offset VkPhysicalDeviceLimits, maxDescriptorSetUniformBuffers} + + {-# INLINE writeVkMaxDescriptorSetUniformBuffers #-} + writeVkMaxDescriptorSetUniformBuffers p + = pokeByteOff p #{offset VkPhysicalDeviceLimits, maxDescriptorSetUniformBuffers} + +instance {-# OVERLAPPING #-} + HasField "maxDescriptorSetUniformBuffers" VkPhysicalDeviceLimits + where + type FieldType "maxDescriptorSetUniformBuffers" + VkPhysicalDeviceLimits + = Word32 + type FieldOptional "maxDescriptorSetUniformBuffers" + VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + type FieldOffset "maxDescriptorSetUniformBuffers" + VkPhysicalDeviceLimits + = + #{offset VkPhysicalDeviceLimits, maxDescriptorSetUniformBuffers} + type FieldIsArray "maxDescriptorSetUniformBuffers" + VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceLimits, maxDescriptorSetUniformBuffers} + +instance CanReadField "maxDescriptorSetUniformBuffers" + VkPhysicalDeviceLimits + where + {-# INLINE getField #-} + getField = vkMaxDescriptorSetUniformBuffers + + {-# INLINE readField #-} + readField = readVkMaxDescriptorSetUniformBuffers + +instance {-# OVERLAPPING #-} + HasVkMaxDescriptorSetUniformBuffersDynamic VkPhysicalDeviceLimits + where + type VkMaxDescriptorSetUniformBuffersDynamicMType + VkPhysicalDeviceLimits + = Word32 + + {-# NOINLINE vkMaxDescriptorSetUniformBuffersDynamic #-} + vkMaxDescriptorSetUniformBuffersDynamic x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceLimits, maxDescriptorSetUniformBuffersDynamic}) + + {-# INLINE vkMaxDescriptorSetUniformBuffersDynamicByteOffset #-} + vkMaxDescriptorSetUniformBuffersDynamicByteOffset ~_ + = #{offset VkPhysicalDeviceLimits, maxDescriptorSetUniformBuffersDynamic} + + {-# INLINE readVkMaxDescriptorSetUniformBuffersDynamic #-} + readVkMaxDescriptorSetUniformBuffersDynamic p + = peekByteOff p #{offset VkPhysicalDeviceLimits, maxDescriptorSetUniformBuffersDynamic} + + {-# INLINE writeVkMaxDescriptorSetUniformBuffersDynamic #-} + writeVkMaxDescriptorSetUniformBuffersDynamic p + = pokeByteOff p #{offset VkPhysicalDeviceLimits, maxDescriptorSetUniformBuffersDynamic} + +instance {-# OVERLAPPING #-} + HasField "maxDescriptorSetUniformBuffersDynamic" + VkPhysicalDeviceLimits + where + type FieldType "maxDescriptorSetUniformBuffersDynamic" + VkPhysicalDeviceLimits + = Word32 + type FieldOptional "maxDescriptorSetUniformBuffersDynamic" + VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + type FieldOffset "maxDescriptorSetUniformBuffersDynamic" + VkPhysicalDeviceLimits + = + #{offset VkPhysicalDeviceLimits, maxDescriptorSetUniformBuffersDynamic} + type FieldIsArray "maxDescriptorSetUniformBuffersDynamic" + VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceLimits, maxDescriptorSetUniformBuffersDynamic} + +instance CanReadField "maxDescriptorSetUniformBuffersDynamic" + VkPhysicalDeviceLimits + where + {-# INLINE getField #-} + getField = vkMaxDescriptorSetUniformBuffersDynamic + + {-# INLINE readField #-} + readField = readVkMaxDescriptorSetUniformBuffersDynamic + +instance {-# OVERLAPPING #-} + HasVkMaxDescriptorSetStorageBuffers VkPhysicalDeviceLimits where + type VkMaxDescriptorSetStorageBuffersMType VkPhysicalDeviceLimits = + Word32 + + {-# NOINLINE vkMaxDescriptorSetStorageBuffers #-} + vkMaxDescriptorSetStorageBuffers x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceLimits, maxDescriptorSetStorageBuffers}) + + {-# INLINE vkMaxDescriptorSetStorageBuffersByteOffset #-} + vkMaxDescriptorSetStorageBuffersByteOffset ~_ + = #{offset VkPhysicalDeviceLimits, maxDescriptorSetStorageBuffers} + + {-# INLINE readVkMaxDescriptorSetStorageBuffers #-} + readVkMaxDescriptorSetStorageBuffers p + = peekByteOff p #{offset VkPhysicalDeviceLimits, maxDescriptorSetStorageBuffers} + + {-# INLINE writeVkMaxDescriptorSetStorageBuffers #-} + writeVkMaxDescriptorSetStorageBuffers p + = pokeByteOff p #{offset VkPhysicalDeviceLimits, maxDescriptorSetStorageBuffers} + +instance {-# OVERLAPPING #-} + HasField "maxDescriptorSetStorageBuffers" VkPhysicalDeviceLimits + where + type FieldType "maxDescriptorSetStorageBuffers" + VkPhysicalDeviceLimits + = Word32 + type FieldOptional "maxDescriptorSetStorageBuffers" + VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + type FieldOffset "maxDescriptorSetStorageBuffers" + VkPhysicalDeviceLimits + = + #{offset VkPhysicalDeviceLimits, maxDescriptorSetStorageBuffers} + type FieldIsArray "maxDescriptorSetStorageBuffers" + VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceLimits, maxDescriptorSetStorageBuffers} + +instance CanReadField "maxDescriptorSetStorageBuffers" + VkPhysicalDeviceLimits + where + {-# INLINE getField #-} + getField = vkMaxDescriptorSetStorageBuffers + + {-# INLINE readField #-} + readField = readVkMaxDescriptorSetStorageBuffers + +instance {-# OVERLAPPING #-} + HasVkMaxDescriptorSetStorageBuffersDynamic VkPhysicalDeviceLimits + where + type VkMaxDescriptorSetStorageBuffersDynamicMType + VkPhysicalDeviceLimits + = Word32 + + {-# NOINLINE vkMaxDescriptorSetStorageBuffersDynamic #-} + vkMaxDescriptorSetStorageBuffersDynamic x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceLimits, maxDescriptorSetStorageBuffersDynamic}) + + {-# INLINE vkMaxDescriptorSetStorageBuffersDynamicByteOffset #-} + vkMaxDescriptorSetStorageBuffersDynamicByteOffset ~_ + = #{offset VkPhysicalDeviceLimits, maxDescriptorSetStorageBuffersDynamic} + + {-# INLINE readVkMaxDescriptorSetStorageBuffersDynamic #-} + readVkMaxDescriptorSetStorageBuffersDynamic p + = peekByteOff p #{offset VkPhysicalDeviceLimits, maxDescriptorSetStorageBuffersDynamic} + + {-# INLINE writeVkMaxDescriptorSetStorageBuffersDynamic #-} + writeVkMaxDescriptorSetStorageBuffersDynamic p + = pokeByteOff p #{offset VkPhysicalDeviceLimits, maxDescriptorSetStorageBuffersDynamic} + +instance {-# OVERLAPPING #-} + HasField "maxDescriptorSetStorageBuffersDynamic" + VkPhysicalDeviceLimits + where + type FieldType "maxDescriptorSetStorageBuffersDynamic" + VkPhysicalDeviceLimits + = Word32 + type FieldOptional "maxDescriptorSetStorageBuffersDynamic" + VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + type FieldOffset "maxDescriptorSetStorageBuffersDynamic" + VkPhysicalDeviceLimits + = + #{offset VkPhysicalDeviceLimits, maxDescriptorSetStorageBuffersDynamic} + type FieldIsArray "maxDescriptorSetStorageBuffersDynamic" + VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceLimits, maxDescriptorSetStorageBuffersDynamic} + +instance CanReadField "maxDescriptorSetStorageBuffersDynamic" + VkPhysicalDeviceLimits + where + {-# INLINE getField #-} + getField = vkMaxDescriptorSetStorageBuffersDynamic + + {-# INLINE readField #-} + readField = readVkMaxDescriptorSetStorageBuffersDynamic + +instance {-# OVERLAPPING #-} + HasVkMaxDescriptorSetSampledImages VkPhysicalDeviceLimits where + type VkMaxDescriptorSetSampledImagesMType VkPhysicalDeviceLimits = + Word32 + + {-# NOINLINE vkMaxDescriptorSetSampledImages #-} + vkMaxDescriptorSetSampledImages x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceLimits, maxDescriptorSetSampledImages}) + + {-# INLINE vkMaxDescriptorSetSampledImagesByteOffset #-} + vkMaxDescriptorSetSampledImagesByteOffset ~_ + = #{offset VkPhysicalDeviceLimits, maxDescriptorSetSampledImages} + + {-# INLINE readVkMaxDescriptorSetSampledImages #-} + readVkMaxDescriptorSetSampledImages p + = peekByteOff p #{offset VkPhysicalDeviceLimits, maxDescriptorSetSampledImages} + + {-# INLINE writeVkMaxDescriptorSetSampledImages #-} + writeVkMaxDescriptorSetSampledImages p + = pokeByteOff p #{offset VkPhysicalDeviceLimits, maxDescriptorSetSampledImages} + +instance {-# OVERLAPPING #-} + HasField "maxDescriptorSetSampledImages" VkPhysicalDeviceLimits + where + type FieldType "maxDescriptorSetSampledImages" + VkPhysicalDeviceLimits + = Word32 + type FieldOptional "maxDescriptorSetSampledImages" + VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + type FieldOffset "maxDescriptorSetSampledImages" + VkPhysicalDeviceLimits + = + #{offset VkPhysicalDeviceLimits, maxDescriptorSetSampledImages} + type FieldIsArray "maxDescriptorSetSampledImages" + VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceLimits, maxDescriptorSetSampledImages} + +instance CanReadField "maxDescriptorSetSampledImages" + VkPhysicalDeviceLimits + where + {-# INLINE getField #-} + getField = vkMaxDescriptorSetSampledImages + + {-# INLINE readField #-} + readField = readVkMaxDescriptorSetSampledImages + +instance {-# OVERLAPPING #-} + HasVkMaxDescriptorSetStorageImages VkPhysicalDeviceLimits where + type VkMaxDescriptorSetStorageImagesMType VkPhysicalDeviceLimits = + Word32 + + {-# NOINLINE vkMaxDescriptorSetStorageImages #-} + vkMaxDescriptorSetStorageImages x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceLimits, maxDescriptorSetStorageImages}) + + {-# INLINE vkMaxDescriptorSetStorageImagesByteOffset #-} + vkMaxDescriptorSetStorageImagesByteOffset ~_ + = #{offset VkPhysicalDeviceLimits, maxDescriptorSetStorageImages} + + {-# INLINE readVkMaxDescriptorSetStorageImages #-} + readVkMaxDescriptorSetStorageImages p + = peekByteOff p #{offset VkPhysicalDeviceLimits, maxDescriptorSetStorageImages} + + {-# INLINE writeVkMaxDescriptorSetStorageImages #-} + writeVkMaxDescriptorSetStorageImages p + = pokeByteOff p #{offset VkPhysicalDeviceLimits, maxDescriptorSetStorageImages} + +instance {-# OVERLAPPING #-} + HasField "maxDescriptorSetStorageImages" VkPhysicalDeviceLimits + where + type FieldType "maxDescriptorSetStorageImages" + VkPhysicalDeviceLimits + = Word32 + type FieldOptional "maxDescriptorSetStorageImages" + VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + type FieldOffset "maxDescriptorSetStorageImages" + VkPhysicalDeviceLimits + = + #{offset VkPhysicalDeviceLimits, maxDescriptorSetStorageImages} + type FieldIsArray "maxDescriptorSetStorageImages" + VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceLimits, maxDescriptorSetStorageImages} + +instance CanReadField "maxDescriptorSetStorageImages" + VkPhysicalDeviceLimits + where + {-# INLINE getField #-} + getField = vkMaxDescriptorSetStorageImages + + {-# INLINE readField #-} + readField = readVkMaxDescriptorSetStorageImages + +instance {-# OVERLAPPING #-} + HasVkMaxDescriptorSetInputAttachments VkPhysicalDeviceLimits where + type VkMaxDescriptorSetInputAttachmentsMType VkPhysicalDeviceLimits + = Word32 + + {-# NOINLINE vkMaxDescriptorSetInputAttachments #-} + vkMaxDescriptorSetInputAttachments x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceLimits, maxDescriptorSetInputAttachments}) + + {-# INLINE vkMaxDescriptorSetInputAttachmentsByteOffset #-} + vkMaxDescriptorSetInputAttachmentsByteOffset ~_ + = #{offset VkPhysicalDeviceLimits, maxDescriptorSetInputAttachments} + + {-# INLINE readVkMaxDescriptorSetInputAttachments #-} + readVkMaxDescriptorSetInputAttachments p + = peekByteOff p #{offset VkPhysicalDeviceLimits, maxDescriptorSetInputAttachments} + + {-# INLINE writeVkMaxDescriptorSetInputAttachments #-} + writeVkMaxDescriptorSetInputAttachments p + = pokeByteOff p #{offset VkPhysicalDeviceLimits, maxDescriptorSetInputAttachments} + +instance {-# OVERLAPPING #-} + HasField "maxDescriptorSetInputAttachments" VkPhysicalDeviceLimits + where + type FieldType "maxDescriptorSetInputAttachments" + VkPhysicalDeviceLimits + = Word32 + type FieldOptional "maxDescriptorSetInputAttachments" + VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + type FieldOffset "maxDescriptorSetInputAttachments" + VkPhysicalDeviceLimits + = + #{offset VkPhysicalDeviceLimits, maxDescriptorSetInputAttachments} + type FieldIsArray "maxDescriptorSetInputAttachments" + VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceLimits, maxDescriptorSetInputAttachments} + +instance CanReadField "maxDescriptorSetInputAttachments" + VkPhysicalDeviceLimits + where + {-# INLINE getField #-} + getField = vkMaxDescriptorSetInputAttachments + + {-# INLINE readField #-} + readField = readVkMaxDescriptorSetInputAttachments + +instance {-# OVERLAPPING #-} + HasVkMaxVertexInputAttributes VkPhysicalDeviceLimits where + type VkMaxVertexInputAttributesMType VkPhysicalDeviceLimits = + Word32 + + {-# NOINLINE vkMaxVertexInputAttributes #-} + vkMaxVertexInputAttributes x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceLimits, maxVertexInputAttributes}) + + {-# INLINE vkMaxVertexInputAttributesByteOffset #-} + vkMaxVertexInputAttributesByteOffset ~_ + = #{offset VkPhysicalDeviceLimits, maxVertexInputAttributes} + + {-# INLINE readVkMaxVertexInputAttributes #-} + readVkMaxVertexInputAttributes p + = peekByteOff p #{offset VkPhysicalDeviceLimits, maxVertexInputAttributes} + + {-# INLINE writeVkMaxVertexInputAttributes #-} + writeVkMaxVertexInputAttributes p + = pokeByteOff p #{offset VkPhysicalDeviceLimits, maxVertexInputAttributes} + +instance {-# OVERLAPPING #-} + HasField "maxVertexInputAttributes" VkPhysicalDeviceLimits where + type FieldType "maxVertexInputAttributes" VkPhysicalDeviceLimits = + Word32 + type FieldOptional "maxVertexInputAttributes" + VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + type FieldOffset "maxVertexInputAttributes" VkPhysicalDeviceLimits + = + #{offset VkPhysicalDeviceLimits, maxVertexInputAttributes} + type FieldIsArray "maxVertexInputAttributes" VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceLimits, maxVertexInputAttributes} + +instance CanReadField "maxVertexInputAttributes" + VkPhysicalDeviceLimits + where + {-# INLINE getField #-} + getField = vkMaxVertexInputAttributes + + {-# INLINE readField #-} + readField = readVkMaxVertexInputAttributes + +instance {-# OVERLAPPING #-} + HasVkMaxVertexInputBindings VkPhysicalDeviceLimits where + type VkMaxVertexInputBindingsMType VkPhysicalDeviceLimits = Word32 + + {-# NOINLINE vkMaxVertexInputBindings #-} + vkMaxVertexInputBindings x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceLimits, maxVertexInputBindings}) + + {-# INLINE vkMaxVertexInputBindingsByteOffset #-} + vkMaxVertexInputBindingsByteOffset ~_ + = #{offset VkPhysicalDeviceLimits, maxVertexInputBindings} + + {-# INLINE readVkMaxVertexInputBindings #-} + readVkMaxVertexInputBindings p + = peekByteOff p #{offset VkPhysicalDeviceLimits, maxVertexInputBindings} + + {-# INLINE writeVkMaxVertexInputBindings #-} + writeVkMaxVertexInputBindings p + = pokeByteOff p #{offset VkPhysicalDeviceLimits, maxVertexInputBindings} + +instance {-# OVERLAPPING #-} + HasField "maxVertexInputBindings" VkPhysicalDeviceLimits where + type FieldType "maxVertexInputBindings" VkPhysicalDeviceLimits = + Word32 + type FieldOptional "maxVertexInputBindings" VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + type FieldOffset "maxVertexInputBindings" VkPhysicalDeviceLimits = + #{offset VkPhysicalDeviceLimits, maxVertexInputBindings} + type FieldIsArray "maxVertexInputBindings" VkPhysicalDeviceLimits = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceLimits, maxVertexInputBindings} + +instance CanReadField "maxVertexInputBindings" + VkPhysicalDeviceLimits + where + {-# INLINE getField #-} + getField = vkMaxVertexInputBindings + + {-# INLINE readField #-} + readField = readVkMaxVertexInputBindings + +instance {-# OVERLAPPING #-} + HasVkMaxVertexInputAttributeOffset VkPhysicalDeviceLimits where + type VkMaxVertexInputAttributeOffsetMType VkPhysicalDeviceLimits = + Word32 + + {-# NOINLINE vkMaxVertexInputAttributeOffset #-} + vkMaxVertexInputAttributeOffset x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceLimits, maxVertexInputAttributeOffset}) + + {-# INLINE vkMaxVertexInputAttributeOffsetByteOffset #-} + vkMaxVertexInputAttributeOffsetByteOffset ~_ + = #{offset VkPhysicalDeviceLimits, maxVertexInputAttributeOffset} + + {-# INLINE readVkMaxVertexInputAttributeOffset #-} + readVkMaxVertexInputAttributeOffset p + = peekByteOff p #{offset VkPhysicalDeviceLimits, maxVertexInputAttributeOffset} + + {-# INLINE writeVkMaxVertexInputAttributeOffset #-} + writeVkMaxVertexInputAttributeOffset p + = pokeByteOff p #{offset VkPhysicalDeviceLimits, maxVertexInputAttributeOffset} + +instance {-# OVERLAPPING #-} + HasField "maxVertexInputAttributeOffset" VkPhysicalDeviceLimits + where + type FieldType "maxVertexInputAttributeOffset" + VkPhysicalDeviceLimits + = Word32 + type FieldOptional "maxVertexInputAttributeOffset" + VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + type FieldOffset "maxVertexInputAttributeOffset" + VkPhysicalDeviceLimits + = + #{offset VkPhysicalDeviceLimits, maxVertexInputAttributeOffset} + type FieldIsArray "maxVertexInputAttributeOffset" + VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceLimits, maxVertexInputAttributeOffset} + +instance CanReadField "maxVertexInputAttributeOffset" + VkPhysicalDeviceLimits + where + {-# INLINE getField #-} + getField = vkMaxVertexInputAttributeOffset + + {-# INLINE readField #-} + readField = readVkMaxVertexInputAttributeOffset + +instance {-# OVERLAPPING #-} + HasVkMaxVertexInputBindingStride VkPhysicalDeviceLimits where + type VkMaxVertexInputBindingStrideMType VkPhysicalDeviceLimits = + Word32 + + {-# NOINLINE vkMaxVertexInputBindingStride #-} + vkMaxVertexInputBindingStride x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceLimits, maxVertexInputBindingStride}) + + {-# INLINE vkMaxVertexInputBindingStrideByteOffset #-} + vkMaxVertexInputBindingStrideByteOffset ~_ + = #{offset VkPhysicalDeviceLimits, maxVertexInputBindingStride} + + {-# INLINE readVkMaxVertexInputBindingStride #-} + readVkMaxVertexInputBindingStride p + = peekByteOff p #{offset VkPhysicalDeviceLimits, maxVertexInputBindingStride} + + {-# INLINE writeVkMaxVertexInputBindingStride #-} + writeVkMaxVertexInputBindingStride p + = pokeByteOff p #{offset VkPhysicalDeviceLimits, maxVertexInputBindingStride} + +instance {-# OVERLAPPING #-} + HasField "maxVertexInputBindingStride" VkPhysicalDeviceLimits where + type FieldType "maxVertexInputBindingStride" VkPhysicalDeviceLimits + = Word32 + type FieldOptional "maxVertexInputBindingStride" + VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + type FieldOffset "maxVertexInputBindingStride" + VkPhysicalDeviceLimits + = + #{offset VkPhysicalDeviceLimits, maxVertexInputBindingStride} + type FieldIsArray "maxVertexInputBindingStride" + VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceLimits, maxVertexInputBindingStride} + +instance CanReadField "maxVertexInputBindingStride" + VkPhysicalDeviceLimits + where + {-# INLINE getField #-} + getField = vkMaxVertexInputBindingStride + + {-# INLINE readField #-} + readField = readVkMaxVertexInputBindingStride + +instance {-# OVERLAPPING #-} + HasVkMaxVertexOutputComponents VkPhysicalDeviceLimits where + type VkMaxVertexOutputComponentsMType VkPhysicalDeviceLimits = + Word32 + + {-# NOINLINE vkMaxVertexOutputComponents #-} + vkMaxVertexOutputComponents x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceLimits, maxVertexOutputComponents}) + + {-# INLINE vkMaxVertexOutputComponentsByteOffset #-} + vkMaxVertexOutputComponentsByteOffset ~_ + = #{offset VkPhysicalDeviceLimits, maxVertexOutputComponents} + + {-# INLINE readVkMaxVertexOutputComponents #-} + readVkMaxVertexOutputComponents p + = peekByteOff p #{offset VkPhysicalDeviceLimits, maxVertexOutputComponents} + + {-# INLINE writeVkMaxVertexOutputComponents #-} + writeVkMaxVertexOutputComponents p + = pokeByteOff p #{offset VkPhysicalDeviceLimits, maxVertexOutputComponents} + +instance {-# OVERLAPPING #-} + HasField "maxVertexOutputComponents" VkPhysicalDeviceLimits where + type FieldType "maxVertexOutputComponents" VkPhysicalDeviceLimits = + Word32 + type FieldOptional "maxVertexOutputComponents" + VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + type FieldOffset "maxVertexOutputComponents" VkPhysicalDeviceLimits + = + #{offset VkPhysicalDeviceLimits, maxVertexOutputComponents} + type FieldIsArray "maxVertexOutputComponents" + VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceLimits, maxVertexOutputComponents} + +instance CanReadField "maxVertexOutputComponents" + VkPhysicalDeviceLimits + where + {-# INLINE getField #-} + getField = vkMaxVertexOutputComponents + + {-# INLINE readField #-} + readField = readVkMaxVertexOutputComponents + +instance {-# OVERLAPPING #-} + HasVkMaxTessellationGenerationLevel VkPhysicalDeviceLimits where + type VkMaxTessellationGenerationLevelMType VkPhysicalDeviceLimits = + Word32 + + {-# NOINLINE vkMaxTessellationGenerationLevel #-} + vkMaxTessellationGenerationLevel x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceLimits, maxTessellationGenerationLevel}) + + {-# INLINE vkMaxTessellationGenerationLevelByteOffset #-} + vkMaxTessellationGenerationLevelByteOffset ~_ + = #{offset VkPhysicalDeviceLimits, maxTessellationGenerationLevel} + + {-# INLINE readVkMaxTessellationGenerationLevel #-} + readVkMaxTessellationGenerationLevel p + = peekByteOff p #{offset VkPhysicalDeviceLimits, maxTessellationGenerationLevel} + + {-# INLINE writeVkMaxTessellationGenerationLevel #-} + writeVkMaxTessellationGenerationLevel p + = pokeByteOff p #{offset VkPhysicalDeviceLimits, maxTessellationGenerationLevel} + +instance {-# OVERLAPPING #-} + HasField "maxTessellationGenerationLevel" VkPhysicalDeviceLimits + where + type FieldType "maxTessellationGenerationLevel" + VkPhysicalDeviceLimits + = Word32 + type FieldOptional "maxTessellationGenerationLevel" + VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + type FieldOffset "maxTessellationGenerationLevel" + VkPhysicalDeviceLimits + = + #{offset VkPhysicalDeviceLimits, maxTessellationGenerationLevel} + type FieldIsArray "maxTessellationGenerationLevel" + VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceLimits, maxTessellationGenerationLevel} + +instance CanReadField "maxTessellationGenerationLevel" + VkPhysicalDeviceLimits + where + {-# INLINE getField #-} + getField = vkMaxTessellationGenerationLevel + + {-# INLINE readField #-} + readField = readVkMaxTessellationGenerationLevel + +instance {-# OVERLAPPING #-} + HasVkMaxTessellationPatchSize VkPhysicalDeviceLimits where + type VkMaxTessellationPatchSizeMType VkPhysicalDeviceLimits = + Word32 + + {-# NOINLINE vkMaxTessellationPatchSize #-} + vkMaxTessellationPatchSize x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceLimits, maxTessellationPatchSize}) + + {-# INLINE vkMaxTessellationPatchSizeByteOffset #-} + vkMaxTessellationPatchSizeByteOffset ~_ + = #{offset VkPhysicalDeviceLimits, maxTessellationPatchSize} + + {-# INLINE readVkMaxTessellationPatchSize #-} + readVkMaxTessellationPatchSize p + = peekByteOff p #{offset VkPhysicalDeviceLimits, maxTessellationPatchSize} + + {-# INLINE writeVkMaxTessellationPatchSize #-} + writeVkMaxTessellationPatchSize p + = pokeByteOff p #{offset VkPhysicalDeviceLimits, maxTessellationPatchSize} + +instance {-# OVERLAPPING #-} + HasField "maxTessellationPatchSize" VkPhysicalDeviceLimits where + type FieldType "maxTessellationPatchSize" VkPhysicalDeviceLimits = + Word32 + type FieldOptional "maxTessellationPatchSize" + VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + type FieldOffset "maxTessellationPatchSize" VkPhysicalDeviceLimits + = + #{offset VkPhysicalDeviceLimits, maxTessellationPatchSize} + type FieldIsArray "maxTessellationPatchSize" VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceLimits, maxTessellationPatchSize} + +instance CanReadField "maxTessellationPatchSize" + VkPhysicalDeviceLimits + where + {-# INLINE getField #-} + getField = vkMaxTessellationPatchSize + + {-# INLINE readField #-} + readField = readVkMaxTessellationPatchSize + +instance {-# OVERLAPPING #-} + HasVkMaxTessellationControlPerVertexInputComponents + VkPhysicalDeviceLimits + where + type VkMaxTessellationControlPerVertexInputComponentsMType + VkPhysicalDeviceLimits + = Word32 + + {-# NOINLINE vkMaxTessellationControlPerVertexInputComponents #-} + vkMaxTessellationControlPerVertexInputComponents x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceLimits, maxTessellationControlPerVertexInputComponents}) + + {-# INLINE vkMaxTessellationControlPerVertexInputComponentsByteOffset + #-} + vkMaxTessellationControlPerVertexInputComponentsByteOffset ~_ + = #{offset VkPhysicalDeviceLimits, maxTessellationControlPerVertexInputComponents} + + {-# INLINE readVkMaxTessellationControlPerVertexInputComponents #-} + readVkMaxTessellationControlPerVertexInputComponents p + = peekByteOff p #{offset VkPhysicalDeviceLimits, maxTessellationControlPerVertexInputComponents} + + {-# INLINE writeVkMaxTessellationControlPerVertexInputComponents + #-} + writeVkMaxTessellationControlPerVertexInputComponents p + = pokeByteOff p #{offset VkPhysicalDeviceLimits, maxTessellationControlPerVertexInputComponents} + +instance {-# OVERLAPPING #-} + HasField "maxTessellationControlPerVertexInputComponents" + VkPhysicalDeviceLimits + where + type FieldType "maxTessellationControlPerVertexInputComponents" + VkPhysicalDeviceLimits + = Word32 + type FieldOptional "maxTessellationControlPerVertexInputComponents" + VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + type FieldOffset "maxTessellationControlPerVertexInputComponents" + VkPhysicalDeviceLimits + = + #{offset VkPhysicalDeviceLimits, maxTessellationControlPerVertexInputComponents} + type FieldIsArray "maxTessellationControlPerVertexInputComponents" + VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceLimits, maxTessellationControlPerVertexInputComponents} + +instance CanReadField + "maxTessellationControlPerVertexInputComponents" + VkPhysicalDeviceLimits + where + {-# INLINE getField #-} + getField = vkMaxTessellationControlPerVertexInputComponents + + {-# INLINE readField #-} + readField = readVkMaxTessellationControlPerVertexInputComponents + +instance {-# OVERLAPPING #-} + HasVkMaxTessellationControlPerVertexOutputComponents + VkPhysicalDeviceLimits + where + type VkMaxTessellationControlPerVertexOutputComponentsMType + VkPhysicalDeviceLimits + = Word32 + + {-# NOINLINE vkMaxTessellationControlPerVertexOutputComponents #-} + vkMaxTessellationControlPerVertexOutputComponents x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceLimits, maxTessellationControlPerVertexOutputComponents}) + + {-# INLINE vkMaxTessellationControlPerVertexOutputComponentsByteOffset + #-} + vkMaxTessellationControlPerVertexOutputComponentsByteOffset ~_ + = #{offset VkPhysicalDeviceLimits, maxTessellationControlPerVertexOutputComponents} + + {-# INLINE readVkMaxTessellationControlPerVertexOutputComponents + #-} + readVkMaxTessellationControlPerVertexOutputComponents p + = peekByteOff p #{offset VkPhysicalDeviceLimits, maxTessellationControlPerVertexOutputComponents} + + {-# INLINE writeVkMaxTessellationControlPerVertexOutputComponents + #-} + writeVkMaxTessellationControlPerVertexOutputComponents p + = pokeByteOff p #{offset VkPhysicalDeviceLimits, maxTessellationControlPerVertexOutputComponents} + +instance {-# OVERLAPPING #-} + HasField "maxTessellationControlPerVertexOutputComponents" + VkPhysicalDeviceLimits + where + type FieldType "maxTessellationControlPerVertexOutputComponents" + VkPhysicalDeviceLimits + = Word32 + type FieldOptional + "maxTessellationControlPerVertexOutputComponents" + VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + type FieldOffset "maxTessellationControlPerVertexOutputComponents" + VkPhysicalDeviceLimits + = + #{offset VkPhysicalDeviceLimits, maxTessellationControlPerVertexOutputComponents} + type FieldIsArray "maxTessellationControlPerVertexOutputComponents" + VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceLimits, maxTessellationControlPerVertexOutputComponents} + +instance CanReadField + "maxTessellationControlPerVertexOutputComponents" + VkPhysicalDeviceLimits + where + {-# INLINE getField #-} + getField = vkMaxTessellationControlPerVertexOutputComponents + + {-# INLINE readField #-} + readField = readVkMaxTessellationControlPerVertexOutputComponents + +instance {-# OVERLAPPING #-} + HasVkMaxTessellationControlPerPatchOutputComponents + VkPhysicalDeviceLimits + where + type VkMaxTessellationControlPerPatchOutputComponentsMType + VkPhysicalDeviceLimits + = Word32 + + {-# NOINLINE vkMaxTessellationControlPerPatchOutputComponents #-} + vkMaxTessellationControlPerPatchOutputComponents x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceLimits, maxTessellationControlPerPatchOutputComponents}) + + {-# INLINE vkMaxTessellationControlPerPatchOutputComponentsByteOffset + #-} + vkMaxTessellationControlPerPatchOutputComponentsByteOffset ~_ + = #{offset VkPhysicalDeviceLimits, maxTessellationControlPerPatchOutputComponents} + + {-# INLINE readVkMaxTessellationControlPerPatchOutputComponents #-} + readVkMaxTessellationControlPerPatchOutputComponents p + = peekByteOff p #{offset VkPhysicalDeviceLimits, maxTessellationControlPerPatchOutputComponents} + + {-# INLINE writeVkMaxTessellationControlPerPatchOutputComponents + #-} + writeVkMaxTessellationControlPerPatchOutputComponents p + = pokeByteOff p #{offset VkPhysicalDeviceLimits, maxTessellationControlPerPatchOutputComponents} + +instance {-# OVERLAPPING #-} + HasField "maxTessellationControlPerPatchOutputComponents" + VkPhysicalDeviceLimits + where + type FieldType "maxTessellationControlPerPatchOutputComponents" + VkPhysicalDeviceLimits + = Word32 + type FieldOptional "maxTessellationControlPerPatchOutputComponents" + VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + type FieldOffset "maxTessellationControlPerPatchOutputComponents" + VkPhysicalDeviceLimits + = + #{offset VkPhysicalDeviceLimits, maxTessellationControlPerPatchOutputComponents} + type FieldIsArray "maxTessellationControlPerPatchOutputComponents" + VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceLimits, maxTessellationControlPerPatchOutputComponents} + +instance CanReadField + "maxTessellationControlPerPatchOutputComponents" + VkPhysicalDeviceLimits + where + {-# INLINE getField #-} + getField = vkMaxTessellationControlPerPatchOutputComponents + + {-# INLINE readField #-} + readField = readVkMaxTessellationControlPerPatchOutputComponents + +instance {-# OVERLAPPING #-} + HasVkMaxTessellationControlTotalOutputComponents + VkPhysicalDeviceLimits + where + type VkMaxTessellationControlTotalOutputComponentsMType + VkPhysicalDeviceLimits + = Word32 + + {-# NOINLINE vkMaxTessellationControlTotalOutputComponents #-} + vkMaxTessellationControlTotalOutputComponents x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceLimits, maxTessellationControlTotalOutputComponents}) + + {-# INLINE vkMaxTessellationControlTotalOutputComponentsByteOffset + #-} + vkMaxTessellationControlTotalOutputComponentsByteOffset ~_ + = #{offset VkPhysicalDeviceLimits, maxTessellationControlTotalOutputComponents} + + {-# INLINE readVkMaxTessellationControlTotalOutputComponents #-} + readVkMaxTessellationControlTotalOutputComponents p + = peekByteOff p #{offset VkPhysicalDeviceLimits, maxTessellationControlTotalOutputComponents} + + {-# INLINE writeVkMaxTessellationControlTotalOutputComponents #-} + writeVkMaxTessellationControlTotalOutputComponents p + = pokeByteOff p #{offset VkPhysicalDeviceLimits, maxTessellationControlTotalOutputComponents} + +instance {-# OVERLAPPING #-} + HasField "maxTessellationControlTotalOutputComponents" + VkPhysicalDeviceLimits + where + type FieldType "maxTessellationControlTotalOutputComponents" + VkPhysicalDeviceLimits + = Word32 + type FieldOptional "maxTessellationControlTotalOutputComponents" + VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + type FieldOffset "maxTessellationControlTotalOutputComponents" + VkPhysicalDeviceLimits + = + #{offset VkPhysicalDeviceLimits, maxTessellationControlTotalOutputComponents} + type FieldIsArray "maxTessellationControlTotalOutputComponents" + VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceLimits, maxTessellationControlTotalOutputComponents} + +instance CanReadField "maxTessellationControlTotalOutputComponents" + VkPhysicalDeviceLimits + where + {-# INLINE getField #-} + getField = vkMaxTessellationControlTotalOutputComponents + + {-# INLINE readField #-} + readField = readVkMaxTessellationControlTotalOutputComponents + +instance {-# OVERLAPPING #-} + HasVkMaxTessellationEvaluationInputComponents + VkPhysicalDeviceLimits + where + type VkMaxTessellationEvaluationInputComponentsMType + VkPhysicalDeviceLimits + = Word32 + + {-# NOINLINE vkMaxTessellationEvaluationInputComponents #-} + vkMaxTessellationEvaluationInputComponents x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceLimits, maxTessellationEvaluationInputComponents}) + + {-# INLINE vkMaxTessellationEvaluationInputComponentsByteOffset #-} + vkMaxTessellationEvaluationInputComponentsByteOffset ~_ + = #{offset VkPhysicalDeviceLimits, maxTessellationEvaluationInputComponents} + + {-# INLINE readVkMaxTessellationEvaluationInputComponents #-} + readVkMaxTessellationEvaluationInputComponents p + = peekByteOff p #{offset VkPhysicalDeviceLimits, maxTessellationEvaluationInputComponents} + + {-# INLINE writeVkMaxTessellationEvaluationInputComponents #-} + writeVkMaxTessellationEvaluationInputComponents p + = pokeByteOff p #{offset VkPhysicalDeviceLimits, maxTessellationEvaluationInputComponents} + +instance {-# OVERLAPPING #-} + HasField "maxTessellationEvaluationInputComponents" + VkPhysicalDeviceLimits + where + type FieldType "maxTessellationEvaluationInputComponents" + VkPhysicalDeviceLimits + = Word32 + type FieldOptional "maxTessellationEvaluationInputComponents" + VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + type FieldOffset "maxTessellationEvaluationInputComponents" + VkPhysicalDeviceLimits + = + #{offset VkPhysicalDeviceLimits, maxTessellationEvaluationInputComponents} + type FieldIsArray "maxTessellationEvaluationInputComponents" + VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceLimits, maxTessellationEvaluationInputComponents} + +instance CanReadField "maxTessellationEvaluationInputComponents" + VkPhysicalDeviceLimits + where + {-# INLINE getField #-} + getField = vkMaxTessellationEvaluationInputComponents + + {-# INLINE readField #-} + readField = readVkMaxTessellationEvaluationInputComponents + +instance {-# OVERLAPPING #-} + HasVkMaxTessellationEvaluationOutputComponents + VkPhysicalDeviceLimits + where + type VkMaxTessellationEvaluationOutputComponentsMType + VkPhysicalDeviceLimits + = Word32 + + {-# NOINLINE vkMaxTessellationEvaluationOutputComponents #-} + vkMaxTessellationEvaluationOutputComponents x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceLimits, maxTessellationEvaluationOutputComponents}) + + {-# INLINE vkMaxTessellationEvaluationOutputComponentsByteOffset + #-} + vkMaxTessellationEvaluationOutputComponentsByteOffset ~_ + = #{offset VkPhysicalDeviceLimits, maxTessellationEvaluationOutputComponents} + + {-# INLINE readVkMaxTessellationEvaluationOutputComponents #-} + readVkMaxTessellationEvaluationOutputComponents p + = peekByteOff p #{offset VkPhysicalDeviceLimits, maxTessellationEvaluationOutputComponents} + + {-# INLINE writeVkMaxTessellationEvaluationOutputComponents #-} + writeVkMaxTessellationEvaluationOutputComponents p + = pokeByteOff p #{offset VkPhysicalDeviceLimits, maxTessellationEvaluationOutputComponents} + +instance {-# OVERLAPPING #-} + HasField "maxTessellationEvaluationOutputComponents" + VkPhysicalDeviceLimits + where + type FieldType "maxTessellationEvaluationOutputComponents" + VkPhysicalDeviceLimits + = Word32 + type FieldOptional "maxTessellationEvaluationOutputComponents" + VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + type FieldOffset "maxTessellationEvaluationOutputComponents" + VkPhysicalDeviceLimits + = + #{offset VkPhysicalDeviceLimits, maxTessellationEvaluationOutputComponents} + type FieldIsArray "maxTessellationEvaluationOutputComponents" + VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceLimits, maxTessellationEvaluationOutputComponents} + +instance CanReadField "maxTessellationEvaluationOutputComponents" + VkPhysicalDeviceLimits + where + {-# INLINE getField #-} + getField = vkMaxTessellationEvaluationOutputComponents + + {-# INLINE readField #-} + readField = readVkMaxTessellationEvaluationOutputComponents + +instance {-# OVERLAPPING #-} + HasVkMaxGeometryShaderInvocations VkPhysicalDeviceLimits where + type VkMaxGeometryShaderInvocationsMType VkPhysicalDeviceLimits = + Word32 + + {-# NOINLINE vkMaxGeometryShaderInvocations #-} + vkMaxGeometryShaderInvocations x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceLimits, maxGeometryShaderInvocations}) + + {-# INLINE vkMaxGeometryShaderInvocationsByteOffset #-} + vkMaxGeometryShaderInvocationsByteOffset ~_ + = #{offset VkPhysicalDeviceLimits, maxGeometryShaderInvocations} + + {-# INLINE readVkMaxGeometryShaderInvocations #-} + readVkMaxGeometryShaderInvocations p + = peekByteOff p #{offset VkPhysicalDeviceLimits, maxGeometryShaderInvocations} + + {-# INLINE writeVkMaxGeometryShaderInvocations #-} + writeVkMaxGeometryShaderInvocations p + = pokeByteOff p #{offset VkPhysicalDeviceLimits, maxGeometryShaderInvocations} + +instance {-# OVERLAPPING #-} + HasField "maxGeometryShaderInvocations" VkPhysicalDeviceLimits + where + type FieldType "maxGeometryShaderInvocations" + VkPhysicalDeviceLimits + = Word32 + type FieldOptional "maxGeometryShaderInvocations" + VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + type FieldOffset "maxGeometryShaderInvocations" + VkPhysicalDeviceLimits + = + #{offset VkPhysicalDeviceLimits, maxGeometryShaderInvocations} + type FieldIsArray "maxGeometryShaderInvocations" + VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceLimits, maxGeometryShaderInvocations} + +instance CanReadField "maxGeometryShaderInvocations" + VkPhysicalDeviceLimits + where + {-# INLINE getField #-} + getField = vkMaxGeometryShaderInvocations + + {-# INLINE readField #-} + readField = readVkMaxGeometryShaderInvocations + +instance {-# OVERLAPPING #-} + HasVkMaxGeometryInputComponents VkPhysicalDeviceLimits where + type VkMaxGeometryInputComponentsMType VkPhysicalDeviceLimits = + Word32 + + {-# NOINLINE vkMaxGeometryInputComponents #-} + vkMaxGeometryInputComponents x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceLimits, maxGeometryInputComponents}) + + {-# INLINE vkMaxGeometryInputComponentsByteOffset #-} + vkMaxGeometryInputComponentsByteOffset ~_ + = #{offset VkPhysicalDeviceLimits, maxGeometryInputComponents} + + {-# INLINE readVkMaxGeometryInputComponents #-} + readVkMaxGeometryInputComponents p + = peekByteOff p #{offset VkPhysicalDeviceLimits, maxGeometryInputComponents} + + {-# INLINE writeVkMaxGeometryInputComponents #-} + writeVkMaxGeometryInputComponents p + = pokeByteOff p #{offset VkPhysicalDeviceLimits, maxGeometryInputComponents} + +instance {-# OVERLAPPING #-} + HasField "maxGeometryInputComponents" VkPhysicalDeviceLimits where + type FieldType "maxGeometryInputComponents" VkPhysicalDeviceLimits + = Word32 + type FieldOptional "maxGeometryInputComponents" + VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + type FieldOffset "maxGeometryInputComponents" + VkPhysicalDeviceLimits + = + #{offset VkPhysicalDeviceLimits, maxGeometryInputComponents} + type FieldIsArray "maxGeometryInputComponents" + VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceLimits, maxGeometryInputComponents} + +instance CanReadField "maxGeometryInputComponents" + VkPhysicalDeviceLimits + where + {-# INLINE getField #-} + getField = vkMaxGeometryInputComponents + + {-# INLINE readField #-} + readField = readVkMaxGeometryInputComponents + +instance {-# OVERLAPPING #-} + HasVkMaxGeometryOutputComponents VkPhysicalDeviceLimits where + type VkMaxGeometryOutputComponentsMType VkPhysicalDeviceLimits = + Word32 + + {-# NOINLINE vkMaxGeometryOutputComponents #-} + vkMaxGeometryOutputComponents x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceLimits, maxGeometryOutputComponents}) + + {-# INLINE vkMaxGeometryOutputComponentsByteOffset #-} + vkMaxGeometryOutputComponentsByteOffset ~_ + = #{offset VkPhysicalDeviceLimits, maxGeometryOutputComponents} + + {-# INLINE readVkMaxGeometryOutputComponents #-} + readVkMaxGeometryOutputComponents p + = peekByteOff p #{offset VkPhysicalDeviceLimits, maxGeometryOutputComponents} + + {-# INLINE writeVkMaxGeometryOutputComponents #-} + writeVkMaxGeometryOutputComponents p + = pokeByteOff p #{offset VkPhysicalDeviceLimits, maxGeometryOutputComponents} + +instance {-# OVERLAPPING #-} + HasField "maxGeometryOutputComponents" VkPhysicalDeviceLimits where + type FieldType "maxGeometryOutputComponents" VkPhysicalDeviceLimits + = Word32 + type FieldOptional "maxGeometryOutputComponents" + VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + type FieldOffset "maxGeometryOutputComponents" + VkPhysicalDeviceLimits + = + #{offset VkPhysicalDeviceLimits, maxGeometryOutputComponents} + type FieldIsArray "maxGeometryOutputComponents" + VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceLimits, maxGeometryOutputComponents} + +instance CanReadField "maxGeometryOutputComponents" + VkPhysicalDeviceLimits + where + {-# INLINE getField #-} + getField = vkMaxGeometryOutputComponents + + {-# INLINE readField #-} + readField = readVkMaxGeometryOutputComponents + +instance {-# OVERLAPPING #-} + HasVkMaxGeometryOutputVertices VkPhysicalDeviceLimits where + type VkMaxGeometryOutputVerticesMType VkPhysicalDeviceLimits = + Word32 + + {-# NOINLINE vkMaxGeometryOutputVertices #-} + vkMaxGeometryOutputVertices x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceLimits, maxGeometryOutputVertices}) + + {-# INLINE vkMaxGeometryOutputVerticesByteOffset #-} + vkMaxGeometryOutputVerticesByteOffset ~_ + = #{offset VkPhysicalDeviceLimits, maxGeometryOutputVertices} + + {-# INLINE readVkMaxGeometryOutputVertices #-} + readVkMaxGeometryOutputVertices p + = peekByteOff p #{offset VkPhysicalDeviceLimits, maxGeometryOutputVertices} + + {-# INLINE writeVkMaxGeometryOutputVertices #-} + writeVkMaxGeometryOutputVertices p + = pokeByteOff p #{offset VkPhysicalDeviceLimits, maxGeometryOutputVertices} + +instance {-# OVERLAPPING #-} + HasField "maxGeometryOutputVertices" VkPhysicalDeviceLimits where + type FieldType "maxGeometryOutputVertices" VkPhysicalDeviceLimits = + Word32 + type FieldOptional "maxGeometryOutputVertices" + VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + type FieldOffset "maxGeometryOutputVertices" VkPhysicalDeviceLimits + = + #{offset VkPhysicalDeviceLimits, maxGeometryOutputVertices} + type FieldIsArray "maxGeometryOutputVertices" + VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceLimits, maxGeometryOutputVertices} + +instance CanReadField "maxGeometryOutputVertices" + VkPhysicalDeviceLimits + where + {-# INLINE getField #-} + getField = vkMaxGeometryOutputVertices + + {-# INLINE readField #-} + readField = readVkMaxGeometryOutputVertices + +instance {-# OVERLAPPING #-} + HasVkMaxGeometryTotalOutputComponents VkPhysicalDeviceLimits where + type VkMaxGeometryTotalOutputComponentsMType VkPhysicalDeviceLimits + = Word32 + + {-# NOINLINE vkMaxGeometryTotalOutputComponents #-} + vkMaxGeometryTotalOutputComponents x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceLimits, maxGeometryTotalOutputComponents}) + + {-# INLINE vkMaxGeometryTotalOutputComponentsByteOffset #-} + vkMaxGeometryTotalOutputComponentsByteOffset ~_ + = #{offset VkPhysicalDeviceLimits, maxGeometryTotalOutputComponents} + + {-# INLINE readVkMaxGeometryTotalOutputComponents #-} + readVkMaxGeometryTotalOutputComponents p + = peekByteOff p #{offset VkPhysicalDeviceLimits, maxGeometryTotalOutputComponents} + + {-# INLINE writeVkMaxGeometryTotalOutputComponents #-} + writeVkMaxGeometryTotalOutputComponents p + = pokeByteOff p #{offset VkPhysicalDeviceLimits, maxGeometryTotalOutputComponents} + +instance {-# OVERLAPPING #-} + HasField "maxGeometryTotalOutputComponents" VkPhysicalDeviceLimits + where + type FieldType "maxGeometryTotalOutputComponents" + VkPhysicalDeviceLimits + = Word32 + type FieldOptional "maxGeometryTotalOutputComponents" + VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + type FieldOffset "maxGeometryTotalOutputComponents" + VkPhysicalDeviceLimits + = + #{offset VkPhysicalDeviceLimits, maxGeometryTotalOutputComponents} + type FieldIsArray "maxGeometryTotalOutputComponents" + VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceLimits, maxGeometryTotalOutputComponents} + +instance CanReadField "maxGeometryTotalOutputComponents" + VkPhysicalDeviceLimits + where + {-# INLINE getField #-} + getField = vkMaxGeometryTotalOutputComponents + + {-# INLINE readField #-} + readField = readVkMaxGeometryTotalOutputComponents + +instance {-# OVERLAPPING #-} + HasVkMaxFragmentInputComponents VkPhysicalDeviceLimits where + type VkMaxFragmentInputComponentsMType VkPhysicalDeviceLimits = + Word32 + + {-# NOINLINE vkMaxFragmentInputComponents #-} + vkMaxFragmentInputComponents x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceLimits, maxFragmentInputComponents}) + + {-# INLINE vkMaxFragmentInputComponentsByteOffset #-} + vkMaxFragmentInputComponentsByteOffset ~_ + = #{offset VkPhysicalDeviceLimits, maxFragmentInputComponents} + + {-# INLINE readVkMaxFragmentInputComponents #-} + readVkMaxFragmentInputComponents p + = peekByteOff p #{offset VkPhysicalDeviceLimits, maxFragmentInputComponents} + + {-# INLINE writeVkMaxFragmentInputComponents #-} + writeVkMaxFragmentInputComponents p + = pokeByteOff p #{offset VkPhysicalDeviceLimits, maxFragmentInputComponents} + +instance {-# OVERLAPPING #-} + HasField "maxFragmentInputComponents" VkPhysicalDeviceLimits where + type FieldType "maxFragmentInputComponents" VkPhysicalDeviceLimits + = Word32 + type FieldOptional "maxFragmentInputComponents" + VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + type FieldOffset "maxFragmentInputComponents" + VkPhysicalDeviceLimits + = + #{offset VkPhysicalDeviceLimits, maxFragmentInputComponents} + type FieldIsArray "maxFragmentInputComponents" + VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceLimits, maxFragmentInputComponents} + +instance CanReadField "maxFragmentInputComponents" + VkPhysicalDeviceLimits + where + {-# INLINE getField #-} + getField = vkMaxFragmentInputComponents + + {-# INLINE readField #-} + readField = readVkMaxFragmentInputComponents + +instance {-# OVERLAPPING #-} + HasVkMaxFragmentOutputAttachments VkPhysicalDeviceLimits where + type VkMaxFragmentOutputAttachmentsMType VkPhysicalDeviceLimits = + Word32 + + {-# NOINLINE vkMaxFragmentOutputAttachments #-} + vkMaxFragmentOutputAttachments x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceLimits, maxFragmentOutputAttachments}) + + {-# INLINE vkMaxFragmentOutputAttachmentsByteOffset #-} + vkMaxFragmentOutputAttachmentsByteOffset ~_ + = #{offset VkPhysicalDeviceLimits, maxFragmentOutputAttachments} + + {-# INLINE readVkMaxFragmentOutputAttachments #-} + readVkMaxFragmentOutputAttachments p + = peekByteOff p #{offset VkPhysicalDeviceLimits, maxFragmentOutputAttachments} + + {-# INLINE writeVkMaxFragmentOutputAttachments #-} + writeVkMaxFragmentOutputAttachments p + = pokeByteOff p #{offset VkPhysicalDeviceLimits, maxFragmentOutputAttachments} + +instance {-# OVERLAPPING #-} + HasField "maxFragmentOutputAttachments" VkPhysicalDeviceLimits + where + type FieldType "maxFragmentOutputAttachments" + VkPhysicalDeviceLimits + = Word32 + type FieldOptional "maxFragmentOutputAttachments" + VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + type FieldOffset "maxFragmentOutputAttachments" + VkPhysicalDeviceLimits + = + #{offset VkPhysicalDeviceLimits, maxFragmentOutputAttachments} + type FieldIsArray "maxFragmentOutputAttachments" + VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceLimits, maxFragmentOutputAttachments} + +instance CanReadField "maxFragmentOutputAttachments" + VkPhysicalDeviceLimits + where + {-# INLINE getField #-} + getField = vkMaxFragmentOutputAttachments + + {-# INLINE readField #-} + readField = readVkMaxFragmentOutputAttachments + +instance {-# OVERLAPPING #-} + HasVkMaxFragmentDualSrcAttachments VkPhysicalDeviceLimits where + type VkMaxFragmentDualSrcAttachmentsMType VkPhysicalDeviceLimits = + Word32 + + {-# NOINLINE vkMaxFragmentDualSrcAttachments #-} + vkMaxFragmentDualSrcAttachments x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceLimits, maxFragmentDualSrcAttachments}) + + {-# INLINE vkMaxFragmentDualSrcAttachmentsByteOffset #-} + vkMaxFragmentDualSrcAttachmentsByteOffset ~_ + = #{offset VkPhysicalDeviceLimits, maxFragmentDualSrcAttachments} + + {-# INLINE readVkMaxFragmentDualSrcAttachments #-} + readVkMaxFragmentDualSrcAttachments p + = peekByteOff p #{offset VkPhysicalDeviceLimits, maxFragmentDualSrcAttachments} + + {-# INLINE writeVkMaxFragmentDualSrcAttachments #-} + writeVkMaxFragmentDualSrcAttachments p + = pokeByteOff p #{offset VkPhysicalDeviceLimits, maxFragmentDualSrcAttachments} + +instance {-# OVERLAPPING #-} + HasField "maxFragmentDualSrcAttachments" VkPhysicalDeviceLimits + where + type FieldType "maxFragmentDualSrcAttachments" + VkPhysicalDeviceLimits + = Word32 + type FieldOptional "maxFragmentDualSrcAttachments" + VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + type FieldOffset "maxFragmentDualSrcAttachments" + VkPhysicalDeviceLimits + = + #{offset VkPhysicalDeviceLimits, maxFragmentDualSrcAttachments} + type FieldIsArray "maxFragmentDualSrcAttachments" + VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceLimits, maxFragmentDualSrcAttachments} + +instance CanReadField "maxFragmentDualSrcAttachments" + VkPhysicalDeviceLimits + where + {-# INLINE getField #-} + getField = vkMaxFragmentDualSrcAttachments + + {-# INLINE readField #-} + readField = readVkMaxFragmentDualSrcAttachments + +instance {-# OVERLAPPING #-} + HasVkMaxFragmentCombinedOutputResources VkPhysicalDeviceLimits + where + type VkMaxFragmentCombinedOutputResourcesMType + VkPhysicalDeviceLimits + = Word32 + + {-# NOINLINE vkMaxFragmentCombinedOutputResources #-} + vkMaxFragmentCombinedOutputResources x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceLimits, maxFragmentCombinedOutputResources}) + + {-# INLINE vkMaxFragmentCombinedOutputResourcesByteOffset #-} + vkMaxFragmentCombinedOutputResourcesByteOffset ~_ + = #{offset VkPhysicalDeviceLimits, maxFragmentCombinedOutputResources} + + {-# INLINE readVkMaxFragmentCombinedOutputResources #-} + readVkMaxFragmentCombinedOutputResources p + = peekByteOff p #{offset VkPhysicalDeviceLimits, maxFragmentCombinedOutputResources} + + {-# INLINE writeVkMaxFragmentCombinedOutputResources #-} + writeVkMaxFragmentCombinedOutputResources p + = pokeByteOff p #{offset VkPhysicalDeviceLimits, maxFragmentCombinedOutputResources} + +instance {-# OVERLAPPING #-} + HasField "maxFragmentCombinedOutputResources" + VkPhysicalDeviceLimits + where + type FieldType "maxFragmentCombinedOutputResources" + VkPhysicalDeviceLimits + = Word32 + type FieldOptional "maxFragmentCombinedOutputResources" + VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + type FieldOffset "maxFragmentCombinedOutputResources" + VkPhysicalDeviceLimits + = + #{offset VkPhysicalDeviceLimits, maxFragmentCombinedOutputResources} + type FieldIsArray "maxFragmentCombinedOutputResources" + VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceLimits, maxFragmentCombinedOutputResources} + +instance CanReadField "maxFragmentCombinedOutputResources" + VkPhysicalDeviceLimits + where + {-# INLINE getField #-} + getField = vkMaxFragmentCombinedOutputResources + + {-# INLINE readField #-} + readField = readVkMaxFragmentCombinedOutputResources + +instance {-# OVERLAPPING #-} + HasVkMaxComputeSharedMemorySize VkPhysicalDeviceLimits where + type VkMaxComputeSharedMemorySizeMType VkPhysicalDeviceLimits = + Word32 + + {-# NOINLINE vkMaxComputeSharedMemorySize #-} + vkMaxComputeSharedMemorySize x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceLimits, maxComputeSharedMemorySize}) + + {-# INLINE vkMaxComputeSharedMemorySizeByteOffset #-} + vkMaxComputeSharedMemorySizeByteOffset ~_ + = #{offset VkPhysicalDeviceLimits, maxComputeSharedMemorySize} + + {-# INLINE readVkMaxComputeSharedMemorySize #-} + readVkMaxComputeSharedMemorySize p + = peekByteOff p #{offset VkPhysicalDeviceLimits, maxComputeSharedMemorySize} + + {-# INLINE writeVkMaxComputeSharedMemorySize #-} + writeVkMaxComputeSharedMemorySize p + = pokeByteOff p #{offset VkPhysicalDeviceLimits, maxComputeSharedMemorySize} + +instance {-# OVERLAPPING #-} + HasField "maxComputeSharedMemorySize" VkPhysicalDeviceLimits where + type FieldType "maxComputeSharedMemorySize" VkPhysicalDeviceLimits + = Word32 + type FieldOptional "maxComputeSharedMemorySize" + VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + type FieldOffset "maxComputeSharedMemorySize" + VkPhysicalDeviceLimits + = + #{offset VkPhysicalDeviceLimits, maxComputeSharedMemorySize} + type FieldIsArray "maxComputeSharedMemorySize" + VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceLimits, maxComputeSharedMemorySize} + +instance CanReadField "maxComputeSharedMemorySize" + VkPhysicalDeviceLimits + where + {-# INLINE getField #-} + getField = vkMaxComputeSharedMemorySize + + {-# INLINE readField #-} + readField = readVkMaxComputeSharedMemorySize + +instance {-# OVERLAPPING #-} + HasVkMaxComputeWorkGroupCountArray VkPhysicalDeviceLimits where + type VkMaxComputeWorkGroupCountArrayMType VkPhysicalDeviceLimits = + Word32 + + {-# NOINLINE vkMaxComputeWorkGroupCountArray #-} + vkMaxComputeWorkGroupCountArray x idx + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) + (idx * sizeOf (undefined :: Word32) + + #{offset VkPhysicalDeviceLimits, maxComputeWorkGroupCount})) + + {-# INLINE vkMaxComputeWorkGroupCountArrayByteOffset #-} + vkMaxComputeWorkGroupCountArrayByteOffset ~_ + = #{offset VkPhysicalDeviceLimits, maxComputeWorkGroupCount} + + {-# INLINE readVkMaxComputeWorkGroupCountArray #-} + readVkMaxComputeWorkGroupCountArray p idx + = peekByteOff p + (idx * sizeOf (undefined :: Word32) + + #{offset VkPhysicalDeviceLimits, maxComputeWorkGroupCount}) + + {-# INLINE writeVkMaxComputeWorkGroupCountArray #-} + writeVkMaxComputeWorkGroupCountArray p idx + = pokeByteOff p + (idx * sizeOf (undefined :: Word32) + + #{offset VkPhysicalDeviceLimits, maxComputeWorkGroupCount}) + +instance {-# OVERLAPPING #-} + HasField "maxComputeWorkGroupCount" VkPhysicalDeviceLimits where + type FieldType "maxComputeWorkGroupCount" VkPhysicalDeviceLimits = + Word32 + type FieldOptional "maxComputeWorkGroupCount" + VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + type FieldOffset "maxComputeWorkGroupCount" VkPhysicalDeviceLimits + = + #{offset VkPhysicalDeviceLimits, maxComputeWorkGroupCount} + type FieldIsArray "maxComputeWorkGroupCount" VkPhysicalDeviceLimits + = 'True -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceLimits, maxComputeWorkGroupCount} + +instance (KnownNat idx, + IndexInBounds "maxComputeWorkGroupCount" idx + VkPhysicalDeviceLimits) => + CanReadFieldArray "maxComputeWorkGroupCount" idx + VkPhysicalDeviceLimits + where + {-# SPECIALISE instance + CanReadFieldArray "maxComputeWorkGroupCount" 0 + VkPhysicalDeviceLimits + #-} + + {-# SPECIALISE instance + CanReadFieldArray "maxComputeWorkGroupCount" 1 + VkPhysicalDeviceLimits + #-} + + {-# SPECIALISE instance + CanReadFieldArray "maxComputeWorkGroupCount" 2 + VkPhysicalDeviceLimits + #-} + type FieldArrayLength "maxComputeWorkGroupCount" + VkPhysicalDeviceLimits + = 3 + + {-# INLINE fieldArrayLength #-} + fieldArrayLength = 3 + + {-# INLINE getFieldArray #-} + getFieldArray x + = vkMaxComputeWorkGroupCountArray x + (fromInteger $ natVal' (proxy## :: Proxy## idx)) -- ' closing tick for hsc2hs + + {-# INLINE readFieldArray #-} + readFieldArray x + = readVkMaxComputeWorkGroupCountArray x + (fromInteger $ natVal' (proxy## :: Proxy## idx)) -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkMaxComputeWorkGroupInvocations VkPhysicalDeviceLimits where + type VkMaxComputeWorkGroupInvocationsMType VkPhysicalDeviceLimits = + Word32 + + {-# NOINLINE vkMaxComputeWorkGroupInvocations #-} + vkMaxComputeWorkGroupInvocations x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceLimits, maxComputeWorkGroupInvocations}) + + {-# INLINE vkMaxComputeWorkGroupInvocationsByteOffset #-} + vkMaxComputeWorkGroupInvocationsByteOffset ~_ + = #{offset VkPhysicalDeviceLimits, maxComputeWorkGroupInvocations} + + {-# INLINE readVkMaxComputeWorkGroupInvocations #-} + readVkMaxComputeWorkGroupInvocations p + = peekByteOff p #{offset VkPhysicalDeviceLimits, maxComputeWorkGroupInvocations} + + {-# INLINE writeVkMaxComputeWorkGroupInvocations #-} + writeVkMaxComputeWorkGroupInvocations p + = pokeByteOff p #{offset VkPhysicalDeviceLimits, maxComputeWorkGroupInvocations} + +instance {-# OVERLAPPING #-} + HasField "maxComputeWorkGroupInvocations" VkPhysicalDeviceLimits + where + type FieldType "maxComputeWorkGroupInvocations" + VkPhysicalDeviceLimits + = Word32 + type FieldOptional "maxComputeWorkGroupInvocations" + VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + type FieldOffset "maxComputeWorkGroupInvocations" + VkPhysicalDeviceLimits + = + #{offset VkPhysicalDeviceLimits, maxComputeWorkGroupInvocations} + type FieldIsArray "maxComputeWorkGroupInvocations" + VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceLimits, maxComputeWorkGroupInvocations} + +instance CanReadField "maxComputeWorkGroupInvocations" + VkPhysicalDeviceLimits + where + {-# INLINE getField #-} + getField = vkMaxComputeWorkGroupInvocations + + {-# INLINE readField #-} + readField = readVkMaxComputeWorkGroupInvocations + +instance {-# OVERLAPPING #-} + HasVkMaxComputeWorkGroupSizeArray VkPhysicalDeviceLimits where + type VkMaxComputeWorkGroupSizeArrayMType VkPhysicalDeviceLimits = + Word32 + + {-# NOINLINE vkMaxComputeWorkGroupSizeArray #-} + vkMaxComputeWorkGroupSizeArray x idx + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) + (idx * sizeOf (undefined :: Word32) + + #{offset VkPhysicalDeviceLimits, maxComputeWorkGroupSize})) + + {-# INLINE vkMaxComputeWorkGroupSizeArrayByteOffset #-} + vkMaxComputeWorkGroupSizeArrayByteOffset ~_ + = #{offset VkPhysicalDeviceLimits, maxComputeWorkGroupSize} + + {-# INLINE readVkMaxComputeWorkGroupSizeArray #-} + readVkMaxComputeWorkGroupSizeArray p idx + = peekByteOff p + (idx * sizeOf (undefined :: Word32) + + #{offset VkPhysicalDeviceLimits, maxComputeWorkGroupSize}) + + {-# INLINE writeVkMaxComputeWorkGroupSizeArray #-} + writeVkMaxComputeWorkGroupSizeArray p idx + = pokeByteOff p + (idx * sizeOf (undefined :: Word32) + + #{offset VkPhysicalDeviceLimits, maxComputeWorkGroupSize}) + +instance {-# OVERLAPPING #-} + HasField "maxComputeWorkGroupSize" VkPhysicalDeviceLimits where + type FieldType "maxComputeWorkGroupSize" VkPhysicalDeviceLimits = + Word32 + type FieldOptional "maxComputeWorkGroupSize" VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + type FieldOffset "maxComputeWorkGroupSize" VkPhysicalDeviceLimits = + #{offset VkPhysicalDeviceLimits, maxComputeWorkGroupSize} + type FieldIsArray "maxComputeWorkGroupSize" VkPhysicalDeviceLimits + = 'True -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceLimits, maxComputeWorkGroupSize} + +instance (KnownNat idx, + IndexInBounds "maxComputeWorkGroupSize" idx + VkPhysicalDeviceLimits) => + CanReadFieldArray "maxComputeWorkGroupSize" idx + VkPhysicalDeviceLimits + where + {-# SPECIALISE instance + CanReadFieldArray "maxComputeWorkGroupSize" 0 + VkPhysicalDeviceLimits + #-} + + {-# SPECIALISE instance + CanReadFieldArray "maxComputeWorkGroupSize" 1 + VkPhysicalDeviceLimits + #-} + + {-# SPECIALISE instance + CanReadFieldArray "maxComputeWorkGroupSize" 2 + VkPhysicalDeviceLimits + #-} + type FieldArrayLength "maxComputeWorkGroupSize" + VkPhysicalDeviceLimits + = 3 + + {-# INLINE fieldArrayLength #-} + fieldArrayLength = 3 + + {-# INLINE getFieldArray #-} + getFieldArray x + = vkMaxComputeWorkGroupSizeArray x + (fromInteger $ natVal' (proxy## :: Proxy## idx)) -- ' closing tick for hsc2hs + + {-# INLINE readFieldArray #-} + readFieldArray x + = readVkMaxComputeWorkGroupSizeArray x + (fromInteger $ natVal' (proxy## :: Proxy## idx)) -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSubPixelPrecisionBits VkPhysicalDeviceLimits where + type VkSubPixelPrecisionBitsMType VkPhysicalDeviceLimits = Word32 + + {-# NOINLINE vkSubPixelPrecisionBits #-} + vkSubPixelPrecisionBits x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceLimits, subPixelPrecisionBits}) + + {-# INLINE vkSubPixelPrecisionBitsByteOffset #-} + vkSubPixelPrecisionBitsByteOffset ~_ + = #{offset VkPhysicalDeviceLimits, subPixelPrecisionBits} + + {-# INLINE readVkSubPixelPrecisionBits #-} + readVkSubPixelPrecisionBits p + = peekByteOff p #{offset VkPhysicalDeviceLimits, subPixelPrecisionBits} + + {-# INLINE writeVkSubPixelPrecisionBits #-} + writeVkSubPixelPrecisionBits p + = pokeByteOff p #{offset VkPhysicalDeviceLimits, subPixelPrecisionBits} + +instance {-# OVERLAPPING #-} + HasField "subPixelPrecisionBits" VkPhysicalDeviceLimits where + type FieldType "subPixelPrecisionBits" VkPhysicalDeviceLimits = + Word32 + type FieldOptional "subPixelPrecisionBits" VkPhysicalDeviceLimits = + 'False -- ' closing tick for hsc2hs + type FieldOffset "subPixelPrecisionBits" VkPhysicalDeviceLimits = + #{offset VkPhysicalDeviceLimits, subPixelPrecisionBits} + type FieldIsArray "subPixelPrecisionBits" VkPhysicalDeviceLimits = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceLimits, subPixelPrecisionBits} + +instance CanReadField "subPixelPrecisionBits" + VkPhysicalDeviceLimits + where + {-# INLINE getField #-} + getField = vkSubPixelPrecisionBits + + {-# INLINE readField #-} + readField = readVkSubPixelPrecisionBits + +instance {-# OVERLAPPING #-} + HasVkSubTexelPrecisionBits VkPhysicalDeviceLimits where + type VkSubTexelPrecisionBitsMType VkPhysicalDeviceLimits = Word32 + + {-# NOINLINE vkSubTexelPrecisionBits #-} + vkSubTexelPrecisionBits x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceLimits, subTexelPrecisionBits}) + + {-# INLINE vkSubTexelPrecisionBitsByteOffset #-} + vkSubTexelPrecisionBitsByteOffset ~_ + = #{offset VkPhysicalDeviceLimits, subTexelPrecisionBits} + + {-# INLINE readVkSubTexelPrecisionBits #-} + readVkSubTexelPrecisionBits p + = peekByteOff p #{offset VkPhysicalDeviceLimits, subTexelPrecisionBits} + + {-# INLINE writeVkSubTexelPrecisionBits #-} + writeVkSubTexelPrecisionBits p + = pokeByteOff p #{offset VkPhysicalDeviceLimits, subTexelPrecisionBits} + +instance {-# OVERLAPPING #-} + HasField "subTexelPrecisionBits" VkPhysicalDeviceLimits where + type FieldType "subTexelPrecisionBits" VkPhysicalDeviceLimits = + Word32 + type FieldOptional "subTexelPrecisionBits" VkPhysicalDeviceLimits = + 'False -- ' closing tick for hsc2hs + type FieldOffset "subTexelPrecisionBits" VkPhysicalDeviceLimits = + #{offset VkPhysicalDeviceLimits, subTexelPrecisionBits} + type FieldIsArray "subTexelPrecisionBits" VkPhysicalDeviceLimits = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceLimits, subTexelPrecisionBits} + +instance CanReadField "subTexelPrecisionBits" + VkPhysicalDeviceLimits + where + {-# INLINE getField #-} + getField = vkSubTexelPrecisionBits + + {-# INLINE readField #-} + readField = readVkSubTexelPrecisionBits + +instance {-# OVERLAPPING #-} + HasVkMipmapPrecisionBits VkPhysicalDeviceLimits where + type VkMipmapPrecisionBitsMType VkPhysicalDeviceLimits = Word32 + + {-# NOINLINE vkMipmapPrecisionBits #-} + vkMipmapPrecisionBits x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceLimits, mipmapPrecisionBits}) + + {-# INLINE vkMipmapPrecisionBitsByteOffset #-} + vkMipmapPrecisionBitsByteOffset ~_ + = #{offset VkPhysicalDeviceLimits, mipmapPrecisionBits} + + {-# INLINE readVkMipmapPrecisionBits #-} + readVkMipmapPrecisionBits p + = peekByteOff p #{offset VkPhysicalDeviceLimits, mipmapPrecisionBits} + + {-# INLINE writeVkMipmapPrecisionBits #-} + writeVkMipmapPrecisionBits p + = pokeByteOff p #{offset VkPhysicalDeviceLimits, mipmapPrecisionBits} + +instance {-# OVERLAPPING #-} + HasField "mipmapPrecisionBits" VkPhysicalDeviceLimits where + type FieldType "mipmapPrecisionBits" VkPhysicalDeviceLimits = + Word32 + type FieldOptional "mipmapPrecisionBits" VkPhysicalDeviceLimits = + 'False -- ' closing tick for hsc2hs + type FieldOffset "mipmapPrecisionBits" VkPhysicalDeviceLimits = + #{offset VkPhysicalDeviceLimits, mipmapPrecisionBits} + type FieldIsArray "mipmapPrecisionBits" VkPhysicalDeviceLimits = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceLimits, mipmapPrecisionBits} + +instance CanReadField "mipmapPrecisionBits" VkPhysicalDeviceLimits + where + {-# INLINE getField #-} + getField = vkMipmapPrecisionBits + + {-# INLINE readField #-} + readField = readVkMipmapPrecisionBits + +instance {-# OVERLAPPING #-} + HasVkMaxDrawIndexedIndexValue VkPhysicalDeviceLimits where + type VkMaxDrawIndexedIndexValueMType VkPhysicalDeviceLimits = + Word32 + + {-# NOINLINE vkMaxDrawIndexedIndexValue #-} + vkMaxDrawIndexedIndexValue x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceLimits, maxDrawIndexedIndexValue}) + + {-# INLINE vkMaxDrawIndexedIndexValueByteOffset #-} + vkMaxDrawIndexedIndexValueByteOffset ~_ + = #{offset VkPhysicalDeviceLimits, maxDrawIndexedIndexValue} + + {-# INLINE readVkMaxDrawIndexedIndexValue #-} + readVkMaxDrawIndexedIndexValue p + = peekByteOff p #{offset VkPhysicalDeviceLimits, maxDrawIndexedIndexValue} + + {-# INLINE writeVkMaxDrawIndexedIndexValue #-} + writeVkMaxDrawIndexedIndexValue p + = pokeByteOff p #{offset VkPhysicalDeviceLimits, maxDrawIndexedIndexValue} + +instance {-# OVERLAPPING #-} + HasField "maxDrawIndexedIndexValue" VkPhysicalDeviceLimits where + type FieldType "maxDrawIndexedIndexValue" VkPhysicalDeviceLimits = + Word32 + type FieldOptional "maxDrawIndexedIndexValue" + VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + type FieldOffset "maxDrawIndexedIndexValue" VkPhysicalDeviceLimits + = + #{offset VkPhysicalDeviceLimits, maxDrawIndexedIndexValue} + type FieldIsArray "maxDrawIndexedIndexValue" VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceLimits, maxDrawIndexedIndexValue} + +instance CanReadField "maxDrawIndexedIndexValue" + VkPhysicalDeviceLimits + where + {-# INLINE getField #-} + getField = vkMaxDrawIndexedIndexValue + + {-# INLINE readField #-} + readField = readVkMaxDrawIndexedIndexValue + +instance {-# OVERLAPPING #-} + HasVkMaxDrawIndirectCount VkPhysicalDeviceLimits where + type VkMaxDrawIndirectCountMType VkPhysicalDeviceLimits = Word32 + + {-# NOINLINE vkMaxDrawIndirectCount #-} + vkMaxDrawIndirectCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceLimits, maxDrawIndirectCount}) + + {-# INLINE vkMaxDrawIndirectCountByteOffset #-} + vkMaxDrawIndirectCountByteOffset ~_ + = #{offset VkPhysicalDeviceLimits, maxDrawIndirectCount} + + {-# INLINE readVkMaxDrawIndirectCount #-} + readVkMaxDrawIndirectCount p + = peekByteOff p #{offset VkPhysicalDeviceLimits, maxDrawIndirectCount} + + {-# INLINE writeVkMaxDrawIndirectCount #-} + writeVkMaxDrawIndirectCount p + = pokeByteOff p #{offset VkPhysicalDeviceLimits, maxDrawIndirectCount} + +instance {-# OVERLAPPING #-} + HasField "maxDrawIndirectCount" VkPhysicalDeviceLimits where + type FieldType "maxDrawIndirectCount" VkPhysicalDeviceLimits = + Word32 + type FieldOptional "maxDrawIndirectCount" VkPhysicalDeviceLimits = + 'False -- ' closing tick for hsc2hs + type FieldOffset "maxDrawIndirectCount" VkPhysicalDeviceLimits = + #{offset VkPhysicalDeviceLimits, maxDrawIndirectCount} + type FieldIsArray "maxDrawIndirectCount" VkPhysicalDeviceLimits = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceLimits, maxDrawIndirectCount} + +instance CanReadField "maxDrawIndirectCount" VkPhysicalDeviceLimits + where + {-# INLINE getField #-} + getField = vkMaxDrawIndirectCount + + {-# INLINE readField #-} + readField = readVkMaxDrawIndirectCount + +instance {-# OVERLAPPING #-} + HasVkMaxSamplerLodBias VkPhysicalDeviceLimits where + type VkMaxSamplerLodBiasMType VkPhysicalDeviceLimits = + #{type float} + + {-# NOINLINE vkMaxSamplerLodBias #-} + vkMaxSamplerLodBias x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceLimits, maxSamplerLodBias}) + + {-# INLINE vkMaxSamplerLodBiasByteOffset #-} + vkMaxSamplerLodBiasByteOffset ~_ + = #{offset VkPhysicalDeviceLimits, maxSamplerLodBias} + + {-# INLINE readVkMaxSamplerLodBias #-} + readVkMaxSamplerLodBias p + = peekByteOff p #{offset VkPhysicalDeviceLimits, maxSamplerLodBias} + + {-# INLINE writeVkMaxSamplerLodBias #-} + writeVkMaxSamplerLodBias p + = pokeByteOff p #{offset VkPhysicalDeviceLimits, maxSamplerLodBias} + +instance {-# OVERLAPPING #-} + HasField "maxSamplerLodBias" VkPhysicalDeviceLimits where + type FieldType "maxSamplerLodBias" VkPhysicalDeviceLimits = + #{type float} + type FieldOptional "maxSamplerLodBias" VkPhysicalDeviceLimits = + 'False -- ' closing tick for hsc2hs + type FieldOffset "maxSamplerLodBias" VkPhysicalDeviceLimits = + #{offset VkPhysicalDeviceLimits, maxSamplerLodBias} + type FieldIsArray "maxSamplerLodBias" VkPhysicalDeviceLimits = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceLimits, maxSamplerLodBias} + +instance CanReadField "maxSamplerLodBias" VkPhysicalDeviceLimits + where + {-# INLINE getField #-} + getField = vkMaxSamplerLodBias + + {-# INLINE readField #-} + readField = readVkMaxSamplerLodBias + +instance {-# OVERLAPPING #-} + HasVkMaxSamplerAnisotropy VkPhysicalDeviceLimits where + type VkMaxSamplerAnisotropyMType VkPhysicalDeviceLimits = + #{type float} + + {-# NOINLINE vkMaxSamplerAnisotropy #-} + vkMaxSamplerAnisotropy x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceLimits, maxSamplerAnisotropy}) + + {-# INLINE vkMaxSamplerAnisotropyByteOffset #-} + vkMaxSamplerAnisotropyByteOffset ~_ + = #{offset VkPhysicalDeviceLimits, maxSamplerAnisotropy} + + {-# INLINE readVkMaxSamplerAnisotropy #-} + readVkMaxSamplerAnisotropy p + = peekByteOff p #{offset VkPhysicalDeviceLimits, maxSamplerAnisotropy} + + {-# INLINE writeVkMaxSamplerAnisotropy #-} + writeVkMaxSamplerAnisotropy p + = pokeByteOff p #{offset VkPhysicalDeviceLimits, maxSamplerAnisotropy} + +instance {-# OVERLAPPING #-} + HasField "maxSamplerAnisotropy" VkPhysicalDeviceLimits where + type FieldType "maxSamplerAnisotropy" VkPhysicalDeviceLimits = + #{type float} + type FieldOptional "maxSamplerAnisotropy" VkPhysicalDeviceLimits = + 'False -- ' closing tick for hsc2hs + type FieldOffset "maxSamplerAnisotropy" VkPhysicalDeviceLimits = + #{offset VkPhysicalDeviceLimits, maxSamplerAnisotropy} + type FieldIsArray "maxSamplerAnisotropy" VkPhysicalDeviceLimits = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceLimits, maxSamplerAnisotropy} + +instance CanReadField "maxSamplerAnisotropy" VkPhysicalDeviceLimits + where + {-# INLINE getField #-} + getField = vkMaxSamplerAnisotropy + + {-# INLINE readField #-} + readField = readVkMaxSamplerAnisotropy + +instance {-# OVERLAPPING #-} + HasVkMaxViewports VkPhysicalDeviceLimits where + type VkMaxViewportsMType VkPhysicalDeviceLimits = Word32 + + {-# NOINLINE vkMaxViewports #-} + vkMaxViewports x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceLimits, maxViewports}) + + {-# INLINE vkMaxViewportsByteOffset #-} + vkMaxViewportsByteOffset ~_ + = #{offset VkPhysicalDeviceLimits, maxViewports} + + {-# INLINE readVkMaxViewports #-} + readVkMaxViewports p + = peekByteOff p #{offset VkPhysicalDeviceLimits, maxViewports} + + {-# INLINE writeVkMaxViewports #-} + writeVkMaxViewports p + = pokeByteOff p #{offset VkPhysicalDeviceLimits, maxViewports} + +instance {-# OVERLAPPING #-} + HasField "maxViewports" VkPhysicalDeviceLimits where + type FieldType "maxViewports" VkPhysicalDeviceLimits = Word32 + type FieldOptional "maxViewports" VkPhysicalDeviceLimits = 'False -- ' closing tick for hsc2hs + type FieldOffset "maxViewports" VkPhysicalDeviceLimits = + #{offset VkPhysicalDeviceLimits, maxViewports} + type FieldIsArray "maxViewports" VkPhysicalDeviceLimits = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceLimits, maxViewports} + +instance CanReadField "maxViewports" VkPhysicalDeviceLimits where + {-# INLINE getField #-} + getField = vkMaxViewports + + {-# INLINE readField #-} + readField = readVkMaxViewports + +instance {-# OVERLAPPING #-} + HasVkMaxViewportDimensionsArray VkPhysicalDeviceLimits where + type VkMaxViewportDimensionsArrayMType VkPhysicalDeviceLimits = + Word32 + + {-# NOINLINE vkMaxViewportDimensionsArray #-} + vkMaxViewportDimensionsArray x idx + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) + (idx * sizeOf (undefined :: Word32) + + #{offset VkPhysicalDeviceLimits, maxViewportDimensions})) + + {-# INLINE vkMaxViewportDimensionsArrayByteOffset #-} + vkMaxViewportDimensionsArrayByteOffset ~_ + = #{offset VkPhysicalDeviceLimits, maxViewportDimensions} + + {-# INLINE readVkMaxViewportDimensionsArray #-} + readVkMaxViewportDimensionsArray p idx + = peekByteOff p + (idx * sizeOf (undefined :: Word32) + + #{offset VkPhysicalDeviceLimits, maxViewportDimensions}) + + {-# INLINE writeVkMaxViewportDimensionsArray #-} + writeVkMaxViewportDimensionsArray p idx + = pokeByteOff p + (idx * sizeOf (undefined :: Word32) + + #{offset VkPhysicalDeviceLimits, maxViewportDimensions}) + +instance {-# OVERLAPPING #-} + HasField "maxViewportDimensions" VkPhysicalDeviceLimits where + type FieldType "maxViewportDimensions" VkPhysicalDeviceLimits = + Word32 + type FieldOptional "maxViewportDimensions" VkPhysicalDeviceLimits = + 'False -- ' closing tick for hsc2hs + type FieldOffset "maxViewportDimensions" VkPhysicalDeviceLimits = + #{offset VkPhysicalDeviceLimits, maxViewportDimensions} + type FieldIsArray "maxViewportDimensions" VkPhysicalDeviceLimits = + 'True -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceLimits, maxViewportDimensions} + +instance (KnownNat idx, + IndexInBounds "maxViewportDimensions" idx + VkPhysicalDeviceLimits) => + CanReadFieldArray "maxViewportDimensions" idx + VkPhysicalDeviceLimits + where + {-# SPECIALISE instance + CanReadFieldArray "maxViewportDimensions" 0 VkPhysicalDeviceLimits + #-} + + {-# SPECIALISE instance + CanReadFieldArray "maxViewportDimensions" 1 VkPhysicalDeviceLimits + #-} + type FieldArrayLength "maxViewportDimensions" + VkPhysicalDeviceLimits + = 2 + + {-# INLINE fieldArrayLength #-} + fieldArrayLength = 2 + + {-# INLINE getFieldArray #-} + getFieldArray x + = vkMaxViewportDimensionsArray x + (fromInteger $ natVal' (proxy## :: Proxy## idx)) -- ' closing tick for hsc2hs + + {-# INLINE readFieldArray #-} + readFieldArray x + = readVkMaxViewportDimensionsArray x + (fromInteger $ natVal' (proxy## :: Proxy## idx)) -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkViewportBoundsRangeArray VkPhysicalDeviceLimits where + type VkViewportBoundsRangeArrayMType VkPhysicalDeviceLimits = + #{type float} + + {-# NOINLINE vkViewportBoundsRangeArray #-} + vkViewportBoundsRangeArray x idx + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) + (idx * sizeOf (undefined :: #{type float}) + + #{offset VkPhysicalDeviceLimits, viewportBoundsRange})) + + {-# INLINE vkViewportBoundsRangeArrayByteOffset #-} + vkViewportBoundsRangeArrayByteOffset ~_ + = #{offset VkPhysicalDeviceLimits, viewportBoundsRange} + + {-# INLINE readVkViewportBoundsRangeArray #-} + readVkViewportBoundsRangeArray p idx + = peekByteOff p + (idx * sizeOf (undefined :: #{type float}) + + #{offset VkPhysicalDeviceLimits, viewportBoundsRange}) + + {-# INLINE writeVkViewportBoundsRangeArray #-} + writeVkViewportBoundsRangeArray p idx + = pokeByteOff p + (idx * sizeOf (undefined :: #{type float}) + + #{offset VkPhysicalDeviceLimits, viewportBoundsRange}) + +instance {-# OVERLAPPING #-} + HasField "viewportBoundsRange" VkPhysicalDeviceLimits where + type FieldType "viewportBoundsRange" VkPhysicalDeviceLimits = + #{type float} + type FieldOptional "viewportBoundsRange" VkPhysicalDeviceLimits = + 'False -- ' closing tick for hsc2hs + type FieldOffset "viewportBoundsRange" VkPhysicalDeviceLimits = + #{offset VkPhysicalDeviceLimits, viewportBoundsRange} + type FieldIsArray "viewportBoundsRange" VkPhysicalDeviceLimits = + 'True -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceLimits, viewportBoundsRange} + +instance (KnownNat idx, + IndexInBounds "viewportBoundsRange" idx VkPhysicalDeviceLimits) => + CanReadFieldArray "viewportBoundsRange" idx VkPhysicalDeviceLimits + where + {-# SPECIALISE instance + CanReadFieldArray "viewportBoundsRange" 0 VkPhysicalDeviceLimits + #-} + + {-# SPECIALISE instance + CanReadFieldArray "viewportBoundsRange" 1 VkPhysicalDeviceLimits + #-} + type FieldArrayLength "viewportBoundsRange" VkPhysicalDeviceLimits + = 2 + + {-# INLINE fieldArrayLength #-} + fieldArrayLength = 2 + + {-# INLINE getFieldArray #-} + getFieldArray x + = vkViewportBoundsRangeArray x + (fromInteger $ natVal' (proxy## :: Proxy## idx)) -- ' closing tick for hsc2hs + + {-# INLINE readFieldArray #-} + readFieldArray x + = readVkViewportBoundsRangeArray x + (fromInteger $ natVal' (proxy## :: Proxy## idx)) -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkViewportSubPixelBits VkPhysicalDeviceLimits where + type VkViewportSubPixelBitsMType VkPhysicalDeviceLimits = Word32 + + {-# NOINLINE vkViewportSubPixelBits #-} + vkViewportSubPixelBits x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceLimits, viewportSubPixelBits}) + + {-# INLINE vkViewportSubPixelBitsByteOffset #-} + vkViewportSubPixelBitsByteOffset ~_ + = #{offset VkPhysicalDeviceLimits, viewportSubPixelBits} + + {-# INLINE readVkViewportSubPixelBits #-} + readVkViewportSubPixelBits p + = peekByteOff p #{offset VkPhysicalDeviceLimits, viewportSubPixelBits} + + {-# INLINE writeVkViewportSubPixelBits #-} + writeVkViewportSubPixelBits p + = pokeByteOff p #{offset VkPhysicalDeviceLimits, viewportSubPixelBits} + +instance {-# OVERLAPPING #-} + HasField "viewportSubPixelBits" VkPhysicalDeviceLimits where + type FieldType "viewportSubPixelBits" VkPhysicalDeviceLimits = + Word32 + type FieldOptional "viewportSubPixelBits" VkPhysicalDeviceLimits = + 'False -- ' closing tick for hsc2hs + type FieldOffset "viewportSubPixelBits" VkPhysicalDeviceLimits = + #{offset VkPhysicalDeviceLimits, viewportSubPixelBits} + type FieldIsArray "viewportSubPixelBits" VkPhysicalDeviceLimits = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceLimits, viewportSubPixelBits} + +instance CanReadField "viewportSubPixelBits" VkPhysicalDeviceLimits + where + {-# INLINE getField #-} + getField = vkViewportSubPixelBits + + {-# INLINE readField #-} + readField = readVkViewportSubPixelBits + +instance {-# OVERLAPPING #-} + HasVkMinMemoryMapAlignment VkPhysicalDeviceLimits where + type VkMinMemoryMapAlignmentMType VkPhysicalDeviceLimits = CSize + + {-# NOINLINE vkMinMemoryMapAlignment #-} + vkMinMemoryMapAlignment x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceLimits, minMemoryMapAlignment}) + + {-# INLINE vkMinMemoryMapAlignmentByteOffset #-} + vkMinMemoryMapAlignmentByteOffset ~_ + = #{offset VkPhysicalDeviceLimits, minMemoryMapAlignment} + + {-# INLINE readVkMinMemoryMapAlignment #-} + readVkMinMemoryMapAlignment p + = peekByteOff p #{offset VkPhysicalDeviceLimits, minMemoryMapAlignment} + + {-# INLINE writeVkMinMemoryMapAlignment #-} + writeVkMinMemoryMapAlignment p + = pokeByteOff p #{offset VkPhysicalDeviceLimits, minMemoryMapAlignment} + +instance {-# OVERLAPPING #-} + HasField "minMemoryMapAlignment" VkPhysicalDeviceLimits where + type FieldType "minMemoryMapAlignment" VkPhysicalDeviceLimits = + CSize + type FieldOptional "minMemoryMapAlignment" VkPhysicalDeviceLimits = + 'False -- ' closing tick for hsc2hs + type FieldOffset "minMemoryMapAlignment" VkPhysicalDeviceLimits = + #{offset VkPhysicalDeviceLimits, minMemoryMapAlignment} + type FieldIsArray "minMemoryMapAlignment" VkPhysicalDeviceLimits = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceLimits, minMemoryMapAlignment} + +instance CanReadField "minMemoryMapAlignment" + VkPhysicalDeviceLimits + where + {-# INLINE getField #-} + getField = vkMinMemoryMapAlignment + + {-# INLINE readField #-} + readField = readVkMinMemoryMapAlignment + +instance {-# OVERLAPPING #-} + HasVkMinTexelBufferOffsetAlignment VkPhysicalDeviceLimits where + type VkMinTexelBufferOffsetAlignmentMType VkPhysicalDeviceLimits = + VkDeviceSize + + {-# NOINLINE vkMinTexelBufferOffsetAlignment #-} + vkMinTexelBufferOffsetAlignment x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceLimits, minTexelBufferOffsetAlignment}) + + {-# INLINE vkMinTexelBufferOffsetAlignmentByteOffset #-} + vkMinTexelBufferOffsetAlignmentByteOffset ~_ + = #{offset VkPhysicalDeviceLimits, minTexelBufferOffsetAlignment} + + {-# INLINE readVkMinTexelBufferOffsetAlignment #-} + readVkMinTexelBufferOffsetAlignment p + = peekByteOff p #{offset VkPhysicalDeviceLimits, minTexelBufferOffsetAlignment} + + {-# INLINE writeVkMinTexelBufferOffsetAlignment #-} + writeVkMinTexelBufferOffsetAlignment p + = pokeByteOff p #{offset VkPhysicalDeviceLimits, minTexelBufferOffsetAlignment} + +instance {-# OVERLAPPING #-} + HasField "minTexelBufferOffsetAlignment" VkPhysicalDeviceLimits + where + type FieldType "minTexelBufferOffsetAlignment" + VkPhysicalDeviceLimits + = VkDeviceSize + type FieldOptional "minTexelBufferOffsetAlignment" + VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + type FieldOffset "minTexelBufferOffsetAlignment" + VkPhysicalDeviceLimits + = + #{offset VkPhysicalDeviceLimits, minTexelBufferOffsetAlignment} + type FieldIsArray "minTexelBufferOffsetAlignment" + VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceLimits, minTexelBufferOffsetAlignment} + +instance CanReadField "minTexelBufferOffsetAlignment" + VkPhysicalDeviceLimits + where + {-# INLINE getField #-} + getField = vkMinTexelBufferOffsetAlignment + + {-# INLINE readField #-} + readField = readVkMinTexelBufferOffsetAlignment + +instance {-# OVERLAPPING #-} + HasVkMinUniformBufferOffsetAlignment VkPhysicalDeviceLimits where + type VkMinUniformBufferOffsetAlignmentMType VkPhysicalDeviceLimits + = VkDeviceSize + + {-# NOINLINE vkMinUniformBufferOffsetAlignment #-} + vkMinUniformBufferOffsetAlignment x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceLimits, minUniformBufferOffsetAlignment}) + + {-# INLINE vkMinUniformBufferOffsetAlignmentByteOffset #-} + vkMinUniformBufferOffsetAlignmentByteOffset ~_ + = #{offset VkPhysicalDeviceLimits, minUniformBufferOffsetAlignment} + + {-# INLINE readVkMinUniformBufferOffsetAlignment #-} + readVkMinUniformBufferOffsetAlignment p + = peekByteOff p #{offset VkPhysicalDeviceLimits, minUniformBufferOffsetAlignment} + + {-# INLINE writeVkMinUniformBufferOffsetAlignment #-} + writeVkMinUniformBufferOffsetAlignment p + = pokeByteOff p #{offset VkPhysicalDeviceLimits, minUniformBufferOffsetAlignment} + +instance {-# OVERLAPPING #-} + HasField "minUniformBufferOffsetAlignment" VkPhysicalDeviceLimits + where + type FieldType "minUniformBufferOffsetAlignment" + VkPhysicalDeviceLimits + = VkDeviceSize + type FieldOptional "minUniformBufferOffsetAlignment" + VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + type FieldOffset "minUniformBufferOffsetAlignment" + VkPhysicalDeviceLimits + = + #{offset VkPhysicalDeviceLimits, minUniformBufferOffsetAlignment} + type FieldIsArray "minUniformBufferOffsetAlignment" + VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceLimits, minUniformBufferOffsetAlignment} + +instance CanReadField "minUniformBufferOffsetAlignment" + VkPhysicalDeviceLimits + where + {-# INLINE getField #-} + getField = vkMinUniformBufferOffsetAlignment + + {-# INLINE readField #-} + readField = readVkMinUniformBufferOffsetAlignment + +instance {-# OVERLAPPING #-} + HasVkMinStorageBufferOffsetAlignment VkPhysicalDeviceLimits where + type VkMinStorageBufferOffsetAlignmentMType VkPhysicalDeviceLimits + = VkDeviceSize + + {-# NOINLINE vkMinStorageBufferOffsetAlignment #-} + vkMinStorageBufferOffsetAlignment x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceLimits, minStorageBufferOffsetAlignment}) + + {-# INLINE vkMinStorageBufferOffsetAlignmentByteOffset #-} + vkMinStorageBufferOffsetAlignmentByteOffset ~_ + = #{offset VkPhysicalDeviceLimits, minStorageBufferOffsetAlignment} + + {-# INLINE readVkMinStorageBufferOffsetAlignment #-} + readVkMinStorageBufferOffsetAlignment p + = peekByteOff p #{offset VkPhysicalDeviceLimits, minStorageBufferOffsetAlignment} + + {-# INLINE writeVkMinStorageBufferOffsetAlignment #-} + writeVkMinStorageBufferOffsetAlignment p + = pokeByteOff p #{offset VkPhysicalDeviceLimits, minStorageBufferOffsetAlignment} + +instance {-# OVERLAPPING #-} + HasField "minStorageBufferOffsetAlignment" VkPhysicalDeviceLimits + where + type FieldType "minStorageBufferOffsetAlignment" + VkPhysicalDeviceLimits + = VkDeviceSize + type FieldOptional "minStorageBufferOffsetAlignment" + VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + type FieldOffset "minStorageBufferOffsetAlignment" + VkPhysicalDeviceLimits + = + #{offset VkPhysicalDeviceLimits, minStorageBufferOffsetAlignment} + type FieldIsArray "minStorageBufferOffsetAlignment" + VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceLimits, minStorageBufferOffsetAlignment} + +instance CanReadField "minStorageBufferOffsetAlignment" + VkPhysicalDeviceLimits + where + {-# INLINE getField #-} + getField = vkMinStorageBufferOffsetAlignment + + {-# INLINE readField #-} + readField = readVkMinStorageBufferOffsetAlignment + +instance {-# OVERLAPPING #-} + HasVkMinTexelOffset VkPhysicalDeviceLimits where + type VkMinTexelOffsetMType VkPhysicalDeviceLimits = Int32 + + {-# NOINLINE vkMinTexelOffset #-} + vkMinTexelOffset x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceLimits, minTexelOffset}) + + {-# INLINE vkMinTexelOffsetByteOffset #-} + vkMinTexelOffsetByteOffset ~_ + = #{offset VkPhysicalDeviceLimits, minTexelOffset} + + {-# INLINE readVkMinTexelOffset #-} + readVkMinTexelOffset p + = peekByteOff p #{offset VkPhysicalDeviceLimits, minTexelOffset} + + {-# INLINE writeVkMinTexelOffset #-} + writeVkMinTexelOffset p + = pokeByteOff p #{offset VkPhysicalDeviceLimits, minTexelOffset} + +instance {-# OVERLAPPING #-} + HasField "minTexelOffset" VkPhysicalDeviceLimits where + type FieldType "minTexelOffset" VkPhysicalDeviceLimits = Int32 + type FieldOptional "minTexelOffset" VkPhysicalDeviceLimits = 'False -- ' closing tick for hsc2hs + type FieldOffset "minTexelOffset" VkPhysicalDeviceLimits = + #{offset VkPhysicalDeviceLimits, minTexelOffset} + type FieldIsArray "minTexelOffset" VkPhysicalDeviceLimits = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceLimits, minTexelOffset} + +instance CanReadField "minTexelOffset" VkPhysicalDeviceLimits where + {-# INLINE getField #-} + getField = vkMinTexelOffset + + {-# INLINE readField #-} + readField = readVkMinTexelOffset + +instance {-# OVERLAPPING #-} + HasVkMaxTexelOffset VkPhysicalDeviceLimits where + type VkMaxTexelOffsetMType VkPhysicalDeviceLimits = Word32 + + {-# NOINLINE vkMaxTexelOffset #-} + vkMaxTexelOffset x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceLimits, maxTexelOffset}) + + {-# INLINE vkMaxTexelOffsetByteOffset #-} + vkMaxTexelOffsetByteOffset ~_ + = #{offset VkPhysicalDeviceLimits, maxTexelOffset} + + {-# INLINE readVkMaxTexelOffset #-} + readVkMaxTexelOffset p + = peekByteOff p #{offset VkPhysicalDeviceLimits, maxTexelOffset} + + {-# INLINE writeVkMaxTexelOffset #-} + writeVkMaxTexelOffset p + = pokeByteOff p #{offset VkPhysicalDeviceLimits, maxTexelOffset} + +instance {-# OVERLAPPING #-} + HasField "maxTexelOffset" VkPhysicalDeviceLimits where + type FieldType "maxTexelOffset" VkPhysicalDeviceLimits = Word32 + type FieldOptional "maxTexelOffset" VkPhysicalDeviceLimits = 'False -- ' closing tick for hsc2hs + type FieldOffset "maxTexelOffset" VkPhysicalDeviceLimits = + #{offset VkPhysicalDeviceLimits, maxTexelOffset} + type FieldIsArray "maxTexelOffset" VkPhysicalDeviceLimits = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceLimits, maxTexelOffset} + +instance CanReadField "maxTexelOffset" VkPhysicalDeviceLimits where + {-# INLINE getField #-} + getField = vkMaxTexelOffset + + {-# INLINE readField #-} + readField = readVkMaxTexelOffset + +instance {-# OVERLAPPING #-} + HasVkMinTexelGatherOffset VkPhysicalDeviceLimits where + type VkMinTexelGatherOffsetMType VkPhysicalDeviceLimits = Int32 + + {-# NOINLINE vkMinTexelGatherOffset #-} + vkMinTexelGatherOffset x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceLimits, minTexelGatherOffset}) + + {-# INLINE vkMinTexelGatherOffsetByteOffset #-} + vkMinTexelGatherOffsetByteOffset ~_ + = #{offset VkPhysicalDeviceLimits, minTexelGatherOffset} + + {-# INLINE readVkMinTexelGatherOffset #-} + readVkMinTexelGatherOffset p + = peekByteOff p #{offset VkPhysicalDeviceLimits, minTexelGatherOffset} + + {-# INLINE writeVkMinTexelGatherOffset #-} + writeVkMinTexelGatherOffset p + = pokeByteOff p #{offset VkPhysicalDeviceLimits, minTexelGatherOffset} + +instance {-# OVERLAPPING #-} + HasField "minTexelGatherOffset" VkPhysicalDeviceLimits where + type FieldType "minTexelGatherOffset" VkPhysicalDeviceLimits = + Int32 + type FieldOptional "minTexelGatherOffset" VkPhysicalDeviceLimits = + 'False -- ' closing tick for hsc2hs + type FieldOffset "minTexelGatherOffset" VkPhysicalDeviceLimits = + #{offset VkPhysicalDeviceLimits, minTexelGatherOffset} + type FieldIsArray "minTexelGatherOffset" VkPhysicalDeviceLimits = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceLimits, minTexelGatherOffset} + +instance CanReadField "minTexelGatherOffset" VkPhysicalDeviceLimits + where + {-# INLINE getField #-} + getField = vkMinTexelGatherOffset + + {-# INLINE readField #-} + readField = readVkMinTexelGatherOffset + +instance {-# OVERLAPPING #-} + HasVkMaxTexelGatherOffset VkPhysicalDeviceLimits where + type VkMaxTexelGatherOffsetMType VkPhysicalDeviceLimits = Word32 + + {-# NOINLINE vkMaxTexelGatherOffset #-} + vkMaxTexelGatherOffset x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceLimits, maxTexelGatherOffset}) + + {-# INLINE vkMaxTexelGatherOffsetByteOffset #-} + vkMaxTexelGatherOffsetByteOffset ~_ + = #{offset VkPhysicalDeviceLimits, maxTexelGatherOffset} + + {-# INLINE readVkMaxTexelGatherOffset #-} + readVkMaxTexelGatherOffset p + = peekByteOff p #{offset VkPhysicalDeviceLimits, maxTexelGatherOffset} + + {-# INLINE writeVkMaxTexelGatherOffset #-} + writeVkMaxTexelGatherOffset p + = pokeByteOff p #{offset VkPhysicalDeviceLimits, maxTexelGatherOffset} + +instance {-# OVERLAPPING #-} + HasField "maxTexelGatherOffset" VkPhysicalDeviceLimits where + type FieldType "maxTexelGatherOffset" VkPhysicalDeviceLimits = + Word32 + type FieldOptional "maxTexelGatherOffset" VkPhysicalDeviceLimits = + 'False -- ' closing tick for hsc2hs + type FieldOffset "maxTexelGatherOffset" VkPhysicalDeviceLimits = + #{offset VkPhysicalDeviceLimits, maxTexelGatherOffset} + type FieldIsArray "maxTexelGatherOffset" VkPhysicalDeviceLimits = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceLimits, maxTexelGatherOffset} + +instance CanReadField "maxTexelGatherOffset" VkPhysicalDeviceLimits + where + {-# INLINE getField #-} + getField = vkMaxTexelGatherOffset + + {-# INLINE readField #-} + readField = readVkMaxTexelGatherOffset + +instance {-# OVERLAPPING #-} + HasVkMinInterpolationOffset VkPhysicalDeviceLimits where + type VkMinInterpolationOffsetMType VkPhysicalDeviceLimits = + #{type float} + + {-# NOINLINE vkMinInterpolationOffset #-} + vkMinInterpolationOffset x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceLimits, minInterpolationOffset}) + + {-# INLINE vkMinInterpolationOffsetByteOffset #-} + vkMinInterpolationOffsetByteOffset ~_ + = #{offset VkPhysicalDeviceLimits, minInterpolationOffset} + + {-# INLINE readVkMinInterpolationOffset #-} + readVkMinInterpolationOffset p + = peekByteOff p #{offset VkPhysicalDeviceLimits, minInterpolationOffset} + + {-# INLINE writeVkMinInterpolationOffset #-} + writeVkMinInterpolationOffset p + = pokeByteOff p #{offset VkPhysicalDeviceLimits, minInterpolationOffset} + +instance {-# OVERLAPPING #-} + HasField "minInterpolationOffset" VkPhysicalDeviceLimits where + type FieldType "minInterpolationOffset" VkPhysicalDeviceLimits = + #{type float} + type FieldOptional "minInterpolationOffset" VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + type FieldOffset "minInterpolationOffset" VkPhysicalDeviceLimits = + #{offset VkPhysicalDeviceLimits, minInterpolationOffset} + type FieldIsArray "minInterpolationOffset" VkPhysicalDeviceLimits = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceLimits, minInterpolationOffset} + +instance CanReadField "minInterpolationOffset" + VkPhysicalDeviceLimits + where + {-# INLINE getField #-} + getField = vkMinInterpolationOffset + + {-# INLINE readField #-} + readField = readVkMinInterpolationOffset + +instance {-# OVERLAPPING #-} + HasVkMaxInterpolationOffset VkPhysicalDeviceLimits where + type VkMaxInterpolationOffsetMType VkPhysicalDeviceLimits = + #{type float} + + {-# NOINLINE vkMaxInterpolationOffset #-} + vkMaxInterpolationOffset x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceLimits, maxInterpolationOffset}) + + {-# INLINE vkMaxInterpolationOffsetByteOffset #-} + vkMaxInterpolationOffsetByteOffset ~_ + = #{offset VkPhysicalDeviceLimits, maxInterpolationOffset} + + {-# INLINE readVkMaxInterpolationOffset #-} + readVkMaxInterpolationOffset p + = peekByteOff p #{offset VkPhysicalDeviceLimits, maxInterpolationOffset} + + {-# INLINE writeVkMaxInterpolationOffset #-} + writeVkMaxInterpolationOffset p + = pokeByteOff p #{offset VkPhysicalDeviceLimits, maxInterpolationOffset} + +instance {-# OVERLAPPING #-} + HasField "maxInterpolationOffset" VkPhysicalDeviceLimits where + type FieldType "maxInterpolationOffset" VkPhysicalDeviceLimits = + #{type float} + type FieldOptional "maxInterpolationOffset" VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + type FieldOffset "maxInterpolationOffset" VkPhysicalDeviceLimits = + #{offset VkPhysicalDeviceLimits, maxInterpolationOffset} + type FieldIsArray "maxInterpolationOffset" VkPhysicalDeviceLimits = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceLimits, maxInterpolationOffset} + +instance CanReadField "maxInterpolationOffset" + VkPhysicalDeviceLimits + where + {-# INLINE getField #-} + getField = vkMaxInterpolationOffset + + {-# INLINE readField #-} + readField = readVkMaxInterpolationOffset + +instance {-# OVERLAPPING #-} + HasVkSubPixelInterpolationOffsetBits VkPhysicalDeviceLimits where + type VkSubPixelInterpolationOffsetBitsMType VkPhysicalDeviceLimits + = Word32 + + {-# NOINLINE vkSubPixelInterpolationOffsetBits #-} + vkSubPixelInterpolationOffsetBits x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceLimits, subPixelInterpolationOffsetBits}) + + {-# INLINE vkSubPixelInterpolationOffsetBitsByteOffset #-} + vkSubPixelInterpolationOffsetBitsByteOffset ~_ + = #{offset VkPhysicalDeviceLimits, subPixelInterpolationOffsetBits} + + {-# INLINE readVkSubPixelInterpolationOffsetBits #-} + readVkSubPixelInterpolationOffsetBits p + = peekByteOff p #{offset VkPhysicalDeviceLimits, subPixelInterpolationOffsetBits} + + {-# INLINE writeVkSubPixelInterpolationOffsetBits #-} + writeVkSubPixelInterpolationOffsetBits p + = pokeByteOff p #{offset VkPhysicalDeviceLimits, subPixelInterpolationOffsetBits} + +instance {-# OVERLAPPING #-} + HasField "subPixelInterpolationOffsetBits" VkPhysicalDeviceLimits + where + type FieldType "subPixelInterpolationOffsetBits" + VkPhysicalDeviceLimits + = Word32 + type FieldOptional "subPixelInterpolationOffsetBits" + VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + type FieldOffset "subPixelInterpolationOffsetBits" + VkPhysicalDeviceLimits + = + #{offset VkPhysicalDeviceLimits, subPixelInterpolationOffsetBits} + type FieldIsArray "subPixelInterpolationOffsetBits" + VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceLimits, subPixelInterpolationOffsetBits} + +instance CanReadField "subPixelInterpolationOffsetBits" + VkPhysicalDeviceLimits + where + {-# INLINE getField #-} + getField = vkSubPixelInterpolationOffsetBits + + {-# INLINE readField #-} + readField = readVkSubPixelInterpolationOffsetBits + +instance {-# OVERLAPPING #-} + HasVkMaxFramebufferWidth VkPhysicalDeviceLimits where + type VkMaxFramebufferWidthMType VkPhysicalDeviceLimits = Word32 + + {-# NOINLINE vkMaxFramebufferWidth #-} + vkMaxFramebufferWidth x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceLimits, maxFramebufferWidth}) + + {-# INLINE vkMaxFramebufferWidthByteOffset #-} + vkMaxFramebufferWidthByteOffset ~_ + = #{offset VkPhysicalDeviceLimits, maxFramebufferWidth} + + {-# INLINE readVkMaxFramebufferWidth #-} + readVkMaxFramebufferWidth p + = peekByteOff p #{offset VkPhysicalDeviceLimits, maxFramebufferWidth} + + {-# INLINE writeVkMaxFramebufferWidth #-} + writeVkMaxFramebufferWidth p + = pokeByteOff p #{offset VkPhysicalDeviceLimits, maxFramebufferWidth} + +instance {-# OVERLAPPING #-} + HasField "maxFramebufferWidth" VkPhysicalDeviceLimits where + type FieldType "maxFramebufferWidth" VkPhysicalDeviceLimits = + Word32 + type FieldOptional "maxFramebufferWidth" VkPhysicalDeviceLimits = + 'False -- ' closing tick for hsc2hs + type FieldOffset "maxFramebufferWidth" VkPhysicalDeviceLimits = + #{offset VkPhysicalDeviceLimits, maxFramebufferWidth} + type FieldIsArray "maxFramebufferWidth" VkPhysicalDeviceLimits = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceLimits, maxFramebufferWidth} + +instance CanReadField "maxFramebufferWidth" VkPhysicalDeviceLimits + where + {-# INLINE getField #-} + getField = vkMaxFramebufferWidth + + {-# INLINE readField #-} + readField = readVkMaxFramebufferWidth + +instance {-# OVERLAPPING #-} + HasVkMaxFramebufferHeight VkPhysicalDeviceLimits where + type VkMaxFramebufferHeightMType VkPhysicalDeviceLimits = Word32 + + {-# NOINLINE vkMaxFramebufferHeight #-} + vkMaxFramebufferHeight x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceLimits, maxFramebufferHeight}) + + {-# INLINE vkMaxFramebufferHeightByteOffset #-} + vkMaxFramebufferHeightByteOffset ~_ + = #{offset VkPhysicalDeviceLimits, maxFramebufferHeight} + + {-# INLINE readVkMaxFramebufferHeight #-} + readVkMaxFramebufferHeight p + = peekByteOff p #{offset VkPhysicalDeviceLimits, maxFramebufferHeight} + + {-# INLINE writeVkMaxFramebufferHeight #-} + writeVkMaxFramebufferHeight p + = pokeByteOff p #{offset VkPhysicalDeviceLimits, maxFramebufferHeight} + +instance {-# OVERLAPPING #-} + HasField "maxFramebufferHeight" VkPhysicalDeviceLimits where + type FieldType "maxFramebufferHeight" VkPhysicalDeviceLimits = + Word32 + type FieldOptional "maxFramebufferHeight" VkPhysicalDeviceLimits = + 'False -- ' closing tick for hsc2hs + type FieldOffset "maxFramebufferHeight" VkPhysicalDeviceLimits = + #{offset VkPhysicalDeviceLimits, maxFramebufferHeight} + type FieldIsArray "maxFramebufferHeight" VkPhysicalDeviceLimits = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceLimits, maxFramebufferHeight} + +instance CanReadField "maxFramebufferHeight" VkPhysicalDeviceLimits + where + {-# INLINE getField #-} + getField = vkMaxFramebufferHeight + + {-# INLINE readField #-} + readField = readVkMaxFramebufferHeight + +instance {-# OVERLAPPING #-} + HasVkMaxFramebufferLayers VkPhysicalDeviceLimits where + type VkMaxFramebufferLayersMType VkPhysicalDeviceLimits = Word32 + + {-# NOINLINE vkMaxFramebufferLayers #-} + vkMaxFramebufferLayers x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceLimits, maxFramebufferLayers}) + + {-# INLINE vkMaxFramebufferLayersByteOffset #-} + vkMaxFramebufferLayersByteOffset ~_ + = #{offset VkPhysicalDeviceLimits, maxFramebufferLayers} + + {-# INLINE readVkMaxFramebufferLayers #-} + readVkMaxFramebufferLayers p + = peekByteOff p #{offset VkPhysicalDeviceLimits, maxFramebufferLayers} + + {-# INLINE writeVkMaxFramebufferLayers #-} + writeVkMaxFramebufferLayers p + = pokeByteOff p #{offset VkPhysicalDeviceLimits, maxFramebufferLayers} + +instance {-# OVERLAPPING #-} + HasField "maxFramebufferLayers" VkPhysicalDeviceLimits where + type FieldType "maxFramebufferLayers" VkPhysicalDeviceLimits = + Word32 + type FieldOptional "maxFramebufferLayers" VkPhysicalDeviceLimits = + 'False -- ' closing tick for hsc2hs + type FieldOffset "maxFramebufferLayers" VkPhysicalDeviceLimits = + #{offset VkPhysicalDeviceLimits, maxFramebufferLayers} + type FieldIsArray "maxFramebufferLayers" VkPhysicalDeviceLimits = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceLimits, maxFramebufferLayers} + +instance CanReadField "maxFramebufferLayers" VkPhysicalDeviceLimits + where + {-# INLINE getField #-} + getField = vkMaxFramebufferLayers + + {-# INLINE readField #-} + readField = readVkMaxFramebufferLayers + +instance {-# OVERLAPPING #-} + HasVkFramebufferColorSampleCounts VkPhysicalDeviceLimits where + type VkFramebufferColorSampleCountsMType VkPhysicalDeviceLimits = + VkSampleCountFlags + + {-# NOINLINE vkFramebufferColorSampleCounts #-} + vkFramebufferColorSampleCounts x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceLimits, framebufferColorSampleCounts}) + + {-# INLINE vkFramebufferColorSampleCountsByteOffset #-} + vkFramebufferColorSampleCountsByteOffset ~_ + = #{offset VkPhysicalDeviceLimits, framebufferColorSampleCounts} + + {-# INLINE readVkFramebufferColorSampleCounts #-} + readVkFramebufferColorSampleCounts p + = peekByteOff p #{offset VkPhysicalDeviceLimits, framebufferColorSampleCounts} + + {-# INLINE writeVkFramebufferColorSampleCounts #-} + writeVkFramebufferColorSampleCounts p + = pokeByteOff p #{offset VkPhysicalDeviceLimits, framebufferColorSampleCounts} + +instance {-# OVERLAPPING #-} + HasField "framebufferColorSampleCounts" VkPhysicalDeviceLimits + where + type FieldType "framebufferColorSampleCounts" + VkPhysicalDeviceLimits + = VkSampleCountFlags + type FieldOptional "framebufferColorSampleCounts" + VkPhysicalDeviceLimits + = 'True -- ' closing tick for hsc2hs + type FieldOffset "framebufferColorSampleCounts" + VkPhysicalDeviceLimits + = + #{offset VkPhysicalDeviceLimits, framebufferColorSampleCounts} + type FieldIsArray "framebufferColorSampleCounts" + VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceLimits, framebufferColorSampleCounts} + +instance CanReadField "framebufferColorSampleCounts" + VkPhysicalDeviceLimits + where + {-# INLINE getField #-} + getField = vkFramebufferColorSampleCounts + + {-# INLINE readField #-} + readField = readVkFramebufferColorSampleCounts + +instance {-# OVERLAPPING #-} + HasVkFramebufferDepthSampleCounts VkPhysicalDeviceLimits where + type VkFramebufferDepthSampleCountsMType VkPhysicalDeviceLimits = + VkSampleCountFlags + + {-# NOINLINE vkFramebufferDepthSampleCounts #-} + vkFramebufferDepthSampleCounts x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceLimits, framebufferDepthSampleCounts}) + + {-# INLINE vkFramebufferDepthSampleCountsByteOffset #-} + vkFramebufferDepthSampleCountsByteOffset ~_ + = #{offset VkPhysicalDeviceLimits, framebufferDepthSampleCounts} + + {-# INLINE readVkFramebufferDepthSampleCounts #-} + readVkFramebufferDepthSampleCounts p + = peekByteOff p #{offset VkPhysicalDeviceLimits, framebufferDepthSampleCounts} + + {-# INLINE writeVkFramebufferDepthSampleCounts #-} + writeVkFramebufferDepthSampleCounts p + = pokeByteOff p #{offset VkPhysicalDeviceLimits, framebufferDepthSampleCounts} + +instance {-# OVERLAPPING #-} + HasField "framebufferDepthSampleCounts" VkPhysicalDeviceLimits + where + type FieldType "framebufferDepthSampleCounts" + VkPhysicalDeviceLimits + = VkSampleCountFlags + type FieldOptional "framebufferDepthSampleCounts" + VkPhysicalDeviceLimits + = 'True -- ' closing tick for hsc2hs + type FieldOffset "framebufferDepthSampleCounts" + VkPhysicalDeviceLimits + = + #{offset VkPhysicalDeviceLimits, framebufferDepthSampleCounts} + type FieldIsArray "framebufferDepthSampleCounts" + VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceLimits, framebufferDepthSampleCounts} + +instance CanReadField "framebufferDepthSampleCounts" + VkPhysicalDeviceLimits + where + {-# INLINE getField #-} + getField = vkFramebufferDepthSampleCounts + + {-# INLINE readField #-} + readField = readVkFramebufferDepthSampleCounts + +instance {-# OVERLAPPING #-} + HasVkFramebufferStencilSampleCounts VkPhysicalDeviceLimits where + type VkFramebufferStencilSampleCountsMType VkPhysicalDeviceLimits = + VkSampleCountFlags + + {-# NOINLINE vkFramebufferStencilSampleCounts #-} + vkFramebufferStencilSampleCounts x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceLimits, framebufferStencilSampleCounts}) + + {-# INLINE vkFramebufferStencilSampleCountsByteOffset #-} + vkFramebufferStencilSampleCountsByteOffset ~_ + = #{offset VkPhysicalDeviceLimits, framebufferStencilSampleCounts} + + {-# INLINE readVkFramebufferStencilSampleCounts #-} + readVkFramebufferStencilSampleCounts p + = peekByteOff p #{offset VkPhysicalDeviceLimits, framebufferStencilSampleCounts} + + {-# INLINE writeVkFramebufferStencilSampleCounts #-} + writeVkFramebufferStencilSampleCounts p + = pokeByteOff p #{offset VkPhysicalDeviceLimits, framebufferStencilSampleCounts} + +instance {-# OVERLAPPING #-} + HasField "framebufferStencilSampleCounts" VkPhysicalDeviceLimits + where + type FieldType "framebufferStencilSampleCounts" + VkPhysicalDeviceLimits + = VkSampleCountFlags + type FieldOptional "framebufferStencilSampleCounts" + VkPhysicalDeviceLimits + = 'True -- ' closing tick for hsc2hs + type FieldOffset "framebufferStencilSampleCounts" + VkPhysicalDeviceLimits + = + #{offset VkPhysicalDeviceLimits, framebufferStencilSampleCounts} + type FieldIsArray "framebufferStencilSampleCounts" + VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceLimits, framebufferStencilSampleCounts} + +instance CanReadField "framebufferStencilSampleCounts" + VkPhysicalDeviceLimits + where + {-# INLINE getField #-} + getField = vkFramebufferStencilSampleCounts + + {-# INLINE readField #-} + readField = readVkFramebufferStencilSampleCounts + +instance {-# OVERLAPPING #-} + HasVkFramebufferNoAttachmentsSampleCounts VkPhysicalDeviceLimits + where + type VkFramebufferNoAttachmentsSampleCountsMType + VkPhysicalDeviceLimits + = VkSampleCountFlags + + {-# NOINLINE vkFramebufferNoAttachmentsSampleCounts #-} + vkFramebufferNoAttachmentsSampleCounts x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceLimits, framebufferNoAttachmentsSampleCounts}) + + {-# INLINE vkFramebufferNoAttachmentsSampleCountsByteOffset #-} + vkFramebufferNoAttachmentsSampleCountsByteOffset ~_ + = #{offset VkPhysicalDeviceLimits, framebufferNoAttachmentsSampleCounts} + + {-# INLINE readVkFramebufferNoAttachmentsSampleCounts #-} + readVkFramebufferNoAttachmentsSampleCounts p + = peekByteOff p #{offset VkPhysicalDeviceLimits, framebufferNoAttachmentsSampleCounts} + + {-# INLINE writeVkFramebufferNoAttachmentsSampleCounts #-} + writeVkFramebufferNoAttachmentsSampleCounts p + = pokeByteOff p #{offset VkPhysicalDeviceLimits, framebufferNoAttachmentsSampleCounts} + +instance {-# OVERLAPPING #-} + HasField "framebufferNoAttachmentsSampleCounts" + VkPhysicalDeviceLimits + where + type FieldType "framebufferNoAttachmentsSampleCounts" + VkPhysicalDeviceLimits + = VkSampleCountFlags + type FieldOptional "framebufferNoAttachmentsSampleCounts" + VkPhysicalDeviceLimits + = 'True -- ' closing tick for hsc2hs + type FieldOffset "framebufferNoAttachmentsSampleCounts" + VkPhysicalDeviceLimits + = + #{offset VkPhysicalDeviceLimits, framebufferNoAttachmentsSampleCounts} + type FieldIsArray "framebufferNoAttachmentsSampleCounts" + VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceLimits, framebufferNoAttachmentsSampleCounts} + +instance CanReadField "framebufferNoAttachmentsSampleCounts" + VkPhysicalDeviceLimits + where + {-# INLINE getField #-} + getField = vkFramebufferNoAttachmentsSampleCounts + + {-# INLINE readField #-} + readField = readVkFramebufferNoAttachmentsSampleCounts + +instance {-# OVERLAPPING #-} + HasVkMaxColorAttachments VkPhysicalDeviceLimits where + type VkMaxColorAttachmentsMType VkPhysicalDeviceLimits = Word32 + + {-# NOINLINE vkMaxColorAttachments #-} + vkMaxColorAttachments x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceLimits, maxColorAttachments}) + + {-# INLINE vkMaxColorAttachmentsByteOffset #-} + vkMaxColorAttachmentsByteOffset ~_ + = #{offset VkPhysicalDeviceLimits, maxColorAttachments} + + {-# INLINE readVkMaxColorAttachments #-} + readVkMaxColorAttachments p + = peekByteOff p #{offset VkPhysicalDeviceLimits, maxColorAttachments} + + {-# INLINE writeVkMaxColorAttachments #-} + writeVkMaxColorAttachments p + = pokeByteOff p #{offset VkPhysicalDeviceLimits, maxColorAttachments} + +instance {-# OVERLAPPING #-} + HasField "maxColorAttachments" VkPhysicalDeviceLimits where + type FieldType "maxColorAttachments" VkPhysicalDeviceLimits = + Word32 + type FieldOptional "maxColorAttachments" VkPhysicalDeviceLimits = + 'False -- ' closing tick for hsc2hs + type FieldOffset "maxColorAttachments" VkPhysicalDeviceLimits = + #{offset VkPhysicalDeviceLimits, maxColorAttachments} + type FieldIsArray "maxColorAttachments" VkPhysicalDeviceLimits = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceLimits, maxColorAttachments} + +instance CanReadField "maxColorAttachments" VkPhysicalDeviceLimits + where + {-# INLINE getField #-} + getField = vkMaxColorAttachments + + {-# INLINE readField #-} + readField = readVkMaxColorAttachments + +instance {-# OVERLAPPING #-} + HasVkSampledImageColorSampleCounts VkPhysicalDeviceLimits where + type VkSampledImageColorSampleCountsMType VkPhysicalDeviceLimits = + VkSampleCountFlags + + {-# NOINLINE vkSampledImageColorSampleCounts #-} + vkSampledImageColorSampleCounts x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceLimits, sampledImageColorSampleCounts}) + + {-# INLINE vkSampledImageColorSampleCountsByteOffset #-} + vkSampledImageColorSampleCountsByteOffset ~_ + = #{offset VkPhysicalDeviceLimits, sampledImageColorSampleCounts} + + {-# INLINE readVkSampledImageColorSampleCounts #-} + readVkSampledImageColorSampleCounts p + = peekByteOff p #{offset VkPhysicalDeviceLimits, sampledImageColorSampleCounts} + + {-# INLINE writeVkSampledImageColorSampleCounts #-} + writeVkSampledImageColorSampleCounts p + = pokeByteOff p #{offset VkPhysicalDeviceLimits, sampledImageColorSampleCounts} + +instance {-# OVERLAPPING #-} + HasField "sampledImageColorSampleCounts" VkPhysicalDeviceLimits + where + type FieldType "sampledImageColorSampleCounts" + VkPhysicalDeviceLimits + = VkSampleCountFlags + type FieldOptional "sampledImageColorSampleCounts" + VkPhysicalDeviceLimits + = 'True -- ' closing tick for hsc2hs + type FieldOffset "sampledImageColorSampleCounts" + VkPhysicalDeviceLimits + = + #{offset VkPhysicalDeviceLimits, sampledImageColorSampleCounts} + type FieldIsArray "sampledImageColorSampleCounts" + VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceLimits, sampledImageColorSampleCounts} + +instance CanReadField "sampledImageColorSampleCounts" + VkPhysicalDeviceLimits + where + {-# INLINE getField #-} + getField = vkSampledImageColorSampleCounts + + {-# INLINE readField #-} + readField = readVkSampledImageColorSampleCounts + +instance {-# OVERLAPPING #-} + HasVkSampledImageIntegerSampleCounts VkPhysicalDeviceLimits where + type VkSampledImageIntegerSampleCountsMType VkPhysicalDeviceLimits + = VkSampleCountFlags + + {-# NOINLINE vkSampledImageIntegerSampleCounts #-} + vkSampledImageIntegerSampleCounts x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceLimits, sampledImageIntegerSampleCounts}) + + {-# INLINE vkSampledImageIntegerSampleCountsByteOffset #-} + vkSampledImageIntegerSampleCountsByteOffset ~_ + = #{offset VkPhysicalDeviceLimits, sampledImageIntegerSampleCounts} + + {-# INLINE readVkSampledImageIntegerSampleCounts #-} + readVkSampledImageIntegerSampleCounts p + = peekByteOff p #{offset VkPhysicalDeviceLimits, sampledImageIntegerSampleCounts} + + {-# INLINE writeVkSampledImageIntegerSampleCounts #-} + writeVkSampledImageIntegerSampleCounts p + = pokeByteOff p #{offset VkPhysicalDeviceLimits, sampledImageIntegerSampleCounts} + +instance {-# OVERLAPPING #-} + HasField "sampledImageIntegerSampleCounts" VkPhysicalDeviceLimits + where + type FieldType "sampledImageIntegerSampleCounts" + VkPhysicalDeviceLimits + = VkSampleCountFlags + type FieldOptional "sampledImageIntegerSampleCounts" + VkPhysicalDeviceLimits + = 'True -- ' closing tick for hsc2hs + type FieldOffset "sampledImageIntegerSampleCounts" + VkPhysicalDeviceLimits + = + #{offset VkPhysicalDeviceLimits, sampledImageIntegerSampleCounts} + type FieldIsArray "sampledImageIntegerSampleCounts" + VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceLimits, sampledImageIntegerSampleCounts} + +instance CanReadField "sampledImageIntegerSampleCounts" + VkPhysicalDeviceLimits + where + {-# INLINE getField #-} + getField = vkSampledImageIntegerSampleCounts + + {-# INLINE readField #-} + readField = readVkSampledImageIntegerSampleCounts + +instance {-# OVERLAPPING #-} + HasVkSampledImageDepthSampleCounts VkPhysicalDeviceLimits where + type VkSampledImageDepthSampleCountsMType VkPhysicalDeviceLimits = + VkSampleCountFlags + + {-# NOINLINE vkSampledImageDepthSampleCounts #-} + vkSampledImageDepthSampleCounts x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceLimits, sampledImageDepthSampleCounts}) + + {-# INLINE vkSampledImageDepthSampleCountsByteOffset #-} + vkSampledImageDepthSampleCountsByteOffset ~_ + = #{offset VkPhysicalDeviceLimits, sampledImageDepthSampleCounts} + + {-# INLINE readVkSampledImageDepthSampleCounts #-} + readVkSampledImageDepthSampleCounts p + = peekByteOff p #{offset VkPhysicalDeviceLimits, sampledImageDepthSampleCounts} + + {-# INLINE writeVkSampledImageDepthSampleCounts #-} + writeVkSampledImageDepthSampleCounts p + = pokeByteOff p #{offset VkPhysicalDeviceLimits, sampledImageDepthSampleCounts} + +instance {-# OVERLAPPING #-} + HasField "sampledImageDepthSampleCounts" VkPhysicalDeviceLimits + where + type FieldType "sampledImageDepthSampleCounts" + VkPhysicalDeviceLimits + = VkSampleCountFlags + type FieldOptional "sampledImageDepthSampleCounts" + VkPhysicalDeviceLimits + = 'True -- ' closing tick for hsc2hs + type FieldOffset "sampledImageDepthSampleCounts" + VkPhysicalDeviceLimits + = + #{offset VkPhysicalDeviceLimits, sampledImageDepthSampleCounts} + type FieldIsArray "sampledImageDepthSampleCounts" + VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceLimits, sampledImageDepthSampleCounts} + +instance CanReadField "sampledImageDepthSampleCounts" + VkPhysicalDeviceLimits + where + {-# INLINE getField #-} + getField = vkSampledImageDepthSampleCounts + + {-# INLINE readField #-} + readField = readVkSampledImageDepthSampleCounts + +instance {-# OVERLAPPING #-} + HasVkSampledImageStencilSampleCounts VkPhysicalDeviceLimits where + type VkSampledImageStencilSampleCountsMType VkPhysicalDeviceLimits + = VkSampleCountFlags + + {-# NOINLINE vkSampledImageStencilSampleCounts #-} + vkSampledImageStencilSampleCounts x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceLimits, sampledImageStencilSampleCounts}) + + {-# INLINE vkSampledImageStencilSampleCountsByteOffset #-} + vkSampledImageStencilSampleCountsByteOffset ~_ + = #{offset VkPhysicalDeviceLimits, sampledImageStencilSampleCounts} + + {-# INLINE readVkSampledImageStencilSampleCounts #-} + readVkSampledImageStencilSampleCounts p + = peekByteOff p #{offset VkPhysicalDeviceLimits, sampledImageStencilSampleCounts} + + {-# INLINE writeVkSampledImageStencilSampleCounts #-} + writeVkSampledImageStencilSampleCounts p + = pokeByteOff p #{offset VkPhysicalDeviceLimits, sampledImageStencilSampleCounts} + +instance {-# OVERLAPPING #-} + HasField "sampledImageStencilSampleCounts" VkPhysicalDeviceLimits + where + type FieldType "sampledImageStencilSampleCounts" + VkPhysicalDeviceLimits + = VkSampleCountFlags + type FieldOptional "sampledImageStencilSampleCounts" + VkPhysicalDeviceLimits + = 'True -- ' closing tick for hsc2hs + type FieldOffset "sampledImageStencilSampleCounts" + VkPhysicalDeviceLimits + = + #{offset VkPhysicalDeviceLimits, sampledImageStencilSampleCounts} + type FieldIsArray "sampledImageStencilSampleCounts" + VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceLimits, sampledImageStencilSampleCounts} + +instance CanReadField "sampledImageStencilSampleCounts" + VkPhysicalDeviceLimits + where + {-# INLINE getField #-} + getField = vkSampledImageStencilSampleCounts + + {-# INLINE readField #-} + readField = readVkSampledImageStencilSampleCounts + +instance {-# OVERLAPPING #-} + HasVkStorageImageSampleCounts VkPhysicalDeviceLimits where + type VkStorageImageSampleCountsMType VkPhysicalDeviceLimits = + VkSampleCountFlags + + {-# NOINLINE vkStorageImageSampleCounts #-} + vkStorageImageSampleCounts x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceLimits, storageImageSampleCounts}) + + {-# INLINE vkStorageImageSampleCountsByteOffset #-} + vkStorageImageSampleCountsByteOffset ~_ + = #{offset VkPhysicalDeviceLimits, storageImageSampleCounts} + + {-# INLINE readVkStorageImageSampleCounts #-} + readVkStorageImageSampleCounts p + = peekByteOff p #{offset VkPhysicalDeviceLimits, storageImageSampleCounts} + + {-# INLINE writeVkStorageImageSampleCounts #-} + writeVkStorageImageSampleCounts p + = pokeByteOff p #{offset VkPhysicalDeviceLimits, storageImageSampleCounts} + +instance {-# OVERLAPPING #-} + HasField "storageImageSampleCounts" VkPhysicalDeviceLimits where + type FieldType "storageImageSampleCounts" VkPhysicalDeviceLimits = + VkSampleCountFlags + type FieldOptional "storageImageSampleCounts" + VkPhysicalDeviceLimits + = 'True -- ' closing tick for hsc2hs + type FieldOffset "storageImageSampleCounts" VkPhysicalDeviceLimits + = + #{offset VkPhysicalDeviceLimits, storageImageSampleCounts} + type FieldIsArray "storageImageSampleCounts" VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceLimits, storageImageSampleCounts} + +instance CanReadField "storageImageSampleCounts" + VkPhysicalDeviceLimits + where + {-# INLINE getField #-} + getField = vkStorageImageSampleCounts + + {-# INLINE readField #-} + readField = readVkStorageImageSampleCounts + +instance {-# OVERLAPPING #-} + HasVkMaxSampleMaskWords VkPhysicalDeviceLimits where + type VkMaxSampleMaskWordsMType VkPhysicalDeviceLimits = Word32 + + {-# NOINLINE vkMaxSampleMaskWords #-} + vkMaxSampleMaskWords x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceLimits, maxSampleMaskWords}) + + {-# INLINE vkMaxSampleMaskWordsByteOffset #-} + vkMaxSampleMaskWordsByteOffset ~_ + = #{offset VkPhysicalDeviceLimits, maxSampleMaskWords} + + {-# INLINE readVkMaxSampleMaskWords #-} + readVkMaxSampleMaskWords p + = peekByteOff p #{offset VkPhysicalDeviceLimits, maxSampleMaskWords} + + {-# INLINE writeVkMaxSampleMaskWords #-} + writeVkMaxSampleMaskWords p + = pokeByteOff p #{offset VkPhysicalDeviceLimits, maxSampleMaskWords} + +instance {-# OVERLAPPING #-} + HasField "maxSampleMaskWords" VkPhysicalDeviceLimits where + type FieldType "maxSampleMaskWords" VkPhysicalDeviceLimits = Word32 + type FieldOptional "maxSampleMaskWords" VkPhysicalDeviceLimits = + 'False -- ' closing tick for hsc2hs + type FieldOffset "maxSampleMaskWords" VkPhysicalDeviceLimits = + #{offset VkPhysicalDeviceLimits, maxSampleMaskWords} + type FieldIsArray "maxSampleMaskWords" VkPhysicalDeviceLimits = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceLimits, maxSampleMaskWords} + +instance CanReadField "maxSampleMaskWords" VkPhysicalDeviceLimits + where + {-# INLINE getField #-} + getField = vkMaxSampleMaskWords + + {-# INLINE readField #-} + readField = readVkMaxSampleMaskWords + +instance {-# OVERLAPPING #-} + HasVkTimestampComputeAndGraphics VkPhysicalDeviceLimits where + type VkTimestampComputeAndGraphicsMType VkPhysicalDeviceLimits = + VkBool32 + + {-# NOINLINE vkTimestampComputeAndGraphics #-} + vkTimestampComputeAndGraphics x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceLimits, timestampComputeAndGraphics}) + + {-# INLINE vkTimestampComputeAndGraphicsByteOffset #-} + vkTimestampComputeAndGraphicsByteOffset ~_ + = #{offset VkPhysicalDeviceLimits, timestampComputeAndGraphics} + + {-# INLINE readVkTimestampComputeAndGraphics #-} + readVkTimestampComputeAndGraphics p + = peekByteOff p #{offset VkPhysicalDeviceLimits, timestampComputeAndGraphics} + + {-# INLINE writeVkTimestampComputeAndGraphics #-} + writeVkTimestampComputeAndGraphics p + = pokeByteOff p #{offset VkPhysicalDeviceLimits, timestampComputeAndGraphics} + +instance {-# OVERLAPPING #-} + HasField "timestampComputeAndGraphics" VkPhysicalDeviceLimits where + type FieldType "timestampComputeAndGraphics" VkPhysicalDeviceLimits + = VkBool32 + type FieldOptional "timestampComputeAndGraphics" + VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + type FieldOffset "timestampComputeAndGraphics" + VkPhysicalDeviceLimits + = + #{offset VkPhysicalDeviceLimits, timestampComputeAndGraphics} + type FieldIsArray "timestampComputeAndGraphics" + VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceLimits, timestampComputeAndGraphics} + +instance CanReadField "timestampComputeAndGraphics" + VkPhysicalDeviceLimits + where + {-# INLINE getField #-} + getField = vkTimestampComputeAndGraphics + + {-# INLINE readField #-} + readField = readVkTimestampComputeAndGraphics + +instance {-# OVERLAPPING #-} + HasVkTimestampPeriod VkPhysicalDeviceLimits where + type VkTimestampPeriodMType VkPhysicalDeviceLimits = + #{type float} + + {-# NOINLINE vkTimestampPeriod #-} + vkTimestampPeriod x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceLimits, timestampPeriod}) + + {-# INLINE vkTimestampPeriodByteOffset #-} + vkTimestampPeriodByteOffset ~_ + = #{offset VkPhysicalDeviceLimits, timestampPeriod} + + {-# INLINE readVkTimestampPeriod #-} + readVkTimestampPeriod p + = peekByteOff p #{offset VkPhysicalDeviceLimits, timestampPeriod} + + {-# INLINE writeVkTimestampPeriod #-} + writeVkTimestampPeriod p + = pokeByteOff p #{offset VkPhysicalDeviceLimits, timestampPeriod} + +instance {-# OVERLAPPING #-} + HasField "timestampPeriod" VkPhysicalDeviceLimits where + type FieldType "timestampPeriod" VkPhysicalDeviceLimits = + #{type float} + type FieldOptional "timestampPeriod" VkPhysicalDeviceLimits = + 'False -- ' closing tick for hsc2hs + type FieldOffset "timestampPeriod" VkPhysicalDeviceLimits = + #{offset VkPhysicalDeviceLimits, timestampPeriod} + type FieldIsArray "timestampPeriod" VkPhysicalDeviceLimits = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceLimits, timestampPeriod} + +instance CanReadField "timestampPeriod" VkPhysicalDeviceLimits + where + {-# INLINE getField #-} + getField = vkTimestampPeriod + + {-# INLINE readField #-} + readField = readVkTimestampPeriod + +instance {-# OVERLAPPING #-} + HasVkMaxClipDistances VkPhysicalDeviceLimits where + type VkMaxClipDistancesMType VkPhysicalDeviceLimits = Word32 + + {-# NOINLINE vkMaxClipDistances #-} + vkMaxClipDistances x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceLimits, maxClipDistances}) + + {-# INLINE vkMaxClipDistancesByteOffset #-} + vkMaxClipDistancesByteOffset ~_ + = #{offset VkPhysicalDeviceLimits, maxClipDistances} + + {-# INLINE readVkMaxClipDistances #-} + readVkMaxClipDistances p + = peekByteOff p #{offset VkPhysicalDeviceLimits, maxClipDistances} + + {-# INLINE writeVkMaxClipDistances #-} + writeVkMaxClipDistances p + = pokeByteOff p #{offset VkPhysicalDeviceLimits, maxClipDistances} + +instance {-# OVERLAPPING #-} + HasField "maxClipDistances" VkPhysicalDeviceLimits where + type FieldType "maxClipDistances" VkPhysicalDeviceLimits = Word32 + type FieldOptional "maxClipDistances" VkPhysicalDeviceLimits = + 'False -- ' closing tick for hsc2hs + type FieldOffset "maxClipDistances" VkPhysicalDeviceLimits = + #{offset VkPhysicalDeviceLimits, maxClipDistances} + type FieldIsArray "maxClipDistances" VkPhysicalDeviceLimits = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceLimits, maxClipDistances} + +instance CanReadField "maxClipDistances" VkPhysicalDeviceLimits + where + {-# INLINE getField #-} + getField = vkMaxClipDistances + + {-# INLINE readField #-} + readField = readVkMaxClipDistances + +instance {-# OVERLAPPING #-} + HasVkMaxCullDistances VkPhysicalDeviceLimits where + type VkMaxCullDistancesMType VkPhysicalDeviceLimits = Word32 + + {-# NOINLINE vkMaxCullDistances #-} + vkMaxCullDistances x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceLimits, maxCullDistances}) + + {-# INLINE vkMaxCullDistancesByteOffset #-} + vkMaxCullDistancesByteOffset ~_ + = #{offset VkPhysicalDeviceLimits, maxCullDistances} + + {-# INLINE readVkMaxCullDistances #-} + readVkMaxCullDistances p + = peekByteOff p #{offset VkPhysicalDeviceLimits, maxCullDistances} + + {-# INLINE writeVkMaxCullDistances #-} + writeVkMaxCullDistances p + = pokeByteOff p #{offset VkPhysicalDeviceLimits, maxCullDistances} + +instance {-# OVERLAPPING #-} + HasField "maxCullDistances" VkPhysicalDeviceLimits where + type FieldType "maxCullDistances" VkPhysicalDeviceLimits = Word32 + type FieldOptional "maxCullDistances" VkPhysicalDeviceLimits = + 'False -- ' closing tick for hsc2hs + type FieldOffset "maxCullDistances" VkPhysicalDeviceLimits = + #{offset VkPhysicalDeviceLimits, maxCullDistances} + type FieldIsArray "maxCullDistances" VkPhysicalDeviceLimits = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceLimits, maxCullDistances} + +instance CanReadField "maxCullDistances" VkPhysicalDeviceLimits + where + {-# INLINE getField #-} + getField = vkMaxCullDistances + + {-# INLINE readField #-} + readField = readVkMaxCullDistances + +instance {-# OVERLAPPING #-} + HasVkMaxCombinedClipAndCullDistances VkPhysicalDeviceLimits where + type VkMaxCombinedClipAndCullDistancesMType VkPhysicalDeviceLimits + = Word32 + + {-# NOINLINE vkMaxCombinedClipAndCullDistances #-} + vkMaxCombinedClipAndCullDistances x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceLimits, maxCombinedClipAndCullDistances}) + + {-# INLINE vkMaxCombinedClipAndCullDistancesByteOffset #-} + vkMaxCombinedClipAndCullDistancesByteOffset ~_ + = #{offset VkPhysicalDeviceLimits, maxCombinedClipAndCullDistances} + + {-# INLINE readVkMaxCombinedClipAndCullDistances #-} + readVkMaxCombinedClipAndCullDistances p + = peekByteOff p #{offset VkPhysicalDeviceLimits, maxCombinedClipAndCullDistances} + + {-# INLINE writeVkMaxCombinedClipAndCullDistances #-} + writeVkMaxCombinedClipAndCullDistances p + = pokeByteOff p #{offset VkPhysicalDeviceLimits, maxCombinedClipAndCullDistances} + +instance {-# OVERLAPPING #-} + HasField "maxCombinedClipAndCullDistances" VkPhysicalDeviceLimits + where + type FieldType "maxCombinedClipAndCullDistances" + VkPhysicalDeviceLimits + = Word32 + type FieldOptional "maxCombinedClipAndCullDistances" + VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + type FieldOffset "maxCombinedClipAndCullDistances" + VkPhysicalDeviceLimits + = + #{offset VkPhysicalDeviceLimits, maxCombinedClipAndCullDistances} + type FieldIsArray "maxCombinedClipAndCullDistances" + VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceLimits, maxCombinedClipAndCullDistances} + +instance CanReadField "maxCombinedClipAndCullDistances" + VkPhysicalDeviceLimits + where + {-# INLINE getField #-} + getField = vkMaxCombinedClipAndCullDistances + + {-# INLINE readField #-} + readField = readVkMaxCombinedClipAndCullDistances + +instance {-# OVERLAPPING #-} + HasVkDiscreteQueuePriorities VkPhysicalDeviceLimits where + type VkDiscreteQueuePrioritiesMType VkPhysicalDeviceLimits = Word32 + + {-# NOINLINE vkDiscreteQueuePriorities #-} + vkDiscreteQueuePriorities x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceLimits, discreteQueuePriorities}) + + {-# INLINE vkDiscreteQueuePrioritiesByteOffset #-} + vkDiscreteQueuePrioritiesByteOffset ~_ + = #{offset VkPhysicalDeviceLimits, discreteQueuePriorities} + + {-# INLINE readVkDiscreteQueuePriorities #-} + readVkDiscreteQueuePriorities p + = peekByteOff p #{offset VkPhysicalDeviceLimits, discreteQueuePriorities} + + {-# INLINE writeVkDiscreteQueuePriorities #-} + writeVkDiscreteQueuePriorities p + = pokeByteOff p #{offset VkPhysicalDeviceLimits, discreteQueuePriorities} + +instance {-# OVERLAPPING #-} + HasField "discreteQueuePriorities" VkPhysicalDeviceLimits where + type FieldType "discreteQueuePriorities" VkPhysicalDeviceLimits = + Word32 + type FieldOptional "discreteQueuePriorities" VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + type FieldOffset "discreteQueuePriorities" VkPhysicalDeviceLimits = + #{offset VkPhysicalDeviceLimits, discreteQueuePriorities} + type FieldIsArray "discreteQueuePriorities" VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceLimits, discreteQueuePriorities} + +instance CanReadField "discreteQueuePriorities" + VkPhysicalDeviceLimits + where + {-# INLINE getField #-} + getField = vkDiscreteQueuePriorities + + {-# INLINE readField #-} + readField = readVkDiscreteQueuePriorities + +instance {-# OVERLAPPING #-} + HasVkPointSizeRangeArray VkPhysicalDeviceLimits where + type VkPointSizeRangeArrayMType VkPhysicalDeviceLimits = + #{type float} + + {-# NOINLINE vkPointSizeRangeArray #-} + vkPointSizeRangeArray x idx + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) + (idx * sizeOf (undefined :: #{type float}) + + #{offset VkPhysicalDeviceLimits, pointSizeRange})) + + {-# INLINE vkPointSizeRangeArrayByteOffset #-} + vkPointSizeRangeArrayByteOffset ~_ + = #{offset VkPhysicalDeviceLimits, pointSizeRange} + + {-# INLINE readVkPointSizeRangeArray #-} + readVkPointSizeRangeArray p idx + = peekByteOff p + (idx * sizeOf (undefined :: #{type float}) + + #{offset VkPhysicalDeviceLimits, pointSizeRange}) + + {-# INLINE writeVkPointSizeRangeArray #-} + writeVkPointSizeRangeArray p idx + = pokeByteOff p + (idx * sizeOf (undefined :: #{type float}) + + #{offset VkPhysicalDeviceLimits, pointSizeRange}) + +instance {-# OVERLAPPING #-} + HasField "pointSizeRange" VkPhysicalDeviceLimits where + type FieldType "pointSizeRange" VkPhysicalDeviceLimits = + #{type float} + type FieldOptional "pointSizeRange" VkPhysicalDeviceLimits = 'False -- ' closing tick for hsc2hs + type FieldOffset "pointSizeRange" VkPhysicalDeviceLimits = + #{offset VkPhysicalDeviceLimits, pointSizeRange} + type FieldIsArray "pointSizeRange" VkPhysicalDeviceLimits = 'True -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceLimits, pointSizeRange} + +instance (KnownNat idx, + IndexInBounds "pointSizeRange" idx VkPhysicalDeviceLimits) => + CanReadFieldArray "pointSizeRange" idx VkPhysicalDeviceLimits + where + {-# SPECIALISE instance + CanReadFieldArray "pointSizeRange" 0 VkPhysicalDeviceLimits #-} + + {-# SPECIALISE instance + CanReadFieldArray "pointSizeRange" 1 VkPhysicalDeviceLimits #-} + type FieldArrayLength "pointSizeRange" VkPhysicalDeviceLimits = 2 + + {-# INLINE fieldArrayLength #-} + fieldArrayLength = 2 + + {-# INLINE getFieldArray #-} + getFieldArray x + = vkPointSizeRangeArray x + (fromInteger $ natVal' (proxy## :: Proxy## idx)) -- ' closing tick for hsc2hs + + {-# INLINE readFieldArray #-} + readFieldArray x + = readVkPointSizeRangeArray x + (fromInteger $ natVal' (proxy## :: Proxy## idx)) -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkLineWidthRangeArray VkPhysicalDeviceLimits where + type VkLineWidthRangeArrayMType VkPhysicalDeviceLimits = + #{type float} + + {-# NOINLINE vkLineWidthRangeArray #-} + vkLineWidthRangeArray x idx + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) + (idx * sizeOf (undefined :: #{type float}) + + #{offset VkPhysicalDeviceLimits, lineWidthRange})) + + {-# INLINE vkLineWidthRangeArrayByteOffset #-} + vkLineWidthRangeArrayByteOffset ~_ + = #{offset VkPhysicalDeviceLimits, lineWidthRange} + + {-# INLINE readVkLineWidthRangeArray #-} + readVkLineWidthRangeArray p idx + = peekByteOff p + (idx * sizeOf (undefined :: #{type float}) + + #{offset VkPhysicalDeviceLimits, lineWidthRange}) + + {-# INLINE writeVkLineWidthRangeArray #-} + writeVkLineWidthRangeArray p idx + = pokeByteOff p + (idx * sizeOf (undefined :: #{type float}) + + #{offset VkPhysicalDeviceLimits, lineWidthRange}) + +instance {-# OVERLAPPING #-} + HasField "lineWidthRange" VkPhysicalDeviceLimits where + type FieldType "lineWidthRange" VkPhysicalDeviceLimits = + #{type float} + type FieldOptional "lineWidthRange" VkPhysicalDeviceLimits = 'False -- ' closing tick for hsc2hs + type FieldOffset "lineWidthRange" VkPhysicalDeviceLimits = + #{offset VkPhysicalDeviceLimits, lineWidthRange} + type FieldIsArray "lineWidthRange" VkPhysicalDeviceLimits = 'True -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceLimits, lineWidthRange} + +instance (KnownNat idx, + IndexInBounds "lineWidthRange" idx VkPhysicalDeviceLimits) => + CanReadFieldArray "lineWidthRange" idx VkPhysicalDeviceLimits + where + {-# SPECIALISE instance + CanReadFieldArray "lineWidthRange" 0 VkPhysicalDeviceLimits #-} + + {-# SPECIALISE instance + CanReadFieldArray "lineWidthRange" 1 VkPhysicalDeviceLimits #-} + type FieldArrayLength "lineWidthRange" VkPhysicalDeviceLimits = 2 + + {-# INLINE fieldArrayLength #-} + fieldArrayLength = 2 + + {-# INLINE getFieldArray #-} + getFieldArray x + = vkLineWidthRangeArray x + (fromInteger $ natVal' (proxy## :: Proxy## idx)) -- ' closing tick for hsc2hs + + {-# INLINE readFieldArray #-} + readFieldArray x + = readVkLineWidthRangeArray x + (fromInteger $ natVal' (proxy## :: Proxy## idx)) -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkPointSizeGranularity VkPhysicalDeviceLimits where + type VkPointSizeGranularityMType VkPhysicalDeviceLimits = + #{type float} + + {-# NOINLINE vkPointSizeGranularity #-} + vkPointSizeGranularity x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceLimits, pointSizeGranularity}) + + {-# INLINE vkPointSizeGranularityByteOffset #-} + vkPointSizeGranularityByteOffset ~_ + = #{offset VkPhysicalDeviceLimits, pointSizeGranularity} + + {-# INLINE readVkPointSizeGranularity #-} + readVkPointSizeGranularity p + = peekByteOff p #{offset VkPhysicalDeviceLimits, pointSizeGranularity} + + {-# INLINE writeVkPointSizeGranularity #-} + writeVkPointSizeGranularity p + = pokeByteOff p #{offset VkPhysicalDeviceLimits, pointSizeGranularity} + +instance {-# OVERLAPPING #-} + HasField "pointSizeGranularity" VkPhysicalDeviceLimits where + type FieldType "pointSizeGranularity" VkPhysicalDeviceLimits = + #{type float} + type FieldOptional "pointSizeGranularity" VkPhysicalDeviceLimits = + 'False -- ' closing tick for hsc2hs + type FieldOffset "pointSizeGranularity" VkPhysicalDeviceLimits = + #{offset VkPhysicalDeviceLimits, pointSizeGranularity} + type FieldIsArray "pointSizeGranularity" VkPhysicalDeviceLimits = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceLimits, pointSizeGranularity} + +instance CanReadField "pointSizeGranularity" VkPhysicalDeviceLimits + where + {-# INLINE getField #-} + getField = vkPointSizeGranularity + + {-# INLINE readField #-} + readField = readVkPointSizeGranularity + +instance {-# OVERLAPPING #-} + HasVkLineWidthGranularity VkPhysicalDeviceLimits where + type VkLineWidthGranularityMType VkPhysicalDeviceLimits = + #{type float} + + {-# NOINLINE vkLineWidthGranularity #-} + vkLineWidthGranularity x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceLimits, lineWidthGranularity}) + + {-# INLINE vkLineWidthGranularityByteOffset #-} + vkLineWidthGranularityByteOffset ~_ + = #{offset VkPhysicalDeviceLimits, lineWidthGranularity} + + {-# INLINE readVkLineWidthGranularity #-} + readVkLineWidthGranularity p + = peekByteOff p #{offset VkPhysicalDeviceLimits, lineWidthGranularity} + + {-# INLINE writeVkLineWidthGranularity #-} + writeVkLineWidthGranularity p + = pokeByteOff p #{offset VkPhysicalDeviceLimits, lineWidthGranularity} + +instance {-# OVERLAPPING #-} + HasField "lineWidthGranularity" VkPhysicalDeviceLimits where + type FieldType "lineWidthGranularity" VkPhysicalDeviceLimits = + #{type float} + type FieldOptional "lineWidthGranularity" VkPhysicalDeviceLimits = + 'False -- ' closing tick for hsc2hs + type FieldOffset "lineWidthGranularity" VkPhysicalDeviceLimits = + #{offset VkPhysicalDeviceLimits, lineWidthGranularity} + type FieldIsArray "lineWidthGranularity" VkPhysicalDeviceLimits = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceLimits, lineWidthGranularity} + +instance CanReadField "lineWidthGranularity" VkPhysicalDeviceLimits + where + {-# INLINE getField #-} + getField = vkLineWidthGranularity + + {-# INLINE readField #-} + readField = readVkLineWidthGranularity + +instance {-# OVERLAPPING #-} + HasVkStrictLines VkPhysicalDeviceLimits where + type VkStrictLinesMType VkPhysicalDeviceLimits = VkBool32 + + {-# NOINLINE vkStrictLines #-} + vkStrictLines x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceLimits, strictLines}) + + {-# INLINE vkStrictLinesByteOffset #-} + vkStrictLinesByteOffset ~_ + = #{offset VkPhysicalDeviceLimits, strictLines} + + {-# INLINE readVkStrictLines #-} + readVkStrictLines p + = peekByteOff p #{offset VkPhysicalDeviceLimits, strictLines} + + {-# INLINE writeVkStrictLines #-} + writeVkStrictLines p + = pokeByteOff p #{offset VkPhysicalDeviceLimits, strictLines} + +instance {-# OVERLAPPING #-} + HasField "strictLines" VkPhysicalDeviceLimits where + type FieldType "strictLines" VkPhysicalDeviceLimits = VkBool32 + type FieldOptional "strictLines" VkPhysicalDeviceLimits = 'False -- ' closing tick for hsc2hs + type FieldOffset "strictLines" VkPhysicalDeviceLimits = + #{offset VkPhysicalDeviceLimits, strictLines} + type FieldIsArray "strictLines" VkPhysicalDeviceLimits = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceLimits, strictLines} + +instance CanReadField "strictLines" VkPhysicalDeviceLimits where + {-# INLINE getField #-} + getField = vkStrictLines + + {-# INLINE readField #-} + readField = readVkStrictLines + +instance {-# OVERLAPPING #-} + HasVkStandardSampleLocations VkPhysicalDeviceLimits where + type VkStandardSampleLocationsMType VkPhysicalDeviceLimits = + VkBool32 + + {-# NOINLINE vkStandardSampleLocations #-} + vkStandardSampleLocations x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceLimits, standardSampleLocations}) + + {-# INLINE vkStandardSampleLocationsByteOffset #-} + vkStandardSampleLocationsByteOffset ~_ + = #{offset VkPhysicalDeviceLimits, standardSampleLocations} + + {-# INLINE readVkStandardSampleLocations #-} + readVkStandardSampleLocations p + = peekByteOff p #{offset VkPhysicalDeviceLimits, standardSampleLocations} + + {-# INLINE writeVkStandardSampleLocations #-} + writeVkStandardSampleLocations p + = pokeByteOff p #{offset VkPhysicalDeviceLimits, standardSampleLocations} + +instance {-# OVERLAPPING #-} + HasField "standardSampleLocations" VkPhysicalDeviceLimits where + type FieldType "standardSampleLocations" VkPhysicalDeviceLimits = + VkBool32 + type FieldOptional "standardSampleLocations" VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + type FieldOffset "standardSampleLocations" VkPhysicalDeviceLimits = + #{offset VkPhysicalDeviceLimits, standardSampleLocations} + type FieldIsArray "standardSampleLocations" VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceLimits, standardSampleLocations} + +instance CanReadField "standardSampleLocations" + VkPhysicalDeviceLimits + where + {-# INLINE getField #-} + getField = vkStandardSampleLocations + + {-# INLINE readField #-} + readField = readVkStandardSampleLocations + +instance {-# OVERLAPPING #-} + HasVkOptimalBufferCopyOffsetAlignment VkPhysicalDeviceLimits where + type VkOptimalBufferCopyOffsetAlignmentMType VkPhysicalDeviceLimits + = VkDeviceSize + + {-# NOINLINE vkOptimalBufferCopyOffsetAlignment #-} + vkOptimalBufferCopyOffsetAlignment x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceLimits, optimalBufferCopyOffsetAlignment}) + + {-# INLINE vkOptimalBufferCopyOffsetAlignmentByteOffset #-} + vkOptimalBufferCopyOffsetAlignmentByteOffset ~_ + = #{offset VkPhysicalDeviceLimits, optimalBufferCopyOffsetAlignment} + + {-# INLINE readVkOptimalBufferCopyOffsetAlignment #-} + readVkOptimalBufferCopyOffsetAlignment p + = peekByteOff p #{offset VkPhysicalDeviceLimits, optimalBufferCopyOffsetAlignment} + + {-# INLINE writeVkOptimalBufferCopyOffsetAlignment #-} + writeVkOptimalBufferCopyOffsetAlignment p + = pokeByteOff p #{offset VkPhysicalDeviceLimits, optimalBufferCopyOffsetAlignment} + +instance {-# OVERLAPPING #-} + HasField "optimalBufferCopyOffsetAlignment" VkPhysicalDeviceLimits + where + type FieldType "optimalBufferCopyOffsetAlignment" + VkPhysicalDeviceLimits + = VkDeviceSize + type FieldOptional "optimalBufferCopyOffsetAlignment" + VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + type FieldOffset "optimalBufferCopyOffsetAlignment" + VkPhysicalDeviceLimits + = + #{offset VkPhysicalDeviceLimits, optimalBufferCopyOffsetAlignment} + type FieldIsArray "optimalBufferCopyOffsetAlignment" + VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceLimits, optimalBufferCopyOffsetAlignment} + +instance CanReadField "optimalBufferCopyOffsetAlignment" + VkPhysicalDeviceLimits + where + {-# INLINE getField #-} + getField = vkOptimalBufferCopyOffsetAlignment + + {-# INLINE readField #-} + readField = readVkOptimalBufferCopyOffsetAlignment + +instance {-# OVERLAPPING #-} + HasVkOptimalBufferCopyRowPitchAlignment VkPhysicalDeviceLimits + where + type VkOptimalBufferCopyRowPitchAlignmentMType + VkPhysicalDeviceLimits + = VkDeviceSize + + {-# NOINLINE vkOptimalBufferCopyRowPitchAlignment #-} + vkOptimalBufferCopyRowPitchAlignment x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceLimits, optimalBufferCopyRowPitchAlignment}) + + {-# INLINE vkOptimalBufferCopyRowPitchAlignmentByteOffset #-} + vkOptimalBufferCopyRowPitchAlignmentByteOffset ~_ + = #{offset VkPhysicalDeviceLimits, optimalBufferCopyRowPitchAlignment} + + {-# INLINE readVkOptimalBufferCopyRowPitchAlignment #-} + readVkOptimalBufferCopyRowPitchAlignment p + = peekByteOff p #{offset VkPhysicalDeviceLimits, optimalBufferCopyRowPitchAlignment} + + {-# INLINE writeVkOptimalBufferCopyRowPitchAlignment #-} + writeVkOptimalBufferCopyRowPitchAlignment p + = pokeByteOff p #{offset VkPhysicalDeviceLimits, optimalBufferCopyRowPitchAlignment} + +instance {-# OVERLAPPING #-} + HasField "optimalBufferCopyRowPitchAlignment" + VkPhysicalDeviceLimits + where + type FieldType "optimalBufferCopyRowPitchAlignment" + VkPhysicalDeviceLimits + = VkDeviceSize + type FieldOptional "optimalBufferCopyRowPitchAlignment" + VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + type FieldOffset "optimalBufferCopyRowPitchAlignment" + VkPhysicalDeviceLimits + = + #{offset VkPhysicalDeviceLimits, optimalBufferCopyRowPitchAlignment} + type FieldIsArray "optimalBufferCopyRowPitchAlignment" + VkPhysicalDeviceLimits + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceLimits, optimalBufferCopyRowPitchAlignment} + +instance CanReadField "optimalBufferCopyRowPitchAlignment" + VkPhysicalDeviceLimits + where + {-# INLINE getField #-} + getField = vkOptimalBufferCopyRowPitchAlignment + + {-# INLINE readField #-} + readField = readVkOptimalBufferCopyRowPitchAlignment + +instance {-# OVERLAPPING #-} + HasVkNonCoherentAtomSize VkPhysicalDeviceLimits where + type VkNonCoherentAtomSizeMType VkPhysicalDeviceLimits = + VkDeviceSize + + {-# NOINLINE vkNonCoherentAtomSize #-} + vkNonCoherentAtomSize x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceLimits, nonCoherentAtomSize}) + + {-# INLINE vkNonCoherentAtomSizeByteOffset #-} + vkNonCoherentAtomSizeByteOffset ~_ + = #{offset VkPhysicalDeviceLimits, nonCoherentAtomSize} + + {-# INLINE readVkNonCoherentAtomSize #-} + readVkNonCoherentAtomSize p + = peekByteOff p #{offset VkPhysicalDeviceLimits, nonCoherentAtomSize} + + {-# INLINE writeVkNonCoherentAtomSize #-} + writeVkNonCoherentAtomSize p + = pokeByteOff p #{offset VkPhysicalDeviceLimits, nonCoherentAtomSize} + +instance {-# OVERLAPPING #-} + HasField "nonCoherentAtomSize" VkPhysicalDeviceLimits where + type FieldType "nonCoherentAtomSize" VkPhysicalDeviceLimits = + VkDeviceSize + type FieldOptional "nonCoherentAtomSize" VkPhysicalDeviceLimits = + 'False -- ' closing tick for hsc2hs + type FieldOffset "nonCoherentAtomSize" VkPhysicalDeviceLimits = + #{offset VkPhysicalDeviceLimits, nonCoherentAtomSize} + type FieldIsArray "nonCoherentAtomSize" VkPhysicalDeviceLimits = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceLimits, nonCoherentAtomSize} + +instance CanReadField "nonCoherentAtomSize" VkPhysicalDeviceLimits + where + {-# INLINE getField #-} + getField = vkNonCoherentAtomSize + + {-# INLINE readField #-} + readField = readVkNonCoherentAtomSize + +instance Show VkPhysicalDeviceLimits where + showsPrec d x + = showString "VkPhysicalDeviceLimits {" . + showString "vkMaxImageDimension1D = " . + showsPrec d (vkMaxImageDimension1D x) . + showString ", " . + showString "vkMaxImageDimension2D = " . + showsPrec d (vkMaxImageDimension2D x) . + showString ", " . + showString "vkMaxImageDimension3D = " . + showsPrec d (vkMaxImageDimension3D x) . + showString ", " . + showString "vkMaxImageDimensionCube = " . + showsPrec d (vkMaxImageDimensionCube x) . + showString ", " . + showString "vkMaxImageArrayLayers = " . + showsPrec d (vkMaxImageArrayLayers x) . + showString ", " . + showString "vkMaxTexelBufferElements = " . + showsPrec d (vkMaxTexelBufferElements x) . + showString ", " . + showString "vkMaxUniformBufferRange = " . + showsPrec d (vkMaxUniformBufferRange x) . + showString ", " . + showString "vkMaxStorageBufferRange = " . + showsPrec d (vkMaxStorageBufferRange x) . + showString ", " . + showString "vkMaxPushConstantsSize = " + . + showsPrec d + (vkMaxPushConstantsSize x) + . + showString ", " . + showString + "vkMaxMemoryAllocationCount = " + . + showsPrec d + (vkMaxMemoryAllocationCount + x) + . + showString ", " . + showString + "vkMaxSamplerAllocationCount = " + . + showsPrec d + (vkMaxSamplerAllocationCount + x) + . + showString ", " . + showString + "vkBufferImageGranularity = " + . + showsPrec d + (vkBufferImageGranularity + x) + . + showString ", " + . + showString + "vkSparseAddressSpaceSize = " + . + showsPrec d + (vkSparseAddressSpaceSize + x) + . + showString + ", " + . + showString + "vkMaxBoundDescriptorSets = " + . + showsPrec + d + (vkMaxBoundDescriptorSets + x) + . + showString + ", " + . + showString + "vkMaxPerStageDescriptorSamplers = " + . + showsPrec + d + (vkMaxPerStageDescriptorSamplers + x) + . + showString + ", " + . + showString + "vkMaxPerStageDescriptorUniformBuffers = " + . + showsPrec + d + (vkMaxPerStageDescriptorUniformBuffers + x) + . + showString + ", " + . + showString + "vkMaxPerStageDescriptorStorageBuffers = " + . + showsPrec + d + (vkMaxPerStageDescriptorStorageBuffers + x) + . + showString + ", " + . + showString + "vkMaxPerStageDescriptorSampledImages = " + . + showsPrec + d + (vkMaxPerStageDescriptorSampledImages + x) + . + showString + ", " + . + showString + "vkMaxPerStageDescriptorStorageImages = " + . + showsPrec + d + (vkMaxPerStageDescriptorStorageImages + x) + . + showString + ", " + . + showString + "vkMaxPerStageDescriptorInputAttachments = " + . + showsPrec + d + (vkMaxPerStageDescriptorInputAttachments + x) + . + showString + ", " + . + showString + "vkMaxPerStageResources = " + . + showsPrec + d + (vkMaxPerStageResources + x) + . + showString + ", " + . + showString + "vkMaxDescriptorSetSamplers = " + . + showsPrec + d + (vkMaxDescriptorSetSamplers + x) + . + showString + ", " + . + showString + "vkMaxDescriptorSetUniformBuffers = " + . + showsPrec + d + (vkMaxDescriptorSetUniformBuffers + x) + . + showString + ", " + . + showString + "vkMaxDescriptorSetUniformBuffersDynamic = " + . + showsPrec + d + (vkMaxDescriptorSetUniformBuffersDynamic + x) + . + showString + ", " + . + showString + "vkMaxDescriptorSetStorageBuffers = " + . + showsPrec + d + (vkMaxDescriptorSetStorageBuffers + x) + . + showString + ", " + . + showString + "vkMaxDescriptorSetStorageBuffersDynamic = " + . + showsPrec + d + (vkMaxDescriptorSetStorageBuffersDynamic + x) + . + showString + ", " + . + showString + "vkMaxDescriptorSetSampledImages = " + . + showsPrec + d + (vkMaxDescriptorSetSampledImages + x) + . + showString + ", " + . + showString + "vkMaxDescriptorSetStorageImages = " + . + showsPrec + d + (vkMaxDescriptorSetStorageImages + x) + . + showString + ", " + . + showString + "vkMaxDescriptorSetInputAttachments = " + . + showsPrec + d + (vkMaxDescriptorSetInputAttachments + x) + . + showString + ", " + . + showString + "vkMaxVertexInputAttributes = " + . + showsPrec + d + (vkMaxVertexInputAttributes + x) + . + showString + ", " + . + showString + "vkMaxVertexInputBindings = " + . + showsPrec + d + (vkMaxVertexInputBindings + x) + . + showString + ", " + . + showString + "vkMaxVertexInputAttributeOffset = " + . + showsPrec + d + (vkMaxVertexInputAttributeOffset + x) + . + showString + ", " + . + showString + "vkMaxVertexInputBindingStride = " + . + showsPrec + d + (vkMaxVertexInputBindingStride + x) + . + showString + ", " + . + showString + "vkMaxVertexOutputComponents = " + . + showsPrec + d + (vkMaxVertexOutputComponents + x) + . + showString + ", " + . + showString + "vkMaxTessellationGenerationLevel = " + . + showsPrec + d + (vkMaxTessellationGenerationLevel + x) + . + showString + ", " + . + showString + "vkMaxTessellationPatchSize = " + . + showsPrec + d + (vkMaxTessellationPatchSize + x) + . + showString + ", " + . + showString + "vkMaxTessellationControlPerVertexInputComponents = " + . + showsPrec + d + (vkMaxTessellationControlPerVertexInputComponents + x) + . + showString + ", " + . + showString + "vkMaxTessellationControlPerVertexOutputComponents = " + . + showsPrec + d + (vkMaxTessellationControlPerVertexOutputComponents + x) + . + showString + ", " + . + showString + "vkMaxTessellationControlPerPatchOutputComponents = " + . + showsPrec + d + (vkMaxTessellationControlPerPatchOutputComponents + x) + . + showString + ", " + . + showString + "vkMaxTessellationControlTotalOutputComponents = " + . + showsPrec + d + (vkMaxTessellationControlTotalOutputComponents + x) + . + showString + ", " + . + showString + "vkMaxTessellationEvaluationInputComponents = " + . + showsPrec + d + (vkMaxTessellationEvaluationInputComponents + x) + . + showString + ", " + . + showString + "vkMaxTessellationEvaluationOutputComponents = " + . + showsPrec + d + (vkMaxTessellationEvaluationOutputComponents + x) + . + showString + ", " + . + showString + "vkMaxGeometryShaderInvocations = " + . + showsPrec + d + (vkMaxGeometryShaderInvocations + x) + . + showString + ", " + . + showString + "vkMaxGeometryInputComponents = " + . + showsPrec + d + (vkMaxGeometryInputComponents + x) + . + showString + ", " + . + showString + "vkMaxGeometryOutputComponents = " + . + showsPrec + d + (vkMaxGeometryOutputComponents + x) + . + showString + ", " + . + showString + "vkMaxGeometryOutputVertices = " + . + showsPrec + d + (vkMaxGeometryOutputVertices + x) + . + showString + ", " + . + showString + "vkMaxGeometryTotalOutputComponents = " + . + showsPrec + d + (vkMaxGeometryTotalOutputComponents + x) + . + showString + ", " + . + showString + "vkMaxFragmentInputComponents = " + . + showsPrec + d + (vkMaxFragmentInputComponents + x) + . + showString + ", " + . + showString + "vkMaxFragmentOutputAttachments = " + . + showsPrec + d + (vkMaxFragmentOutputAttachments + x) + . + showString + ", " + . + showString + "vkMaxFragmentDualSrcAttachments = " + . + showsPrec + d + (vkMaxFragmentDualSrcAttachments + x) + . + showString + ", " + . + showString + "vkMaxFragmentCombinedOutputResources = " + . + showsPrec + d + (vkMaxFragmentCombinedOutputResources + x) + . + showString + ", " + . + showString + "vkMaxComputeSharedMemorySize = " + . + showsPrec + d + (vkMaxComputeSharedMemorySize + x) + . + showString + ", " + . + showString + "vkMaxComputeWorkGroupCountArray = [" + . + showsPrec + d + (map + (vkMaxComputeWorkGroupCountArray + x) + [1 + .. + 3]) + . + showChar + ']' + . + showString + ", " + . + showString + "vkMaxComputeWorkGroupInvocations = " + . + showsPrec + d + (vkMaxComputeWorkGroupInvocations + x) + . + showString + ", " + . + showString + "vkMaxComputeWorkGroupSizeArray = [" + . + showsPrec + d + (map + (vkMaxComputeWorkGroupSizeArray + x) + [1 + .. + 3]) + . + showChar + ']' + . + showString + ", " + . + showString + "vkSubPixelPrecisionBits = " + . + showsPrec + d + (vkSubPixelPrecisionBits + x) + . + showString + ", " + . + showString + "vkSubTexelPrecisionBits = " + . + showsPrec + d + (vkSubTexelPrecisionBits + x) + . + showString + ", " + . + showString + "vkMipmapPrecisionBits = " + . + showsPrec + d + (vkMipmapPrecisionBits + x) + . + showString + ", " + . + showString + "vkMaxDrawIndexedIndexValue = " + . + showsPrec + d + (vkMaxDrawIndexedIndexValue + x) + . + showString + ", " + . + showString + "vkMaxDrawIndirectCount = " + . + showsPrec + d + (vkMaxDrawIndirectCount + x) + . + showString + ", " + . + showString + "vkMaxSamplerLodBias = " + . + showsPrec + d + (vkMaxSamplerLodBias + x) + . + showString + ", " + . + showString + "vkMaxSamplerAnisotropy = " + . + showsPrec + d + (vkMaxSamplerAnisotropy + x) + . + showString + ", " + . + showString + "vkMaxViewports = " + . + showsPrec + d + (vkMaxViewports + x) + . + showString + ", " + . + showString + "vkMaxViewportDimensionsArray = [" + . + showsPrec + d + (map + (vkMaxViewportDimensionsArray + x) + [1 + .. + 2]) + . + showChar + ']' + . + showString + ", " + . + showString + "vkViewportBoundsRangeArray = [" + . + showsPrec + d + (map + (vkViewportBoundsRangeArray + x) + [1 + .. + 2]) + . + showChar + ']' + . + showString + ", " + . + showString + "vkViewportSubPixelBits = " + . + showsPrec + d + (vkViewportSubPixelBits + x) + . + showString + ", " + . + showString + "vkMinMemoryMapAlignment = " + . + showsPrec + d + (vkMinMemoryMapAlignment + x) + . + showString + ", " + . + showString + "vkMinTexelBufferOffsetAlignment = " + . + showsPrec + d + (vkMinTexelBufferOffsetAlignment + x) + . + showString + ", " + . + showString + "vkMinUniformBufferOffsetAlignment = " + . + showsPrec + d + (vkMinUniformBufferOffsetAlignment + x) + . + showString + ", " + . + showString + "vkMinStorageBufferOffsetAlignment = " + . + showsPrec + d + (vkMinStorageBufferOffsetAlignment + x) + . + showString + ", " + . + showString + "vkMinTexelOffset = " + . + showsPrec + d + (vkMinTexelOffset + x) + . + showString + ", " + . + showString + "vkMaxTexelOffset = " + . + showsPrec + d + (vkMaxTexelOffset + x) + . + showString + ", " + . + showString + "vkMinTexelGatherOffset = " + . + showsPrec + d + (vkMinTexelGatherOffset + x) + . + showString + ", " + . + showString + "vkMaxTexelGatherOffset = " + . + showsPrec + d + (vkMaxTexelGatherOffset + x) + . + showString + ", " + . + showString + "vkMinInterpolationOffset = " + . + showsPrec + d + (vkMinInterpolationOffset + x) + . + showString + ", " + . + showString + "vkMaxInterpolationOffset = " + . + showsPrec + d + (vkMaxInterpolationOffset + x) + . + showString + ", " + . + showString + "vkSubPixelInterpolationOffsetBits = " + . + showsPrec + d + (vkSubPixelInterpolationOffsetBits + x) + . + showString + ", " + . + showString + "vkMaxFramebufferWidth = " + . + showsPrec + d + (vkMaxFramebufferWidth + x) + . + showString + ", " + . + showString + "vkMaxFramebufferHeight = " + . + showsPrec + d + (vkMaxFramebufferHeight + x) + . + showString + ", " + . + showString + "vkMaxFramebufferLayers = " + . + showsPrec + d + (vkMaxFramebufferLayers + x) + . + showString + ", " + . + showString + "vkFramebufferColorSampleCounts = " + . + showsPrec + d + (vkFramebufferColorSampleCounts + x) + . + showString + ", " + . + showString + "vkFramebufferDepthSampleCounts = " + . + showsPrec + d + (vkFramebufferDepthSampleCounts + x) + . + showString + ", " + . + showString + "vkFramebufferStencilSampleCounts = " + . + showsPrec + d + (vkFramebufferStencilSampleCounts + x) + . + showString + ", " + . + showString + "vkFramebufferNoAttachmentsSampleCounts = " + . + showsPrec + d + (vkFramebufferNoAttachmentsSampleCounts + x) + . + showString + ", " + . + showString + "vkMaxColorAttachments = " + . + showsPrec + d + (vkMaxColorAttachments + x) + . + showString + ", " + . + showString + "vkSampledImageColorSampleCounts = " + . + showsPrec + d + (vkSampledImageColorSampleCounts + x) + . + showString + ", " + . + showString + "vkSampledImageIntegerSampleCounts = " + . + showsPrec + d + (vkSampledImageIntegerSampleCounts + x) + . + showString + ", " + . + showString + "vkSampledImageDepthSampleCounts = " + . + showsPrec + d + (vkSampledImageDepthSampleCounts + x) + . + showString + ", " + . + showString + "vkSampledImageStencilSampleCounts = " + . + showsPrec + d + (vkSampledImageStencilSampleCounts + x) + . + showString + ", " + . + showString + "vkStorageImageSampleCounts = " + . + showsPrec + d + (vkStorageImageSampleCounts + x) + . + showString + ", " + . + showString + "vkMaxSampleMaskWords = " + . + showsPrec + d + (vkMaxSampleMaskWords + x) + . + showString + ", " + . + showString + "vkTimestampComputeAndGraphics = " + . + showsPrec + d + (vkTimestampComputeAndGraphics + x) + . + showString + ", " + . + showString + "vkTimestampPeriod = " + . + showsPrec + d + (vkTimestampPeriod + x) + . + showString + ", " + . + showString + "vkMaxClipDistances = " + . + showsPrec + d + (vkMaxClipDistances + x) + . + showString + ", " + . + showString + "vkMaxCullDistances = " + . + showsPrec + d + (vkMaxCullDistances + x) + . + showString + ", " + . + showString + "vkMaxCombinedClipAndCullDistances = " + . + showsPrec + d + (vkMaxCombinedClipAndCullDistances + x) + . + showString + ", " + . + showString + "vkDiscreteQueuePriorities = " + . + showsPrec + d + (vkDiscreteQueuePriorities + x) + . + showString + ", " + . + showString + "vkPointSizeRangeArray = [" + . + showsPrec + d + (map + (vkPointSizeRangeArray + x) + [1 + .. + 2]) + . + showChar + ']' + . + showString + ", " + . + showString + "vkLineWidthRangeArray = [" + . + showsPrec + d + (map + (vkLineWidthRangeArray + x) + [1 + .. + 2]) + . + showChar + ']' + . + showString + ", " + . + showString + "vkPointSizeGranularity = " + . + showsPrec + d + (vkPointSizeGranularity + x) + . + showString + ", " + . + showString + "vkLineWidthGranularity = " + . + showsPrec + d + (vkLineWidthGranularity + x) + . + showString + ", " + . + showString + "vkStrictLines = " + . + showsPrec + d + (vkStrictLines + x) + . + showString + ", " + . + showString + "vkStandardSampleLocations = " + . + showsPrec + d + (vkStandardSampleLocations + x) + . + showString + ", " + . + showString + "vkOptimalBufferCopyOffsetAlignment = " + . + showsPrec + d + (vkOptimalBufferCopyOffsetAlignment + x) + . + showString + ", " + . + showString + "vkOptimalBufferCopyRowPitchAlignment = " + . + showsPrec + d + (vkOptimalBufferCopyRowPitchAlignment + x) + . + showString + ", " + . + showString + "vkNonCoherentAtomSize = " + . + showsPrec + d + (vkNonCoherentAtomSize + x) + . + showChar + '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkPhysicalDeviceMemoryProperties.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkPhysicalDeviceMemoryProperties.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkPhysicalDeviceMemoryProperties.hsc @@ -0,0 +1,379 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleContexts #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE ScopedTypeVariables #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +{-# LANGUAGE UndecidableInstances #-} +module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceMemoryProperties + (VkPhysicalDeviceMemoryProperties(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import GHC.TypeLits (KnownNat, natVal') -- ' closing tick for hsc2hs +import Graphics.Vulkan.Constants (VK_MAX_MEMORY_HEAPS, pattern VK_MAX_MEMORY_HEAPS, + VK_MAX_MEMORY_TYPES, + pattern VK_MAX_MEMORY_TYPES) +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Struct.VkMemoryHeap (VkMemoryHeap) +import Graphics.Vulkan.Types.Struct.VkMemoryType (VkMemoryType) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkPhysicalDeviceMemoryProperties { +-- > uint32_t memoryTypeCount; +-- > VkMemoryType memoryTypes[VK_MAX_MEMORY_TYPES]; +-- > uint32_t memoryHeapCount; +-- > VkMemoryHeap memoryHeaps[VK_MAX_MEMORY_HEAPS]; +-- > } VkPhysicalDeviceMemoryProperties; +-- +-- +data VkPhysicalDeviceMemoryProperties = VkPhysicalDeviceMemoryProperties## Addr## + ByteArray## + +instance Eq VkPhysicalDeviceMemoryProperties where + (VkPhysicalDeviceMemoryProperties## a _) == + x@(VkPhysicalDeviceMemoryProperties## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkPhysicalDeviceMemoryProperties where + (VkPhysicalDeviceMemoryProperties## a _) `compare` + x@(VkPhysicalDeviceMemoryProperties## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkPhysicalDeviceMemoryProperties where + sizeOf ~_ = #{size VkPhysicalDeviceMemoryProperties} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkPhysicalDeviceMemoryProperties} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkPhysicalDeviceMemoryProperties where + unsafeAddr (VkPhysicalDeviceMemoryProperties## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkPhysicalDeviceMemoryProperties## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkPhysicalDeviceMemoryProperties## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkPhysicalDeviceMemoryProperties where + type StructFields VkPhysicalDeviceMemoryProperties = + '["memoryTypeCount", "memoryTypes", "memoryHeapCount", -- ' closing tick for hsc2hs + "memoryHeaps"] + type CUnionType VkPhysicalDeviceMemoryProperties = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkPhysicalDeviceMemoryProperties = 'True -- ' closing tick for hsc2hs + type StructExtends VkPhysicalDeviceMemoryProperties = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkMemoryTypeCount VkPhysicalDeviceMemoryProperties where + type VkMemoryTypeCountMType VkPhysicalDeviceMemoryProperties = + Word32 + + {-# NOINLINE vkMemoryTypeCount #-} + vkMemoryTypeCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceMemoryProperties, memoryTypeCount}) + + {-# INLINE vkMemoryTypeCountByteOffset #-} + vkMemoryTypeCountByteOffset ~_ + = #{offset VkPhysicalDeviceMemoryProperties, memoryTypeCount} + + {-# INLINE readVkMemoryTypeCount #-} + readVkMemoryTypeCount p + = peekByteOff p #{offset VkPhysicalDeviceMemoryProperties, memoryTypeCount} + + {-# INLINE writeVkMemoryTypeCount #-} + writeVkMemoryTypeCount p + = pokeByteOff p #{offset VkPhysicalDeviceMemoryProperties, memoryTypeCount} + +instance {-# OVERLAPPING #-} + HasField "memoryTypeCount" VkPhysicalDeviceMemoryProperties where + type FieldType "memoryTypeCount" VkPhysicalDeviceMemoryProperties = + Word32 + type FieldOptional "memoryTypeCount" + VkPhysicalDeviceMemoryProperties + = 'False -- ' closing tick for hsc2hs + type FieldOffset "memoryTypeCount" VkPhysicalDeviceMemoryProperties + = + #{offset VkPhysicalDeviceMemoryProperties, memoryTypeCount} + type FieldIsArray "memoryTypeCount" + VkPhysicalDeviceMemoryProperties + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceMemoryProperties, memoryTypeCount} + +instance CanReadField "memoryTypeCount" + VkPhysicalDeviceMemoryProperties + where + {-# INLINE getField #-} + getField = vkMemoryTypeCount + + {-# INLINE readField #-} + readField = readVkMemoryTypeCount + +instance {-# OVERLAPPING #-} + HasVkMemoryTypesArray VkPhysicalDeviceMemoryProperties where + type VkMemoryTypesArrayMType VkPhysicalDeviceMemoryProperties = + VkMemoryType + + {-# NOINLINE vkMemoryTypesArray #-} + vkMemoryTypesArray x idx + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) + (idx * sizeOf (undefined :: VkMemoryType) + + #{offset VkPhysicalDeviceMemoryProperties, memoryTypes})) + + {-# INLINE vkMemoryTypesArrayByteOffset #-} + vkMemoryTypesArrayByteOffset ~_ + = #{offset VkPhysicalDeviceMemoryProperties, memoryTypes} + + {-# INLINE readVkMemoryTypesArray #-} + readVkMemoryTypesArray p idx + = peekByteOff p + (idx * sizeOf (undefined :: VkMemoryType) + + #{offset VkPhysicalDeviceMemoryProperties, memoryTypes}) + + {-# INLINE writeVkMemoryTypesArray #-} + writeVkMemoryTypesArray p idx + = pokeByteOff p + (idx * sizeOf (undefined :: VkMemoryType) + + #{offset VkPhysicalDeviceMemoryProperties, memoryTypes}) + +instance {-# OVERLAPPING #-} + HasField "memoryTypes" VkPhysicalDeviceMemoryProperties where + type FieldType "memoryTypes" VkPhysicalDeviceMemoryProperties = + VkMemoryType + type FieldOptional "memoryTypes" VkPhysicalDeviceMemoryProperties = + 'False -- ' closing tick for hsc2hs + type FieldOffset "memoryTypes" VkPhysicalDeviceMemoryProperties = + #{offset VkPhysicalDeviceMemoryProperties, memoryTypes} + type FieldIsArray "memoryTypes" VkPhysicalDeviceMemoryProperties = + 'True -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceMemoryProperties, memoryTypes} + +instance (KnownNat idx, + IndexInBounds "memoryTypes" idx + VkPhysicalDeviceMemoryProperties) => + CanReadFieldArray "memoryTypes" idx + VkPhysicalDeviceMemoryProperties + where + {-# SPECIALISE instance + CanReadFieldArray "memoryTypes" 0 VkPhysicalDeviceMemoryProperties + #-} + + {-# SPECIALISE instance + CanReadFieldArray "memoryTypes" 1 VkPhysicalDeviceMemoryProperties + #-} + + {-# SPECIALISE instance + CanReadFieldArray "memoryTypes" 2 VkPhysicalDeviceMemoryProperties + #-} + + {-# SPECIALISE instance + CanReadFieldArray "memoryTypes" 3 VkPhysicalDeviceMemoryProperties + #-} + type FieldArrayLength "memoryTypes" + VkPhysicalDeviceMemoryProperties + = VK_MAX_MEMORY_TYPES + + {-# INLINE fieldArrayLength #-} + fieldArrayLength = VK_MAX_MEMORY_TYPES + + {-# INLINE getFieldArray #-} + getFieldArray x + = vkMemoryTypesArray x + (fromInteger $ natVal' (proxy## :: Proxy## idx)) -- ' closing tick for hsc2hs + + {-# INLINE readFieldArray #-} + readFieldArray x + = readVkMemoryTypesArray x + (fromInteger $ natVal' (proxy## :: Proxy## idx)) -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkMemoryHeapCount VkPhysicalDeviceMemoryProperties where + type VkMemoryHeapCountMType VkPhysicalDeviceMemoryProperties = + Word32 + + {-# NOINLINE vkMemoryHeapCount #-} + vkMemoryHeapCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceMemoryProperties, memoryHeapCount}) + + {-# INLINE vkMemoryHeapCountByteOffset #-} + vkMemoryHeapCountByteOffset ~_ + = #{offset VkPhysicalDeviceMemoryProperties, memoryHeapCount} + + {-# INLINE readVkMemoryHeapCount #-} + readVkMemoryHeapCount p + = peekByteOff p #{offset VkPhysicalDeviceMemoryProperties, memoryHeapCount} + + {-# INLINE writeVkMemoryHeapCount #-} + writeVkMemoryHeapCount p + = pokeByteOff p #{offset VkPhysicalDeviceMemoryProperties, memoryHeapCount} + +instance {-# OVERLAPPING #-} + HasField "memoryHeapCount" VkPhysicalDeviceMemoryProperties where + type FieldType "memoryHeapCount" VkPhysicalDeviceMemoryProperties = + Word32 + type FieldOptional "memoryHeapCount" + VkPhysicalDeviceMemoryProperties + = 'False -- ' closing tick for hsc2hs + type FieldOffset "memoryHeapCount" VkPhysicalDeviceMemoryProperties + = + #{offset VkPhysicalDeviceMemoryProperties, memoryHeapCount} + type FieldIsArray "memoryHeapCount" + VkPhysicalDeviceMemoryProperties + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceMemoryProperties, memoryHeapCount} + +instance CanReadField "memoryHeapCount" + VkPhysicalDeviceMemoryProperties + where + {-# INLINE getField #-} + getField = vkMemoryHeapCount + + {-# INLINE readField #-} + readField = readVkMemoryHeapCount + +instance {-# OVERLAPPING #-} + HasVkMemoryHeapsArray VkPhysicalDeviceMemoryProperties where + type VkMemoryHeapsArrayMType VkPhysicalDeviceMemoryProperties = + VkMemoryHeap + + {-# NOINLINE vkMemoryHeapsArray #-} + vkMemoryHeapsArray x idx + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) + (idx * sizeOf (undefined :: VkMemoryHeap) + + #{offset VkPhysicalDeviceMemoryProperties, memoryHeaps})) + + {-# INLINE vkMemoryHeapsArrayByteOffset #-} + vkMemoryHeapsArrayByteOffset ~_ + = #{offset VkPhysicalDeviceMemoryProperties, memoryHeaps} + + {-# INLINE readVkMemoryHeapsArray #-} + readVkMemoryHeapsArray p idx + = peekByteOff p + (idx * sizeOf (undefined :: VkMemoryHeap) + + #{offset VkPhysicalDeviceMemoryProperties, memoryHeaps}) + + {-# INLINE writeVkMemoryHeapsArray #-} + writeVkMemoryHeapsArray p idx + = pokeByteOff p + (idx * sizeOf (undefined :: VkMemoryHeap) + + #{offset VkPhysicalDeviceMemoryProperties, memoryHeaps}) + +instance {-# OVERLAPPING #-} + HasField "memoryHeaps" VkPhysicalDeviceMemoryProperties where + type FieldType "memoryHeaps" VkPhysicalDeviceMemoryProperties = + VkMemoryHeap + type FieldOptional "memoryHeaps" VkPhysicalDeviceMemoryProperties = + 'False -- ' closing tick for hsc2hs + type FieldOffset "memoryHeaps" VkPhysicalDeviceMemoryProperties = + #{offset VkPhysicalDeviceMemoryProperties, memoryHeaps} + type FieldIsArray "memoryHeaps" VkPhysicalDeviceMemoryProperties = + 'True -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceMemoryProperties, memoryHeaps} + +instance (KnownNat idx, + IndexInBounds "memoryHeaps" idx + VkPhysicalDeviceMemoryProperties) => + CanReadFieldArray "memoryHeaps" idx + VkPhysicalDeviceMemoryProperties + where + {-# SPECIALISE instance + CanReadFieldArray "memoryHeaps" 0 VkPhysicalDeviceMemoryProperties + #-} + + {-# SPECIALISE instance + CanReadFieldArray "memoryHeaps" 1 VkPhysicalDeviceMemoryProperties + #-} + + {-# SPECIALISE instance + CanReadFieldArray "memoryHeaps" 2 VkPhysicalDeviceMemoryProperties + #-} + + {-# SPECIALISE instance + CanReadFieldArray "memoryHeaps" 3 VkPhysicalDeviceMemoryProperties + #-} + type FieldArrayLength "memoryHeaps" + VkPhysicalDeviceMemoryProperties + = VK_MAX_MEMORY_HEAPS + + {-# INLINE fieldArrayLength #-} + fieldArrayLength = VK_MAX_MEMORY_HEAPS + + {-# INLINE getFieldArray #-} + getFieldArray x + = vkMemoryHeapsArray x + (fromInteger $ natVal' (proxy## :: Proxy## idx)) -- ' closing tick for hsc2hs + + {-# INLINE readFieldArray #-} + readFieldArray x + = readVkMemoryHeapsArray x + (fromInteger $ natVal' (proxy## :: Proxy## idx)) -- ' closing tick for hsc2hs + +instance Show VkPhysicalDeviceMemoryProperties where + showsPrec d x + = showString "VkPhysicalDeviceMemoryProperties {" . + showString "vkMemoryTypeCount = " . + showsPrec d (vkMemoryTypeCount x) . + showString ", " . + showString "vkMemoryTypesArray = [" . + showsPrec d (map (vkMemoryTypesArray x) [1 .. VK_MAX_MEMORY_TYPES]) + . + showChar ']' . + showString ", " . + showString "vkMemoryHeapCount = " . + showsPrec d (vkMemoryHeapCount x) . + showString ", " . + showString "vkMemoryHeapsArray = [" . + showsPrec d + (map (vkMemoryHeapsArray x) [1 .. VK_MAX_MEMORY_HEAPS]) + . showChar ']' . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkPhysicalDeviceMemoryProperties2KHR.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkPhysicalDeviceMemoryProperties2KHR.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkPhysicalDeviceMemoryProperties2KHR.hsc @@ -0,0 +1,242 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceMemoryProperties2KHR + (VkPhysicalDeviceMemoryProperties2KHR(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceMemoryProperties (VkPhysicalDeviceMemoryProperties) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkPhysicalDeviceMemoryProperties2KHR { +-- > VkStructureType sType; +-- > void* pNext; +-- > VkPhysicalDeviceMemoryProperties memoryProperties; +-- > } VkPhysicalDeviceMemoryProperties2KHR; +-- +-- +data VkPhysicalDeviceMemoryProperties2KHR = VkPhysicalDeviceMemoryProperties2KHR## Addr## + ByteArray## + +instance Eq VkPhysicalDeviceMemoryProperties2KHR where + (VkPhysicalDeviceMemoryProperties2KHR## a _) == + x@(VkPhysicalDeviceMemoryProperties2KHR## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkPhysicalDeviceMemoryProperties2KHR where + (VkPhysicalDeviceMemoryProperties2KHR## a _) `compare` + x@(VkPhysicalDeviceMemoryProperties2KHR## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkPhysicalDeviceMemoryProperties2KHR where + sizeOf ~_ + = #{size VkPhysicalDeviceMemoryProperties2KHR} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkPhysicalDeviceMemoryProperties2KHR} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkPhysicalDeviceMemoryProperties2KHR + where + unsafeAddr (VkPhysicalDeviceMemoryProperties2KHR## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkPhysicalDeviceMemoryProperties2KHR## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkPhysicalDeviceMemoryProperties2KHR## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkPhysicalDeviceMemoryProperties2KHR where + type StructFields VkPhysicalDeviceMemoryProperties2KHR = + '["sType", "pNext", "memoryProperties"] -- ' closing tick for hsc2hs + type CUnionType VkPhysicalDeviceMemoryProperties2KHR = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkPhysicalDeviceMemoryProperties2KHR = 'True -- ' closing tick for hsc2hs + type StructExtends VkPhysicalDeviceMemoryProperties2KHR = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkPhysicalDeviceMemoryProperties2KHR where + type VkSTypeMType VkPhysicalDeviceMemoryProperties2KHR = + VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceMemoryProperties2KHR, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkPhysicalDeviceMemoryProperties2KHR, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkPhysicalDeviceMemoryProperties2KHR, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkPhysicalDeviceMemoryProperties2KHR, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkPhysicalDeviceMemoryProperties2KHR where + type FieldType "sType" VkPhysicalDeviceMemoryProperties2KHR = + VkStructureType + type FieldOptional "sType" VkPhysicalDeviceMemoryProperties2KHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkPhysicalDeviceMemoryProperties2KHR = + #{offset VkPhysicalDeviceMemoryProperties2KHR, sType} + type FieldIsArray "sType" VkPhysicalDeviceMemoryProperties2KHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceMemoryProperties2KHR, sType} + +instance CanReadField "sType" VkPhysicalDeviceMemoryProperties2KHR + where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkPhysicalDeviceMemoryProperties2KHR where + type VkPNextMType VkPhysicalDeviceMemoryProperties2KHR = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceMemoryProperties2KHR, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkPhysicalDeviceMemoryProperties2KHR, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkPhysicalDeviceMemoryProperties2KHR, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkPhysicalDeviceMemoryProperties2KHR, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkPhysicalDeviceMemoryProperties2KHR where + type FieldType "pNext" VkPhysicalDeviceMemoryProperties2KHR = + Ptr Void + type FieldOptional "pNext" VkPhysicalDeviceMemoryProperties2KHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkPhysicalDeviceMemoryProperties2KHR = + #{offset VkPhysicalDeviceMemoryProperties2KHR, pNext} + type FieldIsArray "pNext" VkPhysicalDeviceMemoryProperties2KHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceMemoryProperties2KHR, pNext} + +instance CanReadField "pNext" VkPhysicalDeviceMemoryProperties2KHR + where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance {-# OVERLAPPING #-} + HasVkMemoryProperties VkPhysicalDeviceMemoryProperties2KHR where + type VkMemoryPropertiesMType VkPhysicalDeviceMemoryProperties2KHR = + VkPhysicalDeviceMemoryProperties + + {-# NOINLINE vkMemoryProperties #-} + vkMemoryProperties x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceMemoryProperties2KHR, memoryProperties}) + + {-# INLINE vkMemoryPropertiesByteOffset #-} + vkMemoryPropertiesByteOffset ~_ + = #{offset VkPhysicalDeviceMemoryProperties2KHR, memoryProperties} + + {-# INLINE readVkMemoryProperties #-} + readVkMemoryProperties p + = peekByteOff p #{offset VkPhysicalDeviceMemoryProperties2KHR, memoryProperties} + + {-# INLINE writeVkMemoryProperties #-} + writeVkMemoryProperties p + = pokeByteOff p #{offset VkPhysicalDeviceMemoryProperties2KHR, memoryProperties} + +instance {-# OVERLAPPING #-} + HasField "memoryProperties" VkPhysicalDeviceMemoryProperties2KHR + where + type FieldType "memoryProperties" + VkPhysicalDeviceMemoryProperties2KHR + = VkPhysicalDeviceMemoryProperties + type FieldOptional "memoryProperties" + VkPhysicalDeviceMemoryProperties2KHR + = 'False -- ' closing tick for hsc2hs + type FieldOffset "memoryProperties" + VkPhysicalDeviceMemoryProperties2KHR + = + #{offset VkPhysicalDeviceMemoryProperties2KHR, memoryProperties} + type FieldIsArray "memoryProperties" + VkPhysicalDeviceMemoryProperties2KHR + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceMemoryProperties2KHR, memoryProperties} + +instance CanReadField "memoryProperties" + VkPhysicalDeviceMemoryProperties2KHR + where + {-# INLINE getField #-} + getField = vkMemoryProperties + + {-# INLINE readField #-} + readField = readVkMemoryProperties + +instance Show VkPhysicalDeviceMemoryProperties2KHR where + showsPrec d x + = showString "VkPhysicalDeviceMemoryProperties2KHR {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkMemoryProperties = " . + showsPrec d (vkMemoryProperties x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkPhysicalDeviceMultiviewFeaturesKHX.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkPhysicalDeviceMultiviewFeaturesKHX.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkPhysicalDeviceMultiviewFeaturesKHX.hsc @@ -0,0 +1,393 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceMultiviewFeaturesKHX + (VkPhysicalDeviceMultiviewFeaturesKHX(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.BaseTypes (VkBool32) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Struct.VkDeviceCreateInfo (VkDeviceCreateInfo) +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceFeatures2KHR (VkPhysicalDeviceFeatures2KHR) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkPhysicalDeviceMultiviewFeaturesKHX { +-- > VkStructureType sType; +-- > void* pNext; +-- > VkBool32 multiview; +-- > VkBool32 multiviewGeometryShader; +-- > VkBool32 multiviewTessellationShader; +-- > } VkPhysicalDeviceMultiviewFeaturesKHX; +-- +-- +data VkPhysicalDeviceMultiviewFeaturesKHX = VkPhysicalDeviceMultiviewFeaturesKHX## Addr## + ByteArray## + +instance Eq VkPhysicalDeviceMultiviewFeaturesKHX where + (VkPhysicalDeviceMultiviewFeaturesKHX## a _) == + x@(VkPhysicalDeviceMultiviewFeaturesKHX## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkPhysicalDeviceMultiviewFeaturesKHX where + (VkPhysicalDeviceMultiviewFeaturesKHX## a _) `compare` + x@(VkPhysicalDeviceMultiviewFeaturesKHX## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkPhysicalDeviceMultiviewFeaturesKHX where + sizeOf ~_ + = #{size VkPhysicalDeviceMultiviewFeaturesKHX} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkPhysicalDeviceMultiviewFeaturesKHX} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkPhysicalDeviceMultiviewFeaturesKHX + where + unsafeAddr (VkPhysicalDeviceMultiviewFeaturesKHX## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkPhysicalDeviceMultiviewFeaturesKHX## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkPhysicalDeviceMultiviewFeaturesKHX## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkPhysicalDeviceMultiviewFeaturesKHX where + type StructFields VkPhysicalDeviceMultiviewFeaturesKHX = + '["sType", "pNext", "multiview", "multiviewGeometryShader", -- ' closing tick for hsc2hs + "multiviewTessellationShader"] + type CUnionType VkPhysicalDeviceMultiviewFeaturesKHX = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkPhysicalDeviceMultiviewFeaturesKHX = 'False -- ' closing tick for hsc2hs + type StructExtends VkPhysicalDeviceMultiviewFeaturesKHX = + '[VkPhysicalDeviceFeatures2KHR, VkDeviceCreateInfo] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkPhysicalDeviceMultiviewFeaturesKHX where + type VkSTypeMType VkPhysicalDeviceMultiviewFeaturesKHX = + VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceMultiviewFeaturesKHX, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkPhysicalDeviceMultiviewFeaturesKHX, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkPhysicalDeviceMultiviewFeaturesKHX, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkPhysicalDeviceMultiviewFeaturesKHX, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkPhysicalDeviceMultiviewFeaturesKHX where + type FieldType "sType" VkPhysicalDeviceMultiviewFeaturesKHX = + VkStructureType + type FieldOptional "sType" VkPhysicalDeviceMultiviewFeaturesKHX = + 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkPhysicalDeviceMultiviewFeaturesKHX = + #{offset VkPhysicalDeviceMultiviewFeaturesKHX, sType} + type FieldIsArray "sType" VkPhysicalDeviceMultiviewFeaturesKHX = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceMultiviewFeaturesKHX, sType} + +instance CanReadField "sType" VkPhysicalDeviceMultiviewFeaturesKHX + where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkPhysicalDeviceMultiviewFeaturesKHX + where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkPhysicalDeviceMultiviewFeaturesKHX where + type VkPNextMType VkPhysicalDeviceMultiviewFeaturesKHX = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceMultiviewFeaturesKHX, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkPhysicalDeviceMultiviewFeaturesKHX, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkPhysicalDeviceMultiviewFeaturesKHX, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkPhysicalDeviceMultiviewFeaturesKHX, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkPhysicalDeviceMultiviewFeaturesKHX where + type FieldType "pNext" VkPhysicalDeviceMultiviewFeaturesKHX = + Ptr Void + type FieldOptional "pNext" VkPhysicalDeviceMultiviewFeaturesKHX = + 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkPhysicalDeviceMultiviewFeaturesKHX = + #{offset VkPhysicalDeviceMultiviewFeaturesKHX, pNext} + type FieldIsArray "pNext" VkPhysicalDeviceMultiviewFeaturesKHX = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceMultiviewFeaturesKHX, pNext} + +instance CanReadField "pNext" VkPhysicalDeviceMultiviewFeaturesKHX + where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkPhysicalDeviceMultiviewFeaturesKHX + where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkMultiview VkPhysicalDeviceMultiviewFeaturesKHX where + type VkMultiviewMType VkPhysicalDeviceMultiviewFeaturesKHX = + VkBool32 + + {-# NOINLINE vkMultiview #-} + vkMultiview x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceMultiviewFeaturesKHX, multiview}) + + {-# INLINE vkMultiviewByteOffset #-} + vkMultiviewByteOffset ~_ + = #{offset VkPhysicalDeviceMultiviewFeaturesKHX, multiview} + + {-# INLINE readVkMultiview #-} + readVkMultiview p + = peekByteOff p #{offset VkPhysicalDeviceMultiviewFeaturesKHX, multiview} + + {-# INLINE writeVkMultiview #-} + writeVkMultiview p + = pokeByteOff p #{offset VkPhysicalDeviceMultiviewFeaturesKHX, multiview} + +instance {-# OVERLAPPING #-} + HasField "multiview" VkPhysicalDeviceMultiviewFeaturesKHX where + type FieldType "multiview" VkPhysicalDeviceMultiviewFeaturesKHX = + VkBool32 + type FieldOptional "multiview" VkPhysicalDeviceMultiviewFeaturesKHX + = 'False -- ' closing tick for hsc2hs + type FieldOffset "multiview" VkPhysicalDeviceMultiviewFeaturesKHX = + #{offset VkPhysicalDeviceMultiviewFeaturesKHX, multiview} + type FieldIsArray "multiview" VkPhysicalDeviceMultiviewFeaturesKHX + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceMultiviewFeaturesKHX, multiview} + +instance CanReadField "multiview" + VkPhysicalDeviceMultiviewFeaturesKHX + where + {-# INLINE getField #-} + getField = vkMultiview + + {-# INLINE readField #-} + readField = readVkMultiview + +instance CanWriteField "multiview" + VkPhysicalDeviceMultiviewFeaturesKHX + where + {-# INLINE writeField #-} + writeField = writeVkMultiview + +instance {-# OVERLAPPING #-} + HasVkMultiviewGeometryShader VkPhysicalDeviceMultiviewFeaturesKHX + where + type VkMultiviewGeometryShaderMType + VkPhysicalDeviceMultiviewFeaturesKHX + = VkBool32 + + {-# NOINLINE vkMultiviewGeometryShader #-} + vkMultiviewGeometryShader x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceMultiviewFeaturesKHX, multiviewGeometryShader}) + + {-# INLINE vkMultiviewGeometryShaderByteOffset #-} + vkMultiviewGeometryShaderByteOffset ~_ + = #{offset VkPhysicalDeviceMultiviewFeaturesKHX, multiviewGeometryShader} + + {-# INLINE readVkMultiviewGeometryShader #-} + readVkMultiviewGeometryShader p + = peekByteOff p #{offset VkPhysicalDeviceMultiviewFeaturesKHX, multiviewGeometryShader} + + {-# INLINE writeVkMultiviewGeometryShader #-} + writeVkMultiviewGeometryShader p + = pokeByteOff p #{offset VkPhysicalDeviceMultiviewFeaturesKHX, multiviewGeometryShader} + +instance {-# OVERLAPPING #-} + HasField "multiviewGeometryShader" + VkPhysicalDeviceMultiviewFeaturesKHX + where + type FieldType "multiviewGeometryShader" + VkPhysicalDeviceMultiviewFeaturesKHX + = VkBool32 + type FieldOptional "multiviewGeometryShader" + VkPhysicalDeviceMultiviewFeaturesKHX + = 'False -- ' closing tick for hsc2hs + type FieldOffset "multiviewGeometryShader" + VkPhysicalDeviceMultiviewFeaturesKHX + = + #{offset VkPhysicalDeviceMultiviewFeaturesKHX, multiviewGeometryShader} + type FieldIsArray "multiviewGeometryShader" + VkPhysicalDeviceMultiviewFeaturesKHX + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceMultiviewFeaturesKHX, multiviewGeometryShader} + +instance CanReadField "multiviewGeometryShader" + VkPhysicalDeviceMultiviewFeaturesKHX + where + {-# INLINE getField #-} + getField = vkMultiviewGeometryShader + + {-# INLINE readField #-} + readField = readVkMultiviewGeometryShader + +instance CanWriteField "multiviewGeometryShader" + VkPhysicalDeviceMultiviewFeaturesKHX + where + {-# INLINE writeField #-} + writeField = writeVkMultiviewGeometryShader + +instance {-# OVERLAPPING #-} + HasVkMultiviewTessellationShader + VkPhysicalDeviceMultiviewFeaturesKHX + where + type VkMultiviewTessellationShaderMType + VkPhysicalDeviceMultiviewFeaturesKHX + = VkBool32 + + {-# NOINLINE vkMultiviewTessellationShader #-} + vkMultiviewTessellationShader x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceMultiviewFeaturesKHX, multiviewTessellationShader}) + + {-# INLINE vkMultiviewTessellationShaderByteOffset #-} + vkMultiviewTessellationShaderByteOffset ~_ + = #{offset VkPhysicalDeviceMultiviewFeaturesKHX, multiviewTessellationShader} + + {-# INLINE readVkMultiviewTessellationShader #-} + readVkMultiviewTessellationShader p + = peekByteOff p #{offset VkPhysicalDeviceMultiviewFeaturesKHX, multiviewTessellationShader} + + {-# INLINE writeVkMultiviewTessellationShader #-} + writeVkMultiviewTessellationShader p + = pokeByteOff p #{offset VkPhysicalDeviceMultiviewFeaturesKHX, multiviewTessellationShader} + +instance {-# OVERLAPPING #-} + HasField "multiviewTessellationShader" + VkPhysicalDeviceMultiviewFeaturesKHX + where + type FieldType "multiviewTessellationShader" + VkPhysicalDeviceMultiviewFeaturesKHX + = VkBool32 + type FieldOptional "multiviewTessellationShader" + VkPhysicalDeviceMultiviewFeaturesKHX + = 'False -- ' closing tick for hsc2hs + type FieldOffset "multiviewTessellationShader" + VkPhysicalDeviceMultiviewFeaturesKHX + = + #{offset VkPhysicalDeviceMultiviewFeaturesKHX, multiviewTessellationShader} + type FieldIsArray "multiviewTessellationShader" + VkPhysicalDeviceMultiviewFeaturesKHX + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceMultiviewFeaturesKHX, multiviewTessellationShader} + +instance CanReadField "multiviewTessellationShader" + VkPhysicalDeviceMultiviewFeaturesKHX + where + {-# INLINE getField #-} + getField = vkMultiviewTessellationShader + + {-# INLINE readField #-} + readField = readVkMultiviewTessellationShader + +instance CanWriteField "multiviewTessellationShader" + VkPhysicalDeviceMultiviewFeaturesKHX + where + {-# INLINE writeField #-} + writeField = writeVkMultiviewTessellationShader + +instance Show VkPhysicalDeviceMultiviewFeaturesKHX where + showsPrec d x + = showString "VkPhysicalDeviceMultiviewFeaturesKHX {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkMultiview = " . + showsPrec d (vkMultiview x) . + showString ", " . + showString "vkMultiviewGeometryShader = " . + showsPrec d (vkMultiviewGeometryShader x) . + showString ", " . + showString "vkMultiviewTessellationShader = " . + showsPrec d (vkMultiviewTessellationShader x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX.hsc @@ -0,0 +1,290 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX + (VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.BaseTypes (VkBool32) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceProperties2KHR (VkPhysicalDeviceProperties2KHR) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX { +-- > VkStructureType sType; +-- > void* pNext; +-- > VkBool32 perViewPositionAllComponents; +-- > } VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX; +-- +-- +data VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX = VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX## Addr## + ByteArray## + +instance Eq VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX + where + (VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX## a _) == + x@(VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord + VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX + where + (VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX## a _) + `compare` + x@(VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable + VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX + where + sizeOf ~_ + = #{size VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim + VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX + where + unsafeAddr + (VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray + (VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal + VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX + where + type StructFields + VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX + = '["sType", "pNext", "perViewPositionAllComponents"] -- ' closing tick for hsc2hs + type CUnionType + VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX + = 'False -- ' closing tick for hsc2hs + type ReturnedOnly + VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX + = 'True -- ' closing tick for hsc2hs + type StructExtends + VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX + = '[VkPhysicalDeviceProperties2KHR] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX + where + type VkSTypeMType + VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX + = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" + VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX + where + type FieldType "sType" + VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX + = VkStructureType + type FieldOptional "sType" + VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX + = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" + VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX + = + #{offset VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX, sType} + type FieldIsArray "sType" + VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX, sType} + +instance CanReadField "sType" + VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX + where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX + where + type VkPNextMType + VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX + = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" + VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX + where + type FieldType "pNext" + VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX + = Ptr Void + type FieldOptional "pNext" + VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX + = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" + VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX + = + #{offset VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX, pNext} + type FieldIsArray "pNext" + VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX, pNext} + +instance CanReadField "pNext" + VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX + where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance {-# OVERLAPPING #-} + HasVkPerViewPositionAllComponents + VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX + where + type VkPerViewPositionAllComponentsMType + VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX + = VkBool32 + + {-# NOINLINE vkPerViewPositionAllComponents #-} + vkPerViewPositionAllComponents x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX, perViewPositionAllComponents}) + + {-# INLINE vkPerViewPositionAllComponentsByteOffset #-} + vkPerViewPositionAllComponentsByteOffset ~_ + = #{offset VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX, perViewPositionAllComponents} + + {-# INLINE readVkPerViewPositionAllComponents #-} + readVkPerViewPositionAllComponents p + = peekByteOff p #{offset VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX, perViewPositionAllComponents} + + {-# INLINE writeVkPerViewPositionAllComponents #-} + writeVkPerViewPositionAllComponents p + = pokeByteOff p #{offset VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX, perViewPositionAllComponents} + +instance {-# OVERLAPPING #-} + HasField "perViewPositionAllComponents" + VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX + where + type FieldType "perViewPositionAllComponents" + VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX + = VkBool32 + type FieldOptional "perViewPositionAllComponents" + VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX + = 'False -- ' closing tick for hsc2hs + type FieldOffset "perViewPositionAllComponents" + VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX + = + #{offset VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX, perViewPositionAllComponents} + type FieldIsArray "perViewPositionAllComponents" + VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX, perViewPositionAllComponents} + +instance CanReadField "perViewPositionAllComponents" + VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX + where + {-# INLINE getField #-} + getField = vkPerViewPositionAllComponents + + {-# INLINE readField #-} + readField = readVkPerViewPositionAllComponents + +instance Show + VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX + where + showsPrec d x + = showString + "VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX {" + . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkPerViewPositionAllComponents = " . + showsPrec d (vkPerViewPositionAllComponents x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkPhysicalDeviceMultiviewPropertiesKHX.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkPhysicalDeviceMultiviewPropertiesKHX.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkPhysicalDeviceMultiviewPropertiesKHX.hsc @@ -0,0 +1,312 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceMultiviewPropertiesKHX + (VkPhysicalDeviceMultiviewPropertiesKHX(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceProperties2KHR (VkPhysicalDeviceProperties2KHR) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkPhysicalDeviceMultiviewPropertiesKHX { +-- > VkStructureType sType; +-- > void* pNext; +-- > uint32_t maxMultiviewViewCount; +-- > uint32_t maxMultiviewInstanceIndex; +-- > } VkPhysicalDeviceMultiviewPropertiesKHX; +-- +-- +data VkPhysicalDeviceMultiviewPropertiesKHX = VkPhysicalDeviceMultiviewPropertiesKHX## Addr## + ByteArray## + +instance Eq VkPhysicalDeviceMultiviewPropertiesKHX where + (VkPhysicalDeviceMultiviewPropertiesKHX## a _) == + x@(VkPhysicalDeviceMultiviewPropertiesKHX## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkPhysicalDeviceMultiviewPropertiesKHX where + (VkPhysicalDeviceMultiviewPropertiesKHX## a _) `compare` + x@(VkPhysicalDeviceMultiviewPropertiesKHX## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkPhysicalDeviceMultiviewPropertiesKHX where + sizeOf ~_ + = #{size VkPhysicalDeviceMultiviewPropertiesKHX} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkPhysicalDeviceMultiviewPropertiesKHX} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkPhysicalDeviceMultiviewPropertiesKHX + where + unsafeAddr (VkPhysicalDeviceMultiviewPropertiesKHX## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkPhysicalDeviceMultiviewPropertiesKHX## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkPhysicalDeviceMultiviewPropertiesKHX## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkPhysicalDeviceMultiviewPropertiesKHX where + type StructFields VkPhysicalDeviceMultiviewPropertiesKHX = + '["sType", "pNext", "maxMultiviewViewCount", -- ' closing tick for hsc2hs + "maxMultiviewInstanceIndex"] + type CUnionType VkPhysicalDeviceMultiviewPropertiesKHX = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkPhysicalDeviceMultiviewPropertiesKHX = 'True -- ' closing tick for hsc2hs + type StructExtends VkPhysicalDeviceMultiviewPropertiesKHX = + '[VkPhysicalDeviceProperties2KHR] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkPhysicalDeviceMultiviewPropertiesKHX where + type VkSTypeMType VkPhysicalDeviceMultiviewPropertiesKHX = + VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceMultiviewPropertiesKHX, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkPhysicalDeviceMultiviewPropertiesKHX, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkPhysicalDeviceMultiviewPropertiesKHX, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkPhysicalDeviceMultiviewPropertiesKHX, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkPhysicalDeviceMultiviewPropertiesKHX where + type FieldType "sType" VkPhysicalDeviceMultiviewPropertiesKHX = + VkStructureType + type FieldOptional "sType" VkPhysicalDeviceMultiviewPropertiesKHX = + 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkPhysicalDeviceMultiviewPropertiesKHX = + #{offset VkPhysicalDeviceMultiviewPropertiesKHX, sType} + type FieldIsArray "sType" VkPhysicalDeviceMultiviewPropertiesKHX = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceMultiviewPropertiesKHX, sType} + +instance CanReadField "sType" + VkPhysicalDeviceMultiviewPropertiesKHX + where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkPhysicalDeviceMultiviewPropertiesKHX where + type VkPNextMType VkPhysicalDeviceMultiviewPropertiesKHX = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceMultiviewPropertiesKHX, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkPhysicalDeviceMultiviewPropertiesKHX, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkPhysicalDeviceMultiviewPropertiesKHX, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkPhysicalDeviceMultiviewPropertiesKHX, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkPhysicalDeviceMultiviewPropertiesKHX where + type FieldType "pNext" VkPhysicalDeviceMultiviewPropertiesKHX = + Ptr Void + type FieldOptional "pNext" VkPhysicalDeviceMultiviewPropertiesKHX = + 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkPhysicalDeviceMultiviewPropertiesKHX = + #{offset VkPhysicalDeviceMultiviewPropertiesKHX, pNext} + type FieldIsArray "pNext" VkPhysicalDeviceMultiviewPropertiesKHX = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceMultiviewPropertiesKHX, pNext} + +instance CanReadField "pNext" + VkPhysicalDeviceMultiviewPropertiesKHX + where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance {-# OVERLAPPING #-} + HasVkMaxMultiviewViewCount VkPhysicalDeviceMultiviewPropertiesKHX + where + type VkMaxMultiviewViewCountMType + VkPhysicalDeviceMultiviewPropertiesKHX + = Word32 + + {-# NOINLINE vkMaxMultiviewViewCount #-} + vkMaxMultiviewViewCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceMultiviewPropertiesKHX, maxMultiviewViewCount}) + + {-# INLINE vkMaxMultiviewViewCountByteOffset #-} + vkMaxMultiviewViewCountByteOffset ~_ + = #{offset VkPhysicalDeviceMultiviewPropertiesKHX, maxMultiviewViewCount} + + {-# INLINE readVkMaxMultiviewViewCount #-} + readVkMaxMultiviewViewCount p + = peekByteOff p #{offset VkPhysicalDeviceMultiviewPropertiesKHX, maxMultiviewViewCount} + + {-# INLINE writeVkMaxMultiviewViewCount #-} + writeVkMaxMultiviewViewCount p + = pokeByteOff p #{offset VkPhysicalDeviceMultiviewPropertiesKHX, maxMultiviewViewCount} + +instance {-# OVERLAPPING #-} + HasField "maxMultiviewViewCount" + VkPhysicalDeviceMultiviewPropertiesKHX + where + type FieldType "maxMultiviewViewCount" + VkPhysicalDeviceMultiviewPropertiesKHX + = Word32 + type FieldOptional "maxMultiviewViewCount" + VkPhysicalDeviceMultiviewPropertiesKHX + = 'False -- ' closing tick for hsc2hs + type FieldOffset "maxMultiviewViewCount" + VkPhysicalDeviceMultiviewPropertiesKHX + = + #{offset VkPhysicalDeviceMultiviewPropertiesKHX, maxMultiviewViewCount} + type FieldIsArray "maxMultiviewViewCount" + VkPhysicalDeviceMultiviewPropertiesKHX + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceMultiviewPropertiesKHX, maxMultiviewViewCount} + +instance CanReadField "maxMultiviewViewCount" + VkPhysicalDeviceMultiviewPropertiesKHX + where + {-# INLINE getField #-} + getField = vkMaxMultiviewViewCount + + {-# INLINE readField #-} + readField = readVkMaxMultiviewViewCount + +instance {-# OVERLAPPING #-} + HasVkMaxMultiviewInstanceIndex + VkPhysicalDeviceMultiviewPropertiesKHX + where + type VkMaxMultiviewInstanceIndexMType + VkPhysicalDeviceMultiviewPropertiesKHX + = Word32 + + {-# NOINLINE vkMaxMultiviewInstanceIndex #-} + vkMaxMultiviewInstanceIndex x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceMultiviewPropertiesKHX, maxMultiviewInstanceIndex}) + + {-# INLINE vkMaxMultiviewInstanceIndexByteOffset #-} + vkMaxMultiviewInstanceIndexByteOffset ~_ + = #{offset VkPhysicalDeviceMultiviewPropertiesKHX, maxMultiviewInstanceIndex} + + {-# INLINE readVkMaxMultiviewInstanceIndex #-} + readVkMaxMultiviewInstanceIndex p + = peekByteOff p #{offset VkPhysicalDeviceMultiviewPropertiesKHX, maxMultiviewInstanceIndex} + + {-# INLINE writeVkMaxMultiviewInstanceIndex #-} + writeVkMaxMultiviewInstanceIndex p + = pokeByteOff p #{offset VkPhysicalDeviceMultiviewPropertiesKHX, maxMultiviewInstanceIndex} + +instance {-# OVERLAPPING #-} + HasField "maxMultiviewInstanceIndex" + VkPhysicalDeviceMultiviewPropertiesKHX + where + type FieldType "maxMultiviewInstanceIndex" + VkPhysicalDeviceMultiviewPropertiesKHX + = Word32 + type FieldOptional "maxMultiviewInstanceIndex" + VkPhysicalDeviceMultiviewPropertiesKHX + = 'False -- ' closing tick for hsc2hs + type FieldOffset "maxMultiviewInstanceIndex" + VkPhysicalDeviceMultiviewPropertiesKHX + = + #{offset VkPhysicalDeviceMultiviewPropertiesKHX, maxMultiviewInstanceIndex} + type FieldIsArray "maxMultiviewInstanceIndex" + VkPhysicalDeviceMultiviewPropertiesKHX + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceMultiviewPropertiesKHX, maxMultiviewInstanceIndex} + +instance CanReadField "maxMultiviewInstanceIndex" + VkPhysicalDeviceMultiviewPropertiesKHX + where + {-# INLINE getField #-} + getField = vkMaxMultiviewInstanceIndex + + {-# INLINE readField #-} + readField = readVkMaxMultiviewInstanceIndex + +instance Show VkPhysicalDeviceMultiviewPropertiesKHX where + showsPrec d x + = showString "VkPhysicalDeviceMultiviewPropertiesKHX {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkMaxMultiviewViewCount = " . + showsPrec d (vkMaxMultiviewViewCount x) . + showString ", " . + showString "vkMaxMultiviewInstanceIndex = " . + showsPrec d (vkMaxMultiviewInstanceIndex x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkPhysicalDevicePointClippingPropertiesKHR.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkPhysicalDevicePointClippingPropertiesKHR.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkPhysicalDevicePointClippingPropertiesKHR.hsc @@ -0,0 +1,261 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkPhysicalDevicePointClippingPropertiesKHR + (VkPhysicalDevicePointClippingPropertiesKHR(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkPointClippingBehaviorKHR (VkPointClippingBehaviorKHR) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceProperties2KHR (VkPhysicalDeviceProperties2KHR) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkPhysicalDevicePointClippingPropertiesKHR { +-- > VkStructureType sType; +-- > void* pNext; +-- > VkPointClippingBehaviorKHR pointClippingBehavior; +-- > } VkPhysicalDevicePointClippingPropertiesKHR; +-- +-- +data VkPhysicalDevicePointClippingPropertiesKHR = VkPhysicalDevicePointClippingPropertiesKHR## Addr## + ByteArray## + +instance Eq VkPhysicalDevicePointClippingPropertiesKHR where + (VkPhysicalDevicePointClippingPropertiesKHR## a _) == + x@(VkPhysicalDevicePointClippingPropertiesKHR## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkPhysicalDevicePointClippingPropertiesKHR where + (VkPhysicalDevicePointClippingPropertiesKHR## a _) `compare` + x@(VkPhysicalDevicePointClippingPropertiesKHR## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkPhysicalDevicePointClippingPropertiesKHR where + sizeOf ~_ + = #{size VkPhysicalDevicePointClippingPropertiesKHR} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkPhysicalDevicePointClippingPropertiesKHR} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim + VkPhysicalDevicePointClippingPropertiesKHR + where + unsafeAddr (VkPhysicalDevicePointClippingPropertiesKHR## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkPhysicalDevicePointClippingPropertiesKHR## _ b) + = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkPhysicalDevicePointClippingPropertiesKHR## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkPhysicalDevicePointClippingPropertiesKHR + where + type StructFields VkPhysicalDevicePointClippingPropertiesKHR = + '["sType", "pNext", "pointClippingBehavior"] -- ' closing tick for hsc2hs + type CUnionType VkPhysicalDevicePointClippingPropertiesKHR = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkPhysicalDevicePointClippingPropertiesKHR = + 'True -- ' closing tick for hsc2hs + type StructExtends VkPhysicalDevicePointClippingPropertiesKHR = + '[VkPhysicalDeviceProperties2KHR] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkPhysicalDevicePointClippingPropertiesKHR where + type VkSTypeMType VkPhysicalDevicePointClippingPropertiesKHR = + VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDevicePointClippingPropertiesKHR, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkPhysicalDevicePointClippingPropertiesKHR, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkPhysicalDevicePointClippingPropertiesKHR, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkPhysicalDevicePointClippingPropertiesKHR, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkPhysicalDevicePointClippingPropertiesKHR where + type FieldType "sType" VkPhysicalDevicePointClippingPropertiesKHR = + VkStructureType + type FieldOptional "sType" + VkPhysicalDevicePointClippingPropertiesKHR + = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkPhysicalDevicePointClippingPropertiesKHR + = + #{offset VkPhysicalDevicePointClippingPropertiesKHR, sType} + type FieldIsArray "sType" + VkPhysicalDevicePointClippingPropertiesKHR + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDevicePointClippingPropertiesKHR, sType} + +instance CanReadField "sType" + VkPhysicalDevicePointClippingPropertiesKHR + where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkPhysicalDevicePointClippingPropertiesKHR where + type VkPNextMType VkPhysicalDevicePointClippingPropertiesKHR = + Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDevicePointClippingPropertiesKHR, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkPhysicalDevicePointClippingPropertiesKHR, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkPhysicalDevicePointClippingPropertiesKHR, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkPhysicalDevicePointClippingPropertiesKHR, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkPhysicalDevicePointClippingPropertiesKHR where + type FieldType "pNext" VkPhysicalDevicePointClippingPropertiesKHR = + Ptr Void + type FieldOptional "pNext" + VkPhysicalDevicePointClippingPropertiesKHR + = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkPhysicalDevicePointClippingPropertiesKHR + = + #{offset VkPhysicalDevicePointClippingPropertiesKHR, pNext} + type FieldIsArray "pNext" + VkPhysicalDevicePointClippingPropertiesKHR + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDevicePointClippingPropertiesKHR, pNext} + +instance CanReadField "pNext" + VkPhysicalDevicePointClippingPropertiesKHR + where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance {-# OVERLAPPING #-} + HasVkPointClippingBehavior + VkPhysicalDevicePointClippingPropertiesKHR + where + type VkPointClippingBehaviorMType + VkPhysicalDevicePointClippingPropertiesKHR + = VkPointClippingBehaviorKHR + + {-# NOINLINE vkPointClippingBehavior #-} + vkPointClippingBehavior x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDevicePointClippingPropertiesKHR, pointClippingBehavior}) + + {-# INLINE vkPointClippingBehaviorByteOffset #-} + vkPointClippingBehaviorByteOffset ~_ + = #{offset VkPhysicalDevicePointClippingPropertiesKHR, pointClippingBehavior} + + {-# INLINE readVkPointClippingBehavior #-} + readVkPointClippingBehavior p + = peekByteOff p #{offset VkPhysicalDevicePointClippingPropertiesKHR, pointClippingBehavior} + + {-# INLINE writeVkPointClippingBehavior #-} + writeVkPointClippingBehavior p + = pokeByteOff p #{offset VkPhysicalDevicePointClippingPropertiesKHR, pointClippingBehavior} + +instance {-# OVERLAPPING #-} + HasField "pointClippingBehavior" + VkPhysicalDevicePointClippingPropertiesKHR + where + type FieldType "pointClippingBehavior" + VkPhysicalDevicePointClippingPropertiesKHR + = VkPointClippingBehaviorKHR + type FieldOptional "pointClippingBehavior" + VkPhysicalDevicePointClippingPropertiesKHR + = 'False -- ' closing tick for hsc2hs + type FieldOffset "pointClippingBehavior" + VkPhysicalDevicePointClippingPropertiesKHR + = + #{offset VkPhysicalDevicePointClippingPropertiesKHR, pointClippingBehavior} + type FieldIsArray "pointClippingBehavior" + VkPhysicalDevicePointClippingPropertiesKHR + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDevicePointClippingPropertiesKHR, pointClippingBehavior} + +instance CanReadField "pointClippingBehavior" + VkPhysicalDevicePointClippingPropertiesKHR + where + {-# INLINE getField #-} + getField = vkPointClippingBehavior + + {-# INLINE readField #-} + readField = readVkPointClippingBehavior + +instance Show VkPhysicalDevicePointClippingPropertiesKHR where + showsPrec d x + = showString "VkPhysicalDevicePointClippingPropertiesKHR {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkPointClippingBehavior = " . + showsPrec d (vkPointClippingBehavior x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkPhysicalDeviceProperties.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkPhysicalDeviceProperties.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkPhysicalDeviceProperties.hsc @@ -0,0 +1,606 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleContexts #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE ScopedTypeVariables #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +{-# LANGUAGE UndecidableInstances #-} +module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceProperties + (VkPhysicalDeviceProperties(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import GHC.TypeLits (KnownNat, + natVal') -- ' closing tick for hsc2hs +import Graphics.Vulkan.Constants (VK_MAX_PHYSICAL_DEVICE_NAME_SIZE, + pattern VK_MAX_PHYSICAL_DEVICE_NAME_SIZE, + VK_UUID_SIZE, + pattern VK_UUID_SIZE) +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkPhysicalDeviceType (VkPhysicalDeviceType) +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceLimits (VkPhysicalDeviceLimits) +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceSparseProperties (VkPhysicalDeviceSparseProperties) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkPhysicalDeviceProperties { +-- > uint32_t apiVersion; +-- > uint32_t driverVersion; +-- > uint32_t vendorID; +-- > uint32_t deviceID; +-- > VkPhysicalDeviceType deviceType; +-- > char deviceName[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE]; +-- > uint8_t pipelineCacheUUID[VK_UUID_SIZE]; +-- > VkPhysicalDeviceLimits limits; +-- > VkPhysicalDeviceSparseProperties sparseProperties; +-- > } VkPhysicalDeviceProperties; +-- +-- +data VkPhysicalDeviceProperties = VkPhysicalDeviceProperties## Addr## + ByteArray## + +instance Eq VkPhysicalDeviceProperties where + (VkPhysicalDeviceProperties## a _) == + x@(VkPhysicalDeviceProperties## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkPhysicalDeviceProperties where + (VkPhysicalDeviceProperties## a _) `compare` + x@(VkPhysicalDeviceProperties## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkPhysicalDeviceProperties where + sizeOf ~_ = #{size VkPhysicalDeviceProperties} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkPhysicalDeviceProperties} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkPhysicalDeviceProperties where + unsafeAddr (VkPhysicalDeviceProperties## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkPhysicalDeviceProperties## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkPhysicalDeviceProperties## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkPhysicalDeviceProperties where + type StructFields VkPhysicalDeviceProperties = + '["apiVersion", "driverVersion", "vendorID", "deviceID", -- ' closing tick for hsc2hs + "deviceType", "deviceName", "pipelineCacheUUID", "limits", + "sparseProperties"] + type CUnionType VkPhysicalDeviceProperties = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkPhysicalDeviceProperties = 'True -- ' closing tick for hsc2hs + type StructExtends VkPhysicalDeviceProperties = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkApiVersion VkPhysicalDeviceProperties where + type VkApiVersionMType VkPhysicalDeviceProperties = Word32 + + {-# NOINLINE vkApiVersion #-} + vkApiVersion x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceProperties, apiVersion}) + + {-# INLINE vkApiVersionByteOffset #-} + vkApiVersionByteOffset ~_ + = #{offset VkPhysicalDeviceProperties, apiVersion} + + {-# INLINE readVkApiVersion #-} + readVkApiVersion p + = peekByteOff p #{offset VkPhysicalDeviceProperties, apiVersion} + + {-# INLINE writeVkApiVersion #-} + writeVkApiVersion p + = pokeByteOff p #{offset VkPhysicalDeviceProperties, apiVersion} + +instance {-# OVERLAPPING #-} + HasField "apiVersion" VkPhysicalDeviceProperties where + type FieldType "apiVersion" VkPhysicalDeviceProperties = Word32 + type FieldOptional "apiVersion" VkPhysicalDeviceProperties = 'False -- ' closing tick for hsc2hs + type FieldOffset "apiVersion" VkPhysicalDeviceProperties = + #{offset VkPhysicalDeviceProperties, apiVersion} + type FieldIsArray "apiVersion" VkPhysicalDeviceProperties = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceProperties, apiVersion} + +instance CanReadField "apiVersion" VkPhysicalDeviceProperties where + {-# INLINE getField #-} + getField = vkApiVersion + + {-# INLINE readField #-} + readField = readVkApiVersion + +instance {-# OVERLAPPING #-} + HasVkDriverVersion VkPhysicalDeviceProperties where + type VkDriverVersionMType VkPhysicalDeviceProperties = Word32 + + {-# NOINLINE vkDriverVersion #-} + vkDriverVersion x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceProperties, driverVersion}) + + {-# INLINE vkDriverVersionByteOffset #-} + vkDriverVersionByteOffset ~_ + = #{offset VkPhysicalDeviceProperties, driverVersion} + + {-# INLINE readVkDriverVersion #-} + readVkDriverVersion p + = peekByteOff p #{offset VkPhysicalDeviceProperties, driverVersion} + + {-# INLINE writeVkDriverVersion #-} + writeVkDriverVersion p + = pokeByteOff p #{offset VkPhysicalDeviceProperties, driverVersion} + +instance {-# OVERLAPPING #-} + HasField "driverVersion" VkPhysicalDeviceProperties where + type FieldType "driverVersion" VkPhysicalDeviceProperties = Word32 + type FieldOptional "driverVersion" VkPhysicalDeviceProperties = + 'False -- ' closing tick for hsc2hs + type FieldOffset "driverVersion" VkPhysicalDeviceProperties = + #{offset VkPhysicalDeviceProperties, driverVersion} + type FieldIsArray "driverVersion" VkPhysicalDeviceProperties = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceProperties, driverVersion} + +instance CanReadField "driverVersion" VkPhysicalDeviceProperties + where + {-# INLINE getField #-} + getField = vkDriverVersion + + {-# INLINE readField #-} + readField = readVkDriverVersion + +instance {-# OVERLAPPING #-} + HasVkVendorID VkPhysicalDeviceProperties where + type VkVendorIDMType VkPhysicalDeviceProperties = Word32 + + {-# NOINLINE vkVendorID #-} + vkVendorID x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceProperties, vendorID}) + + {-# INLINE vkVendorIDByteOffset #-} + vkVendorIDByteOffset ~_ + = #{offset VkPhysicalDeviceProperties, vendorID} + + {-# INLINE readVkVendorID #-} + readVkVendorID p + = peekByteOff p #{offset VkPhysicalDeviceProperties, vendorID} + + {-# INLINE writeVkVendorID #-} + writeVkVendorID p + = pokeByteOff p #{offset VkPhysicalDeviceProperties, vendorID} + +instance {-# OVERLAPPING #-} + HasField "vendorID" VkPhysicalDeviceProperties where + type FieldType "vendorID" VkPhysicalDeviceProperties = Word32 + type FieldOptional "vendorID" VkPhysicalDeviceProperties = 'False -- ' closing tick for hsc2hs + type FieldOffset "vendorID" VkPhysicalDeviceProperties = + #{offset VkPhysicalDeviceProperties, vendorID} + type FieldIsArray "vendorID" VkPhysicalDeviceProperties = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceProperties, vendorID} + +instance CanReadField "vendorID" VkPhysicalDeviceProperties where + {-# INLINE getField #-} + getField = vkVendorID + + {-# INLINE readField #-} + readField = readVkVendorID + +instance {-# OVERLAPPING #-} + HasVkDeviceID VkPhysicalDeviceProperties where + type VkDeviceIDMType VkPhysicalDeviceProperties = Word32 + + {-# NOINLINE vkDeviceID #-} + vkDeviceID x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceProperties, deviceID}) + + {-# INLINE vkDeviceIDByteOffset #-} + vkDeviceIDByteOffset ~_ + = #{offset VkPhysicalDeviceProperties, deviceID} + + {-# INLINE readVkDeviceID #-} + readVkDeviceID p + = peekByteOff p #{offset VkPhysicalDeviceProperties, deviceID} + + {-# INLINE writeVkDeviceID #-} + writeVkDeviceID p + = pokeByteOff p #{offset VkPhysicalDeviceProperties, deviceID} + +instance {-# OVERLAPPING #-} + HasField "deviceID" VkPhysicalDeviceProperties where + type FieldType "deviceID" VkPhysicalDeviceProperties = Word32 + type FieldOptional "deviceID" VkPhysicalDeviceProperties = 'False -- ' closing tick for hsc2hs + type FieldOffset "deviceID" VkPhysicalDeviceProperties = + #{offset VkPhysicalDeviceProperties, deviceID} + type FieldIsArray "deviceID" VkPhysicalDeviceProperties = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceProperties, deviceID} + +instance CanReadField "deviceID" VkPhysicalDeviceProperties where + {-# INLINE getField #-} + getField = vkDeviceID + + {-# INLINE readField #-} + readField = readVkDeviceID + +instance {-# OVERLAPPING #-} + HasVkDeviceType VkPhysicalDeviceProperties where + type VkDeviceTypeMType VkPhysicalDeviceProperties = + VkPhysicalDeviceType + + {-# NOINLINE vkDeviceType #-} + vkDeviceType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceProperties, deviceType}) + + {-# INLINE vkDeviceTypeByteOffset #-} + vkDeviceTypeByteOffset ~_ + = #{offset VkPhysicalDeviceProperties, deviceType} + + {-# INLINE readVkDeviceType #-} + readVkDeviceType p + = peekByteOff p #{offset VkPhysicalDeviceProperties, deviceType} + + {-# INLINE writeVkDeviceType #-} + writeVkDeviceType p + = pokeByteOff p #{offset VkPhysicalDeviceProperties, deviceType} + +instance {-# OVERLAPPING #-} + HasField "deviceType" VkPhysicalDeviceProperties where + type FieldType "deviceType" VkPhysicalDeviceProperties = + VkPhysicalDeviceType + type FieldOptional "deviceType" VkPhysicalDeviceProperties = 'False -- ' closing tick for hsc2hs + type FieldOffset "deviceType" VkPhysicalDeviceProperties = + #{offset VkPhysicalDeviceProperties, deviceType} + type FieldIsArray "deviceType" VkPhysicalDeviceProperties = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceProperties, deviceType} + +instance CanReadField "deviceType" VkPhysicalDeviceProperties where + {-# INLINE getField #-} + getField = vkDeviceType + + {-# INLINE readField #-} + readField = readVkDeviceType + +instance {-# OVERLAPPING #-} + HasVkDeviceNameArray VkPhysicalDeviceProperties where + type VkDeviceNameArrayMType VkPhysicalDeviceProperties = CChar + + {-# NOINLINE vkDeviceNameArray #-} + vkDeviceNameArray x idx + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) + (idx * sizeOf (undefined :: CChar) + + #{offset VkPhysicalDeviceProperties, deviceName})) + + {-# INLINE vkDeviceNameArrayByteOffset #-} + vkDeviceNameArrayByteOffset ~_ + = #{offset VkPhysicalDeviceProperties, deviceName} + + {-# INLINE readVkDeviceNameArray #-} + readVkDeviceNameArray p idx + = peekByteOff p + (idx * sizeOf (undefined :: CChar) + + #{offset VkPhysicalDeviceProperties, deviceName}) + + {-# INLINE writeVkDeviceNameArray #-} + writeVkDeviceNameArray p idx + = pokeByteOff p + (idx * sizeOf (undefined :: CChar) + + #{offset VkPhysicalDeviceProperties, deviceName}) + +instance {-# OVERLAPPING #-} + HasField "deviceName" VkPhysicalDeviceProperties where + type FieldType "deviceName" VkPhysicalDeviceProperties = CChar + type FieldOptional "deviceName" VkPhysicalDeviceProperties = 'False -- ' closing tick for hsc2hs + type FieldOffset "deviceName" VkPhysicalDeviceProperties = + #{offset VkPhysicalDeviceProperties, deviceName} + type FieldIsArray "deviceName" VkPhysicalDeviceProperties = 'True -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceProperties, deviceName} + +instance (KnownNat idx, + IndexInBounds "deviceName" idx VkPhysicalDeviceProperties) => + CanReadFieldArray "deviceName" idx VkPhysicalDeviceProperties + where + {-# SPECIALISE instance + CanReadFieldArray "deviceName" 0 VkPhysicalDeviceProperties #-} + + {-# SPECIALISE instance + CanReadFieldArray "deviceName" 1 VkPhysicalDeviceProperties #-} + + {-# SPECIALISE instance + CanReadFieldArray "deviceName" 2 VkPhysicalDeviceProperties #-} + + {-# SPECIALISE instance + CanReadFieldArray "deviceName" 3 VkPhysicalDeviceProperties #-} + type FieldArrayLength "deviceName" VkPhysicalDeviceProperties = + VK_MAX_PHYSICAL_DEVICE_NAME_SIZE + + {-# INLINE fieldArrayLength #-} + fieldArrayLength = VK_MAX_PHYSICAL_DEVICE_NAME_SIZE + + {-# INLINE getFieldArray #-} + getFieldArray x + = vkDeviceNameArray x + (fromInteger $ natVal' (proxy## :: Proxy## idx)) -- ' closing tick for hsc2hs + + {-# INLINE readFieldArray #-} + readFieldArray x + = readVkDeviceNameArray x + (fromInteger $ natVal' (proxy## :: Proxy## idx)) -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkPipelineCacheUUIDArray VkPhysicalDeviceProperties where + type VkPipelineCacheUUIDArrayMType VkPhysicalDeviceProperties = + Word8 + + {-# NOINLINE vkPipelineCacheUUIDArray #-} + vkPipelineCacheUUIDArray x idx + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) + (idx * sizeOf (undefined :: Word8) + + #{offset VkPhysicalDeviceProperties, pipelineCacheUUID})) + + {-# INLINE vkPipelineCacheUUIDArrayByteOffset #-} + vkPipelineCacheUUIDArrayByteOffset ~_ + = #{offset VkPhysicalDeviceProperties, pipelineCacheUUID} + + {-# INLINE readVkPipelineCacheUUIDArray #-} + readVkPipelineCacheUUIDArray p idx + = peekByteOff p + (idx * sizeOf (undefined :: Word8) + + #{offset VkPhysicalDeviceProperties, pipelineCacheUUID}) + + {-# INLINE writeVkPipelineCacheUUIDArray #-} + writeVkPipelineCacheUUIDArray p idx + = pokeByteOff p + (idx * sizeOf (undefined :: Word8) + + #{offset VkPhysicalDeviceProperties, pipelineCacheUUID}) + +instance {-# OVERLAPPING #-} + HasField "pipelineCacheUUID" VkPhysicalDeviceProperties where + type FieldType "pipelineCacheUUID" VkPhysicalDeviceProperties = + Word8 + type FieldOptional "pipelineCacheUUID" VkPhysicalDeviceProperties = + 'False -- ' closing tick for hsc2hs + type FieldOffset "pipelineCacheUUID" VkPhysicalDeviceProperties = + #{offset VkPhysicalDeviceProperties, pipelineCacheUUID} + type FieldIsArray "pipelineCacheUUID" VkPhysicalDeviceProperties = + 'True -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceProperties, pipelineCacheUUID} + +instance (KnownNat idx, + IndexInBounds "pipelineCacheUUID" idx + VkPhysicalDeviceProperties) => + CanReadFieldArray "pipelineCacheUUID" idx + VkPhysicalDeviceProperties + where + {-# SPECIALISE instance + CanReadFieldArray "pipelineCacheUUID" 0 VkPhysicalDeviceProperties + #-} + + {-# SPECIALISE instance + CanReadFieldArray "pipelineCacheUUID" 1 VkPhysicalDeviceProperties + #-} + + {-# SPECIALISE instance + CanReadFieldArray "pipelineCacheUUID" 2 VkPhysicalDeviceProperties + #-} + + {-# SPECIALISE instance + CanReadFieldArray "pipelineCacheUUID" 3 VkPhysicalDeviceProperties + #-} + type FieldArrayLength "pipelineCacheUUID" + VkPhysicalDeviceProperties + = VK_UUID_SIZE + + {-# INLINE fieldArrayLength #-} + fieldArrayLength = VK_UUID_SIZE + + {-# INLINE getFieldArray #-} + getFieldArray x + = vkPipelineCacheUUIDArray x + (fromInteger $ natVal' (proxy## :: Proxy## idx)) -- ' closing tick for hsc2hs + + {-# INLINE readFieldArray #-} + readFieldArray x + = readVkPipelineCacheUUIDArray x + (fromInteger $ natVal' (proxy## :: Proxy## idx)) -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkLimits VkPhysicalDeviceProperties + where + type VkLimitsMType VkPhysicalDeviceProperties = + VkPhysicalDeviceLimits + + {-# NOINLINE vkLimits #-} + vkLimits x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceProperties, limits}) + + {-# INLINE vkLimitsByteOffset #-} + vkLimitsByteOffset ~_ + = #{offset VkPhysicalDeviceProperties, limits} + + {-# INLINE readVkLimits #-} + readVkLimits p + = peekByteOff p #{offset VkPhysicalDeviceProperties, limits} + + {-# INLINE writeVkLimits #-} + writeVkLimits p + = pokeByteOff p #{offset VkPhysicalDeviceProperties, limits} + +instance {-# OVERLAPPING #-} + HasField "limits" VkPhysicalDeviceProperties where + type FieldType "limits" VkPhysicalDeviceProperties = + VkPhysicalDeviceLimits + type FieldOptional "limits" VkPhysicalDeviceProperties = 'False -- ' closing tick for hsc2hs + type FieldOffset "limits" VkPhysicalDeviceProperties = + #{offset VkPhysicalDeviceProperties, limits} + type FieldIsArray "limits" VkPhysicalDeviceProperties = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceProperties, limits} + +instance CanReadField "limits" VkPhysicalDeviceProperties where + {-# INLINE getField #-} + getField = vkLimits + + {-# INLINE readField #-} + readField = readVkLimits + +instance {-# OVERLAPPING #-} + HasVkSparseProperties VkPhysicalDeviceProperties where + type VkSparsePropertiesMType VkPhysicalDeviceProperties = + VkPhysicalDeviceSparseProperties + + {-# NOINLINE vkSparseProperties #-} + vkSparseProperties x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceProperties, sparseProperties}) + + {-# INLINE vkSparsePropertiesByteOffset #-} + vkSparsePropertiesByteOffset ~_ + = #{offset VkPhysicalDeviceProperties, sparseProperties} + + {-# INLINE readVkSparseProperties #-} + readVkSparseProperties p + = peekByteOff p #{offset VkPhysicalDeviceProperties, sparseProperties} + + {-# INLINE writeVkSparseProperties #-} + writeVkSparseProperties p + = pokeByteOff p #{offset VkPhysicalDeviceProperties, sparseProperties} + +instance {-# OVERLAPPING #-} + HasField "sparseProperties" VkPhysicalDeviceProperties where + type FieldType "sparseProperties" VkPhysicalDeviceProperties = + VkPhysicalDeviceSparseProperties + type FieldOptional "sparseProperties" VkPhysicalDeviceProperties = + 'False -- ' closing tick for hsc2hs + type FieldOffset "sparseProperties" VkPhysicalDeviceProperties = + #{offset VkPhysicalDeviceProperties, sparseProperties} + type FieldIsArray "sparseProperties" VkPhysicalDeviceProperties = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceProperties, sparseProperties} + +instance CanReadField "sparseProperties" VkPhysicalDeviceProperties + where + {-# INLINE getField #-} + getField = vkSparseProperties + + {-# INLINE readField #-} + readField = readVkSparseProperties + +instance Show VkPhysicalDeviceProperties where + showsPrec d x + = showString "VkPhysicalDeviceProperties {" . + showString "vkApiVersion = " . + showsPrec d (vkApiVersion x) . + showString ", " . + showString "vkDriverVersion = " . + showsPrec d (vkDriverVersion x) . + showString ", " . + showString "vkVendorID = " . + showsPrec d (vkVendorID x) . + showString ", " . + showString "vkDeviceID = " . + showsPrec d (vkDeviceID x) . + showString ", " . + showString "vkDeviceType = " . + showsPrec d (vkDeviceType x) . + showString ", " . + showString "vkDeviceNameArray = [" . + showsPrec d + (map (vkDeviceNameArray x) + [1 .. VK_MAX_PHYSICAL_DEVICE_NAME_SIZE]) + . + showChar ']' . + showString ", " . + showString "vkPipelineCacheUUIDArray = [" . + showsPrec d + (map (vkPipelineCacheUUIDArray x) + [1 .. VK_UUID_SIZE]) + . + showChar ']' . + showString ", " . + showString "vkLimits = " . + showsPrec d (vkLimits x) . + showString ", " . + showString "vkSparseProperties = " + . + showsPrec d + (vkSparseProperties x) + . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkPhysicalDeviceProperties2KHR.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkPhysicalDeviceProperties2KHR.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkPhysicalDeviceProperties2KHR.hsc @@ -0,0 +1,224 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceProperties2KHR + (VkPhysicalDeviceProperties2KHR(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceProperties (VkPhysicalDeviceProperties) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkPhysicalDeviceProperties2KHR { +-- > VkStructureType sType; +-- > void* pNext; +-- > VkPhysicalDeviceProperties properties; +-- > } VkPhysicalDeviceProperties2KHR; +-- +-- +data VkPhysicalDeviceProperties2KHR = VkPhysicalDeviceProperties2KHR## Addr## + ByteArray## + +instance Eq VkPhysicalDeviceProperties2KHR where + (VkPhysicalDeviceProperties2KHR## a _) == + x@(VkPhysicalDeviceProperties2KHR## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkPhysicalDeviceProperties2KHR where + (VkPhysicalDeviceProperties2KHR## a _) `compare` + x@(VkPhysicalDeviceProperties2KHR## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkPhysicalDeviceProperties2KHR where + sizeOf ~_ = #{size VkPhysicalDeviceProperties2KHR} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkPhysicalDeviceProperties2KHR} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkPhysicalDeviceProperties2KHR where + unsafeAddr (VkPhysicalDeviceProperties2KHR## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkPhysicalDeviceProperties2KHR## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkPhysicalDeviceProperties2KHR## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkPhysicalDeviceProperties2KHR where + type StructFields VkPhysicalDeviceProperties2KHR = + '["sType", "pNext", "properties"] -- ' closing tick for hsc2hs + type CUnionType VkPhysicalDeviceProperties2KHR = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkPhysicalDeviceProperties2KHR = 'True -- ' closing tick for hsc2hs + type StructExtends VkPhysicalDeviceProperties2KHR = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkPhysicalDeviceProperties2KHR where + type VkSTypeMType VkPhysicalDeviceProperties2KHR = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceProperties2KHR, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkPhysicalDeviceProperties2KHR, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkPhysicalDeviceProperties2KHR, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkPhysicalDeviceProperties2KHR, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkPhysicalDeviceProperties2KHR where + type FieldType "sType" VkPhysicalDeviceProperties2KHR = + VkStructureType + type FieldOptional "sType" VkPhysicalDeviceProperties2KHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkPhysicalDeviceProperties2KHR = + #{offset VkPhysicalDeviceProperties2KHR, sType} + type FieldIsArray "sType" VkPhysicalDeviceProperties2KHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceProperties2KHR, sType} + +instance CanReadField "sType" VkPhysicalDeviceProperties2KHR where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkPhysicalDeviceProperties2KHR where + type VkPNextMType VkPhysicalDeviceProperties2KHR = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceProperties2KHR, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkPhysicalDeviceProperties2KHR, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkPhysicalDeviceProperties2KHR, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkPhysicalDeviceProperties2KHR, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkPhysicalDeviceProperties2KHR where + type FieldType "pNext" VkPhysicalDeviceProperties2KHR = Ptr Void + type FieldOptional "pNext" VkPhysicalDeviceProperties2KHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkPhysicalDeviceProperties2KHR = + #{offset VkPhysicalDeviceProperties2KHR, pNext} + type FieldIsArray "pNext" VkPhysicalDeviceProperties2KHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceProperties2KHR, pNext} + +instance CanReadField "pNext" VkPhysicalDeviceProperties2KHR where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance {-# OVERLAPPING #-} + HasVkProperties VkPhysicalDeviceProperties2KHR where + type VkPropertiesMType VkPhysicalDeviceProperties2KHR = + VkPhysicalDeviceProperties + + {-# NOINLINE vkProperties #-} + vkProperties x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceProperties2KHR, properties}) + + {-# INLINE vkPropertiesByteOffset #-} + vkPropertiesByteOffset ~_ + = #{offset VkPhysicalDeviceProperties2KHR, properties} + + {-# INLINE readVkProperties #-} + readVkProperties p + = peekByteOff p #{offset VkPhysicalDeviceProperties2KHR, properties} + + {-# INLINE writeVkProperties #-} + writeVkProperties p + = pokeByteOff p #{offset VkPhysicalDeviceProperties2KHR, properties} + +instance {-# OVERLAPPING #-} + HasField "properties" VkPhysicalDeviceProperties2KHR where + type FieldType "properties" VkPhysicalDeviceProperties2KHR = + VkPhysicalDeviceProperties + type FieldOptional "properties" VkPhysicalDeviceProperties2KHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "properties" VkPhysicalDeviceProperties2KHR = + #{offset VkPhysicalDeviceProperties2KHR, properties} + type FieldIsArray "properties" VkPhysicalDeviceProperties2KHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceProperties2KHR, properties} + +instance CanReadField "properties" VkPhysicalDeviceProperties2KHR + where + {-# INLINE getField #-} + getField = vkProperties + + {-# INLINE readField #-} + readField = readVkProperties + +instance Show VkPhysicalDeviceProperties2KHR where + showsPrec d x + = showString "VkPhysicalDeviceProperties2KHR {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkProperties = " . + showsPrec d (vkProperties x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkPhysicalDevicePushDescriptorPropertiesKHR.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkPhysicalDevicePushDescriptorPropertiesKHR.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkPhysicalDevicePushDescriptorPropertiesKHR.hsc @@ -0,0 +1,280 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkPhysicalDevicePushDescriptorPropertiesKHR + (VkPhysicalDevicePushDescriptorPropertiesKHR(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceProperties2KHR (VkPhysicalDeviceProperties2KHR) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkPhysicalDevicePushDescriptorPropertiesKHR { +-- > VkStructureType sType; +-- > void* pNext; +-- > uint32_t maxPushDescriptors; +-- > } VkPhysicalDevicePushDescriptorPropertiesKHR; +-- +-- +data VkPhysicalDevicePushDescriptorPropertiesKHR = VkPhysicalDevicePushDescriptorPropertiesKHR## Addr## + ByteArray## + +instance Eq VkPhysicalDevicePushDescriptorPropertiesKHR where + (VkPhysicalDevicePushDescriptorPropertiesKHR## a _) == + x@(VkPhysicalDevicePushDescriptorPropertiesKHR## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkPhysicalDevicePushDescriptorPropertiesKHR where + (VkPhysicalDevicePushDescriptorPropertiesKHR## a _) `compare` + x@(VkPhysicalDevicePushDescriptorPropertiesKHR## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkPhysicalDevicePushDescriptorPropertiesKHR where + sizeOf ~_ + = #{size VkPhysicalDevicePushDescriptorPropertiesKHR} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkPhysicalDevicePushDescriptorPropertiesKHR} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim + VkPhysicalDevicePushDescriptorPropertiesKHR + where + unsafeAddr (VkPhysicalDevicePushDescriptorPropertiesKHR## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkPhysicalDevicePushDescriptorPropertiesKHR## _ b) + = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkPhysicalDevicePushDescriptorPropertiesKHR## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkPhysicalDevicePushDescriptorPropertiesKHR + where + type StructFields VkPhysicalDevicePushDescriptorPropertiesKHR = + '["sType", "pNext", "maxPushDescriptors"] -- ' closing tick for hsc2hs + type CUnionType VkPhysicalDevicePushDescriptorPropertiesKHR = + 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkPhysicalDevicePushDescriptorPropertiesKHR = + 'False -- ' closing tick for hsc2hs + type StructExtends VkPhysicalDevicePushDescriptorPropertiesKHR = + '[VkPhysicalDeviceProperties2KHR] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkPhysicalDevicePushDescriptorPropertiesKHR where + type VkSTypeMType VkPhysicalDevicePushDescriptorPropertiesKHR = + VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDevicePushDescriptorPropertiesKHR, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkPhysicalDevicePushDescriptorPropertiesKHR, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkPhysicalDevicePushDescriptorPropertiesKHR, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkPhysicalDevicePushDescriptorPropertiesKHR, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkPhysicalDevicePushDescriptorPropertiesKHR where + type FieldType "sType" VkPhysicalDevicePushDescriptorPropertiesKHR + = VkStructureType + type FieldOptional "sType" + VkPhysicalDevicePushDescriptorPropertiesKHR + = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" + VkPhysicalDevicePushDescriptorPropertiesKHR + = + #{offset VkPhysicalDevicePushDescriptorPropertiesKHR, sType} + type FieldIsArray "sType" + VkPhysicalDevicePushDescriptorPropertiesKHR + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDevicePushDescriptorPropertiesKHR, sType} + +instance CanReadField "sType" + VkPhysicalDevicePushDescriptorPropertiesKHR + where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" + VkPhysicalDevicePushDescriptorPropertiesKHR + where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkPhysicalDevicePushDescriptorPropertiesKHR where + type VkPNextMType VkPhysicalDevicePushDescriptorPropertiesKHR = + Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDevicePushDescriptorPropertiesKHR, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkPhysicalDevicePushDescriptorPropertiesKHR, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkPhysicalDevicePushDescriptorPropertiesKHR, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkPhysicalDevicePushDescriptorPropertiesKHR, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkPhysicalDevicePushDescriptorPropertiesKHR where + type FieldType "pNext" VkPhysicalDevicePushDescriptorPropertiesKHR + = Ptr Void + type FieldOptional "pNext" + VkPhysicalDevicePushDescriptorPropertiesKHR + = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" + VkPhysicalDevicePushDescriptorPropertiesKHR + = + #{offset VkPhysicalDevicePushDescriptorPropertiesKHR, pNext} + type FieldIsArray "pNext" + VkPhysicalDevicePushDescriptorPropertiesKHR + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDevicePushDescriptorPropertiesKHR, pNext} + +instance CanReadField "pNext" + VkPhysicalDevicePushDescriptorPropertiesKHR + where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" + VkPhysicalDevicePushDescriptorPropertiesKHR + where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkMaxPushDescriptors VkPhysicalDevicePushDescriptorPropertiesKHR + where + type VkMaxPushDescriptorsMType + VkPhysicalDevicePushDescriptorPropertiesKHR + = Word32 + + {-# NOINLINE vkMaxPushDescriptors #-} + vkMaxPushDescriptors x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDevicePushDescriptorPropertiesKHR, maxPushDescriptors}) + + {-# INLINE vkMaxPushDescriptorsByteOffset #-} + vkMaxPushDescriptorsByteOffset ~_ + = #{offset VkPhysicalDevicePushDescriptorPropertiesKHR, maxPushDescriptors} + + {-# INLINE readVkMaxPushDescriptors #-} + readVkMaxPushDescriptors p + = peekByteOff p #{offset VkPhysicalDevicePushDescriptorPropertiesKHR, maxPushDescriptors} + + {-# INLINE writeVkMaxPushDescriptors #-} + writeVkMaxPushDescriptors p + = pokeByteOff p #{offset VkPhysicalDevicePushDescriptorPropertiesKHR, maxPushDescriptors} + +instance {-# OVERLAPPING #-} + HasField "maxPushDescriptors" + VkPhysicalDevicePushDescriptorPropertiesKHR + where + type FieldType "maxPushDescriptors" + VkPhysicalDevicePushDescriptorPropertiesKHR + = Word32 + type FieldOptional "maxPushDescriptors" + VkPhysicalDevicePushDescriptorPropertiesKHR + = 'False -- ' closing tick for hsc2hs + type FieldOffset "maxPushDescriptors" + VkPhysicalDevicePushDescriptorPropertiesKHR + = + #{offset VkPhysicalDevicePushDescriptorPropertiesKHR, maxPushDescriptors} + type FieldIsArray "maxPushDescriptors" + VkPhysicalDevicePushDescriptorPropertiesKHR + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDevicePushDescriptorPropertiesKHR, maxPushDescriptors} + +instance CanReadField "maxPushDescriptors" + VkPhysicalDevicePushDescriptorPropertiesKHR + where + {-# INLINE getField #-} + getField = vkMaxPushDescriptors + + {-# INLINE readField #-} + readField = readVkMaxPushDescriptors + +instance CanWriteField "maxPushDescriptors" + VkPhysicalDevicePushDescriptorPropertiesKHR + where + {-# INLINE writeField #-} + writeField = writeVkMaxPushDescriptors + +instance Show VkPhysicalDevicePushDescriptorPropertiesKHR where + showsPrec d x + = showString "VkPhysicalDevicePushDescriptorPropertiesKHR {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkMaxPushDescriptors = " . + showsPrec d (vkMaxPushDescriptors x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkPhysicalDeviceSampleLocationsPropertiesEXT.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkPhysicalDeviceSampleLocationsPropertiesEXT.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkPhysicalDeviceSampleLocationsPropertiesEXT.hsc @@ -0,0 +1,560 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleContexts #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE ScopedTypeVariables #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +{-# LANGUAGE UndecidableInstances #-} +module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceSampleLocationsPropertiesEXT + (VkPhysicalDeviceSampleLocationsPropertiesEXT(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import GHC.TypeLits (KnownNat, + natVal') -- ' closing tick for hsc2hs +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.BaseTypes (VkBool32) +import Graphics.Vulkan.Types.Enum.VkSampleCountFlags (VkSampleCountFlags) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Struct.VkExtent2D (VkExtent2D) +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceProperties2KHR (VkPhysicalDeviceProperties2KHR) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkPhysicalDeviceSampleLocationsPropertiesEXT { +-- > VkStructureType sType; +-- > void* pNext; +-- > VkSampleCountFlags sampleLocationSampleCounts; +-- > VkExtent2D maxSampleLocationGridSize; +-- > float sampleLocationCoordinateRange[2]; +-- > uint32_t sampleLocationSubPixelBits; +-- > VkBool32 variableSampleLocations; +-- > } VkPhysicalDeviceSampleLocationsPropertiesEXT; +-- +-- +data VkPhysicalDeviceSampleLocationsPropertiesEXT = VkPhysicalDeviceSampleLocationsPropertiesEXT## Addr## + ByteArray## + +instance Eq VkPhysicalDeviceSampleLocationsPropertiesEXT where + (VkPhysicalDeviceSampleLocationsPropertiesEXT## a _) == + x@(VkPhysicalDeviceSampleLocationsPropertiesEXT## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkPhysicalDeviceSampleLocationsPropertiesEXT where + (VkPhysicalDeviceSampleLocationsPropertiesEXT## a _) `compare` + x@(VkPhysicalDeviceSampleLocationsPropertiesEXT## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkPhysicalDeviceSampleLocationsPropertiesEXT + where + sizeOf ~_ + = #{size VkPhysicalDeviceSampleLocationsPropertiesEXT} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkPhysicalDeviceSampleLocationsPropertiesEXT} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim + VkPhysicalDeviceSampleLocationsPropertiesEXT + where + unsafeAddr (VkPhysicalDeviceSampleLocationsPropertiesEXT## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkPhysicalDeviceSampleLocationsPropertiesEXT## _ b) + = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkPhysicalDeviceSampleLocationsPropertiesEXT## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkPhysicalDeviceSampleLocationsPropertiesEXT + where + type StructFields VkPhysicalDeviceSampleLocationsPropertiesEXT = + '["sType", "pNext", "sampleLocationSampleCounts", -- ' closing tick for hsc2hs + "maxSampleLocationGridSize", "sampleLocationCoordinateRange", + "sampleLocationSubPixelBits", "variableSampleLocations"] + type CUnionType VkPhysicalDeviceSampleLocationsPropertiesEXT = + 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkPhysicalDeviceSampleLocationsPropertiesEXT = + 'True -- ' closing tick for hsc2hs + type StructExtends VkPhysicalDeviceSampleLocationsPropertiesEXT = + '[VkPhysicalDeviceProperties2KHR] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkPhysicalDeviceSampleLocationsPropertiesEXT where + type VkSTypeMType VkPhysicalDeviceSampleLocationsPropertiesEXT = + VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceSampleLocationsPropertiesEXT, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkPhysicalDeviceSampleLocationsPropertiesEXT, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkPhysicalDeviceSampleLocationsPropertiesEXT, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkPhysicalDeviceSampleLocationsPropertiesEXT, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkPhysicalDeviceSampleLocationsPropertiesEXT where + type FieldType "sType" VkPhysicalDeviceSampleLocationsPropertiesEXT + = VkStructureType + type FieldOptional "sType" + VkPhysicalDeviceSampleLocationsPropertiesEXT + = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" + VkPhysicalDeviceSampleLocationsPropertiesEXT + = + #{offset VkPhysicalDeviceSampleLocationsPropertiesEXT, sType} + type FieldIsArray "sType" + VkPhysicalDeviceSampleLocationsPropertiesEXT + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceSampleLocationsPropertiesEXT, sType} + +instance CanReadField "sType" + VkPhysicalDeviceSampleLocationsPropertiesEXT + where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkPhysicalDeviceSampleLocationsPropertiesEXT where + type VkPNextMType VkPhysicalDeviceSampleLocationsPropertiesEXT = + Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceSampleLocationsPropertiesEXT, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkPhysicalDeviceSampleLocationsPropertiesEXT, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkPhysicalDeviceSampleLocationsPropertiesEXT, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkPhysicalDeviceSampleLocationsPropertiesEXT, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkPhysicalDeviceSampleLocationsPropertiesEXT where + type FieldType "pNext" VkPhysicalDeviceSampleLocationsPropertiesEXT + = Ptr Void + type FieldOptional "pNext" + VkPhysicalDeviceSampleLocationsPropertiesEXT + = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" + VkPhysicalDeviceSampleLocationsPropertiesEXT + = + #{offset VkPhysicalDeviceSampleLocationsPropertiesEXT, pNext} + type FieldIsArray "pNext" + VkPhysicalDeviceSampleLocationsPropertiesEXT + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceSampleLocationsPropertiesEXT, pNext} + +instance CanReadField "pNext" + VkPhysicalDeviceSampleLocationsPropertiesEXT + where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance {-# OVERLAPPING #-} + HasVkSampleLocationSampleCounts + VkPhysicalDeviceSampleLocationsPropertiesEXT + where + type VkSampleLocationSampleCountsMType + VkPhysicalDeviceSampleLocationsPropertiesEXT + = VkSampleCountFlags + + {-# NOINLINE vkSampleLocationSampleCounts #-} + vkSampleLocationSampleCounts x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceSampleLocationsPropertiesEXT, sampleLocationSampleCounts}) + + {-# INLINE vkSampleLocationSampleCountsByteOffset #-} + vkSampleLocationSampleCountsByteOffset ~_ + = #{offset VkPhysicalDeviceSampleLocationsPropertiesEXT, sampleLocationSampleCounts} + + {-# INLINE readVkSampleLocationSampleCounts #-} + readVkSampleLocationSampleCounts p + = peekByteOff p #{offset VkPhysicalDeviceSampleLocationsPropertiesEXT, sampleLocationSampleCounts} + + {-# INLINE writeVkSampleLocationSampleCounts #-} + writeVkSampleLocationSampleCounts p + = pokeByteOff p #{offset VkPhysicalDeviceSampleLocationsPropertiesEXT, sampleLocationSampleCounts} + +instance {-# OVERLAPPING #-} + HasField "sampleLocationSampleCounts" + VkPhysicalDeviceSampleLocationsPropertiesEXT + where + type FieldType "sampleLocationSampleCounts" + VkPhysicalDeviceSampleLocationsPropertiesEXT + = VkSampleCountFlags + type FieldOptional "sampleLocationSampleCounts" + VkPhysicalDeviceSampleLocationsPropertiesEXT + = 'False -- ' closing tick for hsc2hs + type FieldOffset "sampleLocationSampleCounts" + VkPhysicalDeviceSampleLocationsPropertiesEXT + = + #{offset VkPhysicalDeviceSampleLocationsPropertiesEXT, sampleLocationSampleCounts} + type FieldIsArray "sampleLocationSampleCounts" + VkPhysicalDeviceSampleLocationsPropertiesEXT + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceSampleLocationsPropertiesEXT, sampleLocationSampleCounts} + +instance CanReadField "sampleLocationSampleCounts" + VkPhysicalDeviceSampleLocationsPropertiesEXT + where + {-# INLINE getField #-} + getField = vkSampleLocationSampleCounts + + {-# INLINE readField #-} + readField = readVkSampleLocationSampleCounts + +instance {-# OVERLAPPING #-} + HasVkMaxSampleLocationGridSize + VkPhysicalDeviceSampleLocationsPropertiesEXT + where + type VkMaxSampleLocationGridSizeMType + VkPhysicalDeviceSampleLocationsPropertiesEXT + = VkExtent2D + + {-# NOINLINE vkMaxSampleLocationGridSize #-} + vkMaxSampleLocationGridSize x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceSampleLocationsPropertiesEXT, maxSampleLocationGridSize}) + + {-# INLINE vkMaxSampleLocationGridSizeByteOffset #-} + vkMaxSampleLocationGridSizeByteOffset ~_ + = #{offset VkPhysicalDeviceSampleLocationsPropertiesEXT, maxSampleLocationGridSize} + + {-# INLINE readVkMaxSampleLocationGridSize #-} + readVkMaxSampleLocationGridSize p + = peekByteOff p #{offset VkPhysicalDeviceSampleLocationsPropertiesEXT, maxSampleLocationGridSize} + + {-# INLINE writeVkMaxSampleLocationGridSize #-} + writeVkMaxSampleLocationGridSize p + = pokeByteOff p #{offset VkPhysicalDeviceSampleLocationsPropertiesEXT, maxSampleLocationGridSize} + +instance {-# OVERLAPPING #-} + HasField "maxSampleLocationGridSize" + VkPhysicalDeviceSampleLocationsPropertiesEXT + where + type FieldType "maxSampleLocationGridSize" + VkPhysicalDeviceSampleLocationsPropertiesEXT + = VkExtent2D + type FieldOptional "maxSampleLocationGridSize" + VkPhysicalDeviceSampleLocationsPropertiesEXT + = 'False -- ' closing tick for hsc2hs + type FieldOffset "maxSampleLocationGridSize" + VkPhysicalDeviceSampleLocationsPropertiesEXT + = + #{offset VkPhysicalDeviceSampleLocationsPropertiesEXT, maxSampleLocationGridSize} + type FieldIsArray "maxSampleLocationGridSize" + VkPhysicalDeviceSampleLocationsPropertiesEXT + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceSampleLocationsPropertiesEXT, maxSampleLocationGridSize} + +instance CanReadField "maxSampleLocationGridSize" + VkPhysicalDeviceSampleLocationsPropertiesEXT + where + {-# INLINE getField #-} + getField = vkMaxSampleLocationGridSize + + {-# INLINE readField #-} + readField = readVkMaxSampleLocationGridSize + +instance {-# OVERLAPPING #-} + HasVkSampleLocationCoordinateRangeArray + VkPhysicalDeviceSampleLocationsPropertiesEXT + where + type VkSampleLocationCoordinateRangeArrayMType + VkPhysicalDeviceSampleLocationsPropertiesEXT + = #{type float} + + {-# NOINLINE vkSampleLocationCoordinateRangeArray #-} + vkSampleLocationCoordinateRangeArray x idx + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) + (idx * sizeOf (undefined :: #{type float}) + + #{offset VkPhysicalDeviceSampleLocationsPropertiesEXT, sampleLocationCoordinateRange})) + + {-# INLINE vkSampleLocationCoordinateRangeArrayByteOffset #-} + vkSampleLocationCoordinateRangeArrayByteOffset ~_ + = #{offset VkPhysicalDeviceSampleLocationsPropertiesEXT, sampleLocationCoordinateRange} + + {-# INLINE readVkSampleLocationCoordinateRangeArray #-} + readVkSampleLocationCoordinateRangeArray p idx + = peekByteOff p + (idx * sizeOf (undefined :: #{type float}) + + #{offset VkPhysicalDeviceSampleLocationsPropertiesEXT, sampleLocationCoordinateRange}) + + {-# INLINE writeVkSampleLocationCoordinateRangeArray #-} + writeVkSampleLocationCoordinateRangeArray p idx + = pokeByteOff p + (idx * sizeOf (undefined :: #{type float}) + + #{offset VkPhysicalDeviceSampleLocationsPropertiesEXT, sampleLocationCoordinateRange}) + +instance {-# OVERLAPPING #-} + HasField "sampleLocationCoordinateRange" + VkPhysicalDeviceSampleLocationsPropertiesEXT + where + type FieldType "sampleLocationCoordinateRange" + VkPhysicalDeviceSampleLocationsPropertiesEXT + = #{type float} + type FieldOptional "sampleLocationCoordinateRange" + VkPhysicalDeviceSampleLocationsPropertiesEXT + = 'False -- ' closing tick for hsc2hs + type FieldOffset "sampleLocationCoordinateRange" + VkPhysicalDeviceSampleLocationsPropertiesEXT + = + #{offset VkPhysicalDeviceSampleLocationsPropertiesEXT, sampleLocationCoordinateRange} + type FieldIsArray "sampleLocationCoordinateRange" + VkPhysicalDeviceSampleLocationsPropertiesEXT + = 'True -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceSampleLocationsPropertiesEXT, sampleLocationCoordinateRange} + +instance (KnownNat idx, + IndexInBounds "sampleLocationCoordinateRange" idx + VkPhysicalDeviceSampleLocationsPropertiesEXT) => + CanReadFieldArray "sampleLocationCoordinateRange" idx + VkPhysicalDeviceSampleLocationsPropertiesEXT + where + {-# SPECIALISE instance + CanReadFieldArray "sampleLocationCoordinateRange" 0 + VkPhysicalDeviceSampleLocationsPropertiesEXT + #-} + + {-# SPECIALISE instance + CanReadFieldArray "sampleLocationCoordinateRange" 1 + VkPhysicalDeviceSampleLocationsPropertiesEXT + #-} + type FieldArrayLength "sampleLocationCoordinateRange" + VkPhysicalDeviceSampleLocationsPropertiesEXT + = 2 + + {-# INLINE fieldArrayLength #-} + fieldArrayLength = 2 + + {-# INLINE getFieldArray #-} + getFieldArray x + = vkSampleLocationCoordinateRangeArray x + (fromInteger $ natVal' (proxy## :: Proxy## idx)) -- ' closing tick for hsc2hs + + {-# INLINE readFieldArray #-} + readFieldArray x + = readVkSampleLocationCoordinateRangeArray x + (fromInteger $ natVal' (proxy## :: Proxy## idx)) -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSampleLocationSubPixelBits + VkPhysicalDeviceSampleLocationsPropertiesEXT + where + type VkSampleLocationSubPixelBitsMType + VkPhysicalDeviceSampleLocationsPropertiesEXT + = Word32 + + {-# NOINLINE vkSampleLocationSubPixelBits #-} + vkSampleLocationSubPixelBits x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceSampleLocationsPropertiesEXT, sampleLocationSubPixelBits}) + + {-# INLINE vkSampleLocationSubPixelBitsByteOffset #-} + vkSampleLocationSubPixelBitsByteOffset ~_ + = #{offset VkPhysicalDeviceSampleLocationsPropertiesEXT, sampleLocationSubPixelBits} + + {-# INLINE readVkSampleLocationSubPixelBits #-} + readVkSampleLocationSubPixelBits p + = peekByteOff p #{offset VkPhysicalDeviceSampleLocationsPropertiesEXT, sampleLocationSubPixelBits} + + {-# INLINE writeVkSampleLocationSubPixelBits #-} + writeVkSampleLocationSubPixelBits p + = pokeByteOff p #{offset VkPhysicalDeviceSampleLocationsPropertiesEXT, sampleLocationSubPixelBits} + +instance {-# OVERLAPPING #-} + HasField "sampleLocationSubPixelBits" + VkPhysicalDeviceSampleLocationsPropertiesEXT + where + type FieldType "sampleLocationSubPixelBits" + VkPhysicalDeviceSampleLocationsPropertiesEXT + = Word32 + type FieldOptional "sampleLocationSubPixelBits" + VkPhysicalDeviceSampleLocationsPropertiesEXT + = 'False -- ' closing tick for hsc2hs + type FieldOffset "sampleLocationSubPixelBits" + VkPhysicalDeviceSampleLocationsPropertiesEXT + = + #{offset VkPhysicalDeviceSampleLocationsPropertiesEXT, sampleLocationSubPixelBits} + type FieldIsArray "sampleLocationSubPixelBits" + VkPhysicalDeviceSampleLocationsPropertiesEXT + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceSampleLocationsPropertiesEXT, sampleLocationSubPixelBits} + +instance CanReadField "sampleLocationSubPixelBits" + VkPhysicalDeviceSampleLocationsPropertiesEXT + where + {-# INLINE getField #-} + getField = vkSampleLocationSubPixelBits + + {-# INLINE readField #-} + readField = readVkSampleLocationSubPixelBits + +instance {-# OVERLAPPING #-} + HasVkVariableSampleLocations + VkPhysicalDeviceSampleLocationsPropertiesEXT + where + type VkVariableSampleLocationsMType + VkPhysicalDeviceSampleLocationsPropertiesEXT + = VkBool32 + + {-# NOINLINE vkVariableSampleLocations #-} + vkVariableSampleLocations x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceSampleLocationsPropertiesEXT, variableSampleLocations}) + + {-# INLINE vkVariableSampleLocationsByteOffset #-} + vkVariableSampleLocationsByteOffset ~_ + = #{offset VkPhysicalDeviceSampleLocationsPropertiesEXT, variableSampleLocations} + + {-# INLINE readVkVariableSampleLocations #-} + readVkVariableSampleLocations p + = peekByteOff p #{offset VkPhysicalDeviceSampleLocationsPropertiesEXT, variableSampleLocations} + + {-# INLINE writeVkVariableSampleLocations #-} + writeVkVariableSampleLocations p + = pokeByteOff p #{offset VkPhysicalDeviceSampleLocationsPropertiesEXT, variableSampleLocations} + +instance {-# OVERLAPPING #-} + HasField "variableSampleLocations" + VkPhysicalDeviceSampleLocationsPropertiesEXT + where + type FieldType "variableSampleLocations" + VkPhysicalDeviceSampleLocationsPropertiesEXT + = VkBool32 + type FieldOptional "variableSampleLocations" + VkPhysicalDeviceSampleLocationsPropertiesEXT + = 'False -- ' closing tick for hsc2hs + type FieldOffset "variableSampleLocations" + VkPhysicalDeviceSampleLocationsPropertiesEXT + = + #{offset VkPhysicalDeviceSampleLocationsPropertiesEXT, variableSampleLocations} + type FieldIsArray "variableSampleLocations" + VkPhysicalDeviceSampleLocationsPropertiesEXT + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceSampleLocationsPropertiesEXT, variableSampleLocations} + +instance CanReadField "variableSampleLocations" + VkPhysicalDeviceSampleLocationsPropertiesEXT + where + {-# INLINE getField #-} + getField = vkVariableSampleLocations + + {-# INLINE readField #-} + readField = readVkVariableSampleLocations + +instance Show VkPhysicalDeviceSampleLocationsPropertiesEXT where + showsPrec d x + = showString "VkPhysicalDeviceSampleLocationsPropertiesEXT {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkSampleLocationSampleCounts = " . + showsPrec d (vkSampleLocationSampleCounts x) . + showString ", " . + showString "vkMaxSampleLocationGridSize = " . + showsPrec d (vkMaxSampleLocationGridSize x) . + showString ", " . + showString "vkSampleLocationCoordinateRangeArray = [" . + showsPrec d + (map (vkSampleLocationCoordinateRangeArray x) [1 .. 2]) + . + showChar ']' . + showString ", " . + showString "vkSampleLocationSubPixelBits = " . + showsPrec d (vkSampleLocationSubPixelBits x) . + showString ", " . + showString "vkVariableSampleLocations = " . + showsPrec d (vkVariableSampleLocations x) . + showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT.hsc @@ -0,0 +1,337 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT + (VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.BaseTypes (VkBool32) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceProperties2KHR (VkPhysicalDeviceProperties2KHR) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT { +-- > VkStructureType sType; +-- > void* pNext; +-- > VkBool32 filterMinmaxSingleComponentFormats; +-- > VkBool32 filterMinmaxImageComponentMapping; +-- > } VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT; +-- +-- +data VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT = VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT## Addr## + ByteArray## + +instance Eq VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT where + (VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT## a _) == + x@(VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT where + (VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT## a _) `compare` + x@(VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT + where + sizeOf ~_ + = #{size VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim + VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT + where + unsafeAddr (VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT## a _) + = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray + (VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal + VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT + where + type StructFields VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT + = + '["sType", "pNext", "filterMinmaxSingleComponentFormats", -- ' closing tick for hsc2hs + "filterMinmaxImageComponentMapping"] + type CUnionType VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT = + 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT + = 'True -- ' closing tick for hsc2hs + type StructExtends VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT + = '[VkPhysicalDeviceProperties2KHR] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT where + type VkSTypeMType VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT + = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT + where + type FieldType "sType" + VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT + = VkStructureType + type FieldOptional "sType" + VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT + = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" + VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT + = + #{offset VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT, sType} + type FieldIsArray "sType" + VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT, sType} + +instance CanReadField "sType" + VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT + where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT where + type VkPNextMType VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT + = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT + where + type FieldType "pNext" + VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT + = Ptr Void + type FieldOptional "pNext" + VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT + = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" + VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT + = + #{offset VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT, pNext} + type FieldIsArray "pNext" + VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT, pNext} + +instance CanReadField "pNext" + VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT + where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance {-# OVERLAPPING #-} + HasVkFilterMinmaxSingleComponentFormats + VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT + where + type VkFilterMinmaxSingleComponentFormatsMType + VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT + = VkBool32 + + {-# NOINLINE vkFilterMinmaxSingleComponentFormats #-} + vkFilterMinmaxSingleComponentFormats x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT, filterMinmaxSingleComponentFormats}) + + {-# INLINE vkFilterMinmaxSingleComponentFormatsByteOffset #-} + vkFilterMinmaxSingleComponentFormatsByteOffset ~_ + = #{offset VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT, filterMinmaxSingleComponentFormats} + + {-# INLINE readVkFilterMinmaxSingleComponentFormats #-} + readVkFilterMinmaxSingleComponentFormats p + = peekByteOff p #{offset VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT, filterMinmaxSingleComponentFormats} + + {-# INLINE writeVkFilterMinmaxSingleComponentFormats #-} + writeVkFilterMinmaxSingleComponentFormats p + = pokeByteOff p #{offset VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT, filterMinmaxSingleComponentFormats} + +instance {-# OVERLAPPING #-} + HasField "filterMinmaxSingleComponentFormats" + VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT + where + type FieldType "filterMinmaxSingleComponentFormats" + VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT + = VkBool32 + type FieldOptional "filterMinmaxSingleComponentFormats" + VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT + = 'False -- ' closing tick for hsc2hs + type FieldOffset "filterMinmaxSingleComponentFormats" + VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT + = + #{offset VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT, filterMinmaxSingleComponentFormats} + type FieldIsArray "filterMinmaxSingleComponentFormats" + VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT, filterMinmaxSingleComponentFormats} + +instance CanReadField "filterMinmaxSingleComponentFormats" + VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT + where + {-# INLINE getField #-} + getField = vkFilterMinmaxSingleComponentFormats + + {-# INLINE readField #-} + readField = readVkFilterMinmaxSingleComponentFormats + +instance {-# OVERLAPPING #-} + HasVkFilterMinmaxImageComponentMapping + VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT + where + type VkFilterMinmaxImageComponentMappingMType + VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT + = VkBool32 + + {-# NOINLINE vkFilterMinmaxImageComponentMapping #-} + vkFilterMinmaxImageComponentMapping x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT, filterMinmaxImageComponentMapping}) + + {-# INLINE vkFilterMinmaxImageComponentMappingByteOffset #-} + vkFilterMinmaxImageComponentMappingByteOffset ~_ + = #{offset VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT, filterMinmaxImageComponentMapping} + + {-# INLINE readVkFilterMinmaxImageComponentMapping #-} + readVkFilterMinmaxImageComponentMapping p + = peekByteOff p #{offset VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT, filterMinmaxImageComponentMapping} + + {-# INLINE writeVkFilterMinmaxImageComponentMapping #-} + writeVkFilterMinmaxImageComponentMapping p + = pokeByteOff p #{offset VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT, filterMinmaxImageComponentMapping} + +instance {-# OVERLAPPING #-} + HasField "filterMinmaxImageComponentMapping" + VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT + where + type FieldType "filterMinmaxImageComponentMapping" + VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT + = VkBool32 + type FieldOptional "filterMinmaxImageComponentMapping" + VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT + = 'False -- ' closing tick for hsc2hs + type FieldOffset "filterMinmaxImageComponentMapping" + VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT + = + #{offset VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT, filterMinmaxImageComponentMapping} + type FieldIsArray "filterMinmaxImageComponentMapping" + VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT, filterMinmaxImageComponentMapping} + +instance CanReadField "filterMinmaxImageComponentMapping" + VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT + where + {-# INLINE getField #-} + getField = vkFilterMinmaxImageComponentMapping + + {-# INLINE readField #-} + readField = readVkFilterMinmaxImageComponentMapping + +instance Show VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT + where + showsPrec d x + = showString "VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkFilterMinmaxSingleComponentFormats = " . + showsPrec d (vkFilterMinmaxSingleComponentFormats x) . + showString ", " . + showString "vkFilterMinmaxImageComponentMapping = " . + showsPrec d (vkFilterMinmaxImageComponentMapping x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR.hsc @@ -0,0 +1,294 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR + (VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.BaseTypes (VkBool32) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Struct.VkDeviceCreateInfo (VkDeviceCreateInfo) +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceFeatures2KHR (VkPhysicalDeviceFeatures2KHR) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR { +-- > VkStructureType sType; +-- > void* pNext; +-- > VkBool32 samplerYcbcrConversion; +-- > } VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR; +-- +-- +data VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR = VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR## Addr## + ByteArray## + +instance Eq VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR where + (VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR## a _) == + x@(VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR + where + (VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR## a _) `compare` + x@(VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR + where + sizeOf ~_ + = #{size VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim + VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR + where + unsafeAddr (VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR## a _) + = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray + (VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal + VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR + where + type StructFields VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR + = '["sType", "pNext", "samplerYcbcrConversion"] -- ' closing tick for hsc2hs + type CUnionType VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR = + 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR + = 'False -- ' closing tick for hsc2hs + type StructExtends + VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR + = '[VkPhysicalDeviceFeatures2KHR, VkDeviceCreateInfo] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR where + type VkSTypeMType VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR + = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR + where + type FieldType "sType" + VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR + = VkStructureType + type FieldOptional "sType" + VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR + = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" + VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR + = + #{offset VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR, sType} + type FieldIsArray "sType" + VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR, sType} + +instance CanReadField "sType" + VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR + where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" + VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR + where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR where + type VkPNextMType VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR + = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR + where + type FieldType "pNext" + VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR + = Ptr Void + type FieldOptional "pNext" + VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR + = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" + VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR + = + #{offset VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR, pNext} + type FieldIsArray "pNext" + VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR, pNext} + +instance CanReadField "pNext" + VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR + where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" + VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR + where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkSamplerYcbcrConversion + VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR + where + type VkSamplerYcbcrConversionMType + VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR + = VkBool32 + + {-# NOINLINE vkSamplerYcbcrConversion #-} + vkSamplerYcbcrConversion x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR, samplerYcbcrConversion}) + + {-# INLINE vkSamplerYcbcrConversionByteOffset #-} + vkSamplerYcbcrConversionByteOffset ~_ + = #{offset VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR, samplerYcbcrConversion} + + {-# INLINE readVkSamplerYcbcrConversion #-} + readVkSamplerYcbcrConversion p + = peekByteOff p #{offset VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR, samplerYcbcrConversion} + + {-# INLINE writeVkSamplerYcbcrConversion #-} + writeVkSamplerYcbcrConversion p + = pokeByteOff p #{offset VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR, samplerYcbcrConversion} + +instance {-# OVERLAPPING #-} + HasField "samplerYcbcrConversion" + VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR + where + type FieldType "samplerYcbcrConversion" + VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR + = VkBool32 + type FieldOptional "samplerYcbcrConversion" + VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR + = 'False -- ' closing tick for hsc2hs + type FieldOffset "samplerYcbcrConversion" + VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR + = + #{offset VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR, samplerYcbcrConversion} + type FieldIsArray "samplerYcbcrConversion" + VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR, samplerYcbcrConversion} + +instance CanReadField "samplerYcbcrConversion" + VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR + where + {-# INLINE getField #-} + getField = vkSamplerYcbcrConversion + + {-# INLINE readField #-} + readField = readVkSamplerYcbcrConversion + +instance CanWriteField "samplerYcbcrConversion" + VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR + where + {-# INLINE writeField #-} + writeField = writeVkSamplerYcbcrConversion + +instance Show VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR + where + showsPrec d x + = showString "VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR {" + . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkSamplerYcbcrConversion = " . + showsPrec d (vkSamplerYcbcrConversion x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkPhysicalDeviceSparseImageFormatInfo2KHR.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkPhysicalDeviceSparseImageFormatInfo2KHR.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkPhysicalDeviceSparseImageFormatInfo2KHR.hsc @@ -0,0 +1,517 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceSparseImageFormatInfo2KHR + (VkPhysicalDeviceSparseImageFormatInfo2KHR(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkFormat (VkFormat) +import Graphics.Vulkan.Types.Enum.VkImageTiling (VkImageTiling) +import Graphics.Vulkan.Types.Enum.VkImageType (VkImageType) +import Graphics.Vulkan.Types.Enum.VkImageUsageFlags (VkImageUsageFlags) +import Graphics.Vulkan.Types.Enum.VkSampleCountFlags (VkSampleCountFlagBits) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkPhysicalDeviceSparseImageFormatInfo2KHR { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkFormat format; +-- > VkImageType type; +-- > VkSampleCountFlagBits samples; +-- > VkImageUsageFlags usage; +-- > VkImageTiling tiling; +-- > } VkPhysicalDeviceSparseImageFormatInfo2KHR; +-- +-- +data VkPhysicalDeviceSparseImageFormatInfo2KHR = VkPhysicalDeviceSparseImageFormatInfo2KHR## Addr## + ByteArray## + +instance Eq VkPhysicalDeviceSparseImageFormatInfo2KHR where + (VkPhysicalDeviceSparseImageFormatInfo2KHR## a _) == + x@(VkPhysicalDeviceSparseImageFormatInfo2KHR## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkPhysicalDeviceSparseImageFormatInfo2KHR where + (VkPhysicalDeviceSparseImageFormatInfo2KHR## a _) `compare` + x@(VkPhysicalDeviceSparseImageFormatInfo2KHR## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkPhysicalDeviceSparseImageFormatInfo2KHR where + sizeOf ~_ + = #{size VkPhysicalDeviceSparseImageFormatInfo2KHR} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkPhysicalDeviceSparseImageFormatInfo2KHR} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim + VkPhysicalDeviceSparseImageFormatInfo2KHR + where + unsafeAddr (VkPhysicalDeviceSparseImageFormatInfo2KHR## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkPhysicalDeviceSparseImageFormatInfo2KHR## _ b) + = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkPhysicalDeviceSparseImageFormatInfo2KHR## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkPhysicalDeviceSparseImageFormatInfo2KHR + where + type StructFields VkPhysicalDeviceSparseImageFormatInfo2KHR = + '["sType", "pNext", "format", "type", "samples", "usage", "tiling"] -- ' closing tick for hsc2hs + type CUnionType VkPhysicalDeviceSparseImageFormatInfo2KHR = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkPhysicalDeviceSparseImageFormatInfo2KHR = + 'False -- ' closing tick for hsc2hs + type StructExtends VkPhysicalDeviceSparseImageFormatInfo2KHR = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkPhysicalDeviceSparseImageFormatInfo2KHR where + type VkSTypeMType VkPhysicalDeviceSparseImageFormatInfo2KHR = + VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceSparseImageFormatInfo2KHR, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkPhysicalDeviceSparseImageFormatInfo2KHR, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkPhysicalDeviceSparseImageFormatInfo2KHR, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkPhysicalDeviceSparseImageFormatInfo2KHR, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkPhysicalDeviceSparseImageFormatInfo2KHR where + type FieldType "sType" VkPhysicalDeviceSparseImageFormatInfo2KHR = + VkStructureType + type FieldOptional "sType" + VkPhysicalDeviceSparseImageFormatInfo2KHR + = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkPhysicalDeviceSparseImageFormatInfo2KHR + = + #{offset VkPhysicalDeviceSparseImageFormatInfo2KHR, sType} + type FieldIsArray "sType" VkPhysicalDeviceSparseImageFormatInfo2KHR + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceSparseImageFormatInfo2KHR, sType} + +instance CanReadField "sType" + VkPhysicalDeviceSparseImageFormatInfo2KHR + where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" + VkPhysicalDeviceSparseImageFormatInfo2KHR + where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkPhysicalDeviceSparseImageFormatInfo2KHR where + type VkPNextMType VkPhysicalDeviceSparseImageFormatInfo2KHR = + Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceSparseImageFormatInfo2KHR, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkPhysicalDeviceSparseImageFormatInfo2KHR, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkPhysicalDeviceSparseImageFormatInfo2KHR, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkPhysicalDeviceSparseImageFormatInfo2KHR, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkPhysicalDeviceSparseImageFormatInfo2KHR where + type FieldType "pNext" VkPhysicalDeviceSparseImageFormatInfo2KHR = + Ptr Void + type FieldOptional "pNext" + VkPhysicalDeviceSparseImageFormatInfo2KHR + = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkPhysicalDeviceSparseImageFormatInfo2KHR + = + #{offset VkPhysicalDeviceSparseImageFormatInfo2KHR, pNext} + type FieldIsArray "pNext" VkPhysicalDeviceSparseImageFormatInfo2KHR + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceSparseImageFormatInfo2KHR, pNext} + +instance CanReadField "pNext" + VkPhysicalDeviceSparseImageFormatInfo2KHR + where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" + VkPhysicalDeviceSparseImageFormatInfo2KHR + where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkFormat VkPhysicalDeviceSparseImageFormatInfo2KHR where + type VkFormatMType VkPhysicalDeviceSparseImageFormatInfo2KHR = + VkFormat + + {-# NOINLINE vkFormat #-} + vkFormat x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceSparseImageFormatInfo2KHR, format}) + + {-# INLINE vkFormatByteOffset #-} + vkFormatByteOffset ~_ + = #{offset VkPhysicalDeviceSparseImageFormatInfo2KHR, format} + + {-# INLINE readVkFormat #-} + readVkFormat p + = peekByteOff p #{offset VkPhysicalDeviceSparseImageFormatInfo2KHR, format} + + {-# INLINE writeVkFormat #-} + writeVkFormat p + = pokeByteOff p #{offset VkPhysicalDeviceSparseImageFormatInfo2KHR, format} + +instance {-# OVERLAPPING #-} + HasField "format" VkPhysicalDeviceSparseImageFormatInfo2KHR where + type FieldType "format" VkPhysicalDeviceSparseImageFormatInfo2KHR = + VkFormat + type FieldOptional "format" + VkPhysicalDeviceSparseImageFormatInfo2KHR + = 'False -- ' closing tick for hsc2hs + type FieldOffset "format" VkPhysicalDeviceSparseImageFormatInfo2KHR + = + #{offset VkPhysicalDeviceSparseImageFormatInfo2KHR, format} + type FieldIsArray "format" + VkPhysicalDeviceSparseImageFormatInfo2KHR + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceSparseImageFormatInfo2KHR, format} + +instance CanReadField "format" + VkPhysicalDeviceSparseImageFormatInfo2KHR + where + {-# INLINE getField #-} + getField = vkFormat + + {-# INLINE readField #-} + readField = readVkFormat + +instance CanWriteField "format" + VkPhysicalDeviceSparseImageFormatInfo2KHR + where + {-# INLINE writeField #-} + writeField = writeVkFormat + +instance {-# OVERLAPPING #-} + HasVkType VkPhysicalDeviceSparseImageFormatInfo2KHR where + type VkTypeMType VkPhysicalDeviceSparseImageFormatInfo2KHR = + VkImageType + + {-# NOINLINE vkType #-} + vkType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceSparseImageFormatInfo2KHR, type}) + + {-# INLINE vkTypeByteOffset #-} + vkTypeByteOffset ~_ + = #{offset VkPhysicalDeviceSparseImageFormatInfo2KHR, type} + + {-# INLINE readVkType #-} + readVkType p + = peekByteOff p #{offset VkPhysicalDeviceSparseImageFormatInfo2KHR, type} + + {-# INLINE writeVkType #-} + writeVkType p + = pokeByteOff p #{offset VkPhysicalDeviceSparseImageFormatInfo2KHR, type} + +instance {-# OVERLAPPING #-} + HasField "type" VkPhysicalDeviceSparseImageFormatInfo2KHR where + type FieldType "type" VkPhysicalDeviceSparseImageFormatInfo2KHR = + VkImageType + type FieldOptional "type" VkPhysicalDeviceSparseImageFormatInfo2KHR + = 'False -- ' closing tick for hsc2hs + type FieldOffset "type" VkPhysicalDeviceSparseImageFormatInfo2KHR = + #{offset VkPhysicalDeviceSparseImageFormatInfo2KHR, type} + type FieldIsArray "type" VkPhysicalDeviceSparseImageFormatInfo2KHR + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceSparseImageFormatInfo2KHR, type} + +instance CanReadField "type" + VkPhysicalDeviceSparseImageFormatInfo2KHR + where + {-# INLINE getField #-} + getField = vkType + + {-# INLINE readField #-} + readField = readVkType + +instance CanWriteField "type" + VkPhysicalDeviceSparseImageFormatInfo2KHR + where + {-# INLINE writeField #-} + writeField = writeVkType + +instance {-# OVERLAPPING #-} + HasVkSamples VkPhysicalDeviceSparseImageFormatInfo2KHR where + type VkSamplesMType VkPhysicalDeviceSparseImageFormatInfo2KHR = + VkSampleCountFlagBits + + {-# NOINLINE vkSamples #-} + vkSamples x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceSparseImageFormatInfo2KHR, samples}) + + {-# INLINE vkSamplesByteOffset #-} + vkSamplesByteOffset ~_ + = #{offset VkPhysicalDeviceSparseImageFormatInfo2KHR, samples} + + {-# INLINE readVkSamples #-} + readVkSamples p + = peekByteOff p #{offset VkPhysicalDeviceSparseImageFormatInfo2KHR, samples} + + {-# INLINE writeVkSamples #-} + writeVkSamples p + = pokeByteOff p #{offset VkPhysicalDeviceSparseImageFormatInfo2KHR, samples} + +instance {-# OVERLAPPING #-} + HasField "samples" VkPhysicalDeviceSparseImageFormatInfo2KHR where + type FieldType "samples" VkPhysicalDeviceSparseImageFormatInfo2KHR + = VkSampleCountFlagBits + type FieldOptional "samples" + VkPhysicalDeviceSparseImageFormatInfo2KHR + = 'False -- ' closing tick for hsc2hs + type FieldOffset "samples" + VkPhysicalDeviceSparseImageFormatInfo2KHR + = + #{offset VkPhysicalDeviceSparseImageFormatInfo2KHR, samples} + type FieldIsArray "samples" + VkPhysicalDeviceSparseImageFormatInfo2KHR + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceSparseImageFormatInfo2KHR, samples} + +instance CanReadField "samples" + VkPhysicalDeviceSparseImageFormatInfo2KHR + where + {-# INLINE getField #-} + getField = vkSamples + + {-# INLINE readField #-} + readField = readVkSamples + +instance CanWriteField "samples" + VkPhysicalDeviceSparseImageFormatInfo2KHR + where + {-# INLINE writeField #-} + writeField = writeVkSamples + +instance {-# OVERLAPPING #-} + HasVkUsage VkPhysicalDeviceSparseImageFormatInfo2KHR where + type VkUsageMType VkPhysicalDeviceSparseImageFormatInfo2KHR = + VkImageUsageFlags + + {-# NOINLINE vkUsage #-} + vkUsage x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceSparseImageFormatInfo2KHR, usage}) + + {-# INLINE vkUsageByteOffset #-} + vkUsageByteOffset ~_ + = #{offset VkPhysicalDeviceSparseImageFormatInfo2KHR, usage} + + {-# INLINE readVkUsage #-} + readVkUsage p + = peekByteOff p #{offset VkPhysicalDeviceSparseImageFormatInfo2KHR, usage} + + {-# INLINE writeVkUsage #-} + writeVkUsage p + = pokeByteOff p #{offset VkPhysicalDeviceSparseImageFormatInfo2KHR, usage} + +instance {-# OVERLAPPING #-} + HasField "usage" VkPhysicalDeviceSparseImageFormatInfo2KHR where + type FieldType "usage" VkPhysicalDeviceSparseImageFormatInfo2KHR = + VkImageUsageFlags + type FieldOptional "usage" + VkPhysicalDeviceSparseImageFormatInfo2KHR + = 'False -- ' closing tick for hsc2hs + type FieldOffset "usage" VkPhysicalDeviceSparseImageFormatInfo2KHR + = + #{offset VkPhysicalDeviceSparseImageFormatInfo2KHR, usage} + type FieldIsArray "usage" VkPhysicalDeviceSparseImageFormatInfo2KHR + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceSparseImageFormatInfo2KHR, usage} + +instance CanReadField "usage" + VkPhysicalDeviceSparseImageFormatInfo2KHR + where + {-# INLINE getField #-} + getField = vkUsage + + {-# INLINE readField #-} + readField = readVkUsage + +instance CanWriteField "usage" + VkPhysicalDeviceSparseImageFormatInfo2KHR + where + {-# INLINE writeField #-} + writeField = writeVkUsage + +instance {-# OVERLAPPING #-} + HasVkTiling VkPhysicalDeviceSparseImageFormatInfo2KHR where + type VkTilingMType VkPhysicalDeviceSparseImageFormatInfo2KHR = + VkImageTiling + + {-# NOINLINE vkTiling #-} + vkTiling x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceSparseImageFormatInfo2KHR, tiling}) + + {-# INLINE vkTilingByteOffset #-} + vkTilingByteOffset ~_ + = #{offset VkPhysicalDeviceSparseImageFormatInfo2KHR, tiling} + + {-# INLINE readVkTiling #-} + readVkTiling p + = peekByteOff p #{offset VkPhysicalDeviceSparseImageFormatInfo2KHR, tiling} + + {-# INLINE writeVkTiling #-} + writeVkTiling p + = pokeByteOff p #{offset VkPhysicalDeviceSparseImageFormatInfo2KHR, tiling} + +instance {-# OVERLAPPING #-} + HasField "tiling" VkPhysicalDeviceSparseImageFormatInfo2KHR where + type FieldType "tiling" VkPhysicalDeviceSparseImageFormatInfo2KHR = + VkImageTiling + type FieldOptional "tiling" + VkPhysicalDeviceSparseImageFormatInfo2KHR + = 'False -- ' closing tick for hsc2hs + type FieldOffset "tiling" VkPhysicalDeviceSparseImageFormatInfo2KHR + = + #{offset VkPhysicalDeviceSparseImageFormatInfo2KHR, tiling} + type FieldIsArray "tiling" + VkPhysicalDeviceSparseImageFormatInfo2KHR + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceSparseImageFormatInfo2KHR, tiling} + +instance CanReadField "tiling" + VkPhysicalDeviceSparseImageFormatInfo2KHR + where + {-# INLINE getField #-} + getField = vkTiling + + {-# INLINE readField #-} + readField = readVkTiling + +instance CanWriteField "tiling" + VkPhysicalDeviceSparseImageFormatInfo2KHR + where + {-# INLINE writeField #-} + writeField = writeVkTiling + +instance Show VkPhysicalDeviceSparseImageFormatInfo2KHR where + showsPrec d x + = showString "VkPhysicalDeviceSparseImageFormatInfo2KHR {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkFormat = " . + showsPrec d (vkFormat x) . + showString ", " . + showString "vkType = " . + showsPrec d (vkType x) . + showString ", " . + showString "vkSamples = " . + showsPrec d (vkSamples x) . + showString ", " . + showString "vkUsage = " . + showsPrec d (vkUsage x) . + showString ", " . + showString "vkTiling = " . + showsPrec d (vkTiling x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkPhysicalDeviceSparseProperties.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkPhysicalDeviceSparseProperties.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkPhysicalDeviceSparseProperties.hsc @@ -0,0 +1,389 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceSparseProperties + (VkPhysicalDeviceSparseProperties(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.BaseTypes (VkBool32) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkPhysicalDeviceSparseProperties { +-- > VkBool32 residencyStandard2DBlockShape; +-- > VkBool32 residencyStandard2DMultisampleBlockShape; +-- > VkBool32 residencyStandard3DBlockShape; +-- > VkBool32 residencyAlignedMipSize; +-- > VkBool32 residencyNonResidentStrict; +-- > } VkPhysicalDeviceSparseProperties; +-- +-- +data VkPhysicalDeviceSparseProperties = VkPhysicalDeviceSparseProperties## Addr## + ByteArray## + +instance Eq VkPhysicalDeviceSparseProperties where + (VkPhysicalDeviceSparseProperties## a _) == + x@(VkPhysicalDeviceSparseProperties## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkPhysicalDeviceSparseProperties where + (VkPhysicalDeviceSparseProperties## a _) `compare` + x@(VkPhysicalDeviceSparseProperties## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkPhysicalDeviceSparseProperties where + sizeOf ~_ = #{size VkPhysicalDeviceSparseProperties} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkPhysicalDeviceSparseProperties} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkPhysicalDeviceSparseProperties where + unsafeAddr (VkPhysicalDeviceSparseProperties## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkPhysicalDeviceSparseProperties## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkPhysicalDeviceSparseProperties## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkPhysicalDeviceSparseProperties where + type StructFields VkPhysicalDeviceSparseProperties = + '["residencyStandard2DBlockShape", -- ' closing tick for hsc2hs + "residencyStandard2DMultisampleBlockShape", + "residencyStandard3DBlockShape", "residencyAlignedMipSize", + "residencyNonResidentStrict"] + type CUnionType VkPhysicalDeviceSparseProperties = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkPhysicalDeviceSparseProperties = 'True -- ' closing tick for hsc2hs + type StructExtends VkPhysicalDeviceSparseProperties = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkResidencyStandard2DBlockShape VkPhysicalDeviceSparseProperties + where + type VkResidencyStandard2DBlockShapeMType + VkPhysicalDeviceSparseProperties + = VkBool32 + + {-# NOINLINE vkResidencyStandard2DBlockShape #-} + vkResidencyStandard2DBlockShape x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceSparseProperties, residencyStandard2DBlockShape}) + + {-# INLINE vkResidencyStandard2DBlockShapeByteOffset #-} + vkResidencyStandard2DBlockShapeByteOffset ~_ + = #{offset VkPhysicalDeviceSparseProperties, residencyStandard2DBlockShape} + + {-# INLINE readVkResidencyStandard2DBlockShape #-} + readVkResidencyStandard2DBlockShape p + = peekByteOff p #{offset VkPhysicalDeviceSparseProperties, residencyStandard2DBlockShape} + + {-# INLINE writeVkResidencyStandard2DBlockShape #-} + writeVkResidencyStandard2DBlockShape p + = pokeByteOff p #{offset VkPhysicalDeviceSparseProperties, residencyStandard2DBlockShape} + +instance {-# OVERLAPPING #-} + HasField "residencyStandard2DBlockShape" + VkPhysicalDeviceSparseProperties + where + type FieldType "residencyStandard2DBlockShape" + VkPhysicalDeviceSparseProperties + = VkBool32 + type FieldOptional "residencyStandard2DBlockShape" + VkPhysicalDeviceSparseProperties + = 'False -- ' closing tick for hsc2hs + type FieldOffset "residencyStandard2DBlockShape" + VkPhysicalDeviceSparseProperties + = + #{offset VkPhysicalDeviceSparseProperties, residencyStandard2DBlockShape} + type FieldIsArray "residencyStandard2DBlockShape" + VkPhysicalDeviceSparseProperties + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceSparseProperties, residencyStandard2DBlockShape} + +instance CanReadField "residencyStandard2DBlockShape" + VkPhysicalDeviceSparseProperties + where + {-# INLINE getField #-} + getField = vkResidencyStandard2DBlockShape + + {-# INLINE readField #-} + readField = readVkResidencyStandard2DBlockShape + +instance {-# OVERLAPPING #-} + HasVkResidencyStandard2DMultisampleBlockShape + VkPhysicalDeviceSparseProperties + where + type VkResidencyStandard2DMultisampleBlockShapeMType + VkPhysicalDeviceSparseProperties + = VkBool32 + + {-# NOINLINE vkResidencyStandard2DMultisampleBlockShape #-} + vkResidencyStandard2DMultisampleBlockShape x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceSparseProperties, residencyStandard2DMultisampleBlockShape}) + + {-# INLINE vkResidencyStandard2DMultisampleBlockShapeByteOffset #-} + vkResidencyStandard2DMultisampleBlockShapeByteOffset ~_ + = #{offset VkPhysicalDeviceSparseProperties, residencyStandard2DMultisampleBlockShape} + + {-# INLINE readVkResidencyStandard2DMultisampleBlockShape #-} + readVkResidencyStandard2DMultisampleBlockShape p + = peekByteOff p #{offset VkPhysicalDeviceSparseProperties, residencyStandard2DMultisampleBlockShape} + + {-# INLINE writeVkResidencyStandard2DMultisampleBlockShape #-} + writeVkResidencyStandard2DMultisampleBlockShape p + = pokeByteOff p #{offset VkPhysicalDeviceSparseProperties, residencyStandard2DMultisampleBlockShape} + +instance {-# OVERLAPPING #-} + HasField "residencyStandard2DMultisampleBlockShape" + VkPhysicalDeviceSparseProperties + where + type FieldType "residencyStandard2DMultisampleBlockShape" + VkPhysicalDeviceSparseProperties + = VkBool32 + type FieldOptional "residencyStandard2DMultisampleBlockShape" + VkPhysicalDeviceSparseProperties + = 'False -- ' closing tick for hsc2hs + type FieldOffset "residencyStandard2DMultisampleBlockShape" + VkPhysicalDeviceSparseProperties + = + #{offset VkPhysicalDeviceSparseProperties, residencyStandard2DMultisampleBlockShape} + type FieldIsArray "residencyStandard2DMultisampleBlockShape" + VkPhysicalDeviceSparseProperties + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceSparseProperties, residencyStandard2DMultisampleBlockShape} + +instance CanReadField "residencyStandard2DMultisampleBlockShape" + VkPhysicalDeviceSparseProperties + where + {-# INLINE getField #-} + getField = vkResidencyStandard2DMultisampleBlockShape + + {-# INLINE readField #-} + readField = readVkResidencyStandard2DMultisampleBlockShape + +instance {-# OVERLAPPING #-} + HasVkResidencyStandard3DBlockShape VkPhysicalDeviceSparseProperties + where + type VkResidencyStandard3DBlockShapeMType + VkPhysicalDeviceSparseProperties + = VkBool32 + + {-# NOINLINE vkResidencyStandard3DBlockShape #-} + vkResidencyStandard3DBlockShape x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceSparseProperties, residencyStandard3DBlockShape}) + + {-# INLINE vkResidencyStandard3DBlockShapeByteOffset #-} + vkResidencyStandard3DBlockShapeByteOffset ~_ + = #{offset VkPhysicalDeviceSparseProperties, residencyStandard3DBlockShape} + + {-# INLINE readVkResidencyStandard3DBlockShape #-} + readVkResidencyStandard3DBlockShape p + = peekByteOff p #{offset VkPhysicalDeviceSparseProperties, residencyStandard3DBlockShape} + + {-# INLINE writeVkResidencyStandard3DBlockShape #-} + writeVkResidencyStandard3DBlockShape p + = pokeByteOff p #{offset VkPhysicalDeviceSparseProperties, residencyStandard3DBlockShape} + +instance {-# OVERLAPPING #-} + HasField "residencyStandard3DBlockShape" + VkPhysicalDeviceSparseProperties + where + type FieldType "residencyStandard3DBlockShape" + VkPhysicalDeviceSparseProperties + = VkBool32 + type FieldOptional "residencyStandard3DBlockShape" + VkPhysicalDeviceSparseProperties + = 'False -- ' closing tick for hsc2hs + type FieldOffset "residencyStandard3DBlockShape" + VkPhysicalDeviceSparseProperties + = + #{offset VkPhysicalDeviceSparseProperties, residencyStandard3DBlockShape} + type FieldIsArray "residencyStandard3DBlockShape" + VkPhysicalDeviceSparseProperties + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceSparseProperties, residencyStandard3DBlockShape} + +instance CanReadField "residencyStandard3DBlockShape" + VkPhysicalDeviceSparseProperties + where + {-# INLINE getField #-} + getField = vkResidencyStandard3DBlockShape + + {-# INLINE readField #-} + readField = readVkResidencyStandard3DBlockShape + +instance {-# OVERLAPPING #-} + HasVkResidencyAlignedMipSize VkPhysicalDeviceSparseProperties where + type VkResidencyAlignedMipSizeMType + VkPhysicalDeviceSparseProperties + = VkBool32 + + {-# NOINLINE vkResidencyAlignedMipSize #-} + vkResidencyAlignedMipSize x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceSparseProperties, residencyAlignedMipSize}) + + {-# INLINE vkResidencyAlignedMipSizeByteOffset #-} + vkResidencyAlignedMipSizeByteOffset ~_ + = #{offset VkPhysicalDeviceSparseProperties, residencyAlignedMipSize} + + {-# INLINE readVkResidencyAlignedMipSize #-} + readVkResidencyAlignedMipSize p + = peekByteOff p #{offset VkPhysicalDeviceSparseProperties, residencyAlignedMipSize} + + {-# INLINE writeVkResidencyAlignedMipSize #-} + writeVkResidencyAlignedMipSize p + = pokeByteOff p #{offset VkPhysicalDeviceSparseProperties, residencyAlignedMipSize} + +instance {-# OVERLAPPING #-} + HasField "residencyAlignedMipSize" VkPhysicalDeviceSparseProperties + where + type FieldType "residencyAlignedMipSize" + VkPhysicalDeviceSparseProperties + = VkBool32 + type FieldOptional "residencyAlignedMipSize" + VkPhysicalDeviceSparseProperties + = 'False -- ' closing tick for hsc2hs + type FieldOffset "residencyAlignedMipSize" + VkPhysicalDeviceSparseProperties + = + #{offset VkPhysicalDeviceSparseProperties, residencyAlignedMipSize} + type FieldIsArray "residencyAlignedMipSize" + VkPhysicalDeviceSparseProperties + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceSparseProperties, residencyAlignedMipSize} + +instance CanReadField "residencyAlignedMipSize" + VkPhysicalDeviceSparseProperties + where + {-# INLINE getField #-} + getField = vkResidencyAlignedMipSize + + {-# INLINE readField #-} + readField = readVkResidencyAlignedMipSize + +instance {-# OVERLAPPING #-} + HasVkResidencyNonResidentStrict VkPhysicalDeviceSparseProperties + where + type VkResidencyNonResidentStrictMType + VkPhysicalDeviceSparseProperties + = VkBool32 + + {-# NOINLINE vkResidencyNonResidentStrict #-} + vkResidencyNonResidentStrict x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceSparseProperties, residencyNonResidentStrict}) + + {-# INLINE vkResidencyNonResidentStrictByteOffset #-} + vkResidencyNonResidentStrictByteOffset ~_ + = #{offset VkPhysicalDeviceSparseProperties, residencyNonResidentStrict} + + {-# INLINE readVkResidencyNonResidentStrict #-} + readVkResidencyNonResidentStrict p + = peekByteOff p #{offset VkPhysicalDeviceSparseProperties, residencyNonResidentStrict} + + {-# INLINE writeVkResidencyNonResidentStrict #-} + writeVkResidencyNonResidentStrict p + = pokeByteOff p #{offset VkPhysicalDeviceSparseProperties, residencyNonResidentStrict} + +instance {-# OVERLAPPING #-} + HasField "residencyNonResidentStrict" + VkPhysicalDeviceSparseProperties + where + type FieldType "residencyNonResidentStrict" + VkPhysicalDeviceSparseProperties + = VkBool32 + type FieldOptional "residencyNonResidentStrict" + VkPhysicalDeviceSparseProperties + = 'False -- ' closing tick for hsc2hs + type FieldOffset "residencyNonResidentStrict" + VkPhysicalDeviceSparseProperties + = + #{offset VkPhysicalDeviceSparseProperties, residencyNonResidentStrict} + type FieldIsArray "residencyNonResidentStrict" + VkPhysicalDeviceSparseProperties + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceSparseProperties, residencyNonResidentStrict} + +instance CanReadField "residencyNonResidentStrict" + VkPhysicalDeviceSparseProperties + where + {-# INLINE getField #-} + getField = vkResidencyNonResidentStrict + + {-# INLINE readField #-} + readField = readVkResidencyNonResidentStrict + +instance Show VkPhysicalDeviceSparseProperties where + showsPrec d x + = showString "VkPhysicalDeviceSparseProperties {" . + showString "vkResidencyStandard2DBlockShape = " . + showsPrec d (vkResidencyStandard2DBlockShape x) . + showString ", " . + showString "vkResidencyStandard2DMultisampleBlockShape = " . + showsPrec d (vkResidencyStandard2DMultisampleBlockShape x) . + showString ", " . + showString "vkResidencyStandard3DBlockShape = " . + showsPrec d (vkResidencyStandard3DBlockShape x) . + showString ", " . + showString "vkResidencyAlignedMipSize = " . + showsPrec d (vkResidencyAlignedMipSize x) . + showString ", " . + showString "vkResidencyNonResidentStrict = " . + showsPrec d (vkResidencyNonResidentStrict x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkPhysicalDeviceSurfaceInfo2KHR.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkPhysicalDeviceSurfaceInfo2KHR.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkPhysicalDeviceSurfaceInfo2KHR.hsc @@ -0,0 +1,238 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceSurfaceInfo2KHR + (VkPhysicalDeviceSurfaceInfo2KHR(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Handles (VkSurfaceKHR) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkPhysicalDeviceSurfaceInfo2KHR { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkSurfaceKHR surface; +-- > } VkPhysicalDeviceSurfaceInfo2KHR; +-- +-- +data VkPhysicalDeviceSurfaceInfo2KHR = VkPhysicalDeviceSurfaceInfo2KHR## Addr## + ByteArray## + +instance Eq VkPhysicalDeviceSurfaceInfo2KHR where + (VkPhysicalDeviceSurfaceInfo2KHR## a _) == + x@(VkPhysicalDeviceSurfaceInfo2KHR## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkPhysicalDeviceSurfaceInfo2KHR where + (VkPhysicalDeviceSurfaceInfo2KHR## a _) `compare` + x@(VkPhysicalDeviceSurfaceInfo2KHR## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkPhysicalDeviceSurfaceInfo2KHR where + sizeOf ~_ = #{size VkPhysicalDeviceSurfaceInfo2KHR} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkPhysicalDeviceSurfaceInfo2KHR} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkPhysicalDeviceSurfaceInfo2KHR where + unsafeAddr (VkPhysicalDeviceSurfaceInfo2KHR## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkPhysicalDeviceSurfaceInfo2KHR## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkPhysicalDeviceSurfaceInfo2KHR## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkPhysicalDeviceSurfaceInfo2KHR where + type StructFields VkPhysicalDeviceSurfaceInfo2KHR = + '["sType", "pNext", "surface"] -- ' closing tick for hsc2hs + type CUnionType VkPhysicalDeviceSurfaceInfo2KHR = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkPhysicalDeviceSurfaceInfo2KHR = 'False -- ' closing tick for hsc2hs + type StructExtends VkPhysicalDeviceSurfaceInfo2KHR = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkPhysicalDeviceSurfaceInfo2KHR where + type VkSTypeMType VkPhysicalDeviceSurfaceInfo2KHR = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceSurfaceInfo2KHR, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkPhysicalDeviceSurfaceInfo2KHR, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkPhysicalDeviceSurfaceInfo2KHR, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkPhysicalDeviceSurfaceInfo2KHR, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkPhysicalDeviceSurfaceInfo2KHR where + type FieldType "sType" VkPhysicalDeviceSurfaceInfo2KHR = + VkStructureType + type FieldOptional "sType" VkPhysicalDeviceSurfaceInfo2KHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkPhysicalDeviceSurfaceInfo2KHR = + #{offset VkPhysicalDeviceSurfaceInfo2KHR, sType} + type FieldIsArray "sType" VkPhysicalDeviceSurfaceInfo2KHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceSurfaceInfo2KHR, sType} + +instance CanReadField "sType" VkPhysicalDeviceSurfaceInfo2KHR where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkPhysicalDeviceSurfaceInfo2KHR + where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkPhysicalDeviceSurfaceInfo2KHR where + type VkPNextMType VkPhysicalDeviceSurfaceInfo2KHR = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceSurfaceInfo2KHR, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkPhysicalDeviceSurfaceInfo2KHR, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkPhysicalDeviceSurfaceInfo2KHR, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkPhysicalDeviceSurfaceInfo2KHR, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkPhysicalDeviceSurfaceInfo2KHR where + type FieldType "pNext" VkPhysicalDeviceSurfaceInfo2KHR = Ptr Void + type FieldOptional "pNext" VkPhysicalDeviceSurfaceInfo2KHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkPhysicalDeviceSurfaceInfo2KHR = + #{offset VkPhysicalDeviceSurfaceInfo2KHR, pNext} + type FieldIsArray "pNext" VkPhysicalDeviceSurfaceInfo2KHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceSurfaceInfo2KHR, pNext} + +instance CanReadField "pNext" VkPhysicalDeviceSurfaceInfo2KHR where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkPhysicalDeviceSurfaceInfo2KHR + where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkSurface VkPhysicalDeviceSurfaceInfo2KHR where + type VkSurfaceMType VkPhysicalDeviceSurfaceInfo2KHR = VkSurfaceKHR + + {-# NOINLINE vkSurface #-} + vkSurface x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceSurfaceInfo2KHR, surface}) + + {-# INLINE vkSurfaceByteOffset #-} + vkSurfaceByteOffset ~_ + = #{offset VkPhysicalDeviceSurfaceInfo2KHR, surface} + + {-# INLINE readVkSurface #-} + readVkSurface p + = peekByteOff p #{offset VkPhysicalDeviceSurfaceInfo2KHR, surface} + + {-# INLINE writeVkSurface #-} + writeVkSurface p + = pokeByteOff p #{offset VkPhysicalDeviceSurfaceInfo2KHR, surface} + +instance {-# OVERLAPPING #-} + HasField "surface" VkPhysicalDeviceSurfaceInfo2KHR where + type FieldType "surface" VkPhysicalDeviceSurfaceInfo2KHR = + VkSurfaceKHR + type FieldOptional "surface" VkPhysicalDeviceSurfaceInfo2KHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "surface" VkPhysicalDeviceSurfaceInfo2KHR = + #{offset VkPhysicalDeviceSurfaceInfo2KHR, surface} + type FieldIsArray "surface" VkPhysicalDeviceSurfaceInfo2KHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceSurfaceInfo2KHR, surface} + +instance CanReadField "surface" VkPhysicalDeviceSurfaceInfo2KHR + where + {-# INLINE getField #-} + getField = vkSurface + + {-# INLINE readField #-} + readField = readVkSurface + +instance CanWriteField "surface" VkPhysicalDeviceSurfaceInfo2KHR + where + {-# INLINE writeField #-} + writeField = writeVkSurface + +instance Show VkPhysicalDeviceSurfaceInfo2KHR where + showsPrec d x + = showString "VkPhysicalDeviceSurfaceInfo2KHR {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkSurface = " . + showsPrec d (vkSurface x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkPhysicalDeviceVariablePointerFeaturesKHR.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkPhysicalDeviceVariablePointerFeaturesKHR.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkPhysicalDeviceVariablePointerFeaturesKHR.hsc @@ -0,0 +1,349 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkPhysicalDeviceVariablePointerFeaturesKHR + (VkPhysicalDeviceVariablePointerFeaturesKHR(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.BaseTypes (VkBool32) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Struct.VkDeviceCreateInfo (VkDeviceCreateInfo) +import Graphics.Vulkan.Types.Struct.VkPhysicalDeviceFeatures2KHR (VkPhysicalDeviceFeatures2KHR) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkPhysicalDeviceVariablePointerFeaturesKHR { +-- > VkStructureType sType; +-- > void* pNext; +-- > VkBool32 variablePointersStorageBuffer; +-- > VkBool32 variablePointers; +-- > } VkPhysicalDeviceVariablePointerFeaturesKHR; +-- +-- +data VkPhysicalDeviceVariablePointerFeaturesKHR = VkPhysicalDeviceVariablePointerFeaturesKHR## Addr## + ByteArray## + +instance Eq VkPhysicalDeviceVariablePointerFeaturesKHR where + (VkPhysicalDeviceVariablePointerFeaturesKHR## a _) == + x@(VkPhysicalDeviceVariablePointerFeaturesKHR## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkPhysicalDeviceVariablePointerFeaturesKHR where + (VkPhysicalDeviceVariablePointerFeaturesKHR## a _) `compare` + x@(VkPhysicalDeviceVariablePointerFeaturesKHR## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkPhysicalDeviceVariablePointerFeaturesKHR where + sizeOf ~_ + = #{size VkPhysicalDeviceVariablePointerFeaturesKHR} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkPhysicalDeviceVariablePointerFeaturesKHR} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim + VkPhysicalDeviceVariablePointerFeaturesKHR + where + unsafeAddr (VkPhysicalDeviceVariablePointerFeaturesKHR## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkPhysicalDeviceVariablePointerFeaturesKHR## _ b) + = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkPhysicalDeviceVariablePointerFeaturesKHR## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkPhysicalDeviceVariablePointerFeaturesKHR + where + type StructFields VkPhysicalDeviceVariablePointerFeaturesKHR = + '["sType", "pNext", "variablePointersStorageBuffer", -- ' closing tick for hsc2hs + "variablePointers"] + type CUnionType VkPhysicalDeviceVariablePointerFeaturesKHR = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkPhysicalDeviceVariablePointerFeaturesKHR = + 'False -- ' closing tick for hsc2hs + type StructExtends VkPhysicalDeviceVariablePointerFeaturesKHR = + '[VkPhysicalDeviceFeatures2KHR, VkDeviceCreateInfo] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkPhysicalDeviceVariablePointerFeaturesKHR where + type VkSTypeMType VkPhysicalDeviceVariablePointerFeaturesKHR = + VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceVariablePointerFeaturesKHR, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkPhysicalDeviceVariablePointerFeaturesKHR, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkPhysicalDeviceVariablePointerFeaturesKHR, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkPhysicalDeviceVariablePointerFeaturesKHR, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkPhysicalDeviceVariablePointerFeaturesKHR where + type FieldType "sType" VkPhysicalDeviceVariablePointerFeaturesKHR = + VkStructureType + type FieldOptional "sType" + VkPhysicalDeviceVariablePointerFeaturesKHR + = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkPhysicalDeviceVariablePointerFeaturesKHR + = + #{offset VkPhysicalDeviceVariablePointerFeaturesKHR, sType} + type FieldIsArray "sType" + VkPhysicalDeviceVariablePointerFeaturesKHR + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceVariablePointerFeaturesKHR, sType} + +instance CanReadField "sType" + VkPhysicalDeviceVariablePointerFeaturesKHR + where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" + VkPhysicalDeviceVariablePointerFeaturesKHR + where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkPhysicalDeviceVariablePointerFeaturesKHR where + type VkPNextMType VkPhysicalDeviceVariablePointerFeaturesKHR = + Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceVariablePointerFeaturesKHR, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkPhysicalDeviceVariablePointerFeaturesKHR, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkPhysicalDeviceVariablePointerFeaturesKHR, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkPhysicalDeviceVariablePointerFeaturesKHR, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkPhysicalDeviceVariablePointerFeaturesKHR where + type FieldType "pNext" VkPhysicalDeviceVariablePointerFeaturesKHR = + Ptr Void + type FieldOptional "pNext" + VkPhysicalDeviceVariablePointerFeaturesKHR + = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkPhysicalDeviceVariablePointerFeaturesKHR + = + #{offset VkPhysicalDeviceVariablePointerFeaturesKHR, pNext} + type FieldIsArray "pNext" + VkPhysicalDeviceVariablePointerFeaturesKHR + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceVariablePointerFeaturesKHR, pNext} + +instance CanReadField "pNext" + VkPhysicalDeviceVariablePointerFeaturesKHR + where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" + VkPhysicalDeviceVariablePointerFeaturesKHR + where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkVariablePointersStorageBuffer + VkPhysicalDeviceVariablePointerFeaturesKHR + where + type VkVariablePointersStorageBufferMType + VkPhysicalDeviceVariablePointerFeaturesKHR + = VkBool32 + + {-# NOINLINE vkVariablePointersStorageBuffer #-} + vkVariablePointersStorageBuffer x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceVariablePointerFeaturesKHR, variablePointersStorageBuffer}) + + {-# INLINE vkVariablePointersStorageBufferByteOffset #-} + vkVariablePointersStorageBufferByteOffset ~_ + = #{offset VkPhysicalDeviceVariablePointerFeaturesKHR, variablePointersStorageBuffer} + + {-# INLINE readVkVariablePointersStorageBuffer #-} + readVkVariablePointersStorageBuffer p + = peekByteOff p #{offset VkPhysicalDeviceVariablePointerFeaturesKHR, variablePointersStorageBuffer} + + {-# INLINE writeVkVariablePointersStorageBuffer #-} + writeVkVariablePointersStorageBuffer p + = pokeByteOff p #{offset VkPhysicalDeviceVariablePointerFeaturesKHR, variablePointersStorageBuffer} + +instance {-# OVERLAPPING #-} + HasField "variablePointersStorageBuffer" + VkPhysicalDeviceVariablePointerFeaturesKHR + where + type FieldType "variablePointersStorageBuffer" + VkPhysicalDeviceVariablePointerFeaturesKHR + = VkBool32 + type FieldOptional "variablePointersStorageBuffer" + VkPhysicalDeviceVariablePointerFeaturesKHR + = 'False -- ' closing tick for hsc2hs + type FieldOffset "variablePointersStorageBuffer" + VkPhysicalDeviceVariablePointerFeaturesKHR + = + #{offset VkPhysicalDeviceVariablePointerFeaturesKHR, variablePointersStorageBuffer} + type FieldIsArray "variablePointersStorageBuffer" + VkPhysicalDeviceVariablePointerFeaturesKHR + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceVariablePointerFeaturesKHR, variablePointersStorageBuffer} + +instance CanReadField "variablePointersStorageBuffer" + VkPhysicalDeviceVariablePointerFeaturesKHR + where + {-# INLINE getField #-} + getField = vkVariablePointersStorageBuffer + + {-# INLINE readField #-} + readField = readVkVariablePointersStorageBuffer + +instance CanWriteField "variablePointersStorageBuffer" + VkPhysicalDeviceVariablePointerFeaturesKHR + where + {-# INLINE writeField #-} + writeField = writeVkVariablePointersStorageBuffer + +instance {-# OVERLAPPING #-} + HasVkVariablePointers VkPhysicalDeviceVariablePointerFeaturesKHR + where + type VkVariablePointersMType + VkPhysicalDeviceVariablePointerFeaturesKHR + = VkBool32 + + {-# NOINLINE vkVariablePointers #-} + vkVariablePointers x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPhysicalDeviceVariablePointerFeaturesKHR, variablePointers}) + + {-# INLINE vkVariablePointersByteOffset #-} + vkVariablePointersByteOffset ~_ + = #{offset VkPhysicalDeviceVariablePointerFeaturesKHR, variablePointers} + + {-# INLINE readVkVariablePointers #-} + readVkVariablePointers p + = peekByteOff p #{offset VkPhysicalDeviceVariablePointerFeaturesKHR, variablePointers} + + {-# INLINE writeVkVariablePointers #-} + writeVkVariablePointers p + = pokeByteOff p #{offset VkPhysicalDeviceVariablePointerFeaturesKHR, variablePointers} + +instance {-# OVERLAPPING #-} + HasField "variablePointers" + VkPhysicalDeviceVariablePointerFeaturesKHR + where + type FieldType "variablePointers" + VkPhysicalDeviceVariablePointerFeaturesKHR + = VkBool32 + type FieldOptional "variablePointers" + VkPhysicalDeviceVariablePointerFeaturesKHR + = 'False -- ' closing tick for hsc2hs + type FieldOffset "variablePointers" + VkPhysicalDeviceVariablePointerFeaturesKHR + = + #{offset VkPhysicalDeviceVariablePointerFeaturesKHR, variablePointers} + type FieldIsArray "variablePointers" + VkPhysicalDeviceVariablePointerFeaturesKHR + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPhysicalDeviceVariablePointerFeaturesKHR, variablePointers} + +instance CanReadField "variablePointers" + VkPhysicalDeviceVariablePointerFeaturesKHR + where + {-# INLINE getField #-} + getField = vkVariablePointers + + {-# INLINE readField #-} + readField = readVkVariablePointers + +instance CanWriteField "variablePointers" + VkPhysicalDeviceVariablePointerFeaturesKHR + where + {-# INLINE writeField #-} + writeField = writeVkVariablePointers + +instance Show VkPhysicalDeviceVariablePointerFeaturesKHR where + showsPrec d x + = showString "VkPhysicalDeviceVariablePointerFeaturesKHR {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkVariablePointersStorageBuffer = " . + showsPrec d (vkVariablePointersStorageBuffer x) . + showString ", " . + showString "vkVariablePointers = " . + showsPrec d (vkVariablePointers x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkPipelineCacheCreateInfo.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkPipelineCacheCreateInfo.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkPipelineCacheCreateInfo.hsc @@ -0,0 +1,338 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkPipelineCacheCreateInfo + (VkPipelineCacheCreateInfo(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Bitmasks (VkPipelineCacheCreateFlags) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkPipelineCacheCreateInfo { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkPipelineCacheCreateFlags flags; +-- > size_t initialDataSize; +-- > const void* pInitialData; +-- > } VkPipelineCacheCreateInfo; +-- +-- +data VkPipelineCacheCreateInfo = VkPipelineCacheCreateInfo## Addr## + ByteArray## + +instance Eq VkPipelineCacheCreateInfo where + (VkPipelineCacheCreateInfo## a _) == + x@(VkPipelineCacheCreateInfo## b _) = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkPipelineCacheCreateInfo where + (VkPipelineCacheCreateInfo## a _) `compare` + x@(VkPipelineCacheCreateInfo## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkPipelineCacheCreateInfo where + sizeOf ~_ = #{size VkPipelineCacheCreateInfo} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkPipelineCacheCreateInfo} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkPipelineCacheCreateInfo where + unsafeAddr (VkPipelineCacheCreateInfo## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkPipelineCacheCreateInfo## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkPipelineCacheCreateInfo## (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkPipelineCacheCreateInfo where + type StructFields VkPipelineCacheCreateInfo = + '["sType", "pNext", "flags", "initialDataSize", "pInitialData"] -- ' closing tick for hsc2hs + type CUnionType VkPipelineCacheCreateInfo = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkPipelineCacheCreateInfo = 'False -- ' closing tick for hsc2hs + type StructExtends VkPipelineCacheCreateInfo = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkSType VkPipelineCacheCreateInfo + where + type VkSTypeMType VkPipelineCacheCreateInfo = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineCacheCreateInfo, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkPipelineCacheCreateInfo, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkPipelineCacheCreateInfo, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkPipelineCacheCreateInfo, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkPipelineCacheCreateInfo where + type FieldType "sType" VkPipelineCacheCreateInfo = VkStructureType + type FieldOptional "sType" VkPipelineCacheCreateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkPipelineCacheCreateInfo = + #{offset VkPipelineCacheCreateInfo, sType} + type FieldIsArray "sType" VkPipelineCacheCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineCacheCreateInfo, sType} + +instance CanReadField "sType" VkPipelineCacheCreateInfo where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkPipelineCacheCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} HasVkPNext VkPipelineCacheCreateInfo + where + type VkPNextMType VkPipelineCacheCreateInfo = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineCacheCreateInfo, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkPipelineCacheCreateInfo, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkPipelineCacheCreateInfo, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkPipelineCacheCreateInfo, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkPipelineCacheCreateInfo where + type FieldType "pNext" VkPipelineCacheCreateInfo = Ptr Void + type FieldOptional "pNext" VkPipelineCacheCreateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkPipelineCacheCreateInfo = + #{offset VkPipelineCacheCreateInfo, pNext} + type FieldIsArray "pNext" VkPipelineCacheCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineCacheCreateInfo, pNext} + +instance CanReadField "pNext" VkPipelineCacheCreateInfo where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkPipelineCacheCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} HasVkFlags VkPipelineCacheCreateInfo + where + type VkFlagsMType VkPipelineCacheCreateInfo = + VkPipelineCacheCreateFlags + + {-# NOINLINE vkFlags #-} + vkFlags x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineCacheCreateInfo, flags}) + + {-# INLINE vkFlagsByteOffset #-} + vkFlagsByteOffset ~_ + = #{offset VkPipelineCacheCreateInfo, flags} + + {-# INLINE readVkFlags #-} + readVkFlags p + = peekByteOff p #{offset VkPipelineCacheCreateInfo, flags} + + {-# INLINE writeVkFlags #-} + writeVkFlags p + = pokeByteOff p #{offset VkPipelineCacheCreateInfo, flags} + +instance {-# OVERLAPPING #-} + HasField "flags" VkPipelineCacheCreateInfo where + type FieldType "flags" VkPipelineCacheCreateInfo = + VkPipelineCacheCreateFlags + type FieldOptional "flags" VkPipelineCacheCreateInfo = 'True -- ' closing tick for hsc2hs + type FieldOffset "flags" VkPipelineCacheCreateInfo = + #{offset VkPipelineCacheCreateInfo, flags} + type FieldIsArray "flags" VkPipelineCacheCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineCacheCreateInfo, flags} + +instance CanReadField "flags" VkPipelineCacheCreateInfo where + {-# INLINE getField #-} + getField = vkFlags + + {-# INLINE readField #-} + readField = readVkFlags + +instance CanWriteField "flags" VkPipelineCacheCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkFlags + +instance {-# OVERLAPPING #-} + HasVkInitialDataSize VkPipelineCacheCreateInfo where + type VkInitialDataSizeMType VkPipelineCacheCreateInfo = CSize + + {-# NOINLINE vkInitialDataSize #-} + vkInitialDataSize x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineCacheCreateInfo, initialDataSize}) + + {-# INLINE vkInitialDataSizeByteOffset #-} + vkInitialDataSizeByteOffset ~_ + = #{offset VkPipelineCacheCreateInfo, initialDataSize} + + {-# INLINE readVkInitialDataSize #-} + readVkInitialDataSize p + = peekByteOff p #{offset VkPipelineCacheCreateInfo, initialDataSize} + + {-# INLINE writeVkInitialDataSize #-} + writeVkInitialDataSize p + = pokeByteOff p #{offset VkPipelineCacheCreateInfo, initialDataSize} + +instance {-# OVERLAPPING #-} + HasField "initialDataSize" VkPipelineCacheCreateInfo where + type FieldType "initialDataSize" VkPipelineCacheCreateInfo = CSize + type FieldOptional "initialDataSize" VkPipelineCacheCreateInfo = + 'True -- ' closing tick for hsc2hs + type FieldOffset "initialDataSize" VkPipelineCacheCreateInfo = + #{offset VkPipelineCacheCreateInfo, initialDataSize} + type FieldIsArray "initialDataSize" VkPipelineCacheCreateInfo = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineCacheCreateInfo, initialDataSize} + +instance CanReadField "initialDataSize" VkPipelineCacheCreateInfo + where + {-# INLINE getField #-} + getField = vkInitialDataSize + + {-# INLINE readField #-} + readField = readVkInitialDataSize + +instance CanWriteField "initialDataSize" VkPipelineCacheCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkInitialDataSize + +instance {-# OVERLAPPING #-} + HasVkPInitialData VkPipelineCacheCreateInfo where + type VkPInitialDataMType VkPipelineCacheCreateInfo = Ptr Void + + {-# NOINLINE vkPInitialData #-} + vkPInitialData x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineCacheCreateInfo, pInitialData}) + + {-# INLINE vkPInitialDataByteOffset #-} + vkPInitialDataByteOffset ~_ + = #{offset VkPipelineCacheCreateInfo, pInitialData} + + {-# INLINE readVkPInitialData #-} + readVkPInitialData p + = peekByteOff p #{offset VkPipelineCacheCreateInfo, pInitialData} + + {-# INLINE writeVkPInitialData #-} + writeVkPInitialData p + = pokeByteOff p #{offset VkPipelineCacheCreateInfo, pInitialData} + +instance {-# OVERLAPPING #-} + HasField "pInitialData" VkPipelineCacheCreateInfo where + type FieldType "pInitialData" VkPipelineCacheCreateInfo = Ptr Void + type FieldOptional "pInitialData" VkPipelineCacheCreateInfo = + 'False -- ' closing tick for hsc2hs + type FieldOffset "pInitialData" VkPipelineCacheCreateInfo = + #{offset VkPipelineCacheCreateInfo, pInitialData} + type FieldIsArray "pInitialData" VkPipelineCacheCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineCacheCreateInfo, pInitialData} + +instance CanReadField "pInitialData" VkPipelineCacheCreateInfo + where + {-# INLINE getField #-} + getField = vkPInitialData + + {-# INLINE readField #-} + readField = readVkPInitialData + +instance CanWriteField "pInitialData" VkPipelineCacheCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkPInitialData + +instance Show VkPipelineCacheCreateInfo where + showsPrec d x + = showString "VkPipelineCacheCreateInfo {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkFlags = " . + showsPrec d (vkFlags x) . + showString ", " . + showString "vkInitialDataSize = " . + showsPrec d (vkInitialDataSize x) . + showString ", " . + showString "vkPInitialData = " . + showsPrec d (vkPInitialData x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkPipelineColorBlendAdvancedStateCreateInfoEXT.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkPipelineColorBlendAdvancedStateCreateInfoEXT.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkPipelineColorBlendAdvancedStateCreateInfoEXT.hsc @@ -0,0 +1,434 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkPipelineColorBlendAdvancedStateCreateInfoEXT + (VkPipelineColorBlendAdvancedStateCreateInfoEXT(..)) where +import Foreign.Storable + (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.BaseTypes + (VkBool32) +import Graphics.Vulkan.Types.Enum.VkBlendOverlapEXT + (VkBlendOverlapEXT) +import Graphics.Vulkan.Types.Enum.VkStructureType + (VkStructureType) +import Graphics.Vulkan.Types.Struct.VkPipelineColorBlendStateCreateInfo + (VkPipelineColorBlendStateCreateInfo) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe + (unsafeDupablePerformIO) + +-- | > typedef struct VkPipelineColorBlendAdvancedStateCreateInfoEXT { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkBool32 srcPremultiplied; +-- > VkBool32 dstPremultiplied; +-- > VkBlendOverlapEXT blendOverlap; +-- > } VkPipelineColorBlendAdvancedStateCreateInfoEXT; +-- +-- +data VkPipelineColorBlendAdvancedStateCreateInfoEXT = VkPipelineColorBlendAdvancedStateCreateInfoEXT## Addr## + ByteArray## + +instance Eq VkPipelineColorBlendAdvancedStateCreateInfoEXT where + (VkPipelineColorBlendAdvancedStateCreateInfoEXT## a _) == + x@(VkPipelineColorBlendAdvancedStateCreateInfoEXT## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkPipelineColorBlendAdvancedStateCreateInfoEXT where + (VkPipelineColorBlendAdvancedStateCreateInfoEXT## a _) `compare` + x@(VkPipelineColorBlendAdvancedStateCreateInfoEXT## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkPipelineColorBlendAdvancedStateCreateInfoEXT + where + sizeOf ~_ + = #{size VkPipelineColorBlendAdvancedStateCreateInfoEXT} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkPipelineColorBlendAdvancedStateCreateInfoEXT} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim + VkPipelineColorBlendAdvancedStateCreateInfoEXT + where + unsafeAddr (VkPipelineColorBlendAdvancedStateCreateInfoEXT## a _) + = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray + (VkPipelineColorBlendAdvancedStateCreateInfoEXT## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkPipelineColorBlendAdvancedStateCreateInfoEXT## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal + VkPipelineColorBlendAdvancedStateCreateInfoEXT + where + type StructFields VkPipelineColorBlendAdvancedStateCreateInfoEXT = + '["sType", "pNext", "srcPremultiplied", "dstPremultiplied", -- ' closing tick for hsc2hs + "blendOverlap"] + type CUnionType VkPipelineColorBlendAdvancedStateCreateInfoEXT = + 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkPipelineColorBlendAdvancedStateCreateInfoEXT = + 'False -- ' closing tick for hsc2hs + type StructExtends VkPipelineColorBlendAdvancedStateCreateInfoEXT = + '[VkPipelineColorBlendStateCreateInfo] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkPipelineColorBlendAdvancedStateCreateInfoEXT where + type VkSTypeMType VkPipelineColorBlendAdvancedStateCreateInfoEXT = + VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineColorBlendAdvancedStateCreateInfoEXT, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkPipelineColorBlendAdvancedStateCreateInfoEXT, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkPipelineColorBlendAdvancedStateCreateInfoEXT, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkPipelineColorBlendAdvancedStateCreateInfoEXT, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkPipelineColorBlendAdvancedStateCreateInfoEXT + where + type FieldType "sType" + VkPipelineColorBlendAdvancedStateCreateInfoEXT + = VkStructureType + type FieldOptional "sType" + VkPipelineColorBlendAdvancedStateCreateInfoEXT + = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" + VkPipelineColorBlendAdvancedStateCreateInfoEXT + = + #{offset VkPipelineColorBlendAdvancedStateCreateInfoEXT, sType} + type FieldIsArray "sType" + VkPipelineColorBlendAdvancedStateCreateInfoEXT + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineColorBlendAdvancedStateCreateInfoEXT, sType} + +instance CanReadField "sType" + VkPipelineColorBlendAdvancedStateCreateInfoEXT + where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" + VkPipelineColorBlendAdvancedStateCreateInfoEXT + where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkPipelineColorBlendAdvancedStateCreateInfoEXT where + type VkPNextMType VkPipelineColorBlendAdvancedStateCreateInfoEXT = + Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineColorBlendAdvancedStateCreateInfoEXT, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkPipelineColorBlendAdvancedStateCreateInfoEXT, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkPipelineColorBlendAdvancedStateCreateInfoEXT, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkPipelineColorBlendAdvancedStateCreateInfoEXT, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkPipelineColorBlendAdvancedStateCreateInfoEXT + where + type FieldType "pNext" + VkPipelineColorBlendAdvancedStateCreateInfoEXT + = Ptr Void + type FieldOptional "pNext" + VkPipelineColorBlendAdvancedStateCreateInfoEXT + = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" + VkPipelineColorBlendAdvancedStateCreateInfoEXT + = + #{offset VkPipelineColorBlendAdvancedStateCreateInfoEXT, pNext} + type FieldIsArray "pNext" + VkPipelineColorBlendAdvancedStateCreateInfoEXT + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineColorBlendAdvancedStateCreateInfoEXT, pNext} + +instance CanReadField "pNext" + VkPipelineColorBlendAdvancedStateCreateInfoEXT + where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" + VkPipelineColorBlendAdvancedStateCreateInfoEXT + where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkSrcPremultiplied + VkPipelineColorBlendAdvancedStateCreateInfoEXT + where + type VkSrcPremultipliedMType + VkPipelineColorBlendAdvancedStateCreateInfoEXT + = VkBool32 + + {-# NOINLINE vkSrcPremultiplied #-} + vkSrcPremultiplied x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineColorBlendAdvancedStateCreateInfoEXT, srcPremultiplied}) + + {-# INLINE vkSrcPremultipliedByteOffset #-} + vkSrcPremultipliedByteOffset ~_ + = #{offset VkPipelineColorBlendAdvancedStateCreateInfoEXT, srcPremultiplied} + + {-# INLINE readVkSrcPremultiplied #-} + readVkSrcPremultiplied p + = peekByteOff p #{offset VkPipelineColorBlendAdvancedStateCreateInfoEXT, srcPremultiplied} + + {-# INLINE writeVkSrcPremultiplied #-} + writeVkSrcPremultiplied p + = pokeByteOff p #{offset VkPipelineColorBlendAdvancedStateCreateInfoEXT, srcPremultiplied} + +instance {-# OVERLAPPING #-} + HasField "srcPremultiplied" + VkPipelineColorBlendAdvancedStateCreateInfoEXT + where + type FieldType "srcPremultiplied" + VkPipelineColorBlendAdvancedStateCreateInfoEXT + = VkBool32 + type FieldOptional "srcPremultiplied" + VkPipelineColorBlendAdvancedStateCreateInfoEXT + = 'False -- ' closing tick for hsc2hs + type FieldOffset "srcPremultiplied" + VkPipelineColorBlendAdvancedStateCreateInfoEXT + = + #{offset VkPipelineColorBlendAdvancedStateCreateInfoEXT, srcPremultiplied} + type FieldIsArray "srcPremultiplied" + VkPipelineColorBlendAdvancedStateCreateInfoEXT + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineColorBlendAdvancedStateCreateInfoEXT, srcPremultiplied} + +instance CanReadField "srcPremultiplied" + VkPipelineColorBlendAdvancedStateCreateInfoEXT + where + {-# INLINE getField #-} + getField = vkSrcPremultiplied + + {-# INLINE readField #-} + readField = readVkSrcPremultiplied + +instance CanWriteField "srcPremultiplied" + VkPipelineColorBlendAdvancedStateCreateInfoEXT + where + {-# INLINE writeField #-} + writeField = writeVkSrcPremultiplied + +instance {-# OVERLAPPING #-} + HasVkDstPremultiplied + VkPipelineColorBlendAdvancedStateCreateInfoEXT + where + type VkDstPremultipliedMType + VkPipelineColorBlendAdvancedStateCreateInfoEXT + = VkBool32 + + {-# NOINLINE vkDstPremultiplied #-} + vkDstPremultiplied x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineColorBlendAdvancedStateCreateInfoEXT, dstPremultiplied}) + + {-# INLINE vkDstPremultipliedByteOffset #-} + vkDstPremultipliedByteOffset ~_ + = #{offset VkPipelineColorBlendAdvancedStateCreateInfoEXT, dstPremultiplied} + + {-# INLINE readVkDstPremultiplied #-} + readVkDstPremultiplied p + = peekByteOff p #{offset VkPipelineColorBlendAdvancedStateCreateInfoEXT, dstPremultiplied} + + {-# INLINE writeVkDstPremultiplied #-} + writeVkDstPremultiplied p + = pokeByteOff p #{offset VkPipelineColorBlendAdvancedStateCreateInfoEXT, dstPremultiplied} + +instance {-# OVERLAPPING #-} + HasField "dstPremultiplied" + VkPipelineColorBlendAdvancedStateCreateInfoEXT + where + type FieldType "dstPremultiplied" + VkPipelineColorBlendAdvancedStateCreateInfoEXT + = VkBool32 + type FieldOptional "dstPremultiplied" + VkPipelineColorBlendAdvancedStateCreateInfoEXT + = 'False -- ' closing tick for hsc2hs + type FieldOffset "dstPremultiplied" + VkPipelineColorBlendAdvancedStateCreateInfoEXT + = + #{offset VkPipelineColorBlendAdvancedStateCreateInfoEXT, dstPremultiplied} + type FieldIsArray "dstPremultiplied" + VkPipelineColorBlendAdvancedStateCreateInfoEXT + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineColorBlendAdvancedStateCreateInfoEXT, dstPremultiplied} + +instance CanReadField "dstPremultiplied" + VkPipelineColorBlendAdvancedStateCreateInfoEXT + where + {-# INLINE getField #-} + getField = vkDstPremultiplied + + {-# INLINE readField #-} + readField = readVkDstPremultiplied + +instance CanWriteField "dstPremultiplied" + VkPipelineColorBlendAdvancedStateCreateInfoEXT + where + {-# INLINE writeField #-} + writeField = writeVkDstPremultiplied + +instance {-# OVERLAPPING #-} + HasVkBlendOverlap VkPipelineColorBlendAdvancedStateCreateInfoEXT + where + type VkBlendOverlapMType + VkPipelineColorBlendAdvancedStateCreateInfoEXT + = VkBlendOverlapEXT + + {-# NOINLINE vkBlendOverlap #-} + vkBlendOverlap x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineColorBlendAdvancedStateCreateInfoEXT, blendOverlap}) + + {-# INLINE vkBlendOverlapByteOffset #-} + vkBlendOverlapByteOffset ~_ + = #{offset VkPipelineColorBlendAdvancedStateCreateInfoEXT, blendOverlap} + + {-# INLINE readVkBlendOverlap #-} + readVkBlendOverlap p + = peekByteOff p #{offset VkPipelineColorBlendAdvancedStateCreateInfoEXT, blendOverlap} + + {-# INLINE writeVkBlendOverlap #-} + writeVkBlendOverlap p + = pokeByteOff p #{offset VkPipelineColorBlendAdvancedStateCreateInfoEXT, blendOverlap} + +instance {-# OVERLAPPING #-} + HasField "blendOverlap" + VkPipelineColorBlendAdvancedStateCreateInfoEXT + where + type FieldType "blendOverlap" + VkPipelineColorBlendAdvancedStateCreateInfoEXT + = VkBlendOverlapEXT + type FieldOptional "blendOverlap" + VkPipelineColorBlendAdvancedStateCreateInfoEXT + = 'False -- ' closing tick for hsc2hs + type FieldOffset "blendOverlap" + VkPipelineColorBlendAdvancedStateCreateInfoEXT + = + #{offset VkPipelineColorBlendAdvancedStateCreateInfoEXT, blendOverlap} + type FieldIsArray "blendOverlap" + VkPipelineColorBlendAdvancedStateCreateInfoEXT + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineColorBlendAdvancedStateCreateInfoEXT, blendOverlap} + +instance CanReadField "blendOverlap" + VkPipelineColorBlendAdvancedStateCreateInfoEXT + where + {-# INLINE getField #-} + getField = vkBlendOverlap + + {-# INLINE readField #-} + readField = readVkBlendOverlap + +instance CanWriteField "blendOverlap" + VkPipelineColorBlendAdvancedStateCreateInfoEXT + where + {-# INLINE writeField #-} + writeField = writeVkBlendOverlap + +instance Show VkPipelineColorBlendAdvancedStateCreateInfoEXT where + showsPrec d x + = showString "VkPipelineColorBlendAdvancedStateCreateInfoEXT {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkSrcPremultiplied = " . + showsPrec d (vkSrcPremultiplied x) . + showString ", " . + showString "vkDstPremultiplied = " . + showsPrec d (vkDstPremultiplied x) . + showString ", " . + showString "vkBlendOverlap = " . + showsPrec d (vkBlendOverlap x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkPipelineColorBlendAttachmentState.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkPipelineColorBlendAttachmentState.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkPipelineColorBlendAttachmentState.hsc @@ -0,0 +1,592 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkPipelineColorBlendAttachmentState + (VkPipelineColorBlendAttachmentState(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.BaseTypes (VkBool32) +import Graphics.Vulkan.Types.Enum.VkBlendFactor (VkBlendFactor) +import Graphics.Vulkan.Types.Enum.VkBlendOp (VkBlendOp) +import Graphics.Vulkan.Types.Enum.VkColorComponentFlags (VkColorComponentFlags) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkPipelineColorBlendAttachmentState { +-- > VkBool32 blendEnable; +-- > VkBlendFactor srcColorBlendFactor; +-- > VkBlendFactor dstColorBlendFactor; +-- > VkBlendOp colorBlendOp; +-- > VkBlendFactor srcAlphaBlendFactor; +-- > VkBlendFactor dstAlphaBlendFactor; +-- > VkBlendOp alphaBlendOp; +-- > VkColorComponentFlags colorWriteMask; +-- > } VkPipelineColorBlendAttachmentState; +-- +-- +data VkPipelineColorBlendAttachmentState = VkPipelineColorBlendAttachmentState## Addr## + ByteArray## + +instance Eq VkPipelineColorBlendAttachmentState where + (VkPipelineColorBlendAttachmentState## a _) == + x@(VkPipelineColorBlendAttachmentState## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkPipelineColorBlendAttachmentState where + (VkPipelineColorBlendAttachmentState## a _) `compare` + x@(VkPipelineColorBlendAttachmentState## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkPipelineColorBlendAttachmentState where + sizeOf ~_ = #{size VkPipelineColorBlendAttachmentState} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkPipelineColorBlendAttachmentState} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkPipelineColorBlendAttachmentState + where + unsafeAddr (VkPipelineColorBlendAttachmentState## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkPipelineColorBlendAttachmentState## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkPipelineColorBlendAttachmentState## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkPipelineColorBlendAttachmentState where + type StructFields VkPipelineColorBlendAttachmentState = + '["blendEnable", "srcColorBlendFactor", "dstColorBlendFactor", -- ' closing tick for hsc2hs + "colorBlendOp", "srcAlphaBlendFactor", "dstAlphaBlendFactor", + "alphaBlendOp", "colorWriteMask"] + type CUnionType VkPipelineColorBlendAttachmentState = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkPipelineColorBlendAttachmentState = 'False -- ' closing tick for hsc2hs + type StructExtends VkPipelineColorBlendAttachmentState = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkBlendEnable VkPipelineColorBlendAttachmentState where + type VkBlendEnableMType VkPipelineColorBlendAttachmentState = + VkBool32 + + {-# NOINLINE vkBlendEnable #-} + vkBlendEnable x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineColorBlendAttachmentState, blendEnable}) + + {-# INLINE vkBlendEnableByteOffset #-} + vkBlendEnableByteOffset ~_ + = #{offset VkPipelineColorBlendAttachmentState, blendEnable} + + {-# INLINE readVkBlendEnable #-} + readVkBlendEnable p + = peekByteOff p #{offset VkPipelineColorBlendAttachmentState, blendEnable} + + {-# INLINE writeVkBlendEnable #-} + writeVkBlendEnable p + = pokeByteOff p #{offset VkPipelineColorBlendAttachmentState, blendEnable} + +instance {-# OVERLAPPING #-} + HasField "blendEnable" VkPipelineColorBlendAttachmentState where + type FieldType "blendEnable" VkPipelineColorBlendAttachmentState = + VkBool32 + type FieldOptional "blendEnable" + VkPipelineColorBlendAttachmentState + = 'False -- ' closing tick for hsc2hs + type FieldOffset "blendEnable" VkPipelineColorBlendAttachmentState + = + #{offset VkPipelineColorBlendAttachmentState, blendEnable} + type FieldIsArray "blendEnable" VkPipelineColorBlendAttachmentState + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineColorBlendAttachmentState, blendEnable} + +instance CanReadField "blendEnable" + VkPipelineColorBlendAttachmentState + where + {-# INLINE getField #-} + getField = vkBlendEnable + + {-# INLINE readField #-} + readField = readVkBlendEnable + +instance CanWriteField "blendEnable" + VkPipelineColorBlendAttachmentState + where + {-# INLINE writeField #-} + writeField = writeVkBlendEnable + +instance {-# OVERLAPPING #-} + HasVkSrcColorBlendFactor VkPipelineColorBlendAttachmentState where + type VkSrcColorBlendFactorMType VkPipelineColorBlendAttachmentState + = VkBlendFactor + + {-# NOINLINE vkSrcColorBlendFactor #-} + vkSrcColorBlendFactor x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineColorBlendAttachmentState, srcColorBlendFactor}) + + {-# INLINE vkSrcColorBlendFactorByteOffset #-} + vkSrcColorBlendFactorByteOffset ~_ + = #{offset VkPipelineColorBlendAttachmentState, srcColorBlendFactor} + + {-# INLINE readVkSrcColorBlendFactor #-} + readVkSrcColorBlendFactor p + = peekByteOff p #{offset VkPipelineColorBlendAttachmentState, srcColorBlendFactor} + + {-# INLINE writeVkSrcColorBlendFactor #-} + writeVkSrcColorBlendFactor p + = pokeByteOff p #{offset VkPipelineColorBlendAttachmentState, srcColorBlendFactor} + +instance {-# OVERLAPPING #-} + HasField "srcColorBlendFactor" VkPipelineColorBlendAttachmentState + where + type FieldType "srcColorBlendFactor" + VkPipelineColorBlendAttachmentState + = VkBlendFactor + type FieldOptional "srcColorBlendFactor" + VkPipelineColorBlendAttachmentState + = 'False -- ' closing tick for hsc2hs + type FieldOffset "srcColorBlendFactor" + VkPipelineColorBlendAttachmentState + = + #{offset VkPipelineColorBlendAttachmentState, srcColorBlendFactor} + type FieldIsArray "srcColorBlendFactor" + VkPipelineColorBlendAttachmentState + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineColorBlendAttachmentState, srcColorBlendFactor} + +instance CanReadField "srcColorBlendFactor" + VkPipelineColorBlendAttachmentState + where + {-# INLINE getField #-} + getField = vkSrcColorBlendFactor + + {-# INLINE readField #-} + readField = readVkSrcColorBlendFactor + +instance CanWriteField "srcColorBlendFactor" + VkPipelineColorBlendAttachmentState + where + {-# INLINE writeField #-} + writeField = writeVkSrcColorBlendFactor + +instance {-# OVERLAPPING #-} + HasVkDstColorBlendFactor VkPipelineColorBlendAttachmentState where + type VkDstColorBlendFactorMType VkPipelineColorBlendAttachmentState + = VkBlendFactor + + {-# NOINLINE vkDstColorBlendFactor #-} + vkDstColorBlendFactor x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineColorBlendAttachmentState, dstColorBlendFactor}) + + {-# INLINE vkDstColorBlendFactorByteOffset #-} + vkDstColorBlendFactorByteOffset ~_ + = #{offset VkPipelineColorBlendAttachmentState, dstColorBlendFactor} + + {-# INLINE readVkDstColorBlendFactor #-} + readVkDstColorBlendFactor p + = peekByteOff p #{offset VkPipelineColorBlendAttachmentState, dstColorBlendFactor} + + {-# INLINE writeVkDstColorBlendFactor #-} + writeVkDstColorBlendFactor p + = pokeByteOff p #{offset VkPipelineColorBlendAttachmentState, dstColorBlendFactor} + +instance {-# OVERLAPPING #-} + HasField "dstColorBlendFactor" VkPipelineColorBlendAttachmentState + where + type FieldType "dstColorBlendFactor" + VkPipelineColorBlendAttachmentState + = VkBlendFactor + type FieldOptional "dstColorBlendFactor" + VkPipelineColorBlendAttachmentState + = 'False -- ' closing tick for hsc2hs + type FieldOffset "dstColorBlendFactor" + VkPipelineColorBlendAttachmentState + = + #{offset VkPipelineColorBlendAttachmentState, dstColorBlendFactor} + type FieldIsArray "dstColorBlendFactor" + VkPipelineColorBlendAttachmentState + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineColorBlendAttachmentState, dstColorBlendFactor} + +instance CanReadField "dstColorBlendFactor" + VkPipelineColorBlendAttachmentState + where + {-# INLINE getField #-} + getField = vkDstColorBlendFactor + + {-# INLINE readField #-} + readField = readVkDstColorBlendFactor + +instance CanWriteField "dstColorBlendFactor" + VkPipelineColorBlendAttachmentState + where + {-# INLINE writeField #-} + writeField = writeVkDstColorBlendFactor + +instance {-# OVERLAPPING #-} + HasVkColorBlendOp VkPipelineColorBlendAttachmentState where + type VkColorBlendOpMType VkPipelineColorBlendAttachmentState = + VkBlendOp + + {-# NOINLINE vkColorBlendOp #-} + vkColorBlendOp x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineColorBlendAttachmentState, colorBlendOp}) + + {-# INLINE vkColorBlendOpByteOffset #-} + vkColorBlendOpByteOffset ~_ + = #{offset VkPipelineColorBlendAttachmentState, colorBlendOp} + + {-# INLINE readVkColorBlendOp #-} + readVkColorBlendOp p + = peekByteOff p #{offset VkPipelineColorBlendAttachmentState, colorBlendOp} + + {-# INLINE writeVkColorBlendOp #-} + writeVkColorBlendOp p + = pokeByteOff p #{offset VkPipelineColorBlendAttachmentState, colorBlendOp} + +instance {-# OVERLAPPING #-} + HasField "colorBlendOp" VkPipelineColorBlendAttachmentState where + type FieldType "colorBlendOp" VkPipelineColorBlendAttachmentState = + VkBlendOp + type FieldOptional "colorBlendOp" + VkPipelineColorBlendAttachmentState + = 'False -- ' closing tick for hsc2hs + type FieldOffset "colorBlendOp" VkPipelineColorBlendAttachmentState + = + #{offset VkPipelineColorBlendAttachmentState, colorBlendOp} + type FieldIsArray "colorBlendOp" + VkPipelineColorBlendAttachmentState + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineColorBlendAttachmentState, colorBlendOp} + +instance CanReadField "colorBlendOp" + VkPipelineColorBlendAttachmentState + where + {-# INLINE getField #-} + getField = vkColorBlendOp + + {-# INLINE readField #-} + readField = readVkColorBlendOp + +instance CanWriteField "colorBlendOp" + VkPipelineColorBlendAttachmentState + where + {-# INLINE writeField #-} + writeField = writeVkColorBlendOp + +instance {-# OVERLAPPING #-} + HasVkSrcAlphaBlendFactor VkPipelineColorBlendAttachmentState where + type VkSrcAlphaBlendFactorMType VkPipelineColorBlendAttachmentState + = VkBlendFactor + + {-# NOINLINE vkSrcAlphaBlendFactor #-} + vkSrcAlphaBlendFactor x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineColorBlendAttachmentState, srcAlphaBlendFactor}) + + {-# INLINE vkSrcAlphaBlendFactorByteOffset #-} + vkSrcAlphaBlendFactorByteOffset ~_ + = #{offset VkPipelineColorBlendAttachmentState, srcAlphaBlendFactor} + + {-# INLINE readVkSrcAlphaBlendFactor #-} + readVkSrcAlphaBlendFactor p + = peekByteOff p #{offset VkPipelineColorBlendAttachmentState, srcAlphaBlendFactor} + + {-# INLINE writeVkSrcAlphaBlendFactor #-} + writeVkSrcAlphaBlendFactor p + = pokeByteOff p #{offset VkPipelineColorBlendAttachmentState, srcAlphaBlendFactor} + +instance {-# OVERLAPPING #-} + HasField "srcAlphaBlendFactor" VkPipelineColorBlendAttachmentState + where + type FieldType "srcAlphaBlendFactor" + VkPipelineColorBlendAttachmentState + = VkBlendFactor + type FieldOptional "srcAlphaBlendFactor" + VkPipelineColorBlendAttachmentState + = 'False -- ' closing tick for hsc2hs + type FieldOffset "srcAlphaBlendFactor" + VkPipelineColorBlendAttachmentState + = + #{offset VkPipelineColorBlendAttachmentState, srcAlphaBlendFactor} + type FieldIsArray "srcAlphaBlendFactor" + VkPipelineColorBlendAttachmentState + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineColorBlendAttachmentState, srcAlphaBlendFactor} + +instance CanReadField "srcAlphaBlendFactor" + VkPipelineColorBlendAttachmentState + where + {-# INLINE getField #-} + getField = vkSrcAlphaBlendFactor + + {-# INLINE readField #-} + readField = readVkSrcAlphaBlendFactor + +instance CanWriteField "srcAlphaBlendFactor" + VkPipelineColorBlendAttachmentState + where + {-# INLINE writeField #-} + writeField = writeVkSrcAlphaBlendFactor + +instance {-# OVERLAPPING #-} + HasVkDstAlphaBlendFactor VkPipelineColorBlendAttachmentState where + type VkDstAlphaBlendFactorMType VkPipelineColorBlendAttachmentState + = VkBlendFactor + + {-# NOINLINE vkDstAlphaBlendFactor #-} + vkDstAlphaBlendFactor x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineColorBlendAttachmentState, dstAlphaBlendFactor}) + + {-# INLINE vkDstAlphaBlendFactorByteOffset #-} + vkDstAlphaBlendFactorByteOffset ~_ + = #{offset VkPipelineColorBlendAttachmentState, dstAlphaBlendFactor} + + {-# INLINE readVkDstAlphaBlendFactor #-} + readVkDstAlphaBlendFactor p + = peekByteOff p #{offset VkPipelineColorBlendAttachmentState, dstAlphaBlendFactor} + + {-# INLINE writeVkDstAlphaBlendFactor #-} + writeVkDstAlphaBlendFactor p + = pokeByteOff p #{offset VkPipelineColorBlendAttachmentState, dstAlphaBlendFactor} + +instance {-# OVERLAPPING #-} + HasField "dstAlphaBlendFactor" VkPipelineColorBlendAttachmentState + where + type FieldType "dstAlphaBlendFactor" + VkPipelineColorBlendAttachmentState + = VkBlendFactor + type FieldOptional "dstAlphaBlendFactor" + VkPipelineColorBlendAttachmentState + = 'False -- ' closing tick for hsc2hs + type FieldOffset "dstAlphaBlendFactor" + VkPipelineColorBlendAttachmentState + = + #{offset VkPipelineColorBlendAttachmentState, dstAlphaBlendFactor} + type FieldIsArray "dstAlphaBlendFactor" + VkPipelineColorBlendAttachmentState + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineColorBlendAttachmentState, dstAlphaBlendFactor} + +instance CanReadField "dstAlphaBlendFactor" + VkPipelineColorBlendAttachmentState + where + {-# INLINE getField #-} + getField = vkDstAlphaBlendFactor + + {-# INLINE readField #-} + readField = readVkDstAlphaBlendFactor + +instance CanWriteField "dstAlphaBlendFactor" + VkPipelineColorBlendAttachmentState + where + {-# INLINE writeField #-} + writeField = writeVkDstAlphaBlendFactor + +instance {-# OVERLAPPING #-} + HasVkAlphaBlendOp VkPipelineColorBlendAttachmentState where + type VkAlphaBlendOpMType VkPipelineColorBlendAttachmentState = + VkBlendOp + + {-# NOINLINE vkAlphaBlendOp #-} + vkAlphaBlendOp x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineColorBlendAttachmentState, alphaBlendOp}) + + {-# INLINE vkAlphaBlendOpByteOffset #-} + vkAlphaBlendOpByteOffset ~_ + = #{offset VkPipelineColorBlendAttachmentState, alphaBlendOp} + + {-# INLINE readVkAlphaBlendOp #-} + readVkAlphaBlendOp p + = peekByteOff p #{offset VkPipelineColorBlendAttachmentState, alphaBlendOp} + + {-# INLINE writeVkAlphaBlendOp #-} + writeVkAlphaBlendOp p + = pokeByteOff p #{offset VkPipelineColorBlendAttachmentState, alphaBlendOp} + +instance {-# OVERLAPPING #-} + HasField "alphaBlendOp" VkPipelineColorBlendAttachmentState where + type FieldType "alphaBlendOp" VkPipelineColorBlendAttachmentState = + VkBlendOp + type FieldOptional "alphaBlendOp" + VkPipelineColorBlendAttachmentState + = 'False -- ' closing tick for hsc2hs + type FieldOffset "alphaBlendOp" VkPipelineColorBlendAttachmentState + = + #{offset VkPipelineColorBlendAttachmentState, alphaBlendOp} + type FieldIsArray "alphaBlendOp" + VkPipelineColorBlendAttachmentState + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineColorBlendAttachmentState, alphaBlendOp} + +instance CanReadField "alphaBlendOp" + VkPipelineColorBlendAttachmentState + where + {-# INLINE getField #-} + getField = vkAlphaBlendOp + + {-# INLINE readField #-} + readField = readVkAlphaBlendOp + +instance CanWriteField "alphaBlendOp" + VkPipelineColorBlendAttachmentState + where + {-# INLINE writeField #-} + writeField = writeVkAlphaBlendOp + +instance {-# OVERLAPPING #-} + HasVkColorWriteMask VkPipelineColorBlendAttachmentState where + type VkColorWriteMaskMType VkPipelineColorBlendAttachmentState = + VkColorComponentFlags + + {-# NOINLINE vkColorWriteMask #-} + vkColorWriteMask x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineColorBlendAttachmentState, colorWriteMask}) + + {-# INLINE vkColorWriteMaskByteOffset #-} + vkColorWriteMaskByteOffset ~_ + = #{offset VkPipelineColorBlendAttachmentState, colorWriteMask} + + {-# INLINE readVkColorWriteMask #-} + readVkColorWriteMask p + = peekByteOff p #{offset VkPipelineColorBlendAttachmentState, colorWriteMask} + + {-# INLINE writeVkColorWriteMask #-} + writeVkColorWriteMask p + = pokeByteOff p #{offset VkPipelineColorBlendAttachmentState, colorWriteMask} + +instance {-# OVERLAPPING #-} + HasField "colorWriteMask" VkPipelineColorBlendAttachmentState where + type FieldType "colorWriteMask" VkPipelineColorBlendAttachmentState + = VkColorComponentFlags + type FieldOptional "colorWriteMask" + VkPipelineColorBlendAttachmentState + = 'True -- ' closing tick for hsc2hs + type FieldOffset "colorWriteMask" + VkPipelineColorBlendAttachmentState + = + #{offset VkPipelineColorBlendAttachmentState, colorWriteMask} + type FieldIsArray "colorWriteMask" + VkPipelineColorBlendAttachmentState + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineColorBlendAttachmentState, colorWriteMask} + +instance CanReadField "colorWriteMask" + VkPipelineColorBlendAttachmentState + where + {-# INLINE getField #-} + getField = vkColorWriteMask + + {-# INLINE readField #-} + readField = readVkColorWriteMask + +instance CanWriteField "colorWriteMask" + VkPipelineColorBlendAttachmentState + where + {-# INLINE writeField #-} + writeField = writeVkColorWriteMask + +instance Show VkPipelineColorBlendAttachmentState where + showsPrec d x + = showString "VkPipelineColorBlendAttachmentState {" . + showString "vkBlendEnable = " . + showsPrec d (vkBlendEnable x) . + showString ", " . + showString "vkSrcColorBlendFactor = " . + showsPrec d (vkSrcColorBlendFactor x) . + showString ", " . + showString "vkDstColorBlendFactor = " . + showsPrec d (vkDstColorBlendFactor x) . + showString ", " . + showString "vkColorBlendOp = " . + showsPrec d (vkColorBlendOp x) . + showString ", " . + showString "vkSrcAlphaBlendFactor = " . + showsPrec d (vkSrcAlphaBlendFactor x) . + showString ", " . + showString "vkDstAlphaBlendFactor = " . + showsPrec d (vkDstAlphaBlendFactor x) . + showString ", " . + showString "vkAlphaBlendOp = " . + showsPrec d (vkAlphaBlendOp x) . + showString ", " . + showString "vkColorWriteMask = " . + showsPrec d (vkColorWriteMask x) . + showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkPipelineColorBlendStateCreateInfo.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkPipelineColorBlendStateCreateInfo.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkPipelineColorBlendStateCreateInfo.hsc @@ -0,0 +1,643 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleContexts #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE ScopedTypeVariables #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +{-# LANGUAGE UndecidableInstances #-} +module Graphics.Vulkan.Types.Struct.VkPipelineColorBlendStateCreateInfo + (VkPipelineColorBlendStateCreateInfo(..)) where +import Foreign.Storable + (Storable (..)) +import GHC.Prim +import GHC.TypeLits + (KnownNat, + natVal') -- ' closing tick for hsc2hs +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.BaseTypes + (VkBool32) +import Graphics.Vulkan.Types.Bitmasks + (VkPipelineColorBlendStateCreateFlags) +import Graphics.Vulkan.Types.Enum.VkLogicOp + (VkLogicOp) +import Graphics.Vulkan.Types.Enum.VkStructureType + (VkStructureType) +import Graphics.Vulkan.Types.Struct.VkPipelineColorBlendAttachmentState + (VkPipelineColorBlendAttachmentState) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe + (unsafeDupablePerformIO) + +-- | > typedef struct VkPipelineColorBlendStateCreateInfo { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkPipelineColorBlendStateCreateFlags flags; +-- > VkBool32 logicOpEnable; +-- > VkLogicOp logicOp; +-- > uint32_t attachmentCount; +-- > const VkPipelineColorBlendAttachmentState* pAttachments; +-- > float blendConstants[4]; +-- > } VkPipelineColorBlendStateCreateInfo; +-- +-- +data VkPipelineColorBlendStateCreateInfo = VkPipelineColorBlendStateCreateInfo## Addr## + ByteArray## + +instance Eq VkPipelineColorBlendStateCreateInfo where + (VkPipelineColorBlendStateCreateInfo## a _) == + x@(VkPipelineColorBlendStateCreateInfo## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkPipelineColorBlendStateCreateInfo where + (VkPipelineColorBlendStateCreateInfo## a _) `compare` + x@(VkPipelineColorBlendStateCreateInfo## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkPipelineColorBlendStateCreateInfo where + sizeOf ~_ = #{size VkPipelineColorBlendStateCreateInfo} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkPipelineColorBlendStateCreateInfo} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkPipelineColorBlendStateCreateInfo + where + unsafeAddr (VkPipelineColorBlendStateCreateInfo## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkPipelineColorBlendStateCreateInfo## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkPipelineColorBlendStateCreateInfo## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkPipelineColorBlendStateCreateInfo where + type StructFields VkPipelineColorBlendStateCreateInfo = + '["sType", "pNext", "flags", "logicOpEnable", "logicOp", -- ' closing tick for hsc2hs + "attachmentCount", "pAttachments", "blendConstants"] + type CUnionType VkPipelineColorBlendStateCreateInfo = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkPipelineColorBlendStateCreateInfo = 'False -- ' closing tick for hsc2hs + type StructExtends VkPipelineColorBlendStateCreateInfo = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkPipelineColorBlendStateCreateInfo where + type VkSTypeMType VkPipelineColorBlendStateCreateInfo = + VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineColorBlendStateCreateInfo, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkPipelineColorBlendStateCreateInfo, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkPipelineColorBlendStateCreateInfo, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkPipelineColorBlendStateCreateInfo, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkPipelineColorBlendStateCreateInfo where + type FieldType "sType" VkPipelineColorBlendStateCreateInfo = + VkStructureType + type FieldOptional "sType" VkPipelineColorBlendStateCreateInfo = + 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkPipelineColorBlendStateCreateInfo = + #{offset VkPipelineColorBlendStateCreateInfo, sType} + type FieldIsArray "sType" VkPipelineColorBlendStateCreateInfo = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineColorBlendStateCreateInfo, sType} + +instance CanReadField "sType" VkPipelineColorBlendStateCreateInfo + where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkPipelineColorBlendStateCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkPipelineColorBlendStateCreateInfo where + type VkPNextMType VkPipelineColorBlendStateCreateInfo = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineColorBlendStateCreateInfo, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkPipelineColorBlendStateCreateInfo, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkPipelineColorBlendStateCreateInfo, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkPipelineColorBlendStateCreateInfo, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkPipelineColorBlendStateCreateInfo where + type FieldType "pNext" VkPipelineColorBlendStateCreateInfo = + Ptr Void + type FieldOptional "pNext" VkPipelineColorBlendStateCreateInfo = + 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkPipelineColorBlendStateCreateInfo = + #{offset VkPipelineColorBlendStateCreateInfo, pNext} + type FieldIsArray "pNext" VkPipelineColorBlendStateCreateInfo = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineColorBlendStateCreateInfo, pNext} + +instance CanReadField "pNext" VkPipelineColorBlendStateCreateInfo + where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkPipelineColorBlendStateCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkFlags VkPipelineColorBlendStateCreateInfo where + type VkFlagsMType VkPipelineColorBlendStateCreateInfo = + VkPipelineColorBlendStateCreateFlags + + {-# NOINLINE vkFlags #-} + vkFlags x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineColorBlendStateCreateInfo, flags}) + + {-# INLINE vkFlagsByteOffset #-} + vkFlagsByteOffset ~_ + = #{offset VkPipelineColorBlendStateCreateInfo, flags} + + {-# INLINE readVkFlags #-} + readVkFlags p + = peekByteOff p #{offset VkPipelineColorBlendStateCreateInfo, flags} + + {-# INLINE writeVkFlags #-} + writeVkFlags p + = pokeByteOff p #{offset VkPipelineColorBlendStateCreateInfo, flags} + +instance {-# OVERLAPPING #-} + HasField "flags" VkPipelineColorBlendStateCreateInfo where + type FieldType "flags" VkPipelineColorBlendStateCreateInfo = + VkPipelineColorBlendStateCreateFlags + type FieldOptional "flags" VkPipelineColorBlendStateCreateInfo = + 'True -- ' closing tick for hsc2hs + type FieldOffset "flags" VkPipelineColorBlendStateCreateInfo = + #{offset VkPipelineColorBlendStateCreateInfo, flags} + type FieldIsArray "flags" VkPipelineColorBlendStateCreateInfo = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineColorBlendStateCreateInfo, flags} + +instance CanReadField "flags" VkPipelineColorBlendStateCreateInfo + where + {-# INLINE getField #-} + getField = vkFlags + + {-# INLINE readField #-} + readField = readVkFlags + +instance CanWriteField "flags" VkPipelineColorBlendStateCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkFlags + +instance {-# OVERLAPPING #-} + HasVkLogicOpEnable VkPipelineColorBlendStateCreateInfo where + type VkLogicOpEnableMType VkPipelineColorBlendStateCreateInfo = + VkBool32 + + {-# NOINLINE vkLogicOpEnable #-} + vkLogicOpEnable x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineColorBlendStateCreateInfo, logicOpEnable}) + + {-# INLINE vkLogicOpEnableByteOffset #-} + vkLogicOpEnableByteOffset ~_ + = #{offset VkPipelineColorBlendStateCreateInfo, logicOpEnable} + + {-# INLINE readVkLogicOpEnable #-} + readVkLogicOpEnable p + = peekByteOff p #{offset VkPipelineColorBlendStateCreateInfo, logicOpEnable} + + {-# INLINE writeVkLogicOpEnable #-} + writeVkLogicOpEnable p + = pokeByteOff p #{offset VkPipelineColorBlendStateCreateInfo, logicOpEnable} + +instance {-# OVERLAPPING #-} + HasField "logicOpEnable" VkPipelineColorBlendStateCreateInfo where + type FieldType "logicOpEnable" VkPipelineColorBlendStateCreateInfo + = VkBool32 + type FieldOptional "logicOpEnable" + VkPipelineColorBlendStateCreateInfo + = 'False -- ' closing tick for hsc2hs + type FieldOffset "logicOpEnable" + VkPipelineColorBlendStateCreateInfo + = + #{offset VkPipelineColorBlendStateCreateInfo, logicOpEnable} + type FieldIsArray "logicOpEnable" + VkPipelineColorBlendStateCreateInfo + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineColorBlendStateCreateInfo, logicOpEnable} + +instance CanReadField "logicOpEnable" + VkPipelineColorBlendStateCreateInfo + where + {-# INLINE getField #-} + getField = vkLogicOpEnable + + {-# INLINE readField #-} + readField = readVkLogicOpEnable + +instance CanWriteField "logicOpEnable" + VkPipelineColorBlendStateCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkLogicOpEnable + +instance {-# OVERLAPPING #-} + HasVkLogicOp VkPipelineColorBlendStateCreateInfo where + type VkLogicOpMType VkPipelineColorBlendStateCreateInfo = VkLogicOp + + {-# NOINLINE vkLogicOp #-} + vkLogicOp x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineColorBlendStateCreateInfo, logicOp}) + + {-# INLINE vkLogicOpByteOffset #-} + vkLogicOpByteOffset ~_ + = #{offset VkPipelineColorBlendStateCreateInfo, logicOp} + + {-# INLINE readVkLogicOp #-} + readVkLogicOp p + = peekByteOff p #{offset VkPipelineColorBlendStateCreateInfo, logicOp} + + {-# INLINE writeVkLogicOp #-} + writeVkLogicOp p + = pokeByteOff p #{offset VkPipelineColorBlendStateCreateInfo, logicOp} + +instance {-# OVERLAPPING #-} + HasField "logicOp" VkPipelineColorBlendStateCreateInfo where + type FieldType "logicOp" VkPipelineColorBlendStateCreateInfo = + VkLogicOp + type FieldOptional "logicOp" VkPipelineColorBlendStateCreateInfo = + 'False -- ' closing tick for hsc2hs + type FieldOffset "logicOp" VkPipelineColorBlendStateCreateInfo = + #{offset VkPipelineColorBlendStateCreateInfo, logicOp} + type FieldIsArray "logicOp" VkPipelineColorBlendStateCreateInfo = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineColorBlendStateCreateInfo, logicOp} + +instance CanReadField "logicOp" VkPipelineColorBlendStateCreateInfo + where + {-# INLINE getField #-} + getField = vkLogicOp + + {-# INLINE readField #-} + readField = readVkLogicOp + +instance CanWriteField "logicOp" + VkPipelineColorBlendStateCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkLogicOp + +instance {-# OVERLAPPING #-} + HasVkAttachmentCount VkPipelineColorBlendStateCreateInfo where + type VkAttachmentCountMType VkPipelineColorBlendStateCreateInfo = + Word32 + + {-# NOINLINE vkAttachmentCount #-} + vkAttachmentCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineColorBlendStateCreateInfo, attachmentCount}) + + {-# INLINE vkAttachmentCountByteOffset #-} + vkAttachmentCountByteOffset ~_ + = #{offset VkPipelineColorBlendStateCreateInfo, attachmentCount} + + {-# INLINE readVkAttachmentCount #-} + readVkAttachmentCount p + = peekByteOff p #{offset VkPipelineColorBlendStateCreateInfo, attachmentCount} + + {-# INLINE writeVkAttachmentCount #-} + writeVkAttachmentCount p + = pokeByteOff p #{offset VkPipelineColorBlendStateCreateInfo, attachmentCount} + +instance {-# OVERLAPPING #-} + HasField "attachmentCount" VkPipelineColorBlendStateCreateInfo + where + type FieldType "attachmentCount" + VkPipelineColorBlendStateCreateInfo + = Word32 + type FieldOptional "attachmentCount" + VkPipelineColorBlendStateCreateInfo + = 'True -- ' closing tick for hsc2hs + type FieldOffset "attachmentCount" + VkPipelineColorBlendStateCreateInfo + = + #{offset VkPipelineColorBlendStateCreateInfo, attachmentCount} + type FieldIsArray "attachmentCount" + VkPipelineColorBlendStateCreateInfo + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineColorBlendStateCreateInfo, attachmentCount} + +instance CanReadField "attachmentCount" + VkPipelineColorBlendStateCreateInfo + where + {-# INLINE getField #-} + getField = vkAttachmentCount + + {-# INLINE readField #-} + readField = readVkAttachmentCount + +instance CanWriteField "attachmentCount" + VkPipelineColorBlendStateCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkAttachmentCount + +instance {-# OVERLAPPING #-} + HasVkPAttachments VkPipelineColorBlendStateCreateInfo where + type VkPAttachmentsMType VkPipelineColorBlendStateCreateInfo = + Ptr VkPipelineColorBlendAttachmentState + + {-# NOINLINE vkPAttachments #-} + vkPAttachments x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineColorBlendStateCreateInfo, pAttachments}) + + {-# INLINE vkPAttachmentsByteOffset #-} + vkPAttachmentsByteOffset ~_ + = #{offset VkPipelineColorBlendStateCreateInfo, pAttachments} + + {-# INLINE readVkPAttachments #-} + readVkPAttachments p + = peekByteOff p #{offset VkPipelineColorBlendStateCreateInfo, pAttachments} + + {-# INLINE writeVkPAttachments #-} + writeVkPAttachments p + = pokeByteOff p #{offset VkPipelineColorBlendStateCreateInfo, pAttachments} + +instance {-# OVERLAPPING #-} + HasField "pAttachments" VkPipelineColorBlendStateCreateInfo where + type FieldType "pAttachments" VkPipelineColorBlendStateCreateInfo = + Ptr VkPipelineColorBlendAttachmentState + type FieldOptional "pAttachments" + VkPipelineColorBlendStateCreateInfo + = 'False -- ' closing tick for hsc2hs + type FieldOffset "pAttachments" VkPipelineColorBlendStateCreateInfo + = + #{offset VkPipelineColorBlendStateCreateInfo, pAttachments} + type FieldIsArray "pAttachments" + VkPipelineColorBlendStateCreateInfo + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineColorBlendStateCreateInfo, pAttachments} + +instance CanReadField "pAttachments" + VkPipelineColorBlendStateCreateInfo + where + {-# INLINE getField #-} + getField = vkPAttachments + + {-# INLINE readField #-} + readField = readVkPAttachments + +instance CanWriteField "pAttachments" + VkPipelineColorBlendStateCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkPAttachments + +instance {-# OVERLAPPING #-} + HasVkBlendConstantsArray VkPipelineColorBlendStateCreateInfo where + type VkBlendConstantsArrayMType VkPipelineColorBlendStateCreateInfo + = #{type float} + + {-# NOINLINE vkBlendConstantsArray #-} + vkBlendConstantsArray x idx + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) + (idx * sizeOf (undefined :: #{type float}) + + #{offset VkPipelineColorBlendStateCreateInfo, blendConstants})) + + {-# INLINE vkBlendConstantsArrayByteOffset #-} + vkBlendConstantsArrayByteOffset ~_ + = #{offset VkPipelineColorBlendStateCreateInfo, blendConstants} + + {-# INLINE readVkBlendConstantsArray #-} + readVkBlendConstantsArray p idx + = peekByteOff p + (idx * sizeOf (undefined :: #{type float}) + + #{offset VkPipelineColorBlendStateCreateInfo, blendConstants}) + + {-# INLINE writeVkBlendConstantsArray #-} + writeVkBlendConstantsArray p idx + = pokeByteOff p + (idx * sizeOf (undefined :: #{type float}) + + #{offset VkPipelineColorBlendStateCreateInfo, blendConstants}) + +instance {-# OVERLAPPING #-} + HasField "blendConstants" VkPipelineColorBlendStateCreateInfo where + type FieldType "blendConstants" VkPipelineColorBlendStateCreateInfo + = #{type float} + type FieldOptional "blendConstants" + VkPipelineColorBlendStateCreateInfo + = 'False -- ' closing tick for hsc2hs + type FieldOffset "blendConstants" + VkPipelineColorBlendStateCreateInfo + = + #{offset VkPipelineColorBlendStateCreateInfo, blendConstants} + type FieldIsArray "blendConstants" + VkPipelineColorBlendStateCreateInfo + = 'True -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineColorBlendStateCreateInfo, blendConstants} + +instance (KnownNat idx, + IndexInBounds "blendConstants" idx + VkPipelineColorBlendStateCreateInfo) => + CanReadFieldArray "blendConstants" idx + VkPipelineColorBlendStateCreateInfo + where + {-# SPECIALISE instance + CanReadFieldArray "blendConstants" 0 + VkPipelineColorBlendStateCreateInfo + #-} + + {-# SPECIALISE instance + CanReadFieldArray "blendConstants" 1 + VkPipelineColorBlendStateCreateInfo + #-} + + {-# SPECIALISE instance + CanReadFieldArray "blendConstants" 2 + VkPipelineColorBlendStateCreateInfo + #-} + + {-# SPECIALISE instance + CanReadFieldArray "blendConstants" 3 + VkPipelineColorBlendStateCreateInfo + #-} + type FieldArrayLength "blendConstants" + VkPipelineColorBlendStateCreateInfo + = 4 + + {-# INLINE fieldArrayLength #-} + fieldArrayLength = 4 + + {-# INLINE getFieldArray #-} + getFieldArray x + = vkBlendConstantsArray x + (fromInteger $ natVal' (proxy## :: Proxy## idx)) -- ' closing tick for hsc2hs + + {-# INLINE readFieldArray #-} + readFieldArray x + = readVkBlendConstantsArray x + (fromInteger $ natVal' (proxy## :: Proxy## idx)) -- ' closing tick for hsc2hs + +instance (KnownNat idx, + IndexInBounds "blendConstants" idx + VkPipelineColorBlendStateCreateInfo) => + CanWriteFieldArray "blendConstants" idx + VkPipelineColorBlendStateCreateInfo + where + {-# SPECIALISE instance + CanWriteFieldArray "blendConstants" 0 + VkPipelineColorBlendStateCreateInfo + #-} + + {-# SPECIALISE instance + CanWriteFieldArray "blendConstants" 1 + VkPipelineColorBlendStateCreateInfo + #-} + + {-# SPECIALISE instance + CanWriteFieldArray "blendConstants" 2 + VkPipelineColorBlendStateCreateInfo + #-} + + {-# SPECIALISE instance + CanWriteFieldArray "blendConstants" 3 + VkPipelineColorBlendStateCreateInfo + #-} + + {-# INLINE writeFieldArray #-} + writeFieldArray x + = writeVkBlendConstantsArray x + (fromInteger $ natVal' (proxy## :: Proxy## idx)) -- ' closing tick for hsc2hs + +instance Show VkPipelineColorBlendStateCreateInfo where + showsPrec d x + = showString "VkPipelineColorBlendStateCreateInfo {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkFlags = " . + showsPrec d (vkFlags x) . + showString ", " . + showString "vkLogicOpEnable = " . + showsPrec d (vkLogicOpEnable x) . + showString ", " . + showString "vkLogicOp = " . + showsPrec d (vkLogicOp x) . + showString ", " . + showString "vkAttachmentCount = " . + showsPrec d (vkAttachmentCount x) . + showString ", " . + showString "vkPAttachments = " . + showsPrec d (vkPAttachments x) . + showString ", " . + showString "vkBlendConstantsArray = [" . + showsPrec d + (map (vkBlendConstantsArray x) [1 .. 4]) + . showChar ']' . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkPipelineCoverageModulationStateCreateInfoNV.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkPipelineCoverageModulationStateCreateInfoNV.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkPipelineCoverageModulationStateCreateInfoNV.hsc @@ -0,0 +1,572 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkPipelineCoverageModulationStateCreateInfoNV + (VkPipelineCoverageModulationStateCreateInfoNV(..)) where +import Foreign.Storable + (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.BaseTypes + (VkBool32) +import Graphics.Vulkan.Types.Bitmasks + (VkPipelineCoverageModulationStateCreateFlagsNV) +import Graphics.Vulkan.Types.Enum.VkCoverageModulationModeNV + (VkCoverageModulationModeNV) +import Graphics.Vulkan.Types.Enum.VkStructureType + (VkStructureType) +import Graphics.Vulkan.Types.Struct.VkPipelineMultisampleStateCreateInfo + (VkPipelineMultisampleStateCreateInfo) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe + (unsafeDupablePerformIO) + +-- | > typedef struct VkPipelineCoverageModulationStateCreateInfoNV { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkPipelineCoverageModulationStateCreateFlagsNV flags; +-- > VkCoverageModulationModeNV coverageModulationMode; +-- > VkBool32 coverageModulationTableEnable; +-- > uint32_t coverageModulationTableCount; +-- > const float* pCoverageModulationTable; +-- > } VkPipelineCoverageModulationStateCreateInfoNV; +-- +-- +data VkPipelineCoverageModulationStateCreateInfoNV = VkPipelineCoverageModulationStateCreateInfoNV## Addr## + ByteArray## + +instance Eq VkPipelineCoverageModulationStateCreateInfoNV where + (VkPipelineCoverageModulationStateCreateInfoNV## a _) == + x@(VkPipelineCoverageModulationStateCreateInfoNV## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkPipelineCoverageModulationStateCreateInfoNV where + (VkPipelineCoverageModulationStateCreateInfoNV## a _) `compare` + x@(VkPipelineCoverageModulationStateCreateInfoNV## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkPipelineCoverageModulationStateCreateInfoNV + where + sizeOf ~_ + = #{size VkPipelineCoverageModulationStateCreateInfoNV} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkPipelineCoverageModulationStateCreateInfoNV} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim + VkPipelineCoverageModulationStateCreateInfoNV + where + unsafeAddr (VkPipelineCoverageModulationStateCreateInfoNV## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray + (VkPipelineCoverageModulationStateCreateInfoNV## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkPipelineCoverageModulationStateCreateInfoNV## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal + VkPipelineCoverageModulationStateCreateInfoNV + where + type StructFields VkPipelineCoverageModulationStateCreateInfoNV = + '["sType", "pNext", "flags", "coverageModulationMode", -- ' closing tick for hsc2hs + "coverageModulationTableEnable", "coverageModulationTableCount", + "pCoverageModulationTable"] + type CUnionType VkPipelineCoverageModulationStateCreateInfoNV = + 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkPipelineCoverageModulationStateCreateInfoNV = + 'False -- ' closing tick for hsc2hs + type StructExtends VkPipelineCoverageModulationStateCreateInfoNV = + '[VkPipelineMultisampleStateCreateInfo] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkPipelineCoverageModulationStateCreateInfoNV where + type VkSTypeMType VkPipelineCoverageModulationStateCreateInfoNV = + VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineCoverageModulationStateCreateInfoNV, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkPipelineCoverageModulationStateCreateInfoNV, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkPipelineCoverageModulationStateCreateInfoNV, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkPipelineCoverageModulationStateCreateInfoNV, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkPipelineCoverageModulationStateCreateInfoNV + where + type FieldType "sType" + VkPipelineCoverageModulationStateCreateInfoNV + = VkStructureType + type FieldOptional "sType" + VkPipelineCoverageModulationStateCreateInfoNV + = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" + VkPipelineCoverageModulationStateCreateInfoNV + = + #{offset VkPipelineCoverageModulationStateCreateInfoNV, sType} + type FieldIsArray "sType" + VkPipelineCoverageModulationStateCreateInfoNV + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineCoverageModulationStateCreateInfoNV, sType} + +instance CanReadField "sType" + VkPipelineCoverageModulationStateCreateInfoNV + where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" + VkPipelineCoverageModulationStateCreateInfoNV + where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkPipelineCoverageModulationStateCreateInfoNV where + type VkPNextMType VkPipelineCoverageModulationStateCreateInfoNV = + Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineCoverageModulationStateCreateInfoNV, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkPipelineCoverageModulationStateCreateInfoNV, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkPipelineCoverageModulationStateCreateInfoNV, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkPipelineCoverageModulationStateCreateInfoNV, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkPipelineCoverageModulationStateCreateInfoNV + where + type FieldType "pNext" + VkPipelineCoverageModulationStateCreateInfoNV + = Ptr Void + type FieldOptional "pNext" + VkPipelineCoverageModulationStateCreateInfoNV + = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" + VkPipelineCoverageModulationStateCreateInfoNV + = + #{offset VkPipelineCoverageModulationStateCreateInfoNV, pNext} + type FieldIsArray "pNext" + VkPipelineCoverageModulationStateCreateInfoNV + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineCoverageModulationStateCreateInfoNV, pNext} + +instance CanReadField "pNext" + VkPipelineCoverageModulationStateCreateInfoNV + where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" + VkPipelineCoverageModulationStateCreateInfoNV + where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkFlags VkPipelineCoverageModulationStateCreateInfoNV where + type VkFlagsMType VkPipelineCoverageModulationStateCreateInfoNV = + VkPipelineCoverageModulationStateCreateFlagsNV + + {-# NOINLINE vkFlags #-} + vkFlags x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineCoverageModulationStateCreateInfoNV, flags}) + + {-# INLINE vkFlagsByteOffset #-} + vkFlagsByteOffset ~_ + = #{offset VkPipelineCoverageModulationStateCreateInfoNV, flags} + + {-# INLINE readVkFlags #-} + readVkFlags p + = peekByteOff p #{offset VkPipelineCoverageModulationStateCreateInfoNV, flags} + + {-# INLINE writeVkFlags #-} + writeVkFlags p + = pokeByteOff p #{offset VkPipelineCoverageModulationStateCreateInfoNV, flags} + +instance {-# OVERLAPPING #-} + HasField "flags" VkPipelineCoverageModulationStateCreateInfoNV + where + type FieldType "flags" + VkPipelineCoverageModulationStateCreateInfoNV + = VkPipelineCoverageModulationStateCreateFlagsNV + type FieldOptional "flags" + VkPipelineCoverageModulationStateCreateInfoNV + = 'True -- ' closing tick for hsc2hs + type FieldOffset "flags" + VkPipelineCoverageModulationStateCreateInfoNV + = + #{offset VkPipelineCoverageModulationStateCreateInfoNV, flags} + type FieldIsArray "flags" + VkPipelineCoverageModulationStateCreateInfoNV + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineCoverageModulationStateCreateInfoNV, flags} + +instance CanReadField "flags" + VkPipelineCoverageModulationStateCreateInfoNV + where + {-# INLINE getField #-} + getField = vkFlags + + {-# INLINE readField #-} + readField = readVkFlags + +instance CanWriteField "flags" + VkPipelineCoverageModulationStateCreateInfoNV + where + {-# INLINE writeField #-} + writeField = writeVkFlags + +instance {-# OVERLAPPING #-} + HasVkCoverageModulationMode + VkPipelineCoverageModulationStateCreateInfoNV + where + type VkCoverageModulationModeMType + VkPipelineCoverageModulationStateCreateInfoNV + = VkCoverageModulationModeNV + + {-# NOINLINE vkCoverageModulationMode #-} + vkCoverageModulationMode x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineCoverageModulationStateCreateInfoNV, coverageModulationMode}) + + {-# INLINE vkCoverageModulationModeByteOffset #-} + vkCoverageModulationModeByteOffset ~_ + = #{offset VkPipelineCoverageModulationStateCreateInfoNV, coverageModulationMode} + + {-# INLINE readVkCoverageModulationMode #-} + readVkCoverageModulationMode p + = peekByteOff p #{offset VkPipelineCoverageModulationStateCreateInfoNV, coverageModulationMode} + + {-# INLINE writeVkCoverageModulationMode #-} + writeVkCoverageModulationMode p + = pokeByteOff p #{offset VkPipelineCoverageModulationStateCreateInfoNV, coverageModulationMode} + +instance {-# OVERLAPPING #-} + HasField "coverageModulationMode" + VkPipelineCoverageModulationStateCreateInfoNV + where + type FieldType "coverageModulationMode" + VkPipelineCoverageModulationStateCreateInfoNV + = VkCoverageModulationModeNV + type FieldOptional "coverageModulationMode" + VkPipelineCoverageModulationStateCreateInfoNV + = 'False -- ' closing tick for hsc2hs + type FieldOffset "coverageModulationMode" + VkPipelineCoverageModulationStateCreateInfoNV + = + #{offset VkPipelineCoverageModulationStateCreateInfoNV, coverageModulationMode} + type FieldIsArray "coverageModulationMode" + VkPipelineCoverageModulationStateCreateInfoNV + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineCoverageModulationStateCreateInfoNV, coverageModulationMode} + +instance CanReadField "coverageModulationMode" + VkPipelineCoverageModulationStateCreateInfoNV + where + {-# INLINE getField #-} + getField = vkCoverageModulationMode + + {-# INLINE readField #-} + readField = readVkCoverageModulationMode + +instance CanWriteField "coverageModulationMode" + VkPipelineCoverageModulationStateCreateInfoNV + where + {-# INLINE writeField #-} + writeField = writeVkCoverageModulationMode + +instance {-# OVERLAPPING #-} + HasVkCoverageModulationTableEnable + VkPipelineCoverageModulationStateCreateInfoNV + where + type VkCoverageModulationTableEnableMType + VkPipelineCoverageModulationStateCreateInfoNV + = VkBool32 + + {-# NOINLINE vkCoverageModulationTableEnable #-} + vkCoverageModulationTableEnable x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineCoverageModulationStateCreateInfoNV, coverageModulationTableEnable}) + + {-# INLINE vkCoverageModulationTableEnableByteOffset #-} + vkCoverageModulationTableEnableByteOffset ~_ + = #{offset VkPipelineCoverageModulationStateCreateInfoNV, coverageModulationTableEnable} + + {-# INLINE readVkCoverageModulationTableEnable #-} + readVkCoverageModulationTableEnable p + = peekByteOff p #{offset VkPipelineCoverageModulationStateCreateInfoNV, coverageModulationTableEnable} + + {-# INLINE writeVkCoverageModulationTableEnable #-} + writeVkCoverageModulationTableEnable p + = pokeByteOff p #{offset VkPipelineCoverageModulationStateCreateInfoNV, coverageModulationTableEnable} + +instance {-# OVERLAPPING #-} + HasField "coverageModulationTableEnable" + VkPipelineCoverageModulationStateCreateInfoNV + where + type FieldType "coverageModulationTableEnable" + VkPipelineCoverageModulationStateCreateInfoNV + = VkBool32 + type FieldOptional "coverageModulationTableEnable" + VkPipelineCoverageModulationStateCreateInfoNV + = 'False -- ' closing tick for hsc2hs + type FieldOffset "coverageModulationTableEnable" + VkPipelineCoverageModulationStateCreateInfoNV + = + #{offset VkPipelineCoverageModulationStateCreateInfoNV, coverageModulationTableEnable} + type FieldIsArray "coverageModulationTableEnable" + VkPipelineCoverageModulationStateCreateInfoNV + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineCoverageModulationStateCreateInfoNV, coverageModulationTableEnable} + +instance CanReadField "coverageModulationTableEnable" + VkPipelineCoverageModulationStateCreateInfoNV + where + {-# INLINE getField #-} + getField = vkCoverageModulationTableEnable + + {-# INLINE readField #-} + readField = readVkCoverageModulationTableEnable + +instance CanWriteField "coverageModulationTableEnable" + VkPipelineCoverageModulationStateCreateInfoNV + where + {-# INLINE writeField #-} + writeField = writeVkCoverageModulationTableEnable + +instance {-# OVERLAPPING #-} + HasVkCoverageModulationTableCount + VkPipelineCoverageModulationStateCreateInfoNV + where + type VkCoverageModulationTableCountMType + VkPipelineCoverageModulationStateCreateInfoNV + = Word32 + + {-# NOINLINE vkCoverageModulationTableCount #-} + vkCoverageModulationTableCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineCoverageModulationStateCreateInfoNV, coverageModulationTableCount}) + + {-# INLINE vkCoverageModulationTableCountByteOffset #-} + vkCoverageModulationTableCountByteOffset ~_ + = #{offset VkPipelineCoverageModulationStateCreateInfoNV, coverageModulationTableCount} + + {-# INLINE readVkCoverageModulationTableCount #-} + readVkCoverageModulationTableCount p + = peekByteOff p #{offset VkPipelineCoverageModulationStateCreateInfoNV, coverageModulationTableCount} + + {-# INLINE writeVkCoverageModulationTableCount #-} + writeVkCoverageModulationTableCount p + = pokeByteOff p #{offset VkPipelineCoverageModulationStateCreateInfoNV, coverageModulationTableCount} + +instance {-# OVERLAPPING #-} + HasField "coverageModulationTableCount" + VkPipelineCoverageModulationStateCreateInfoNV + where + type FieldType "coverageModulationTableCount" + VkPipelineCoverageModulationStateCreateInfoNV + = Word32 + type FieldOptional "coverageModulationTableCount" + VkPipelineCoverageModulationStateCreateInfoNV + = 'False -- ' closing tick for hsc2hs + type FieldOffset "coverageModulationTableCount" + VkPipelineCoverageModulationStateCreateInfoNV + = + #{offset VkPipelineCoverageModulationStateCreateInfoNV, coverageModulationTableCount} + type FieldIsArray "coverageModulationTableCount" + VkPipelineCoverageModulationStateCreateInfoNV + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineCoverageModulationStateCreateInfoNV, coverageModulationTableCount} + +instance CanReadField "coverageModulationTableCount" + VkPipelineCoverageModulationStateCreateInfoNV + where + {-# INLINE getField #-} + getField = vkCoverageModulationTableCount + + {-# INLINE readField #-} + readField = readVkCoverageModulationTableCount + +instance CanWriteField "coverageModulationTableCount" + VkPipelineCoverageModulationStateCreateInfoNV + where + {-# INLINE writeField #-} + writeField = writeVkCoverageModulationTableCount + +instance {-# OVERLAPPING #-} + HasVkPCoverageModulationTable + VkPipelineCoverageModulationStateCreateInfoNV + where + type VkPCoverageModulationTableMType + VkPipelineCoverageModulationStateCreateInfoNV + = Ptr #{type float} + + {-# NOINLINE vkPCoverageModulationTable #-} + vkPCoverageModulationTable x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineCoverageModulationStateCreateInfoNV, pCoverageModulationTable}) + + {-# INLINE vkPCoverageModulationTableByteOffset #-} + vkPCoverageModulationTableByteOffset ~_ + = #{offset VkPipelineCoverageModulationStateCreateInfoNV, pCoverageModulationTable} + + {-# INLINE readVkPCoverageModulationTable #-} + readVkPCoverageModulationTable p + = peekByteOff p #{offset VkPipelineCoverageModulationStateCreateInfoNV, pCoverageModulationTable} + + {-# INLINE writeVkPCoverageModulationTable #-} + writeVkPCoverageModulationTable p + = pokeByteOff p #{offset VkPipelineCoverageModulationStateCreateInfoNV, pCoverageModulationTable} + +instance {-# OVERLAPPING #-} + HasField "pCoverageModulationTable" + VkPipelineCoverageModulationStateCreateInfoNV + where + type FieldType "pCoverageModulationTable" + VkPipelineCoverageModulationStateCreateInfoNV + = Ptr #{type float} + type FieldOptional "pCoverageModulationTable" + VkPipelineCoverageModulationStateCreateInfoNV + = 'True -- ' closing tick for hsc2hs + type FieldOffset "pCoverageModulationTable" + VkPipelineCoverageModulationStateCreateInfoNV + = + #{offset VkPipelineCoverageModulationStateCreateInfoNV, pCoverageModulationTable} + type FieldIsArray "pCoverageModulationTable" + VkPipelineCoverageModulationStateCreateInfoNV + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineCoverageModulationStateCreateInfoNV, pCoverageModulationTable} + +instance CanReadField "pCoverageModulationTable" + VkPipelineCoverageModulationStateCreateInfoNV + where + {-# INLINE getField #-} + getField = vkPCoverageModulationTable + + {-# INLINE readField #-} + readField = readVkPCoverageModulationTable + +instance CanWriteField "pCoverageModulationTable" + VkPipelineCoverageModulationStateCreateInfoNV + where + {-# INLINE writeField #-} + writeField = writeVkPCoverageModulationTable + +instance Show VkPipelineCoverageModulationStateCreateInfoNV where + showsPrec d x + = showString "VkPipelineCoverageModulationStateCreateInfoNV {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkFlags = " . + showsPrec d (vkFlags x) . + showString ", " . + showString "vkCoverageModulationMode = " . + showsPrec d (vkCoverageModulationMode x) . + showString ", " . + showString "vkCoverageModulationTableEnable = " . + showsPrec d (vkCoverageModulationTableEnable x) . + showString ", " . + showString "vkCoverageModulationTableCount = " . + showsPrec d (vkCoverageModulationTableCount x) . + showString ", " . + showString "vkPCoverageModulationTable = " . + showsPrec d (vkPCoverageModulationTable x) . + showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkPipelineCoverageToColorStateCreateInfoNV.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkPipelineCoverageToColorStateCreateInfoNV.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkPipelineCoverageToColorStateCreateInfoNV.hsc @@ -0,0 +1,418 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkPipelineCoverageToColorStateCreateInfoNV + (VkPipelineCoverageToColorStateCreateInfoNV(..)) where +import Foreign.Storable + (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.BaseTypes + (VkBool32) +import Graphics.Vulkan.Types.Bitmasks + (VkPipelineCoverageToColorStateCreateFlagsNV) +import Graphics.Vulkan.Types.Enum.VkStructureType + (VkStructureType) +import Graphics.Vulkan.Types.Struct.VkPipelineMultisampleStateCreateInfo + (VkPipelineMultisampleStateCreateInfo) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe + (unsafeDupablePerformIO) + +-- | > typedef struct VkPipelineCoverageToColorStateCreateInfoNV { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkPipelineCoverageToColorStateCreateFlagsNV flags; +-- > VkBool32 coverageToColorEnable; +-- > uint32_t coverageToColorLocation; +-- > } VkPipelineCoverageToColorStateCreateInfoNV; +-- +-- +data VkPipelineCoverageToColorStateCreateInfoNV = VkPipelineCoverageToColorStateCreateInfoNV## Addr## + ByteArray## + +instance Eq VkPipelineCoverageToColorStateCreateInfoNV where + (VkPipelineCoverageToColorStateCreateInfoNV## a _) == + x@(VkPipelineCoverageToColorStateCreateInfoNV## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkPipelineCoverageToColorStateCreateInfoNV where + (VkPipelineCoverageToColorStateCreateInfoNV## a _) `compare` + x@(VkPipelineCoverageToColorStateCreateInfoNV## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkPipelineCoverageToColorStateCreateInfoNV where + sizeOf ~_ + = #{size VkPipelineCoverageToColorStateCreateInfoNV} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkPipelineCoverageToColorStateCreateInfoNV} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim + VkPipelineCoverageToColorStateCreateInfoNV + where + unsafeAddr (VkPipelineCoverageToColorStateCreateInfoNV## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkPipelineCoverageToColorStateCreateInfoNV## _ b) + = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkPipelineCoverageToColorStateCreateInfoNV## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkPipelineCoverageToColorStateCreateInfoNV + where + type StructFields VkPipelineCoverageToColorStateCreateInfoNV = + '["sType", "pNext", "flags", "coverageToColorEnable", -- ' closing tick for hsc2hs + "coverageToColorLocation"] + type CUnionType VkPipelineCoverageToColorStateCreateInfoNV = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkPipelineCoverageToColorStateCreateInfoNV = + 'False -- ' closing tick for hsc2hs + type StructExtends VkPipelineCoverageToColorStateCreateInfoNV = + '[VkPipelineMultisampleStateCreateInfo] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkPipelineCoverageToColorStateCreateInfoNV where + type VkSTypeMType VkPipelineCoverageToColorStateCreateInfoNV = + VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineCoverageToColorStateCreateInfoNV, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkPipelineCoverageToColorStateCreateInfoNV, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkPipelineCoverageToColorStateCreateInfoNV, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkPipelineCoverageToColorStateCreateInfoNV, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkPipelineCoverageToColorStateCreateInfoNV where + type FieldType "sType" VkPipelineCoverageToColorStateCreateInfoNV = + VkStructureType + type FieldOptional "sType" + VkPipelineCoverageToColorStateCreateInfoNV + = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkPipelineCoverageToColorStateCreateInfoNV + = + #{offset VkPipelineCoverageToColorStateCreateInfoNV, sType} + type FieldIsArray "sType" + VkPipelineCoverageToColorStateCreateInfoNV + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineCoverageToColorStateCreateInfoNV, sType} + +instance CanReadField "sType" + VkPipelineCoverageToColorStateCreateInfoNV + where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" + VkPipelineCoverageToColorStateCreateInfoNV + where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkPipelineCoverageToColorStateCreateInfoNV where + type VkPNextMType VkPipelineCoverageToColorStateCreateInfoNV = + Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineCoverageToColorStateCreateInfoNV, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkPipelineCoverageToColorStateCreateInfoNV, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkPipelineCoverageToColorStateCreateInfoNV, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkPipelineCoverageToColorStateCreateInfoNV, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkPipelineCoverageToColorStateCreateInfoNV where + type FieldType "pNext" VkPipelineCoverageToColorStateCreateInfoNV = + Ptr Void + type FieldOptional "pNext" + VkPipelineCoverageToColorStateCreateInfoNV + = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkPipelineCoverageToColorStateCreateInfoNV + = + #{offset VkPipelineCoverageToColorStateCreateInfoNV, pNext} + type FieldIsArray "pNext" + VkPipelineCoverageToColorStateCreateInfoNV + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineCoverageToColorStateCreateInfoNV, pNext} + +instance CanReadField "pNext" + VkPipelineCoverageToColorStateCreateInfoNV + where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" + VkPipelineCoverageToColorStateCreateInfoNV + where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkFlags VkPipelineCoverageToColorStateCreateInfoNV where + type VkFlagsMType VkPipelineCoverageToColorStateCreateInfoNV = + VkPipelineCoverageToColorStateCreateFlagsNV + + {-# NOINLINE vkFlags #-} + vkFlags x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineCoverageToColorStateCreateInfoNV, flags}) + + {-# INLINE vkFlagsByteOffset #-} + vkFlagsByteOffset ~_ + = #{offset VkPipelineCoverageToColorStateCreateInfoNV, flags} + + {-# INLINE readVkFlags #-} + readVkFlags p + = peekByteOff p #{offset VkPipelineCoverageToColorStateCreateInfoNV, flags} + + {-# INLINE writeVkFlags #-} + writeVkFlags p + = pokeByteOff p #{offset VkPipelineCoverageToColorStateCreateInfoNV, flags} + +instance {-# OVERLAPPING #-} + HasField "flags" VkPipelineCoverageToColorStateCreateInfoNV where + type FieldType "flags" VkPipelineCoverageToColorStateCreateInfoNV = + VkPipelineCoverageToColorStateCreateFlagsNV + type FieldOptional "flags" + VkPipelineCoverageToColorStateCreateInfoNV + = 'True -- ' closing tick for hsc2hs + type FieldOffset "flags" VkPipelineCoverageToColorStateCreateInfoNV + = + #{offset VkPipelineCoverageToColorStateCreateInfoNV, flags} + type FieldIsArray "flags" + VkPipelineCoverageToColorStateCreateInfoNV + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineCoverageToColorStateCreateInfoNV, flags} + +instance CanReadField "flags" + VkPipelineCoverageToColorStateCreateInfoNV + where + {-# INLINE getField #-} + getField = vkFlags + + {-# INLINE readField #-} + readField = readVkFlags + +instance CanWriteField "flags" + VkPipelineCoverageToColorStateCreateInfoNV + where + {-# INLINE writeField #-} + writeField = writeVkFlags + +instance {-# OVERLAPPING #-} + HasVkCoverageToColorEnable + VkPipelineCoverageToColorStateCreateInfoNV + where + type VkCoverageToColorEnableMType + VkPipelineCoverageToColorStateCreateInfoNV + = VkBool32 + + {-# NOINLINE vkCoverageToColorEnable #-} + vkCoverageToColorEnable x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineCoverageToColorStateCreateInfoNV, coverageToColorEnable}) + + {-# INLINE vkCoverageToColorEnableByteOffset #-} + vkCoverageToColorEnableByteOffset ~_ + = #{offset VkPipelineCoverageToColorStateCreateInfoNV, coverageToColorEnable} + + {-# INLINE readVkCoverageToColorEnable #-} + readVkCoverageToColorEnable p + = peekByteOff p #{offset VkPipelineCoverageToColorStateCreateInfoNV, coverageToColorEnable} + + {-# INLINE writeVkCoverageToColorEnable #-} + writeVkCoverageToColorEnable p + = pokeByteOff p #{offset VkPipelineCoverageToColorStateCreateInfoNV, coverageToColorEnable} + +instance {-# OVERLAPPING #-} + HasField "coverageToColorEnable" + VkPipelineCoverageToColorStateCreateInfoNV + where + type FieldType "coverageToColorEnable" + VkPipelineCoverageToColorStateCreateInfoNV + = VkBool32 + type FieldOptional "coverageToColorEnable" + VkPipelineCoverageToColorStateCreateInfoNV + = 'False -- ' closing tick for hsc2hs + type FieldOffset "coverageToColorEnable" + VkPipelineCoverageToColorStateCreateInfoNV + = + #{offset VkPipelineCoverageToColorStateCreateInfoNV, coverageToColorEnable} + type FieldIsArray "coverageToColorEnable" + VkPipelineCoverageToColorStateCreateInfoNV + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineCoverageToColorStateCreateInfoNV, coverageToColorEnable} + +instance CanReadField "coverageToColorEnable" + VkPipelineCoverageToColorStateCreateInfoNV + where + {-# INLINE getField #-} + getField = vkCoverageToColorEnable + + {-# INLINE readField #-} + readField = readVkCoverageToColorEnable + +instance CanWriteField "coverageToColorEnable" + VkPipelineCoverageToColorStateCreateInfoNV + where + {-# INLINE writeField #-} + writeField = writeVkCoverageToColorEnable + +instance {-# OVERLAPPING #-} + HasVkCoverageToColorLocation + VkPipelineCoverageToColorStateCreateInfoNV + where + type VkCoverageToColorLocationMType + VkPipelineCoverageToColorStateCreateInfoNV + = Word32 + + {-# NOINLINE vkCoverageToColorLocation #-} + vkCoverageToColorLocation x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineCoverageToColorStateCreateInfoNV, coverageToColorLocation}) + + {-# INLINE vkCoverageToColorLocationByteOffset #-} + vkCoverageToColorLocationByteOffset ~_ + = #{offset VkPipelineCoverageToColorStateCreateInfoNV, coverageToColorLocation} + + {-# INLINE readVkCoverageToColorLocation #-} + readVkCoverageToColorLocation p + = peekByteOff p #{offset VkPipelineCoverageToColorStateCreateInfoNV, coverageToColorLocation} + + {-# INLINE writeVkCoverageToColorLocation #-} + writeVkCoverageToColorLocation p + = pokeByteOff p #{offset VkPipelineCoverageToColorStateCreateInfoNV, coverageToColorLocation} + +instance {-# OVERLAPPING #-} + HasField "coverageToColorLocation" + VkPipelineCoverageToColorStateCreateInfoNV + where + type FieldType "coverageToColorLocation" + VkPipelineCoverageToColorStateCreateInfoNV + = Word32 + type FieldOptional "coverageToColorLocation" + VkPipelineCoverageToColorStateCreateInfoNV + = 'True -- ' closing tick for hsc2hs + type FieldOffset "coverageToColorLocation" + VkPipelineCoverageToColorStateCreateInfoNV + = + #{offset VkPipelineCoverageToColorStateCreateInfoNV, coverageToColorLocation} + type FieldIsArray "coverageToColorLocation" + VkPipelineCoverageToColorStateCreateInfoNV + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineCoverageToColorStateCreateInfoNV, coverageToColorLocation} + +instance CanReadField "coverageToColorLocation" + VkPipelineCoverageToColorStateCreateInfoNV + where + {-# INLINE getField #-} + getField = vkCoverageToColorLocation + + {-# INLINE readField #-} + readField = readVkCoverageToColorLocation + +instance CanWriteField "coverageToColorLocation" + VkPipelineCoverageToColorStateCreateInfoNV + where + {-# INLINE writeField #-} + writeField = writeVkCoverageToColorLocation + +instance Show VkPipelineCoverageToColorStateCreateInfoNV where + showsPrec d x + = showString "VkPipelineCoverageToColorStateCreateInfoNV {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkFlags = " . + showsPrec d (vkFlags x) . + showString ", " . + showString "vkCoverageToColorEnable = " . + showsPrec d (vkCoverageToColorEnable x) . + showString ", " . + showString "vkCoverageToColorLocation = " . + showsPrec d (vkCoverageToColorLocation x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkPipelineDepthStencilStateCreateInfo.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkPipelineDepthStencilStateCreateInfo.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkPipelineDepthStencilStateCreateInfo.hsc @@ -0,0 +1,840 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkPipelineDepthStencilStateCreateInfo + (VkPipelineDepthStencilStateCreateInfo(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.BaseTypes (VkBool32) +import Graphics.Vulkan.Types.Bitmasks (VkPipelineDepthStencilStateCreateFlags) +import Graphics.Vulkan.Types.Enum.VkCompareOp (VkCompareOp) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Struct.VkStencilOpState (VkStencilOpState) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkPipelineDepthStencilStateCreateInfo { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkPipelineDepthStencilStateCreateFlags flags; +-- > VkBool32 depthTestEnable; +-- > VkBool32 depthWriteEnable; +-- > VkCompareOp depthCompareOp; +-- > VkBool32 depthBoundsTestEnable; +-- > VkBool32 stencilTestEnable; +-- > VkStencilOpState front; +-- > VkStencilOpState back; +-- > float minDepthBounds; +-- > float maxDepthBounds; +-- > } VkPipelineDepthStencilStateCreateInfo; +-- +-- +data VkPipelineDepthStencilStateCreateInfo = VkPipelineDepthStencilStateCreateInfo## Addr## + ByteArray## + +instance Eq VkPipelineDepthStencilStateCreateInfo where + (VkPipelineDepthStencilStateCreateInfo## a _) == + x@(VkPipelineDepthStencilStateCreateInfo## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkPipelineDepthStencilStateCreateInfo where + (VkPipelineDepthStencilStateCreateInfo## a _) `compare` + x@(VkPipelineDepthStencilStateCreateInfo## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkPipelineDepthStencilStateCreateInfo where + sizeOf ~_ + = #{size VkPipelineDepthStencilStateCreateInfo} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkPipelineDepthStencilStateCreateInfo} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkPipelineDepthStencilStateCreateInfo + where + unsafeAddr (VkPipelineDepthStencilStateCreateInfo## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkPipelineDepthStencilStateCreateInfo## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkPipelineDepthStencilStateCreateInfo## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkPipelineDepthStencilStateCreateInfo where + type StructFields VkPipelineDepthStencilStateCreateInfo = + '["sType", "pNext", "flags", "depthTestEnable", "depthWriteEnable", -- ' closing tick for hsc2hs + "depthCompareOp", "depthBoundsTestEnable", "stencilTestEnable", + "front", "back", "minDepthBounds", "maxDepthBounds"] + type CUnionType VkPipelineDepthStencilStateCreateInfo = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkPipelineDepthStencilStateCreateInfo = 'False -- ' closing tick for hsc2hs + type StructExtends VkPipelineDepthStencilStateCreateInfo = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkPipelineDepthStencilStateCreateInfo where + type VkSTypeMType VkPipelineDepthStencilStateCreateInfo = + VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineDepthStencilStateCreateInfo, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkPipelineDepthStencilStateCreateInfo, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkPipelineDepthStencilStateCreateInfo, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkPipelineDepthStencilStateCreateInfo, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkPipelineDepthStencilStateCreateInfo where + type FieldType "sType" VkPipelineDepthStencilStateCreateInfo = + VkStructureType + type FieldOptional "sType" VkPipelineDepthStencilStateCreateInfo = + 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkPipelineDepthStencilStateCreateInfo = + #{offset VkPipelineDepthStencilStateCreateInfo, sType} + type FieldIsArray "sType" VkPipelineDepthStencilStateCreateInfo = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineDepthStencilStateCreateInfo, sType} + +instance CanReadField "sType" VkPipelineDepthStencilStateCreateInfo + where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" + VkPipelineDepthStencilStateCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkPipelineDepthStencilStateCreateInfo where + type VkPNextMType VkPipelineDepthStencilStateCreateInfo = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineDepthStencilStateCreateInfo, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkPipelineDepthStencilStateCreateInfo, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkPipelineDepthStencilStateCreateInfo, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkPipelineDepthStencilStateCreateInfo, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkPipelineDepthStencilStateCreateInfo where + type FieldType "pNext" VkPipelineDepthStencilStateCreateInfo = + Ptr Void + type FieldOptional "pNext" VkPipelineDepthStencilStateCreateInfo = + 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkPipelineDepthStencilStateCreateInfo = + #{offset VkPipelineDepthStencilStateCreateInfo, pNext} + type FieldIsArray "pNext" VkPipelineDepthStencilStateCreateInfo = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineDepthStencilStateCreateInfo, pNext} + +instance CanReadField "pNext" VkPipelineDepthStencilStateCreateInfo + where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" + VkPipelineDepthStencilStateCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkFlags VkPipelineDepthStencilStateCreateInfo where + type VkFlagsMType VkPipelineDepthStencilStateCreateInfo = + VkPipelineDepthStencilStateCreateFlags + + {-# NOINLINE vkFlags #-} + vkFlags x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineDepthStencilStateCreateInfo, flags}) + + {-# INLINE vkFlagsByteOffset #-} + vkFlagsByteOffset ~_ + = #{offset VkPipelineDepthStencilStateCreateInfo, flags} + + {-# INLINE readVkFlags #-} + readVkFlags p + = peekByteOff p #{offset VkPipelineDepthStencilStateCreateInfo, flags} + + {-# INLINE writeVkFlags #-} + writeVkFlags p + = pokeByteOff p #{offset VkPipelineDepthStencilStateCreateInfo, flags} + +instance {-# OVERLAPPING #-} + HasField "flags" VkPipelineDepthStencilStateCreateInfo where + type FieldType "flags" VkPipelineDepthStencilStateCreateInfo = + VkPipelineDepthStencilStateCreateFlags + type FieldOptional "flags" VkPipelineDepthStencilStateCreateInfo = + 'True -- ' closing tick for hsc2hs + type FieldOffset "flags" VkPipelineDepthStencilStateCreateInfo = + #{offset VkPipelineDepthStencilStateCreateInfo, flags} + type FieldIsArray "flags" VkPipelineDepthStencilStateCreateInfo = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineDepthStencilStateCreateInfo, flags} + +instance CanReadField "flags" VkPipelineDepthStencilStateCreateInfo + where + {-# INLINE getField #-} + getField = vkFlags + + {-# INLINE readField #-} + readField = readVkFlags + +instance CanWriteField "flags" + VkPipelineDepthStencilStateCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkFlags + +instance {-# OVERLAPPING #-} + HasVkDepthTestEnable VkPipelineDepthStencilStateCreateInfo where + type VkDepthTestEnableMType VkPipelineDepthStencilStateCreateInfo = + VkBool32 + + {-# NOINLINE vkDepthTestEnable #-} + vkDepthTestEnable x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineDepthStencilStateCreateInfo, depthTestEnable}) + + {-# INLINE vkDepthTestEnableByteOffset #-} + vkDepthTestEnableByteOffset ~_ + = #{offset VkPipelineDepthStencilStateCreateInfo, depthTestEnable} + + {-# INLINE readVkDepthTestEnable #-} + readVkDepthTestEnable p + = peekByteOff p #{offset VkPipelineDepthStencilStateCreateInfo, depthTestEnable} + + {-# INLINE writeVkDepthTestEnable #-} + writeVkDepthTestEnable p + = pokeByteOff p #{offset VkPipelineDepthStencilStateCreateInfo, depthTestEnable} + +instance {-# OVERLAPPING #-} + HasField "depthTestEnable" VkPipelineDepthStencilStateCreateInfo + where + type FieldType "depthTestEnable" + VkPipelineDepthStencilStateCreateInfo + = VkBool32 + type FieldOptional "depthTestEnable" + VkPipelineDepthStencilStateCreateInfo + = 'False -- ' closing tick for hsc2hs + type FieldOffset "depthTestEnable" + VkPipelineDepthStencilStateCreateInfo + = + #{offset VkPipelineDepthStencilStateCreateInfo, depthTestEnable} + type FieldIsArray "depthTestEnable" + VkPipelineDepthStencilStateCreateInfo + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineDepthStencilStateCreateInfo, depthTestEnable} + +instance CanReadField "depthTestEnable" + VkPipelineDepthStencilStateCreateInfo + where + {-# INLINE getField #-} + getField = vkDepthTestEnable + + {-# INLINE readField #-} + readField = readVkDepthTestEnable + +instance CanWriteField "depthTestEnable" + VkPipelineDepthStencilStateCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkDepthTestEnable + +instance {-# OVERLAPPING #-} + HasVkDepthWriteEnable VkPipelineDepthStencilStateCreateInfo where + type VkDepthWriteEnableMType VkPipelineDepthStencilStateCreateInfo + = VkBool32 + + {-# NOINLINE vkDepthWriteEnable #-} + vkDepthWriteEnable x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineDepthStencilStateCreateInfo, depthWriteEnable}) + + {-# INLINE vkDepthWriteEnableByteOffset #-} + vkDepthWriteEnableByteOffset ~_ + = #{offset VkPipelineDepthStencilStateCreateInfo, depthWriteEnable} + + {-# INLINE readVkDepthWriteEnable #-} + readVkDepthWriteEnable p + = peekByteOff p #{offset VkPipelineDepthStencilStateCreateInfo, depthWriteEnable} + + {-# INLINE writeVkDepthWriteEnable #-} + writeVkDepthWriteEnable p + = pokeByteOff p #{offset VkPipelineDepthStencilStateCreateInfo, depthWriteEnable} + +instance {-# OVERLAPPING #-} + HasField "depthWriteEnable" VkPipelineDepthStencilStateCreateInfo + where + type FieldType "depthWriteEnable" + VkPipelineDepthStencilStateCreateInfo + = VkBool32 + type FieldOptional "depthWriteEnable" + VkPipelineDepthStencilStateCreateInfo + = 'False -- ' closing tick for hsc2hs + type FieldOffset "depthWriteEnable" + VkPipelineDepthStencilStateCreateInfo + = + #{offset VkPipelineDepthStencilStateCreateInfo, depthWriteEnable} + type FieldIsArray "depthWriteEnable" + VkPipelineDepthStencilStateCreateInfo + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineDepthStencilStateCreateInfo, depthWriteEnable} + +instance CanReadField "depthWriteEnable" + VkPipelineDepthStencilStateCreateInfo + where + {-# INLINE getField #-} + getField = vkDepthWriteEnable + + {-# INLINE readField #-} + readField = readVkDepthWriteEnable + +instance CanWriteField "depthWriteEnable" + VkPipelineDepthStencilStateCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkDepthWriteEnable + +instance {-# OVERLAPPING #-} + HasVkDepthCompareOp VkPipelineDepthStencilStateCreateInfo where + type VkDepthCompareOpMType VkPipelineDepthStencilStateCreateInfo = + VkCompareOp + + {-# NOINLINE vkDepthCompareOp #-} + vkDepthCompareOp x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineDepthStencilStateCreateInfo, depthCompareOp}) + + {-# INLINE vkDepthCompareOpByteOffset #-} + vkDepthCompareOpByteOffset ~_ + = #{offset VkPipelineDepthStencilStateCreateInfo, depthCompareOp} + + {-# INLINE readVkDepthCompareOp #-} + readVkDepthCompareOp p + = peekByteOff p #{offset VkPipelineDepthStencilStateCreateInfo, depthCompareOp} + + {-# INLINE writeVkDepthCompareOp #-} + writeVkDepthCompareOp p + = pokeByteOff p #{offset VkPipelineDepthStencilStateCreateInfo, depthCompareOp} + +instance {-# OVERLAPPING #-} + HasField "depthCompareOp" VkPipelineDepthStencilStateCreateInfo + where + type FieldType "depthCompareOp" + VkPipelineDepthStencilStateCreateInfo + = VkCompareOp + type FieldOptional "depthCompareOp" + VkPipelineDepthStencilStateCreateInfo + = 'False -- ' closing tick for hsc2hs + type FieldOffset "depthCompareOp" + VkPipelineDepthStencilStateCreateInfo + = + #{offset VkPipelineDepthStencilStateCreateInfo, depthCompareOp} + type FieldIsArray "depthCompareOp" + VkPipelineDepthStencilStateCreateInfo + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineDepthStencilStateCreateInfo, depthCompareOp} + +instance CanReadField "depthCompareOp" + VkPipelineDepthStencilStateCreateInfo + where + {-# INLINE getField #-} + getField = vkDepthCompareOp + + {-# INLINE readField #-} + readField = readVkDepthCompareOp + +instance CanWriteField "depthCompareOp" + VkPipelineDepthStencilStateCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkDepthCompareOp + +instance {-# OVERLAPPING #-} + HasVkDepthBoundsTestEnable VkPipelineDepthStencilStateCreateInfo + where + type VkDepthBoundsTestEnableMType + VkPipelineDepthStencilStateCreateInfo + = VkBool32 + + {-# NOINLINE vkDepthBoundsTestEnable #-} + vkDepthBoundsTestEnable x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineDepthStencilStateCreateInfo, depthBoundsTestEnable}) + + {-# INLINE vkDepthBoundsTestEnableByteOffset #-} + vkDepthBoundsTestEnableByteOffset ~_ + = #{offset VkPipelineDepthStencilStateCreateInfo, depthBoundsTestEnable} + + {-# INLINE readVkDepthBoundsTestEnable #-} + readVkDepthBoundsTestEnable p + = peekByteOff p #{offset VkPipelineDepthStencilStateCreateInfo, depthBoundsTestEnable} + + {-# INLINE writeVkDepthBoundsTestEnable #-} + writeVkDepthBoundsTestEnable p + = pokeByteOff p #{offset VkPipelineDepthStencilStateCreateInfo, depthBoundsTestEnable} + +instance {-# OVERLAPPING #-} + HasField "depthBoundsTestEnable" + VkPipelineDepthStencilStateCreateInfo + where + type FieldType "depthBoundsTestEnable" + VkPipelineDepthStencilStateCreateInfo + = VkBool32 + type FieldOptional "depthBoundsTestEnable" + VkPipelineDepthStencilStateCreateInfo + = 'False -- ' closing tick for hsc2hs + type FieldOffset "depthBoundsTestEnable" + VkPipelineDepthStencilStateCreateInfo + = + #{offset VkPipelineDepthStencilStateCreateInfo, depthBoundsTestEnable} + type FieldIsArray "depthBoundsTestEnable" + VkPipelineDepthStencilStateCreateInfo + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineDepthStencilStateCreateInfo, depthBoundsTestEnable} + +instance CanReadField "depthBoundsTestEnable" + VkPipelineDepthStencilStateCreateInfo + where + {-# INLINE getField #-} + getField = vkDepthBoundsTestEnable + + {-# INLINE readField #-} + readField = readVkDepthBoundsTestEnable + +instance CanWriteField "depthBoundsTestEnable" + VkPipelineDepthStencilStateCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkDepthBoundsTestEnable + +instance {-# OVERLAPPING #-} + HasVkStencilTestEnable VkPipelineDepthStencilStateCreateInfo where + type VkStencilTestEnableMType VkPipelineDepthStencilStateCreateInfo + = VkBool32 + + {-# NOINLINE vkStencilTestEnable #-} + vkStencilTestEnable x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineDepthStencilStateCreateInfo, stencilTestEnable}) + + {-# INLINE vkStencilTestEnableByteOffset #-} + vkStencilTestEnableByteOffset ~_ + = #{offset VkPipelineDepthStencilStateCreateInfo, stencilTestEnable} + + {-# INLINE readVkStencilTestEnable #-} + readVkStencilTestEnable p + = peekByteOff p #{offset VkPipelineDepthStencilStateCreateInfo, stencilTestEnable} + + {-# INLINE writeVkStencilTestEnable #-} + writeVkStencilTestEnable p + = pokeByteOff p #{offset VkPipelineDepthStencilStateCreateInfo, stencilTestEnable} + +instance {-# OVERLAPPING #-} + HasField "stencilTestEnable" VkPipelineDepthStencilStateCreateInfo + where + type FieldType "stencilTestEnable" + VkPipelineDepthStencilStateCreateInfo + = VkBool32 + type FieldOptional "stencilTestEnable" + VkPipelineDepthStencilStateCreateInfo + = 'False -- ' closing tick for hsc2hs + type FieldOffset "stencilTestEnable" + VkPipelineDepthStencilStateCreateInfo + = + #{offset VkPipelineDepthStencilStateCreateInfo, stencilTestEnable} + type FieldIsArray "stencilTestEnable" + VkPipelineDepthStencilStateCreateInfo + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineDepthStencilStateCreateInfo, stencilTestEnable} + +instance CanReadField "stencilTestEnable" + VkPipelineDepthStencilStateCreateInfo + where + {-# INLINE getField #-} + getField = vkStencilTestEnable + + {-# INLINE readField #-} + readField = readVkStencilTestEnable + +instance CanWriteField "stencilTestEnable" + VkPipelineDepthStencilStateCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkStencilTestEnable + +instance {-# OVERLAPPING #-} + HasVkFront VkPipelineDepthStencilStateCreateInfo where + type VkFrontMType VkPipelineDepthStencilStateCreateInfo = + VkStencilOpState + + {-# NOINLINE vkFront #-} + vkFront x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineDepthStencilStateCreateInfo, front}) + + {-# INLINE vkFrontByteOffset #-} + vkFrontByteOffset ~_ + = #{offset VkPipelineDepthStencilStateCreateInfo, front} + + {-# INLINE readVkFront #-} + readVkFront p + = peekByteOff p #{offset VkPipelineDepthStencilStateCreateInfo, front} + + {-# INLINE writeVkFront #-} + writeVkFront p + = pokeByteOff p #{offset VkPipelineDepthStencilStateCreateInfo, front} + +instance {-# OVERLAPPING #-} + HasField "front" VkPipelineDepthStencilStateCreateInfo where + type FieldType "front" VkPipelineDepthStencilStateCreateInfo = + VkStencilOpState + type FieldOptional "front" VkPipelineDepthStencilStateCreateInfo = + 'False -- ' closing tick for hsc2hs + type FieldOffset "front" VkPipelineDepthStencilStateCreateInfo = + #{offset VkPipelineDepthStencilStateCreateInfo, front} + type FieldIsArray "front" VkPipelineDepthStencilStateCreateInfo = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineDepthStencilStateCreateInfo, front} + +instance CanReadField "front" VkPipelineDepthStencilStateCreateInfo + where + {-# INLINE getField #-} + getField = vkFront + + {-# INLINE readField #-} + readField = readVkFront + +instance CanWriteField "front" + VkPipelineDepthStencilStateCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkFront + +instance {-# OVERLAPPING #-} + HasVkBack VkPipelineDepthStencilStateCreateInfo where + type VkBackMType VkPipelineDepthStencilStateCreateInfo = + VkStencilOpState + + {-# NOINLINE vkBack #-} + vkBack x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineDepthStencilStateCreateInfo, back}) + + {-# INLINE vkBackByteOffset #-} + vkBackByteOffset ~_ + = #{offset VkPipelineDepthStencilStateCreateInfo, back} + + {-# INLINE readVkBack #-} + readVkBack p + = peekByteOff p #{offset VkPipelineDepthStencilStateCreateInfo, back} + + {-# INLINE writeVkBack #-} + writeVkBack p + = pokeByteOff p #{offset VkPipelineDepthStencilStateCreateInfo, back} + +instance {-# OVERLAPPING #-} + HasField "back" VkPipelineDepthStencilStateCreateInfo where + type FieldType "back" VkPipelineDepthStencilStateCreateInfo = + VkStencilOpState + type FieldOptional "back" VkPipelineDepthStencilStateCreateInfo = + 'False -- ' closing tick for hsc2hs + type FieldOffset "back" VkPipelineDepthStencilStateCreateInfo = + #{offset VkPipelineDepthStencilStateCreateInfo, back} + type FieldIsArray "back" VkPipelineDepthStencilStateCreateInfo = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineDepthStencilStateCreateInfo, back} + +instance CanReadField "back" VkPipelineDepthStencilStateCreateInfo + where + {-# INLINE getField #-} + getField = vkBack + + {-# INLINE readField #-} + readField = readVkBack + +instance CanWriteField "back" VkPipelineDepthStencilStateCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkBack + +instance {-# OVERLAPPING #-} + HasVkMinDepthBounds VkPipelineDepthStencilStateCreateInfo where + type VkMinDepthBoundsMType VkPipelineDepthStencilStateCreateInfo = + #{type float} + + {-# NOINLINE vkMinDepthBounds #-} + vkMinDepthBounds x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineDepthStencilStateCreateInfo, minDepthBounds}) + + {-# INLINE vkMinDepthBoundsByteOffset #-} + vkMinDepthBoundsByteOffset ~_ + = #{offset VkPipelineDepthStencilStateCreateInfo, minDepthBounds} + + {-# INLINE readVkMinDepthBounds #-} + readVkMinDepthBounds p + = peekByteOff p #{offset VkPipelineDepthStencilStateCreateInfo, minDepthBounds} + + {-# INLINE writeVkMinDepthBounds #-} + writeVkMinDepthBounds p + = pokeByteOff p #{offset VkPipelineDepthStencilStateCreateInfo, minDepthBounds} + +instance {-# OVERLAPPING #-} + HasField "minDepthBounds" VkPipelineDepthStencilStateCreateInfo + where + type FieldType "minDepthBounds" + VkPipelineDepthStencilStateCreateInfo + = #{type float} + type FieldOptional "minDepthBounds" + VkPipelineDepthStencilStateCreateInfo + = 'False -- ' closing tick for hsc2hs + type FieldOffset "minDepthBounds" + VkPipelineDepthStencilStateCreateInfo + = + #{offset VkPipelineDepthStencilStateCreateInfo, minDepthBounds} + type FieldIsArray "minDepthBounds" + VkPipelineDepthStencilStateCreateInfo + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineDepthStencilStateCreateInfo, minDepthBounds} + +instance CanReadField "minDepthBounds" + VkPipelineDepthStencilStateCreateInfo + where + {-# INLINE getField #-} + getField = vkMinDepthBounds + + {-# INLINE readField #-} + readField = readVkMinDepthBounds + +instance CanWriteField "minDepthBounds" + VkPipelineDepthStencilStateCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkMinDepthBounds + +instance {-# OVERLAPPING #-} + HasVkMaxDepthBounds VkPipelineDepthStencilStateCreateInfo where + type VkMaxDepthBoundsMType VkPipelineDepthStencilStateCreateInfo = + #{type float} + + {-# NOINLINE vkMaxDepthBounds #-} + vkMaxDepthBounds x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineDepthStencilStateCreateInfo, maxDepthBounds}) + + {-# INLINE vkMaxDepthBoundsByteOffset #-} + vkMaxDepthBoundsByteOffset ~_ + = #{offset VkPipelineDepthStencilStateCreateInfo, maxDepthBounds} + + {-# INLINE readVkMaxDepthBounds #-} + readVkMaxDepthBounds p + = peekByteOff p #{offset VkPipelineDepthStencilStateCreateInfo, maxDepthBounds} + + {-# INLINE writeVkMaxDepthBounds #-} + writeVkMaxDepthBounds p + = pokeByteOff p #{offset VkPipelineDepthStencilStateCreateInfo, maxDepthBounds} + +instance {-# OVERLAPPING #-} + HasField "maxDepthBounds" VkPipelineDepthStencilStateCreateInfo + where + type FieldType "maxDepthBounds" + VkPipelineDepthStencilStateCreateInfo + = #{type float} + type FieldOptional "maxDepthBounds" + VkPipelineDepthStencilStateCreateInfo + = 'False -- ' closing tick for hsc2hs + type FieldOffset "maxDepthBounds" + VkPipelineDepthStencilStateCreateInfo + = + #{offset VkPipelineDepthStencilStateCreateInfo, maxDepthBounds} + type FieldIsArray "maxDepthBounds" + VkPipelineDepthStencilStateCreateInfo + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineDepthStencilStateCreateInfo, maxDepthBounds} + +instance CanReadField "maxDepthBounds" + VkPipelineDepthStencilStateCreateInfo + where + {-# INLINE getField #-} + getField = vkMaxDepthBounds + + {-# INLINE readField #-} + readField = readVkMaxDepthBounds + +instance CanWriteField "maxDepthBounds" + VkPipelineDepthStencilStateCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkMaxDepthBounds + +instance Show VkPipelineDepthStencilStateCreateInfo where + showsPrec d x + = showString "VkPipelineDepthStencilStateCreateInfo {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkFlags = " . + showsPrec d (vkFlags x) . + showString ", " . + showString "vkDepthTestEnable = " . + showsPrec d (vkDepthTestEnable x) . + showString ", " . + showString "vkDepthWriteEnable = " . + showsPrec d (vkDepthWriteEnable x) . + showString ", " . + showString "vkDepthCompareOp = " . + showsPrec d (vkDepthCompareOp x) . + showString ", " . + showString "vkDepthBoundsTestEnable = " . + showsPrec d (vkDepthBoundsTestEnable x) . + showString ", " . + showString "vkStencilTestEnable = " . + showsPrec d (vkStencilTestEnable x) . + showString ", " . + showString "vkFront = " . + showsPrec d (vkFront x) . + showString ", " . + showString "vkBack = " . + showsPrec d (vkBack x) . + showString ", " . + showString + "vkMinDepthBounds = " + . + showsPrec d + (vkMinDepthBounds x) + . + showString ", " . + showString + "vkMaxDepthBounds = " + . + showsPrec d + (vkMaxDepthBounds + x) + . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkPipelineDiscardRectangleStateCreateInfoEXT.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkPipelineDiscardRectangleStateCreateInfoEXT.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkPipelineDiscardRectangleStateCreateInfoEXT.hsc @@ -0,0 +1,487 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkPipelineDiscardRectangleStateCreateInfoEXT + (VkPipelineDiscardRectangleStateCreateInfoEXT(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Bitmasks (VkPipelineDiscardRectangleStateCreateFlagsEXT) +import Graphics.Vulkan.Types.Enum.VkDiscardRectangleModeEXT (VkDiscardRectangleModeEXT) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Struct.VkGraphicsPipelineCreateInfo (VkGraphicsPipelineCreateInfo) +import Graphics.Vulkan.Types.Struct.VkRect2D (VkRect2D) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkPipelineDiscardRectangleStateCreateInfoEXT { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkPipelineDiscardRectangleStateCreateFlagsEXT flags; +-- > VkDiscardRectangleModeEXT discardRectangleMode; +-- > uint32_t discardRectangleCount; +-- > const VkRect2D* pDiscardRectangles; +-- > } VkPipelineDiscardRectangleStateCreateInfoEXT; +-- +-- +data VkPipelineDiscardRectangleStateCreateInfoEXT = VkPipelineDiscardRectangleStateCreateInfoEXT## Addr## + ByteArray## + +instance Eq VkPipelineDiscardRectangleStateCreateInfoEXT where + (VkPipelineDiscardRectangleStateCreateInfoEXT## a _) == + x@(VkPipelineDiscardRectangleStateCreateInfoEXT## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkPipelineDiscardRectangleStateCreateInfoEXT where + (VkPipelineDiscardRectangleStateCreateInfoEXT## a _) `compare` + x@(VkPipelineDiscardRectangleStateCreateInfoEXT## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkPipelineDiscardRectangleStateCreateInfoEXT + where + sizeOf ~_ + = #{size VkPipelineDiscardRectangleStateCreateInfoEXT} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkPipelineDiscardRectangleStateCreateInfoEXT} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim + VkPipelineDiscardRectangleStateCreateInfoEXT + where + unsafeAddr (VkPipelineDiscardRectangleStateCreateInfoEXT## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkPipelineDiscardRectangleStateCreateInfoEXT## _ b) + = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkPipelineDiscardRectangleStateCreateInfoEXT## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkPipelineDiscardRectangleStateCreateInfoEXT + where + type StructFields VkPipelineDiscardRectangleStateCreateInfoEXT = + '["sType", "pNext", "flags", "discardRectangleMode", -- ' closing tick for hsc2hs + "discardRectangleCount", "pDiscardRectangles"] + type CUnionType VkPipelineDiscardRectangleStateCreateInfoEXT = + 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkPipelineDiscardRectangleStateCreateInfoEXT = + 'False -- ' closing tick for hsc2hs + type StructExtends VkPipelineDiscardRectangleStateCreateInfoEXT = + '[VkGraphicsPipelineCreateInfo] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkPipelineDiscardRectangleStateCreateInfoEXT where + type VkSTypeMType VkPipelineDiscardRectangleStateCreateInfoEXT = + VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineDiscardRectangleStateCreateInfoEXT, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkPipelineDiscardRectangleStateCreateInfoEXT, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkPipelineDiscardRectangleStateCreateInfoEXT, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkPipelineDiscardRectangleStateCreateInfoEXT, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkPipelineDiscardRectangleStateCreateInfoEXT where + type FieldType "sType" VkPipelineDiscardRectangleStateCreateInfoEXT + = VkStructureType + type FieldOptional "sType" + VkPipelineDiscardRectangleStateCreateInfoEXT + = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" + VkPipelineDiscardRectangleStateCreateInfoEXT + = + #{offset VkPipelineDiscardRectangleStateCreateInfoEXT, sType} + type FieldIsArray "sType" + VkPipelineDiscardRectangleStateCreateInfoEXT + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineDiscardRectangleStateCreateInfoEXT, sType} + +instance CanReadField "sType" + VkPipelineDiscardRectangleStateCreateInfoEXT + where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" + VkPipelineDiscardRectangleStateCreateInfoEXT + where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkPipelineDiscardRectangleStateCreateInfoEXT where + type VkPNextMType VkPipelineDiscardRectangleStateCreateInfoEXT = + Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineDiscardRectangleStateCreateInfoEXT, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkPipelineDiscardRectangleStateCreateInfoEXT, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkPipelineDiscardRectangleStateCreateInfoEXT, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkPipelineDiscardRectangleStateCreateInfoEXT, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkPipelineDiscardRectangleStateCreateInfoEXT where + type FieldType "pNext" VkPipelineDiscardRectangleStateCreateInfoEXT + = Ptr Void + type FieldOptional "pNext" + VkPipelineDiscardRectangleStateCreateInfoEXT + = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" + VkPipelineDiscardRectangleStateCreateInfoEXT + = + #{offset VkPipelineDiscardRectangleStateCreateInfoEXT, pNext} + type FieldIsArray "pNext" + VkPipelineDiscardRectangleStateCreateInfoEXT + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineDiscardRectangleStateCreateInfoEXT, pNext} + +instance CanReadField "pNext" + VkPipelineDiscardRectangleStateCreateInfoEXT + where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" + VkPipelineDiscardRectangleStateCreateInfoEXT + where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkFlags VkPipelineDiscardRectangleStateCreateInfoEXT where + type VkFlagsMType VkPipelineDiscardRectangleStateCreateInfoEXT = + VkPipelineDiscardRectangleStateCreateFlagsEXT + + {-# NOINLINE vkFlags #-} + vkFlags x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineDiscardRectangleStateCreateInfoEXT, flags}) + + {-# INLINE vkFlagsByteOffset #-} + vkFlagsByteOffset ~_ + = #{offset VkPipelineDiscardRectangleStateCreateInfoEXT, flags} + + {-# INLINE readVkFlags #-} + readVkFlags p + = peekByteOff p #{offset VkPipelineDiscardRectangleStateCreateInfoEXT, flags} + + {-# INLINE writeVkFlags #-} + writeVkFlags p + = pokeByteOff p #{offset VkPipelineDiscardRectangleStateCreateInfoEXT, flags} + +instance {-# OVERLAPPING #-} + HasField "flags" VkPipelineDiscardRectangleStateCreateInfoEXT where + type FieldType "flags" VkPipelineDiscardRectangleStateCreateInfoEXT + = VkPipelineDiscardRectangleStateCreateFlagsEXT + type FieldOptional "flags" + VkPipelineDiscardRectangleStateCreateInfoEXT + = 'True -- ' closing tick for hsc2hs + type FieldOffset "flags" + VkPipelineDiscardRectangleStateCreateInfoEXT + = + #{offset VkPipelineDiscardRectangleStateCreateInfoEXT, flags} + type FieldIsArray "flags" + VkPipelineDiscardRectangleStateCreateInfoEXT + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineDiscardRectangleStateCreateInfoEXT, flags} + +instance CanReadField "flags" + VkPipelineDiscardRectangleStateCreateInfoEXT + where + {-# INLINE getField #-} + getField = vkFlags + + {-# INLINE readField #-} + readField = readVkFlags + +instance CanWriteField "flags" + VkPipelineDiscardRectangleStateCreateInfoEXT + where + {-# INLINE writeField #-} + writeField = writeVkFlags + +instance {-# OVERLAPPING #-} + HasVkDiscardRectangleMode + VkPipelineDiscardRectangleStateCreateInfoEXT + where + type VkDiscardRectangleModeMType + VkPipelineDiscardRectangleStateCreateInfoEXT + = VkDiscardRectangleModeEXT + + {-# NOINLINE vkDiscardRectangleMode #-} + vkDiscardRectangleMode x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineDiscardRectangleStateCreateInfoEXT, discardRectangleMode}) + + {-# INLINE vkDiscardRectangleModeByteOffset #-} + vkDiscardRectangleModeByteOffset ~_ + = #{offset VkPipelineDiscardRectangleStateCreateInfoEXT, discardRectangleMode} + + {-# INLINE readVkDiscardRectangleMode #-} + readVkDiscardRectangleMode p + = peekByteOff p #{offset VkPipelineDiscardRectangleStateCreateInfoEXT, discardRectangleMode} + + {-# INLINE writeVkDiscardRectangleMode #-} + writeVkDiscardRectangleMode p + = pokeByteOff p #{offset VkPipelineDiscardRectangleStateCreateInfoEXT, discardRectangleMode} + +instance {-# OVERLAPPING #-} + HasField "discardRectangleMode" + VkPipelineDiscardRectangleStateCreateInfoEXT + where + type FieldType "discardRectangleMode" + VkPipelineDiscardRectangleStateCreateInfoEXT + = VkDiscardRectangleModeEXT + type FieldOptional "discardRectangleMode" + VkPipelineDiscardRectangleStateCreateInfoEXT + = 'False -- ' closing tick for hsc2hs + type FieldOffset "discardRectangleMode" + VkPipelineDiscardRectangleStateCreateInfoEXT + = + #{offset VkPipelineDiscardRectangleStateCreateInfoEXT, discardRectangleMode} + type FieldIsArray "discardRectangleMode" + VkPipelineDiscardRectangleStateCreateInfoEXT + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineDiscardRectangleStateCreateInfoEXT, discardRectangleMode} + +instance CanReadField "discardRectangleMode" + VkPipelineDiscardRectangleStateCreateInfoEXT + where + {-# INLINE getField #-} + getField = vkDiscardRectangleMode + + {-# INLINE readField #-} + readField = readVkDiscardRectangleMode + +instance CanWriteField "discardRectangleMode" + VkPipelineDiscardRectangleStateCreateInfoEXT + where + {-# INLINE writeField #-} + writeField = writeVkDiscardRectangleMode + +instance {-# OVERLAPPING #-} + HasVkDiscardRectangleCount + VkPipelineDiscardRectangleStateCreateInfoEXT + where + type VkDiscardRectangleCountMType + VkPipelineDiscardRectangleStateCreateInfoEXT + = Word32 + + {-# NOINLINE vkDiscardRectangleCount #-} + vkDiscardRectangleCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineDiscardRectangleStateCreateInfoEXT, discardRectangleCount}) + + {-# INLINE vkDiscardRectangleCountByteOffset #-} + vkDiscardRectangleCountByteOffset ~_ + = #{offset VkPipelineDiscardRectangleStateCreateInfoEXT, discardRectangleCount} + + {-# INLINE readVkDiscardRectangleCount #-} + readVkDiscardRectangleCount p + = peekByteOff p #{offset VkPipelineDiscardRectangleStateCreateInfoEXT, discardRectangleCount} + + {-# INLINE writeVkDiscardRectangleCount #-} + writeVkDiscardRectangleCount p + = pokeByteOff p #{offset VkPipelineDiscardRectangleStateCreateInfoEXT, discardRectangleCount} + +instance {-# OVERLAPPING #-} + HasField "discardRectangleCount" + VkPipelineDiscardRectangleStateCreateInfoEXT + where + type FieldType "discardRectangleCount" + VkPipelineDiscardRectangleStateCreateInfoEXT + = Word32 + type FieldOptional "discardRectangleCount" + VkPipelineDiscardRectangleStateCreateInfoEXT + = 'True -- ' closing tick for hsc2hs + type FieldOffset "discardRectangleCount" + VkPipelineDiscardRectangleStateCreateInfoEXT + = + #{offset VkPipelineDiscardRectangleStateCreateInfoEXT, discardRectangleCount} + type FieldIsArray "discardRectangleCount" + VkPipelineDiscardRectangleStateCreateInfoEXT + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineDiscardRectangleStateCreateInfoEXT, discardRectangleCount} + +instance CanReadField "discardRectangleCount" + VkPipelineDiscardRectangleStateCreateInfoEXT + where + {-# INLINE getField #-} + getField = vkDiscardRectangleCount + + {-# INLINE readField #-} + readField = readVkDiscardRectangleCount + +instance CanWriteField "discardRectangleCount" + VkPipelineDiscardRectangleStateCreateInfoEXT + where + {-# INLINE writeField #-} + writeField = writeVkDiscardRectangleCount + +instance {-# OVERLAPPING #-} + HasVkPDiscardRectangles + VkPipelineDiscardRectangleStateCreateInfoEXT + where + type VkPDiscardRectanglesMType + VkPipelineDiscardRectangleStateCreateInfoEXT + = Ptr VkRect2D + + {-# NOINLINE vkPDiscardRectangles #-} + vkPDiscardRectangles x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineDiscardRectangleStateCreateInfoEXT, pDiscardRectangles}) + + {-# INLINE vkPDiscardRectanglesByteOffset #-} + vkPDiscardRectanglesByteOffset ~_ + = #{offset VkPipelineDiscardRectangleStateCreateInfoEXT, pDiscardRectangles} + + {-# INLINE readVkPDiscardRectangles #-} + readVkPDiscardRectangles p + = peekByteOff p #{offset VkPipelineDiscardRectangleStateCreateInfoEXT, pDiscardRectangles} + + {-# INLINE writeVkPDiscardRectangles #-} + writeVkPDiscardRectangles p + = pokeByteOff p #{offset VkPipelineDiscardRectangleStateCreateInfoEXT, pDiscardRectangles} + +instance {-# OVERLAPPING #-} + HasField "pDiscardRectangles" + VkPipelineDiscardRectangleStateCreateInfoEXT + where + type FieldType "pDiscardRectangles" + VkPipelineDiscardRectangleStateCreateInfoEXT + = Ptr VkRect2D + type FieldOptional "pDiscardRectangles" + VkPipelineDiscardRectangleStateCreateInfoEXT + = 'True -- ' closing tick for hsc2hs + type FieldOffset "pDiscardRectangles" + VkPipelineDiscardRectangleStateCreateInfoEXT + = + #{offset VkPipelineDiscardRectangleStateCreateInfoEXT, pDiscardRectangles} + type FieldIsArray "pDiscardRectangles" + VkPipelineDiscardRectangleStateCreateInfoEXT + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineDiscardRectangleStateCreateInfoEXT, pDiscardRectangles} + +instance CanReadField "pDiscardRectangles" + VkPipelineDiscardRectangleStateCreateInfoEXT + where + {-# INLINE getField #-} + getField = vkPDiscardRectangles + + {-# INLINE readField #-} + readField = readVkPDiscardRectangles + +instance CanWriteField "pDiscardRectangles" + VkPipelineDiscardRectangleStateCreateInfoEXT + where + {-# INLINE writeField #-} + writeField = writeVkPDiscardRectangles + +instance Show VkPipelineDiscardRectangleStateCreateInfoEXT where + showsPrec d x + = showString "VkPipelineDiscardRectangleStateCreateInfoEXT {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkFlags = " . + showsPrec d (vkFlags x) . + showString ", " . + showString "vkDiscardRectangleMode = " . + showsPrec d (vkDiscardRectangleMode x) . + showString ", " . + showString "vkDiscardRectangleCount = " . + showsPrec d (vkDiscardRectangleCount x) . + showString ", " . + showString "vkPDiscardRectangles = " . + showsPrec d (vkPDiscardRectangles x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkPipelineDynamicStateCreateInfo.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkPipelineDynamicStateCreateInfo.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkPipelineDynamicStateCreateInfo.hsc @@ -0,0 +1,368 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkPipelineDynamicStateCreateInfo + (VkPipelineDynamicStateCreateInfo(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Bitmasks (VkPipelineDynamicStateCreateFlags) +import Graphics.Vulkan.Types.Enum.VkDynamicState (VkDynamicState) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkPipelineDynamicStateCreateInfo { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkPipelineDynamicStateCreateFlags flags; +-- > uint32_t dynamicStateCount; +-- > const VkDynamicState* pDynamicStates; +-- > } VkPipelineDynamicStateCreateInfo; +-- +-- +data VkPipelineDynamicStateCreateInfo = VkPipelineDynamicStateCreateInfo## Addr## + ByteArray## + +instance Eq VkPipelineDynamicStateCreateInfo where + (VkPipelineDynamicStateCreateInfo## a _) == + x@(VkPipelineDynamicStateCreateInfo## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkPipelineDynamicStateCreateInfo where + (VkPipelineDynamicStateCreateInfo## a _) `compare` + x@(VkPipelineDynamicStateCreateInfo## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkPipelineDynamicStateCreateInfo where + sizeOf ~_ = #{size VkPipelineDynamicStateCreateInfo} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkPipelineDynamicStateCreateInfo} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkPipelineDynamicStateCreateInfo where + unsafeAddr (VkPipelineDynamicStateCreateInfo## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkPipelineDynamicStateCreateInfo## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkPipelineDynamicStateCreateInfo## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkPipelineDynamicStateCreateInfo where + type StructFields VkPipelineDynamicStateCreateInfo = + '["sType", "pNext", "flags", "dynamicStateCount", "pDynamicStates"] -- ' closing tick for hsc2hs + type CUnionType VkPipelineDynamicStateCreateInfo = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkPipelineDynamicStateCreateInfo = 'False -- ' closing tick for hsc2hs + type StructExtends VkPipelineDynamicStateCreateInfo = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkPipelineDynamicStateCreateInfo where + type VkSTypeMType VkPipelineDynamicStateCreateInfo = + VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineDynamicStateCreateInfo, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkPipelineDynamicStateCreateInfo, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkPipelineDynamicStateCreateInfo, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkPipelineDynamicStateCreateInfo, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkPipelineDynamicStateCreateInfo where + type FieldType "sType" VkPipelineDynamicStateCreateInfo = + VkStructureType + type FieldOptional "sType" VkPipelineDynamicStateCreateInfo = + 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkPipelineDynamicStateCreateInfo = + #{offset VkPipelineDynamicStateCreateInfo, sType} + type FieldIsArray "sType" VkPipelineDynamicStateCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineDynamicStateCreateInfo, sType} + +instance CanReadField "sType" VkPipelineDynamicStateCreateInfo + where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkPipelineDynamicStateCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkPipelineDynamicStateCreateInfo where + type VkPNextMType VkPipelineDynamicStateCreateInfo = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineDynamicStateCreateInfo, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkPipelineDynamicStateCreateInfo, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkPipelineDynamicStateCreateInfo, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkPipelineDynamicStateCreateInfo, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkPipelineDynamicStateCreateInfo where + type FieldType "pNext" VkPipelineDynamicStateCreateInfo = Ptr Void + type FieldOptional "pNext" VkPipelineDynamicStateCreateInfo = + 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkPipelineDynamicStateCreateInfo = + #{offset VkPipelineDynamicStateCreateInfo, pNext} + type FieldIsArray "pNext" VkPipelineDynamicStateCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineDynamicStateCreateInfo, pNext} + +instance CanReadField "pNext" VkPipelineDynamicStateCreateInfo + where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkPipelineDynamicStateCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkFlags VkPipelineDynamicStateCreateInfo where + type VkFlagsMType VkPipelineDynamicStateCreateInfo = + VkPipelineDynamicStateCreateFlags + + {-# NOINLINE vkFlags #-} + vkFlags x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineDynamicStateCreateInfo, flags}) + + {-# INLINE vkFlagsByteOffset #-} + vkFlagsByteOffset ~_ + = #{offset VkPipelineDynamicStateCreateInfo, flags} + + {-# INLINE readVkFlags #-} + readVkFlags p + = peekByteOff p #{offset VkPipelineDynamicStateCreateInfo, flags} + + {-# INLINE writeVkFlags #-} + writeVkFlags p + = pokeByteOff p #{offset VkPipelineDynamicStateCreateInfo, flags} + +instance {-# OVERLAPPING #-} + HasField "flags" VkPipelineDynamicStateCreateInfo where + type FieldType "flags" VkPipelineDynamicStateCreateInfo = + VkPipelineDynamicStateCreateFlags + type FieldOptional "flags" VkPipelineDynamicStateCreateInfo = 'True -- ' closing tick for hsc2hs + type FieldOffset "flags" VkPipelineDynamicStateCreateInfo = + #{offset VkPipelineDynamicStateCreateInfo, flags} + type FieldIsArray "flags" VkPipelineDynamicStateCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineDynamicStateCreateInfo, flags} + +instance CanReadField "flags" VkPipelineDynamicStateCreateInfo + where + {-# INLINE getField #-} + getField = vkFlags + + {-# INLINE readField #-} + readField = readVkFlags + +instance CanWriteField "flags" VkPipelineDynamicStateCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkFlags + +instance {-# OVERLAPPING #-} + HasVkDynamicStateCount VkPipelineDynamicStateCreateInfo where + type VkDynamicStateCountMType VkPipelineDynamicStateCreateInfo = + Word32 + + {-# NOINLINE vkDynamicStateCount #-} + vkDynamicStateCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineDynamicStateCreateInfo, dynamicStateCount}) + + {-# INLINE vkDynamicStateCountByteOffset #-} + vkDynamicStateCountByteOffset ~_ + = #{offset VkPipelineDynamicStateCreateInfo, dynamicStateCount} + + {-# INLINE readVkDynamicStateCount #-} + readVkDynamicStateCount p + = peekByteOff p #{offset VkPipelineDynamicStateCreateInfo, dynamicStateCount} + + {-# INLINE writeVkDynamicStateCount #-} + writeVkDynamicStateCount p + = pokeByteOff p #{offset VkPipelineDynamicStateCreateInfo, dynamicStateCount} + +instance {-# OVERLAPPING #-} + HasField "dynamicStateCount" VkPipelineDynamicStateCreateInfo where + type FieldType "dynamicStateCount" VkPipelineDynamicStateCreateInfo + = Word32 + type FieldOptional "dynamicStateCount" + VkPipelineDynamicStateCreateInfo + = 'False -- ' closing tick for hsc2hs + type FieldOffset "dynamicStateCount" + VkPipelineDynamicStateCreateInfo + = + #{offset VkPipelineDynamicStateCreateInfo, dynamicStateCount} + type FieldIsArray "dynamicStateCount" + VkPipelineDynamicStateCreateInfo + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineDynamicStateCreateInfo, dynamicStateCount} + +instance CanReadField "dynamicStateCount" + VkPipelineDynamicStateCreateInfo + where + {-# INLINE getField #-} + getField = vkDynamicStateCount + + {-# INLINE readField #-} + readField = readVkDynamicStateCount + +instance CanWriteField "dynamicStateCount" + VkPipelineDynamicStateCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkDynamicStateCount + +instance {-# OVERLAPPING #-} + HasVkPDynamicStates VkPipelineDynamicStateCreateInfo where + type VkPDynamicStatesMType VkPipelineDynamicStateCreateInfo = + Ptr VkDynamicState + + {-# NOINLINE vkPDynamicStates #-} + vkPDynamicStates x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineDynamicStateCreateInfo, pDynamicStates}) + + {-# INLINE vkPDynamicStatesByteOffset #-} + vkPDynamicStatesByteOffset ~_ + = #{offset VkPipelineDynamicStateCreateInfo, pDynamicStates} + + {-# INLINE readVkPDynamicStates #-} + readVkPDynamicStates p + = peekByteOff p #{offset VkPipelineDynamicStateCreateInfo, pDynamicStates} + + {-# INLINE writeVkPDynamicStates #-} + writeVkPDynamicStates p + = pokeByteOff p #{offset VkPipelineDynamicStateCreateInfo, pDynamicStates} + +instance {-# OVERLAPPING #-} + HasField "pDynamicStates" VkPipelineDynamicStateCreateInfo where + type FieldType "pDynamicStates" VkPipelineDynamicStateCreateInfo = + Ptr VkDynamicState + type FieldOptional "pDynamicStates" + VkPipelineDynamicStateCreateInfo + = 'False -- ' closing tick for hsc2hs + type FieldOffset "pDynamicStates" VkPipelineDynamicStateCreateInfo + = + #{offset VkPipelineDynamicStateCreateInfo, pDynamicStates} + type FieldIsArray "pDynamicStates" VkPipelineDynamicStateCreateInfo + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineDynamicStateCreateInfo, pDynamicStates} + +instance CanReadField "pDynamicStates" + VkPipelineDynamicStateCreateInfo + where + {-# INLINE getField #-} + getField = vkPDynamicStates + + {-# INLINE readField #-} + readField = readVkPDynamicStates + +instance CanWriteField "pDynamicStates" + VkPipelineDynamicStateCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkPDynamicStates + +instance Show VkPipelineDynamicStateCreateInfo where + showsPrec d x + = showString "VkPipelineDynamicStateCreateInfo {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkFlags = " . + showsPrec d (vkFlags x) . + showString ", " . + showString "vkDynamicStateCount = " . + showsPrec d (vkDynamicStateCount x) . + showString ", " . + showString "vkPDynamicStates = " . + showsPrec d (vkPDynamicStates x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkPipelineInputAssemblyStateCreateInfo.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkPipelineInputAssemblyStateCreateInfo.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkPipelineInputAssemblyStateCreateInfo.hsc @@ -0,0 +1,387 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkPipelineInputAssemblyStateCreateInfo + (VkPipelineInputAssemblyStateCreateInfo(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.BaseTypes (VkBool32) +import Graphics.Vulkan.Types.Bitmasks (VkPipelineInputAssemblyStateCreateFlags) +import Graphics.Vulkan.Types.Enum.VkPrimitiveTopology (VkPrimitiveTopology) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkPipelineInputAssemblyStateCreateInfo { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkPipelineInputAssemblyStateCreateFlags flags; +-- > VkPrimitiveTopology topology; +-- > VkBool32 primitiveRestartEnable; +-- > } VkPipelineInputAssemblyStateCreateInfo; +-- +-- +data VkPipelineInputAssemblyStateCreateInfo = VkPipelineInputAssemblyStateCreateInfo## Addr## + ByteArray## + +instance Eq VkPipelineInputAssemblyStateCreateInfo where + (VkPipelineInputAssemblyStateCreateInfo## a _) == + x@(VkPipelineInputAssemblyStateCreateInfo## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkPipelineInputAssemblyStateCreateInfo where + (VkPipelineInputAssemblyStateCreateInfo## a _) `compare` + x@(VkPipelineInputAssemblyStateCreateInfo## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkPipelineInputAssemblyStateCreateInfo where + sizeOf ~_ + = #{size VkPipelineInputAssemblyStateCreateInfo} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkPipelineInputAssemblyStateCreateInfo} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkPipelineInputAssemblyStateCreateInfo + where + unsafeAddr (VkPipelineInputAssemblyStateCreateInfo## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkPipelineInputAssemblyStateCreateInfo## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkPipelineInputAssemblyStateCreateInfo## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkPipelineInputAssemblyStateCreateInfo where + type StructFields VkPipelineInputAssemblyStateCreateInfo = + '["sType", "pNext", "flags", "topology", "primitiveRestartEnable"] -- ' closing tick for hsc2hs + type CUnionType VkPipelineInputAssemblyStateCreateInfo = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkPipelineInputAssemblyStateCreateInfo = 'False -- ' closing tick for hsc2hs + type StructExtends VkPipelineInputAssemblyStateCreateInfo = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkPipelineInputAssemblyStateCreateInfo where + type VkSTypeMType VkPipelineInputAssemblyStateCreateInfo = + VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineInputAssemblyStateCreateInfo, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkPipelineInputAssemblyStateCreateInfo, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkPipelineInputAssemblyStateCreateInfo, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkPipelineInputAssemblyStateCreateInfo, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkPipelineInputAssemblyStateCreateInfo where + type FieldType "sType" VkPipelineInputAssemblyStateCreateInfo = + VkStructureType + type FieldOptional "sType" VkPipelineInputAssemblyStateCreateInfo = + 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkPipelineInputAssemblyStateCreateInfo = + #{offset VkPipelineInputAssemblyStateCreateInfo, sType} + type FieldIsArray "sType" VkPipelineInputAssemblyStateCreateInfo = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineInputAssemblyStateCreateInfo, sType} + +instance CanReadField "sType" + VkPipelineInputAssemblyStateCreateInfo + where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" + VkPipelineInputAssemblyStateCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkPipelineInputAssemblyStateCreateInfo where + type VkPNextMType VkPipelineInputAssemblyStateCreateInfo = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineInputAssemblyStateCreateInfo, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkPipelineInputAssemblyStateCreateInfo, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkPipelineInputAssemblyStateCreateInfo, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkPipelineInputAssemblyStateCreateInfo, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkPipelineInputAssemblyStateCreateInfo where + type FieldType "pNext" VkPipelineInputAssemblyStateCreateInfo = + Ptr Void + type FieldOptional "pNext" VkPipelineInputAssemblyStateCreateInfo = + 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkPipelineInputAssemblyStateCreateInfo = + #{offset VkPipelineInputAssemblyStateCreateInfo, pNext} + type FieldIsArray "pNext" VkPipelineInputAssemblyStateCreateInfo = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineInputAssemblyStateCreateInfo, pNext} + +instance CanReadField "pNext" + VkPipelineInputAssemblyStateCreateInfo + where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" + VkPipelineInputAssemblyStateCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkFlags VkPipelineInputAssemblyStateCreateInfo where + type VkFlagsMType VkPipelineInputAssemblyStateCreateInfo = + VkPipelineInputAssemblyStateCreateFlags + + {-# NOINLINE vkFlags #-} + vkFlags x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineInputAssemblyStateCreateInfo, flags}) + + {-# INLINE vkFlagsByteOffset #-} + vkFlagsByteOffset ~_ + = #{offset VkPipelineInputAssemblyStateCreateInfo, flags} + + {-# INLINE readVkFlags #-} + readVkFlags p + = peekByteOff p #{offset VkPipelineInputAssemblyStateCreateInfo, flags} + + {-# INLINE writeVkFlags #-} + writeVkFlags p + = pokeByteOff p #{offset VkPipelineInputAssemblyStateCreateInfo, flags} + +instance {-# OVERLAPPING #-} + HasField "flags" VkPipelineInputAssemblyStateCreateInfo where + type FieldType "flags" VkPipelineInputAssemblyStateCreateInfo = + VkPipelineInputAssemblyStateCreateFlags + type FieldOptional "flags" VkPipelineInputAssemblyStateCreateInfo = + 'True -- ' closing tick for hsc2hs + type FieldOffset "flags" VkPipelineInputAssemblyStateCreateInfo = + #{offset VkPipelineInputAssemblyStateCreateInfo, flags} + type FieldIsArray "flags" VkPipelineInputAssemblyStateCreateInfo = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineInputAssemblyStateCreateInfo, flags} + +instance CanReadField "flags" + VkPipelineInputAssemblyStateCreateInfo + where + {-# INLINE getField #-} + getField = vkFlags + + {-# INLINE readField #-} + readField = readVkFlags + +instance CanWriteField "flags" + VkPipelineInputAssemblyStateCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkFlags + +instance {-# OVERLAPPING #-} + HasVkTopology VkPipelineInputAssemblyStateCreateInfo where + type VkTopologyMType VkPipelineInputAssemblyStateCreateInfo = + VkPrimitiveTopology + + {-# NOINLINE vkTopology #-} + vkTopology x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineInputAssemblyStateCreateInfo, topology}) + + {-# INLINE vkTopologyByteOffset #-} + vkTopologyByteOffset ~_ + = #{offset VkPipelineInputAssemblyStateCreateInfo, topology} + + {-# INLINE readVkTopology #-} + readVkTopology p + = peekByteOff p #{offset VkPipelineInputAssemblyStateCreateInfo, topology} + + {-# INLINE writeVkTopology #-} + writeVkTopology p + = pokeByteOff p #{offset VkPipelineInputAssemblyStateCreateInfo, topology} + +instance {-# OVERLAPPING #-} + HasField "topology" VkPipelineInputAssemblyStateCreateInfo where + type FieldType "topology" VkPipelineInputAssemblyStateCreateInfo = + VkPrimitiveTopology + type FieldOptional "topology" + VkPipelineInputAssemblyStateCreateInfo + = 'False -- ' closing tick for hsc2hs + type FieldOffset "topology" VkPipelineInputAssemblyStateCreateInfo + = + #{offset VkPipelineInputAssemblyStateCreateInfo, topology} + type FieldIsArray "topology" VkPipelineInputAssemblyStateCreateInfo + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineInputAssemblyStateCreateInfo, topology} + +instance CanReadField "topology" + VkPipelineInputAssemblyStateCreateInfo + where + {-# INLINE getField #-} + getField = vkTopology + + {-# INLINE readField #-} + readField = readVkTopology + +instance CanWriteField "topology" + VkPipelineInputAssemblyStateCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkTopology + +instance {-# OVERLAPPING #-} + HasVkPrimitiveRestartEnable VkPipelineInputAssemblyStateCreateInfo + where + type VkPrimitiveRestartEnableMType + VkPipelineInputAssemblyStateCreateInfo + = VkBool32 + + {-# NOINLINE vkPrimitiveRestartEnable #-} + vkPrimitiveRestartEnable x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineInputAssemblyStateCreateInfo, primitiveRestartEnable}) + + {-# INLINE vkPrimitiveRestartEnableByteOffset #-} + vkPrimitiveRestartEnableByteOffset ~_ + = #{offset VkPipelineInputAssemblyStateCreateInfo, primitiveRestartEnable} + + {-# INLINE readVkPrimitiveRestartEnable #-} + readVkPrimitiveRestartEnable p + = peekByteOff p #{offset VkPipelineInputAssemblyStateCreateInfo, primitiveRestartEnable} + + {-# INLINE writeVkPrimitiveRestartEnable #-} + writeVkPrimitiveRestartEnable p + = pokeByteOff p #{offset VkPipelineInputAssemblyStateCreateInfo, primitiveRestartEnable} + +instance {-# OVERLAPPING #-} + HasField "primitiveRestartEnable" + VkPipelineInputAssemblyStateCreateInfo + where + type FieldType "primitiveRestartEnable" + VkPipelineInputAssemblyStateCreateInfo + = VkBool32 + type FieldOptional "primitiveRestartEnable" + VkPipelineInputAssemblyStateCreateInfo + = 'False -- ' closing tick for hsc2hs + type FieldOffset "primitiveRestartEnable" + VkPipelineInputAssemblyStateCreateInfo + = + #{offset VkPipelineInputAssemblyStateCreateInfo, primitiveRestartEnable} + type FieldIsArray "primitiveRestartEnable" + VkPipelineInputAssemblyStateCreateInfo + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineInputAssemblyStateCreateInfo, primitiveRestartEnable} + +instance CanReadField "primitiveRestartEnable" + VkPipelineInputAssemblyStateCreateInfo + where + {-# INLINE getField #-} + getField = vkPrimitiveRestartEnable + + {-# INLINE readField #-} + readField = readVkPrimitiveRestartEnable + +instance CanWriteField "primitiveRestartEnable" + VkPipelineInputAssemblyStateCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkPrimitiveRestartEnable + +instance Show VkPipelineInputAssemblyStateCreateInfo where + showsPrec d x + = showString "VkPipelineInputAssemblyStateCreateInfo {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkFlags = " . + showsPrec d (vkFlags x) . + showString ", " . + showString "vkTopology = " . + showsPrec d (vkTopology x) . + showString ", " . + showString "vkPrimitiveRestartEnable = " . + showsPrec d (vkPrimitiveRestartEnable x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkPipelineLayoutCreateInfo.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkPipelineLayoutCreateInfo.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkPipelineLayoutCreateInfo.hsc @@ -0,0 +1,468 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkPipelineLayoutCreateInfo + (VkPipelineLayoutCreateInfo(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Bitmasks (VkPipelineLayoutCreateFlags) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Handles (VkDescriptorSetLayout) +import Graphics.Vulkan.Types.Struct.VkPushConstantRange (VkPushConstantRange) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkPipelineLayoutCreateInfo { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkPipelineLayoutCreateFlags flags; +-- > uint32_t setLayoutCount; +-- > const VkDescriptorSetLayout* pSetLayouts; +-- > uint32_t pushConstantRangeCount; +-- > const VkPushConstantRange* pPushConstantRanges; +-- > } VkPipelineLayoutCreateInfo; +-- +-- +data VkPipelineLayoutCreateInfo = VkPipelineLayoutCreateInfo## Addr## + ByteArray## + +instance Eq VkPipelineLayoutCreateInfo where + (VkPipelineLayoutCreateInfo## a _) == + x@(VkPipelineLayoutCreateInfo## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkPipelineLayoutCreateInfo where + (VkPipelineLayoutCreateInfo## a _) `compare` + x@(VkPipelineLayoutCreateInfo## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkPipelineLayoutCreateInfo where + sizeOf ~_ = #{size VkPipelineLayoutCreateInfo} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkPipelineLayoutCreateInfo} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkPipelineLayoutCreateInfo where + unsafeAddr (VkPipelineLayoutCreateInfo## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkPipelineLayoutCreateInfo## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkPipelineLayoutCreateInfo## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkPipelineLayoutCreateInfo where + type StructFields VkPipelineLayoutCreateInfo = + '["sType", "pNext", "flags", "setLayoutCount", "pSetLayouts", -- ' closing tick for hsc2hs + "pushConstantRangeCount", "pPushConstantRanges"] + type CUnionType VkPipelineLayoutCreateInfo = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkPipelineLayoutCreateInfo = 'False -- ' closing tick for hsc2hs + type StructExtends VkPipelineLayoutCreateInfo = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkSType VkPipelineLayoutCreateInfo + where + type VkSTypeMType VkPipelineLayoutCreateInfo = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineLayoutCreateInfo, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkPipelineLayoutCreateInfo, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkPipelineLayoutCreateInfo, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkPipelineLayoutCreateInfo, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkPipelineLayoutCreateInfo where + type FieldType "sType" VkPipelineLayoutCreateInfo = VkStructureType + type FieldOptional "sType" VkPipelineLayoutCreateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkPipelineLayoutCreateInfo = + #{offset VkPipelineLayoutCreateInfo, sType} + type FieldIsArray "sType" VkPipelineLayoutCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineLayoutCreateInfo, sType} + +instance CanReadField "sType" VkPipelineLayoutCreateInfo where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkPipelineLayoutCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} HasVkPNext VkPipelineLayoutCreateInfo + where + type VkPNextMType VkPipelineLayoutCreateInfo = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineLayoutCreateInfo, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkPipelineLayoutCreateInfo, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkPipelineLayoutCreateInfo, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkPipelineLayoutCreateInfo, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkPipelineLayoutCreateInfo where + type FieldType "pNext" VkPipelineLayoutCreateInfo = Ptr Void + type FieldOptional "pNext" VkPipelineLayoutCreateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkPipelineLayoutCreateInfo = + #{offset VkPipelineLayoutCreateInfo, pNext} + type FieldIsArray "pNext" VkPipelineLayoutCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineLayoutCreateInfo, pNext} + +instance CanReadField "pNext" VkPipelineLayoutCreateInfo where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkPipelineLayoutCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} HasVkFlags VkPipelineLayoutCreateInfo + where + type VkFlagsMType VkPipelineLayoutCreateInfo = + VkPipelineLayoutCreateFlags + + {-# NOINLINE vkFlags #-} + vkFlags x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineLayoutCreateInfo, flags}) + + {-# INLINE vkFlagsByteOffset #-} + vkFlagsByteOffset ~_ + = #{offset VkPipelineLayoutCreateInfo, flags} + + {-# INLINE readVkFlags #-} + readVkFlags p + = peekByteOff p #{offset VkPipelineLayoutCreateInfo, flags} + + {-# INLINE writeVkFlags #-} + writeVkFlags p + = pokeByteOff p #{offset VkPipelineLayoutCreateInfo, flags} + +instance {-# OVERLAPPING #-} + HasField "flags" VkPipelineLayoutCreateInfo where + type FieldType "flags" VkPipelineLayoutCreateInfo = + VkPipelineLayoutCreateFlags + type FieldOptional "flags" VkPipelineLayoutCreateInfo = 'True -- ' closing tick for hsc2hs + type FieldOffset "flags" VkPipelineLayoutCreateInfo = + #{offset VkPipelineLayoutCreateInfo, flags} + type FieldIsArray "flags" VkPipelineLayoutCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineLayoutCreateInfo, flags} + +instance CanReadField "flags" VkPipelineLayoutCreateInfo where + {-# INLINE getField #-} + getField = vkFlags + + {-# INLINE readField #-} + readField = readVkFlags + +instance CanWriteField "flags" VkPipelineLayoutCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkFlags + +instance {-# OVERLAPPING #-} + HasVkSetLayoutCount VkPipelineLayoutCreateInfo where + type VkSetLayoutCountMType VkPipelineLayoutCreateInfo = Word32 + + {-# NOINLINE vkSetLayoutCount #-} + vkSetLayoutCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineLayoutCreateInfo, setLayoutCount}) + + {-# INLINE vkSetLayoutCountByteOffset #-} + vkSetLayoutCountByteOffset ~_ + = #{offset VkPipelineLayoutCreateInfo, setLayoutCount} + + {-# INLINE readVkSetLayoutCount #-} + readVkSetLayoutCount p + = peekByteOff p #{offset VkPipelineLayoutCreateInfo, setLayoutCount} + + {-# INLINE writeVkSetLayoutCount #-} + writeVkSetLayoutCount p + = pokeByteOff p #{offset VkPipelineLayoutCreateInfo, setLayoutCount} + +instance {-# OVERLAPPING #-} + HasField "setLayoutCount" VkPipelineLayoutCreateInfo where + type FieldType "setLayoutCount" VkPipelineLayoutCreateInfo = Word32 + type FieldOptional "setLayoutCount" VkPipelineLayoutCreateInfo = + 'True -- ' closing tick for hsc2hs + type FieldOffset "setLayoutCount" VkPipelineLayoutCreateInfo = + #{offset VkPipelineLayoutCreateInfo, setLayoutCount} + type FieldIsArray "setLayoutCount" VkPipelineLayoutCreateInfo = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineLayoutCreateInfo, setLayoutCount} + +instance CanReadField "setLayoutCount" VkPipelineLayoutCreateInfo + where + {-# INLINE getField #-} + getField = vkSetLayoutCount + + {-# INLINE readField #-} + readField = readVkSetLayoutCount + +instance CanWriteField "setLayoutCount" VkPipelineLayoutCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkSetLayoutCount + +instance {-# OVERLAPPING #-} + HasVkPSetLayouts VkPipelineLayoutCreateInfo where + type VkPSetLayoutsMType VkPipelineLayoutCreateInfo = + Ptr VkDescriptorSetLayout + + {-# NOINLINE vkPSetLayouts #-} + vkPSetLayouts x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineLayoutCreateInfo, pSetLayouts}) + + {-# INLINE vkPSetLayoutsByteOffset #-} + vkPSetLayoutsByteOffset ~_ + = #{offset VkPipelineLayoutCreateInfo, pSetLayouts} + + {-# INLINE readVkPSetLayouts #-} + readVkPSetLayouts p + = peekByteOff p #{offset VkPipelineLayoutCreateInfo, pSetLayouts} + + {-# INLINE writeVkPSetLayouts #-} + writeVkPSetLayouts p + = pokeByteOff p #{offset VkPipelineLayoutCreateInfo, pSetLayouts} + +instance {-# OVERLAPPING #-} + HasField "pSetLayouts" VkPipelineLayoutCreateInfo where + type FieldType "pSetLayouts" VkPipelineLayoutCreateInfo = + Ptr VkDescriptorSetLayout + type FieldOptional "pSetLayouts" VkPipelineLayoutCreateInfo = + 'False -- ' closing tick for hsc2hs + type FieldOffset "pSetLayouts" VkPipelineLayoutCreateInfo = + #{offset VkPipelineLayoutCreateInfo, pSetLayouts} + type FieldIsArray "pSetLayouts" VkPipelineLayoutCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineLayoutCreateInfo, pSetLayouts} + +instance CanReadField "pSetLayouts" VkPipelineLayoutCreateInfo + where + {-# INLINE getField #-} + getField = vkPSetLayouts + + {-# INLINE readField #-} + readField = readVkPSetLayouts + +instance CanWriteField "pSetLayouts" VkPipelineLayoutCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkPSetLayouts + +instance {-# OVERLAPPING #-} + HasVkPushConstantRangeCount VkPipelineLayoutCreateInfo where + type VkPushConstantRangeCountMType VkPipelineLayoutCreateInfo = + Word32 + + {-# NOINLINE vkPushConstantRangeCount #-} + vkPushConstantRangeCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineLayoutCreateInfo, pushConstantRangeCount}) + + {-# INLINE vkPushConstantRangeCountByteOffset #-} + vkPushConstantRangeCountByteOffset ~_ + = #{offset VkPipelineLayoutCreateInfo, pushConstantRangeCount} + + {-# INLINE readVkPushConstantRangeCount #-} + readVkPushConstantRangeCount p + = peekByteOff p #{offset VkPipelineLayoutCreateInfo, pushConstantRangeCount} + + {-# INLINE writeVkPushConstantRangeCount #-} + writeVkPushConstantRangeCount p + = pokeByteOff p #{offset VkPipelineLayoutCreateInfo, pushConstantRangeCount} + +instance {-# OVERLAPPING #-} + HasField "pushConstantRangeCount" VkPipelineLayoutCreateInfo where + type FieldType "pushConstantRangeCount" VkPipelineLayoutCreateInfo + = Word32 + type FieldOptional "pushConstantRangeCount" + VkPipelineLayoutCreateInfo + = 'True -- ' closing tick for hsc2hs + type FieldOffset "pushConstantRangeCount" + VkPipelineLayoutCreateInfo + = + #{offset VkPipelineLayoutCreateInfo, pushConstantRangeCount} + type FieldIsArray "pushConstantRangeCount" + VkPipelineLayoutCreateInfo + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineLayoutCreateInfo, pushConstantRangeCount} + +instance CanReadField "pushConstantRangeCount" + VkPipelineLayoutCreateInfo + where + {-# INLINE getField #-} + getField = vkPushConstantRangeCount + + {-# INLINE readField #-} + readField = readVkPushConstantRangeCount + +instance CanWriteField "pushConstantRangeCount" + VkPipelineLayoutCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkPushConstantRangeCount + +instance {-# OVERLAPPING #-} + HasVkPPushConstantRanges VkPipelineLayoutCreateInfo where + type VkPPushConstantRangesMType VkPipelineLayoutCreateInfo = + Ptr VkPushConstantRange + + {-# NOINLINE vkPPushConstantRanges #-} + vkPPushConstantRanges x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineLayoutCreateInfo, pPushConstantRanges}) + + {-# INLINE vkPPushConstantRangesByteOffset #-} + vkPPushConstantRangesByteOffset ~_ + = #{offset VkPipelineLayoutCreateInfo, pPushConstantRanges} + + {-# INLINE readVkPPushConstantRanges #-} + readVkPPushConstantRanges p + = peekByteOff p #{offset VkPipelineLayoutCreateInfo, pPushConstantRanges} + + {-# INLINE writeVkPPushConstantRanges #-} + writeVkPPushConstantRanges p + = pokeByteOff p #{offset VkPipelineLayoutCreateInfo, pPushConstantRanges} + +instance {-# OVERLAPPING #-} + HasField "pPushConstantRanges" VkPipelineLayoutCreateInfo where + type FieldType "pPushConstantRanges" VkPipelineLayoutCreateInfo = + Ptr VkPushConstantRange + type FieldOptional "pPushConstantRanges" VkPipelineLayoutCreateInfo + = 'False -- ' closing tick for hsc2hs + type FieldOffset "pPushConstantRanges" VkPipelineLayoutCreateInfo = + #{offset VkPipelineLayoutCreateInfo, pPushConstantRanges} + type FieldIsArray "pPushConstantRanges" VkPipelineLayoutCreateInfo + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineLayoutCreateInfo, pPushConstantRanges} + +instance CanReadField "pPushConstantRanges" + VkPipelineLayoutCreateInfo + where + {-# INLINE getField #-} + getField = vkPPushConstantRanges + + {-# INLINE readField #-} + readField = readVkPPushConstantRanges + +instance CanWriteField "pPushConstantRanges" + VkPipelineLayoutCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkPPushConstantRanges + +instance Show VkPipelineLayoutCreateInfo where + showsPrec d x + = showString "VkPipelineLayoutCreateInfo {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkFlags = " . + showsPrec d (vkFlags x) . + showString ", " . + showString "vkSetLayoutCount = " . + showsPrec d (vkSetLayoutCount x) . + showString ", " . + showString "vkPSetLayouts = " . + showsPrec d (vkPSetLayouts x) . + showString ", " . + showString "vkPushConstantRangeCount = " . + showsPrec d (vkPushConstantRangeCount x) . + showString ", " . + showString "vkPPushConstantRanges = " . + showsPrec d (vkPPushConstantRanges x) . + showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkPipelineMultisampleStateCreateInfo.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkPipelineMultisampleStateCreateInfo.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkPipelineMultisampleStateCreateInfo.hsc @@ -0,0 +1,650 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkPipelineMultisampleStateCreateInfo + (VkPipelineMultisampleStateCreateInfo(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.BaseTypes (VkBool32, + VkSampleMask) +import Graphics.Vulkan.Types.Bitmasks (VkPipelineMultisampleStateCreateFlags) +import Graphics.Vulkan.Types.Enum.VkSampleCountFlags (VkSampleCountFlagBits) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkPipelineMultisampleStateCreateInfo { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkPipelineMultisampleStateCreateFlags flags; +-- > VkSampleCountFlagBits rasterizationSamples; +-- > VkBool32 sampleShadingEnable; +-- > float minSampleShading; +-- > const VkSampleMask* pSampleMask; +-- > VkBool32 alphaToCoverageEnable; +-- > VkBool32 alphaToOneEnable; +-- > } VkPipelineMultisampleStateCreateInfo; +-- +-- +data VkPipelineMultisampleStateCreateInfo = VkPipelineMultisampleStateCreateInfo## Addr## + ByteArray## + +instance Eq VkPipelineMultisampleStateCreateInfo where + (VkPipelineMultisampleStateCreateInfo## a _) == + x@(VkPipelineMultisampleStateCreateInfo## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkPipelineMultisampleStateCreateInfo where + (VkPipelineMultisampleStateCreateInfo## a _) `compare` + x@(VkPipelineMultisampleStateCreateInfo## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkPipelineMultisampleStateCreateInfo where + sizeOf ~_ + = #{size VkPipelineMultisampleStateCreateInfo} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkPipelineMultisampleStateCreateInfo} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkPipelineMultisampleStateCreateInfo + where + unsafeAddr (VkPipelineMultisampleStateCreateInfo## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkPipelineMultisampleStateCreateInfo## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkPipelineMultisampleStateCreateInfo## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkPipelineMultisampleStateCreateInfo where + type StructFields VkPipelineMultisampleStateCreateInfo = + '["sType", "pNext", "flags", "rasterizationSamples", -- ' closing tick for hsc2hs + "sampleShadingEnable", "minSampleShading", "pSampleMask", + "alphaToCoverageEnable", "alphaToOneEnable"] + type CUnionType VkPipelineMultisampleStateCreateInfo = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkPipelineMultisampleStateCreateInfo = 'False -- ' closing tick for hsc2hs + type StructExtends VkPipelineMultisampleStateCreateInfo = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkPipelineMultisampleStateCreateInfo where + type VkSTypeMType VkPipelineMultisampleStateCreateInfo = + VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineMultisampleStateCreateInfo, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkPipelineMultisampleStateCreateInfo, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkPipelineMultisampleStateCreateInfo, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkPipelineMultisampleStateCreateInfo, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkPipelineMultisampleStateCreateInfo where + type FieldType "sType" VkPipelineMultisampleStateCreateInfo = + VkStructureType + type FieldOptional "sType" VkPipelineMultisampleStateCreateInfo = + 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkPipelineMultisampleStateCreateInfo = + #{offset VkPipelineMultisampleStateCreateInfo, sType} + type FieldIsArray "sType" VkPipelineMultisampleStateCreateInfo = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineMultisampleStateCreateInfo, sType} + +instance CanReadField "sType" VkPipelineMultisampleStateCreateInfo + where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkPipelineMultisampleStateCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkPipelineMultisampleStateCreateInfo where + type VkPNextMType VkPipelineMultisampleStateCreateInfo = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineMultisampleStateCreateInfo, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkPipelineMultisampleStateCreateInfo, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkPipelineMultisampleStateCreateInfo, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkPipelineMultisampleStateCreateInfo, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkPipelineMultisampleStateCreateInfo where + type FieldType "pNext" VkPipelineMultisampleStateCreateInfo = + Ptr Void + type FieldOptional "pNext" VkPipelineMultisampleStateCreateInfo = + 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkPipelineMultisampleStateCreateInfo = + #{offset VkPipelineMultisampleStateCreateInfo, pNext} + type FieldIsArray "pNext" VkPipelineMultisampleStateCreateInfo = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineMultisampleStateCreateInfo, pNext} + +instance CanReadField "pNext" VkPipelineMultisampleStateCreateInfo + where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkPipelineMultisampleStateCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkFlags VkPipelineMultisampleStateCreateInfo where + type VkFlagsMType VkPipelineMultisampleStateCreateInfo = + VkPipelineMultisampleStateCreateFlags + + {-# NOINLINE vkFlags #-} + vkFlags x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineMultisampleStateCreateInfo, flags}) + + {-# INLINE vkFlagsByteOffset #-} + vkFlagsByteOffset ~_ + = #{offset VkPipelineMultisampleStateCreateInfo, flags} + + {-# INLINE readVkFlags #-} + readVkFlags p + = peekByteOff p #{offset VkPipelineMultisampleStateCreateInfo, flags} + + {-# INLINE writeVkFlags #-} + writeVkFlags p + = pokeByteOff p #{offset VkPipelineMultisampleStateCreateInfo, flags} + +instance {-# OVERLAPPING #-} + HasField "flags" VkPipelineMultisampleStateCreateInfo where + type FieldType "flags" VkPipelineMultisampleStateCreateInfo = + VkPipelineMultisampleStateCreateFlags + type FieldOptional "flags" VkPipelineMultisampleStateCreateInfo = + 'True -- ' closing tick for hsc2hs + type FieldOffset "flags" VkPipelineMultisampleStateCreateInfo = + #{offset VkPipelineMultisampleStateCreateInfo, flags} + type FieldIsArray "flags" VkPipelineMultisampleStateCreateInfo = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineMultisampleStateCreateInfo, flags} + +instance CanReadField "flags" VkPipelineMultisampleStateCreateInfo + where + {-# INLINE getField #-} + getField = vkFlags + + {-# INLINE readField #-} + readField = readVkFlags + +instance CanWriteField "flags" VkPipelineMultisampleStateCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkFlags + +instance {-# OVERLAPPING #-} + HasVkRasterizationSamples VkPipelineMultisampleStateCreateInfo + where + type VkRasterizationSamplesMType + VkPipelineMultisampleStateCreateInfo + = VkSampleCountFlagBits + + {-# NOINLINE vkRasterizationSamples #-} + vkRasterizationSamples x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineMultisampleStateCreateInfo, rasterizationSamples}) + + {-# INLINE vkRasterizationSamplesByteOffset #-} + vkRasterizationSamplesByteOffset ~_ + = #{offset VkPipelineMultisampleStateCreateInfo, rasterizationSamples} + + {-# INLINE readVkRasterizationSamples #-} + readVkRasterizationSamples p + = peekByteOff p #{offset VkPipelineMultisampleStateCreateInfo, rasterizationSamples} + + {-# INLINE writeVkRasterizationSamples #-} + writeVkRasterizationSamples p + = pokeByteOff p #{offset VkPipelineMultisampleStateCreateInfo, rasterizationSamples} + +instance {-# OVERLAPPING #-} + HasField "rasterizationSamples" + VkPipelineMultisampleStateCreateInfo + where + type FieldType "rasterizationSamples" + VkPipelineMultisampleStateCreateInfo + = VkSampleCountFlagBits + type FieldOptional "rasterizationSamples" + VkPipelineMultisampleStateCreateInfo + = 'False -- ' closing tick for hsc2hs + type FieldOffset "rasterizationSamples" + VkPipelineMultisampleStateCreateInfo + = + #{offset VkPipelineMultisampleStateCreateInfo, rasterizationSamples} + type FieldIsArray "rasterizationSamples" + VkPipelineMultisampleStateCreateInfo + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineMultisampleStateCreateInfo, rasterizationSamples} + +instance CanReadField "rasterizationSamples" + VkPipelineMultisampleStateCreateInfo + where + {-# INLINE getField #-} + getField = vkRasterizationSamples + + {-# INLINE readField #-} + readField = readVkRasterizationSamples + +instance CanWriteField "rasterizationSamples" + VkPipelineMultisampleStateCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkRasterizationSamples + +instance {-# OVERLAPPING #-} + HasVkSampleShadingEnable VkPipelineMultisampleStateCreateInfo where + type VkSampleShadingEnableMType + VkPipelineMultisampleStateCreateInfo + = VkBool32 + + {-# NOINLINE vkSampleShadingEnable #-} + vkSampleShadingEnable x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineMultisampleStateCreateInfo, sampleShadingEnable}) + + {-# INLINE vkSampleShadingEnableByteOffset #-} + vkSampleShadingEnableByteOffset ~_ + = #{offset VkPipelineMultisampleStateCreateInfo, sampleShadingEnable} + + {-# INLINE readVkSampleShadingEnable #-} + readVkSampleShadingEnable p + = peekByteOff p #{offset VkPipelineMultisampleStateCreateInfo, sampleShadingEnable} + + {-# INLINE writeVkSampleShadingEnable #-} + writeVkSampleShadingEnable p + = pokeByteOff p #{offset VkPipelineMultisampleStateCreateInfo, sampleShadingEnable} + +instance {-# OVERLAPPING #-} + HasField "sampleShadingEnable" VkPipelineMultisampleStateCreateInfo + where + type FieldType "sampleShadingEnable" + VkPipelineMultisampleStateCreateInfo + = VkBool32 + type FieldOptional "sampleShadingEnable" + VkPipelineMultisampleStateCreateInfo + = 'False -- ' closing tick for hsc2hs + type FieldOffset "sampleShadingEnable" + VkPipelineMultisampleStateCreateInfo + = + #{offset VkPipelineMultisampleStateCreateInfo, sampleShadingEnable} + type FieldIsArray "sampleShadingEnable" + VkPipelineMultisampleStateCreateInfo + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineMultisampleStateCreateInfo, sampleShadingEnable} + +instance CanReadField "sampleShadingEnable" + VkPipelineMultisampleStateCreateInfo + where + {-# INLINE getField #-} + getField = vkSampleShadingEnable + + {-# INLINE readField #-} + readField = readVkSampleShadingEnable + +instance CanWriteField "sampleShadingEnable" + VkPipelineMultisampleStateCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkSampleShadingEnable + +instance {-# OVERLAPPING #-} + HasVkMinSampleShading VkPipelineMultisampleStateCreateInfo where + type VkMinSampleShadingMType VkPipelineMultisampleStateCreateInfo = + #{type float} + + {-# NOINLINE vkMinSampleShading #-} + vkMinSampleShading x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineMultisampleStateCreateInfo, minSampleShading}) + + {-# INLINE vkMinSampleShadingByteOffset #-} + vkMinSampleShadingByteOffset ~_ + = #{offset VkPipelineMultisampleStateCreateInfo, minSampleShading} + + {-# INLINE readVkMinSampleShading #-} + readVkMinSampleShading p + = peekByteOff p #{offset VkPipelineMultisampleStateCreateInfo, minSampleShading} + + {-# INLINE writeVkMinSampleShading #-} + writeVkMinSampleShading p + = pokeByteOff p #{offset VkPipelineMultisampleStateCreateInfo, minSampleShading} + +instance {-# OVERLAPPING #-} + HasField "minSampleShading" VkPipelineMultisampleStateCreateInfo + where + type FieldType "minSampleShading" + VkPipelineMultisampleStateCreateInfo + = #{type float} + type FieldOptional "minSampleShading" + VkPipelineMultisampleStateCreateInfo + = 'False -- ' closing tick for hsc2hs + type FieldOffset "minSampleShading" + VkPipelineMultisampleStateCreateInfo + = + #{offset VkPipelineMultisampleStateCreateInfo, minSampleShading} + type FieldIsArray "minSampleShading" + VkPipelineMultisampleStateCreateInfo + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineMultisampleStateCreateInfo, minSampleShading} + +instance CanReadField "minSampleShading" + VkPipelineMultisampleStateCreateInfo + where + {-# INLINE getField #-} + getField = vkMinSampleShading + + {-# INLINE readField #-} + readField = readVkMinSampleShading + +instance CanWriteField "minSampleShading" + VkPipelineMultisampleStateCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkMinSampleShading + +instance {-# OVERLAPPING #-} + HasVkPSampleMask VkPipelineMultisampleStateCreateInfo where + type VkPSampleMaskMType VkPipelineMultisampleStateCreateInfo = + Ptr VkSampleMask + + {-# NOINLINE vkPSampleMask #-} + vkPSampleMask x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineMultisampleStateCreateInfo, pSampleMask}) + + {-# INLINE vkPSampleMaskByteOffset #-} + vkPSampleMaskByteOffset ~_ + = #{offset VkPipelineMultisampleStateCreateInfo, pSampleMask} + + {-# INLINE readVkPSampleMask #-} + readVkPSampleMask p + = peekByteOff p #{offset VkPipelineMultisampleStateCreateInfo, pSampleMask} + + {-# INLINE writeVkPSampleMask #-} + writeVkPSampleMask p + = pokeByteOff p #{offset VkPipelineMultisampleStateCreateInfo, pSampleMask} + +instance {-# OVERLAPPING #-} + HasField "pSampleMask" VkPipelineMultisampleStateCreateInfo where + type FieldType "pSampleMask" VkPipelineMultisampleStateCreateInfo = + Ptr VkSampleMask + type FieldOptional "pSampleMask" + VkPipelineMultisampleStateCreateInfo + = 'True -- ' closing tick for hsc2hs + type FieldOffset "pSampleMask" VkPipelineMultisampleStateCreateInfo + = + #{offset VkPipelineMultisampleStateCreateInfo, pSampleMask} + type FieldIsArray "pSampleMask" + VkPipelineMultisampleStateCreateInfo + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineMultisampleStateCreateInfo, pSampleMask} + +instance CanReadField "pSampleMask" + VkPipelineMultisampleStateCreateInfo + where + {-# INLINE getField #-} + getField = vkPSampleMask + + {-# INLINE readField #-} + readField = readVkPSampleMask + +instance CanWriteField "pSampleMask" + VkPipelineMultisampleStateCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkPSampleMask + +instance {-# OVERLAPPING #-} + HasVkAlphaToCoverageEnable VkPipelineMultisampleStateCreateInfo + where + type VkAlphaToCoverageEnableMType + VkPipelineMultisampleStateCreateInfo + = VkBool32 + + {-# NOINLINE vkAlphaToCoverageEnable #-} + vkAlphaToCoverageEnable x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineMultisampleStateCreateInfo, alphaToCoverageEnable}) + + {-# INLINE vkAlphaToCoverageEnableByteOffset #-} + vkAlphaToCoverageEnableByteOffset ~_ + = #{offset VkPipelineMultisampleStateCreateInfo, alphaToCoverageEnable} + + {-# INLINE readVkAlphaToCoverageEnable #-} + readVkAlphaToCoverageEnable p + = peekByteOff p #{offset VkPipelineMultisampleStateCreateInfo, alphaToCoverageEnable} + + {-# INLINE writeVkAlphaToCoverageEnable #-} + writeVkAlphaToCoverageEnable p + = pokeByteOff p #{offset VkPipelineMultisampleStateCreateInfo, alphaToCoverageEnable} + +instance {-# OVERLAPPING #-} + HasField "alphaToCoverageEnable" + VkPipelineMultisampleStateCreateInfo + where + type FieldType "alphaToCoverageEnable" + VkPipelineMultisampleStateCreateInfo + = VkBool32 + type FieldOptional "alphaToCoverageEnable" + VkPipelineMultisampleStateCreateInfo + = 'False -- ' closing tick for hsc2hs + type FieldOffset "alphaToCoverageEnable" + VkPipelineMultisampleStateCreateInfo + = + #{offset VkPipelineMultisampleStateCreateInfo, alphaToCoverageEnable} + type FieldIsArray "alphaToCoverageEnable" + VkPipelineMultisampleStateCreateInfo + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineMultisampleStateCreateInfo, alphaToCoverageEnable} + +instance CanReadField "alphaToCoverageEnable" + VkPipelineMultisampleStateCreateInfo + where + {-# INLINE getField #-} + getField = vkAlphaToCoverageEnable + + {-# INLINE readField #-} + readField = readVkAlphaToCoverageEnable + +instance CanWriteField "alphaToCoverageEnable" + VkPipelineMultisampleStateCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkAlphaToCoverageEnable + +instance {-# OVERLAPPING #-} + HasVkAlphaToOneEnable VkPipelineMultisampleStateCreateInfo where + type VkAlphaToOneEnableMType VkPipelineMultisampleStateCreateInfo = + VkBool32 + + {-# NOINLINE vkAlphaToOneEnable #-} + vkAlphaToOneEnable x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineMultisampleStateCreateInfo, alphaToOneEnable}) + + {-# INLINE vkAlphaToOneEnableByteOffset #-} + vkAlphaToOneEnableByteOffset ~_ + = #{offset VkPipelineMultisampleStateCreateInfo, alphaToOneEnable} + + {-# INLINE readVkAlphaToOneEnable #-} + readVkAlphaToOneEnable p + = peekByteOff p #{offset VkPipelineMultisampleStateCreateInfo, alphaToOneEnable} + + {-# INLINE writeVkAlphaToOneEnable #-} + writeVkAlphaToOneEnable p + = pokeByteOff p #{offset VkPipelineMultisampleStateCreateInfo, alphaToOneEnable} + +instance {-# OVERLAPPING #-} + HasField "alphaToOneEnable" VkPipelineMultisampleStateCreateInfo + where + type FieldType "alphaToOneEnable" + VkPipelineMultisampleStateCreateInfo + = VkBool32 + type FieldOptional "alphaToOneEnable" + VkPipelineMultisampleStateCreateInfo + = 'False -- ' closing tick for hsc2hs + type FieldOffset "alphaToOneEnable" + VkPipelineMultisampleStateCreateInfo + = + #{offset VkPipelineMultisampleStateCreateInfo, alphaToOneEnable} + type FieldIsArray "alphaToOneEnable" + VkPipelineMultisampleStateCreateInfo + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineMultisampleStateCreateInfo, alphaToOneEnable} + +instance CanReadField "alphaToOneEnable" + VkPipelineMultisampleStateCreateInfo + where + {-# INLINE getField #-} + getField = vkAlphaToOneEnable + + {-# INLINE readField #-} + readField = readVkAlphaToOneEnable + +instance CanWriteField "alphaToOneEnable" + VkPipelineMultisampleStateCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkAlphaToOneEnable + +instance Show VkPipelineMultisampleStateCreateInfo where + showsPrec d x + = showString "VkPipelineMultisampleStateCreateInfo {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkFlags = " . + showsPrec d (vkFlags x) . + showString ", " . + showString "vkRasterizationSamples = " . + showsPrec d (vkRasterizationSamples x) . + showString ", " . + showString "vkSampleShadingEnable = " . + showsPrec d (vkSampleShadingEnable x) . + showString ", " . + showString "vkMinSampleShading = " . + showsPrec d (vkMinSampleShading x) . + showString ", " . + showString "vkPSampleMask = " . + showsPrec d (vkPSampleMask x) . + showString ", " . + showString "vkAlphaToCoverageEnable = " . + showsPrec d (vkAlphaToCoverageEnable x) . + showString ", " . + showString "vkAlphaToOneEnable = " . + showsPrec d (vkAlphaToOneEnable x) . + showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkPipelineRasterizationConservativeStateCreateInfoEXT.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkPipelineRasterizationConservativeStateCreateInfoEXT.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkPipelineRasterizationConservativeStateCreateInfoEXT.hsc @@ -0,0 +1,453 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkPipelineRasterizationConservativeStateCreateInfoEXT + (VkPipelineRasterizationConservativeStateCreateInfoEXT(..)) where +import Foreign.Storable + (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Bitmasks + (VkPipelineRasterizationConservativeStateCreateFlagsEXT) +import Graphics.Vulkan.Types.Enum.VkConservativeRasterizationModeEXT + (VkConservativeRasterizationModeEXT) +import Graphics.Vulkan.Types.Enum.VkStructureType + (VkStructureType) +import Graphics.Vulkan.Types.Struct.VkPipelineRasterizationStateCreateInfo + (VkPipelineRasterizationStateCreateInfo) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe + (unsafeDupablePerformIO) + +-- | > typedef struct VkPipelineRasterizationConservativeStateCreateInfoEXT { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkPipelineRasterizationConservativeStateCreateFlagsEXT flags; +-- > VkConservativeRasterizationModeEXT conservativeRasterizationMode; +-- > float extraPrimitiveOverestimationSize; +-- > } VkPipelineRasterizationConservativeStateCreateInfoEXT; +-- +-- +data VkPipelineRasterizationConservativeStateCreateInfoEXT = VkPipelineRasterizationConservativeStateCreateInfoEXT## Addr## + ByteArray## + +instance Eq VkPipelineRasterizationConservativeStateCreateInfoEXT + where + (VkPipelineRasterizationConservativeStateCreateInfoEXT## a _) == + x@(VkPipelineRasterizationConservativeStateCreateInfoEXT## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkPipelineRasterizationConservativeStateCreateInfoEXT + where + (VkPipelineRasterizationConservativeStateCreateInfoEXT## a _) + `compare` + x@(VkPipelineRasterizationConservativeStateCreateInfoEXT## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable + VkPipelineRasterizationConservativeStateCreateInfoEXT + where + sizeOf ~_ + = #{size VkPipelineRasterizationConservativeStateCreateInfoEXT} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkPipelineRasterizationConservativeStateCreateInfoEXT} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim + VkPipelineRasterizationConservativeStateCreateInfoEXT + where + unsafeAddr + (VkPipelineRasterizationConservativeStateCreateInfoEXT## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray + (VkPipelineRasterizationConservativeStateCreateInfoEXT## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkPipelineRasterizationConservativeStateCreateInfoEXT## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal + VkPipelineRasterizationConservativeStateCreateInfoEXT + where + type StructFields + VkPipelineRasterizationConservativeStateCreateInfoEXT + = + '["sType", "pNext", "flags", "conservativeRasterizationMode", -- ' closing tick for hsc2hs + "extraPrimitiveOverestimationSize"] + type CUnionType + VkPipelineRasterizationConservativeStateCreateInfoEXT + = 'False -- ' closing tick for hsc2hs + type ReturnedOnly + VkPipelineRasterizationConservativeStateCreateInfoEXT + = 'False -- ' closing tick for hsc2hs + type StructExtends + VkPipelineRasterizationConservativeStateCreateInfoEXT + = '[VkPipelineRasterizationStateCreateInfo] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkPipelineRasterizationConservativeStateCreateInfoEXT + where + type VkSTypeMType + VkPipelineRasterizationConservativeStateCreateInfoEXT + = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineRasterizationConservativeStateCreateInfoEXT, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkPipelineRasterizationConservativeStateCreateInfoEXT, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkPipelineRasterizationConservativeStateCreateInfoEXT, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkPipelineRasterizationConservativeStateCreateInfoEXT, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" + VkPipelineRasterizationConservativeStateCreateInfoEXT + where + type FieldType "sType" + VkPipelineRasterizationConservativeStateCreateInfoEXT + = VkStructureType + type FieldOptional "sType" + VkPipelineRasterizationConservativeStateCreateInfoEXT + = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" + VkPipelineRasterizationConservativeStateCreateInfoEXT + = + #{offset VkPipelineRasterizationConservativeStateCreateInfoEXT, sType} + type FieldIsArray "sType" + VkPipelineRasterizationConservativeStateCreateInfoEXT + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineRasterizationConservativeStateCreateInfoEXT, sType} + +instance CanReadField "sType" + VkPipelineRasterizationConservativeStateCreateInfoEXT + where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" + VkPipelineRasterizationConservativeStateCreateInfoEXT + where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkPipelineRasterizationConservativeStateCreateInfoEXT + where + type VkPNextMType + VkPipelineRasterizationConservativeStateCreateInfoEXT + = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineRasterizationConservativeStateCreateInfoEXT, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkPipelineRasterizationConservativeStateCreateInfoEXT, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkPipelineRasterizationConservativeStateCreateInfoEXT, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkPipelineRasterizationConservativeStateCreateInfoEXT, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" + VkPipelineRasterizationConservativeStateCreateInfoEXT + where + type FieldType "pNext" + VkPipelineRasterizationConservativeStateCreateInfoEXT + = Ptr Void + type FieldOptional "pNext" + VkPipelineRasterizationConservativeStateCreateInfoEXT + = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" + VkPipelineRasterizationConservativeStateCreateInfoEXT + = + #{offset VkPipelineRasterizationConservativeStateCreateInfoEXT, pNext} + type FieldIsArray "pNext" + VkPipelineRasterizationConservativeStateCreateInfoEXT + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineRasterizationConservativeStateCreateInfoEXT, pNext} + +instance CanReadField "pNext" + VkPipelineRasterizationConservativeStateCreateInfoEXT + where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" + VkPipelineRasterizationConservativeStateCreateInfoEXT + where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkFlags VkPipelineRasterizationConservativeStateCreateInfoEXT + where + type VkFlagsMType + VkPipelineRasterizationConservativeStateCreateInfoEXT + = VkPipelineRasterizationConservativeStateCreateFlagsEXT + + {-# NOINLINE vkFlags #-} + vkFlags x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineRasterizationConservativeStateCreateInfoEXT, flags}) + + {-# INLINE vkFlagsByteOffset #-} + vkFlagsByteOffset ~_ + = #{offset VkPipelineRasterizationConservativeStateCreateInfoEXT, flags} + + {-# INLINE readVkFlags #-} + readVkFlags p + = peekByteOff p #{offset VkPipelineRasterizationConservativeStateCreateInfoEXT, flags} + + {-# INLINE writeVkFlags #-} + writeVkFlags p + = pokeByteOff p #{offset VkPipelineRasterizationConservativeStateCreateInfoEXT, flags} + +instance {-# OVERLAPPING #-} + HasField "flags" + VkPipelineRasterizationConservativeStateCreateInfoEXT + where + type FieldType "flags" + VkPipelineRasterizationConservativeStateCreateInfoEXT + = VkPipelineRasterizationConservativeStateCreateFlagsEXT + type FieldOptional "flags" + VkPipelineRasterizationConservativeStateCreateInfoEXT + = 'True -- ' closing tick for hsc2hs + type FieldOffset "flags" + VkPipelineRasterizationConservativeStateCreateInfoEXT + = + #{offset VkPipelineRasterizationConservativeStateCreateInfoEXT, flags} + type FieldIsArray "flags" + VkPipelineRasterizationConservativeStateCreateInfoEXT + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineRasterizationConservativeStateCreateInfoEXT, flags} + +instance CanReadField "flags" + VkPipelineRasterizationConservativeStateCreateInfoEXT + where + {-# INLINE getField #-} + getField = vkFlags + + {-# INLINE readField #-} + readField = readVkFlags + +instance CanWriteField "flags" + VkPipelineRasterizationConservativeStateCreateInfoEXT + where + {-# INLINE writeField #-} + writeField = writeVkFlags + +instance {-# OVERLAPPING #-} + HasVkConservativeRasterizationMode + VkPipelineRasterizationConservativeStateCreateInfoEXT + where + type VkConservativeRasterizationModeMType + VkPipelineRasterizationConservativeStateCreateInfoEXT + = VkConservativeRasterizationModeEXT + + {-# NOINLINE vkConservativeRasterizationMode #-} + vkConservativeRasterizationMode x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineRasterizationConservativeStateCreateInfoEXT, conservativeRasterizationMode}) + + {-# INLINE vkConservativeRasterizationModeByteOffset #-} + vkConservativeRasterizationModeByteOffset ~_ + = #{offset VkPipelineRasterizationConservativeStateCreateInfoEXT, conservativeRasterizationMode} + + {-# INLINE readVkConservativeRasterizationMode #-} + readVkConservativeRasterizationMode p + = peekByteOff p #{offset VkPipelineRasterizationConservativeStateCreateInfoEXT, conservativeRasterizationMode} + + {-# INLINE writeVkConservativeRasterizationMode #-} + writeVkConservativeRasterizationMode p + = pokeByteOff p #{offset VkPipelineRasterizationConservativeStateCreateInfoEXT, conservativeRasterizationMode} + +instance {-# OVERLAPPING #-} + HasField "conservativeRasterizationMode" + VkPipelineRasterizationConservativeStateCreateInfoEXT + where + type FieldType "conservativeRasterizationMode" + VkPipelineRasterizationConservativeStateCreateInfoEXT + = VkConservativeRasterizationModeEXT + type FieldOptional "conservativeRasterizationMode" + VkPipelineRasterizationConservativeStateCreateInfoEXT + = 'False -- ' closing tick for hsc2hs + type FieldOffset "conservativeRasterizationMode" + VkPipelineRasterizationConservativeStateCreateInfoEXT + = + #{offset VkPipelineRasterizationConservativeStateCreateInfoEXT, conservativeRasterizationMode} + type FieldIsArray "conservativeRasterizationMode" + VkPipelineRasterizationConservativeStateCreateInfoEXT + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineRasterizationConservativeStateCreateInfoEXT, conservativeRasterizationMode} + +instance CanReadField "conservativeRasterizationMode" + VkPipelineRasterizationConservativeStateCreateInfoEXT + where + {-# INLINE getField #-} + getField = vkConservativeRasterizationMode + + {-# INLINE readField #-} + readField = readVkConservativeRasterizationMode + +instance CanWriteField "conservativeRasterizationMode" + VkPipelineRasterizationConservativeStateCreateInfoEXT + where + {-# INLINE writeField #-} + writeField = writeVkConservativeRasterizationMode + +instance {-# OVERLAPPING #-} + HasVkExtraPrimitiveOverestimationSize + VkPipelineRasterizationConservativeStateCreateInfoEXT + where + type VkExtraPrimitiveOverestimationSizeMType + VkPipelineRasterizationConservativeStateCreateInfoEXT + = #{type float} + + {-# NOINLINE vkExtraPrimitiveOverestimationSize #-} + vkExtraPrimitiveOverestimationSize x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineRasterizationConservativeStateCreateInfoEXT, extraPrimitiveOverestimationSize}) + + {-# INLINE vkExtraPrimitiveOverestimationSizeByteOffset #-} + vkExtraPrimitiveOverestimationSizeByteOffset ~_ + = #{offset VkPipelineRasterizationConservativeStateCreateInfoEXT, extraPrimitiveOverestimationSize} + + {-# INLINE readVkExtraPrimitiveOverestimationSize #-} + readVkExtraPrimitiveOverestimationSize p + = peekByteOff p #{offset VkPipelineRasterizationConservativeStateCreateInfoEXT, extraPrimitiveOverestimationSize} + + {-# INLINE writeVkExtraPrimitiveOverestimationSize #-} + writeVkExtraPrimitiveOverestimationSize p + = pokeByteOff p #{offset VkPipelineRasterizationConservativeStateCreateInfoEXT, extraPrimitiveOverestimationSize} + +instance {-# OVERLAPPING #-} + HasField "extraPrimitiveOverestimationSize" + VkPipelineRasterizationConservativeStateCreateInfoEXT + where + type FieldType "extraPrimitiveOverestimationSize" + VkPipelineRasterizationConservativeStateCreateInfoEXT + = #{type float} + type FieldOptional "extraPrimitiveOverestimationSize" + VkPipelineRasterizationConservativeStateCreateInfoEXT + = 'False -- ' closing tick for hsc2hs + type FieldOffset "extraPrimitiveOverestimationSize" + VkPipelineRasterizationConservativeStateCreateInfoEXT + = + #{offset VkPipelineRasterizationConservativeStateCreateInfoEXT, extraPrimitiveOverestimationSize} + type FieldIsArray "extraPrimitiveOverestimationSize" + VkPipelineRasterizationConservativeStateCreateInfoEXT + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineRasterizationConservativeStateCreateInfoEXT, extraPrimitiveOverestimationSize} + +instance CanReadField "extraPrimitiveOverestimationSize" + VkPipelineRasterizationConservativeStateCreateInfoEXT + where + {-# INLINE getField #-} + getField = vkExtraPrimitiveOverestimationSize + + {-# INLINE readField #-} + readField = readVkExtraPrimitiveOverestimationSize + +instance CanWriteField "extraPrimitiveOverestimationSize" + VkPipelineRasterizationConservativeStateCreateInfoEXT + where + {-# INLINE writeField #-} + writeField = writeVkExtraPrimitiveOverestimationSize + +instance Show VkPipelineRasterizationConservativeStateCreateInfoEXT + where + showsPrec d x + = showString + "VkPipelineRasterizationConservativeStateCreateInfoEXT {" + . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkFlags = " . + showsPrec d (vkFlags x) . + showString ", " . + showString "vkConservativeRasterizationMode = " . + showsPrec d (vkConservativeRasterizationMode x) . + showString ", " . + showString "vkExtraPrimitiveOverestimationSize = " . + showsPrec d (vkExtraPrimitiveOverestimationSize x) . + showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkPipelineRasterizationStateCreateInfo.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkPipelineRasterizationStateCreateInfo.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkPipelineRasterizationStateCreateInfo.hsc @@ -0,0 +1,932 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkPipelineRasterizationStateCreateInfo + (VkPipelineRasterizationStateCreateInfo(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.BaseTypes (VkBool32) +import Graphics.Vulkan.Types.Bitmasks (VkPipelineRasterizationStateCreateFlags) +import Graphics.Vulkan.Types.Enum.VkCullModeFlags (VkCullModeFlags) +import Graphics.Vulkan.Types.Enum.VkFrontFace (VkFrontFace) +import Graphics.Vulkan.Types.Enum.VkPolygonMode (VkPolygonMode) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkPipelineRasterizationStateCreateInfo { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkPipelineRasterizationStateCreateFlags flags; +-- > VkBool32 depthClampEnable; +-- > VkBool32 rasterizerDiscardEnable; +-- > VkPolygonMode polygonMode; +-- > VkCullModeFlags cullMode; +-- > VkFrontFace frontFace; +-- > VkBool32 depthBiasEnable; +-- > float depthBiasConstantFactor; +-- > float depthBiasClamp; +-- > float depthBiasSlopeFactor; +-- > float lineWidth; +-- > } VkPipelineRasterizationStateCreateInfo; +-- +-- +data VkPipelineRasterizationStateCreateInfo = VkPipelineRasterizationStateCreateInfo## Addr## + ByteArray## + +instance Eq VkPipelineRasterizationStateCreateInfo where + (VkPipelineRasterizationStateCreateInfo## a _) == + x@(VkPipelineRasterizationStateCreateInfo## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkPipelineRasterizationStateCreateInfo where + (VkPipelineRasterizationStateCreateInfo## a _) `compare` + x@(VkPipelineRasterizationStateCreateInfo## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkPipelineRasterizationStateCreateInfo where + sizeOf ~_ + = #{size VkPipelineRasterizationStateCreateInfo} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkPipelineRasterizationStateCreateInfo} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkPipelineRasterizationStateCreateInfo + where + unsafeAddr (VkPipelineRasterizationStateCreateInfo## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkPipelineRasterizationStateCreateInfo## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkPipelineRasterizationStateCreateInfo## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkPipelineRasterizationStateCreateInfo where + type StructFields VkPipelineRasterizationStateCreateInfo = + '["sType", "pNext", "flags", "depthClampEnable", -- ' closing tick for hsc2hs + "rasterizerDiscardEnable", "polygonMode", "cullMode", "frontFace", + "depthBiasEnable", "depthBiasConstantFactor", "depthBiasClamp", + "depthBiasSlopeFactor", "lineWidth"] + type CUnionType VkPipelineRasterizationStateCreateInfo = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkPipelineRasterizationStateCreateInfo = 'False -- ' closing tick for hsc2hs + type StructExtends VkPipelineRasterizationStateCreateInfo = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkPipelineRasterizationStateCreateInfo where + type VkSTypeMType VkPipelineRasterizationStateCreateInfo = + VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineRasterizationStateCreateInfo, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkPipelineRasterizationStateCreateInfo, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkPipelineRasterizationStateCreateInfo, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkPipelineRasterizationStateCreateInfo, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkPipelineRasterizationStateCreateInfo where + type FieldType "sType" VkPipelineRasterizationStateCreateInfo = + VkStructureType + type FieldOptional "sType" VkPipelineRasterizationStateCreateInfo = + 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkPipelineRasterizationStateCreateInfo = + #{offset VkPipelineRasterizationStateCreateInfo, sType} + type FieldIsArray "sType" VkPipelineRasterizationStateCreateInfo = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineRasterizationStateCreateInfo, sType} + +instance CanReadField "sType" + VkPipelineRasterizationStateCreateInfo + where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" + VkPipelineRasterizationStateCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkPipelineRasterizationStateCreateInfo where + type VkPNextMType VkPipelineRasterizationStateCreateInfo = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineRasterizationStateCreateInfo, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkPipelineRasterizationStateCreateInfo, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkPipelineRasterizationStateCreateInfo, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkPipelineRasterizationStateCreateInfo, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkPipelineRasterizationStateCreateInfo where + type FieldType "pNext" VkPipelineRasterizationStateCreateInfo = + Ptr Void + type FieldOptional "pNext" VkPipelineRasterizationStateCreateInfo = + 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkPipelineRasterizationStateCreateInfo = + #{offset VkPipelineRasterizationStateCreateInfo, pNext} + type FieldIsArray "pNext" VkPipelineRasterizationStateCreateInfo = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineRasterizationStateCreateInfo, pNext} + +instance CanReadField "pNext" + VkPipelineRasterizationStateCreateInfo + where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" + VkPipelineRasterizationStateCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkFlags VkPipelineRasterizationStateCreateInfo where + type VkFlagsMType VkPipelineRasterizationStateCreateInfo = + VkPipelineRasterizationStateCreateFlags + + {-# NOINLINE vkFlags #-} + vkFlags x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineRasterizationStateCreateInfo, flags}) + + {-# INLINE vkFlagsByteOffset #-} + vkFlagsByteOffset ~_ + = #{offset VkPipelineRasterizationStateCreateInfo, flags} + + {-# INLINE readVkFlags #-} + readVkFlags p + = peekByteOff p #{offset VkPipelineRasterizationStateCreateInfo, flags} + + {-# INLINE writeVkFlags #-} + writeVkFlags p + = pokeByteOff p #{offset VkPipelineRasterizationStateCreateInfo, flags} + +instance {-# OVERLAPPING #-} + HasField "flags" VkPipelineRasterizationStateCreateInfo where + type FieldType "flags" VkPipelineRasterizationStateCreateInfo = + VkPipelineRasterizationStateCreateFlags + type FieldOptional "flags" VkPipelineRasterizationStateCreateInfo = + 'True -- ' closing tick for hsc2hs + type FieldOffset "flags" VkPipelineRasterizationStateCreateInfo = + #{offset VkPipelineRasterizationStateCreateInfo, flags} + type FieldIsArray "flags" VkPipelineRasterizationStateCreateInfo = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineRasterizationStateCreateInfo, flags} + +instance CanReadField "flags" + VkPipelineRasterizationStateCreateInfo + where + {-# INLINE getField #-} + getField = vkFlags + + {-# INLINE readField #-} + readField = readVkFlags + +instance CanWriteField "flags" + VkPipelineRasterizationStateCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkFlags + +instance {-# OVERLAPPING #-} + HasVkDepthClampEnable VkPipelineRasterizationStateCreateInfo where + type VkDepthClampEnableMType VkPipelineRasterizationStateCreateInfo + = VkBool32 + + {-# NOINLINE vkDepthClampEnable #-} + vkDepthClampEnable x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineRasterizationStateCreateInfo, depthClampEnable}) + + {-# INLINE vkDepthClampEnableByteOffset #-} + vkDepthClampEnableByteOffset ~_ + = #{offset VkPipelineRasterizationStateCreateInfo, depthClampEnable} + + {-# INLINE readVkDepthClampEnable #-} + readVkDepthClampEnable p + = peekByteOff p #{offset VkPipelineRasterizationStateCreateInfo, depthClampEnable} + + {-# INLINE writeVkDepthClampEnable #-} + writeVkDepthClampEnable p + = pokeByteOff p #{offset VkPipelineRasterizationStateCreateInfo, depthClampEnable} + +instance {-# OVERLAPPING #-} + HasField "depthClampEnable" VkPipelineRasterizationStateCreateInfo + where + type FieldType "depthClampEnable" + VkPipelineRasterizationStateCreateInfo + = VkBool32 + type FieldOptional "depthClampEnable" + VkPipelineRasterizationStateCreateInfo + = 'False -- ' closing tick for hsc2hs + type FieldOffset "depthClampEnable" + VkPipelineRasterizationStateCreateInfo + = + #{offset VkPipelineRasterizationStateCreateInfo, depthClampEnable} + type FieldIsArray "depthClampEnable" + VkPipelineRasterizationStateCreateInfo + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineRasterizationStateCreateInfo, depthClampEnable} + +instance CanReadField "depthClampEnable" + VkPipelineRasterizationStateCreateInfo + where + {-# INLINE getField #-} + getField = vkDepthClampEnable + + {-# INLINE readField #-} + readField = readVkDepthClampEnable + +instance CanWriteField "depthClampEnable" + VkPipelineRasterizationStateCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkDepthClampEnable + +instance {-# OVERLAPPING #-} + HasVkRasterizerDiscardEnable VkPipelineRasterizationStateCreateInfo + where + type VkRasterizerDiscardEnableMType + VkPipelineRasterizationStateCreateInfo + = VkBool32 + + {-# NOINLINE vkRasterizerDiscardEnable #-} + vkRasterizerDiscardEnable x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineRasterizationStateCreateInfo, rasterizerDiscardEnable}) + + {-# INLINE vkRasterizerDiscardEnableByteOffset #-} + vkRasterizerDiscardEnableByteOffset ~_ + = #{offset VkPipelineRasterizationStateCreateInfo, rasterizerDiscardEnable} + + {-# INLINE readVkRasterizerDiscardEnable #-} + readVkRasterizerDiscardEnable p + = peekByteOff p #{offset VkPipelineRasterizationStateCreateInfo, rasterizerDiscardEnable} + + {-# INLINE writeVkRasterizerDiscardEnable #-} + writeVkRasterizerDiscardEnable p + = pokeByteOff p #{offset VkPipelineRasterizationStateCreateInfo, rasterizerDiscardEnable} + +instance {-# OVERLAPPING #-} + HasField "rasterizerDiscardEnable" + VkPipelineRasterizationStateCreateInfo + where + type FieldType "rasterizerDiscardEnable" + VkPipelineRasterizationStateCreateInfo + = VkBool32 + type FieldOptional "rasterizerDiscardEnable" + VkPipelineRasterizationStateCreateInfo + = 'False -- ' closing tick for hsc2hs + type FieldOffset "rasterizerDiscardEnable" + VkPipelineRasterizationStateCreateInfo + = + #{offset VkPipelineRasterizationStateCreateInfo, rasterizerDiscardEnable} + type FieldIsArray "rasterizerDiscardEnable" + VkPipelineRasterizationStateCreateInfo + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineRasterizationStateCreateInfo, rasterizerDiscardEnable} + +instance CanReadField "rasterizerDiscardEnable" + VkPipelineRasterizationStateCreateInfo + where + {-# INLINE getField #-} + getField = vkRasterizerDiscardEnable + + {-# INLINE readField #-} + readField = readVkRasterizerDiscardEnable + +instance CanWriteField "rasterizerDiscardEnable" + VkPipelineRasterizationStateCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkRasterizerDiscardEnable + +instance {-# OVERLAPPING #-} + HasVkPolygonMode VkPipelineRasterizationStateCreateInfo where + type VkPolygonModeMType VkPipelineRasterizationStateCreateInfo = + VkPolygonMode + + {-# NOINLINE vkPolygonMode #-} + vkPolygonMode x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineRasterizationStateCreateInfo, polygonMode}) + + {-# INLINE vkPolygonModeByteOffset #-} + vkPolygonModeByteOffset ~_ + = #{offset VkPipelineRasterizationStateCreateInfo, polygonMode} + + {-# INLINE readVkPolygonMode #-} + readVkPolygonMode p + = peekByteOff p #{offset VkPipelineRasterizationStateCreateInfo, polygonMode} + + {-# INLINE writeVkPolygonMode #-} + writeVkPolygonMode p + = pokeByteOff p #{offset VkPipelineRasterizationStateCreateInfo, polygonMode} + +instance {-# OVERLAPPING #-} + HasField "polygonMode" VkPipelineRasterizationStateCreateInfo where + type FieldType "polygonMode" VkPipelineRasterizationStateCreateInfo + = VkPolygonMode + type FieldOptional "polygonMode" + VkPipelineRasterizationStateCreateInfo + = 'False -- ' closing tick for hsc2hs + type FieldOffset "polygonMode" + VkPipelineRasterizationStateCreateInfo + = + #{offset VkPipelineRasterizationStateCreateInfo, polygonMode} + type FieldIsArray "polygonMode" + VkPipelineRasterizationStateCreateInfo + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineRasterizationStateCreateInfo, polygonMode} + +instance CanReadField "polygonMode" + VkPipelineRasterizationStateCreateInfo + where + {-# INLINE getField #-} + getField = vkPolygonMode + + {-# INLINE readField #-} + readField = readVkPolygonMode + +instance CanWriteField "polygonMode" + VkPipelineRasterizationStateCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkPolygonMode + +instance {-# OVERLAPPING #-} + HasVkCullMode VkPipelineRasterizationStateCreateInfo where + type VkCullModeMType VkPipelineRasterizationStateCreateInfo = + VkCullModeFlags + + {-# NOINLINE vkCullMode #-} + vkCullMode x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineRasterizationStateCreateInfo, cullMode}) + + {-# INLINE vkCullModeByteOffset #-} + vkCullModeByteOffset ~_ + = #{offset VkPipelineRasterizationStateCreateInfo, cullMode} + + {-# INLINE readVkCullMode #-} + readVkCullMode p + = peekByteOff p #{offset VkPipelineRasterizationStateCreateInfo, cullMode} + + {-# INLINE writeVkCullMode #-} + writeVkCullMode p + = pokeByteOff p #{offset VkPipelineRasterizationStateCreateInfo, cullMode} + +instance {-# OVERLAPPING #-} + HasField "cullMode" VkPipelineRasterizationStateCreateInfo where + type FieldType "cullMode" VkPipelineRasterizationStateCreateInfo = + VkCullModeFlags + type FieldOptional "cullMode" + VkPipelineRasterizationStateCreateInfo + = 'True -- ' closing tick for hsc2hs + type FieldOffset "cullMode" VkPipelineRasterizationStateCreateInfo + = + #{offset VkPipelineRasterizationStateCreateInfo, cullMode} + type FieldIsArray "cullMode" VkPipelineRasterizationStateCreateInfo + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineRasterizationStateCreateInfo, cullMode} + +instance CanReadField "cullMode" + VkPipelineRasterizationStateCreateInfo + where + {-# INLINE getField #-} + getField = vkCullMode + + {-# INLINE readField #-} + readField = readVkCullMode + +instance CanWriteField "cullMode" + VkPipelineRasterizationStateCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkCullMode + +instance {-# OVERLAPPING #-} + HasVkFrontFace VkPipelineRasterizationStateCreateInfo where + type VkFrontFaceMType VkPipelineRasterizationStateCreateInfo = + VkFrontFace + + {-# NOINLINE vkFrontFace #-} + vkFrontFace x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineRasterizationStateCreateInfo, frontFace}) + + {-# INLINE vkFrontFaceByteOffset #-} + vkFrontFaceByteOffset ~_ + = #{offset VkPipelineRasterizationStateCreateInfo, frontFace} + + {-# INLINE readVkFrontFace #-} + readVkFrontFace p + = peekByteOff p #{offset VkPipelineRasterizationStateCreateInfo, frontFace} + + {-# INLINE writeVkFrontFace #-} + writeVkFrontFace p + = pokeByteOff p #{offset VkPipelineRasterizationStateCreateInfo, frontFace} + +instance {-# OVERLAPPING #-} + HasField "frontFace" VkPipelineRasterizationStateCreateInfo where + type FieldType "frontFace" VkPipelineRasterizationStateCreateInfo = + VkFrontFace + type FieldOptional "frontFace" + VkPipelineRasterizationStateCreateInfo + = 'False -- ' closing tick for hsc2hs + type FieldOffset "frontFace" VkPipelineRasterizationStateCreateInfo + = + #{offset VkPipelineRasterizationStateCreateInfo, frontFace} + type FieldIsArray "frontFace" + VkPipelineRasterizationStateCreateInfo + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineRasterizationStateCreateInfo, frontFace} + +instance CanReadField "frontFace" + VkPipelineRasterizationStateCreateInfo + where + {-# INLINE getField #-} + getField = vkFrontFace + + {-# INLINE readField #-} + readField = readVkFrontFace + +instance CanWriteField "frontFace" + VkPipelineRasterizationStateCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkFrontFace + +instance {-# OVERLAPPING #-} + HasVkDepthBiasEnable VkPipelineRasterizationStateCreateInfo where + type VkDepthBiasEnableMType VkPipelineRasterizationStateCreateInfo + = VkBool32 + + {-# NOINLINE vkDepthBiasEnable #-} + vkDepthBiasEnable x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineRasterizationStateCreateInfo, depthBiasEnable}) + + {-# INLINE vkDepthBiasEnableByteOffset #-} + vkDepthBiasEnableByteOffset ~_ + = #{offset VkPipelineRasterizationStateCreateInfo, depthBiasEnable} + + {-# INLINE readVkDepthBiasEnable #-} + readVkDepthBiasEnable p + = peekByteOff p #{offset VkPipelineRasterizationStateCreateInfo, depthBiasEnable} + + {-# INLINE writeVkDepthBiasEnable #-} + writeVkDepthBiasEnable p + = pokeByteOff p #{offset VkPipelineRasterizationStateCreateInfo, depthBiasEnable} + +instance {-# OVERLAPPING #-} + HasField "depthBiasEnable" VkPipelineRasterizationStateCreateInfo + where + type FieldType "depthBiasEnable" + VkPipelineRasterizationStateCreateInfo + = VkBool32 + type FieldOptional "depthBiasEnable" + VkPipelineRasterizationStateCreateInfo + = 'False -- ' closing tick for hsc2hs + type FieldOffset "depthBiasEnable" + VkPipelineRasterizationStateCreateInfo + = + #{offset VkPipelineRasterizationStateCreateInfo, depthBiasEnable} + type FieldIsArray "depthBiasEnable" + VkPipelineRasterizationStateCreateInfo + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineRasterizationStateCreateInfo, depthBiasEnable} + +instance CanReadField "depthBiasEnable" + VkPipelineRasterizationStateCreateInfo + where + {-# INLINE getField #-} + getField = vkDepthBiasEnable + + {-# INLINE readField #-} + readField = readVkDepthBiasEnable + +instance CanWriteField "depthBiasEnable" + VkPipelineRasterizationStateCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkDepthBiasEnable + +instance {-# OVERLAPPING #-} + HasVkDepthBiasConstantFactor VkPipelineRasterizationStateCreateInfo + where + type VkDepthBiasConstantFactorMType + VkPipelineRasterizationStateCreateInfo + = #{type float} + + {-# NOINLINE vkDepthBiasConstantFactor #-} + vkDepthBiasConstantFactor x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineRasterizationStateCreateInfo, depthBiasConstantFactor}) + + {-# INLINE vkDepthBiasConstantFactorByteOffset #-} + vkDepthBiasConstantFactorByteOffset ~_ + = #{offset VkPipelineRasterizationStateCreateInfo, depthBiasConstantFactor} + + {-# INLINE readVkDepthBiasConstantFactor #-} + readVkDepthBiasConstantFactor p + = peekByteOff p #{offset VkPipelineRasterizationStateCreateInfo, depthBiasConstantFactor} + + {-# INLINE writeVkDepthBiasConstantFactor #-} + writeVkDepthBiasConstantFactor p + = pokeByteOff p #{offset VkPipelineRasterizationStateCreateInfo, depthBiasConstantFactor} + +instance {-# OVERLAPPING #-} + HasField "depthBiasConstantFactor" + VkPipelineRasterizationStateCreateInfo + where + type FieldType "depthBiasConstantFactor" + VkPipelineRasterizationStateCreateInfo + = #{type float} + type FieldOptional "depthBiasConstantFactor" + VkPipelineRasterizationStateCreateInfo + = 'False -- ' closing tick for hsc2hs + type FieldOffset "depthBiasConstantFactor" + VkPipelineRasterizationStateCreateInfo + = + #{offset VkPipelineRasterizationStateCreateInfo, depthBiasConstantFactor} + type FieldIsArray "depthBiasConstantFactor" + VkPipelineRasterizationStateCreateInfo + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineRasterizationStateCreateInfo, depthBiasConstantFactor} + +instance CanReadField "depthBiasConstantFactor" + VkPipelineRasterizationStateCreateInfo + where + {-# INLINE getField #-} + getField = vkDepthBiasConstantFactor + + {-# INLINE readField #-} + readField = readVkDepthBiasConstantFactor + +instance CanWriteField "depthBiasConstantFactor" + VkPipelineRasterizationStateCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkDepthBiasConstantFactor + +instance {-# OVERLAPPING #-} + HasVkDepthBiasClamp VkPipelineRasterizationStateCreateInfo where + type VkDepthBiasClampMType VkPipelineRasterizationStateCreateInfo = + #{type float} + + {-# NOINLINE vkDepthBiasClamp #-} + vkDepthBiasClamp x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineRasterizationStateCreateInfo, depthBiasClamp}) + + {-# INLINE vkDepthBiasClampByteOffset #-} + vkDepthBiasClampByteOffset ~_ + = #{offset VkPipelineRasterizationStateCreateInfo, depthBiasClamp} + + {-# INLINE readVkDepthBiasClamp #-} + readVkDepthBiasClamp p + = peekByteOff p #{offset VkPipelineRasterizationStateCreateInfo, depthBiasClamp} + + {-# INLINE writeVkDepthBiasClamp #-} + writeVkDepthBiasClamp p + = pokeByteOff p #{offset VkPipelineRasterizationStateCreateInfo, depthBiasClamp} + +instance {-# OVERLAPPING #-} + HasField "depthBiasClamp" VkPipelineRasterizationStateCreateInfo + where + type FieldType "depthBiasClamp" + VkPipelineRasterizationStateCreateInfo + = #{type float} + type FieldOptional "depthBiasClamp" + VkPipelineRasterizationStateCreateInfo + = 'False -- ' closing tick for hsc2hs + type FieldOffset "depthBiasClamp" + VkPipelineRasterizationStateCreateInfo + = + #{offset VkPipelineRasterizationStateCreateInfo, depthBiasClamp} + type FieldIsArray "depthBiasClamp" + VkPipelineRasterizationStateCreateInfo + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineRasterizationStateCreateInfo, depthBiasClamp} + +instance CanReadField "depthBiasClamp" + VkPipelineRasterizationStateCreateInfo + where + {-# INLINE getField #-} + getField = vkDepthBiasClamp + + {-# INLINE readField #-} + readField = readVkDepthBiasClamp + +instance CanWriteField "depthBiasClamp" + VkPipelineRasterizationStateCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkDepthBiasClamp + +instance {-# OVERLAPPING #-} + HasVkDepthBiasSlopeFactor VkPipelineRasterizationStateCreateInfo + where + type VkDepthBiasSlopeFactorMType + VkPipelineRasterizationStateCreateInfo + = #{type float} + + {-# NOINLINE vkDepthBiasSlopeFactor #-} + vkDepthBiasSlopeFactor x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineRasterizationStateCreateInfo, depthBiasSlopeFactor}) + + {-# INLINE vkDepthBiasSlopeFactorByteOffset #-} + vkDepthBiasSlopeFactorByteOffset ~_ + = #{offset VkPipelineRasterizationStateCreateInfo, depthBiasSlopeFactor} + + {-# INLINE readVkDepthBiasSlopeFactor #-} + readVkDepthBiasSlopeFactor p + = peekByteOff p #{offset VkPipelineRasterizationStateCreateInfo, depthBiasSlopeFactor} + + {-# INLINE writeVkDepthBiasSlopeFactor #-} + writeVkDepthBiasSlopeFactor p + = pokeByteOff p #{offset VkPipelineRasterizationStateCreateInfo, depthBiasSlopeFactor} + +instance {-# OVERLAPPING #-} + HasField "depthBiasSlopeFactor" + VkPipelineRasterizationStateCreateInfo + where + type FieldType "depthBiasSlopeFactor" + VkPipelineRasterizationStateCreateInfo + = #{type float} + type FieldOptional "depthBiasSlopeFactor" + VkPipelineRasterizationStateCreateInfo + = 'False -- ' closing tick for hsc2hs + type FieldOffset "depthBiasSlopeFactor" + VkPipelineRasterizationStateCreateInfo + = + #{offset VkPipelineRasterizationStateCreateInfo, depthBiasSlopeFactor} + type FieldIsArray "depthBiasSlopeFactor" + VkPipelineRasterizationStateCreateInfo + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineRasterizationStateCreateInfo, depthBiasSlopeFactor} + +instance CanReadField "depthBiasSlopeFactor" + VkPipelineRasterizationStateCreateInfo + where + {-# INLINE getField #-} + getField = vkDepthBiasSlopeFactor + + {-# INLINE readField #-} + readField = readVkDepthBiasSlopeFactor + +instance CanWriteField "depthBiasSlopeFactor" + VkPipelineRasterizationStateCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkDepthBiasSlopeFactor + +instance {-# OVERLAPPING #-} + HasVkLineWidth VkPipelineRasterizationStateCreateInfo where + type VkLineWidthMType VkPipelineRasterizationStateCreateInfo = + #{type float} + + {-# NOINLINE vkLineWidth #-} + vkLineWidth x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineRasterizationStateCreateInfo, lineWidth}) + + {-# INLINE vkLineWidthByteOffset #-} + vkLineWidthByteOffset ~_ + = #{offset VkPipelineRasterizationStateCreateInfo, lineWidth} + + {-# INLINE readVkLineWidth #-} + readVkLineWidth p + = peekByteOff p #{offset VkPipelineRasterizationStateCreateInfo, lineWidth} + + {-# INLINE writeVkLineWidth #-} + writeVkLineWidth p + = pokeByteOff p #{offset VkPipelineRasterizationStateCreateInfo, lineWidth} + +instance {-# OVERLAPPING #-} + HasField "lineWidth" VkPipelineRasterizationStateCreateInfo where + type FieldType "lineWidth" VkPipelineRasterizationStateCreateInfo = + #{type float} + type FieldOptional "lineWidth" + VkPipelineRasterizationStateCreateInfo + = 'False -- ' closing tick for hsc2hs + type FieldOffset "lineWidth" VkPipelineRasterizationStateCreateInfo + = + #{offset VkPipelineRasterizationStateCreateInfo, lineWidth} + type FieldIsArray "lineWidth" + VkPipelineRasterizationStateCreateInfo + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineRasterizationStateCreateInfo, lineWidth} + +instance CanReadField "lineWidth" + VkPipelineRasterizationStateCreateInfo + where + {-# INLINE getField #-} + getField = vkLineWidth + + {-# INLINE readField #-} + readField = readVkLineWidth + +instance CanWriteField "lineWidth" + VkPipelineRasterizationStateCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkLineWidth + +instance Show VkPipelineRasterizationStateCreateInfo where + showsPrec d x + = showString "VkPipelineRasterizationStateCreateInfo {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkFlags = " . + showsPrec d (vkFlags x) . + showString ", " . + showString "vkDepthClampEnable = " . + showsPrec d (vkDepthClampEnable x) . + showString ", " . + showString "vkRasterizerDiscardEnable = " . + showsPrec d (vkRasterizerDiscardEnable x) . + showString ", " . + showString "vkPolygonMode = " . + showsPrec d (vkPolygonMode x) . + showString ", " . + showString "vkCullMode = " . + showsPrec d (vkCullMode x) . + showString ", " . + showString "vkFrontFace = " . + showsPrec d (vkFrontFace x) . + showString ", " . + showString "vkDepthBiasEnable = " . + showsPrec d (vkDepthBiasEnable x) . + showString ", " . + showString + "vkDepthBiasConstantFactor = " + . + showsPrec d + (vkDepthBiasConstantFactor + x) + . + showString ", " . + showString + "vkDepthBiasClamp = " + . + showsPrec d + (vkDepthBiasClamp x) + . + showString ", " . + showString + "vkDepthBiasSlopeFactor = " + . + showsPrec d + (vkDepthBiasSlopeFactor + x) + . + showString ", " + . + showString + "vkLineWidth = " + . + showsPrec d + (vkLineWidth + x) + . + showChar + '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkPipelineRasterizationStateRasterizationOrderAMD.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkPipelineRasterizationStateRasterizationOrderAMD.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkPipelineRasterizationStateRasterizationOrderAMD.hsc @@ -0,0 +1,298 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkPipelineRasterizationStateRasterizationOrderAMD + (VkPipelineRasterizationStateRasterizationOrderAMD(..)) where +import Foreign.Storable + (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkRasterizationOrderAMD + (VkRasterizationOrderAMD) +import Graphics.Vulkan.Types.Enum.VkStructureType + (VkStructureType) +import Graphics.Vulkan.Types.Struct.VkPipelineRasterizationStateCreateInfo + (VkPipelineRasterizationStateCreateInfo) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe + (unsafeDupablePerformIO) + +-- | > typedef struct VkPipelineRasterizationStateRasterizationOrderAMD { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkRasterizationOrderAMD rasterizationOrder; +-- > } VkPipelineRasterizationStateRasterizationOrderAMD; +-- +-- +data VkPipelineRasterizationStateRasterizationOrderAMD = VkPipelineRasterizationStateRasterizationOrderAMD## Addr## + ByteArray## + +instance Eq VkPipelineRasterizationStateRasterizationOrderAMD where + (VkPipelineRasterizationStateRasterizationOrderAMD## a _) == + x@(VkPipelineRasterizationStateRasterizationOrderAMD## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkPipelineRasterizationStateRasterizationOrderAMD + where + (VkPipelineRasterizationStateRasterizationOrderAMD## a _) `compare` + x@(VkPipelineRasterizationStateRasterizationOrderAMD## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkPipelineRasterizationStateRasterizationOrderAMD + where + sizeOf ~_ + = #{size VkPipelineRasterizationStateRasterizationOrderAMD} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkPipelineRasterizationStateRasterizationOrderAMD} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim + VkPipelineRasterizationStateRasterizationOrderAMD + where + unsafeAddr (VkPipelineRasterizationStateRasterizationOrderAMD## a _) + = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray + (VkPipelineRasterizationStateRasterizationOrderAMD## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkPipelineRasterizationStateRasterizationOrderAMD## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal + VkPipelineRasterizationStateRasterizationOrderAMD + where + type StructFields VkPipelineRasterizationStateRasterizationOrderAMD + = '["sType", "pNext", "rasterizationOrder"] -- ' closing tick for hsc2hs + type CUnionType VkPipelineRasterizationStateRasterizationOrderAMD = + 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkPipelineRasterizationStateRasterizationOrderAMD + = 'False -- ' closing tick for hsc2hs + type StructExtends + VkPipelineRasterizationStateRasterizationOrderAMD + = '[VkPipelineRasterizationStateCreateInfo] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkPipelineRasterizationStateRasterizationOrderAMD where + type VkSTypeMType VkPipelineRasterizationStateRasterizationOrderAMD + = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineRasterizationStateRasterizationOrderAMD, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkPipelineRasterizationStateRasterizationOrderAMD, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkPipelineRasterizationStateRasterizationOrderAMD, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkPipelineRasterizationStateRasterizationOrderAMD, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkPipelineRasterizationStateRasterizationOrderAMD + where + type FieldType "sType" + VkPipelineRasterizationStateRasterizationOrderAMD + = VkStructureType + type FieldOptional "sType" + VkPipelineRasterizationStateRasterizationOrderAMD + = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" + VkPipelineRasterizationStateRasterizationOrderAMD + = + #{offset VkPipelineRasterizationStateRasterizationOrderAMD, sType} + type FieldIsArray "sType" + VkPipelineRasterizationStateRasterizationOrderAMD + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineRasterizationStateRasterizationOrderAMD, sType} + +instance CanReadField "sType" + VkPipelineRasterizationStateRasterizationOrderAMD + where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" + VkPipelineRasterizationStateRasterizationOrderAMD + where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkPipelineRasterizationStateRasterizationOrderAMD where + type VkPNextMType VkPipelineRasterizationStateRasterizationOrderAMD + = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineRasterizationStateRasterizationOrderAMD, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkPipelineRasterizationStateRasterizationOrderAMD, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkPipelineRasterizationStateRasterizationOrderAMD, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkPipelineRasterizationStateRasterizationOrderAMD, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkPipelineRasterizationStateRasterizationOrderAMD + where + type FieldType "pNext" + VkPipelineRasterizationStateRasterizationOrderAMD + = Ptr Void + type FieldOptional "pNext" + VkPipelineRasterizationStateRasterizationOrderAMD + = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" + VkPipelineRasterizationStateRasterizationOrderAMD + = + #{offset VkPipelineRasterizationStateRasterizationOrderAMD, pNext} + type FieldIsArray "pNext" + VkPipelineRasterizationStateRasterizationOrderAMD + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineRasterizationStateRasterizationOrderAMD, pNext} + +instance CanReadField "pNext" + VkPipelineRasterizationStateRasterizationOrderAMD + where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" + VkPipelineRasterizationStateRasterizationOrderAMD + where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkRasterizationOrder + VkPipelineRasterizationStateRasterizationOrderAMD + where + type VkRasterizationOrderMType + VkPipelineRasterizationStateRasterizationOrderAMD + = VkRasterizationOrderAMD + + {-# NOINLINE vkRasterizationOrder #-} + vkRasterizationOrder x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineRasterizationStateRasterizationOrderAMD, rasterizationOrder}) + + {-# INLINE vkRasterizationOrderByteOffset #-} + vkRasterizationOrderByteOffset ~_ + = #{offset VkPipelineRasterizationStateRasterizationOrderAMD, rasterizationOrder} + + {-# INLINE readVkRasterizationOrder #-} + readVkRasterizationOrder p + = peekByteOff p #{offset VkPipelineRasterizationStateRasterizationOrderAMD, rasterizationOrder} + + {-# INLINE writeVkRasterizationOrder #-} + writeVkRasterizationOrder p + = pokeByteOff p #{offset VkPipelineRasterizationStateRasterizationOrderAMD, rasterizationOrder} + +instance {-# OVERLAPPING #-} + HasField "rasterizationOrder" + VkPipelineRasterizationStateRasterizationOrderAMD + where + type FieldType "rasterizationOrder" + VkPipelineRasterizationStateRasterizationOrderAMD + = VkRasterizationOrderAMD + type FieldOptional "rasterizationOrder" + VkPipelineRasterizationStateRasterizationOrderAMD + = 'False -- ' closing tick for hsc2hs + type FieldOffset "rasterizationOrder" + VkPipelineRasterizationStateRasterizationOrderAMD + = + #{offset VkPipelineRasterizationStateRasterizationOrderAMD, rasterizationOrder} + type FieldIsArray "rasterizationOrder" + VkPipelineRasterizationStateRasterizationOrderAMD + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineRasterizationStateRasterizationOrderAMD, rasterizationOrder} + +instance CanReadField "rasterizationOrder" + VkPipelineRasterizationStateRasterizationOrderAMD + where + {-# INLINE getField #-} + getField = vkRasterizationOrder + + {-# INLINE readField #-} + readField = readVkRasterizationOrder + +instance CanWriteField "rasterizationOrder" + VkPipelineRasterizationStateRasterizationOrderAMD + where + {-# INLINE writeField #-} + writeField = writeVkRasterizationOrder + +instance Show VkPipelineRasterizationStateRasterizationOrderAMD + where + showsPrec d x + = showString "VkPipelineRasterizationStateRasterizationOrderAMD {" + . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkRasterizationOrder = " . + showsPrec d (vkRasterizationOrder x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkPipelineSampleLocationsStateCreateInfoEXT.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkPipelineSampleLocationsStateCreateInfoEXT.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkPipelineSampleLocationsStateCreateInfoEXT.hsc @@ -0,0 +1,358 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkPipelineSampleLocationsStateCreateInfoEXT + (VkPipelineSampleLocationsStateCreateInfoEXT(..)) where +import Foreign.Storable + (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.BaseTypes + (VkBool32) +import Graphics.Vulkan.Types.Enum.VkStructureType + (VkStructureType) +import Graphics.Vulkan.Types.Struct.VkPipelineMultisampleStateCreateInfo + (VkPipelineMultisampleStateCreateInfo) +import Graphics.Vulkan.Types.Struct.VkSampleLocationsInfoEXT + (VkSampleLocationsInfoEXT) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe + (unsafeDupablePerformIO) + +-- | > typedef struct VkPipelineSampleLocationsStateCreateInfoEXT { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkBool32 sampleLocationsEnable; +-- > VkSampleLocationsInfoEXT sampleLocationsInfo; +-- > } VkPipelineSampleLocationsStateCreateInfoEXT; +-- +-- +data VkPipelineSampleLocationsStateCreateInfoEXT = VkPipelineSampleLocationsStateCreateInfoEXT## Addr## + ByteArray## + +instance Eq VkPipelineSampleLocationsStateCreateInfoEXT where + (VkPipelineSampleLocationsStateCreateInfoEXT## a _) == + x@(VkPipelineSampleLocationsStateCreateInfoEXT## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkPipelineSampleLocationsStateCreateInfoEXT where + (VkPipelineSampleLocationsStateCreateInfoEXT## a _) `compare` + x@(VkPipelineSampleLocationsStateCreateInfoEXT## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkPipelineSampleLocationsStateCreateInfoEXT where + sizeOf ~_ + = #{size VkPipelineSampleLocationsStateCreateInfoEXT} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkPipelineSampleLocationsStateCreateInfoEXT} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim + VkPipelineSampleLocationsStateCreateInfoEXT + where + unsafeAddr (VkPipelineSampleLocationsStateCreateInfoEXT## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkPipelineSampleLocationsStateCreateInfoEXT## _ b) + = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkPipelineSampleLocationsStateCreateInfoEXT## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkPipelineSampleLocationsStateCreateInfoEXT + where + type StructFields VkPipelineSampleLocationsStateCreateInfoEXT = + '["sType", "pNext", "sampleLocationsEnable", "sampleLocationsInfo"] -- ' closing tick for hsc2hs + type CUnionType VkPipelineSampleLocationsStateCreateInfoEXT = + 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkPipelineSampleLocationsStateCreateInfoEXT = + 'False -- ' closing tick for hsc2hs + type StructExtends VkPipelineSampleLocationsStateCreateInfoEXT = + '[VkPipelineMultisampleStateCreateInfo] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkPipelineSampleLocationsStateCreateInfoEXT where + type VkSTypeMType VkPipelineSampleLocationsStateCreateInfoEXT = + VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineSampleLocationsStateCreateInfoEXT, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkPipelineSampleLocationsStateCreateInfoEXT, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkPipelineSampleLocationsStateCreateInfoEXT, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkPipelineSampleLocationsStateCreateInfoEXT, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkPipelineSampleLocationsStateCreateInfoEXT where + type FieldType "sType" VkPipelineSampleLocationsStateCreateInfoEXT + = VkStructureType + type FieldOptional "sType" + VkPipelineSampleLocationsStateCreateInfoEXT + = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" + VkPipelineSampleLocationsStateCreateInfoEXT + = + #{offset VkPipelineSampleLocationsStateCreateInfoEXT, sType} + type FieldIsArray "sType" + VkPipelineSampleLocationsStateCreateInfoEXT + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineSampleLocationsStateCreateInfoEXT, sType} + +instance CanReadField "sType" + VkPipelineSampleLocationsStateCreateInfoEXT + where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" + VkPipelineSampleLocationsStateCreateInfoEXT + where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkPipelineSampleLocationsStateCreateInfoEXT where + type VkPNextMType VkPipelineSampleLocationsStateCreateInfoEXT = + Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineSampleLocationsStateCreateInfoEXT, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkPipelineSampleLocationsStateCreateInfoEXT, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkPipelineSampleLocationsStateCreateInfoEXT, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkPipelineSampleLocationsStateCreateInfoEXT, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkPipelineSampleLocationsStateCreateInfoEXT where + type FieldType "pNext" VkPipelineSampleLocationsStateCreateInfoEXT + = Ptr Void + type FieldOptional "pNext" + VkPipelineSampleLocationsStateCreateInfoEXT + = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" + VkPipelineSampleLocationsStateCreateInfoEXT + = + #{offset VkPipelineSampleLocationsStateCreateInfoEXT, pNext} + type FieldIsArray "pNext" + VkPipelineSampleLocationsStateCreateInfoEXT + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineSampleLocationsStateCreateInfoEXT, pNext} + +instance CanReadField "pNext" + VkPipelineSampleLocationsStateCreateInfoEXT + where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" + VkPipelineSampleLocationsStateCreateInfoEXT + where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkSampleLocationsEnable + VkPipelineSampleLocationsStateCreateInfoEXT + where + type VkSampleLocationsEnableMType + VkPipelineSampleLocationsStateCreateInfoEXT + = VkBool32 + + {-# NOINLINE vkSampleLocationsEnable #-} + vkSampleLocationsEnable x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineSampleLocationsStateCreateInfoEXT, sampleLocationsEnable}) + + {-# INLINE vkSampleLocationsEnableByteOffset #-} + vkSampleLocationsEnableByteOffset ~_ + = #{offset VkPipelineSampleLocationsStateCreateInfoEXT, sampleLocationsEnable} + + {-# INLINE readVkSampleLocationsEnable #-} + readVkSampleLocationsEnable p + = peekByteOff p #{offset VkPipelineSampleLocationsStateCreateInfoEXT, sampleLocationsEnable} + + {-# INLINE writeVkSampleLocationsEnable #-} + writeVkSampleLocationsEnable p + = pokeByteOff p #{offset VkPipelineSampleLocationsStateCreateInfoEXT, sampleLocationsEnable} + +instance {-# OVERLAPPING #-} + HasField "sampleLocationsEnable" + VkPipelineSampleLocationsStateCreateInfoEXT + where + type FieldType "sampleLocationsEnable" + VkPipelineSampleLocationsStateCreateInfoEXT + = VkBool32 + type FieldOptional "sampleLocationsEnable" + VkPipelineSampleLocationsStateCreateInfoEXT + = 'False -- ' closing tick for hsc2hs + type FieldOffset "sampleLocationsEnable" + VkPipelineSampleLocationsStateCreateInfoEXT + = + #{offset VkPipelineSampleLocationsStateCreateInfoEXT, sampleLocationsEnable} + type FieldIsArray "sampleLocationsEnable" + VkPipelineSampleLocationsStateCreateInfoEXT + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineSampleLocationsStateCreateInfoEXT, sampleLocationsEnable} + +instance CanReadField "sampleLocationsEnable" + VkPipelineSampleLocationsStateCreateInfoEXT + where + {-# INLINE getField #-} + getField = vkSampleLocationsEnable + + {-# INLINE readField #-} + readField = readVkSampleLocationsEnable + +instance CanWriteField "sampleLocationsEnable" + VkPipelineSampleLocationsStateCreateInfoEXT + where + {-# INLINE writeField #-} + writeField = writeVkSampleLocationsEnable + +instance {-# OVERLAPPING #-} + HasVkSampleLocationsInfo + VkPipelineSampleLocationsStateCreateInfoEXT + where + type VkSampleLocationsInfoMType + VkPipelineSampleLocationsStateCreateInfoEXT + = VkSampleLocationsInfoEXT + + {-# NOINLINE vkSampleLocationsInfo #-} + vkSampleLocationsInfo x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineSampleLocationsStateCreateInfoEXT, sampleLocationsInfo}) + + {-# INLINE vkSampleLocationsInfoByteOffset #-} + vkSampleLocationsInfoByteOffset ~_ + = #{offset VkPipelineSampleLocationsStateCreateInfoEXT, sampleLocationsInfo} + + {-# INLINE readVkSampleLocationsInfo #-} + readVkSampleLocationsInfo p + = peekByteOff p #{offset VkPipelineSampleLocationsStateCreateInfoEXT, sampleLocationsInfo} + + {-# INLINE writeVkSampleLocationsInfo #-} + writeVkSampleLocationsInfo p + = pokeByteOff p #{offset VkPipelineSampleLocationsStateCreateInfoEXT, sampleLocationsInfo} + +instance {-# OVERLAPPING #-} + HasField "sampleLocationsInfo" + VkPipelineSampleLocationsStateCreateInfoEXT + where + type FieldType "sampleLocationsInfo" + VkPipelineSampleLocationsStateCreateInfoEXT + = VkSampleLocationsInfoEXT + type FieldOptional "sampleLocationsInfo" + VkPipelineSampleLocationsStateCreateInfoEXT + = 'False -- ' closing tick for hsc2hs + type FieldOffset "sampleLocationsInfo" + VkPipelineSampleLocationsStateCreateInfoEXT + = + #{offset VkPipelineSampleLocationsStateCreateInfoEXT, sampleLocationsInfo} + type FieldIsArray "sampleLocationsInfo" + VkPipelineSampleLocationsStateCreateInfoEXT + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineSampleLocationsStateCreateInfoEXT, sampleLocationsInfo} + +instance CanReadField "sampleLocationsInfo" + VkPipelineSampleLocationsStateCreateInfoEXT + where + {-# INLINE getField #-} + getField = vkSampleLocationsInfo + + {-# INLINE readField #-} + readField = readVkSampleLocationsInfo + +instance CanWriteField "sampleLocationsInfo" + VkPipelineSampleLocationsStateCreateInfoEXT + where + {-# INLINE writeField #-} + writeField = writeVkSampleLocationsInfo + +instance Show VkPipelineSampleLocationsStateCreateInfoEXT where + showsPrec d x + = showString "VkPipelineSampleLocationsStateCreateInfoEXT {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkSampleLocationsEnable = " . + showsPrec d (vkSampleLocationsEnable x) . + showString ", " . + showString "vkSampleLocationsInfo = " . + showsPrec d (vkSampleLocationsInfo x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkPipelineShaderStageCreateInfo.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkPipelineShaderStageCreateInfo.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkPipelineShaderStageCreateInfo.hsc @@ -0,0 +1,467 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkPipelineShaderStageCreateInfo + (VkPipelineShaderStageCreateInfo(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Bitmasks (VkPipelineShaderStageCreateFlags) +import Graphics.Vulkan.Types.Enum.VkShaderStageFlags (VkShaderStageFlagBits) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Handles (VkShaderModule) +import Graphics.Vulkan.Types.Struct.VkSpecializationInfo (VkSpecializationInfo) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkPipelineShaderStageCreateInfo { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkPipelineShaderStageCreateFlags flags; +-- > VkShaderStageFlagBits stage; +-- > VkShaderModule module; +-- > const char* pName; +-- > const VkSpecializationInfo* pSpecializationInfo; +-- > } VkPipelineShaderStageCreateInfo; +-- +-- +data VkPipelineShaderStageCreateInfo = VkPipelineShaderStageCreateInfo## Addr## + ByteArray## + +instance Eq VkPipelineShaderStageCreateInfo where + (VkPipelineShaderStageCreateInfo## a _) == + x@(VkPipelineShaderStageCreateInfo## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkPipelineShaderStageCreateInfo where + (VkPipelineShaderStageCreateInfo## a _) `compare` + x@(VkPipelineShaderStageCreateInfo## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkPipelineShaderStageCreateInfo where + sizeOf ~_ = #{size VkPipelineShaderStageCreateInfo} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkPipelineShaderStageCreateInfo} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkPipelineShaderStageCreateInfo where + unsafeAddr (VkPipelineShaderStageCreateInfo## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkPipelineShaderStageCreateInfo## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkPipelineShaderStageCreateInfo## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkPipelineShaderStageCreateInfo where + type StructFields VkPipelineShaderStageCreateInfo = + '["sType", "pNext", "flags", "stage", "module", "pName", -- ' closing tick for hsc2hs + "pSpecializationInfo"] + type CUnionType VkPipelineShaderStageCreateInfo = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkPipelineShaderStageCreateInfo = 'False -- ' closing tick for hsc2hs + type StructExtends VkPipelineShaderStageCreateInfo = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkPipelineShaderStageCreateInfo where + type VkSTypeMType VkPipelineShaderStageCreateInfo = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineShaderStageCreateInfo, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkPipelineShaderStageCreateInfo, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkPipelineShaderStageCreateInfo, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkPipelineShaderStageCreateInfo, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkPipelineShaderStageCreateInfo where + type FieldType "sType" VkPipelineShaderStageCreateInfo = + VkStructureType + type FieldOptional "sType" VkPipelineShaderStageCreateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkPipelineShaderStageCreateInfo = + #{offset VkPipelineShaderStageCreateInfo, sType} + type FieldIsArray "sType" VkPipelineShaderStageCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineShaderStageCreateInfo, sType} + +instance CanReadField "sType" VkPipelineShaderStageCreateInfo where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkPipelineShaderStageCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkPipelineShaderStageCreateInfo where + type VkPNextMType VkPipelineShaderStageCreateInfo = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineShaderStageCreateInfo, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkPipelineShaderStageCreateInfo, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkPipelineShaderStageCreateInfo, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkPipelineShaderStageCreateInfo, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkPipelineShaderStageCreateInfo where + type FieldType "pNext" VkPipelineShaderStageCreateInfo = Ptr Void + type FieldOptional "pNext" VkPipelineShaderStageCreateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkPipelineShaderStageCreateInfo = + #{offset VkPipelineShaderStageCreateInfo, pNext} + type FieldIsArray "pNext" VkPipelineShaderStageCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineShaderStageCreateInfo, pNext} + +instance CanReadField "pNext" VkPipelineShaderStageCreateInfo where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkPipelineShaderStageCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkFlags VkPipelineShaderStageCreateInfo where + type VkFlagsMType VkPipelineShaderStageCreateInfo = + VkPipelineShaderStageCreateFlags + + {-# NOINLINE vkFlags #-} + vkFlags x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineShaderStageCreateInfo, flags}) + + {-# INLINE vkFlagsByteOffset #-} + vkFlagsByteOffset ~_ + = #{offset VkPipelineShaderStageCreateInfo, flags} + + {-# INLINE readVkFlags #-} + readVkFlags p + = peekByteOff p #{offset VkPipelineShaderStageCreateInfo, flags} + + {-# INLINE writeVkFlags #-} + writeVkFlags p + = pokeByteOff p #{offset VkPipelineShaderStageCreateInfo, flags} + +instance {-# OVERLAPPING #-} + HasField "flags" VkPipelineShaderStageCreateInfo where + type FieldType "flags" VkPipelineShaderStageCreateInfo = + VkPipelineShaderStageCreateFlags + type FieldOptional "flags" VkPipelineShaderStageCreateInfo = 'True -- ' closing tick for hsc2hs + type FieldOffset "flags" VkPipelineShaderStageCreateInfo = + #{offset VkPipelineShaderStageCreateInfo, flags} + type FieldIsArray "flags" VkPipelineShaderStageCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineShaderStageCreateInfo, flags} + +instance CanReadField "flags" VkPipelineShaderStageCreateInfo where + {-# INLINE getField #-} + getField = vkFlags + + {-# INLINE readField #-} + readField = readVkFlags + +instance CanWriteField "flags" VkPipelineShaderStageCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkFlags + +instance {-# OVERLAPPING #-} + HasVkStage VkPipelineShaderStageCreateInfo where + type VkStageMType VkPipelineShaderStageCreateInfo = + VkShaderStageFlagBits + + {-# NOINLINE vkStage #-} + vkStage x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineShaderStageCreateInfo, stage}) + + {-# INLINE vkStageByteOffset #-} + vkStageByteOffset ~_ + = #{offset VkPipelineShaderStageCreateInfo, stage} + + {-# INLINE readVkStage #-} + readVkStage p + = peekByteOff p #{offset VkPipelineShaderStageCreateInfo, stage} + + {-# INLINE writeVkStage #-} + writeVkStage p + = pokeByteOff p #{offset VkPipelineShaderStageCreateInfo, stage} + +instance {-# OVERLAPPING #-} + HasField "stage" VkPipelineShaderStageCreateInfo where + type FieldType "stage" VkPipelineShaderStageCreateInfo = + VkShaderStageFlagBits + type FieldOptional "stage" VkPipelineShaderStageCreateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "stage" VkPipelineShaderStageCreateInfo = + #{offset VkPipelineShaderStageCreateInfo, stage} + type FieldIsArray "stage" VkPipelineShaderStageCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineShaderStageCreateInfo, stage} + +instance CanReadField "stage" VkPipelineShaderStageCreateInfo where + {-# INLINE getField #-} + getField = vkStage + + {-# INLINE readField #-} + readField = readVkStage + +instance CanWriteField "stage" VkPipelineShaderStageCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkStage + +instance {-# OVERLAPPING #-} + HasVkModule VkPipelineShaderStageCreateInfo where + type VkModuleMType VkPipelineShaderStageCreateInfo = VkShaderModule + + {-# NOINLINE vkModule #-} + vkModule x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineShaderStageCreateInfo, module}) + + {-# INLINE vkModuleByteOffset #-} + vkModuleByteOffset ~_ + = #{offset VkPipelineShaderStageCreateInfo, module} + + {-# INLINE readVkModule #-} + readVkModule p + = peekByteOff p #{offset VkPipelineShaderStageCreateInfo, module} + + {-# INLINE writeVkModule #-} + writeVkModule p + = pokeByteOff p #{offset VkPipelineShaderStageCreateInfo, module} + +instance {-# OVERLAPPING #-} + HasField "module" VkPipelineShaderStageCreateInfo where + type FieldType "module" VkPipelineShaderStageCreateInfo = + VkShaderModule + type FieldOptional "module" VkPipelineShaderStageCreateInfo = + 'False -- ' closing tick for hsc2hs + type FieldOffset "module" VkPipelineShaderStageCreateInfo = + #{offset VkPipelineShaderStageCreateInfo, module} + type FieldIsArray "module" VkPipelineShaderStageCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineShaderStageCreateInfo, module} + +instance CanReadField "module" VkPipelineShaderStageCreateInfo + where + {-# INLINE getField #-} + getField = vkModule + + {-# INLINE readField #-} + readField = readVkModule + +instance CanWriteField "module" VkPipelineShaderStageCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkModule + +instance {-# OVERLAPPING #-} + HasVkPName VkPipelineShaderStageCreateInfo where + type VkPNameMType VkPipelineShaderStageCreateInfo = CString + + {-# NOINLINE vkPName #-} + vkPName x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineShaderStageCreateInfo, pName}) + + {-# INLINE vkPNameByteOffset #-} + vkPNameByteOffset ~_ + = #{offset VkPipelineShaderStageCreateInfo, pName} + + {-# INLINE readVkPName #-} + readVkPName p + = peekByteOff p #{offset VkPipelineShaderStageCreateInfo, pName} + + {-# INLINE writeVkPName #-} + writeVkPName p + = pokeByteOff p #{offset VkPipelineShaderStageCreateInfo, pName} + +instance {-# OVERLAPPING #-} + HasField "pName" VkPipelineShaderStageCreateInfo where + type FieldType "pName" VkPipelineShaderStageCreateInfo = CString + type FieldOptional "pName" VkPipelineShaderStageCreateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "pName" VkPipelineShaderStageCreateInfo = + #{offset VkPipelineShaderStageCreateInfo, pName} + type FieldIsArray "pName" VkPipelineShaderStageCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineShaderStageCreateInfo, pName} + +instance CanReadField "pName" VkPipelineShaderStageCreateInfo where + {-# INLINE getField #-} + getField = vkPName + + {-# INLINE readField #-} + readField = readVkPName + +instance CanWriteField "pName" VkPipelineShaderStageCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkPName + +instance {-# OVERLAPPING #-} + HasVkPSpecializationInfo VkPipelineShaderStageCreateInfo where + type VkPSpecializationInfoMType VkPipelineShaderStageCreateInfo = + Ptr VkSpecializationInfo + + {-# NOINLINE vkPSpecializationInfo #-} + vkPSpecializationInfo x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineShaderStageCreateInfo, pSpecializationInfo}) + + {-# INLINE vkPSpecializationInfoByteOffset #-} + vkPSpecializationInfoByteOffset ~_ + = #{offset VkPipelineShaderStageCreateInfo, pSpecializationInfo} + + {-# INLINE readVkPSpecializationInfo #-} + readVkPSpecializationInfo p + = peekByteOff p #{offset VkPipelineShaderStageCreateInfo, pSpecializationInfo} + + {-# INLINE writeVkPSpecializationInfo #-} + writeVkPSpecializationInfo p + = pokeByteOff p #{offset VkPipelineShaderStageCreateInfo, pSpecializationInfo} + +instance {-# OVERLAPPING #-} + HasField "pSpecializationInfo" VkPipelineShaderStageCreateInfo + where + type FieldType "pSpecializationInfo" + VkPipelineShaderStageCreateInfo + = Ptr VkSpecializationInfo + type FieldOptional "pSpecializationInfo" + VkPipelineShaderStageCreateInfo + = 'True -- ' closing tick for hsc2hs + type FieldOffset "pSpecializationInfo" + VkPipelineShaderStageCreateInfo + = + #{offset VkPipelineShaderStageCreateInfo, pSpecializationInfo} + type FieldIsArray "pSpecializationInfo" + VkPipelineShaderStageCreateInfo + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineShaderStageCreateInfo, pSpecializationInfo} + +instance CanReadField "pSpecializationInfo" + VkPipelineShaderStageCreateInfo + where + {-# INLINE getField #-} + getField = vkPSpecializationInfo + + {-# INLINE readField #-} + readField = readVkPSpecializationInfo + +instance CanWriteField "pSpecializationInfo" + VkPipelineShaderStageCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkPSpecializationInfo + +instance Show VkPipelineShaderStageCreateInfo where + showsPrec d x + = showString "VkPipelineShaderStageCreateInfo {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkFlags = " . + showsPrec d (vkFlags x) . + showString ", " . + showString "vkStage = " . + showsPrec d (vkStage x) . + showString ", " . + showString "vkModule = " . + showsPrec d (vkModule x) . + showString ", " . + showString "vkPName = " . + showsPrec d (vkPName x) . + showString ", " . + showString "vkPSpecializationInfo = " . + showsPrec d (vkPSpecializationInfo x) . + showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkPipelineTessellationDomainOriginStateCreateInfoKHR.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkPipelineTessellationDomainOriginStateCreateInfoKHR.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkPipelineTessellationDomainOriginStateCreateInfoKHR.hsc @@ -0,0 +1,311 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkPipelineTessellationDomainOriginStateCreateInfoKHR + (VkPipelineTessellationDomainOriginStateCreateInfoKHR(..)) where +import Foreign.Storable + (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkStructureType + (VkStructureType) +import Graphics.Vulkan.Types.Enum.VkTessellationDomainOriginKHR + (VkTessellationDomainOriginKHR) +import Graphics.Vulkan.Types.Struct.VkPipelineTessellationStateCreateInfo + (VkPipelineTessellationStateCreateInfo) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe + (unsafeDupablePerformIO) + +-- | > typedef struct VkPipelineTessellationDomainOriginStateCreateInfoKHR { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkTessellationDomainOriginKHR domainOrigin; +-- > } VkPipelineTessellationDomainOriginStateCreateInfoKHR; +-- +-- +data VkPipelineTessellationDomainOriginStateCreateInfoKHR = VkPipelineTessellationDomainOriginStateCreateInfoKHR## Addr## + ByteArray## + +instance Eq VkPipelineTessellationDomainOriginStateCreateInfoKHR + where + (VkPipelineTessellationDomainOriginStateCreateInfoKHR## a _) == + x@(VkPipelineTessellationDomainOriginStateCreateInfoKHR## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkPipelineTessellationDomainOriginStateCreateInfoKHR + where + (VkPipelineTessellationDomainOriginStateCreateInfoKHR## a _) + `compare` + x@(VkPipelineTessellationDomainOriginStateCreateInfoKHR## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable + VkPipelineTessellationDomainOriginStateCreateInfoKHR + where + sizeOf ~_ + = #{size VkPipelineTessellationDomainOriginStateCreateInfoKHR} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkPipelineTessellationDomainOriginStateCreateInfoKHR} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim + VkPipelineTessellationDomainOriginStateCreateInfoKHR + where + unsafeAddr + (VkPipelineTessellationDomainOriginStateCreateInfoKHR## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray + (VkPipelineTessellationDomainOriginStateCreateInfoKHR## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkPipelineTessellationDomainOriginStateCreateInfoKHR## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal + VkPipelineTessellationDomainOriginStateCreateInfoKHR + where + type StructFields + VkPipelineTessellationDomainOriginStateCreateInfoKHR + = '["sType", "pNext", "domainOrigin"] -- ' closing tick for hsc2hs + type CUnionType + VkPipelineTessellationDomainOriginStateCreateInfoKHR + = 'False -- ' closing tick for hsc2hs + type ReturnedOnly + VkPipelineTessellationDomainOriginStateCreateInfoKHR + = 'False -- ' closing tick for hsc2hs + type StructExtends + VkPipelineTessellationDomainOriginStateCreateInfoKHR + = '[VkPipelineTessellationStateCreateInfo] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkPipelineTessellationDomainOriginStateCreateInfoKHR + where + type VkSTypeMType + VkPipelineTessellationDomainOriginStateCreateInfoKHR + = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineTessellationDomainOriginStateCreateInfoKHR, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkPipelineTessellationDomainOriginStateCreateInfoKHR, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkPipelineTessellationDomainOriginStateCreateInfoKHR, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkPipelineTessellationDomainOriginStateCreateInfoKHR, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" + VkPipelineTessellationDomainOriginStateCreateInfoKHR + where + type FieldType "sType" + VkPipelineTessellationDomainOriginStateCreateInfoKHR + = VkStructureType + type FieldOptional "sType" + VkPipelineTessellationDomainOriginStateCreateInfoKHR + = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" + VkPipelineTessellationDomainOriginStateCreateInfoKHR + = + #{offset VkPipelineTessellationDomainOriginStateCreateInfoKHR, sType} + type FieldIsArray "sType" + VkPipelineTessellationDomainOriginStateCreateInfoKHR + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineTessellationDomainOriginStateCreateInfoKHR, sType} + +instance CanReadField "sType" + VkPipelineTessellationDomainOriginStateCreateInfoKHR + where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" + VkPipelineTessellationDomainOriginStateCreateInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkPipelineTessellationDomainOriginStateCreateInfoKHR + where + type VkPNextMType + VkPipelineTessellationDomainOriginStateCreateInfoKHR + = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineTessellationDomainOriginStateCreateInfoKHR, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkPipelineTessellationDomainOriginStateCreateInfoKHR, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkPipelineTessellationDomainOriginStateCreateInfoKHR, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkPipelineTessellationDomainOriginStateCreateInfoKHR, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" + VkPipelineTessellationDomainOriginStateCreateInfoKHR + where + type FieldType "pNext" + VkPipelineTessellationDomainOriginStateCreateInfoKHR + = Ptr Void + type FieldOptional "pNext" + VkPipelineTessellationDomainOriginStateCreateInfoKHR + = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" + VkPipelineTessellationDomainOriginStateCreateInfoKHR + = + #{offset VkPipelineTessellationDomainOriginStateCreateInfoKHR, pNext} + type FieldIsArray "pNext" + VkPipelineTessellationDomainOriginStateCreateInfoKHR + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineTessellationDomainOriginStateCreateInfoKHR, pNext} + +instance CanReadField "pNext" + VkPipelineTessellationDomainOriginStateCreateInfoKHR + where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" + VkPipelineTessellationDomainOriginStateCreateInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkDomainOrigin + VkPipelineTessellationDomainOriginStateCreateInfoKHR + where + type VkDomainOriginMType + VkPipelineTessellationDomainOriginStateCreateInfoKHR + = VkTessellationDomainOriginKHR + + {-# NOINLINE vkDomainOrigin #-} + vkDomainOrigin x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineTessellationDomainOriginStateCreateInfoKHR, domainOrigin}) + + {-# INLINE vkDomainOriginByteOffset #-} + vkDomainOriginByteOffset ~_ + = #{offset VkPipelineTessellationDomainOriginStateCreateInfoKHR, domainOrigin} + + {-# INLINE readVkDomainOrigin #-} + readVkDomainOrigin p + = peekByteOff p #{offset VkPipelineTessellationDomainOriginStateCreateInfoKHR, domainOrigin} + + {-# INLINE writeVkDomainOrigin #-} + writeVkDomainOrigin p + = pokeByteOff p #{offset VkPipelineTessellationDomainOriginStateCreateInfoKHR, domainOrigin} + +instance {-# OVERLAPPING #-} + HasField "domainOrigin" + VkPipelineTessellationDomainOriginStateCreateInfoKHR + where + type FieldType "domainOrigin" + VkPipelineTessellationDomainOriginStateCreateInfoKHR + = VkTessellationDomainOriginKHR + type FieldOptional "domainOrigin" + VkPipelineTessellationDomainOriginStateCreateInfoKHR + = 'False -- ' closing tick for hsc2hs + type FieldOffset "domainOrigin" + VkPipelineTessellationDomainOriginStateCreateInfoKHR + = + #{offset VkPipelineTessellationDomainOriginStateCreateInfoKHR, domainOrigin} + type FieldIsArray "domainOrigin" + VkPipelineTessellationDomainOriginStateCreateInfoKHR + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineTessellationDomainOriginStateCreateInfoKHR, domainOrigin} + +instance CanReadField "domainOrigin" + VkPipelineTessellationDomainOriginStateCreateInfoKHR + where + {-# INLINE getField #-} + getField = vkDomainOrigin + + {-# INLINE readField #-} + readField = readVkDomainOrigin + +instance CanWriteField "domainOrigin" + VkPipelineTessellationDomainOriginStateCreateInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkDomainOrigin + +instance Show VkPipelineTessellationDomainOriginStateCreateInfoKHR + where + showsPrec d x + = showString + "VkPipelineTessellationDomainOriginStateCreateInfoKHR {" + . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkDomainOrigin = " . + showsPrec d (vkDomainOrigin x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkPipelineTessellationStateCreateInfo.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkPipelineTessellationStateCreateInfo.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkPipelineTessellationStateCreateInfo.hsc @@ -0,0 +1,319 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkPipelineTessellationStateCreateInfo + (VkPipelineTessellationStateCreateInfo(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Bitmasks (VkPipelineTessellationStateCreateFlags) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkPipelineTessellationStateCreateInfo { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkPipelineTessellationStateCreateFlags flags; +-- > uint32_t patchControlPoints; +-- > } VkPipelineTessellationStateCreateInfo; +-- +-- +data VkPipelineTessellationStateCreateInfo = VkPipelineTessellationStateCreateInfo## Addr## + ByteArray## + +instance Eq VkPipelineTessellationStateCreateInfo where + (VkPipelineTessellationStateCreateInfo## a _) == + x@(VkPipelineTessellationStateCreateInfo## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkPipelineTessellationStateCreateInfo where + (VkPipelineTessellationStateCreateInfo## a _) `compare` + x@(VkPipelineTessellationStateCreateInfo## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkPipelineTessellationStateCreateInfo where + sizeOf ~_ + = #{size VkPipelineTessellationStateCreateInfo} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkPipelineTessellationStateCreateInfo} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkPipelineTessellationStateCreateInfo + where + unsafeAddr (VkPipelineTessellationStateCreateInfo## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkPipelineTessellationStateCreateInfo## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkPipelineTessellationStateCreateInfo## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkPipelineTessellationStateCreateInfo where + type StructFields VkPipelineTessellationStateCreateInfo = + '["sType", "pNext", "flags", "patchControlPoints"] -- ' closing tick for hsc2hs + type CUnionType VkPipelineTessellationStateCreateInfo = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkPipelineTessellationStateCreateInfo = 'False -- ' closing tick for hsc2hs + type StructExtends VkPipelineTessellationStateCreateInfo = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkPipelineTessellationStateCreateInfo where + type VkSTypeMType VkPipelineTessellationStateCreateInfo = + VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineTessellationStateCreateInfo, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkPipelineTessellationStateCreateInfo, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkPipelineTessellationStateCreateInfo, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkPipelineTessellationStateCreateInfo, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkPipelineTessellationStateCreateInfo where + type FieldType "sType" VkPipelineTessellationStateCreateInfo = + VkStructureType + type FieldOptional "sType" VkPipelineTessellationStateCreateInfo = + 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkPipelineTessellationStateCreateInfo = + #{offset VkPipelineTessellationStateCreateInfo, sType} + type FieldIsArray "sType" VkPipelineTessellationStateCreateInfo = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineTessellationStateCreateInfo, sType} + +instance CanReadField "sType" VkPipelineTessellationStateCreateInfo + where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" + VkPipelineTessellationStateCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkPipelineTessellationStateCreateInfo where + type VkPNextMType VkPipelineTessellationStateCreateInfo = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineTessellationStateCreateInfo, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkPipelineTessellationStateCreateInfo, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkPipelineTessellationStateCreateInfo, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkPipelineTessellationStateCreateInfo, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkPipelineTessellationStateCreateInfo where + type FieldType "pNext" VkPipelineTessellationStateCreateInfo = + Ptr Void + type FieldOptional "pNext" VkPipelineTessellationStateCreateInfo = + 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkPipelineTessellationStateCreateInfo = + #{offset VkPipelineTessellationStateCreateInfo, pNext} + type FieldIsArray "pNext" VkPipelineTessellationStateCreateInfo = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineTessellationStateCreateInfo, pNext} + +instance CanReadField "pNext" VkPipelineTessellationStateCreateInfo + where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" + VkPipelineTessellationStateCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkFlags VkPipelineTessellationStateCreateInfo where + type VkFlagsMType VkPipelineTessellationStateCreateInfo = + VkPipelineTessellationStateCreateFlags + + {-# NOINLINE vkFlags #-} + vkFlags x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineTessellationStateCreateInfo, flags}) + + {-# INLINE vkFlagsByteOffset #-} + vkFlagsByteOffset ~_ + = #{offset VkPipelineTessellationStateCreateInfo, flags} + + {-# INLINE readVkFlags #-} + readVkFlags p + = peekByteOff p #{offset VkPipelineTessellationStateCreateInfo, flags} + + {-# INLINE writeVkFlags #-} + writeVkFlags p + = pokeByteOff p #{offset VkPipelineTessellationStateCreateInfo, flags} + +instance {-# OVERLAPPING #-} + HasField "flags" VkPipelineTessellationStateCreateInfo where + type FieldType "flags" VkPipelineTessellationStateCreateInfo = + VkPipelineTessellationStateCreateFlags + type FieldOptional "flags" VkPipelineTessellationStateCreateInfo = + 'True -- ' closing tick for hsc2hs + type FieldOffset "flags" VkPipelineTessellationStateCreateInfo = + #{offset VkPipelineTessellationStateCreateInfo, flags} + type FieldIsArray "flags" VkPipelineTessellationStateCreateInfo = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineTessellationStateCreateInfo, flags} + +instance CanReadField "flags" VkPipelineTessellationStateCreateInfo + where + {-# INLINE getField #-} + getField = vkFlags + + {-# INLINE readField #-} + readField = readVkFlags + +instance CanWriteField "flags" + VkPipelineTessellationStateCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkFlags + +instance {-# OVERLAPPING #-} + HasVkPatchControlPoints VkPipelineTessellationStateCreateInfo where + type VkPatchControlPointsMType + VkPipelineTessellationStateCreateInfo + = Word32 + + {-# NOINLINE vkPatchControlPoints #-} + vkPatchControlPoints x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineTessellationStateCreateInfo, patchControlPoints}) + + {-# INLINE vkPatchControlPointsByteOffset #-} + vkPatchControlPointsByteOffset ~_ + = #{offset VkPipelineTessellationStateCreateInfo, patchControlPoints} + + {-# INLINE readVkPatchControlPoints #-} + readVkPatchControlPoints p + = peekByteOff p #{offset VkPipelineTessellationStateCreateInfo, patchControlPoints} + + {-# INLINE writeVkPatchControlPoints #-} + writeVkPatchControlPoints p + = pokeByteOff p #{offset VkPipelineTessellationStateCreateInfo, patchControlPoints} + +instance {-# OVERLAPPING #-} + HasField "patchControlPoints" VkPipelineTessellationStateCreateInfo + where + type FieldType "patchControlPoints" + VkPipelineTessellationStateCreateInfo + = Word32 + type FieldOptional "patchControlPoints" + VkPipelineTessellationStateCreateInfo + = 'False -- ' closing tick for hsc2hs + type FieldOffset "patchControlPoints" + VkPipelineTessellationStateCreateInfo + = + #{offset VkPipelineTessellationStateCreateInfo, patchControlPoints} + type FieldIsArray "patchControlPoints" + VkPipelineTessellationStateCreateInfo + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineTessellationStateCreateInfo, patchControlPoints} + +instance CanReadField "patchControlPoints" + VkPipelineTessellationStateCreateInfo + where + {-# INLINE getField #-} + getField = vkPatchControlPoints + + {-# INLINE readField #-} + readField = readVkPatchControlPoints + +instance CanWriteField "patchControlPoints" + VkPipelineTessellationStateCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkPatchControlPoints + +instance Show VkPipelineTessellationStateCreateInfo where + showsPrec d x + = showString "VkPipelineTessellationStateCreateInfo {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkFlags = " . + showsPrec d (vkFlags x) . + showString ", " . + showString "vkPatchControlPoints = " . + showsPrec d (vkPatchControlPoints x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkPipelineVertexInputStateCreateInfo.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkPipelineVertexInputStateCreateInfo.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkPipelineVertexInputStateCreateInfo.hsc @@ -0,0 +1,531 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkPipelineVertexInputStateCreateInfo + (VkPipelineVertexInputStateCreateInfo(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Bitmasks (VkPipelineVertexInputStateCreateFlags) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Struct.VkVertexInputAttributeDescription (VkVertexInputAttributeDescription) +import Graphics.Vulkan.Types.Struct.VkVertexInputBindingDescription (VkVertexInputBindingDescription) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkPipelineVertexInputStateCreateInfo { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkPipelineVertexInputStateCreateFlags flags; +-- > uint32_t vertexBindingDescriptionCount; +-- > const VkVertexInputBindingDescription* pVertexBindingDescriptions; +-- > uint32_t vertexAttributeDescriptionCount; +-- > const VkVertexInputAttributeDescription* pVertexAttributeDescriptions; +-- > } VkPipelineVertexInputStateCreateInfo; +-- +-- +data VkPipelineVertexInputStateCreateInfo = VkPipelineVertexInputStateCreateInfo## Addr## + ByteArray## + +instance Eq VkPipelineVertexInputStateCreateInfo where + (VkPipelineVertexInputStateCreateInfo## a _) == + x@(VkPipelineVertexInputStateCreateInfo## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkPipelineVertexInputStateCreateInfo where + (VkPipelineVertexInputStateCreateInfo## a _) `compare` + x@(VkPipelineVertexInputStateCreateInfo## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkPipelineVertexInputStateCreateInfo where + sizeOf ~_ + = #{size VkPipelineVertexInputStateCreateInfo} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkPipelineVertexInputStateCreateInfo} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkPipelineVertexInputStateCreateInfo + where + unsafeAddr (VkPipelineVertexInputStateCreateInfo## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkPipelineVertexInputStateCreateInfo## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkPipelineVertexInputStateCreateInfo## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkPipelineVertexInputStateCreateInfo where + type StructFields VkPipelineVertexInputStateCreateInfo = + '["sType", "pNext", "flags", "vertexBindingDescriptionCount", -- ' closing tick for hsc2hs + "pVertexBindingDescriptions", "vertexAttributeDescriptionCount", + "pVertexAttributeDescriptions"] + type CUnionType VkPipelineVertexInputStateCreateInfo = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkPipelineVertexInputStateCreateInfo = 'False -- ' closing tick for hsc2hs + type StructExtends VkPipelineVertexInputStateCreateInfo = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkPipelineVertexInputStateCreateInfo where + type VkSTypeMType VkPipelineVertexInputStateCreateInfo = + VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineVertexInputStateCreateInfo, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkPipelineVertexInputStateCreateInfo, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkPipelineVertexInputStateCreateInfo, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkPipelineVertexInputStateCreateInfo, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkPipelineVertexInputStateCreateInfo where + type FieldType "sType" VkPipelineVertexInputStateCreateInfo = + VkStructureType + type FieldOptional "sType" VkPipelineVertexInputStateCreateInfo = + 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkPipelineVertexInputStateCreateInfo = + #{offset VkPipelineVertexInputStateCreateInfo, sType} + type FieldIsArray "sType" VkPipelineVertexInputStateCreateInfo = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineVertexInputStateCreateInfo, sType} + +instance CanReadField "sType" VkPipelineVertexInputStateCreateInfo + where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkPipelineVertexInputStateCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkPipelineVertexInputStateCreateInfo where + type VkPNextMType VkPipelineVertexInputStateCreateInfo = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineVertexInputStateCreateInfo, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkPipelineVertexInputStateCreateInfo, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkPipelineVertexInputStateCreateInfo, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkPipelineVertexInputStateCreateInfo, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkPipelineVertexInputStateCreateInfo where + type FieldType "pNext" VkPipelineVertexInputStateCreateInfo = + Ptr Void + type FieldOptional "pNext" VkPipelineVertexInputStateCreateInfo = + 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkPipelineVertexInputStateCreateInfo = + #{offset VkPipelineVertexInputStateCreateInfo, pNext} + type FieldIsArray "pNext" VkPipelineVertexInputStateCreateInfo = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineVertexInputStateCreateInfo, pNext} + +instance CanReadField "pNext" VkPipelineVertexInputStateCreateInfo + where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkPipelineVertexInputStateCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkFlags VkPipelineVertexInputStateCreateInfo where + type VkFlagsMType VkPipelineVertexInputStateCreateInfo = + VkPipelineVertexInputStateCreateFlags + + {-# NOINLINE vkFlags #-} + vkFlags x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineVertexInputStateCreateInfo, flags}) + + {-# INLINE vkFlagsByteOffset #-} + vkFlagsByteOffset ~_ + = #{offset VkPipelineVertexInputStateCreateInfo, flags} + + {-# INLINE readVkFlags #-} + readVkFlags p + = peekByteOff p #{offset VkPipelineVertexInputStateCreateInfo, flags} + + {-# INLINE writeVkFlags #-} + writeVkFlags p + = pokeByteOff p #{offset VkPipelineVertexInputStateCreateInfo, flags} + +instance {-# OVERLAPPING #-} + HasField "flags" VkPipelineVertexInputStateCreateInfo where + type FieldType "flags" VkPipelineVertexInputStateCreateInfo = + VkPipelineVertexInputStateCreateFlags + type FieldOptional "flags" VkPipelineVertexInputStateCreateInfo = + 'True -- ' closing tick for hsc2hs + type FieldOffset "flags" VkPipelineVertexInputStateCreateInfo = + #{offset VkPipelineVertexInputStateCreateInfo, flags} + type FieldIsArray "flags" VkPipelineVertexInputStateCreateInfo = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineVertexInputStateCreateInfo, flags} + +instance CanReadField "flags" VkPipelineVertexInputStateCreateInfo + where + {-# INLINE getField #-} + getField = vkFlags + + {-# INLINE readField #-} + readField = readVkFlags + +instance CanWriteField "flags" VkPipelineVertexInputStateCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkFlags + +instance {-# OVERLAPPING #-} + HasVkVertexBindingDescriptionCount + VkPipelineVertexInputStateCreateInfo + where + type VkVertexBindingDescriptionCountMType + VkPipelineVertexInputStateCreateInfo + = Word32 + + {-# NOINLINE vkVertexBindingDescriptionCount #-} + vkVertexBindingDescriptionCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineVertexInputStateCreateInfo, vertexBindingDescriptionCount}) + + {-# INLINE vkVertexBindingDescriptionCountByteOffset #-} + vkVertexBindingDescriptionCountByteOffset ~_ + = #{offset VkPipelineVertexInputStateCreateInfo, vertexBindingDescriptionCount} + + {-# INLINE readVkVertexBindingDescriptionCount #-} + readVkVertexBindingDescriptionCount p + = peekByteOff p #{offset VkPipelineVertexInputStateCreateInfo, vertexBindingDescriptionCount} + + {-# INLINE writeVkVertexBindingDescriptionCount #-} + writeVkVertexBindingDescriptionCount p + = pokeByteOff p #{offset VkPipelineVertexInputStateCreateInfo, vertexBindingDescriptionCount} + +instance {-# OVERLAPPING #-} + HasField "vertexBindingDescriptionCount" + VkPipelineVertexInputStateCreateInfo + where + type FieldType "vertexBindingDescriptionCount" + VkPipelineVertexInputStateCreateInfo + = Word32 + type FieldOptional "vertexBindingDescriptionCount" + VkPipelineVertexInputStateCreateInfo + = 'True -- ' closing tick for hsc2hs + type FieldOffset "vertexBindingDescriptionCount" + VkPipelineVertexInputStateCreateInfo + = + #{offset VkPipelineVertexInputStateCreateInfo, vertexBindingDescriptionCount} + type FieldIsArray "vertexBindingDescriptionCount" + VkPipelineVertexInputStateCreateInfo + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineVertexInputStateCreateInfo, vertexBindingDescriptionCount} + +instance CanReadField "vertexBindingDescriptionCount" + VkPipelineVertexInputStateCreateInfo + where + {-# INLINE getField #-} + getField = vkVertexBindingDescriptionCount + + {-# INLINE readField #-} + readField = readVkVertexBindingDescriptionCount + +instance CanWriteField "vertexBindingDescriptionCount" + VkPipelineVertexInputStateCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkVertexBindingDescriptionCount + +instance {-# OVERLAPPING #-} + HasVkPVertexBindingDescriptions + VkPipelineVertexInputStateCreateInfo + where + type VkPVertexBindingDescriptionsMType + VkPipelineVertexInputStateCreateInfo + = Ptr VkVertexInputBindingDescription + + {-# NOINLINE vkPVertexBindingDescriptions #-} + vkPVertexBindingDescriptions x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineVertexInputStateCreateInfo, pVertexBindingDescriptions}) + + {-# INLINE vkPVertexBindingDescriptionsByteOffset #-} + vkPVertexBindingDescriptionsByteOffset ~_ + = #{offset VkPipelineVertexInputStateCreateInfo, pVertexBindingDescriptions} + + {-# INLINE readVkPVertexBindingDescriptions #-} + readVkPVertexBindingDescriptions p + = peekByteOff p #{offset VkPipelineVertexInputStateCreateInfo, pVertexBindingDescriptions} + + {-# INLINE writeVkPVertexBindingDescriptions #-} + writeVkPVertexBindingDescriptions p + = pokeByteOff p #{offset VkPipelineVertexInputStateCreateInfo, pVertexBindingDescriptions} + +instance {-# OVERLAPPING #-} + HasField "pVertexBindingDescriptions" + VkPipelineVertexInputStateCreateInfo + where + type FieldType "pVertexBindingDescriptions" + VkPipelineVertexInputStateCreateInfo + = Ptr VkVertexInputBindingDescription + type FieldOptional "pVertexBindingDescriptions" + VkPipelineVertexInputStateCreateInfo + = 'False -- ' closing tick for hsc2hs + type FieldOffset "pVertexBindingDescriptions" + VkPipelineVertexInputStateCreateInfo + = + #{offset VkPipelineVertexInputStateCreateInfo, pVertexBindingDescriptions} + type FieldIsArray "pVertexBindingDescriptions" + VkPipelineVertexInputStateCreateInfo + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineVertexInputStateCreateInfo, pVertexBindingDescriptions} + +instance CanReadField "pVertexBindingDescriptions" + VkPipelineVertexInputStateCreateInfo + where + {-# INLINE getField #-} + getField = vkPVertexBindingDescriptions + + {-# INLINE readField #-} + readField = readVkPVertexBindingDescriptions + +instance CanWriteField "pVertexBindingDescriptions" + VkPipelineVertexInputStateCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkPVertexBindingDescriptions + +instance {-# OVERLAPPING #-} + HasVkVertexAttributeDescriptionCount + VkPipelineVertexInputStateCreateInfo + where + type VkVertexAttributeDescriptionCountMType + VkPipelineVertexInputStateCreateInfo + = Word32 + + {-# NOINLINE vkVertexAttributeDescriptionCount #-} + vkVertexAttributeDescriptionCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineVertexInputStateCreateInfo, vertexAttributeDescriptionCount}) + + {-# INLINE vkVertexAttributeDescriptionCountByteOffset #-} + vkVertexAttributeDescriptionCountByteOffset ~_ + = #{offset VkPipelineVertexInputStateCreateInfo, vertexAttributeDescriptionCount} + + {-# INLINE readVkVertexAttributeDescriptionCount #-} + readVkVertexAttributeDescriptionCount p + = peekByteOff p #{offset VkPipelineVertexInputStateCreateInfo, vertexAttributeDescriptionCount} + + {-# INLINE writeVkVertexAttributeDescriptionCount #-} + writeVkVertexAttributeDescriptionCount p + = pokeByteOff p #{offset VkPipelineVertexInputStateCreateInfo, vertexAttributeDescriptionCount} + +instance {-# OVERLAPPING #-} + HasField "vertexAttributeDescriptionCount" + VkPipelineVertexInputStateCreateInfo + where + type FieldType "vertexAttributeDescriptionCount" + VkPipelineVertexInputStateCreateInfo + = Word32 + type FieldOptional "vertexAttributeDescriptionCount" + VkPipelineVertexInputStateCreateInfo + = 'True -- ' closing tick for hsc2hs + type FieldOffset "vertexAttributeDescriptionCount" + VkPipelineVertexInputStateCreateInfo + = + #{offset VkPipelineVertexInputStateCreateInfo, vertexAttributeDescriptionCount} + type FieldIsArray "vertexAttributeDescriptionCount" + VkPipelineVertexInputStateCreateInfo + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineVertexInputStateCreateInfo, vertexAttributeDescriptionCount} + +instance CanReadField "vertexAttributeDescriptionCount" + VkPipelineVertexInputStateCreateInfo + where + {-# INLINE getField #-} + getField = vkVertexAttributeDescriptionCount + + {-# INLINE readField #-} + readField = readVkVertexAttributeDescriptionCount + +instance CanWriteField "vertexAttributeDescriptionCount" + VkPipelineVertexInputStateCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkVertexAttributeDescriptionCount + +instance {-# OVERLAPPING #-} + HasVkPVertexAttributeDescriptions + VkPipelineVertexInputStateCreateInfo + where + type VkPVertexAttributeDescriptionsMType + VkPipelineVertexInputStateCreateInfo + = Ptr VkVertexInputAttributeDescription + + {-# NOINLINE vkPVertexAttributeDescriptions #-} + vkPVertexAttributeDescriptions x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineVertexInputStateCreateInfo, pVertexAttributeDescriptions}) + + {-# INLINE vkPVertexAttributeDescriptionsByteOffset #-} + vkPVertexAttributeDescriptionsByteOffset ~_ + = #{offset VkPipelineVertexInputStateCreateInfo, pVertexAttributeDescriptions} + + {-# INLINE readVkPVertexAttributeDescriptions #-} + readVkPVertexAttributeDescriptions p + = peekByteOff p #{offset VkPipelineVertexInputStateCreateInfo, pVertexAttributeDescriptions} + + {-# INLINE writeVkPVertexAttributeDescriptions #-} + writeVkPVertexAttributeDescriptions p + = pokeByteOff p #{offset VkPipelineVertexInputStateCreateInfo, pVertexAttributeDescriptions} + +instance {-# OVERLAPPING #-} + HasField "pVertexAttributeDescriptions" + VkPipelineVertexInputStateCreateInfo + where + type FieldType "pVertexAttributeDescriptions" + VkPipelineVertexInputStateCreateInfo + = Ptr VkVertexInputAttributeDescription + type FieldOptional "pVertexAttributeDescriptions" + VkPipelineVertexInputStateCreateInfo + = 'False -- ' closing tick for hsc2hs + type FieldOffset "pVertexAttributeDescriptions" + VkPipelineVertexInputStateCreateInfo + = + #{offset VkPipelineVertexInputStateCreateInfo, pVertexAttributeDescriptions} + type FieldIsArray "pVertexAttributeDescriptions" + VkPipelineVertexInputStateCreateInfo + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineVertexInputStateCreateInfo, pVertexAttributeDescriptions} + +instance CanReadField "pVertexAttributeDescriptions" + VkPipelineVertexInputStateCreateInfo + where + {-# INLINE getField #-} + getField = vkPVertexAttributeDescriptions + + {-# INLINE readField #-} + readField = readVkPVertexAttributeDescriptions + +instance CanWriteField "pVertexAttributeDescriptions" + VkPipelineVertexInputStateCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkPVertexAttributeDescriptions + +instance Show VkPipelineVertexInputStateCreateInfo where + showsPrec d x + = showString "VkPipelineVertexInputStateCreateInfo {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkFlags = " . + showsPrec d (vkFlags x) . + showString ", " . + showString "vkVertexBindingDescriptionCount = " . + showsPrec d (vkVertexBindingDescriptionCount x) . + showString ", " . + showString "vkPVertexBindingDescriptions = " . + showsPrec d (vkPVertexBindingDescriptions x) . + showString ", " . + showString "vkVertexAttributeDescriptionCount = " . + showsPrec d (vkVertexAttributeDescriptionCount x) . + showString ", " . + showString "vkPVertexAttributeDescriptions = " . + showsPrec d (vkPVertexAttributeDescriptions x) . + showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkPipelineViewportStateCreateInfo.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkPipelineViewportStateCreateInfo.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkPipelineViewportStateCreateInfo.hsc @@ -0,0 +1,486 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkPipelineViewportStateCreateInfo + (VkPipelineViewportStateCreateInfo(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Bitmasks (VkPipelineViewportStateCreateFlags) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Struct.VkRect2D (VkRect2D) +import Graphics.Vulkan.Types.Struct.VkViewport (VkViewport) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkPipelineViewportStateCreateInfo { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkPipelineViewportStateCreateFlags flags; +-- > uint32_t viewportCount; +-- > const VkViewport* pViewports; +-- > uint32_t scissorCount; +-- > const VkRect2D* pScissors; +-- > } VkPipelineViewportStateCreateInfo; +-- +-- +data VkPipelineViewportStateCreateInfo = VkPipelineViewportStateCreateInfo## Addr## + ByteArray## + +instance Eq VkPipelineViewportStateCreateInfo where + (VkPipelineViewportStateCreateInfo## a _) == + x@(VkPipelineViewportStateCreateInfo## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkPipelineViewportStateCreateInfo where + (VkPipelineViewportStateCreateInfo## a _) `compare` + x@(VkPipelineViewportStateCreateInfo## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkPipelineViewportStateCreateInfo where + sizeOf ~_ = #{size VkPipelineViewportStateCreateInfo} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkPipelineViewportStateCreateInfo} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkPipelineViewportStateCreateInfo where + unsafeAddr (VkPipelineViewportStateCreateInfo## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkPipelineViewportStateCreateInfo## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkPipelineViewportStateCreateInfo## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkPipelineViewportStateCreateInfo where + type StructFields VkPipelineViewportStateCreateInfo = + '["sType", "pNext", "flags", "viewportCount", "pViewports", -- ' closing tick for hsc2hs + "scissorCount", "pScissors"] + type CUnionType VkPipelineViewportStateCreateInfo = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkPipelineViewportStateCreateInfo = 'False -- ' closing tick for hsc2hs + type StructExtends VkPipelineViewportStateCreateInfo = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkPipelineViewportStateCreateInfo where + type VkSTypeMType VkPipelineViewportStateCreateInfo = + VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineViewportStateCreateInfo, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkPipelineViewportStateCreateInfo, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkPipelineViewportStateCreateInfo, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkPipelineViewportStateCreateInfo, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkPipelineViewportStateCreateInfo where + type FieldType "sType" VkPipelineViewportStateCreateInfo = + VkStructureType + type FieldOptional "sType" VkPipelineViewportStateCreateInfo = + 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkPipelineViewportStateCreateInfo = + #{offset VkPipelineViewportStateCreateInfo, sType} + type FieldIsArray "sType" VkPipelineViewportStateCreateInfo = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineViewportStateCreateInfo, sType} + +instance CanReadField "sType" VkPipelineViewportStateCreateInfo + where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkPipelineViewportStateCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkPipelineViewportStateCreateInfo where + type VkPNextMType VkPipelineViewportStateCreateInfo = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineViewportStateCreateInfo, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkPipelineViewportStateCreateInfo, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkPipelineViewportStateCreateInfo, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkPipelineViewportStateCreateInfo, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkPipelineViewportStateCreateInfo where + type FieldType "pNext" VkPipelineViewportStateCreateInfo = Ptr Void + type FieldOptional "pNext" VkPipelineViewportStateCreateInfo = + 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkPipelineViewportStateCreateInfo = + #{offset VkPipelineViewportStateCreateInfo, pNext} + type FieldIsArray "pNext" VkPipelineViewportStateCreateInfo = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineViewportStateCreateInfo, pNext} + +instance CanReadField "pNext" VkPipelineViewportStateCreateInfo + where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkPipelineViewportStateCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkFlags VkPipelineViewportStateCreateInfo where + type VkFlagsMType VkPipelineViewportStateCreateInfo = + VkPipelineViewportStateCreateFlags + + {-# NOINLINE vkFlags #-} + vkFlags x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineViewportStateCreateInfo, flags}) + + {-# INLINE vkFlagsByteOffset #-} + vkFlagsByteOffset ~_ + = #{offset VkPipelineViewportStateCreateInfo, flags} + + {-# INLINE readVkFlags #-} + readVkFlags p + = peekByteOff p #{offset VkPipelineViewportStateCreateInfo, flags} + + {-# INLINE writeVkFlags #-} + writeVkFlags p + = pokeByteOff p #{offset VkPipelineViewportStateCreateInfo, flags} + +instance {-# OVERLAPPING #-} + HasField "flags" VkPipelineViewportStateCreateInfo where + type FieldType "flags" VkPipelineViewportStateCreateInfo = + VkPipelineViewportStateCreateFlags + type FieldOptional "flags" VkPipelineViewportStateCreateInfo = + 'True -- ' closing tick for hsc2hs + type FieldOffset "flags" VkPipelineViewportStateCreateInfo = + #{offset VkPipelineViewportStateCreateInfo, flags} + type FieldIsArray "flags" VkPipelineViewportStateCreateInfo = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineViewportStateCreateInfo, flags} + +instance CanReadField "flags" VkPipelineViewportStateCreateInfo + where + {-# INLINE getField #-} + getField = vkFlags + + {-# INLINE readField #-} + readField = readVkFlags + +instance CanWriteField "flags" VkPipelineViewportStateCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkFlags + +instance {-# OVERLAPPING #-} + HasVkViewportCount VkPipelineViewportStateCreateInfo where + type VkViewportCountMType VkPipelineViewportStateCreateInfo = + Word32 + + {-# NOINLINE vkViewportCount #-} + vkViewportCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineViewportStateCreateInfo, viewportCount}) + + {-# INLINE vkViewportCountByteOffset #-} + vkViewportCountByteOffset ~_ + = #{offset VkPipelineViewportStateCreateInfo, viewportCount} + + {-# INLINE readVkViewportCount #-} + readVkViewportCount p + = peekByteOff p #{offset VkPipelineViewportStateCreateInfo, viewportCount} + + {-# INLINE writeVkViewportCount #-} + writeVkViewportCount p + = pokeByteOff p #{offset VkPipelineViewportStateCreateInfo, viewportCount} + +instance {-# OVERLAPPING #-} + HasField "viewportCount" VkPipelineViewportStateCreateInfo where + type FieldType "viewportCount" VkPipelineViewportStateCreateInfo = + Word32 + type FieldOptional "viewportCount" + VkPipelineViewportStateCreateInfo + = 'False -- ' closing tick for hsc2hs + type FieldOffset "viewportCount" VkPipelineViewportStateCreateInfo + = + #{offset VkPipelineViewportStateCreateInfo, viewportCount} + type FieldIsArray "viewportCount" VkPipelineViewportStateCreateInfo + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineViewportStateCreateInfo, viewportCount} + +instance CanReadField "viewportCount" + VkPipelineViewportStateCreateInfo + where + {-# INLINE getField #-} + getField = vkViewportCount + + {-# INLINE readField #-} + readField = readVkViewportCount + +instance CanWriteField "viewportCount" + VkPipelineViewportStateCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkViewportCount + +instance {-# OVERLAPPING #-} + HasVkPViewports VkPipelineViewportStateCreateInfo where + type VkPViewportsMType VkPipelineViewportStateCreateInfo = + Ptr VkViewport + + {-# NOINLINE vkPViewports #-} + vkPViewports x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineViewportStateCreateInfo, pViewports}) + + {-# INLINE vkPViewportsByteOffset #-} + vkPViewportsByteOffset ~_ + = #{offset VkPipelineViewportStateCreateInfo, pViewports} + + {-# INLINE readVkPViewports #-} + readVkPViewports p + = peekByteOff p #{offset VkPipelineViewportStateCreateInfo, pViewports} + + {-# INLINE writeVkPViewports #-} + writeVkPViewports p + = pokeByteOff p #{offset VkPipelineViewportStateCreateInfo, pViewports} + +instance {-# OVERLAPPING #-} + HasField "pViewports" VkPipelineViewportStateCreateInfo where + type FieldType "pViewports" VkPipelineViewportStateCreateInfo = + Ptr VkViewport + type FieldOptional "pViewports" VkPipelineViewportStateCreateInfo = + 'True -- ' closing tick for hsc2hs + type FieldOffset "pViewports" VkPipelineViewportStateCreateInfo = + #{offset VkPipelineViewportStateCreateInfo, pViewports} + type FieldIsArray "pViewports" VkPipelineViewportStateCreateInfo = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineViewportStateCreateInfo, pViewports} + +instance CanReadField "pViewports" + VkPipelineViewportStateCreateInfo + where + {-# INLINE getField #-} + getField = vkPViewports + + {-# INLINE readField #-} + readField = readVkPViewports + +instance CanWriteField "pViewports" + VkPipelineViewportStateCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkPViewports + +instance {-# OVERLAPPING #-} + HasVkScissorCount VkPipelineViewportStateCreateInfo where + type VkScissorCountMType VkPipelineViewportStateCreateInfo = Word32 + + {-# NOINLINE vkScissorCount #-} + vkScissorCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineViewportStateCreateInfo, scissorCount}) + + {-# INLINE vkScissorCountByteOffset #-} + vkScissorCountByteOffset ~_ + = #{offset VkPipelineViewportStateCreateInfo, scissorCount} + + {-# INLINE readVkScissorCount #-} + readVkScissorCount p + = peekByteOff p #{offset VkPipelineViewportStateCreateInfo, scissorCount} + + {-# INLINE writeVkScissorCount #-} + writeVkScissorCount p + = pokeByteOff p #{offset VkPipelineViewportStateCreateInfo, scissorCount} + +instance {-# OVERLAPPING #-} + HasField "scissorCount" VkPipelineViewportStateCreateInfo where + type FieldType "scissorCount" VkPipelineViewportStateCreateInfo = + Word32 + type FieldOptional "scissorCount" VkPipelineViewportStateCreateInfo + = 'False -- ' closing tick for hsc2hs + type FieldOffset "scissorCount" VkPipelineViewportStateCreateInfo = + #{offset VkPipelineViewportStateCreateInfo, scissorCount} + type FieldIsArray "scissorCount" VkPipelineViewportStateCreateInfo + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineViewportStateCreateInfo, scissorCount} + +instance CanReadField "scissorCount" + VkPipelineViewportStateCreateInfo + where + {-# INLINE getField #-} + getField = vkScissorCount + + {-# INLINE readField #-} + readField = readVkScissorCount + +instance CanWriteField "scissorCount" + VkPipelineViewportStateCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkScissorCount + +instance {-# OVERLAPPING #-} + HasVkPScissors VkPipelineViewportStateCreateInfo where + type VkPScissorsMType VkPipelineViewportStateCreateInfo = + Ptr VkRect2D + + {-# NOINLINE vkPScissors #-} + vkPScissors x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineViewportStateCreateInfo, pScissors}) + + {-# INLINE vkPScissorsByteOffset #-} + vkPScissorsByteOffset ~_ + = #{offset VkPipelineViewportStateCreateInfo, pScissors} + + {-# INLINE readVkPScissors #-} + readVkPScissors p + = peekByteOff p #{offset VkPipelineViewportStateCreateInfo, pScissors} + + {-# INLINE writeVkPScissors #-} + writeVkPScissors p + = pokeByteOff p #{offset VkPipelineViewportStateCreateInfo, pScissors} + +instance {-# OVERLAPPING #-} + HasField "pScissors" VkPipelineViewportStateCreateInfo where + type FieldType "pScissors" VkPipelineViewportStateCreateInfo = + Ptr VkRect2D + type FieldOptional "pScissors" VkPipelineViewportStateCreateInfo = + 'True -- ' closing tick for hsc2hs + type FieldOffset "pScissors" VkPipelineViewportStateCreateInfo = + #{offset VkPipelineViewportStateCreateInfo, pScissors} + type FieldIsArray "pScissors" VkPipelineViewportStateCreateInfo = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineViewportStateCreateInfo, pScissors} + +instance CanReadField "pScissors" VkPipelineViewportStateCreateInfo + where + {-# INLINE getField #-} + getField = vkPScissors + + {-# INLINE readField #-} + readField = readVkPScissors + +instance CanWriteField "pScissors" + VkPipelineViewportStateCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkPScissors + +instance Show VkPipelineViewportStateCreateInfo where + showsPrec d x + = showString "VkPipelineViewportStateCreateInfo {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkFlags = " . + showsPrec d (vkFlags x) . + showString ", " . + showString "vkViewportCount = " . + showsPrec d (vkViewportCount x) . + showString ", " . + showString "vkPViewports = " . + showsPrec d (vkPViewports x) . + showString ", " . + showString "vkScissorCount = " . + showsPrec d (vkScissorCount x) . + showString ", " . + showString "vkPScissors = " . + showsPrec d (vkPScissors x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkPipelineViewportSwizzleStateCreateInfoNV.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkPipelineViewportSwizzleStateCreateInfoNV.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkPipelineViewportSwizzleStateCreateInfoNV.hsc @@ -0,0 +1,407 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkPipelineViewportSwizzleStateCreateInfoNV + (VkPipelineViewportSwizzleStateCreateInfoNV(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Bitmasks (VkPipelineViewportSwizzleStateCreateFlagsNV) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Struct.VkPipelineViewportStateCreateInfo (VkPipelineViewportStateCreateInfo) +import Graphics.Vulkan.Types.Struct.VkViewportSwizzleNV (VkViewportSwizzleNV) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkPipelineViewportSwizzleStateCreateInfoNV { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkPipelineViewportSwizzleStateCreateFlagsNV flags; +-- > uint32_t viewportCount; +-- > const VkViewportSwizzleNV* pViewportSwizzles; +-- > } VkPipelineViewportSwizzleStateCreateInfoNV; +-- +-- +data VkPipelineViewportSwizzleStateCreateInfoNV = VkPipelineViewportSwizzleStateCreateInfoNV## Addr## + ByteArray## + +instance Eq VkPipelineViewportSwizzleStateCreateInfoNV where + (VkPipelineViewportSwizzleStateCreateInfoNV## a _) == + x@(VkPipelineViewportSwizzleStateCreateInfoNV## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkPipelineViewportSwizzleStateCreateInfoNV where + (VkPipelineViewportSwizzleStateCreateInfoNV## a _) `compare` + x@(VkPipelineViewportSwizzleStateCreateInfoNV## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkPipelineViewportSwizzleStateCreateInfoNV where + sizeOf ~_ + = #{size VkPipelineViewportSwizzleStateCreateInfoNV} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkPipelineViewportSwizzleStateCreateInfoNV} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim + VkPipelineViewportSwizzleStateCreateInfoNV + where + unsafeAddr (VkPipelineViewportSwizzleStateCreateInfoNV## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkPipelineViewportSwizzleStateCreateInfoNV## _ b) + = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkPipelineViewportSwizzleStateCreateInfoNV## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkPipelineViewportSwizzleStateCreateInfoNV + where + type StructFields VkPipelineViewportSwizzleStateCreateInfoNV = + '["sType", "pNext", "flags", "viewportCount", "pViewportSwizzles"] -- ' closing tick for hsc2hs + type CUnionType VkPipelineViewportSwizzleStateCreateInfoNV = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkPipelineViewportSwizzleStateCreateInfoNV = + 'False -- ' closing tick for hsc2hs + type StructExtends VkPipelineViewportSwizzleStateCreateInfoNV = + '[VkPipelineViewportStateCreateInfo] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkPipelineViewportSwizzleStateCreateInfoNV where + type VkSTypeMType VkPipelineViewportSwizzleStateCreateInfoNV = + VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineViewportSwizzleStateCreateInfoNV, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkPipelineViewportSwizzleStateCreateInfoNV, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkPipelineViewportSwizzleStateCreateInfoNV, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkPipelineViewportSwizzleStateCreateInfoNV, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkPipelineViewportSwizzleStateCreateInfoNV where + type FieldType "sType" VkPipelineViewportSwizzleStateCreateInfoNV = + VkStructureType + type FieldOptional "sType" + VkPipelineViewportSwizzleStateCreateInfoNV + = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkPipelineViewportSwizzleStateCreateInfoNV + = + #{offset VkPipelineViewportSwizzleStateCreateInfoNV, sType} + type FieldIsArray "sType" + VkPipelineViewportSwizzleStateCreateInfoNV + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineViewportSwizzleStateCreateInfoNV, sType} + +instance CanReadField "sType" + VkPipelineViewportSwizzleStateCreateInfoNV + where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" + VkPipelineViewportSwizzleStateCreateInfoNV + where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkPipelineViewportSwizzleStateCreateInfoNV where + type VkPNextMType VkPipelineViewportSwizzleStateCreateInfoNV = + Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineViewportSwizzleStateCreateInfoNV, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkPipelineViewportSwizzleStateCreateInfoNV, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkPipelineViewportSwizzleStateCreateInfoNV, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkPipelineViewportSwizzleStateCreateInfoNV, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkPipelineViewportSwizzleStateCreateInfoNV where + type FieldType "pNext" VkPipelineViewportSwizzleStateCreateInfoNV = + Ptr Void + type FieldOptional "pNext" + VkPipelineViewportSwizzleStateCreateInfoNV + = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkPipelineViewportSwizzleStateCreateInfoNV + = + #{offset VkPipelineViewportSwizzleStateCreateInfoNV, pNext} + type FieldIsArray "pNext" + VkPipelineViewportSwizzleStateCreateInfoNV + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineViewportSwizzleStateCreateInfoNV, pNext} + +instance CanReadField "pNext" + VkPipelineViewportSwizzleStateCreateInfoNV + where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" + VkPipelineViewportSwizzleStateCreateInfoNV + where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkFlags VkPipelineViewportSwizzleStateCreateInfoNV where + type VkFlagsMType VkPipelineViewportSwizzleStateCreateInfoNV = + VkPipelineViewportSwizzleStateCreateFlagsNV + + {-# NOINLINE vkFlags #-} + vkFlags x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineViewportSwizzleStateCreateInfoNV, flags}) + + {-# INLINE vkFlagsByteOffset #-} + vkFlagsByteOffset ~_ + = #{offset VkPipelineViewportSwizzleStateCreateInfoNV, flags} + + {-# INLINE readVkFlags #-} + readVkFlags p + = peekByteOff p #{offset VkPipelineViewportSwizzleStateCreateInfoNV, flags} + + {-# INLINE writeVkFlags #-} + writeVkFlags p + = pokeByteOff p #{offset VkPipelineViewportSwizzleStateCreateInfoNV, flags} + +instance {-# OVERLAPPING #-} + HasField "flags" VkPipelineViewportSwizzleStateCreateInfoNV where + type FieldType "flags" VkPipelineViewportSwizzleStateCreateInfoNV = + VkPipelineViewportSwizzleStateCreateFlagsNV + type FieldOptional "flags" + VkPipelineViewportSwizzleStateCreateInfoNV + = 'True -- ' closing tick for hsc2hs + type FieldOffset "flags" VkPipelineViewportSwizzleStateCreateInfoNV + = + #{offset VkPipelineViewportSwizzleStateCreateInfoNV, flags} + type FieldIsArray "flags" + VkPipelineViewportSwizzleStateCreateInfoNV + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineViewportSwizzleStateCreateInfoNV, flags} + +instance CanReadField "flags" + VkPipelineViewportSwizzleStateCreateInfoNV + where + {-# INLINE getField #-} + getField = vkFlags + + {-# INLINE readField #-} + readField = readVkFlags + +instance CanWriteField "flags" + VkPipelineViewportSwizzleStateCreateInfoNV + where + {-# INLINE writeField #-} + writeField = writeVkFlags + +instance {-# OVERLAPPING #-} + HasVkViewportCount VkPipelineViewportSwizzleStateCreateInfoNV where + type VkViewportCountMType + VkPipelineViewportSwizzleStateCreateInfoNV + = Word32 + + {-# NOINLINE vkViewportCount #-} + vkViewportCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineViewportSwizzleStateCreateInfoNV, viewportCount}) + + {-# INLINE vkViewportCountByteOffset #-} + vkViewportCountByteOffset ~_ + = #{offset VkPipelineViewportSwizzleStateCreateInfoNV, viewportCount} + + {-# INLINE readVkViewportCount #-} + readVkViewportCount p + = peekByteOff p #{offset VkPipelineViewportSwizzleStateCreateInfoNV, viewportCount} + + {-# INLINE writeVkViewportCount #-} + writeVkViewportCount p + = pokeByteOff p #{offset VkPipelineViewportSwizzleStateCreateInfoNV, viewportCount} + +instance {-# OVERLAPPING #-} + HasField "viewportCount" VkPipelineViewportSwizzleStateCreateInfoNV + where + type FieldType "viewportCount" + VkPipelineViewportSwizzleStateCreateInfoNV + = Word32 + type FieldOptional "viewportCount" + VkPipelineViewportSwizzleStateCreateInfoNV + = 'False -- ' closing tick for hsc2hs + type FieldOffset "viewportCount" + VkPipelineViewportSwizzleStateCreateInfoNV + = + #{offset VkPipelineViewportSwizzleStateCreateInfoNV, viewportCount} + type FieldIsArray "viewportCount" + VkPipelineViewportSwizzleStateCreateInfoNV + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineViewportSwizzleStateCreateInfoNV, viewportCount} + +instance CanReadField "viewportCount" + VkPipelineViewportSwizzleStateCreateInfoNV + where + {-# INLINE getField #-} + getField = vkViewportCount + + {-# INLINE readField #-} + readField = readVkViewportCount + +instance CanWriteField "viewportCount" + VkPipelineViewportSwizzleStateCreateInfoNV + where + {-# INLINE writeField #-} + writeField = writeVkViewportCount + +instance {-# OVERLAPPING #-} + HasVkPViewportSwizzles VkPipelineViewportSwizzleStateCreateInfoNV + where + type VkPViewportSwizzlesMType + VkPipelineViewportSwizzleStateCreateInfoNV + = Ptr VkViewportSwizzleNV + + {-# NOINLINE vkPViewportSwizzles #-} + vkPViewportSwizzles x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineViewportSwizzleStateCreateInfoNV, pViewportSwizzles}) + + {-# INLINE vkPViewportSwizzlesByteOffset #-} + vkPViewportSwizzlesByteOffset ~_ + = #{offset VkPipelineViewportSwizzleStateCreateInfoNV, pViewportSwizzles} + + {-# INLINE readVkPViewportSwizzles #-} + readVkPViewportSwizzles p + = peekByteOff p #{offset VkPipelineViewportSwizzleStateCreateInfoNV, pViewportSwizzles} + + {-# INLINE writeVkPViewportSwizzles #-} + writeVkPViewportSwizzles p + = pokeByteOff p #{offset VkPipelineViewportSwizzleStateCreateInfoNV, pViewportSwizzles} + +instance {-# OVERLAPPING #-} + HasField "pViewportSwizzles" + VkPipelineViewportSwizzleStateCreateInfoNV + where + type FieldType "pViewportSwizzles" + VkPipelineViewportSwizzleStateCreateInfoNV + = Ptr VkViewportSwizzleNV + type FieldOptional "pViewportSwizzles" + VkPipelineViewportSwizzleStateCreateInfoNV + = 'True -- ' closing tick for hsc2hs + type FieldOffset "pViewportSwizzles" + VkPipelineViewportSwizzleStateCreateInfoNV + = + #{offset VkPipelineViewportSwizzleStateCreateInfoNV, pViewportSwizzles} + type FieldIsArray "pViewportSwizzles" + VkPipelineViewportSwizzleStateCreateInfoNV + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineViewportSwizzleStateCreateInfoNV, pViewportSwizzles} + +instance CanReadField "pViewportSwizzles" + VkPipelineViewportSwizzleStateCreateInfoNV + where + {-# INLINE getField #-} + getField = vkPViewportSwizzles + + {-# INLINE readField #-} + readField = readVkPViewportSwizzles + +instance CanWriteField "pViewportSwizzles" + VkPipelineViewportSwizzleStateCreateInfoNV + where + {-# INLINE writeField #-} + writeField = writeVkPViewportSwizzles + +instance Show VkPipelineViewportSwizzleStateCreateInfoNV where + showsPrec d x + = showString "VkPipelineViewportSwizzleStateCreateInfoNV {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkFlags = " . + showsPrec d (vkFlags x) . + showString ", " . + showString "vkViewportCount = " . + showsPrec d (vkViewportCount x) . + showString ", " . + showString "vkPViewportSwizzles = " . + showsPrec d (vkPViewportSwizzles x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkPipelineViewportWScalingStateCreateInfoNV.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkPipelineViewportWScalingStateCreateInfoNV.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkPipelineViewportWScalingStateCreateInfoNV.hsc @@ -0,0 +1,420 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkPipelineViewportWScalingStateCreateInfoNV + (VkPipelineViewportWScalingStateCreateInfoNV(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.BaseTypes (VkBool32) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Struct.VkPipelineViewportStateCreateInfo (VkPipelineViewportStateCreateInfo) +import Graphics.Vulkan.Types.Struct.VkViewportWScalingNV (VkViewportWScalingNV) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkPipelineViewportWScalingStateCreateInfoNV { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkBool32 viewportWScalingEnable; +-- > uint32_t viewportCount; +-- > const VkViewportWScalingNV* pViewportWScalings; +-- > } VkPipelineViewportWScalingStateCreateInfoNV; +-- +-- +data VkPipelineViewportWScalingStateCreateInfoNV = VkPipelineViewportWScalingStateCreateInfoNV## Addr## + ByteArray## + +instance Eq VkPipelineViewportWScalingStateCreateInfoNV where + (VkPipelineViewportWScalingStateCreateInfoNV## a _) == + x@(VkPipelineViewportWScalingStateCreateInfoNV## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkPipelineViewportWScalingStateCreateInfoNV where + (VkPipelineViewportWScalingStateCreateInfoNV## a _) `compare` + x@(VkPipelineViewportWScalingStateCreateInfoNV## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkPipelineViewportWScalingStateCreateInfoNV where + sizeOf ~_ + = #{size VkPipelineViewportWScalingStateCreateInfoNV} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkPipelineViewportWScalingStateCreateInfoNV} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim + VkPipelineViewportWScalingStateCreateInfoNV + where + unsafeAddr (VkPipelineViewportWScalingStateCreateInfoNV## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkPipelineViewportWScalingStateCreateInfoNV## _ b) + = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkPipelineViewportWScalingStateCreateInfoNV## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkPipelineViewportWScalingStateCreateInfoNV + where + type StructFields VkPipelineViewportWScalingStateCreateInfoNV = + '["sType", "pNext", "viewportWScalingEnable", "viewportCount", -- ' closing tick for hsc2hs + "pViewportWScalings"] + type CUnionType VkPipelineViewportWScalingStateCreateInfoNV = + 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkPipelineViewportWScalingStateCreateInfoNV = + 'False -- ' closing tick for hsc2hs + type StructExtends VkPipelineViewportWScalingStateCreateInfoNV = + '[VkPipelineViewportStateCreateInfo] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkPipelineViewportWScalingStateCreateInfoNV where + type VkSTypeMType VkPipelineViewportWScalingStateCreateInfoNV = + VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineViewportWScalingStateCreateInfoNV, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkPipelineViewportWScalingStateCreateInfoNV, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkPipelineViewportWScalingStateCreateInfoNV, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkPipelineViewportWScalingStateCreateInfoNV, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkPipelineViewportWScalingStateCreateInfoNV where + type FieldType "sType" VkPipelineViewportWScalingStateCreateInfoNV + = VkStructureType + type FieldOptional "sType" + VkPipelineViewportWScalingStateCreateInfoNV + = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" + VkPipelineViewportWScalingStateCreateInfoNV + = + #{offset VkPipelineViewportWScalingStateCreateInfoNV, sType} + type FieldIsArray "sType" + VkPipelineViewportWScalingStateCreateInfoNV + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineViewportWScalingStateCreateInfoNV, sType} + +instance CanReadField "sType" + VkPipelineViewportWScalingStateCreateInfoNV + where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" + VkPipelineViewportWScalingStateCreateInfoNV + where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkPipelineViewportWScalingStateCreateInfoNV where + type VkPNextMType VkPipelineViewportWScalingStateCreateInfoNV = + Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineViewportWScalingStateCreateInfoNV, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkPipelineViewportWScalingStateCreateInfoNV, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkPipelineViewportWScalingStateCreateInfoNV, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkPipelineViewportWScalingStateCreateInfoNV, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkPipelineViewportWScalingStateCreateInfoNV where + type FieldType "pNext" VkPipelineViewportWScalingStateCreateInfoNV + = Ptr Void + type FieldOptional "pNext" + VkPipelineViewportWScalingStateCreateInfoNV + = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" + VkPipelineViewportWScalingStateCreateInfoNV + = + #{offset VkPipelineViewportWScalingStateCreateInfoNV, pNext} + type FieldIsArray "pNext" + VkPipelineViewportWScalingStateCreateInfoNV + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineViewportWScalingStateCreateInfoNV, pNext} + +instance CanReadField "pNext" + VkPipelineViewportWScalingStateCreateInfoNV + where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" + VkPipelineViewportWScalingStateCreateInfoNV + where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkViewportWScalingEnable + VkPipelineViewportWScalingStateCreateInfoNV + where + type VkViewportWScalingEnableMType + VkPipelineViewportWScalingStateCreateInfoNV + = VkBool32 + + {-# NOINLINE vkViewportWScalingEnable #-} + vkViewportWScalingEnable x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineViewportWScalingStateCreateInfoNV, viewportWScalingEnable}) + + {-# INLINE vkViewportWScalingEnableByteOffset #-} + vkViewportWScalingEnableByteOffset ~_ + = #{offset VkPipelineViewportWScalingStateCreateInfoNV, viewportWScalingEnable} + + {-# INLINE readVkViewportWScalingEnable #-} + readVkViewportWScalingEnable p + = peekByteOff p #{offset VkPipelineViewportWScalingStateCreateInfoNV, viewportWScalingEnable} + + {-# INLINE writeVkViewportWScalingEnable #-} + writeVkViewportWScalingEnable p + = pokeByteOff p #{offset VkPipelineViewportWScalingStateCreateInfoNV, viewportWScalingEnable} + +instance {-# OVERLAPPING #-} + HasField "viewportWScalingEnable" + VkPipelineViewportWScalingStateCreateInfoNV + where + type FieldType "viewportWScalingEnable" + VkPipelineViewportWScalingStateCreateInfoNV + = VkBool32 + type FieldOptional "viewportWScalingEnable" + VkPipelineViewportWScalingStateCreateInfoNV + = 'False -- ' closing tick for hsc2hs + type FieldOffset "viewportWScalingEnable" + VkPipelineViewportWScalingStateCreateInfoNV + = + #{offset VkPipelineViewportWScalingStateCreateInfoNV, viewportWScalingEnable} + type FieldIsArray "viewportWScalingEnable" + VkPipelineViewportWScalingStateCreateInfoNV + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineViewportWScalingStateCreateInfoNV, viewportWScalingEnable} + +instance CanReadField "viewportWScalingEnable" + VkPipelineViewportWScalingStateCreateInfoNV + where + {-# INLINE getField #-} + getField = vkViewportWScalingEnable + + {-# INLINE readField #-} + readField = readVkViewportWScalingEnable + +instance CanWriteField "viewportWScalingEnable" + VkPipelineViewportWScalingStateCreateInfoNV + where + {-# INLINE writeField #-} + writeField = writeVkViewportWScalingEnable + +instance {-# OVERLAPPING #-} + HasVkViewportCount VkPipelineViewportWScalingStateCreateInfoNV + where + type VkViewportCountMType + VkPipelineViewportWScalingStateCreateInfoNV + = Word32 + + {-# NOINLINE vkViewportCount #-} + vkViewportCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineViewportWScalingStateCreateInfoNV, viewportCount}) + + {-# INLINE vkViewportCountByteOffset #-} + vkViewportCountByteOffset ~_ + = #{offset VkPipelineViewportWScalingStateCreateInfoNV, viewportCount} + + {-# INLINE readVkViewportCount #-} + readVkViewportCount p + = peekByteOff p #{offset VkPipelineViewportWScalingStateCreateInfoNV, viewportCount} + + {-# INLINE writeVkViewportCount #-} + writeVkViewportCount p + = pokeByteOff p #{offset VkPipelineViewportWScalingStateCreateInfoNV, viewportCount} + +instance {-# OVERLAPPING #-} + HasField "viewportCount" + VkPipelineViewportWScalingStateCreateInfoNV + where + type FieldType "viewportCount" + VkPipelineViewportWScalingStateCreateInfoNV + = Word32 + type FieldOptional "viewportCount" + VkPipelineViewportWScalingStateCreateInfoNV + = 'False -- ' closing tick for hsc2hs + type FieldOffset "viewportCount" + VkPipelineViewportWScalingStateCreateInfoNV + = + #{offset VkPipelineViewportWScalingStateCreateInfoNV, viewportCount} + type FieldIsArray "viewportCount" + VkPipelineViewportWScalingStateCreateInfoNV + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineViewportWScalingStateCreateInfoNV, viewportCount} + +instance CanReadField "viewportCount" + VkPipelineViewportWScalingStateCreateInfoNV + where + {-# INLINE getField #-} + getField = vkViewportCount + + {-# INLINE readField #-} + readField = readVkViewportCount + +instance CanWriteField "viewportCount" + VkPipelineViewportWScalingStateCreateInfoNV + where + {-# INLINE writeField #-} + writeField = writeVkViewportCount + +instance {-# OVERLAPPING #-} + HasVkPViewportWScalings VkPipelineViewportWScalingStateCreateInfoNV + where + type VkPViewportWScalingsMType + VkPipelineViewportWScalingStateCreateInfoNV + = Ptr VkViewportWScalingNV + + {-# NOINLINE vkPViewportWScalings #-} + vkPViewportWScalings x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPipelineViewportWScalingStateCreateInfoNV, pViewportWScalings}) + + {-# INLINE vkPViewportWScalingsByteOffset #-} + vkPViewportWScalingsByteOffset ~_ + = #{offset VkPipelineViewportWScalingStateCreateInfoNV, pViewportWScalings} + + {-# INLINE readVkPViewportWScalings #-} + readVkPViewportWScalings p + = peekByteOff p #{offset VkPipelineViewportWScalingStateCreateInfoNV, pViewportWScalings} + + {-# INLINE writeVkPViewportWScalings #-} + writeVkPViewportWScalings p + = pokeByteOff p #{offset VkPipelineViewportWScalingStateCreateInfoNV, pViewportWScalings} + +instance {-# OVERLAPPING #-} + HasField "pViewportWScalings" + VkPipelineViewportWScalingStateCreateInfoNV + where + type FieldType "pViewportWScalings" + VkPipelineViewportWScalingStateCreateInfoNV + = Ptr VkViewportWScalingNV + type FieldOptional "pViewportWScalings" + VkPipelineViewportWScalingStateCreateInfoNV + = 'False -- ' closing tick for hsc2hs + type FieldOffset "pViewportWScalings" + VkPipelineViewportWScalingStateCreateInfoNV + = + #{offset VkPipelineViewportWScalingStateCreateInfoNV, pViewportWScalings} + type FieldIsArray "pViewportWScalings" + VkPipelineViewportWScalingStateCreateInfoNV + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPipelineViewportWScalingStateCreateInfoNV, pViewportWScalings} + +instance CanReadField "pViewportWScalings" + VkPipelineViewportWScalingStateCreateInfoNV + where + {-# INLINE getField #-} + getField = vkPViewportWScalings + + {-# INLINE readField #-} + readField = readVkPViewportWScalings + +instance CanWriteField "pViewportWScalings" + VkPipelineViewportWScalingStateCreateInfoNV + where + {-# INLINE writeField #-} + writeField = writeVkPViewportWScalings + +instance Show VkPipelineViewportWScalingStateCreateInfoNV where + showsPrec d x + = showString "VkPipelineViewportWScalingStateCreateInfoNV {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkViewportWScalingEnable = " . + showsPrec d (vkViewportWScalingEnable x) . + showString ", " . + showString "vkViewportCount = " . + showsPrec d (vkViewportCount x) . + showString ", " . + showString "vkPViewportWScalings = " . + showsPrec d (vkPViewportWScalings x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkPresentInfoKHR.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkPresentInfoKHR.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkPresentInfoKHR.hsc @@ -0,0 +1,475 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkPresentInfoKHR + (VkPresentInfoKHR(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkResult (VkResult) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Handles (VkSemaphore, + VkSwapchainKHR) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkPresentInfoKHR { +-- > VkStructureType sType; +-- > const void* pNext; +-- > uint32_t waitSemaphoreCount; +-- > const VkSemaphore* pWaitSemaphores; +-- > uint32_t swapchainCount; +-- > const VkSwapchainKHR* pSwapchains; +-- > const uint32_t* pImageIndices; +-- > VkResult* pResults; +-- > } VkPresentInfoKHR; +-- +-- +data VkPresentInfoKHR = VkPresentInfoKHR## Addr## ByteArray## + +instance Eq VkPresentInfoKHR where + (VkPresentInfoKHR## a _) == x@(VkPresentInfoKHR## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkPresentInfoKHR where + (VkPresentInfoKHR## a _) `compare` x@(VkPresentInfoKHR## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkPresentInfoKHR where + sizeOf ~_ = #{size VkPresentInfoKHR} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkPresentInfoKHR} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkPresentInfoKHR where + unsafeAddr (VkPresentInfoKHR## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkPresentInfoKHR## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkPresentInfoKHR## (plusAddr## (byteArrayContents## b) off) b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkPresentInfoKHR where + type StructFields VkPresentInfoKHR = + '["sType", "pNext", "waitSemaphoreCount", "pWaitSemaphores", -- ' closing tick for hsc2hs + "swapchainCount", "pSwapchains", "pImageIndices", "pResults"] + type CUnionType VkPresentInfoKHR = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkPresentInfoKHR = 'False -- ' closing tick for hsc2hs + type StructExtends VkPresentInfoKHR = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkSType VkPresentInfoKHR where + type VkSTypeMType VkPresentInfoKHR = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPresentInfoKHR, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkPresentInfoKHR, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkPresentInfoKHR, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkPresentInfoKHR, sType} + +instance {-# OVERLAPPING #-} HasField "sType" VkPresentInfoKHR + where + type FieldType "sType" VkPresentInfoKHR = VkStructureType + type FieldOptional "sType" VkPresentInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkPresentInfoKHR = + #{offset VkPresentInfoKHR, sType} + type FieldIsArray "sType" VkPresentInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkPresentInfoKHR, sType} + +instance CanReadField "sType" VkPresentInfoKHR where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkPresentInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} HasVkPNext VkPresentInfoKHR where + type VkPNextMType VkPresentInfoKHR = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPresentInfoKHR, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkPresentInfoKHR, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkPresentInfoKHR, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkPresentInfoKHR, pNext} + +instance {-# OVERLAPPING #-} HasField "pNext" VkPresentInfoKHR + where + type FieldType "pNext" VkPresentInfoKHR = Ptr Void + type FieldOptional "pNext" VkPresentInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkPresentInfoKHR = + #{offset VkPresentInfoKHR, pNext} + type FieldIsArray "pNext" VkPresentInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkPresentInfoKHR, pNext} + +instance CanReadField "pNext" VkPresentInfoKHR where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkPresentInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkWaitSemaphoreCount VkPresentInfoKHR where + type VkWaitSemaphoreCountMType VkPresentInfoKHR = Word32 + + {-# NOINLINE vkWaitSemaphoreCount #-} + vkWaitSemaphoreCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPresentInfoKHR, waitSemaphoreCount}) + + {-# INLINE vkWaitSemaphoreCountByteOffset #-} + vkWaitSemaphoreCountByteOffset ~_ + = #{offset VkPresentInfoKHR, waitSemaphoreCount} + + {-# INLINE readVkWaitSemaphoreCount #-} + readVkWaitSemaphoreCount p + = peekByteOff p #{offset VkPresentInfoKHR, waitSemaphoreCount} + + {-# INLINE writeVkWaitSemaphoreCount #-} + writeVkWaitSemaphoreCount p + = pokeByteOff p #{offset VkPresentInfoKHR, waitSemaphoreCount} + +instance {-# OVERLAPPING #-} + HasField "waitSemaphoreCount" VkPresentInfoKHR where + type FieldType "waitSemaphoreCount" VkPresentInfoKHR = Word32 + type FieldOptional "waitSemaphoreCount" VkPresentInfoKHR = 'True -- ' closing tick for hsc2hs + type FieldOffset "waitSemaphoreCount" VkPresentInfoKHR = + #{offset VkPresentInfoKHR, waitSemaphoreCount} + type FieldIsArray "waitSemaphoreCount" VkPresentInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPresentInfoKHR, waitSemaphoreCount} + +instance CanReadField "waitSemaphoreCount" VkPresentInfoKHR where + {-# INLINE getField #-} + getField = vkWaitSemaphoreCount + + {-# INLINE readField #-} + readField = readVkWaitSemaphoreCount + +instance CanWriteField "waitSemaphoreCount" VkPresentInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkWaitSemaphoreCount + +instance {-# OVERLAPPING #-} HasVkPWaitSemaphores VkPresentInfoKHR + where + type VkPWaitSemaphoresMType VkPresentInfoKHR = Ptr VkSemaphore + + {-# NOINLINE vkPWaitSemaphores #-} + vkPWaitSemaphores x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPresentInfoKHR, pWaitSemaphores}) + + {-# INLINE vkPWaitSemaphoresByteOffset #-} + vkPWaitSemaphoresByteOffset ~_ + = #{offset VkPresentInfoKHR, pWaitSemaphores} + + {-# INLINE readVkPWaitSemaphores #-} + readVkPWaitSemaphores p + = peekByteOff p #{offset VkPresentInfoKHR, pWaitSemaphores} + + {-# INLINE writeVkPWaitSemaphores #-} + writeVkPWaitSemaphores p + = pokeByteOff p #{offset VkPresentInfoKHR, pWaitSemaphores} + +instance {-# OVERLAPPING #-} + HasField "pWaitSemaphores" VkPresentInfoKHR where + type FieldType "pWaitSemaphores" VkPresentInfoKHR = Ptr VkSemaphore + type FieldOptional "pWaitSemaphores" VkPresentInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "pWaitSemaphores" VkPresentInfoKHR = + #{offset VkPresentInfoKHR, pWaitSemaphores} + type FieldIsArray "pWaitSemaphores" VkPresentInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPresentInfoKHR, pWaitSemaphores} + +instance CanReadField "pWaitSemaphores" VkPresentInfoKHR where + {-# INLINE getField #-} + getField = vkPWaitSemaphores + + {-# INLINE readField #-} + readField = readVkPWaitSemaphores + +instance CanWriteField "pWaitSemaphores" VkPresentInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkPWaitSemaphores + +instance {-# OVERLAPPING #-} HasVkSwapchainCount VkPresentInfoKHR + where + type VkSwapchainCountMType VkPresentInfoKHR = Word32 + + {-# NOINLINE vkSwapchainCount #-} + vkSwapchainCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPresentInfoKHR, swapchainCount}) + + {-# INLINE vkSwapchainCountByteOffset #-} + vkSwapchainCountByteOffset ~_ + = #{offset VkPresentInfoKHR, swapchainCount} + + {-# INLINE readVkSwapchainCount #-} + readVkSwapchainCount p + = peekByteOff p #{offset VkPresentInfoKHR, swapchainCount} + + {-# INLINE writeVkSwapchainCount #-} + writeVkSwapchainCount p + = pokeByteOff p #{offset VkPresentInfoKHR, swapchainCount} + +instance {-# OVERLAPPING #-} + HasField "swapchainCount" VkPresentInfoKHR where + type FieldType "swapchainCount" VkPresentInfoKHR = Word32 + type FieldOptional "swapchainCount" VkPresentInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "swapchainCount" VkPresentInfoKHR = + #{offset VkPresentInfoKHR, swapchainCount} + type FieldIsArray "swapchainCount" VkPresentInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPresentInfoKHR, swapchainCount} + +instance CanReadField "swapchainCount" VkPresentInfoKHR where + {-# INLINE getField #-} + getField = vkSwapchainCount + + {-# INLINE readField #-} + readField = readVkSwapchainCount + +instance CanWriteField "swapchainCount" VkPresentInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkSwapchainCount + +instance {-# OVERLAPPING #-} HasVkPSwapchains VkPresentInfoKHR + where + type VkPSwapchainsMType VkPresentInfoKHR = Ptr VkSwapchainKHR + + {-# NOINLINE vkPSwapchains #-} + vkPSwapchains x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPresentInfoKHR, pSwapchains}) + + {-# INLINE vkPSwapchainsByteOffset #-} + vkPSwapchainsByteOffset ~_ + = #{offset VkPresentInfoKHR, pSwapchains} + + {-# INLINE readVkPSwapchains #-} + readVkPSwapchains p + = peekByteOff p #{offset VkPresentInfoKHR, pSwapchains} + + {-# INLINE writeVkPSwapchains #-} + writeVkPSwapchains p + = pokeByteOff p #{offset VkPresentInfoKHR, pSwapchains} + +instance {-# OVERLAPPING #-} + HasField "pSwapchains" VkPresentInfoKHR where + type FieldType "pSwapchains" VkPresentInfoKHR = Ptr VkSwapchainKHR + type FieldOptional "pSwapchains" VkPresentInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "pSwapchains" VkPresentInfoKHR = + #{offset VkPresentInfoKHR, pSwapchains} + type FieldIsArray "pSwapchains" VkPresentInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkPresentInfoKHR, pSwapchains} + +instance CanReadField "pSwapchains" VkPresentInfoKHR where + {-# INLINE getField #-} + getField = vkPSwapchains + + {-# INLINE readField #-} + readField = readVkPSwapchains + +instance CanWriteField "pSwapchains" VkPresentInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkPSwapchains + +instance {-# OVERLAPPING #-} HasVkPImageIndices VkPresentInfoKHR + where + type VkPImageIndicesMType VkPresentInfoKHR = Ptr Word32 + + {-# NOINLINE vkPImageIndices #-} + vkPImageIndices x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPresentInfoKHR, pImageIndices}) + + {-# INLINE vkPImageIndicesByteOffset #-} + vkPImageIndicesByteOffset ~_ + = #{offset VkPresentInfoKHR, pImageIndices} + + {-# INLINE readVkPImageIndices #-} + readVkPImageIndices p + = peekByteOff p #{offset VkPresentInfoKHR, pImageIndices} + + {-# INLINE writeVkPImageIndices #-} + writeVkPImageIndices p + = pokeByteOff p #{offset VkPresentInfoKHR, pImageIndices} + +instance {-# OVERLAPPING #-} + HasField "pImageIndices" VkPresentInfoKHR where + type FieldType "pImageIndices" VkPresentInfoKHR = Ptr Word32 + type FieldOptional "pImageIndices" VkPresentInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "pImageIndices" VkPresentInfoKHR = + #{offset VkPresentInfoKHR, pImageIndices} + type FieldIsArray "pImageIndices" VkPresentInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkPresentInfoKHR, pImageIndices} + +instance CanReadField "pImageIndices" VkPresentInfoKHR where + {-# INLINE getField #-} + getField = vkPImageIndices + + {-# INLINE readField #-} + readField = readVkPImageIndices + +instance CanWriteField "pImageIndices" VkPresentInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkPImageIndices + +instance {-# OVERLAPPING #-} HasVkPResults VkPresentInfoKHR where + type VkPResultsMType VkPresentInfoKHR = Ptr VkResult + + {-# NOINLINE vkPResults #-} + vkPResults x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPresentInfoKHR, pResults}) + + {-# INLINE vkPResultsByteOffset #-} + vkPResultsByteOffset ~_ + = #{offset VkPresentInfoKHR, pResults} + + {-# INLINE readVkPResults #-} + readVkPResults p + = peekByteOff p #{offset VkPresentInfoKHR, pResults} + + {-# INLINE writeVkPResults #-} + writeVkPResults p + = pokeByteOff p #{offset VkPresentInfoKHR, pResults} + +instance {-# OVERLAPPING #-} HasField "pResults" VkPresentInfoKHR + where + type FieldType "pResults" VkPresentInfoKHR = Ptr VkResult + type FieldOptional "pResults" VkPresentInfoKHR = 'True -- ' closing tick for hsc2hs + type FieldOffset "pResults" VkPresentInfoKHR = + #{offset VkPresentInfoKHR, pResults} + type FieldIsArray "pResults" VkPresentInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkPresentInfoKHR, pResults} + +instance CanReadField "pResults" VkPresentInfoKHR where + {-# INLINE getField #-} + getField = vkPResults + + {-# INLINE readField #-} + readField = readVkPResults + +instance CanWriteField "pResults" VkPresentInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkPResults + +instance Show VkPresentInfoKHR where + showsPrec d x + = showString "VkPresentInfoKHR {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkWaitSemaphoreCount = " . + showsPrec d (vkWaitSemaphoreCount x) . + showString ", " . + showString "vkPWaitSemaphores = " . + showsPrec d (vkPWaitSemaphores x) . + showString ", " . + showString "vkSwapchainCount = " . + showsPrec d (vkSwapchainCount x) . + showString ", " . + showString "vkPSwapchains = " . + showsPrec d (vkPSwapchains x) . + showString ", " . + showString "vkPImageIndices = " . + showsPrec d (vkPImageIndices x) . + showString ", " . + showString "vkPResults = " . + showsPrec d (vkPResults x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkPresentRegionKHR.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkPresentRegionKHR.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkPresentRegionKHR.hsc @@ -0,0 +1,173 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkPresentRegionKHR + (VkPresentRegionKHR(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Struct.VkRectLayerKHR (VkRectLayerKHR) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkPresentRegionKHR { +-- > uint32_t rectangleCount; +-- > const VkRectLayerKHR* pRectangles; +-- > } VkPresentRegionKHR; +-- +-- +data VkPresentRegionKHR = VkPresentRegionKHR## Addr## ByteArray## + +instance Eq VkPresentRegionKHR where + (VkPresentRegionKHR## a _) == x@(VkPresentRegionKHR## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkPresentRegionKHR where + (VkPresentRegionKHR## a _) `compare` x@(VkPresentRegionKHR## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkPresentRegionKHR where + sizeOf ~_ = #{size VkPresentRegionKHR} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkPresentRegionKHR} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkPresentRegionKHR where + unsafeAddr (VkPresentRegionKHR## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkPresentRegionKHR## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkPresentRegionKHR## (plusAddr## (byteArrayContents## b) off) b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkPresentRegionKHR where + type StructFields VkPresentRegionKHR = + '["rectangleCount", "pRectangles"] -- ' closing tick for hsc2hs + type CUnionType VkPresentRegionKHR = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkPresentRegionKHR = 'False -- ' closing tick for hsc2hs + type StructExtends VkPresentRegionKHR = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkRectangleCount VkPresentRegionKHR + where + type VkRectangleCountMType VkPresentRegionKHR = Word32 + + {-# NOINLINE vkRectangleCount #-} + vkRectangleCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPresentRegionKHR, rectangleCount}) + + {-# INLINE vkRectangleCountByteOffset #-} + vkRectangleCountByteOffset ~_ + = #{offset VkPresentRegionKHR, rectangleCount} + + {-# INLINE readVkRectangleCount #-} + readVkRectangleCount p + = peekByteOff p #{offset VkPresentRegionKHR, rectangleCount} + + {-# INLINE writeVkRectangleCount #-} + writeVkRectangleCount p + = pokeByteOff p #{offset VkPresentRegionKHR, rectangleCount} + +instance {-# OVERLAPPING #-} + HasField "rectangleCount" VkPresentRegionKHR where + type FieldType "rectangleCount" VkPresentRegionKHR = Word32 + type FieldOptional "rectangleCount" VkPresentRegionKHR = 'True -- ' closing tick for hsc2hs + type FieldOffset "rectangleCount" VkPresentRegionKHR = + #{offset VkPresentRegionKHR, rectangleCount} + type FieldIsArray "rectangleCount" VkPresentRegionKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPresentRegionKHR, rectangleCount} + +instance CanReadField "rectangleCount" VkPresentRegionKHR where + {-# INLINE getField #-} + getField = vkRectangleCount + + {-# INLINE readField #-} + readField = readVkRectangleCount + +instance CanWriteField "rectangleCount" VkPresentRegionKHR where + {-# INLINE writeField #-} + writeField = writeVkRectangleCount + +instance {-# OVERLAPPING #-} HasVkPRectangles VkPresentRegionKHR + where + type VkPRectanglesMType VkPresentRegionKHR = Ptr VkRectLayerKHR + + {-# NOINLINE vkPRectangles #-} + vkPRectangles x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPresentRegionKHR, pRectangles}) + + {-# INLINE vkPRectanglesByteOffset #-} + vkPRectanglesByteOffset ~_ + = #{offset VkPresentRegionKHR, pRectangles} + + {-# INLINE readVkPRectangles #-} + readVkPRectangles p + = peekByteOff p #{offset VkPresentRegionKHR, pRectangles} + + {-# INLINE writeVkPRectangles #-} + writeVkPRectangles p + = pokeByteOff p #{offset VkPresentRegionKHR, pRectangles} + +instance {-# OVERLAPPING #-} + HasField "pRectangles" VkPresentRegionKHR where + type FieldType "pRectangles" VkPresentRegionKHR = + Ptr VkRectLayerKHR + type FieldOptional "pRectangles" VkPresentRegionKHR = 'True -- ' closing tick for hsc2hs + type FieldOffset "pRectangles" VkPresentRegionKHR = + #{offset VkPresentRegionKHR, pRectangles} + type FieldIsArray "pRectangles" VkPresentRegionKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkPresentRegionKHR, pRectangles} + +instance CanReadField "pRectangles" VkPresentRegionKHR where + {-# INLINE getField #-} + getField = vkPRectangles + + {-# INLINE readField #-} + readField = readVkPRectangles + +instance CanWriteField "pRectangles" VkPresentRegionKHR where + {-# INLINE writeField #-} + writeField = writeVkPRectangles + +instance Show VkPresentRegionKHR where + showsPrec d x + = showString "VkPresentRegionKHR {" . + showString "vkRectangleCount = " . + showsPrec d (vkRectangleCount x) . + showString ", " . + showString "vkPRectangles = " . + showsPrec d (vkPRectangles x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkPresentRegionsKHR.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkPresentRegionsKHR.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkPresentRegionsKHR.hsc @@ -0,0 +1,273 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkPresentRegionsKHR + (VkPresentRegionsKHR(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Struct.VkPresentInfoKHR (VkPresentInfoKHR) +import Graphics.Vulkan.Types.Struct.VkPresentRegionKHR (VkPresentRegionKHR) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkPresentRegionsKHR { +-- > VkStructureType sType; +-- > const void* pNext; +-- > uint32_t swapchainCount; +-- > const VkPresentRegionKHR* pRegions; +-- > } VkPresentRegionsKHR; +-- +-- +data VkPresentRegionsKHR = VkPresentRegionsKHR## Addr## ByteArray## + +instance Eq VkPresentRegionsKHR where + (VkPresentRegionsKHR## a _) == x@(VkPresentRegionsKHR## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkPresentRegionsKHR where + (VkPresentRegionsKHR## a _) `compare` x@(VkPresentRegionsKHR## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkPresentRegionsKHR where + sizeOf ~_ = #{size VkPresentRegionsKHR} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkPresentRegionsKHR} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkPresentRegionsKHR where + unsafeAddr (VkPresentRegionsKHR## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkPresentRegionsKHR## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkPresentRegionsKHR## (plusAddr## (byteArrayContents## b) off) b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkPresentRegionsKHR where + type StructFields VkPresentRegionsKHR = + '["sType", "pNext", "swapchainCount", "pRegions"] -- ' closing tick for hsc2hs + type CUnionType VkPresentRegionsKHR = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkPresentRegionsKHR = 'False -- ' closing tick for hsc2hs + type StructExtends VkPresentRegionsKHR = '[VkPresentInfoKHR] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkSType VkPresentRegionsKHR where + type VkSTypeMType VkPresentRegionsKHR = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPresentRegionsKHR, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkPresentRegionsKHR, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkPresentRegionsKHR, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkPresentRegionsKHR, sType} + +instance {-# OVERLAPPING #-} HasField "sType" VkPresentRegionsKHR + where + type FieldType "sType" VkPresentRegionsKHR = VkStructureType + type FieldOptional "sType" VkPresentRegionsKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkPresentRegionsKHR = + #{offset VkPresentRegionsKHR, sType} + type FieldIsArray "sType" VkPresentRegionsKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkPresentRegionsKHR, sType} + +instance CanReadField "sType" VkPresentRegionsKHR where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkPresentRegionsKHR where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} HasVkPNext VkPresentRegionsKHR where + type VkPNextMType VkPresentRegionsKHR = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPresentRegionsKHR, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkPresentRegionsKHR, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkPresentRegionsKHR, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkPresentRegionsKHR, pNext} + +instance {-# OVERLAPPING #-} HasField "pNext" VkPresentRegionsKHR + where + type FieldType "pNext" VkPresentRegionsKHR = Ptr Void + type FieldOptional "pNext" VkPresentRegionsKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkPresentRegionsKHR = + #{offset VkPresentRegionsKHR, pNext} + type FieldIsArray "pNext" VkPresentRegionsKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkPresentRegionsKHR, pNext} + +instance CanReadField "pNext" VkPresentRegionsKHR where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkPresentRegionsKHR where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkSwapchainCount VkPresentRegionsKHR where + type VkSwapchainCountMType VkPresentRegionsKHR = Word32 + + {-# NOINLINE vkSwapchainCount #-} + vkSwapchainCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPresentRegionsKHR, swapchainCount}) + + {-# INLINE vkSwapchainCountByteOffset #-} + vkSwapchainCountByteOffset ~_ + = #{offset VkPresentRegionsKHR, swapchainCount} + + {-# INLINE readVkSwapchainCount #-} + readVkSwapchainCount p + = peekByteOff p #{offset VkPresentRegionsKHR, swapchainCount} + + {-# INLINE writeVkSwapchainCount #-} + writeVkSwapchainCount p + = pokeByteOff p #{offset VkPresentRegionsKHR, swapchainCount} + +instance {-# OVERLAPPING #-} + HasField "swapchainCount" VkPresentRegionsKHR where + type FieldType "swapchainCount" VkPresentRegionsKHR = Word32 + type FieldOptional "swapchainCount" VkPresentRegionsKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "swapchainCount" VkPresentRegionsKHR = + #{offset VkPresentRegionsKHR, swapchainCount} + type FieldIsArray "swapchainCount" VkPresentRegionsKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPresentRegionsKHR, swapchainCount} + +instance CanReadField "swapchainCount" VkPresentRegionsKHR where + {-# INLINE getField #-} + getField = vkSwapchainCount + + {-# INLINE readField #-} + readField = readVkSwapchainCount + +instance CanWriteField "swapchainCount" VkPresentRegionsKHR where + {-# INLINE writeField #-} + writeField = writeVkSwapchainCount + +instance {-# OVERLAPPING #-} HasVkPRegions VkPresentRegionsKHR + where + type VkPRegionsMType VkPresentRegionsKHR = Ptr VkPresentRegionKHR + + {-# NOINLINE vkPRegions #-} + vkPRegions x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPresentRegionsKHR, pRegions}) + + {-# INLINE vkPRegionsByteOffset #-} + vkPRegionsByteOffset ~_ + = #{offset VkPresentRegionsKHR, pRegions} + + {-# INLINE readVkPRegions #-} + readVkPRegions p + = peekByteOff p #{offset VkPresentRegionsKHR, pRegions} + + {-# INLINE writeVkPRegions #-} + writeVkPRegions p + = pokeByteOff p #{offset VkPresentRegionsKHR, pRegions} + +instance {-# OVERLAPPING #-} + HasField "pRegions" VkPresentRegionsKHR where + type FieldType "pRegions" VkPresentRegionsKHR = + Ptr VkPresentRegionKHR + type FieldOptional "pRegions" VkPresentRegionsKHR = 'True -- ' closing tick for hsc2hs + type FieldOffset "pRegions" VkPresentRegionsKHR = + #{offset VkPresentRegionsKHR, pRegions} + type FieldIsArray "pRegions" VkPresentRegionsKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkPresentRegionsKHR, pRegions} + +instance CanReadField "pRegions" VkPresentRegionsKHR where + {-# INLINE getField #-} + getField = vkPRegions + + {-# INLINE readField #-} + readField = readVkPRegions + +instance CanWriteField "pRegions" VkPresentRegionsKHR where + {-# INLINE writeField #-} + writeField = writeVkPRegions + +instance Show VkPresentRegionsKHR where + showsPrec d x + = showString "VkPresentRegionsKHR {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkSwapchainCount = " . + showsPrec d (vkSwapchainCount x) . + showString ", " . + showString "vkPRegions = " . + showsPrec d (vkPRegions x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkPresentTimeGOOGLE.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkPresentTimeGOOGLE.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkPresentTimeGOOGLE.hsc @@ -0,0 +1,174 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkPresentTimeGOOGLE + (VkPresentTimeGOOGLE(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkPresentTimeGOOGLE { +-- > uint32_t presentID; +-- > uint64_t desiredPresentTime; +-- > } VkPresentTimeGOOGLE; +-- +-- +data VkPresentTimeGOOGLE = VkPresentTimeGOOGLE## Addr## ByteArray## + +instance Eq VkPresentTimeGOOGLE where + (VkPresentTimeGOOGLE## a _) == x@(VkPresentTimeGOOGLE## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkPresentTimeGOOGLE where + (VkPresentTimeGOOGLE## a _) `compare` x@(VkPresentTimeGOOGLE## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkPresentTimeGOOGLE where + sizeOf ~_ = #{size VkPresentTimeGOOGLE} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkPresentTimeGOOGLE} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkPresentTimeGOOGLE where + unsafeAddr (VkPresentTimeGOOGLE## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkPresentTimeGOOGLE## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkPresentTimeGOOGLE## (plusAddr## (byteArrayContents## b) off) b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkPresentTimeGOOGLE where + type StructFields VkPresentTimeGOOGLE = + '["presentID", "desiredPresentTime"] -- ' closing tick for hsc2hs + type CUnionType VkPresentTimeGOOGLE = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkPresentTimeGOOGLE = 'False -- ' closing tick for hsc2hs + type StructExtends VkPresentTimeGOOGLE = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkPresentID VkPresentTimeGOOGLE + where + type VkPresentIDMType VkPresentTimeGOOGLE = Word32 + + {-# NOINLINE vkPresentID #-} + vkPresentID x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPresentTimeGOOGLE, presentID}) + + {-# INLINE vkPresentIDByteOffset #-} + vkPresentIDByteOffset ~_ + = #{offset VkPresentTimeGOOGLE, presentID} + + {-# INLINE readVkPresentID #-} + readVkPresentID p + = peekByteOff p #{offset VkPresentTimeGOOGLE, presentID} + + {-# INLINE writeVkPresentID #-} + writeVkPresentID p + = pokeByteOff p #{offset VkPresentTimeGOOGLE, presentID} + +instance {-# OVERLAPPING #-} + HasField "presentID" VkPresentTimeGOOGLE where + type FieldType "presentID" VkPresentTimeGOOGLE = Word32 + type FieldOptional "presentID" VkPresentTimeGOOGLE = 'False -- ' closing tick for hsc2hs + type FieldOffset "presentID" VkPresentTimeGOOGLE = + #{offset VkPresentTimeGOOGLE, presentID} + type FieldIsArray "presentID" VkPresentTimeGOOGLE = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkPresentTimeGOOGLE, presentID} + +instance CanReadField "presentID" VkPresentTimeGOOGLE where + {-# INLINE getField #-} + getField = vkPresentID + + {-# INLINE readField #-} + readField = readVkPresentID + +instance CanWriteField "presentID" VkPresentTimeGOOGLE where + {-# INLINE writeField #-} + writeField = writeVkPresentID + +instance {-# OVERLAPPING #-} + HasVkDesiredPresentTime VkPresentTimeGOOGLE where + type VkDesiredPresentTimeMType VkPresentTimeGOOGLE = Word64 + + {-# NOINLINE vkDesiredPresentTime #-} + vkDesiredPresentTime x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPresentTimeGOOGLE, desiredPresentTime}) + + {-# INLINE vkDesiredPresentTimeByteOffset #-} + vkDesiredPresentTimeByteOffset ~_ + = #{offset VkPresentTimeGOOGLE, desiredPresentTime} + + {-# INLINE readVkDesiredPresentTime #-} + readVkDesiredPresentTime p + = peekByteOff p #{offset VkPresentTimeGOOGLE, desiredPresentTime} + + {-# INLINE writeVkDesiredPresentTime #-} + writeVkDesiredPresentTime p + = pokeByteOff p #{offset VkPresentTimeGOOGLE, desiredPresentTime} + +instance {-# OVERLAPPING #-} + HasField "desiredPresentTime" VkPresentTimeGOOGLE where + type FieldType "desiredPresentTime" VkPresentTimeGOOGLE = Word64 + type FieldOptional "desiredPresentTime" VkPresentTimeGOOGLE = + 'False -- ' closing tick for hsc2hs + type FieldOffset "desiredPresentTime" VkPresentTimeGOOGLE = + #{offset VkPresentTimeGOOGLE, desiredPresentTime} + type FieldIsArray "desiredPresentTime" VkPresentTimeGOOGLE = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPresentTimeGOOGLE, desiredPresentTime} + +instance CanReadField "desiredPresentTime" VkPresentTimeGOOGLE + where + {-# INLINE getField #-} + getField = vkDesiredPresentTime + + {-# INLINE readField #-} + readField = readVkDesiredPresentTime + +instance CanWriteField "desiredPresentTime" VkPresentTimeGOOGLE + where + {-# INLINE writeField #-} + writeField = writeVkDesiredPresentTime + +instance Show VkPresentTimeGOOGLE where + showsPrec d x + = showString "VkPresentTimeGOOGLE {" . + showString "vkPresentID = " . + showsPrec d (vkPresentID x) . + showString ", " . + showString "vkDesiredPresentTime = " . + showsPrec d (vkDesiredPresentTime x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkPresentTimesInfoGOOGLE.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkPresentTimesInfoGOOGLE.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkPresentTimesInfoGOOGLE.hsc @@ -0,0 +1,282 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkPresentTimesInfoGOOGLE + (VkPresentTimesInfoGOOGLE(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Struct.VkPresentInfoKHR (VkPresentInfoKHR) +import Graphics.Vulkan.Types.Struct.VkPresentTimeGOOGLE (VkPresentTimeGOOGLE) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkPresentTimesInfoGOOGLE { +-- > VkStructureType sType; +-- > const void* pNext; +-- > uint32_t swapchainCount; +-- > const VkPresentTimeGOOGLE* pTimes; +-- > } VkPresentTimesInfoGOOGLE; +-- +-- +data VkPresentTimesInfoGOOGLE = VkPresentTimesInfoGOOGLE## Addr## + ByteArray## + +instance Eq VkPresentTimesInfoGOOGLE where + (VkPresentTimesInfoGOOGLE## a _) == + x@(VkPresentTimesInfoGOOGLE## b _) = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkPresentTimesInfoGOOGLE where + (VkPresentTimesInfoGOOGLE## a _) `compare` + x@(VkPresentTimesInfoGOOGLE## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkPresentTimesInfoGOOGLE where + sizeOf ~_ = #{size VkPresentTimesInfoGOOGLE} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkPresentTimesInfoGOOGLE} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkPresentTimesInfoGOOGLE where + unsafeAddr (VkPresentTimesInfoGOOGLE## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkPresentTimesInfoGOOGLE## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkPresentTimesInfoGOOGLE## (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkPresentTimesInfoGOOGLE where + type StructFields VkPresentTimesInfoGOOGLE = + '["sType", "pNext", "swapchainCount", "pTimes"] -- ' closing tick for hsc2hs + type CUnionType VkPresentTimesInfoGOOGLE = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkPresentTimesInfoGOOGLE = 'False -- ' closing tick for hsc2hs + type StructExtends VkPresentTimesInfoGOOGLE = '[VkPresentInfoKHR] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkSType VkPresentTimesInfoGOOGLE + where + type VkSTypeMType VkPresentTimesInfoGOOGLE = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPresentTimesInfoGOOGLE, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkPresentTimesInfoGOOGLE, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkPresentTimesInfoGOOGLE, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkPresentTimesInfoGOOGLE, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkPresentTimesInfoGOOGLE where + type FieldType "sType" VkPresentTimesInfoGOOGLE = VkStructureType + type FieldOptional "sType" VkPresentTimesInfoGOOGLE = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkPresentTimesInfoGOOGLE = + #{offset VkPresentTimesInfoGOOGLE, sType} + type FieldIsArray "sType" VkPresentTimesInfoGOOGLE = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkPresentTimesInfoGOOGLE, sType} + +instance CanReadField "sType" VkPresentTimesInfoGOOGLE where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkPresentTimesInfoGOOGLE where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} HasVkPNext VkPresentTimesInfoGOOGLE + where + type VkPNextMType VkPresentTimesInfoGOOGLE = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPresentTimesInfoGOOGLE, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkPresentTimesInfoGOOGLE, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkPresentTimesInfoGOOGLE, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkPresentTimesInfoGOOGLE, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkPresentTimesInfoGOOGLE where + type FieldType "pNext" VkPresentTimesInfoGOOGLE = Ptr Void + type FieldOptional "pNext" VkPresentTimesInfoGOOGLE = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkPresentTimesInfoGOOGLE = + #{offset VkPresentTimesInfoGOOGLE, pNext} + type FieldIsArray "pNext" VkPresentTimesInfoGOOGLE = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkPresentTimesInfoGOOGLE, pNext} + +instance CanReadField "pNext" VkPresentTimesInfoGOOGLE where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkPresentTimesInfoGOOGLE where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkSwapchainCount VkPresentTimesInfoGOOGLE where + type VkSwapchainCountMType VkPresentTimesInfoGOOGLE = Word32 + + {-# NOINLINE vkSwapchainCount #-} + vkSwapchainCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPresentTimesInfoGOOGLE, swapchainCount}) + + {-# INLINE vkSwapchainCountByteOffset #-} + vkSwapchainCountByteOffset ~_ + = #{offset VkPresentTimesInfoGOOGLE, swapchainCount} + + {-# INLINE readVkSwapchainCount #-} + readVkSwapchainCount p + = peekByteOff p #{offset VkPresentTimesInfoGOOGLE, swapchainCount} + + {-# INLINE writeVkSwapchainCount #-} + writeVkSwapchainCount p + = pokeByteOff p #{offset VkPresentTimesInfoGOOGLE, swapchainCount} + +instance {-# OVERLAPPING #-} + HasField "swapchainCount" VkPresentTimesInfoGOOGLE where + type FieldType "swapchainCount" VkPresentTimesInfoGOOGLE = Word32 + type FieldOptional "swapchainCount" VkPresentTimesInfoGOOGLE = + 'False -- ' closing tick for hsc2hs + type FieldOffset "swapchainCount" VkPresentTimesInfoGOOGLE = + #{offset VkPresentTimesInfoGOOGLE, swapchainCount} + type FieldIsArray "swapchainCount" VkPresentTimesInfoGOOGLE = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPresentTimesInfoGOOGLE, swapchainCount} + +instance CanReadField "swapchainCount" VkPresentTimesInfoGOOGLE + where + {-# INLINE getField #-} + getField = vkSwapchainCount + + {-# INLINE readField #-} + readField = readVkSwapchainCount + +instance CanWriteField "swapchainCount" VkPresentTimesInfoGOOGLE + where + {-# INLINE writeField #-} + writeField = writeVkSwapchainCount + +instance {-# OVERLAPPING #-} HasVkPTimes VkPresentTimesInfoGOOGLE + where + type VkPTimesMType VkPresentTimesInfoGOOGLE = + Ptr VkPresentTimeGOOGLE + + {-# NOINLINE vkPTimes #-} + vkPTimes x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPresentTimesInfoGOOGLE, pTimes}) + + {-# INLINE vkPTimesByteOffset #-} + vkPTimesByteOffset ~_ + = #{offset VkPresentTimesInfoGOOGLE, pTimes} + + {-# INLINE readVkPTimes #-} + readVkPTimes p + = peekByteOff p #{offset VkPresentTimesInfoGOOGLE, pTimes} + + {-# INLINE writeVkPTimes #-} + writeVkPTimes p + = pokeByteOff p #{offset VkPresentTimesInfoGOOGLE, pTimes} + +instance {-# OVERLAPPING #-} + HasField "pTimes" VkPresentTimesInfoGOOGLE where + type FieldType "pTimes" VkPresentTimesInfoGOOGLE = + Ptr VkPresentTimeGOOGLE + type FieldOptional "pTimes" VkPresentTimesInfoGOOGLE = 'True -- ' closing tick for hsc2hs + type FieldOffset "pTimes" VkPresentTimesInfoGOOGLE = + #{offset VkPresentTimesInfoGOOGLE, pTimes} + type FieldIsArray "pTimes" VkPresentTimesInfoGOOGLE = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkPresentTimesInfoGOOGLE, pTimes} + +instance CanReadField "pTimes" VkPresentTimesInfoGOOGLE where + {-# INLINE getField #-} + getField = vkPTimes + + {-# INLINE readField #-} + readField = readVkPTimes + +instance CanWriteField "pTimes" VkPresentTimesInfoGOOGLE where + {-# INLINE writeField #-} + writeField = writeVkPTimes + +instance Show VkPresentTimesInfoGOOGLE where + showsPrec d x + = showString "VkPresentTimesInfoGOOGLE {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkSwapchainCount = " . + showsPrec d (vkSwapchainCount x) . + showString ", " . + showString "vkPTimes = " . showsPrec d (vkPTimes x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkPushConstantRange.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkPushConstantRange.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkPushConstantRange.hsc @@ -0,0 +1,219 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkPushConstantRange + (VkPushConstantRange(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkShaderStageFlags (VkShaderStageFlags) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkPushConstantRange { +-- > VkShaderStageFlags stageFlags; +-- > uint32_t offset; +-- > uint32_t size; +-- > } VkPushConstantRange; +-- +-- +data VkPushConstantRange = VkPushConstantRange## Addr## ByteArray## + +instance Eq VkPushConstantRange where + (VkPushConstantRange## a _) == x@(VkPushConstantRange## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkPushConstantRange where + (VkPushConstantRange## a _) `compare` x@(VkPushConstantRange## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkPushConstantRange where + sizeOf ~_ = #{size VkPushConstantRange} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkPushConstantRange} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkPushConstantRange where + unsafeAddr (VkPushConstantRange## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkPushConstantRange## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkPushConstantRange## (plusAddr## (byteArrayContents## b) off) b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkPushConstantRange where + type StructFields VkPushConstantRange = + '["stageFlags", "offset", "size"] -- ' closing tick for hsc2hs + type CUnionType VkPushConstantRange = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkPushConstantRange = 'False -- ' closing tick for hsc2hs + type StructExtends VkPushConstantRange = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkStageFlags VkPushConstantRange + where + type VkStageFlagsMType VkPushConstantRange = VkShaderStageFlags + + {-# NOINLINE vkStageFlags #-} + vkStageFlags x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPushConstantRange, stageFlags}) + + {-# INLINE vkStageFlagsByteOffset #-} + vkStageFlagsByteOffset ~_ + = #{offset VkPushConstantRange, stageFlags} + + {-# INLINE readVkStageFlags #-} + readVkStageFlags p + = peekByteOff p #{offset VkPushConstantRange, stageFlags} + + {-# INLINE writeVkStageFlags #-} + writeVkStageFlags p + = pokeByteOff p #{offset VkPushConstantRange, stageFlags} + +instance {-# OVERLAPPING #-} + HasField "stageFlags" VkPushConstantRange where + type FieldType "stageFlags" VkPushConstantRange = + VkShaderStageFlags + type FieldOptional "stageFlags" VkPushConstantRange = 'False -- ' closing tick for hsc2hs + type FieldOffset "stageFlags" VkPushConstantRange = + #{offset VkPushConstantRange, stageFlags} + type FieldIsArray "stageFlags" VkPushConstantRange = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkPushConstantRange, stageFlags} + +instance CanReadField "stageFlags" VkPushConstantRange where + {-# INLINE getField #-} + getField = vkStageFlags + + {-# INLINE readField #-} + readField = readVkStageFlags + +instance CanWriteField "stageFlags" VkPushConstantRange where + {-# INLINE writeField #-} + writeField = writeVkStageFlags + +instance {-# OVERLAPPING #-} HasVkOffset VkPushConstantRange where + type VkOffsetMType VkPushConstantRange = Word32 + + {-# NOINLINE vkOffset #-} + vkOffset x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPushConstantRange, offset}) + + {-# INLINE vkOffsetByteOffset #-} + vkOffsetByteOffset ~_ + = #{offset VkPushConstantRange, offset} + + {-# INLINE readVkOffset #-} + readVkOffset p + = peekByteOff p #{offset VkPushConstantRange, offset} + + {-# INLINE writeVkOffset #-} + writeVkOffset p + = pokeByteOff p #{offset VkPushConstantRange, offset} + +instance {-# OVERLAPPING #-} HasField "offset" VkPushConstantRange + where + type FieldType "offset" VkPushConstantRange = Word32 + type FieldOptional "offset" VkPushConstantRange = 'False -- ' closing tick for hsc2hs + type FieldOffset "offset" VkPushConstantRange = + #{offset VkPushConstantRange, offset} + type FieldIsArray "offset" VkPushConstantRange = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkPushConstantRange, offset} + +instance CanReadField "offset" VkPushConstantRange where + {-# INLINE getField #-} + getField = vkOffset + + {-# INLINE readField #-} + readField = readVkOffset + +instance CanWriteField "offset" VkPushConstantRange where + {-# INLINE writeField #-} + writeField = writeVkOffset + +instance {-# OVERLAPPING #-} HasVkSize VkPushConstantRange where + type VkSizeMType VkPushConstantRange = Word32 + + {-# NOINLINE vkSize #-} + vkSize x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkPushConstantRange, size}) + + {-# INLINE vkSizeByteOffset #-} + vkSizeByteOffset ~_ + = #{offset VkPushConstantRange, size} + + {-# INLINE readVkSize #-} + readVkSize p + = peekByteOff p #{offset VkPushConstantRange, size} + + {-# INLINE writeVkSize #-} + writeVkSize p + = pokeByteOff p #{offset VkPushConstantRange, size} + +instance {-# OVERLAPPING #-} HasField "size" VkPushConstantRange + where + type FieldType "size" VkPushConstantRange = Word32 + type FieldOptional "size" VkPushConstantRange = 'False -- ' closing tick for hsc2hs + type FieldOffset "size" VkPushConstantRange = + #{offset VkPushConstantRange, size} + type FieldIsArray "size" VkPushConstantRange = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkPushConstantRange, size} + +instance CanReadField "size" VkPushConstantRange where + {-# INLINE getField #-} + getField = vkSize + + {-# INLINE readField #-} + readField = readVkSize + +instance CanWriteField "size" VkPushConstantRange where + {-# INLINE writeField #-} + writeField = writeVkSize + +instance Show VkPushConstantRange where + showsPrec d x + = showString "VkPushConstantRange {" . + showString "vkStageFlags = " . + showsPrec d (vkStageFlags x) . + showString ", " . + showString "vkOffset = " . + showsPrec d (vkOffset x) . + showString ", " . + showString "vkSize = " . showsPrec d (vkSize x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkQueryPoolCreateInfo.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkQueryPoolCreateInfo.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkQueryPoolCreateInfo.hsc @@ -0,0 +1,383 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkQueryPoolCreateInfo + (VkQueryPoolCreateInfo(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Bitmasks (VkQueryPoolCreateFlags) +import Graphics.Vulkan.Types.Enum.VkQueryPipelineStatisticFlags (VkQueryPipelineStatisticFlags) +import Graphics.Vulkan.Types.Enum.VkQueryType (VkQueryType) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkQueryPoolCreateInfo { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkQueryPoolCreateFlags flags; +-- > VkQueryType queryType; +-- > uint32_t queryCount; +-- > VkQueryPipelineStatisticFlags pipelineStatistics; +-- > } VkQueryPoolCreateInfo; +-- +-- +data VkQueryPoolCreateInfo = VkQueryPoolCreateInfo## Addr## + ByteArray## + +instance Eq VkQueryPoolCreateInfo where + (VkQueryPoolCreateInfo## a _) == x@(VkQueryPoolCreateInfo## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkQueryPoolCreateInfo where + (VkQueryPoolCreateInfo## a _) `compare` + x@(VkQueryPoolCreateInfo## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkQueryPoolCreateInfo where + sizeOf ~_ = #{size VkQueryPoolCreateInfo} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkQueryPoolCreateInfo} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkQueryPoolCreateInfo where + unsafeAddr (VkQueryPoolCreateInfo## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkQueryPoolCreateInfo## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkQueryPoolCreateInfo## (plusAddr## (byteArrayContents## b) off) b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkQueryPoolCreateInfo where + type StructFields VkQueryPoolCreateInfo = + '["sType", "pNext", "flags", "queryType", "queryCount", -- ' closing tick for hsc2hs + "pipelineStatistics"] + type CUnionType VkQueryPoolCreateInfo = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkQueryPoolCreateInfo = 'False -- ' closing tick for hsc2hs + type StructExtends VkQueryPoolCreateInfo = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkSType VkQueryPoolCreateInfo where + type VkSTypeMType VkQueryPoolCreateInfo = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkQueryPoolCreateInfo, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkQueryPoolCreateInfo, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkQueryPoolCreateInfo, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkQueryPoolCreateInfo, sType} + +instance {-# OVERLAPPING #-} HasField "sType" VkQueryPoolCreateInfo + where + type FieldType "sType" VkQueryPoolCreateInfo = VkStructureType + type FieldOptional "sType" VkQueryPoolCreateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkQueryPoolCreateInfo = + #{offset VkQueryPoolCreateInfo, sType} + type FieldIsArray "sType" VkQueryPoolCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkQueryPoolCreateInfo, sType} + +instance CanReadField "sType" VkQueryPoolCreateInfo where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkQueryPoolCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} HasVkPNext VkQueryPoolCreateInfo where + type VkPNextMType VkQueryPoolCreateInfo = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkQueryPoolCreateInfo, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkQueryPoolCreateInfo, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkQueryPoolCreateInfo, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkQueryPoolCreateInfo, pNext} + +instance {-# OVERLAPPING #-} HasField "pNext" VkQueryPoolCreateInfo + where + type FieldType "pNext" VkQueryPoolCreateInfo = Ptr Void + type FieldOptional "pNext" VkQueryPoolCreateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkQueryPoolCreateInfo = + #{offset VkQueryPoolCreateInfo, pNext} + type FieldIsArray "pNext" VkQueryPoolCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkQueryPoolCreateInfo, pNext} + +instance CanReadField "pNext" VkQueryPoolCreateInfo where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkQueryPoolCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} HasVkFlags VkQueryPoolCreateInfo where + type VkFlagsMType VkQueryPoolCreateInfo = VkQueryPoolCreateFlags + + {-# NOINLINE vkFlags #-} + vkFlags x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkQueryPoolCreateInfo, flags}) + + {-# INLINE vkFlagsByteOffset #-} + vkFlagsByteOffset ~_ + = #{offset VkQueryPoolCreateInfo, flags} + + {-# INLINE readVkFlags #-} + readVkFlags p + = peekByteOff p #{offset VkQueryPoolCreateInfo, flags} + + {-# INLINE writeVkFlags #-} + writeVkFlags p + = pokeByteOff p #{offset VkQueryPoolCreateInfo, flags} + +instance {-# OVERLAPPING #-} HasField "flags" VkQueryPoolCreateInfo + where + type FieldType "flags" VkQueryPoolCreateInfo = + VkQueryPoolCreateFlags + type FieldOptional "flags" VkQueryPoolCreateInfo = 'True -- ' closing tick for hsc2hs + type FieldOffset "flags" VkQueryPoolCreateInfo = + #{offset VkQueryPoolCreateInfo, flags} + type FieldIsArray "flags" VkQueryPoolCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkQueryPoolCreateInfo, flags} + +instance CanReadField "flags" VkQueryPoolCreateInfo where + {-# INLINE getField #-} + getField = vkFlags + + {-# INLINE readField #-} + readField = readVkFlags + +instance CanWriteField "flags" VkQueryPoolCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkFlags + +instance {-# OVERLAPPING #-} HasVkQueryType VkQueryPoolCreateInfo + where + type VkQueryTypeMType VkQueryPoolCreateInfo = VkQueryType + + {-# NOINLINE vkQueryType #-} + vkQueryType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkQueryPoolCreateInfo, queryType}) + + {-# INLINE vkQueryTypeByteOffset #-} + vkQueryTypeByteOffset ~_ + = #{offset VkQueryPoolCreateInfo, queryType} + + {-# INLINE readVkQueryType #-} + readVkQueryType p + = peekByteOff p #{offset VkQueryPoolCreateInfo, queryType} + + {-# INLINE writeVkQueryType #-} + writeVkQueryType p + = pokeByteOff p #{offset VkQueryPoolCreateInfo, queryType} + +instance {-# OVERLAPPING #-} + HasField "queryType" VkQueryPoolCreateInfo where + type FieldType "queryType" VkQueryPoolCreateInfo = VkQueryType + type FieldOptional "queryType" VkQueryPoolCreateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "queryType" VkQueryPoolCreateInfo = + #{offset VkQueryPoolCreateInfo, queryType} + type FieldIsArray "queryType" VkQueryPoolCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkQueryPoolCreateInfo, queryType} + +instance CanReadField "queryType" VkQueryPoolCreateInfo where + {-# INLINE getField #-} + getField = vkQueryType + + {-# INLINE readField #-} + readField = readVkQueryType + +instance CanWriteField "queryType" VkQueryPoolCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkQueryType + +instance {-# OVERLAPPING #-} HasVkQueryCount VkQueryPoolCreateInfo + where + type VkQueryCountMType VkQueryPoolCreateInfo = Word32 + + {-# NOINLINE vkQueryCount #-} + vkQueryCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkQueryPoolCreateInfo, queryCount}) + + {-# INLINE vkQueryCountByteOffset #-} + vkQueryCountByteOffset ~_ + = #{offset VkQueryPoolCreateInfo, queryCount} + + {-# INLINE readVkQueryCount #-} + readVkQueryCount p + = peekByteOff p #{offset VkQueryPoolCreateInfo, queryCount} + + {-# INLINE writeVkQueryCount #-} + writeVkQueryCount p + = pokeByteOff p #{offset VkQueryPoolCreateInfo, queryCount} + +instance {-# OVERLAPPING #-} + HasField "queryCount" VkQueryPoolCreateInfo where + type FieldType "queryCount" VkQueryPoolCreateInfo = Word32 + type FieldOptional "queryCount" VkQueryPoolCreateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "queryCount" VkQueryPoolCreateInfo = + #{offset VkQueryPoolCreateInfo, queryCount} + type FieldIsArray "queryCount" VkQueryPoolCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkQueryPoolCreateInfo, queryCount} + +instance CanReadField "queryCount" VkQueryPoolCreateInfo where + {-# INLINE getField #-} + getField = vkQueryCount + + {-# INLINE readField #-} + readField = readVkQueryCount + +instance CanWriteField "queryCount" VkQueryPoolCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkQueryCount + +instance {-# OVERLAPPING #-} + HasVkPipelineStatistics VkQueryPoolCreateInfo where + type VkPipelineStatisticsMType VkQueryPoolCreateInfo = + VkQueryPipelineStatisticFlags + + {-# NOINLINE vkPipelineStatistics #-} + vkPipelineStatistics x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkQueryPoolCreateInfo, pipelineStatistics}) + + {-# INLINE vkPipelineStatisticsByteOffset #-} + vkPipelineStatisticsByteOffset ~_ + = #{offset VkQueryPoolCreateInfo, pipelineStatistics} + + {-# INLINE readVkPipelineStatistics #-} + readVkPipelineStatistics p + = peekByteOff p #{offset VkQueryPoolCreateInfo, pipelineStatistics} + + {-# INLINE writeVkPipelineStatistics #-} + writeVkPipelineStatistics p + = pokeByteOff p #{offset VkQueryPoolCreateInfo, pipelineStatistics} + +instance {-# OVERLAPPING #-} + HasField "pipelineStatistics" VkQueryPoolCreateInfo where + type FieldType "pipelineStatistics" VkQueryPoolCreateInfo = + VkQueryPipelineStatisticFlags + type FieldOptional "pipelineStatistics" VkQueryPoolCreateInfo = + 'True -- ' closing tick for hsc2hs + type FieldOffset "pipelineStatistics" VkQueryPoolCreateInfo = + #{offset VkQueryPoolCreateInfo, pipelineStatistics} + type FieldIsArray "pipelineStatistics" VkQueryPoolCreateInfo = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkQueryPoolCreateInfo, pipelineStatistics} + +instance CanReadField "pipelineStatistics" VkQueryPoolCreateInfo + where + {-# INLINE getField #-} + getField = vkPipelineStatistics + + {-# INLINE readField #-} + readField = readVkPipelineStatistics + +instance CanWriteField "pipelineStatistics" VkQueryPoolCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkPipelineStatistics + +instance Show VkQueryPoolCreateInfo where + showsPrec d x + = showString "VkQueryPoolCreateInfo {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkFlags = " . + showsPrec d (vkFlags x) . + showString ", " . + showString "vkQueryType = " . + showsPrec d (vkQueryType x) . + showString ", " . + showString "vkQueryCount = " . + showsPrec d (vkQueryCount x) . + showString ", " . + showString "vkPipelineStatistics = " . + showsPrec d (vkPipelineStatistics x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkQueueFamilyProperties.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkQueueFamilyProperties.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkQueueFamilyProperties.hsc @@ -0,0 +1,278 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkQueueFamilyProperties + (VkQueueFamilyProperties(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkQueueFlags (VkQueueFlags) +import Graphics.Vulkan.Types.Struct.VkExtent3D (VkExtent3D) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkQueueFamilyProperties { +-- > VkQueueFlags queueFlags; +-- > uint32_t queueCount; +-- > uint32_t timestampValidBits; +-- > VkExtent3D minImageTransferGranularity; +-- > } VkQueueFamilyProperties; +-- +-- +data VkQueueFamilyProperties = VkQueueFamilyProperties## Addr## + ByteArray## + +instance Eq VkQueueFamilyProperties where + (VkQueueFamilyProperties## a _) == x@(VkQueueFamilyProperties## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkQueueFamilyProperties where + (VkQueueFamilyProperties## a _) `compare` + x@(VkQueueFamilyProperties## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkQueueFamilyProperties where + sizeOf ~_ = #{size VkQueueFamilyProperties} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkQueueFamilyProperties} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkQueueFamilyProperties where + unsafeAddr (VkQueueFamilyProperties## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkQueueFamilyProperties## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkQueueFamilyProperties## (plusAddr## (byteArrayContents## b) off) b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkQueueFamilyProperties where + type StructFields VkQueueFamilyProperties = + '["queueFlags", "queueCount", "timestampValidBits", -- ' closing tick for hsc2hs + "minImageTransferGranularity"] + type CUnionType VkQueueFamilyProperties = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkQueueFamilyProperties = 'True -- ' closing tick for hsc2hs + type StructExtends VkQueueFamilyProperties = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkQueueFlags VkQueueFamilyProperties where + type VkQueueFlagsMType VkQueueFamilyProperties = VkQueueFlags + + {-# NOINLINE vkQueueFlags #-} + vkQueueFlags x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkQueueFamilyProperties, queueFlags}) + + {-# INLINE vkQueueFlagsByteOffset #-} + vkQueueFlagsByteOffset ~_ + = #{offset VkQueueFamilyProperties, queueFlags} + + {-# INLINE readVkQueueFlags #-} + readVkQueueFlags p + = peekByteOff p #{offset VkQueueFamilyProperties, queueFlags} + + {-# INLINE writeVkQueueFlags #-} + writeVkQueueFlags p + = pokeByteOff p #{offset VkQueueFamilyProperties, queueFlags} + +instance {-# OVERLAPPING #-} + HasField "queueFlags" VkQueueFamilyProperties where + type FieldType "queueFlags" VkQueueFamilyProperties = VkQueueFlags + type FieldOptional "queueFlags" VkQueueFamilyProperties = 'True -- ' closing tick for hsc2hs + type FieldOffset "queueFlags" VkQueueFamilyProperties = + #{offset VkQueueFamilyProperties, queueFlags} + type FieldIsArray "queueFlags" VkQueueFamilyProperties = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkQueueFamilyProperties, queueFlags} + +instance CanReadField "queueFlags" VkQueueFamilyProperties where + {-# INLINE getField #-} + getField = vkQueueFlags + + {-# INLINE readField #-} + readField = readVkQueueFlags + +instance {-# OVERLAPPING #-} + HasVkQueueCount VkQueueFamilyProperties where + type VkQueueCountMType VkQueueFamilyProperties = Word32 + + {-# NOINLINE vkQueueCount #-} + vkQueueCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkQueueFamilyProperties, queueCount}) + + {-# INLINE vkQueueCountByteOffset #-} + vkQueueCountByteOffset ~_ + = #{offset VkQueueFamilyProperties, queueCount} + + {-# INLINE readVkQueueCount #-} + readVkQueueCount p + = peekByteOff p #{offset VkQueueFamilyProperties, queueCount} + + {-# INLINE writeVkQueueCount #-} + writeVkQueueCount p + = pokeByteOff p #{offset VkQueueFamilyProperties, queueCount} + +instance {-# OVERLAPPING #-} + HasField "queueCount" VkQueueFamilyProperties where + type FieldType "queueCount" VkQueueFamilyProperties = Word32 + type FieldOptional "queueCount" VkQueueFamilyProperties = 'False -- ' closing tick for hsc2hs + type FieldOffset "queueCount" VkQueueFamilyProperties = + #{offset VkQueueFamilyProperties, queueCount} + type FieldIsArray "queueCount" VkQueueFamilyProperties = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkQueueFamilyProperties, queueCount} + +instance CanReadField "queueCount" VkQueueFamilyProperties where + {-# INLINE getField #-} + getField = vkQueueCount + + {-# INLINE readField #-} + readField = readVkQueueCount + +instance {-# OVERLAPPING #-} + HasVkTimestampValidBits VkQueueFamilyProperties where + type VkTimestampValidBitsMType VkQueueFamilyProperties = Word32 + + {-# NOINLINE vkTimestampValidBits #-} + vkTimestampValidBits x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkQueueFamilyProperties, timestampValidBits}) + + {-# INLINE vkTimestampValidBitsByteOffset #-} + vkTimestampValidBitsByteOffset ~_ + = #{offset VkQueueFamilyProperties, timestampValidBits} + + {-# INLINE readVkTimestampValidBits #-} + readVkTimestampValidBits p + = peekByteOff p #{offset VkQueueFamilyProperties, timestampValidBits} + + {-# INLINE writeVkTimestampValidBits #-} + writeVkTimestampValidBits p + = pokeByteOff p #{offset VkQueueFamilyProperties, timestampValidBits} + +instance {-# OVERLAPPING #-} + HasField "timestampValidBits" VkQueueFamilyProperties where + type FieldType "timestampValidBits" VkQueueFamilyProperties = + Word32 + type FieldOptional "timestampValidBits" VkQueueFamilyProperties = + 'False -- ' closing tick for hsc2hs + type FieldOffset "timestampValidBits" VkQueueFamilyProperties = + #{offset VkQueueFamilyProperties, timestampValidBits} + type FieldIsArray "timestampValidBits" VkQueueFamilyProperties = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkQueueFamilyProperties, timestampValidBits} + +instance CanReadField "timestampValidBits" VkQueueFamilyProperties + where + {-# INLINE getField #-} + getField = vkTimestampValidBits + + {-# INLINE readField #-} + readField = readVkTimestampValidBits + +instance {-# OVERLAPPING #-} + HasVkMinImageTransferGranularity VkQueueFamilyProperties where + type VkMinImageTransferGranularityMType VkQueueFamilyProperties = + VkExtent3D + + {-# NOINLINE vkMinImageTransferGranularity #-} + vkMinImageTransferGranularity x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkQueueFamilyProperties, minImageTransferGranularity}) + + {-# INLINE vkMinImageTransferGranularityByteOffset #-} + vkMinImageTransferGranularityByteOffset ~_ + = #{offset VkQueueFamilyProperties, minImageTransferGranularity} + + {-# INLINE readVkMinImageTransferGranularity #-} + readVkMinImageTransferGranularity p + = peekByteOff p #{offset VkQueueFamilyProperties, minImageTransferGranularity} + + {-# INLINE writeVkMinImageTransferGranularity #-} + writeVkMinImageTransferGranularity p + = pokeByteOff p #{offset VkQueueFamilyProperties, minImageTransferGranularity} + +instance {-# OVERLAPPING #-} + HasField "minImageTransferGranularity" VkQueueFamilyProperties + where + type FieldType "minImageTransferGranularity" + VkQueueFamilyProperties + = VkExtent3D + type FieldOptional "minImageTransferGranularity" + VkQueueFamilyProperties + = 'False -- ' closing tick for hsc2hs + type FieldOffset "minImageTransferGranularity" + VkQueueFamilyProperties + = + #{offset VkQueueFamilyProperties, minImageTransferGranularity} + type FieldIsArray "minImageTransferGranularity" + VkQueueFamilyProperties + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkQueueFamilyProperties, minImageTransferGranularity} + +instance CanReadField "minImageTransferGranularity" + VkQueueFamilyProperties + where + {-# INLINE getField #-} + getField = vkMinImageTransferGranularity + + {-# INLINE readField #-} + readField = readVkMinImageTransferGranularity + +instance Show VkQueueFamilyProperties where + showsPrec d x + = showString "VkQueueFamilyProperties {" . + showString "vkQueueFlags = " . + showsPrec d (vkQueueFlags x) . + showString ", " . + showString "vkQueueCount = " . + showsPrec d (vkQueueCount x) . + showString ", " . + showString "vkTimestampValidBits = " . + showsPrec d (vkTimestampValidBits x) . + showString ", " . + showString "vkMinImageTransferGranularity = " . + showsPrec d (vkMinImageTransferGranularity x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkQueueFamilyProperties2KHR.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkQueueFamilyProperties2KHR.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkQueueFamilyProperties2KHR.hsc @@ -0,0 +1,228 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkQueueFamilyProperties2KHR + (VkQueueFamilyProperties2KHR(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Struct.VkQueueFamilyProperties (VkQueueFamilyProperties) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkQueueFamilyProperties2KHR { +-- > VkStructureType sType; +-- > void* pNext; +-- > VkQueueFamilyProperties queueFamilyProperties; +-- > } VkQueueFamilyProperties2KHR; +-- +-- +data VkQueueFamilyProperties2KHR = VkQueueFamilyProperties2KHR## Addr## + ByteArray## + +instance Eq VkQueueFamilyProperties2KHR where + (VkQueueFamilyProperties2KHR## a _) == + x@(VkQueueFamilyProperties2KHR## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkQueueFamilyProperties2KHR where + (VkQueueFamilyProperties2KHR## a _) `compare` + x@(VkQueueFamilyProperties2KHR## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkQueueFamilyProperties2KHR where + sizeOf ~_ = #{size VkQueueFamilyProperties2KHR} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkQueueFamilyProperties2KHR} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkQueueFamilyProperties2KHR where + unsafeAddr (VkQueueFamilyProperties2KHR## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkQueueFamilyProperties2KHR## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkQueueFamilyProperties2KHR## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkQueueFamilyProperties2KHR where + type StructFields VkQueueFamilyProperties2KHR = + '["sType", "pNext", "queueFamilyProperties"] -- ' closing tick for hsc2hs + type CUnionType VkQueueFamilyProperties2KHR = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkQueueFamilyProperties2KHR = 'True -- ' closing tick for hsc2hs + type StructExtends VkQueueFamilyProperties2KHR = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkSType VkQueueFamilyProperties2KHR + where + type VkSTypeMType VkQueueFamilyProperties2KHR = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkQueueFamilyProperties2KHR, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkQueueFamilyProperties2KHR, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkQueueFamilyProperties2KHR, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkQueueFamilyProperties2KHR, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkQueueFamilyProperties2KHR where + type FieldType "sType" VkQueueFamilyProperties2KHR = + VkStructureType + type FieldOptional "sType" VkQueueFamilyProperties2KHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkQueueFamilyProperties2KHR = + #{offset VkQueueFamilyProperties2KHR, sType} + type FieldIsArray "sType" VkQueueFamilyProperties2KHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkQueueFamilyProperties2KHR, sType} + +instance CanReadField "sType" VkQueueFamilyProperties2KHR where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance {-# OVERLAPPING #-} HasVkPNext VkQueueFamilyProperties2KHR + where + type VkPNextMType VkQueueFamilyProperties2KHR = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkQueueFamilyProperties2KHR, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkQueueFamilyProperties2KHR, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkQueueFamilyProperties2KHR, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkQueueFamilyProperties2KHR, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkQueueFamilyProperties2KHR where + type FieldType "pNext" VkQueueFamilyProperties2KHR = Ptr Void + type FieldOptional "pNext" VkQueueFamilyProperties2KHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkQueueFamilyProperties2KHR = + #{offset VkQueueFamilyProperties2KHR, pNext} + type FieldIsArray "pNext" VkQueueFamilyProperties2KHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkQueueFamilyProperties2KHR, pNext} + +instance CanReadField "pNext" VkQueueFamilyProperties2KHR where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance {-# OVERLAPPING #-} + HasVkQueueFamilyProperties VkQueueFamilyProperties2KHR where + type VkQueueFamilyPropertiesMType VkQueueFamilyProperties2KHR = + VkQueueFamilyProperties + + {-# NOINLINE vkQueueFamilyProperties #-} + vkQueueFamilyProperties x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkQueueFamilyProperties2KHR, queueFamilyProperties}) + + {-# INLINE vkQueueFamilyPropertiesByteOffset #-} + vkQueueFamilyPropertiesByteOffset ~_ + = #{offset VkQueueFamilyProperties2KHR, queueFamilyProperties} + + {-# INLINE readVkQueueFamilyProperties #-} + readVkQueueFamilyProperties p + = peekByteOff p #{offset VkQueueFamilyProperties2KHR, queueFamilyProperties} + + {-# INLINE writeVkQueueFamilyProperties #-} + writeVkQueueFamilyProperties p + = pokeByteOff p #{offset VkQueueFamilyProperties2KHR, queueFamilyProperties} + +instance {-# OVERLAPPING #-} + HasField "queueFamilyProperties" VkQueueFamilyProperties2KHR where + type FieldType "queueFamilyProperties" VkQueueFamilyProperties2KHR + = VkQueueFamilyProperties + type FieldOptional "queueFamilyProperties" + VkQueueFamilyProperties2KHR + = 'False -- ' closing tick for hsc2hs + type FieldOffset "queueFamilyProperties" + VkQueueFamilyProperties2KHR + = + #{offset VkQueueFamilyProperties2KHR, queueFamilyProperties} + type FieldIsArray "queueFamilyProperties" + VkQueueFamilyProperties2KHR + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkQueueFamilyProperties2KHR, queueFamilyProperties} + +instance CanReadField "queueFamilyProperties" + VkQueueFamilyProperties2KHR + where + {-# INLINE getField #-} + getField = vkQueueFamilyProperties + + {-# INLINE readField #-} + readField = readVkQueueFamilyProperties + +instance Show VkQueueFamilyProperties2KHR where + showsPrec d x + = showString "VkQueueFamilyProperties2KHR {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkQueueFamilyProperties = " . + showsPrec d (vkQueueFamilyProperties x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkRect2D.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkRect2D.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkRect2D.hsc @@ -0,0 +1,163 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkRect2D (VkRect2D(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Struct.VkExtent2D (VkExtent2D) +import Graphics.Vulkan.Types.Struct.VkOffset2D (VkOffset2D) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkRect2D { +-- > VkOffset2D offset; +-- > VkExtent2D extent; +-- > } VkRect2D; +-- +-- +data VkRect2D = VkRect2D## Addr## ByteArray## + +instance Eq VkRect2D where + (VkRect2D## a _) == x@(VkRect2D## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkRect2D where + (VkRect2D## a _) `compare` x@(VkRect2D## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkRect2D where + sizeOf ~_ = #{size VkRect2D} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkRect2D} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkRect2D where + unsafeAddr (VkRect2D## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkRect2D## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkRect2D## (plusAddr## (byteArrayContents## b) off) b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkRect2D where + type StructFields VkRect2D = '["offset", "extent"] -- ' closing tick for hsc2hs + type CUnionType VkRect2D = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkRect2D = 'False -- ' closing tick for hsc2hs + type StructExtends VkRect2D = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkOffset VkRect2D where + type VkOffsetMType VkRect2D = VkOffset2D + + {-# NOINLINE vkOffset #-} + vkOffset x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkRect2D, offset}) + + {-# INLINE vkOffsetByteOffset #-} + vkOffsetByteOffset ~_ = #{offset VkRect2D, offset} + + {-# INLINE readVkOffset #-} + readVkOffset p + = peekByteOff p #{offset VkRect2D, offset} + + {-# INLINE writeVkOffset #-} + writeVkOffset p + = pokeByteOff p #{offset VkRect2D, offset} + +instance {-# OVERLAPPING #-} HasField "offset" VkRect2D where + type FieldType "offset" VkRect2D = VkOffset2D + type FieldOptional "offset" VkRect2D = 'False -- ' closing tick for hsc2hs + type FieldOffset "offset" VkRect2D = + #{offset VkRect2D, offset} + type FieldIsArray "offset" VkRect2D = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkRect2D, offset} + +instance CanReadField "offset" VkRect2D where + {-# INLINE getField #-} + getField = vkOffset + + {-# INLINE readField #-} + readField = readVkOffset + +instance CanWriteField "offset" VkRect2D where + {-# INLINE writeField #-} + writeField = writeVkOffset + +instance {-# OVERLAPPING #-} HasVkExtent VkRect2D where + type VkExtentMType VkRect2D = VkExtent2D + + {-# NOINLINE vkExtent #-} + vkExtent x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkRect2D, extent}) + + {-# INLINE vkExtentByteOffset #-} + vkExtentByteOffset ~_ = #{offset VkRect2D, extent} + + {-# INLINE readVkExtent #-} + readVkExtent p + = peekByteOff p #{offset VkRect2D, extent} + + {-# INLINE writeVkExtent #-} + writeVkExtent p + = pokeByteOff p #{offset VkRect2D, extent} + +instance {-# OVERLAPPING #-} HasField "extent" VkRect2D where + type FieldType "extent" VkRect2D = VkExtent2D + type FieldOptional "extent" VkRect2D = 'False -- ' closing tick for hsc2hs + type FieldOffset "extent" VkRect2D = + #{offset VkRect2D, extent} + type FieldIsArray "extent" VkRect2D = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkRect2D, extent} + +instance CanReadField "extent" VkRect2D where + {-# INLINE getField #-} + getField = vkExtent + + {-# INLINE readField #-} + readField = readVkExtent + +instance CanWriteField "extent" VkRect2D where + {-# INLINE writeField #-} + writeField = writeVkExtent + +instance Show VkRect2D where + showsPrec d x + = showString "VkRect2D {" . + showString "vkOffset = " . + showsPrec d (vkOffset x) . + showString ", " . + showString "vkExtent = " . showsPrec d (vkExtent x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkRectLayerKHR.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkRectLayerKHR.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkRectLayerKHR.hsc @@ -0,0 +1,213 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkRectLayerKHR + (VkRectLayerKHR(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Struct.VkExtent2D (VkExtent2D) +import Graphics.Vulkan.Types.Struct.VkOffset2D (VkOffset2D) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkRectLayerKHR { +-- > VkOffset2D offset; +-- > VkExtent2D extent; +-- > uint32_t layer; +-- > } VkRectLayerKHR; +-- +-- +data VkRectLayerKHR = VkRectLayerKHR## Addr## ByteArray## + +instance Eq VkRectLayerKHR where + (VkRectLayerKHR## a _) == x@(VkRectLayerKHR## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkRectLayerKHR where + (VkRectLayerKHR## a _) `compare` x@(VkRectLayerKHR## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkRectLayerKHR where + sizeOf ~_ = #{size VkRectLayerKHR} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkRectLayerKHR} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkRectLayerKHR where + unsafeAddr (VkRectLayerKHR## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkRectLayerKHR## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkRectLayerKHR## (plusAddr## (byteArrayContents## b) off) b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkRectLayerKHR where + type StructFields VkRectLayerKHR = '["offset", "extent", "layer"] -- ' closing tick for hsc2hs + type CUnionType VkRectLayerKHR = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkRectLayerKHR = 'False -- ' closing tick for hsc2hs + type StructExtends VkRectLayerKHR = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkOffset VkRectLayerKHR where + type VkOffsetMType VkRectLayerKHR = VkOffset2D + + {-# NOINLINE vkOffset #-} + vkOffset x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkRectLayerKHR, offset}) + + {-# INLINE vkOffsetByteOffset #-} + vkOffsetByteOffset ~_ + = #{offset VkRectLayerKHR, offset} + + {-# INLINE readVkOffset #-} + readVkOffset p + = peekByteOff p #{offset VkRectLayerKHR, offset} + + {-# INLINE writeVkOffset #-} + writeVkOffset p + = pokeByteOff p #{offset VkRectLayerKHR, offset} + +instance {-# OVERLAPPING #-} HasField "offset" VkRectLayerKHR where + type FieldType "offset" VkRectLayerKHR = VkOffset2D + type FieldOptional "offset" VkRectLayerKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "offset" VkRectLayerKHR = + #{offset VkRectLayerKHR, offset} + type FieldIsArray "offset" VkRectLayerKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkRectLayerKHR, offset} + +instance CanReadField "offset" VkRectLayerKHR where + {-# INLINE getField #-} + getField = vkOffset + + {-# INLINE readField #-} + readField = readVkOffset + +instance CanWriteField "offset" VkRectLayerKHR where + {-# INLINE writeField #-} + writeField = writeVkOffset + +instance {-# OVERLAPPING #-} HasVkExtent VkRectLayerKHR where + type VkExtentMType VkRectLayerKHR = VkExtent2D + + {-# NOINLINE vkExtent #-} + vkExtent x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkRectLayerKHR, extent}) + + {-# INLINE vkExtentByteOffset #-} + vkExtentByteOffset ~_ + = #{offset VkRectLayerKHR, extent} + + {-# INLINE readVkExtent #-} + readVkExtent p + = peekByteOff p #{offset VkRectLayerKHR, extent} + + {-# INLINE writeVkExtent #-} + writeVkExtent p + = pokeByteOff p #{offset VkRectLayerKHR, extent} + +instance {-# OVERLAPPING #-} HasField "extent" VkRectLayerKHR where + type FieldType "extent" VkRectLayerKHR = VkExtent2D + type FieldOptional "extent" VkRectLayerKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "extent" VkRectLayerKHR = + #{offset VkRectLayerKHR, extent} + type FieldIsArray "extent" VkRectLayerKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkRectLayerKHR, extent} + +instance CanReadField "extent" VkRectLayerKHR where + {-# INLINE getField #-} + getField = vkExtent + + {-# INLINE readField #-} + readField = readVkExtent + +instance CanWriteField "extent" VkRectLayerKHR where + {-# INLINE writeField #-} + writeField = writeVkExtent + +instance {-# OVERLAPPING #-} HasVkLayer VkRectLayerKHR where + type VkLayerMType VkRectLayerKHR = Word32 + + {-# NOINLINE vkLayer #-} + vkLayer x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkRectLayerKHR, layer}) + + {-# INLINE vkLayerByteOffset #-} + vkLayerByteOffset ~_ = #{offset VkRectLayerKHR, layer} + + {-# INLINE readVkLayer #-} + readVkLayer p + = peekByteOff p #{offset VkRectLayerKHR, layer} + + {-# INLINE writeVkLayer #-} + writeVkLayer p + = pokeByteOff p #{offset VkRectLayerKHR, layer} + +instance {-# OVERLAPPING #-} HasField "layer" VkRectLayerKHR where + type FieldType "layer" VkRectLayerKHR = Word32 + type FieldOptional "layer" VkRectLayerKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "layer" VkRectLayerKHR = + #{offset VkRectLayerKHR, layer} + type FieldIsArray "layer" VkRectLayerKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkRectLayerKHR, layer} + +instance CanReadField "layer" VkRectLayerKHR where + {-# INLINE getField #-} + getField = vkLayer + + {-# INLINE readField #-} + readField = readVkLayer + +instance CanWriteField "layer" VkRectLayerKHR where + {-# INLINE writeField #-} + writeField = writeVkLayer + +instance Show VkRectLayerKHR where + showsPrec d x + = showString "VkRectLayerKHR {" . + showString "vkOffset = " . + showsPrec d (vkOffset x) . + showString ", " . + showString "vkExtent = " . + showsPrec d (vkExtent x) . + showString ", " . + showString "vkLayer = " . showsPrec d (vkLayer x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkRefreshCycleDurationGOOGLE.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkRefreshCycleDurationGOOGLE.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkRefreshCycleDurationGOOGLE.hsc @@ -0,0 +1,133 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkRefreshCycleDurationGOOGLE + (VkRefreshCycleDurationGOOGLE(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkRefreshCycleDurationGOOGLE { +-- > uint64_t refreshDuration; +-- > } VkRefreshCycleDurationGOOGLE; +-- +-- +data VkRefreshCycleDurationGOOGLE = VkRefreshCycleDurationGOOGLE## Addr## + ByteArray## + +instance Eq VkRefreshCycleDurationGOOGLE where + (VkRefreshCycleDurationGOOGLE## a _) == + x@(VkRefreshCycleDurationGOOGLE## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkRefreshCycleDurationGOOGLE where + (VkRefreshCycleDurationGOOGLE## a _) `compare` + x@(VkRefreshCycleDurationGOOGLE## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkRefreshCycleDurationGOOGLE where + sizeOf ~_ = #{size VkRefreshCycleDurationGOOGLE} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkRefreshCycleDurationGOOGLE} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkRefreshCycleDurationGOOGLE where + unsafeAddr (VkRefreshCycleDurationGOOGLE## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkRefreshCycleDurationGOOGLE## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkRefreshCycleDurationGOOGLE## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkRefreshCycleDurationGOOGLE where + type StructFields VkRefreshCycleDurationGOOGLE = + '["refreshDuration"] -- ' closing tick for hsc2hs + type CUnionType VkRefreshCycleDurationGOOGLE = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkRefreshCycleDurationGOOGLE = 'False -- ' closing tick for hsc2hs + type StructExtends VkRefreshCycleDurationGOOGLE = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkRefreshDuration VkRefreshCycleDurationGOOGLE where + type VkRefreshDurationMType VkRefreshCycleDurationGOOGLE = Word64 + + {-# NOINLINE vkRefreshDuration #-} + vkRefreshDuration x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkRefreshCycleDurationGOOGLE, refreshDuration}) + + {-# INLINE vkRefreshDurationByteOffset #-} + vkRefreshDurationByteOffset ~_ + = #{offset VkRefreshCycleDurationGOOGLE, refreshDuration} + + {-# INLINE readVkRefreshDuration #-} + readVkRefreshDuration p + = peekByteOff p #{offset VkRefreshCycleDurationGOOGLE, refreshDuration} + + {-# INLINE writeVkRefreshDuration #-} + writeVkRefreshDuration p + = pokeByteOff p #{offset VkRefreshCycleDurationGOOGLE, refreshDuration} + +instance {-# OVERLAPPING #-} + HasField "refreshDuration" VkRefreshCycleDurationGOOGLE where + type FieldType "refreshDuration" VkRefreshCycleDurationGOOGLE = + Word64 + type FieldOptional "refreshDuration" VkRefreshCycleDurationGOOGLE = + 'False -- ' closing tick for hsc2hs + type FieldOffset "refreshDuration" VkRefreshCycleDurationGOOGLE = + #{offset VkRefreshCycleDurationGOOGLE, refreshDuration} + type FieldIsArray "refreshDuration" VkRefreshCycleDurationGOOGLE = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkRefreshCycleDurationGOOGLE, refreshDuration} + +instance CanReadField "refreshDuration" + VkRefreshCycleDurationGOOGLE + where + {-# INLINE getField #-} + getField = vkRefreshDuration + + {-# INLINE readField #-} + readField = readVkRefreshDuration + +instance CanWriteField "refreshDuration" + VkRefreshCycleDurationGOOGLE + where + {-# INLINE writeField #-} + writeField = writeVkRefreshDuration + +instance Show VkRefreshCycleDurationGOOGLE where + showsPrec d x + = showString "VkRefreshCycleDurationGOOGLE {" . + showString "vkRefreshDuration = " . + showsPrec d (vkRefreshDuration x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkRenderPassBeginInfo.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkRenderPassBeginInfo.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkRenderPassBeginInfo.hsc @@ -0,0 +1,432 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkRenderPassBeginInfo + (VkRenderPassBeginInfo(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Handles (VkFramebuffer, + VkRenderPass) +import Graphics.Vulkan.Types.Struct.VkClearValue (VkClearValue) +import Graphics.Vulkan.Types.Struct.VkRect2D (VkRect2D) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkRenderPassBeginInfo { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkRenderPass renderPass; +-- > VkFramebuffer framebuffer; +-- > VkRect2D renderArea; +-- > uint32_t clearValueCount; +-- > const VkClearValue* pClearValues; +-- > } VkRenderPassBeginInfo; +-- +-- +data VkRenderPassBeginInfo = VkRenderPassBeginInfo## Addr## + ByteArray## + +instance Eq VkRenderPassBeginInfo where + (VkRenderPassBeginInfo## a _) == x@(VkRenderPassBeginInfo## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkRenderPassBeginInfo where + (VkRenderPassBeginInfo## a _) `compare` + x@(VkRenderPassBeginInfo## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkRenderPassBeginInfo where + sizeOf ~_ = #{size VkRenderPassBeginInfo} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkRenderPassBeginInfo} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkRenderPassBeginInfo where + unsafeAddr (VkRenderPassBeginInfo## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkRenderPassBeginInfo## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkRenderPassBeginInfo## (plusAddr## (byteArrayContents## b) off) b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkRenderPassBeginInfo where + type StructFields VkRenderPassBeginInfo = + '["sType", "pNext", "renderPass", "framebuffer", "renderArea", -- ' closing tick for hsc2hs + "clearValueCount", "pClearValues"] + type CUnionType VkRenderPassBeginInfo = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkRenderPassBeginInfo = 'False -- ' closing tick for hsc2hs + type StructExtends VkRenderPassBeginInfo = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkSType VkRenderPassBeginInfo where + type VkSTypeMType VkRenderPassBeginInfo = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkRenderPassBeginInfo, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkRenderPassBeginInfo, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkRenderPassBeginInfo, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkRenderPassBeginInfo, sType} + +instance {-# OVERLAPPING #-} HasField "sType" VkRenderPassBeginInfo + where + type FieldType "sType" VkRenderPassBeginInfo = VkStructureType + type FieldOptional "sType" VkRenderPassBeginInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkRenderPassBeginInfo = + #{offset VkRenderPassBeginInfo, sType} + type FieldIsArray "sType" VkRenderPassBeginInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkRenderPassBeginInfo, sType} + +instance CanReadField "sType" VkRenderPassBeginInfo where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkRenderPassBeginInfo where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} HasVkPNext VkRenderPassBeginInfo where + type VkPNextMType VkRenderPassBeginInfo = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkRenderPassBeginInfo, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkRenderPassBeginInfo, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkRenderPassBeginInfo, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkRenderPassBeginInfo, pNext} + +instance {-# OVERLAPPING #-} HasField "pNext" VkRenderPassBeginInfo + where + type FieldType "pNext" VkRenderPassBeginInfo = Ptr Void + type FieldOptional "pNext" VkRenderPassBeginInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkRenderPassBeginInfo = + #{offset VkRenderPassBeginInfo, pNext} + type FieldIsArray "pNext" VkRenderPassBeginInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkRenderPassBeginInfo, pNext} + +instance CanReadField "pNext" VkRenderPassBeginInfo where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkRenderPassBeginInfo where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} HasVkRenderPass VkRenderPassBeginInfo + where + type VkRenderPassMType VkRenderPassBeginInfo = VkRenderPass + + {-# NOINLINE vkRenderPass #-} + vkRenderPass x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkRenderPassBeginInfo, renderPass}) + + {-# INLINE vkRenderPassByteOffset #-} + vkRenderPassByteOffset ~_ + = #{offset VkRenderPassBeginInfo, renderPass} + + {-# INLINE readVkRenderPass #-} + readVkRenderPass p + = peekByteOff p #{offset VkRenderPassBeginInfo, renderPass} + + {-# INLINE writeVkRenderPass #-} + writeVkRenderPass p + = pokeByteOff p #{offset VkRenderPassBeginInfo, renderPass} + +instance {-# OVERLAPPING #-} + HasField "renderPass" VkRenderPassBeginInfo where + type FieldType "renderPass" VkRenderPassBeginInfo = VkRenderPass + type FieldOptional "renderPass" VkRenderPassBeginInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "renderPass" VkRenderPassBeginInfo = + #{offset VkRenderPassBeginInfo, renderPass} + type FieldIsArray "renderPass" VkRenderPassBeginInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkRenderPassBeginInfo, renderPass} + +instance CanReadField "renderPass" VkRenderPassBeginInfo where + {-# INLINE getField #-} + getField = vkRenderPass + + {-# INLINE readField #-} + readField = readVkRenderPass + +instance CanWriteField "renderPass" VkRenderPassBeginInfo where + {-# INLINE writeField #-} + writeField = writeVkRenderPass + +instance {-# OVERLAPPING #-} HasVkFramebuffer VkRenderPassBeginInfo + where + type VkFramebufferMType VkRenderPassBeginInfo = VkFramebuffer + + {-# NOINLINE vkFramebuffer #-} + vkFramebuffer x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkRenderPassBeginInfo, framebuffer}) + + {-# INLINE vkFramebufferByteOffset #-} + vkFramebufferByteOffset ~_ + = #{offset VkRenderPassBeginInfo, framebuffer} + + {-# INLINE readVkFramebuffer #-} + readVkFramebuffer p + = peekByteOff p #{offset VkRenderPassBeginInfo, framebuffer} + + {-# INLINE writeVkFramebuffer #-} + writeVkFramebuffer p + = pokeByteOff p #{offset VkRenderPassBeginInfo, framebuffer} + +instance {-# OVERLAPPING #-} + HasField "framebuffer" VkRenderPassBeginInfo where + type FieldType "framebuffer" VkRenderPassBeginInfo = VkFramebuffer + type FieldOptional "framebuffer" VkRenderPassBeginInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "framebuffer" VkRenderPassBeginInfo = + #{offset VkRenderPassBeginInfo, framebuffer} + type FieldIsArray "framebuffer" VkRenderPassBeginInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkRenderPassBeginInfo, framebuffer} + +instance CanReadField "framebuffer" VkRenderPassBeginInfo where + {-# INLINE getField #-} + getField = vkFramebuffer + + {-# INLINE readField #-} + readField = readVkFramebuffer + +instance CanWriteField "framebuffer" VkRenderPassBeginInfo where + {-# INLINE writeField #-} + writeField = writeVkFramebuffer + +instance {-# OVERLAPPING #-} HasVkRenderArea VkRenderPassBeginInfo + where + type VkRenderAreaMType VkRenderPassBeginInfo = VkRect2D + + {-# NOINLINE vkRenderArea #-} + vkRenderArea x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkRenderPassBeginInfo, renderArea}) + + {-# INLINE vkRenderAreaByteOffset #-} + vkRenderAreaByteOffset ~_ + = #{offset VkRenderPassBeginInfo, renderArea} + + {-# INLINE readVkRenderArea #-} + readVkRenderArea p + = peekByteOff p #{offset VkRenderPassBeginInfo, renderArea} + + {-# INLINE writeVkRenderArea #-} + writeVkRenderArea p + = pokeByteOff p #{offset VkRenderPassBeginInfo, renderArea} + +instance {-# OVERLAPPING #-} + HasField "renderArea" VkRenderPassBeginInfo where + type FieldType "renderArea" VkRenderPassBeginInfo = VkRect2D + type FieldOptional "renderArea" VkRenderPassBeginInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "renderArea" VkRenderPassBeginInfo = + #{offset VkRenderPassBeginInfo, renderArea} + type FieldIsArray "renderArea" VkRenderPassBeginInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkRenderPassBeginInfo, renderArea} + +instance CanReadField "renderArea" VkRenderPassBeginInfo where + {-# INLINE getField #-} + getField = vkRenderArea + + {-# INLINE readField #-} + readField = readVkRenderArea + +instance CanWriteField "renderArea" VkRenderPassBeginInfo where + {-# INLINE writeField #-} + writeField = writeVkRenderArea + +instance {-# OVERLAPPING #-} + HasVkClearValueCount VkRenderPassBeginInfo where + type VkClearValueCountMType VkRenderPassBeginInfo = Word32 + + {-# NOINLINE vkClearValueCount #-} + vkClearValueCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkRenderPassBeginInfo, clearValueCount}) + + {-# INLINE vkClearValueCountByteOffset #-} + vkClearValueCountByteOffset ~_ + = #{offset VkRenderPassBeginInfo, clearValueCount} + + {-# INLINE readVkClearValueCount #-} + readVkClearValueCount p + = peekByteOff p #{offset VkRenderPassBeginInfo, clearValueCount} + + {-# INLINE writeVkClearValueCount #-} + writeVkClearValueCount p + = pokeByteOff p #{offset VkRenderPassBeginInfo, clearValueCount} + +instance {-# OVERLAPPING #-} + HasField "clearValueCount" VkRenderPassBeginInfo where + type FieldType "clearValueCount" VkRenderPassBeginInfo = Word32 + type FieldOptional "clearValueCount" VkRenderPassBeginInfo = 'True -- ' closing tick for hsc2hs + type FieldOffset "clearValueCount" VkRenderPassBeginInfo = + #{offset VkRenderPassBeginInfo, clearValueCount} + type FieldIsArray "clearValueCount" VkRenderPassBeginInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkRenderPassBeginInfo, clearValueCount} + +instance CanReadField "clearValueCount" VkRenderPassBeginInfo where + {-# INLINE getField #-} + getField = vkClearValueCount + + {-# INLINE readField #-} + readField = readVkClearValueCount + +instance CanWriteField "clearValueCount" VkRenderPassBeginInfo + where + {-# INLINE writeField #-} + writeField = writeVkClearValueCount + +instance {-# OVERLAPPING #-} + HasVkPClearValues VkRenderPassBeginInfo where + type VkPClearValuesMType VkRenderPassBeginInfo = Ptr VkClearValue + + {-# NOINLINE vkPClearValues #-} + vkPClearValues x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkRenderPassBeginInfo, pClearValues}) + + {-# INLINE vkPClearValuesByteOffset #-} + vkPClearValuesByteOffset ~_ + = #{offset VkRenderPassBeginInfo, pClearValues} + + {-# INLINE readVkPClearValues #-} + readVkPClearValues p + = peekByteOff p #{offset VkRenderPassBeginInfo, pClearValues} + + {-# INLINE writeVkPClearValues #-} + writeVkPClearValues p + = pokeByteOff p #{offset VkRenderPassBeginInfo, pClearValues} + +instance {-# OVERLAPPING #-} + HasField "pClearValues" VkRenderPassBeginInfo where + type FieldType "pClearValues" VkRenderPassBeginInfo = + Ptr VkClearValue + type FieldOptional "pClearValues" VkRenderPassBeginInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "pClearValues" VkRenderPassBeginInfo = + #{offset VkRenderPassBeginInfo, pClearValues} + type FieldIsArray "pClearValues" VkRenderPassBeginInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkRenderPassBeginInfo, pClearValues} + +instance CanReadField "pClearValues" VkRenderPassBeginInfo where + {-# INLINE getField #-} + getField = vkPClearValues + + {-# INLINE readField #-} + readField = readVkPClearValues + +instance CanWriteField "pClearValues" VkRenderPassBeginInfo where + {-# INLINE writeField #-} + writeField = writeVkPClearValues + +instance Show VkRenderPassBeginInfo where + showsPrec d x + = showString "VkRenderPassBeginInfo {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkRenderPass = " . + showsPrec d (vkRenderPass x) . + showString ", " . + showString "vkFramebuffer = " . + showsPrec d (vkFramebuffer x) . + showString ", " . + showString "vkRenderArea = " . + showsPrec d (vkRenderArea x) . + showString ", " . + showString "vkClearValueCount = " . + showsPrec d (vkClearValueCount x) . + showString ", " . + showString "vkPClearValues = " . + showsPrec d (vkPClearValues x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkRenderPassCreateInfo.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkRenderPassCreateInfo.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkRenderPassCreateInfo.hsc @@ -0,0 +1,545 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkRenderPassCreateInfo + (VkRenderPassCreateInfo(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Bitmasks (VkRenderPassCreateFlags) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Struct.VkAttachmentDescription (VkAttachmentDescription) +import Graphics.Vulkan.Types.Struct.VkSubpassDependency (VkSubpassDependency) +import Graphics.Vulkan.Types.Struct.VkSubpassDescription (VkSubpassDescription) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkRenderPassCreateInfo { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkRenderPassCreateFlags flags; +-- > uint32_t attachmentCount; +-- > const VkAttachmentDescription* pAttachments; +-- > uint32_t subpassCount; +-- > const VkSubpassDescription* pSubpasses; +-- > uint32_t dependencyCount; +-- > const VkSubpassDependency* pDependencies; +-- > } VkRenderPassCreateInfo; +-- +-- +data VkRenderPassCreateInfo = VkRenderPassCreateInfo## Addr## + ByteArray## + +instance Eq VkRenderPassCreateInfo where + (VkRenderPassCreateInfo## a _) == x@(VkRenderPassCreateInfo## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkRenderPassCreateInfo where + (VkRenderPassCreateInfo## a _) `compare` + x@(VkRenderPassCreateInfo## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkRenderPassCreateInfo where + sizeOf ~_ = #{size VkRenderPassCreateInfo} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkRenderPassCreateInfo} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkRenderPassCreateInfo where + unsafeAddr (VkRenderPassCreateInfo## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkRenderPassCreateInfo## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkRenderPassCreateInfo## (plusAddr## (byteArrayContents## b) off) b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkRenderPassCreateInfo where + type StructFields VkRenderPassCreateInfo = + '["sType", "pNext", "flags", "attachmentCount", "pAttachments", -- ' closing tick for hsc2hs + "subpassCount", "pSubpasses", "dependencyCount", "pDependencies"] + type CUnionType VkRenderPassCreateInfo = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkRenderPassCreateInfo = 'False -- ' closing tick for hsc2hs + type StructExtends VkRenderPassCreateInfo = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkSType VkRenderPassCreateInfo + where + type VkSTypeMType VkRenderPassCreateInfo = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkRenderPassCreateInfo, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkRenderPassCreateInfo, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkRenderPassCreateInfo, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkRenderPassCreateInfo, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkRenderPassCreateInfo where + type FieldType "sType" VkRenderPassCreateInfo = VkStructureType + type FieldOptional "sType" VkRenderPassCreateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkRenderPassCreateInfo = + #{offset VkRenderPassCreateInfo, sType} + type FieldIsArray "sType" VkRenderPassCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkRenderPassCreateInfo, sType} + +instance CanReadField "sType" VkRenderPassCreateInfo where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkRenderPassCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} HasVkPNext VkRenderPassCreateInfo + where + type VkPNextMType VkRenderPassCreateInfo = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkRenderPassCreateInfo, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkRenderPassCreateInfo, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkRenderPassCreateInfo, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkRenderPassCreateInfo, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkRenderPassCreateInfo where + type FieldType "pNext" VkRenderPassCreateInfo = Ptr Void + type FieldOptional "pNext" VkRenderPassCreateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkRenderPassCreateInfo = + #{offset VkRenderPassCreateInfo, pNext} + type FieldIsArray "pNext" VkRenderPassCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkRenderPassCreateInfo, pNext} + +instance CanReadField "pNext" VkRenderPassCreateInfo where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkRenderPassCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} HasVkFlags VkRenderPassCreateInfo + where + type VkFlagsMType VkRenderPassCreateInfo = VkRenderPassCreateFlags + + {-# NOINLINE vkFlags #-} + vkFlags x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkRenderPassCreateInfo, flags}) + + {-# INLINE vkFlagsByteOffset #-} + vkFlagsByteOffset ~_ + = #{offset VkRenderPassCreateInfo, flags} + + {-# INLINE readVkFlags #-} + readVkFlags p + = peekByteOff p #{offset VkRenderPassCreateInfo, flags} + + {-# INLINE writeVkFlags #-} + writeVkFlags p + = pokeByteOff p #{offset VkRenderPassCreateInfo, flags} + +instance {-# OVERLAPPING #-} + HasField "flags" VkRenderPassCreateInfo where + type FieldType "flags" VkRenderPassCreateInfo = + VkRenderPassCreateFlags + type FieldOptional "flags" VkRenderPassCreateInfo = 'True -- ' closing tick for hsc2hs + type FieldOffset "flags" VkRenderPassCreateInfo = + #{offset VkRenderPassCreateInfo, flags} + type FieldIsArray "flags" VkRenderPassCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkRenderPassCreateInfo, flags} + +instance CanReadField "flags" VkRenderPassCreateInfo where + {-# INLINE getField #-} + getField = vkFlags + + {-# INLINE readField #-} + readField = readVkFlags + +instance CanWriteField "flags" VkRenderPassCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkFlags + +instance {-# OVERLAPPING #-} + HasVkAttachmentCount VkRenderPassCreateInfo where + type VkAttachmentCountMType VkRenderPassCreateInfo = Word32 + + {-# NOINLINE vkAttachmentCount #-} + vkAttachmentCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkRenderPassCreateInfo, attachmentCount}) + + {-# INLINE vkAttachmentCountByteOffset #-} + vkAttachmentCountByteOffset ~_ + = #{offset VkRenderPassCreateInfo, attachmentCount} + + {-# INLINE readVkAttachmentCount #-} + readVkAttachmentCount p + = peekByteOff p #{offset VkRenderPassCreateInfo, attachmentCount} + + {-# INLINE writeVkAttachmentCount #-} + writeVkAttachmentCount p + = pokeByteOff p #{offset VkRenderPassCreateInfo, attachmentCount} + +instance {-# OVERLAPPING #-} + HasField "attachmentCount" VkRenderPassCreateInfo where + type FieldType "attachmentCount" VkRenderPassCreateInfo = Word32 + type FieldOptional "attachmentCount" VkRenderPassCreateInfo = 'True -- ' closing tick for hsc2hs + type FieldOffset "attachmentCount" VkRenderPassCreateInfo = + #{offset VkRenderPassCreateInfo, attachmentCount} + type FieldIsArray "attachmentCount" VkRenderPassCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkRenderPassCreateInfo, attachmentCount} + +instance CanReadField "attachmentCount" VkRenderPassCreateInfo + where + {-# INLINE getField #-} + getField = vkAttachmentCount + + {-# INLINE readField #-} + readField = readVkAttachmentCount + +instance CanWriteField "attachmentCount" VkRenderPassCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkAttachmentCount + +instance {-# OVERLAPPING #-} + HasVkPAttachments VkRenderPassCreateInfo where + type VkPAttachmentsMType VkRenderPassCreateInfo = + Ptr VkAttachmentDescription + + {-# NOINLINE vkPAttachments #-} + vkPAttachments x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkRenderPassCreateInfo, pAttachments}) + + {-# INLINE vkPAttachmentsByteOffset #-} + vkPAttachmentsByteOffset ~_ + = #{offset VkRenderPassCreateInfo, pAttachments} + + {-# INLINE readVkPAttachments #-} + readVkPAttachments p + = peekByteOff p #{offset VkRenderPassCreateInfo, pAttachments} + + {-# INLINE writeVkPAttachments #-} + writeVkPAttachments p + = pokeByteOff p #{offset VkRenderPassCreateInfo, pAttachments} + +instance {-# OVERLAPPING #-} + HasField "pAttachments" VkRenderPassCreateInfo where + type FieldType "pAttachments" VkRenderPassCreateInfo = + Ptr VkAttachmentDescription + type FieldOptional "pAttachments" VkRenderPassCreateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "pAttachments" VkRenderPassCreateInfo = + #{offset VkRenderPassCreateInfo, pAttachments} + type FieldIsArray "pAttachments" VkRenderPassCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkRenderPassCreateInfo, pAttachments} + +instance CanReadField "pAttachments" VkRenderPassCreateInfo where + {-# INLINE getField #-} + getField = vkPAttachments + + {-# INLINE readField #-} + readField = readVkPAttachments + +instance CanWriteField "pAttachments" VkRenderPassCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkPAttachments + +instance {-# OVERLAPPING #-} + HasVkSubpassCount VkRenderPassCreateInfo where + type VkSubpassCountMType VkRenderPassCreateInfo = Word32 + + {-# NOINLINE vkSubpassCount #-} + vkSubpassCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkRenderPassCreateInfo, subpassCount}) + + {-# INLINE vkSubpassCountByteOffset #-} + vkSubpassCountByteOffset ~_ + = #{offset VkRenderPassCreateInfo, subpassCount} + + {-# INLINE readVkSubpassCount #-} + readVkSubpassCount p + = peekByteOff p #{offset VkRenderPassCreateInfo, subpassCount} + + {-# INLINE writeVkSubpassCount #-} + writeVkSubpassCount p + = pokeByteOff p #{offset VkRenderPassCreateInfo, subpassCount} + +instance {-# OVERLAPPING #-} + HasField "subpassCount" VkRenderPassCreateInfo where + type FieldType "subpassCount" VkRenderPassCreateInfo = Word32 + type FieldOptional "subpassCount" VkRenderPassCreateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "subpassCount" VkRenderPassCreateInfo = + #{offset VkRenderPassCreateInfo, subpassCount} + type FieldIsArray "subpassCount" VkRenderPassCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkRenderPassCreateInfo, subpassCount} + +instance CanReadField "subpassCount" VkRenderPassCreateInfo where + {-# INLINE getField #-} + getField = vkSubpassCount + + {-# INLINE readField #-} + readField = readVkSubpassCount + +instance CanWriteField "subpassCount" VkRenderPassCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkSubpassCount + +instance {-# OVERLAPPING #-} HasVkPSubpasses VkRenderPassCreateInfo + where + type VkPSubpassesMType VkRenderPassCreateInfo = + Ptr VkSubpassDescription + + {-# NOINLINE vkPSubpasses #-} + vkPSubpasses x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkRenderPassCreateInfo, pSubpasses}) + + {-# INLINE vkPSubpassesByteOffset #-} + vkPSubpassesByteOffset ~_ + = #{offset VkRenderPassCreateInfo, pSubpasses} + + {-# INLINE readVkPSubpasses #-} + readVkPSubpasses p + = peekByteOff p #{offset VkRenderPassCreateInfo, pSubpasses} + + {-# INLINE writeVkPSubpasses #-} + writeVkPSubpasses p + = pokeByteOff p #{offset VkRenderPassCreateInfo, pSubpasses} + +instance {-# OVERLAPPING #-} + HasField "pSubpasses" VkRenderPassCreateInfo where + type FieldType "pSubpasses" VkRenderPassCreateInfo = + Ptr VkSubpassDescription + type FieldOptional "pSubpasses" VkRenderPassCreateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "pSubpasses" VkRenderPassCreateInfo = + #{offset VkRenderPassCreateInfo, pSubpasses} + type FieldIsArray "pSubpasses" VkRenderPassCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkRenderPassCreateInfo, pSubpasses} + +instance CanReadField "pSubpasses" VkRenderPassCreateInfo where + {-# INLINE getField #-} + getField = vkPSubpasses + + {-# INLINE readField #-} + readField = readVkPSubpasses + +instance CanWriteField "pSubpasses" VkRenderPassCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkPSubpasses + +instance {-# OVERLAPPING #-} + HasVkDependencyCount VkRenderPassCreateInfo where + type VkDependencyCountMType VkRenderPassCreateInfo = Word32 + + {-# NOINLINE vkDependencyCount #-} + vkDependencyCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkRenderPassCreateInfo, dependencyCount}) + + {-# INLINE vkDependencyCountByteOffset #-} + vkDependencyCountByteOffset ~_ + = #{offset VkRenderPassCreateInfo, dependencyCount} + + {-# INLINE readVkDependencyCount #-} + readVkDependencyCount p + = peekByteOff p #{offset VkRenderPassCreateInfo, dependencyCount} + + {-# INLINE writeVkDependencyCount #-} + writeVkDependencyCount p + = pokeByteOff p #{offset VkRenderPassCreateInfo, dependencyCount} + +instance {-# OVERLAPPING #-} + HasField "dependencyCount" VkRenderPassCreateInfo where + type FieldType "dependencyCount" VkRenderPassCreateInfo = Word32 + type FieldOptional "dependencyCount" VkRenderPassCreateInfo = 'True -- ' closing tick for hsc2hs + type FieldOffset "dependencyCount" VkRenderPassCreateInfo = + #{offset VkRenderPassCreateInfo, dependencyCount} + type FieldIsArray "dependencyCount" VkRenderPassCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkRenderPassCreateInfo, dependencyCount} + +instance CanReadField "dependencyCount" VkRenderPassCreateInfo + where + {-# INLINE getField #-} + getField = vkDependencyCount + + {-# INLINE readField #-} + readField = readVkDependencyCount + +instance CanWriteField "dependencyCount" VkRenderPassCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkDependencyCount + +instance {-# OVERLAPPING #-} + HasVkPDependencies VkRenderPassCreateInfo where + type VkPDependenciesMType VkRenderPassCreateInfo = + Ptr VkSubpassDependency + + {-# NOINLINE vkPDependencies #-} + vkPDependencies x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkRenderPassCreateInfo, pDependencies}) + + {-# INLINE vkPDependenciesByteOffset #-} + vkPDependenciesByteOffset ~_ + = #{offset VkRenderPassCreateInfo, pDependencies} + + {-# INLINE readVkPDependencies #-} + readVkPDependencies p + = peekByteOff p #{offset VkRenderPassCreateInfo, pDependencies} + + {-# INLINE writeVkPDependencies #-} + writeVkPDependencies p + = pokeByteOff p #{offset VkRenderPassCreateInfo, pDependencies} + +instance {-# OVERLAPPING #-} + HasField "pDependencies" VkRenderPassCreateInfo where + type FieldType "pDependencies" VkRenderPassCreateInfo = + Ptr VkSubpassDependency + type FieldOptional "pDependencies" VkRenderPassCreateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "pDependencies" VkRenderPassCreateInfo = + #{offset VkRenderPassCreateInfo, pDependencies} + type FieldIsArray "pDependencies" VkRenderPassCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkRenderPassCreateInfo, pDependencies} + +instance CanReadField "pDependencies" VkRenderPassCreateInfo where + {-# INLINE getField #-} + getField = vkPDependencies + + {-# INLINE readField #-} + readField = readVkPDependencies + +instance CanWriteField "pDependencies" VkRenderPassCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkPDependencies + +instance Show VkRenderPassCreateInfo where + showsPrec d x + = showString "VkRenderPassCreateInfo {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkFlags = " . + showsPrec d (vkFlags x) . + showString ", " . + showString "vkAttachmentCount = " . + showsPrec d (vkAttachmentCount x) . + showString ", " . + showString "vkPAttachments = " . + showsPrec d (vkPAttachments x) . + showString ", " . + showString "vkSubpassCount = " . + showsPrec d (vkSubpassCount x) . + showString ", " . + showString "vkPSubpasses = " . + showsPrec d (vkPSubpasses x) . + showString ", " . + showString "vkDependencyCount = " . + showsPrec d (vkDependencyCount x) . + showString ", " . + showString "vkPDependencies = " . + showsPrec d (vkPDependencies x) . + showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkRenderPassInputAttachmentAspectCreateInfoKHR.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkRenderPassInputAttachmentAspectCreateInfoKHR.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkRenderPassInputAttachmentAspectCreateInfoKHR.hsc @@ -0,0 +1,363 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkRenderPassInputAttachmentAspectCreateInfoKHR + (VkRenderPassInputAttachmentAspectCreateInfoKHR(..)) where +import Foreign.Storable + (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkStructureType + (VkStructureType) +import Graphics.Vulkan.Types.Struct.VkInputAttachmentAspectReferenceKHR + (VkInputAttachmentAspectReferenceKHR) +import Graphics.Vulkan.Types.Struct.VkRenderPassCreateInfo + (VkRenderPassCreateInfo) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe + (unsafeDupablePerformIO) + +-- | > typedef struct VkRenderPassInputAttachmentAspectCreateInfoKHR { +-- > VkStructureType sType; +-- > const void* pNext; +-- > uint32_t aspectReferenceCount; +-- > const VkInputAttachmentAspectReferenceKHR* pAspectReferences; +-- > } VkRenderPassInputAttachmentAspectCreateInfoKHR; +-- +-- +data VkRenderPassInputAttachmentAspectCreateInfoKHR = VkRenderPassInputAttachmentAspectCreateInfoKHR## Addr## + ByteArray## + +instance Eq VkRenderPassInputAttachmentAspectCreateInfoKHR where + (VkRenderPassInputAttachmentAspectCreateInfoKHR## a _) == + x@(VkRenderPassInputAttachmentAspectCreateInfoKHR## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkRenderPassInputAttachmentAspectCreateInfoKHR where + (VkRenderPassInputAttachmentAspectCreateInfoKHR## a _) `compare` + x@(VkRenderPassInputAttachmentAspectCreateInfoKHR## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkRenderPassInputAttachmentAspectCreateInfoKHR + where + sizeOf ~_ + = #{size VkRenderPassInputAttachmentAspectCreateInfoKHR} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkRenderPassInputAttachmentAspectCreateInfoKHR} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim + VkRenderPassInputAttachmentAspectCreateInfoKHR + where + unsafeAddr (VkRenderPassInputAttachmentAspectCreateInfoKHR## a _) + = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray + (VkRenderPassInputAttachmentAspectCreateInfoKHR## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkRenderPassInputAttachmentAspectCreateInfoKHR## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal + VkRenderPassInputAttachmentAspectCreateInfoKHR + where + type StructFields VkRenderPassInputAttachmentAspectCreateInfoKHR = + '["sType", "pNext", "aspectReferenceCount", "pAspectReferences"] -- ' closing tick for hsc2hs + type CUnionType VkRenderPassInputAttachmentAspectCreateInfoKHR = + 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkRenderPassInputAttachmentAspectCreateInfoKHR = + 'False -- ' closing tick for hsc2hs + type StructExtends VkRenderPassInputAttachmentAspectCreateInfoKHR = + '[VkRenderPassCreateInfo] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkRenderPassInputAttachmentAspectCreateInfoKHR where + type VkSTypeMType VkRenderPassInputAttachmentAspectCreateInfoKHR = + VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkRenderPassInputAttachmentAspectCreateInfoKHR, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkRenderPassInputAttachmentAspectCreateInfoKHR, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkRenderPassInputAttachmentAspectCreateInfoKHR, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkRenderPassInputAttachmentAspectCreateInfoKHR, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkRenderPassInputAttachmentAspectCreateInfoKHR + where + type FieldType "sType" + VkRenderPassInputAttachmentAspectCreateInfoKHR + = VkStructureType + type FieldOptional "sType" + VkRenderPassInputAttachmentAspectCreateInfoKHR + = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" + VkRenderPassInputAttachmentAspectCreateInfoKHR + = + #{offset VkRenderPassInputAttachmentAspectCreateInfoKHR, sType} + type FieldIsArray "sType" + VkRenderPassInputAttachmentAspectCreateInfoKHR + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkRenderPassInputAttachmentAspectCreateInfoKHR, sType} + +instance CanReadField "sType" + VkRenderPassInputAttachmentAspectCreateInfoKHR + where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" + VkRenderPassInputAttachmentAspectCreateInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkRenderPassInputAttachmentAspectCreateInfoKHR where + type VkPNextMType VkRenderPassInputAttachmentAspectCreateInfoKHR = + Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkRenderPassInputAttachmentAspectCreateInfoKHR, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkRenderPassInputAttachmentAspectCreateInfoKHR, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkRenderPassInputAttachmentAspectCreateInfoKHR, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkRenderPassInputAttachmentAspectCreateInfoKHR, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkRenderPassInputAttachmentAspectCreateInfoKHR + where + type FieldType "pNext" + VkRenderPassInputAttachmentAspectCreateInfoKHR + = Ptr Void + type FieldOptional "pNext" + VkRenderPassInputAttachmentAspectCreateInfoKHR + = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" + VkRenderPassInputAttachmentAspectCreateInfoKHR + = + #{offset VkRenderPassInputAttachmentAspectCreateInfoKHR, pNext} + type FieldIsArray "pNext" + VkRenderPassInputAttachmentAspectCreateInfoKHR + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkRenderPassInputAttachmentAspectCreateInfoKHR, pNext} + +instance CanReadField "pNext" + VkRenderPassInputAttachmentAspectCreateInfoKHR + where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" + VkRenderPassInputAttachmentAspectCreateInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkAspectReferenceCount + VkRenderPassInputAttachmentAspectCreateInfoKHR + where + type VkAspectReferenceCountMType + VkRenderPassInputAttachmentAspectCreateInfoKHR + = Word32 + + {-# NOINLINE vkAspectReferenceCount #-} + vkAspectReferenceCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkRenderPassInputAttachmentAspectCreateInfoKHR, aspectReferenceCount}) + + {-# INLINE vkAspectReferenceCountByteOffset #-} + vkAspectReferenceCountByteOffset ~_ + = #{offset VkRenderPassInputAttachmentAspectCreateInfoKHR, aspectReferenceCount} + + {-# INLINE readVkAspectReferenceCount #-} + readVkAspectReferenceCount p + = peekByteOff p #{offset VkRenderPassInputAttachmentAspectCreateInfoKHR, aspectReferenceCount} + + {-# INLINE writeVkAspectReferenceCount #-} + writeVkAspectReferenceCount p + = pokeByteOff p #{offset VkRenderPassInputAttachmentAspectCreateInfoKHR, aspectReferenceCount} + +instance {-# OVERLAPPING #-} + HasField "aspectReferenceCount" + VkRenderPassInputAttachmentAspectCreateInfoKHR + where + type FieldType "aspectReferenceCount" + VkRenderPassInputAttachmentAspectCreateInfoKHR + = Word32 + type FieldOptional "aspectReferenceCount" + VkRenderPassInputAttachmentAspectCreateInfoKHR + = 'False -- ' closing tick for hsc2hs + type FieldOffset "aspectReferenceCount" + VkRenderPassInputAttachmentAspectCreateInfoKHR + = + #{offset VkRenderPassInputAttachmentAspectCreateInfoKHR, aspectReferenceCount} + type FieldIsArray "aspectReferenceCount" + VkRenderPassInputAttachmentAspectCreateInfoKHR + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkRenderPassInputAttachmentAspectCreateInfoKHR, aspectReferenceCount} + +instance CanReadField "aspectReferenceCount" + VkRenderPassInputAttachmentAspectCreateInfoKHR + where + {-# INLINE getField #-} + getField = vkAspectReferenceCount + + {-# INLINE readField #-} + readField = readVkAspectReferenceCount + +instance CanWriteField "aspectReferenceCount" + VkRenderPassInputAttachmentAspectCreateInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkAspectReferenceCount + +instance {-# OVERLAPPING #-} + HasVkPAspectReferences + VkRenderPassInputAttachmentAspectCreateInfoKHR + where + type VkPAspectReferencesMType + VkRenderPassInputAttachmentAspectCreateInfoKHR + = Ptr VkInputAttachmentAspectReferenceKHR + + {-# NOINLINE vkPAspectReferences #-} + vkPAspectReferences x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkRenderPassInputAttachmentAspectCreateInfoKHR, pAspectReferences}) + + {-# INLINE vkPAspectReferencesByteOffset #-} + vkPAspectReferencesByteOffset ~_ + = #{offset VkRenderPassInputAttachmentAspectCreateInfoKHR, pAspectReferences} + + {-# INLINE readVkPAspectReferences #-} + readVkPAspectReferences p + = peekByteOff p #{offset VkRenderPassInputAttachmentAspectCreateInfoKHR, pAspectReferences} + + {-# INLINE writeVkPAspectReferences #-} + writeVkPAspectReferences p + = pokeByteOff p #{offset VkRenderPassInputAttachmentAspectCreateInfoKHR, pAspectReferences} + +instance {-# OVERLAPPING #-} + HasField "pAspectReferences" + VkRenderPassInputAttachmentAspectCreateInfoKHR + where + type FieldType "pAspectReferences" + VkRenderPassInputAttachmentAspectCreateInfoKHR + = Ptr VkInputAttachmentAspectReferenceKHR + type FieldOptional "pAspectReferences" + VkRenderPassInputAttachmentAspectCreateInfoKHR + = 'False -- ' closing tick for hsc2hs + type FieldOffset "pAspectReferences" + VkRenderPassInputAttachmentAspectCreateInfoKHR + = + #{offset VkRenderPassInputAttachmentAspectCreateInfoKHR, pAspectReferences} + type FieldIsArray "pAspectReferences" + VkRenderPassInputAttachmentAspectCreateInfoKHR + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkRenderPassInputAttachmentAspectCreateInfoKHR, pAspectReferences} + +instance CanReadField "pAspectReferences" + VkRenderPassInputAttachmentAspectCreateInfoKHR + where + {-# INLINE getField #-} + getField = vkPAspectReferences + + {-# INLINE readField #-} + readField = readVkPAspectReferences + +instance CanWriteField "pAspectReferences" + VkRenderPassInputAttachmentAspectCreateInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkPAspectReferences + +instance Show VkRenderPassInputAttachmentAspectCreateInfoKHR where + showsPrec d x + = showString "VkRenderPassInputAttachmentAspectCreateInfoKHR {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkAspectReferenceCount = " . + showsPrec d (vkAspectReferenceCount x) . + showString ", " . + showString "vkPAspectReferences = " . + showsPrec d (vkPAspectReferences x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkRenderPassMultiviewCreateInfoKHX.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkRenderPassMultiviewCreateInfoKHX.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkRenderPassMultiviewCreateInfoKHX.hsc @@ -0,0 +1,569 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkRenderPassMultiviewCreateInfoKHX + (VkRenderPassMultiviewCreateInfoKHX(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Struct.VkRenderPassCreateInfo (VkRenderPassCreateInfo) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkRenderPassMultiviewCreateInfoKHX { +-- > VkStructureType sType; +-- > const void* pNext; +-- > uint32_t subpassCount; +-- > const uint32_t* pViewMasks; +-- > uint32_t dependencyCount; +-- > const int32_t* pViewOffsets; +-- > uint32_t correlationMaskCount; +-- > const uint32_t* pCorrelationMasks; +-- > } VkRenderPassMultiviewCreateInfoKHX; +-- +-- +data VkRenderPassMultiviewCreateInfoKHX = VkRenderPassMultiviewCreateInfoKHX## Addr## + ByteArray## + +instance Eq VkRenderPassMultiviewCreateInfoKHX where + (VkRenderPassMultiviewCreateInfoKHX## a _) == + x@(VkRenderPassMultiviewCreateInfoKHX## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkRenderPassMultiviewCreateInfoKHX where + (VkRenderPassMultiviewCreateInfoKHX## a _) `compare` + x@(VkRenderPassMultiviewCreateInfoKHX## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkRenderPassMultiviewCreateInfoKHX where + sizeOf ~_ = #{size VkRenderPassMultiviewCreateInfoKHX} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkRenderPassMultiviewCreateInfoKHX} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkRenderPassMultiviewCreateInfoKHX where + unsafeAddr (VkRenderPassMultiviewCreateInfoKHX## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkRenderPassMultiviewCreateInfoKHX## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkRenderPassMultiviewCreateInfoKHX## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkRenderPassMultiviewCreateInfoKHX where + type StructFields VkRenderPassMultiviewCreateInfoKHX = + '["sType", "pNext", "subpassCount", "pViewMasks", -- ' closing tick for hsc2hs + "dependencyCount", "pViewOffsets", "correlationMaskCount", + "pCorrelationMasks"] + type CUnionType VkRenderPassMultiviewCreateInfoKHX = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkRenderPassMultiviewCreateInfoKHX = 'False -- ' closing tick for hsc2hs + type StructExtends VkRenderPassMultiviewCreateInfoKHX = + '[VkRenderPassCreateInfo] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkRenderPassMultiviewCreateInfoKHX where + type VkSTypeMType VkRenderPassMultiviewCreateInfoKHX = + VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkRenderPassMultiviewCreateInfoKHX, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkRenderPassMultiviewCreateInfoKHX, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkRenderPassMultiviewCreateInfoKHX, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkRenderPassMultiviewCreateInfoKHX, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkRenderPassMultiviewCreateInfoKHX where + type FieldType "sType" VkRenderPassMultiviewCreateInfoKHX = + VkStructureType + type FieldOptional "sType" VkRenderPassMultiviewCreateInfoKHX = + 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkRenderPassMultiviewCreateInfoKHX = + #{offset VkRenderPassMultiviewCreateInfoKHX, sType} + type FieldIsArray "sType" VkRenderPassMultiviewCreateInfoKHX = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkRenderPassMultiviewCreateInfoKHX, sType} + +instance CanReadField "sType" VkRenderPassMultiviewCreateInfoKHX + where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkRenderPassMultiviewCreateInfoKHX + where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkRenderPassMultiviewCreateInfoKHX where + type VkPNextMType VkRenderPassMultiviewCreateInfoKHX = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkRenderPassMultiviewCreateInfoKHX, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkRenderPassMultiviewCreateInfoKHX, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkRenderPassMultiviewCreateInfoKHX, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkRenderPassMultiviewCreateInfoKHX, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkRenderPassMultiviewCreateInfoKHX where + type FieldType "pNext" VkRenderPassMultiviewCreateInfoKHX = + Ptr Void + type FieldOptional "pNext" VkRenderPassMultiviewCreateInfoKHX = + 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkRenderPassMultiviewCreateInfoKHX = + #{offset VkRenderPassMultiviewCreateInfoKHX, pNext} + type FieldIsArray "pNext" VkRenderPassMultiviewCreateInfoKHX = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkRenderPassMultiviewCreateInfoKHX, pNext} + +instance CanReadField "pNext" VkRenderPassMultiviewCreateInfoKHX + where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkRenderPassMultiviewCreateInfoKHX + where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkSubpassCount VkRenderPassMultiviewCreateInfoKHX where + type VkSubpassCountMType VkRenderPassMultiviewCreateInfoKHX = + Word32 + + {-# NOINLINE vkSubpassCount #-} + vkSubpassCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkRenderPassMultiviewCreateInfoKHX, subpassCount}) + + {-# INLINE vkSubpassCountByteOffset #-} + vkSubpassCountByteOffset ~_ + = #{offset VkRenderPassMultiviewCreateInfoKHX, subpassCount} + + {-# INLINE readVkSubpassCount #-} + readVkSubpassCount p + = peekByteOff p #{offset VkRenderPassMultiviewCreateInfoKHX, subpassCount} + + {-# INLINE writeVkSubpassCount #-} + writeVkSubpassCount p + = pokeByteOff p #{offset VkRenderPassMultiviewCreateInfoKHX, subpassCount} + +instance {-# OVERLAPPING #-} + HasField "subpassCount" VkRenderPassMultiviewCreateInfoKHX where + type FieldType "subpassCount" VkRenderPassMultiviewCreateInfoKHX = + Word32 + type FieldOptional "subpassCount" + VkRenderPassMultiviewCreateInfoKHX + = 'True -- ' closing tick for hsc2hs + type FieldOffset "subpassCount" VkRenderPassMultiviewCreateInfoKHX + = + #{offset VkRenderPassMultiviewCreateInfoKHX, subpassCount} + type FieldIsArray "subpassCount" VkRenderPassMultiviewCreateInfoKHX + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkRenderPassMultiviewCreateInfoKHX, subpassCount} + +instance CanReadField "subpassCount" + VkRenderPassMultiviewCreateInfoKHX + where + {-# INLINE getField #-} + getField = vkSubpassCount + + {-# INLINE readField #-} + readField = readVkSubpassCount + +instance CanWriteField "subpassCount" + VkRenderPassMultiviewCreateInfoKHX + where + {-# INLINE writeField #-} + writeField = writeVkSubpassCount + +instance {-# OVERLAPPING #-} + HasVkPViewMasks VkRenderPassMultiviewCreateInfoKHX where + type VkPViewMasksMType VkRenderPassMultiviewCreateInfoKHX = + Ptr Word32 + + {-# NOINLINE vkPViewMasks #-} + vkPViewMasks x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkRenderPassMultiviewCreateInfoKHX, pViewMasks}) + + {-# INLINE vkPViewMasksByteOffset #-} + vkPViewMasksByteOffset ~_ + = #{offset VkRenderPassMultiviewCreateInfoKHX, pViewMasks} + + {-# INLINE readVkPViewMasks #-} + readVkPViewMasks p + = peekByteOff p #{offset VkRenderPassMultiviewCreateInfoKHX, pViewMasks} + + {-# INLINE writeVkPViewMasks #-} + writeVkPViewMasks p + = pokeByteOff p #{offset VkRenderPassMultiviewCreateInfoKHX, pViewMasks} + +instance {-# OVERLAPPING #-} + HasField "pViewMasks" VkRenderPassMultiviewCreateInfoKHX where + type FieldType "pViewMasks" VkRenderPassMultiviewCreateInfoKHX = + Ptr Word32 + type FieldOptional "pViewMasks" VkRenderPassMultiviewCreateInfoKHX + = 'False -- ' closing tick for hsc2hs + type FieldOffset "pViewMasks" VkRenderPassMultiviewCreateInfoKHX = + #{offset VkRenderPassMultiviewCreateInfoKHX, pViewMasks} + type FieldIsArray "pViewMasks" VkRenderPassMultiviewCreateInfoKHX = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkRenderPassMultiviewCreateInfoKHX, pViewMasks} + +instance CanReadField "pViewMasks" + VkRenderPassMultiviewCreateInfoKHX + where + {-# INLINE getField #-} + getField = vkPViewMasks + + {-# INLINE readField #-} + readField = readVkPViewMasks + +instance CanWriteField "pViewMasks" + VkRenderPassMultiviewCreateInfoKHX + where + {-# INLINE writeField #-} + writeField = writeVkPViewMasks + +instance {-# OVERLAPPING #-} + HasVkDependencyCount VkRenderPassMultiviewCreateInfoKHX where + type VkDependencyCountMType VkRenderPassMultiviewCreateInfoKHX = + Word32 + + {-# NOINLINE vkDependencyCount #-} + vkDependencyCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkRenderPassMultiviewCreateInfoKHX, dependencyCount}) + + {-# INLINE vkDependencyCountByteOffset #-} + vkDependencyCountByteOffset ~_ + = #{offset VkRenderPassMultiviewCreateInfoKHX, dependencyCount} + + {-# INLINE readVkDependencyCount #-} + readVkDependencyCount p + = peekByteOff p #{offset VkRenderPassMultiviewCreateInfoKHX, dependencyCount} + + {-# INLINE writeVkDependencyCount #-} + writeVkDependencyCount p + = pokeByteOff p #{offset VkRenderPassMultiviewCreateInfoKHX, dependencyCount} + +instance {-# OVERLAPPING #-} + HasField "dependencyCount" VkRenderPassMultiviewCreateInfoKHX where + type FieldType "dependencyCount" VkRenderPassMultiviewCreateInfoKHX + = Word32 + type FieldOptional "dependencyCount" + VkRenderPassMultiviewCreateInfoKHX + = 'True -- ' closing tick for hsc2hs + type FieldOffset "dependencyCount" + VkRenderPassMultiviewCreateInfoKHX + = + #{offset VkRenderPassMultiviewCreateInfoKHX, dependencyCount} + type FieldIsArray "dependencyCount" + VkRenderPassMultiviewCreateInfoKHX + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkRenderPassMultiviewCreateInfoKHX, dependencyCount} + +instance CanReadField "dependencyCount" + VkRenderPassMultiviewCreateInfoKHX + where + {-# INLINE getField #-} + getField = vkDependencyCount + + {-# INLINE readField #-} + readField = readVkDependencyCount + +instance CanWriteField "dependencyCount" + VkRenderPassMultiviewCreateInfoKHX + where + {-# INLINE writeField #-} + writeField = writeVkDependencyCount + +instance {-# OVERLAPPING #-} + HasVkPViewOffsets VkRenderPassMultiviewCreateInfoKHX where + type VkPViewOffsetsMType VkRenderPassMultiviewCreateInfoKHX = + Ptr Int32 + + {-# NOINLINE vkPViewOffsets #-} + vkPViewOffsets x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkRenderPassMultiviewCreateInfoKHX, pViewOffsets}) + + {-# INLINE vkPViewOffsetsByteOffset #-} + vkPViewOffsetsByteOffset ~_ + = #{offset VkRenderPassMultiviewCreateInfoKHX, pViewOffsets} + + {-# INLINE readVkPViewOffsets #-} + readVkPViewOffsets p + = peekByteOff p #{offset VkRenderPassMultiviewCreateInfoKHX, pViewOffsets} + + {-# INLINE writeVkPViewOffsets #-} + writeVkPViewOffsets p + = pokeByteOff p #{offset VkRenderPassMultiviewCreateInfoKHX, pViewOffsets} + +instance {-# OVERLAPPING #-} + HasField "pViewOffsets" VkRenderPassMultiviewCreateInfoKHX where + type FieldType "pViewOffsets" VkRenderPassMultiviewCreateInfoKHX = + Ptr Int32 + type FieldOptional "pViewOffsets" + VkRenderPassMultiviewCreateInfoKHX + = 'False -- ' closing tick for hsc2hs + type FieldOffset "pViewOffsets" VkRenderPassMultiviewCreateInfoKHX + = + #{offset VkRenderPassMultiviewCreateInfoKHX, pViewOffsets} + type FieldIsArray "pViewOffsets" VkRenderPassMultiviewCreateInfoKHX + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkRenderPassMultiviewCreateInfoKHX, pViewOffsets} + +instance CanReadField "pViewOffsets" + VkRenderPassMultiviewCreateInfoKHX + where + {-# INLINE getField #-} + getField = vkPViewOffsets + + {-# INLINE readField #-} + readField = readVkPViewOffsets + +instance CanWriteField "pViewOffsets" + VkRenderPassMultiviewCreateInfoKHX + where + {-# INLINE writeField #-} + writeField = writeVkPViewOffsets + +instance {-# OVERLAPPING #-} + HasVkCorrelationMaskCount VkRenderPassMultiviewCreateInfoKHX where + type VkCorrelationMaskCountMType VkRenderPassMultiviewCreateInfoKHX + = Word32 + + {-# NOINLINE vkCorrelationMaskCount #-} + vkCorrelationMaskCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkRenderPassMultiviewCreateInfoKHX, correlationMaskCount}) + + {-# INLINE vkCorrelationMaskCountByteOffset #-} + vkCorrelationMaskCountByteOffset ~_ + = #{offset VkRenderPassMultiviewCreateInfoKHX, correlationMaskCount} + + {-# INLINE readVkCorrelationMaskCount #-} + readVkCorrelationMaskCount p + = peekByteOff p #{offset VkRenderPassMultiviewCreateInfoKHX, correlationMaskCount} + + {-# INLINE writeVkCorrelationMaskCount #-} + writeVkCorrelationMaskCount p + = pokeByteOff p #{offset VkRenderPassMultiviewCreateInfoKHX, correlationMaskCount} + +instance {-# OVERLAPPING #-} + HasField "correlationMaskCount" VkRenderPassMultiviewCreateInfoKHX + where + type FieldType "correlationMaskCount" + VkRenderPassMultiviewCreateInfoKHX + = Word32 + type FieldOptional "correlationMaskCount" + VkRenderPassMultiviewCreateInfoKHX + = 'True -- ' closing tick for hsc2hs + type FieldOffset "correlationMaskCount" + VkRenderPassMultiviewCreateInfoKHX + = + #{offset VkRenderPassMultiviewCreateInfoKHX, correlationMaskCount} + type FieldIsArray "correlationMaskCount" + VkRenderPassMultiviewCreateInfoKHX + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkRenderPassMultiviewCreateInfoKHX, correlationMaskCount} + +instance CanReadField "correlationMaskCount" + VkRenderPassMultiviewCreateInfoKHX + where + {-# INLINE getField #-} + getField = vkCorrelationMaskCount + + {-# INLINE readField #-} + readField = readVkCorrelationMaskCount + +instance CanWriteField "correlationMaskCount" + VkRenderPassMultiviewCreateInfoKHX + where + {-# INLINE writeField #-} + writeField = writeVkCorrelationMaskCount + +instance {-# OVERLAPPING #-} + HasVkPCorrelationMasks VkRenderPassMultiviewCreateInfoKHX where + type VkPCorrelationMasksMType VkRenderPassMultiviewCreateInfoKHX = + Ptr Word32 + + {-# NOINLINE vkPCorrelationMasks #-} + vkPCorrelationMasks x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkRenderPassMultiviewCreateInfoKHX, pCorrelationMasks}) + + {-# INLINE vkPCorrelationMasksByteOffset #-} + vkPCorrelationMasksByteOffset ~_ + = #{offset VkRenderPassMultiviewCreateInfoKHX, pCorrelationMasks} + + {-# INLINE readVkPCorrelationMasks #-} + readVkPCorrelationMasks p + = peekByteOff p #{offset VkRenderPassMultiviewCreateInfoKHX, pCorrelationMasks} + + {-# INLINE writeVkPCorrelationMasks #-} + writeVkPCorrelationMasks p + = pokeByteOff p #{offset VkRenderPassMultiviewCreateInfoKHX, pCorrelationMasks} + +instance {-# OVERLAPPING #-} + HasField "pCorrelationMasks" VkRenderPassMultiviewCreateInfoKHX + where + type FieldType "pCorrelationMasks" + VkRenderPassMultiviewCreateInfoKHX + = Ptr Word32 + type FieldOptional "pCorrelationMasks" + VkRenderPassMultiviewCreateInfoKHX + = 'False -- ' closing tick for hsc2hs + type FieldOffset "pCorrelationMasks" + VkRenderPassMultiviewCreateInfoKHX + = + #{offset VkRenderPassMultiviewCreateInfoKHX, pCorrelationMasks} + type FieldIsArray "pCorrelationMasks" + VkRenderPassMultiviewCreateInfoKHX + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkRenderPassMultiviewCreateInfoKHX, pCorrelationMasks} + +instance CanReadField "pCorrelationMasks" + VkRenderPassMultiviewCreateInfoKHX + where + {-# INLINE getField #-} + getField = vkPCorrelationMasks + + {-# INLINE readField #-} + readField = readVkPCorrelationMasks + +instance CanWriteField "pCorrelationMasks" + VkRenderPassMultiviewCreateInfoKHX + where + {-# INLINE writeField #-} + writeField = writeVkPCorrelationMasks + +instance Show VkRenderPassMultiviewCreateInfoKHX where + showsPrec d x + = showString "VkRenderPassMultiviewCreateInfoKHX {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkSubpassCount = " . + showsPrec d (vkSubpassCount x) . + showString ", " . + showString "vkPViewMasks = " . + showsPrec d (vkPViewMasks x) . + showString ", " . + showString "vkDependencyCount = " . + showsPrec d (vkDependencyCount x) . + showString ", " . + showString "vkPViewOffsets = " . + showsPrec d (vkPViewOffsets x) . + showString ", " . + showString "vkCorrelationMaskCount = " . + showsPrec d (vkCorrelationMaskCount x) . + showString ", " . + showString "vkPCorrelationMasks = " . + showsPrec d (vkPCorrelationMasks x) . + showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkRenderPassSampleLocationsBeginInfoEXT.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkRenderPassSampleLocationsBeginInfoEXT.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkRenderPassSampleLocationsBeginInfoEXT.hsc @@ -0,0 +1,481 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkRenderPassSampleLocationsBeginInfoEXT + (VkRenderPassSampleLocationsBeginInfoEXT(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Struct.VkAttachmentSampleLocationsEXT (VkAttachmentSampleLocationsEXT) +import Graphics.Vulkan.Types.Struct.VkRenderPassBeginInfo (VkRenderPassBeginInfo) +import Graphics.Vulkan.Types.Struct.VkSubpassSampleLocationsEXT (VkSubpassSampleLocationsEXT) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkRenderPassSampleLocationsBeginInfoEXT { +-- > VkStructureType sType; +-- > const void* pNext; +-- > uint32_t attachmentInitialSampleLocationsCount; +-- > const VkAttachmentSampleLocationsEXT* pAttachmentInitialSampleLocations; +-- > uint32_t postSubpassSampleLocationsCount; +-- > const VkSubpassSampleLocationsEXT* pPostSubpassSampleLocations; +-- > } VkRenderPassSampleLocationsBeginInfoEXT; +-- +-- +data VkRenderPassSampleLocationsBeginInfoEXT = VkRenderPassSampleLocationsBeginInfoEXT## Addr## + ByteArray## + +instance Eq VkRenderPassSampleLocationsBeginInfoEXT where + (VkRenderPassSampleLocationsBeginInfoEXT## a _) == + x@(VkRenderPassSampleLocationsBeginInfoEXT## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkRenderPassSampleLocationsBeginInfoEXT where + (VkRenderPassSampleLocationsBeginInfoEXT## a _) `compare` + x@(VkRenderPassSampleLocationsBeginInfoEXT## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkRenderPassSampleLocationsBeginInfoEXT where + sizeOf ~_ + = #{size VkRenderPassSampleLocationsBeginInfoEXT} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkRenderPassSampleLocationsBeginInfoEXT} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkRenderPassSampleLocationsBeginInfoEXT + where + unsafeAddr (VkRenderPassSampleLocationsBeginInfoEXT## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkRenderPassSampleLocationsBeginInfoEXT## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkRenderPassSampleLocationsBeginInfoEXT## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkRenderPassSampleLocationsBeginInfoEXT + where + type StructFields VkRenderPassSampleLocationsBeginInfoEXT = + '["sType", "pNext", "attachmentInitialSampleLocationsCount", -- ' closing tick for hsc2hs + "pAttachmentInitialSampleLocations", + "postSubpassSampleLocationsCount", "pPostSubpassSampleLocations"] + type CUnionType VkRenderPassSampleLocationsBeginInfoEXT = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkRenderPassSampleLocationsBeginInfoEXT = 'False -- ' closing tick for hsc2hs + type StructExtends VkRenderPassSampleLocationsBeginInfoEXT = + '[VkRenderPassBeginInfo] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkRenderPassSampleLocationsBeginInfoEXT where + type VkSTypeMType VkRenderPassSampleLocationsBeginInfoEXT = + VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkRenderPassSampleLocationsBeginInfoEXT, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkRenderPassSampleLocationsBeginInfoEXT, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkRenderPassSampleLocationsBeginInfoEXT, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkRenderPassSampleLocationsBeginInfoEXT, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkRenderPassSampleLocationsBeginInfoEXT where + type FieldType "sType" VkRenderPassSampleLocationsBeginInfoEXT = + VkStructureType + type FieldOptional "sType" VkRenderPassSampleLocationsBeginInfoEXT + = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkRenderPassSampleLocationsBeginInfoEXT = + #{offset VkRenderPassSampleLocationsBeginInfoEXT, sType} + type FieldIsArray "sType" VkRenderPassSampleLocationsBeginInfoEXT = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkRenderPassSampleLocationsBeginInfoEXT, sType} + +instance CanReadField "sType" + VkRenderPassSampleLocationsBeginInfoEXT + where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" + VkRenderPassSampleLocationsBeginInfoEXT + where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkRenderPassSampleLocationsBeginInfoEXT where + type VkPNextMType VkRenderPassSampleLocationsBeginInfoEXT = + Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkRenderPassSampleLocationsBeginInfoEXT, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkRenderPassSampleLocationsBeginInfoEXT, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkRenderPassSampleLocationsBeginInfoEXT, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkRenderPassSampleLocationsBeginInfoEXT, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkRenderPassSampleLocationsBeginInfoEXT where + type FieldType "pNext" VkRenderPassSampleLocationsBeginInfoEXT = + Ptr Void + type FieldOptional "pNext" VkRenderPassSampleLocationsBeginInfoEXT + = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkRenderPassSampleLocationsBeginInfoEXT = + #{offset VkRenderPassSampleLocationsBeginInfoEXT, pNext} + type FieldIsArray "pNext" VkRenderPassSampleLocationsBeginInfoEXT = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkRenderPassSampleLocationsBeginInfoEXT, pNext} + +instance CanReadField "pNext" + VkRenderPassSampleLocationsBeginInfoEXT + where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" + VkRenderPassSampleLocationsBeginInfoEXT + where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkAttachmentInitialSampleLocationsCount + VkRenderPassSampleLocationsBeginInfoEXT + where + type VkAttachmentInitialSampleLocationsCountMType + VkRenderPassSampleLocationsBeginInfoEXT + = Word32 + + {-# NOINLINE vkAttachmentInitialSampleLocationsCount #-} + vkAttachmentInitialSampleLocationsCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkRenderPassSampleLocationsBeginInfoEXT, attachmentInitialSampleLocationsCount}) + + {-# INLINE vkAttachmentInitialSampleLocationsCountByteOffset #-} + vkAttachmentInitialSampleLocationsCountByteOffset ~_ + = #{offset VkRenderPassSampleLocationsBeginInfoEXT, attachmentInitialSampleLocationsCount} + + {-# INLINE readVkAttachmentInitialSampleLocationsCount #-} + readVkAttachmentInitialSampleLocationsCount p + = peekByteOff p #{offset VkRenderPassSampleLocationsBeginInfoEXT, attachmentInitialSampleLocationsCount} + + {-# INLINE writeVkAttachmentInitialSampleLocationsCount #-} + writeVkAttachmentInitialSampleLocationsCount p + = pokeByteOff p #{offset VkRenderPassSampleLocationsBeginInfoEXT, attachmentInitialSampleLocationsCount} + +instance {-# OVERLAPPING #-} + HasField "attachmentInitialSampleLocationsCount" + VkRenderPassSampleLocationsBeginInfoEXT + where + type FieldType "attachmentInitialSampleLocationsCount" + VkRenderPassSampleLocationsBeginInfoEXT + = Word32 + type FieldOptional "attachmentInitialSampleLocationsCount" + VkRenderPassSampleLocationsBeginInfoEXT + = 'True -- ' closing tick for hsc2hs + type FieldOffset "attachmentInitialSampleLocationsCount" + VkRenderPassSampleLocationsBeginInfoEXT + = + #{offset VkRenderPassSampleLocationsBeginInfoEXT, attachmentInitialSampleLocationsCount} + type FieldIsArray "attachmentInitialSampleLocationsCount" + VkRenderPassSampleLocationsBeginInfoEXT + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkRenderPassSampleLocationsBeginInfoEXT, attachmentInitialSampleLocationsCount} + +instance CanReadField "attachmentInitialSampleLocationsCount" + VkRenderPassSampleLocationsBeginInfoEXT + where + {-# INLINE getField #-} + getField = vkAttachmentInitialSampleLocationsCount + + {-# INLINE readField #-} + readField = readVkAttachmentInitialSampleLocationsCount + +instance CanWriteField "attachmentInitialSampleLocationsCount" + VkRenderPassSampleLocationsBeginInfoEXT + where + {-# INLINE writeField #-} + writeField = writeVkAttachmentInitialSampleLocationsCount + +instance {-# OVERLAPPING #-} + HasVkPAttachmentInitialSampleLocations + VkRenderPassSampleLocationsBeginInfoEXT + where + type VkPAttachmentInitialSampleLocationsMType + VkRenderPassSampleLocationsBeginInfoEXT + = Ptr VkAttachmentSampleLocationsEXT + + {-# NOINLINE vkPAttachmentInitialSampleLocations #-} + vkPAttachmentInitialSampleLocations x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkRenderPassSampleLocationsBeginInfoEXT, pAttachmentInitialSampleLocations}) + + {-# INLINE vkPAttachmentInitialSampleLocationsByteOffset #-} + vkPAttachmentInitialSampleLocationsByteOffset ~_ + = #{offset VkRenderPassSampleLocationsBeginInfoEXT, pAttachmentInitialSampleLocations} + + {-# INLINE readVkPAttachmentInitialSampleLocations #-} + readVkPAttachmentInitialSampleLocations p + = peekByteOff p #{offset VkRenderPassSampleLocationsBeginInfoEXT, pAttachmentInitialSampleLocations} + + {-# INLINE writeVkPAttachmentInitialSampleLocations #-} + writeVkPAttachmentInitialSampleLocations p + = pokeByteOff p #{offset VkRenderPassSampleLocationsBeginInfoEXT, pAttachmentInitialSampleLocations} + +instance {-# OVERLAPPING #-} + HasField "pAttachmentInitialSampleLocations" + VkRenderPassSampleLocationsBeginInfoEXT + where + type FieldType "pAttachmentInitialSampleLocations" + VkRenderPassSampleLocationsBeginInfoEXT + = Ptr VkAttachmentSampleLocationsEXT + type FieldOptional "pAttachmentInitialSampleLocations" + VkRenderPassSampleLocationsBeginInfoEXT + = 'False -- ' closing tick for hsc2hs + type FieldOffset "pAttachmentInitialSampleLocations" + VkRenderPassSampleLocationsBeginInfoEXT + = + #{offset VkRenderPassSampleLocationsBeginInfoEXT, pAttachmentInitialSampleLocations} + type FieldIsArray "pAttachmentInitialSampleLocations" + VkRenderPassSampleLocationsBeginInfoEXT + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkRenderPassSampleLocationsBeginInfoEXT, pAttachmentInitialSampleLocations} + +instance CanReadField "pAttachmentInitialSampleLocations" + VkRenderPassSampleLocationsBeginInfoEXT + where + {-# INLINE getField #-} + getField = vkPAttachmentInitialSampleLocations + + {-# INLINE readField #-} + readField = readVkPAttachmentInitialSampleLocations + +instance CanWriteField "pAttachmentInitialSampleLocations" + VkRenderPassSampleLocationsBeginInfoEXT + where + {-# INLINE writeField #-} + writeField = writeVkPAttachmentInitialSampleLocations + +instance {-# OVERLAPPING #-} + HasVkPostSubpassSampleLocationsCount + VkRenderPassSampleLocationsBeginInfoEXT + where + type VkPostSubpassSampleLocationsCountMType + VkRenderPassSampleLocationsBeginInfoEXT + = Word32 + + {-# NOINLINE vkPostSubpassSampleLocationsCount #-} + vkPostSubpassSampleLocationsCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkRenderPassSampleLocationsBeginInfoEXT, postSubpassSampleLocationsCount}) + + {-# INLINE vkPostSubpassSampleLocationsCountByteOffset #-} + vkPostSubpassSampleLocationsCountByteOffset ~_ + = #{offset VkRenderPassSampleLocationsBeginInfoEXT, postSubpassSampleLocationsCount} + + {-# INLINE readVkPostSubpassSampleLocationsCount #-} + readVkPostSubpassSampleLocationsCount p + = peekByteOff p #{offset VkRenderPassSampleLocationsBeginInfoEXT, postSubpassSampleLocationsCount} + + {-# INLINE writeVkPostSubpassSampleLocationsCount #-} + writeVkPostSubpassSampleLocationsCount p + = pokeByteOff p #{offset VkRenderPassSampleLocationsBeginInfoEXT, postSubpassSampleLocationsCount} + +instance {-# OVERLAPPING #-} + HasField "postSubpassSampleLocationsCount" + VkRenderPassSampleLocationsBeginInfoEXT + where + type FieldType "postSubpassSampleLocationsCount" + VkRenderPassSampleLocationsBeginInfoEXT + = Word32 + type FieldOptional "postSubpassSampleLocationsCount" + VkRenderPassSampleLocationsBeginInfoEXT + = 'True -- ' closing tick for hsc2hs + type FieldOffset "postSubpassSampleLocationsCount" + VkRenderPassSampleLocationsBeginInfoEXT + = + #{offset VkRenderPassSampleLocationsBeginInfoEXT, postSubpassSampleLocationsCount} + type FieldIsArray "postSubpassSampleLocationsCount" + VkRenderPassSampleLocationsBeginInfoEXT + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkRenderPassSampleLocationsBeginInfoEXT, postSubpassSampleLocationsCount} + +instance CanReadField "postSubpassSampleLocationsCount" + VkRenderPassSampleLocationsBeginInfoEXT + where + {-# INLINE getField #-} + getField = vkPostSubpassSampleLocationsCount + + {-# INLINE readField #-} + readField = readVkPostSubpassSampleLocationsCount + +instance CanWriteField "postSubpassSampleLocationsCount" + VkRenderPassSampleLocationsBeginInfoEXT + where + {-# INLINE writeField #-} + writeField = writeVkPostSubpassSampleLocationsCount + +instance {-# OVERLAPPING #-} + HasVkPPostSubpassSampleLocations + VkRenderPassSampleLocationsBeginInfoEXT + where + type VkPPostSubpassSampleLocationsMType + VkRenderPassSampleLocationsBeginInfoEXT + = Ptr VkSubpassSampleLocationsEXT + + {-# NOINLINE vkPPostSubpassSampleLocations #-} + vkPPostSubpassSampleLocations x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkRenderPassSampleLocationsBeginInfoEXT, pPostSubpassSampleLocations}) + + {-# INLINE vkPPostSubpassSampleLocationsByteOffset #-} + vkPPostSubpassSampleLocationsByteOffset ~_ + = #{offset VkRenderPassSampleLocationsBeginInfoEXT, pPostSubpassSampleLocations} + + {-# INLINE readVkPPostSubpassSampleLocations #-} + readVkPPostSubpassSampleLocations p + = peekByteOff p #{offset VkRenderPassSampleLocationsBeginInfoEXT, pPostSubpassSampleLocations} + + {-# INLINE writeVkPPostSubpassSampleLocations #-} + writeVkPPostSubpassSampleLocations p + = pokeByteOff p #{offset VkRenderPassSampleLocationsBeginInfoEXT, pPostSubpassSampleLocations} + +instance {-# OVERLAPPING #-} + HasField "pPostSubpassSampleLocations" + VkRenderPassSampleLocationsBeginInfoEXT + where + type FieldType "pPostSubpassSampleLocations" + VkRenderPassSampleLocationsBeginInfoEXT + = Ptr VkSubpassSampleLocationsEXT + type FieldOptional "pPostSubpassSampleLocations" + VkRenderPassSampleLocationsBeginInfoEXT + = 'False -- ' closing tick for hsc2hs + type FieldOffset "pPostSubpassSampleLocations" + VkRenderPassSampleLocationsBeginInfoEXT + = + #{offset VkRenderPassSampleLocationsBeginInfoEXT, pPostSubpassSampleLocations} + type FieldIsArray "pPostSubpassSampleLocations" + VkRenderPassSampleLocationsBeginInfoEXT + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkRenderPassSampleLocationsBeginInfoEXT, pPostSubpassSampleLocations} + +instance CanReadField "pPostSubpassSampleLocations" + VkRenderPassSampleLocationsBeginInfoEXT + where + {-# INLINE getField #-} + getField = vkPPostSubpassSampleLocations + + {-# INLINE readField #-} + readField = readVkPPostSubpassSampleLocations + +instance CanWriteField "pPostSubpassSampleLocations" + VkRenderPassSampleLocationsBeginInfoEXT + where + {-# INLINE writeField #-} + writeField = writeVkPPostSubpassSampleLocations + +instance Show VkRenderPassSampleLocationsBeginInfoEXT where + showsPrec d x + = showString "VkRenderPassSampleLocationsBeginInfoEXT {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkAttachmentInitialSampleLocationsCount = " . + showsPrec d (vkAttachmentInitialSampleLocationsCount x) . + showString ", " . + showString "vkPAttachmentInitialSampleLocations = " . + showsPrec d (vkPAttachmentInitialSampleLocations x) . + showString ", " . + showString "vkPostSubpassSampleLocationsCount = " . + showsPrec d (vkPostSubpassSampleLocationsCount x) . + showString ", " . + showString "vkPPostSubpassSampleLocations = " . + showsPrec d (vkPPostSubpassSampleLocations x) . + showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkSampleLocationEXT.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkSampleLocationEXT.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkSampleLocationEXT.hsc @@ -0,0 +1,162 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkSampleLocationEXT + (VkSampleLocationEXT(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkSampleLocationEXT { +-- > float x; +-- > float y; +-- > } VkSampleLocationEXT; +-- +-- +data VkSampleLocationEXT = VkSampleLocationEXT## Addr## ByteArray## + +instance Eq VkSampleLocationEXT where + (VkSampleLocationEXT## a _) == x@(VkSampleLocationEXT## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkSampleLocationEXT where + (VkSampleLocationEXT## a _) `compare` x@(VkSampleLocationEXT## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkSampleLocationEXT where + sizeOf ~_ = #{size VkSampleLocationEXT} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkSampleLocationEXT} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkSampleLocationEXT where + unsafeAddr (VkSampleLocationEXT## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkSampleLocationEXT## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkSampleLocationEXT## (plusAddr## (byteArrayContents## b) off) b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkSampleLocationEXT where + type StructFields VkSampleLocationEXT = '["x", "y"] -- ' closing tick for hsc2hs + type CUnionType VkSampleLocationEXT = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkSampleLocationEXT = 'False -- ' closing tick for hsc2hs + type StructExtends VkSampleLocationEXT = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkX VkSampleLocationEXT where + type VkXMType VkSampleLocationEXT = #{type float} + + {-# NOINLINE vkX #-} + vkX x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSampleLocationEXT, x}) + + {-# INLINE vkXByteOffset #-} + vkXByteOffset ~_ = #{offset VkSampleLocationEXT, x} + + {-# INLINE readVkX #-} + readVkX p + = peekByteOff p #{offset VkSampleLocationEXT, x} + + {-# INLINE writeVkX #-} + writeVkX p + = pokeByteOff p #{offset VkSampleLocationEXT, x} + +instance {-# OVERLAPPING #-} HasField "x" VkSampleLocationEXT where + type FieldType "x" VkSampleLocationEXT = #{type float} + type FieldOptional "x" VkSampleLocationEXT = 'False -- ' closing tick for hsc2hs + type FieldOffset "x" VkSampleLocationEXT = + #{offset VkSampleLocationEXT, x} + type FieldIsArray "x" VkSampleLocationEXT = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkSampleLocationEXT, x} + +instance CanReadField "x" VkSampleLocationEXT where + {-# INLINE getField #-} + getField = vkX + + {-# INLINE readField #-} + readField = readVkX + +instance CanWriteField "x" VkSampleLocationEXT where + {-# INLINE writeField #-} + writeField = writeVkX + +instance {-# OVERLAPPING #-} HasVkY VkSampleLocationEXT where + type VkYMType VkSampleLocationEXT = #{type float} + + {-# NOINLINE vkY #-} + vkY x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSampleLocationEXT, y}) + + {-# INLINE vkYByteOffset #-} + vkYByteOffset ~_ = #{offset VkSampleLocationEXT, y} + + {-# INLINE readVkY #-} + readVkY p + = peekByteOff p #{offset VkSampleLocationEXT, y} + + {-# INLINE writeVkY #-} + writeVkY p + = pokeByteOff p #{offset VkSampleLocationEXT, y} + +instance {-# OVERLAPPING #-} HasField "y" VkSampleLocationEXT where + type FieldType "y" VkSampleLocationEXT = #{type float} + type FieldOptional "y" VkSampleLocationEXT = 'False -- ' closing tick for hsc2hs + type FieldOffset "y" VkSampleLocationEXT = + #{offset VkSampleLocationEXT, y} + type FieldIsArray "y" VkSampleLocationEXT = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkSampleLocationEXT, y} + +instance CanReadField "y" VkSampleLocationEXT where + {-# INLINE getField #-} + getField = vkY + + {-# INLINE readField #-} + readField = readVkY + +instance CanWriteField "y" VkSampleLocationEXT where + {-# INLINE writeField #-} + writeField = writeVkY + +instance Show VkSampleLocationEXT where + showsPrec d x + = showString "VkSampleLocationEXT {" . + showString "vkX = " . + showsPrec d (vkX x) . + showString ", " . + showString "vkY = " . showsPrec d (vkY x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkSampleLocationsInfoEXT.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkSampleLocationsInfoEXT.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkSampleLocationsInfoEXT.hsc @@ -0,0 +1,418 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkSampleLocationsInfoEXT + (VkSampleLocationsInfoEXT(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkSampleCountFlags (VkSampleCountFlagBits) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Struct.VkExtent2D (VkExtent2D) +import Graphics.Vulkan.Types.Struct.VkImageMemoryBarrier (VkImageMemoryBarrier) +import Graphics.Vulkan.Types.Struct.VkSampleLocationEXT (VkSampleLocationEXT) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkSampleLocationsInfoEXT { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkSampleCountFlagBits sampleLocationsPerPixel; +-- > VkExtent2D sampleLocationGridSize; +-- > uint32_t sampleLocationsCount; +-- > const VkSampleLocationEXT* pSampleLocations; +-- > } VkSampleLocationsInfoEXT; +-- +-- +data VkSampleLocationsInfoEXT = VkSampleLocationsInfoEXT## Addr## + ByteArray## + +instance Eq VkSampleLocationsInfoEXT where + (VkSampleLocationsInfoEXT## a _) == + x@(VkSampleLocationsInfoEXT## b _) = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkSampleLocationsInfoEXT where + (VkSampleLocationsInfoEXT## a _) `compare` + x@(VkSampleLocationsInfoEXT## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkSampleLocationsInfoEXT where + sizeOf ~_ = #{size VkSampleLocationsInfoEXT} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkSampleLocationsInfoEXT} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkSampleLocationsInfoEXT where + unsafeAddr (VkSampleLocationsInfoEXT## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkSampleLocationsInfoEXT## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkSampleLocationsInfoEXT## (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkSampleLocationsInfoEXT where + type StructFields VkSampleLocationsInfoEXT = + '["sType", "pNext", "sampleLocationsPerPixel", -- ' closing tick for hsc2hs + "sampleLocationGridSize", "sampleLocationsCount", + "pSampleLocations"] + type CUnionType VkSampleLocationsInfoEXT = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkSampleLocationsInfoEXT = 'False -- ' closing tick for hsc2hs + type StructExtends VkSampleLocationsInfoEXT = + '[VkImageMemoryBarrier] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkSType VkSampleLocationsInfoEXT + where + type VkSTypeMType VkSampleLocationsInfoEXT = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSampleLocationsInfoEXT, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkSampleLocationsInfoEXT, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkSampleLocationsInfoEXT, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkSampleLocationsInfoEXT, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkSampleLocationsInfoEXT where + type FieldType "sType" VkSampleLocationsInfoEXT = VkStructureType + type FieldOptional "sType" VkSampleLocationsInfoEXT = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkSampleLocationsInfoEXT = + #{offset VkSampleLocationsInfoEXT, sType} + type FieldIsArray "sType" VkSampleLocationsInfoEXT = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkSampleLocationsInfoEXT, sType} + +instance CanReadField "sType" VkSampleLocationsInfoEXT where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkSampleLocationsInfoEXT where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} HasVkPNext VkSampleLocationsInfoEXT + where + type VkPNextMType VkSampleLocationsInfoEXT = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSampleLocationsInfoEXT, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkSampleLocationsInfoEXT, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkSampleLocationsInfoEXT, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkSampleLocationsInfoEXT, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkSampleLocationsInfoEXT where + type FieldType "pNext" VkSampleLocationsInfoEXT = Ptr Void + type FieldOptional "pNext" VkSampleLocationsInfoEXT = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkSampleLocationsInfoEXT = + #{offset VkSampleLocationsInfoEXT, pNext} + type FieldIsArray "pNext" VkSampleLocationsInfoEXT = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkSampleLocationsInfoEXT, pNext} + +instance CanReadField "pNext" VkSampleLocationsInfoEXT where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkSampleLocationsInfoEXT where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkSampleLocationsPerPixel VkSampleLocationsInfoEXT where + type VkSampleLocationsPerPixelMType VkSampleLocationsInfoEXT = + VkSampleCountFlagBits + + {-# NOINLINE vkSampleLocationsPerPixel #-} + vkSampleLocationsPerPixel x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSampleLocationsInfoEXT, sampleLocationsPerPixel}) + + {-# INLINE vkSampleLocationsPerPixelByteOffset #-} + vkSampleLocationsPerPixelByteOffset ~_ + = #{offset VkSampleLocationsInfoEXT, sampleLocationsPerPixel} + + {-# INLINE readVkSampleLocationsPerPixel #-} + readVkSampleLocationsPerPixel p + = peekByteOff p #{offset VkSampleLocationsInfoEXT, sampleLocationsPerPixel} + + {-# INLINE writeVkSampleLocationsPerPixel #-} + writeVkSampleLocationsPerPixel p + = pokeByteOff p #{offset VkSampleLocationsInfoEXT, sampleLocationsPerPixel} + +instance {-# OVERLAPPING #-} + HasField "sampleLocationsPerPixel" VkSampleLocationsInfoEXT where + type FieldType "sampleLocationsPerPixel" VkSampleLocationsInfoEXT = + VkSampleCountFlagBits + type FieldOptional "sampleLocationsPerPixel" + VkSampleLocationsInfoEXT + = 'False -- ' closing tick for hsc2hs + type FieldOffset "sampleLocationsPerPixel" VkSampleLocationsInfoEXT + = + #{offset VkSampleLocationsInfoEXT, sampleLocationsPerPixel} + type FieldIsArray "sampleLocationsPerPixel" + VkSampleLocationsInfoEXT + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSampleLocationsInfoEXT, sampleLocationsPerPixel} + +instance CanReadField "sampleLocationsPerPixel" + VkSampleLocationsInfoEXT + where + {-# INLINE getField #-} + getField = vkSampleLocationsPerPixel + + {-# INLINE readField #-} + readField = readVkSampleLocationsPerPixel + +instance CanWriteField "sampleLocationsPerPixel" + VkSampleLocationsInfoEXT + where + {-# INLINE writeField #-} + writeField = writeVkSampleLocationsPerPixel + +instance {-# OVERLAPPING #-} + HasVkSampleLocationGridSize VkSampleLocationsInfoEXT where + type VkSampleLocationGridSizeMType VkSampleLocationsInfoEXT = + VkExtent2D + + {-# NOINLINE vkSampleLocationGridSize #-} + vkSampleLocationGridSize x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSampleLocationsInfoEXT, sampleLocationGridSize}) + + {-# INLINE vkSampleLocationGridSizeByteOffset #-} + vkSampleLocationGridSizeByteOffset ~_ + = #{offset VkSampleLocationsInfoEXT, sampleLocationGridSize} + + {-# INLINE readVkSampleLocationGridSize #-} + readVkSampleLocationGridSize p + = peekByteOff p #{offset VkSampleLocationsInfoEXT, sampleLocationGridSize} + + {-# INLINE writeVkSampleLocationGridSize #-} + writeVkSampleLocationGridSize p + = pokeByteOff p #{offset VkSampleLocationsInfoEXT, sampleLocationGridSize} + +instance {-# OVERLAPPING #-} + HasField "sampleLocationGridSize" VkSampleLocationsInfoEXT where + type FieldType "sampleLocationGridSize" VkSampleLocationsInfoEXT = + VkExtent2D + type FieldOptional "sampleLocationGridSize" + VkSampleLocationsInfoEXT + = 'False -- ' closing tick for hsc2hs + type FieldOffset "sampleLocationGridSize" VkSampleLocationsInfoEXT + = + #{offset VkSampleLocationsInfoEXT, sampleLocationGridSize} + type FieldIsArray "sampleLocationGridSize" VkSampleLocationsInfoEXT + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSampleLocationsInfoEXT, sampleLocationGridSize} + +instance CanReadField "sampleLocationGridSize" + VkSampleLocationsInfoEXT + where + {-# INLINE getField #-} + getField = vkSampleLocationGridSize + + {-# INLINE readField #-} + readField = readVkSampleLocationGridSize + +instance CanWriteField "sampleLocationGridSize" + VkSampleLocationsInfoEXT + where + {-# INLINE writeField #-} + writeField = writeVkSampleLocationGridSize + +instance {-# OVERLAPPING #-} + HasVkSampleLocationsCount VkSampleLocationsInfoEXT where + type VkSampleLocationsCountMType VkSampleLocationsInfoEXT = Word32 + + {-# NOINLINE vkSampleLocationsCount #-} + vkSampleLocationsCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSampleLocationsInfoEXT, sampleLocationsCount}) + + {-# INLINE vkSampleLocationsCountByteOffset #-} + vkSampleLocationsCountByteOffset ~_ + = #{offset VkSampleLocationsInfoEXT, sampleLocationsCount} + + {-# INLINE readVkSampleLocationsCount #-} + readVkSampleLocationsCount p + = peekByteOff p #{offset VkSampleLocationsInfoEXT, sampleLocationsCount} + + {-# INLINE writeVkSampleLocationsCount #-} + writeVkSampleLocationsCount p + = pokeByteOff p #{offset VkSampleLocationsInfoEXT, sampleLocationsCount} + +instance {-# OVERLAPPING #-} + HasField "sampleLocationsCount" VkSampleLocationsInfoEXT where + type FieldType "sampleLocationsCount" VkSampleLocationsInfoEXT = + Word32 + type FieldOptional "sampleLocationsCount" VkSampleLocationsInfoEXT + = 'False -- ' closing tick for hsc2hs + type FieldOffset "sampleLocationsCount" VkSampleLocationsInfoEXT = + #{offset VkSampleLocationsInfoEXT, sampleLocationsCount} + type FieldIsArray "sampleLocationsCount" VkSampleLocationsInfoEXT = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSampleLocationsInfoEXT, sampleLocationsCount} + +instance CanReadField "sampleLocationsCount" + VkSampleLocationsInfoEXT + where + {-# INLINE getField #-} + getField = vkSampleLocationsCount + + {-# INLINE readField #-} + readField = readVkSampleLocationsCount + +instance CanWriteField "sampleLocationsCount" + VkSampleLocationsInfoEXT + where + {-# INLINE writeField #-} + writeField = writeVkSampleLocationsCount + +instance {-# OVERLAPPING #-} + HasVkPSampleLocations VkSampleLocationsInfoEXT where + type VkPSampleLocationsMType VkSampleLocationsInfoEXT = + Ptr VkSampleLocationEXT + + {-# NOINLINE vkPSampleLocations #-} + vkPSampleLocations x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSampleLocationsInfoEXT, pSampleLocations}) + + {-# INLINE vkPSampleLocationsByteOffset #-} + vkPSampleLocationsByteOffset ~_ + = #{offset VkSampleLocationsInfoEXT, pSampleLocations} + + {-# INLINE readVkPSampleLocations #-} + readVkPSampleLocations p + = peekByteOff p #{offset VkSampleLocationsInfoEXT, pSampleLocations} + + {-# INLINE writeVkPSampleLocations #-} + writeVkPSampleLocations p + = pokeByteOff p #{offset VkSampleLocationsInfoEXT, pSampleLocations} + +instance {-# OVERLAPPING #-} + HasField "pSampleLocations" VkSampleLocationsInfoEXT where + type FieldType "pSampleLocations" VkSampleLocationsInfoEXT = + Ptr VkSampleLocationEXT + type FieldOptional "pSampleLocations" VkSampleLocationsInfoEXT = + 'False -- ' closing tick for hsc2hs + type FieldOffset "pSampleLocations" VkSampleLocationsInfoEXT = + #{offset VkSampleLocationsInfoEXT, pSampleLocations} + type FieldIsArray "pSampleLocations" VkSampleLocationsInfoEXT = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSampleLocationsInfoEXT, pSampleLocations} + +instance CanReadField "pSampleLocations" VkSampleLocationsInfoEXT + where + {-# INLINE getField #-} + getField = vkPSampleLocations + + {-# INLINE readField #-} + readField = readVkPSampleLocations + +instance CanWriteField "pSampleLocations" VkSampleLocationsInfoEXT + where + {-# INLINE writeField #-} + writeField = writeVkPSampleLocations + +instance Show VkSampleLocationsInfoEXT where + showsPrec d x + = showString "VkSampleLocationsInfoEXT {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkSampleLocationsPerPixel = " . + showsPrec d (vkSampleLocationsPerPixel x) . + showString ", " . + showString "vkSampleLocationGridSize = " . + showsPrec d (vkSampleLocationGridSize x) . + showString ", " . + showString "vkSampleLocationsCount = " . + showsPrec d (vkSampleLocationsCount x) . + showString ", " . + showString "vkPSampleLocations = " . + showsPrec d (vkPSampleLocations x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkSamplerCreateInfo.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkSamplerCreateInfo.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkSamplerCreateInfo.hsc @@ -0,0 +1,1058 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkSamplerCreateInfo + (VkSamplerCreateInfo(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.BaseTypes (VkBool32) +import Graphics.Vulkan.Types.Bitmasks (VkSamplerCreateFlags) +import Graphics.Vulkan.Types.Enum.VkBorderColor (VkBorderColor) +import Graphics.Vulkan.Types.Enum.VkCompareOp (VkCompareOp) +import Graphics.Vulkan.Types.Enum.VkFilter (VkFilter) +import Graphics.Vulkan.Types.Enum.VkSamplerAddressMode (VkSamplerAddressMode) +import Graphics.Vulkan.Types.Enum.VkSamplerMipmapMode (VkSamplerMipmapMode) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkSamplerCreateInfo { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkSamplerCreateFlags flags; +-- > VkFilter magFilter; +-- > VkFilter minFilter; +-- > VkSamplerMipmapMode mipmapMode; +-- > VkSamplerAddressMode addressModeU; +-- > VkSamplerAddressMode addressModeV; +-- > VkSamplerAddressMode addressModeW; +-- > float mipLodBias; +-- > VkBool32 anisotropyEnable; +-- > float maxAnisotropy; +-- > VkBool32 compareEnable; +-- > VkCompareOp compareOp; +-- > float minLod; +-- > float maxLod; +-- > VkBorderColor borderColor; +-- > VkBool32 unnormalizedCoordinates; +-- > } VkSamplerCreateInfo; +-- +-- +data VkSamplerCreateInfo = VkSamplerCreateInfo## Addr## ByteArray## + +instance Eq VkSamplerCreateInfo where + (VkSamplerCreateInfo## a _) == x@(VkSamplerCreateInfo## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkSamplerCreateInfo where + (VkSamplerCreateInfo## a _) `compare` x@(VkSamplerCreateInfo## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkSamplerCreateInfo where + sizeOf ~_ = #{size VkSamplerCreateInfo} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkSamplerCreateInfo} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkSamplerCreateInfo where + unsafeAddr (VkSamplerCreateInfo## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkSamplerCreateInfo## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkSamplerCreateInfo## (plusAddr## (byteArrayContents## b) off) b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkSamplerCreateInfo where + type StructFields VkSamplerCreateInfo = + '["sType", "pNext", "flags", "magFilter", "minFilter", -- ' closing tick for hsc2hs + "mipmapMode", "addressModeU", "addressModeV", "addressModeW", + "mipLodBias", "anisotropyEnable", "maxAnisotropy", "compareEnable", + "compareOp", "minLod", "maxLod", "borderColor", + "unnormalizedCoordinates"] + type CUnionType VkSamplerCreateInfo = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkSamplerCreateInfo = 'False -- ' closing tick for hsc2hs + type StructExtends VkSamplerCreateInfo = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkSType VkSamplerCreateInfo where + type VkSTypeMType VkSamplerCreateInfo = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSamplerCreateInfo, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkSamplerCreateInfo, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkSamplerCreateInfo, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkSamplerCreateInfo, sType} + +instance {-# OVERLAPPING #-} HasField "sType" VkSamplerCreateInfo + where + type FieldType "sType" VkSamplerCreateInfo = VkStructureType + type FieldOptional "sType" VkSamplerCreateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkSamplerCreateInfo = + #{offset VkSamplerCreateInfo, sType} + type FieldIsArray "sType" VkSamplerCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkSamplerCreateInfo, sType} + +instance CanReadField "sType" VkSamplerCreateInfo where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkSamplerCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} HasVkPNext VkSamplerCreateInfo where + type VkPNextMType VkSamplerCreateInfo = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSamplerCreateInfo, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkSamplerCreateInfo, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkSamplerCreateInfo, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkSamplerCreateInfo, pNext} + +instance {-# OVERLAPPING #-} HasField "pNext" VkSamplerCreateInfo + where + type FieldType "pNext" VkSamplerCreateInfo = Ptr Void + type FieldOptional "pNext" VkSamplerCreateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkSamplerCreateInfo = + #{offset VkSamplerCreateInfo, pNext} + type FieldIsArray "pNext" VkSamplerCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkSamplerCreateInfo, pNext} + +instance CanReadField "pNext" VkSamplerCreateInfo where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkSamplerCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} HasVkFlags VkSamplerCreateInfo where + type VkFlagsMType VkSamplerCreateInfo = VkSamplerCreateFlags + + {-# NOINLINE vkFlags #-} + vkFlags x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSamplerCreateInfo, flags}) + + {-# INLINE vkFlagsByteOffset #-} + vkFlagsByteOffset ~_ + = #{offset VkSamplerCreateInfo, flags} + + {-# INLINE readVkFlags #-} + readVkFlags p + = peekByteOff p #{offset VkSamplerCreateInfo, flags} + + {-# INLINE writeVkFlags #-} + writeVkFlags p + = pokeByteOff p #{offset VkSamplerCreateInfo, flags} + +instance {-# OVERLAPPING #-} HasField "flags" VkSamplerCreateInfo + where + type FieldType "flags" VkSamplerCreateInfo = VkSamplerCreateFlags + type FieldOptional "flags" VkSamplerCreateInfo = 'True -- ' closing tick for hsc2hs + type FieldOffset "flags" VkSamplerCreateInfo = + #{offset VkSamplerCreateInfo, flags} + type FieldIsArray "flags" VkSamplerCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkSamplerCreateInfo, flags} + +instance CanReadField "flags" VkSamplerCreateInfo where + {-# INLINE getField #-} + getField = vkFlags + + {-# INLINE readField #-} + readField = readVkFlags + +instance CanWriteField "flags" VkSamplerCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkFlags + +instance {-# OVERLAPPING #-} HasVkMagFilter VkSamplerCreateInfo + where + type VkMagFilterMType VkSamplerCreateInfo = VkFilter + + {-# NOINLINE vkMagFilter #-} + vkMagFilter x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSamplerCreateInfo, magFilter}) + + {-# INLINE vkMagFilterByteOffset #-} + vkMagFilterByteOffset ~_ + = #{offset VkSamplerCreateInfo, magFilter} + + {-# INLINE readVkMagFilter #-} + readVkMagFilter p + = peekByteOff p #{offset VkSamplerCreateInfo, magFilter} + + {-# INLINE writeVkMagFilter #-} + writeVkMagFilter p + = pokeByteOff p #{offset VkSamplerCreateInfo, magFilter} + +instance {-# OVERLAPPING #-} + HasField "magFilter" VkSamplerCreateInfo where + type FieldType "magFilter" VkSamplerCreateInfo = VkFilter + type FieldOptional "magFilter" VkSamplerCreateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "magFilter" VkSamplerCreateInfo = + #{offset VkSamplerCreateInfo, magFilter} + type FieldIsArray "magFilter" VkSamplerCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkSamplerCreateInfo, magFilter} + +instance CanReadField "magFilter" VkSamplerCreateInfo where + {-# INLINE getField #-} + getField = vkMagFilter + + {-# INLINE readField #-} + readField = readVkMagFilter + +instance CanWriteField "magFilter" VkSamplerCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkMagFilter + +instance {-# OVERLAPPING #-} HasVkMinFilter VkSamplerCreateInfo + where + type VkMinFilterMType VkSamplerCreateInfo = VkFilter + + {-# NOINLINE vkMinFilter #-} + vkMinFilter x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSamplerCreateInfo, minFilter}) + + {-# INLINE vkMinFilterByteOffset #-} + vkMinFilterByteOffset ~_ + = #{offset VkSamplerCreateInfo, minFilter} + + {-# INLINE readVkMinFilter #-} + readVkMinFilter p + = peekByteOff p #{offset VkSamplerCreateInfo, minFilter} + + {-# INLINE writeVkMinFilter #-} + writeVkMinFilter p + = pokeByteOff p #{offset VkSamplerCreateInfo, minFilter} + +instance {-# OVERLAPPING #-} + HasField "minFilter" VkSamplerCreateInfo where + type FieldType "minFilter" VkSamplerCreateInfo = VkFilter + type FieldOptional "minFilter" VkSamplerCreateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "minFilter" VkSamplerCreateInfo = + #{offset VkSamplerCreateInfo, minFilter} + type FieldIsArray "minFilter" VkSamplerCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkSamplerCreateInfo, minFilter} + +instance CanReadField "minFilter" VkSamplerCreateInfo where + {-# INLINE getField #-} + getField = vkMinFilter + + {-# INLINE readField #-} + readField = readVkMinFilter + +instance CanWriteField "minFilter" VkSamplerCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkMinFilter + +instance {-# OVERLAPPING #-} HasVkMipmapMode VkSamplerCreateInfo + where + type VkMipmapModeMType VkSamplerCreateInfo = VkSamplerMipmapMode + + {-# NOINLINE vkMipmapMode #-} + vkMipmapMode x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSamplerCreateInfo, mipmapMode}) + + {-# INLINE vkMipmapModeByteOffset #-} + vkMipmapModeByteOffset ~_ + = #{offset VkSamplerCreateInfo, mipmapMode} + + {-# INLINE readVkMipmapMode #-} + readVkMipmapMode p + = peekByteOff p #{offset VkSamplerCreateInfo, mipmapMode} + + {-# INLINE writeVkMipmapMode #-} + writeVkMipmapMode p + = pokeByteOff p #{offset VkSamplerCreateInfo, mipmapMode} + +instance {-# OVERLAPPING #-} + HasField "mipmapMode" VkSamplerCreateInfo where + type FieldType "mipmapMode" VkSamplerCreateInfo = + VkSamplerMipmapMode + type FieldOptional "mipmapMode" VkSamplerCreateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "mipmapMode" VkSamplerCreateInfo = + #{offset VkSamplerCreateInfo, mipmapMode} + type FieldIsArray "mipmapMode" VkSamplerCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkSamplerCreateInfo, mipmapMode} + +instance CanReadField "mipmapMode" VkSamplerCreateInfo where + {-# INLINE getField #-} + getField = vkMipmapMode + + {-# INLINE readField #-} + readField = readVkMipmapMode + +instance CanWriteField "mipmapMode" VkSamplerCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkMipmapMode + +instance {-# OVERLAPPING #-} HasVkAddressModeU VkSamplerCreateInfo + where + type VkAddressModeUMType VkSamplerCreateInfo = VkSamplerAddressMode + + {-# NOINLINE vkAddressModeU #-} + vkAddressModeU x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSamplerCreateInfo, addressModeU}) + + {-# INLINE vkAddressModeUByteOffset #-} + vkAddressModeUByteOffset ~_ + = #{offset VkSamplerCreateInfo, addressModeU} + + {-# INLINE readVkAddressModeU #-} + readVkAddressModeU p + = peekByteOff p #{offset VkSamplerCreateInfo, addressModeU} + + {-# INLINE writeVkAddressModeU #-} + writeVkAddressModeU p + = pokeByteOff p #{offset VkSamplerCreateInfo, addressModeU} + +instance {-# OVERLAPPING #-} + HasField "addressModeU" VkSamplerCreateInfo where + type FieldType "addressModeU" VkSamplerCreateInfo = + VkSamplerAddressMode + type FieldOptional "addressModeU" VkSamplerCreateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "addressModeU" VkSamplerCreateInfo = + #{offset VkSamplerCreateInfo, addressModeU} + type FieldIsArray "addressModeU" VkSamplerCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSamplerCreateInfo, addressModeU} + +instance CanReadField "addressModeU" VkSamplerCreateInfo where + {-# INLINE getField #-} + getField = vkAddressModeU + + {-# INLINE readField #-} + readField = readVkAddressModeU + +instance CanWriteField "addressModeU" VkSamplerCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkAddressModeU + +instance {-# OVERLAPPING #-} HasVkAddressModeV VkSamplerCreateInfo + where + type VkAddressModeVMType VkSamplerCreateInfo = VkSamplerAddressMode + + {-# NOINLINE vkAddressModeV #-} + vkAddressModeV x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSamplerCreateInfo, addressModeV}) + + {-# INLINE vkAddressModeVByteOffset #-} + vkAddressModeVByteOffset ~_ + = #{offset VkSamplerCreateInfo, addressModeV} + + {-# INLINE readVkAddressModeV #-} + readVkAddressModeV p + = peekByteOff p #{offset VkSamplerCreateInfo, addressModeV} + + {-# INLINE writeVkAddressModeV #-} + writeVkAddressModeV p + = pokeByteOff p #{offset VkSamplerCreateInfo, addressModeV} + +instance {-# OVERLAPPING #-} + HasField "addressModeV" VkSamplerCreateInfo where + type FieldType "addressModeV" VkSamplerCreateInfo = + VkSamplerAddressMode + type FieldOptional "addressModeV" VkSamplerCreateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "addressModeV" VkSamplerCreateInfo = + #{offset VkSamplerCreateInfo, addressModeV} + type FieldIsArray "addressModeV" VkSamplerCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSamplerCreateInfo, addressModeV} + +instance CanReadField "addressModeV" VkSamplerCreateInfo where + {-# INLINE getField #-} + getField = vkAddressModeV + + {-# INLINE readField #-} + readField = readVkAddressModeV + +instance CanWriteField "addressModeV" VkSamplerCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkAddressModeV + +instance {-# OVERLAPPING #-} HasVkAddressModeW VkSamplerCreateInfo + where + type VkAddressModeWMType VkSamplerCreateInfo = VkSamplerAddressMode + + {-# NOINLINE vkAddressModeW #-} + vkAddressModeW x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSamplerCreateInfo, addressModeW}) + + {-# INLINE vkAddressModeWByteOffset #-} + vkAddressModeWByteOffset ~_ + = #{offset VkSamplerCreateInfo, addressModeW} + + {-# INLINE readVkAddressModeW #-} + readVkAddressModeW p + = peekByteOff p #{offset VkSamplerCreateInfo, addressModeW} + + {-# INLINE writeVkAddressModeW #-} + writeVkAddressModeW p + = pokeByteOff p #{offset VkSamplerCreateInfo, addressModeW} + +instance {-# OVERLAPPING #-} + HasField "addressModeW" VkSamplerCreateInfo where + type FieldType "addressModeW" VkSamplerCreateInfo = + VkSamplerAddressMode + type FieldOptional "addressModeW" VkSamplerCreateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "addressModeW" VkSamplerCreateInfo = + #{offset VkSamplerCreateInfo, addressModeW} + type FieldIsArray "addressModeW" VkSamplerCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSamplerCreateInfo, addressModeW} + +instance CanReadField "addressModeW" VkSamplerCreateInfo where + {-# INLINE getField #-} + getField = vkAddressModeW + + {-# INLINE readField #-} + readField = readVkAddressModeW + +instance CanWriteField "addressModeW" VkSamplerCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkAddressModeW + +instance {-# OVERLAPPING #-} HasVkMipLodBias VkSamplerCreateInfo + where + type VkMipLodBiasMType VkSamplerCreateInfo = + #{type float} + + {-# NOINLINE vkMipLodBias #-} + vkMipLodBias x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSamplerCreateInfo, mipLodBias}) + + {-# INLINE vkMipLodBiasByteOffset #-} + vkMipLodBiasByteOffset ~_ + = #{offset VkSamplerCreateInfo, mipLodBias} + + {-# INLINE readVkMipLodBias #-} + readVkMipLodBias p + = peekByteOff p #{offset VkSamplerCreateInfo, mipLodBias} + + {-# INLINE writeVkMipLodBias #-} + writeVkMipLodBias p + = pokeByteOff p #{offset VkSamplerCreateInfo, mipLodBias} + +instance {-# OVERLAPPING #-} + HasField "mipLodBias" VkSamplerCreateInfo where + type FieldType "mipLodBias" VkSamplerCreateInfo = + #{type float} + type FieldOptional "mipLodBias" VkSamplerCreateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "mipLodBias" VkSamplerCreateInfo = + #{offset VkSamplerCreateInfo, mipLodBias} + type FieldIsArray "mipLodBias" VkSamplerCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkSamplerCreateInfo, mipLodBias} + +instance CanReadField "mipLodBias" VkSamplerCreateInfo where + {-# INLINE getField #-} + getField = vkMipLodBias + + {-# INLINE readField #-} + readField = readVkMipLodBias + +instance CanWriteField "mipLodBias" VkSamplerCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkMipLodBias + +instance {-# OVERLAPPING #-} + HasVkAnisotropyEnable VkSamplerCreateInfo where + type VkAnisotropyEnableMType VkSamplerCreateInfo = VkBool32 + + {-# NOINLINE vkAnisotropyEnable #-} + vkAnisotropyEnable x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSamplerCreateInfo, anisotropyEnable}) + + {-# INLINE vkAnisotropyEnableByteOffset #-} + vkAnisotropyEnableByteOffset ~_ + = #{offset VkSamplerCreateInfo, anisotropyEnable} + + {-# INLINE readVkAnisotropyEnable #-} + readVkAnisotropyEnable p + = peekByteOff p #{offset VkSamplerCreateInfo, anisotropyEnable} + + {-# INLINE writeVkAnisotropyEnable #-} + writeVkAnisotropyEnable p + = pokeByteOff p #{offset VkSamplerCreateInfo, anisotropyEnable} + +instance {-# OVERLAPPING #-} + HasField "anisotropyEnable" VkSamplerCreateInfo where + type FieldType "anisotropyEnable" VkSamplerCreateInfo = VkBool32 + type FieldOptional "anisotropyEnable" VkSamplerCreateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "anisotropyEnable" VkSamplerCreateInfo = + #{offset VkSamplerCreateInfo, anisotropyEnable} + type FieldIsArray "anisotropyEnable" VkSamplerCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSamplerCreateInfo, anisotropyEnable} + +instance CanReadField "anisotropyEnable" VkSamplerCreateInfo where + {-# INLINE getField #-} + getField = vkAnisotropyEnable + + {-# INLINE readField #-} + readField = readVkAnisotropyEnable + +instance CanWriteField "anisotropyEnable" VkSamplerCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkAnisotropyEnable + +instance {-# OVERLAPPING #-} HasVkMaxAnisotropy VkSamplerCreateInfo + where + type VkMaxAnisotropyMType VkSamplerCreateInfo = + #{type float} + + {-# NOINLINE vkMaxAnisotropy #-} + vkMaxAnisotropy x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSamplerCreateInfo, maxAnisotropy}) + + {-# INLINE vkMaxAnisotropyByteOffset #-} + vkMaxAnisotropyByteOffset ~_ + = #{offset VkSamplerCreateInfo, maxAnisotropy} + + {-# INLINE readVkMaxAnisotropy #-} + readVkMaxAnisotropy p + = peekByteOff p #{offset VkSamplerCreateInfo, maxAnisotropy} + + {-# INLINE writeVkMaxAnisotropy #-} + writeVkMaxAnisotropy p + = pokeByteOff p #{offset VkSamplerCreateInfo, maxAnisotropy} + +instance {-# OVERLAPPING #-} + HasField "maxAnisotropy" VkSamplerCreateInfo where + type FieldType "maxAnisotropy" VkSamplerCreateInfo = + #{type float} + type FieldOptional "maxAnisotropy" VkSamplerCreateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "maxAnisotropy" VkSamplerCreateInfo = + #{offset VkSamplerCreateInfo, maxAnisotropy} + type FieldIsArray "maxAnisotropy" VkSamplerCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSamplerCreateInfo, maxAnisotropy} + +instance CanReadField "maxAnisotropy" VkSamplerCreateInfo where + {-# INLINE getField #-} + getField = vkMaxAnisotropy + + {-# INLINE readField #-} + readField = readVkMaxAnisotropy + +instance CanWriteField "maxAnisotropy" VkSamplerCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkMaxAnisotropy + +instance {-# OVERLAPPING #-} HasVkCompareEnable VkSamplerCreateInfo + where + type VkCompareEnableMType VkSamplerCreateInfo = VkBool32 + + {-# NOINLINE vkCompareEnable #-} + vkCompareEnable x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSamplerCreateInfo, compareEnable}) + + {-# INLINE vkCompareEnableByteOffset #-} + vkCompareEnableByteOffset ~_ + = #{offset VkSamplerCreateInfo, compareEnable} + + {-# INLINE readVkCompareEnable #-} + readVkCompareEnable p + = peekByteOff p #{offset VkSamplerCreateInfo, compareEnable} + + {-# INLINE writeVkCompareEnable #-} + writeVkCompareEnable p + = pokeByteOff p #{offset VkSamplerCreateInfo, compareEnable} + +instance {-# OVERLAPPING #-} + HasField "compareEnable" VkSamplerCreateInfo where + type FieldType "compareEnable" VkSamplerCreateInfo = VkBool32 + type FieldOptional "compareEnable" VkSamplerCreateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "compareEnable" VkSamplerCreateInfo = + #{offset VkSamplerCreateInfo, compareEnable} + type FieldIsArray "compareEnable" VkSamplerCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSamplerCreateInfo, compareEnable} + +instance CanReadField "compareEnable" VkSamplerCreateInfo where + {-# INLINE getField #-} + getField = vkCompareEnable + + {-# INLINE readField #-} + readField = readVkCompareEnable + +instance CanWriteField "compareEnable" VkSamplerCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkCompareEnable + +instance {-# OVERLAPPING #-} HasVkCompareOp VkSamplerCreateInfo + where + type VkCompareOpMType VkSamplerCreateInfo = VkCompareOp + + {-# NOINLINE vkCompareOp #-} + vkCompareOp x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSamplerCreateInfo, compareOp}) + + {-# INLINE vkCompareOpByteOffset #-} + vkCompareOpByteOffset ~_ + = #{offset VkSamplerCreateInfo, compareOp} + + {-# INLINE readVkCompareOp #-} + readVkCompareOp p + = peekByteOff p #{offset VkSamplerCreateInfo, compareOp} + + {-# INLINE writeVkCompareOp #-} + writeVkCompareOp p + = pokeByteOff p #{offset VkSamplerCreateInfo, compareOp} + +instance {-# OVERLAPPING #-} + HasField "compareOp" VkSamplerCreateInfo where + type FieldType "compareOp" VkSamplerCreateInfo = VkCompareOp + type FieldOptional "compareOp" VkSamplerCreateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "compareOp" VkSamplerCreateInfo = + #{offset VkSamplerCreateInfo, compareOp} + type FieldIsArray "compareOp" VkSamplerCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkSamplerCreateInfo, compareOp} + +instance CanReadField "compareOp" VkSamplerCreateInfo where + {-# INLINE getField #-} + getField = vkCompareOp + + {-# INLINE readField #-} + readField = readVkCompareOp + +instance CanWriteField "compareOp" VkSamplerCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkCompareOp + +instance {-# OVERLAPPING #-} HasVkMinLod VkSamplerCreateInfo where + type VkMinLodMType VkSamplerCreateInfo = #{type float} + + {-# NOINLINE vkMinLod #-} + vkMinLod x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSamplerCreateInfo, minLod}) + + {-# INLINE vkMinLodByteOffset #-} + vkMinLodByteOffset ~_ + = #{offset VkSamplerCreateInfo, minLod} + + {-# INLINE readVkMinLod #-} + readVkMinLod p + = peekByteOff p #{offset VkSamplerCreateInfo, minLod} + + {-# INLINE writeVkMinLod #-} + writeVkMinLod p + = pokeByteOff p #{offset VkSamplerCreateInfo, minLod} + +instance {-# OVERLAPPING #-} HasField "minLod" VkSamplerCreateInfo + where + type FieldType "minLod" VkSamplerCreateInfo = + #{type float} + type FieldOptional "minLod" VkSamplerCreateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "minLod" VkSamplerCreateInfo = + #{offset VkSamplerCreateInfo, minLod} + type FieldIsArray "minLod" VkSamplerCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkSamplerCreateInfo, minLod} + +instance CanReadField "minLod" VkSamplerCreateInfo where + {-# INLINE getField #-} + getField = vkMinLod + + {-# INLINE readField #-} + readField = readVkMinLod + +instance CanWriteField "minLod" VkSamplerCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkMinLod + +instance {-# OVERLAPPING #-} HasVkMaxLod VkSamplerCreateInfo where + type VkMaxLodMType VkSamplerCreateInfo = #{type float} + + {-# NOINLINE vkMaxLod #-} + vkMaxLod x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSamplerCreateInfo, maxLod}) + + {-# INLINE vkMaxLodByteOffset #-} + vkMaxLodByteOffset ~_ + = #{offset VkSamplerCreateInfo, maxLod} + + {-# INLINE readVkMaxLod #-} + readVkMaxLod p + = peekByteOff p #{offset VkSamplerCreateInfo, maxLod} + + {-# INLINE writeVkMaxLod #-} + writeVkMaxLod p + = pokeByteOff p #{offset VkSamplerCreateInfo, maxLod} + +instance {-# OVERLAPPING #-} HasField "maxLod" VkSamplerCreateInfo + where + type FieldType "maxLod" VkSamplerCreateInfo = + #{type float} + type FieldOptional "maxLod" VkSamplerCreateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "maxLod" VkSamplerCreateInfo = + #{offset VkSamplerCreateInfo, maxLod} + type FieldIsArray "maxLod" VkSamplerCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkSamplerCreateInfo, maxLod} + +instance CanReadField "maxLod" VkSamplerCreateInfo where + {-# INLINE getField #-} + getField = vkMaxLod + + {-# INLINE readField #-} + readField = readVkMaxLod + +instance CanWriteField "maxLod" VkSamplerCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkMaxLod + +instance {-# OVERLAPPING #-} HasVkBorderColor VkSamplerCreateInfo + where + type VkBorderColorMType VkSamplerCreateInfo = VkBorderColor + + {-# NOINLINE vkBorderColor #-} + vkBorderColor x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSamplerCreateInfo, borderColor}) + + {-# INLINE vkBorderColorByteOffset #-} + vkBorderColorByteOffset ~_ + = #{offset VkSamplerCreateInfo, borderColor} + + {-# INLINE readVkBorderColor #-} + readVkBorderColor p + = peekByteOff p #{offset VkSamplerCreateInfo, borderColor} + + {-# INLINE writeVkBorderColor #-} + writeVkBorderColor p + = pokeByteOff p #{offset VkSamplerCreateInfo, borderColor} + +instance {-# OVERLAPPING #-} + HasField "borderColor" VkSamplerCreateInfo where + type FieldType "borderColor" VkSamplerCreateInfo = VkBorderColor + type FieldOptional "borderColor" VkSamplerCreateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "borderColor" VkSamplerCreateInfo = + #{offset VkSamplerCreateInfo, borderColor} + type FieldIsArray "borderColor" VkSamplerCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSamplerCreateInfo, borderColor} + +instance CanReadField "borderColor" VkSamplerCreateInfo where + {-# INLINE getField #-} + getField = vkBorderColor + + {-# INLINE readField #-} + readField = readVkBorderColor + +instance CanWriteField "borderColor" VkSamplerCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkBorderColor + +instance {-# OVERLAPPING #-} + HasVkUnnormalizedCoordinates VkSamplerCreateInfo where + type VkUnnormalizedCoordinatesMType VkSamplerCreateInfo = VkBool32 + + {-# NOINLINE vkUnnormalizedCoordinates #-} + vkUnnormalizedCoordinates x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSamplerCreateInfo, unnormalizedCoordinates}) + + {-# INLINE vkUnnormalizedCoordinatesByteOffset #-} + vkUnnormalizedCoordinatesByteOffset ~_ + = #{offset VkSamplerCreateInfo, unnormalizedCoordinates} + + {-# INLINE readVkUnnormalizedCoordinates #-} + readVkUnnormalizedCoordinates p + = peekByteOff p #{offset VkSamplerCreateInfo, unnormalizedCoordinates} + + {-# INLINE writeVkUnnormalizedCoordinates #-} + writeVkUnnormalizedCoordinates p + = pokeByteOff p #{offset VkSamplerCreateInfo, unnormalizedCoordinates} + +instance {-# OVERLAPPING #-} + HasField "unnormalizedCoordinates" VkSamplerCreateInfo where + type FieldType "unnormalizedCoordinates" VkSamplerCreateInfo = + VkBool32 + type FieldOptional "unnormalizedCoordinates" VkSamplerCreateInfo = + 'False -- ' closing tick for hsc2hs + type FieldOffset "unnormalizedCoordinates" VkSamplerCreateInfo = + #{offset VkSamplerCreateInfo, unnormalizedCoordinates} + type FieldIsArray "unnormalizedCoordinates" VkSamplerCreateInfo = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSamplerCreateInfo, unnormalizedCoordinates} + +instance CanReadField "unnormalizedCoordinates" VkSamplerCreateInfo + where + {-# INLINE getField #-} + getField = vkUnnormalizedCoordinates + + {-# INLINE readField #-} + readField = readVkUnnormalizedCoordinates + +instance CanWriteField "unnormalizedCoordinates" + VkSamplerCreateInfo + where + {-# INLINE writeField #-} + writeField = writeVkUnnormalizedCoordinates + +instance Show VkSamplerCreateInfo where + showsPrec d x + = showString "VkSamplerCreateInfo {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkFlags = " . + showsPrec d (vkFlags x) . + showString ", " . + showString "vkMagFilter = " . + showsPrec d (vkMagFilter x) . + showString ", " . + showString "vkMinFilter = " . + showsPrec d (vkMinFilter x) . + showString ", " . + showString "vkMipmapMode = " . + showsPrec d (vkMipmapMode x) . + showString ", " . + showString "vkAddressModeU = " . + showsPrec d (vkAddressModeU x) . + showString ", " . + showString "vkAddressModeV = " . + showsPrec d (vkAddressModeV x) . + showString ", " . + showString "vkAddressModeW = " . + showsPrec d (vkAddressModeW x) . + showString ", " . + showString "vkMipLodBias = " . + showsPrec d (vkMipLodBias x) . + showString ", " . + showString + "vkAnisotropyEnable = " + . + showsPrec d + (vkAnisotropyEnable x) + . + showString ", " . + showString + "vkMaxAnisotropy = " + . + showsPrec d + (vkMaxAnisotropy + x) + . + showString ", " + . + showString + "vkCompareEnable = " + . + showsPrec d + (vkCompareEnable + x) + . + showString + ", " + . + showString + "vkCompareOp = " + . + showsPrec + d + (vkCompareOp + x) + . + showString + ", " + . + showString + "vkMinLod = " + . + showsPrec + d + (vkMinLod + x) + . + showString + ", " + . + showString + "vkMaxLod = " + . + showsPrec + d + (vkMaxLod + x) + . + showString + ", " + . + showString + "vkBorderColor = " + . + showsPrec + d + (vkBorderColor + x) + . + showString + ", " + . + showString + "vkUnnormalizedCoordinates = " + . + showsPrec + d + (vkUnnormalizedCoordinates + x) + . + showChar + '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkSamplerReductionModeCreateInfoEXT.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkSamplerReductionModeCreateInfoEXT.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkSamplerReductionModeCreateInfoEXT.hsc @@ -0,0 +1,257 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkSamplerReductionModeCreateInfoEXT + (VkSamplerReductionModeCreateInfoEXT(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkSamplerReductionModeEXT (VkSamplerReductionModeEXT) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Struct.VkSamplerCreateInfo (VkSamplerCreateInfo) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkSamplerReductionModeCreateInfoEXT { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkSamplerReductionModeEXT reductionMode; +-- > } VkSamplerReductionModeCreateInfoEXT; +-- +-- +data VkSamplerReductionModeCreateInfoEXT = VkSamplerReductionModeCreateInfoEXT## Addr## + ByteArray## + +instance Eq VkSamplerReductionModeCreateInfoEXT where + (VkSamplerReductionModeCreateInfoEXT## a _) == + x@(VkSamplerReductionModeCreateInfoEXT## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkSamplerReductionModeCreateInfoEXT where + (VkSamplerReductionModeCreateInfoEXT## a _) `compare` + x@(VkSamplerReductionModeCreateInfoEXT## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkSamplerReductionModeCreateInfoEXT where + sizeOf ~_ = #{size VkSamplerReductionModeCreateInfoEXT} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkSamplerReductionModeCreateInfoEXT} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkSamplerReductionModeCreateInfoEXT + where + unsafeAddr (VkSamplerReductionModeCreateInfoEXT## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkSamplerReductionModeCreateInfoEXT## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkSamplerReductionModeCreateInfoEXT## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkSamplerReductionModeCreateInfoEXT where + type StructFields VkSamplerReductionModeCreateInfoEXT = + '["sType", "pNext", "reductionMode"] -- ' closing tick for hsc2hs + type CUnionType VkSamplerReductionModeCreateInfoEXT = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkSamplerReductionModeCreateInfoEXT = 'False -- ' closing tick for hsc2hs + type StructExtends VkSamplerReductionModeCreateInfoEXT = + '[VkSamplerCreateInfo] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkSamplerReductionModeCreateInfoEXT where + type VkSTypeMType VkSamplerReductionModeCreateInfoEXT = + VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSamplerReductionModeCreateInfoEXT, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkSamplerReductionModeCreateInfoEXT, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkSamplerReductionModeCreateInfoEXT, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkSamplerReductionModeCreateInfoEXT, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkSamplerReductionModeCreateInfoEXT where + type FieldType "sType" VkSamplerReductionModeCreateInfoEXT = + VkStructureType + type FieldOptional "sType" VkSamplerReductionModeCreateInfoEXT = + 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkSamplerReductionModeCreateInfoEXT = + #{offset VkSamplerReductionModeCreateInfoEXT, sType} + type FieldIsArray "sType" VkSamplerReductionModeCreateInfoEXT = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSamplerReductionModeCreateInfoEXT, sType} + +instance CanReadField "sType" VkSamplerReductionModeCreateInfoEXT + where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkSamplerReductionModeCreateInfoEXT + where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkSamplerReductionModeCreateInfoEXT where + type VkPNextMType VkSamplerReductionModeCreateInfoEXT = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSamplerReductionModeCreateInfoEXT, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkSamplerReductionModeCreateInfoEXT, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkSamplerReductionModeCreateInfoEXT, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkSamplerReductionModeCreateInfoEXT, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkSamplerReductionModeCreateInfoEXT where + type FieldType "pNext" VkSamplerReductionModeCreateInfoEXT = + Ptr Void + type FieldOptional "pNext" VkSamplerReductionModeCreateInfoEXT = + 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkSamplerReductionModeCreateInfoEXT = + #{offset VkSamplerReductionModeCreateInfoEXT, pNext} + type FieldIsArray "pNext" VkSamplerReductionModeCreateInfoEXT = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSamplerReductionModeCreateInfoEXT, pNext} + +instance CanReadField "pNext" VkSamplerReductionModeCreateInfoEXT + where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkSamplerReductionModeCreateInfoEXT + where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkReductionMode VkSamplerReductionModeCreateInfoEXT where + type VkReductionModeMType VkSamplerReductionModeCreateInfoEXT = + VkSamplerReductionModeEXT + + {-# NOINLINE vkReductionMode #-} + vkReductionMode x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSamplerReductionModeCreateInfoEXT, reductionMode}) + + {-# INLINE vkReductionModeByteOffset #-} + vkReductionModeByteOffset ~_ + = #{offset VkSamplerReductionModeCreateInfoEXT, reductionMode} + + {-# INLINE readVkReductionMode #-} + readVkReductionMode p + = peekByteOff p #{offset VkSamplerReductionModeCreateInfoEXT, reductionMode} + + {-# INLINE writeVkReductionMode #-} + writeVkReductionMode p + = pokeByteOff p #{offset VkSamplerReductionModeCreateInfoEXT, reductionMode} + +instance {-# OVERLAPPING #-} + HasField "reductionMode" VkSamplerReductionModeCreateInfoEXT where + type FieldType "reductionMode" VkSamplerReductionModeCreateInfoEXT + = VkSamplerReductionModeEXT + type FieldOptional "reductionMode" + VkSamplerReductionModeCreateInfoEXT + = 'False -- ' closing tick for hsc2hs + type FieldOffset "reductionMode" + VkSamplerReductionModeCreateInfoEXT + = + #{offset VkSamplerReductionModeCreateInfoEXT, reductionMode} + type FieldIsArray "reductionMode" + VkSamplerReductionModeCreateInfoEXT + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSamplerReductionModeCreateInfoEXT, reductionMode} + +instance CanReadField "reductionMode" + VkSamplerReductionModeCreateInfoEXT + where + {-# INLINE getField #-} + getField = vkReductionMode + + {-# INLINE readField #-} + readField = readVkReductionMode + +instance CanWriteField "reductionMode" + VkSamplerReductionModeCreateInfoEXT + where + {-# INLINE writeField #-} + writeField = writeVkReductionMode + +instance Show VkSamplerReductionModeCreateInfoEXT where + showsPrec d x + = showString "VkSamplerReductionModeCreateInfoEXT {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkReductionMode = " . + showsPrec d (vkReductionMode x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkSamplerYcbcrConversionCreateInfoKHR.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkSamplerYcbcrConversionCreateInfoKHR.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkSamplerYcbcrConversionCreateInfoKHR.hsc @@ -0,0 +1,714 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkSamplerYcbcrConversionCreateInfoKHR + (VkSamplerYcbcrConversionCreateInfoKHR(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.BaseTypes (VkBool32) +import Graphics.Vulkan.Types.Enum.VkChromaLocationKHR (VkChromaLocationKHR) +import Graphics.Vulkan.Types.Enum.VkFilter (VkFilter) +import Graphics.Vulkan.Types.Enum.VkFormat (VkFormat) +import Graphics.Vulkan.Types.Enum.VkSamplerYcbcrModelConversionKHR (VkSamplerYcbcrModelConversionKHR) +import Graphics.Vulkan.Types.Enum.VkSamplerYcbcrRangeKHR (VkSamplerYcbcrRangeKHR) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Struct.VkComponentMapping (VkComponentMapping) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkSamplerYcbcrConversionCreateInfoKHR { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkFormat format; +-- > VkSamplerYcbcrModelConversionKHR ycbcrModel; +-- > VkSamplerYcbcrRangeKHR ycbcrRange; +-- > VkComponentMapping components; +-- > VkChromaLocationKHR xChromaOffset; +-- > VkChromaLocationKHR yChromaOffset; +-- > VkFilter chromaFilter; +-- > VkBool32 forceExplicitReconstruction; +-- > } VkSamplerYcbcrConversionCreateInfoKHR; +-- +-- +data VkSamplerYcbcrConversionCreateInfoKHR = VkSamplerYcbcrConversionCreateInfoKHR## Addr## + ByteArray## + +instance Eq VkSamplerYcbcrConversionCreateInfoKHR where + (VkSamplerYcbcrConversionCreateInfoKHR## a _) == + x@(VkSamplerYcbcrConversionCreateInfoKHR## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkSamplerYcbcrConversionCreateInfoKHR where + (VkSamplerYcbcrConversionCreateInfoKHR## a _) `compare` + x@(VkSamplerYcbcrConversionCreateInfoKHR## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkSamplerYcbcrConversionCreateInfoKHR where + sizeOf ~_ + = #{size VkSamplerYcbcrConversionCreateInfoKHR} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkSamplerYcbcrConversionCreateInfoKHR} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkSamplerYcbcrConversionCreateInfoKHR + where + unsafeAddr (VkSamplerYcbcrConversionCreateInfoKHR## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkSamplerYcbcrConversionCreateInfoKHR## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkSamplerYcbcrConversionCreateInfoKHR## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkSamplerYcbcrConversionCreateInfoKHR where + type StructFields VkSamplerYcbcrConversionCreateInfoKHR = + '["sType", "pNext", "format", "ycbcrModel", "ycbcrRange", -- ' closing tick for hsc2hs + "components", "xChromaOffset", "yChromaOffset", "chromaFilter", + "forceExplicitReconstruction"] + type CUnionType VkSamplerYcbcrConversionCreateInfoKHR = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkSamplerYcbcrConversionCreateInfoKHR = 'False -- ' closing tick for hsc2hs + type StructExtends VkSamplerYcbcrConversionCreateInfoKHR = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkSamplerYcbcrConversionCreateInfoKHR where + type VkSTypeMType VkSamplerYcbcrConversionCreateInfoKHR = + VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSamplerYcbcrConversionCreateInfoKHR, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkSamplerYcbcrConversionCreateInfoKHR, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkSamplerYcbcrConversionCreateInfoKHR, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkSamplerYcbcrConversionCreateInfoKHR, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkSamplerYcbcrConversionCreateInfoKHR where + type FieldType "sType" VkSamplerYcbcrConversionCreateInfoKHR = + VkStructureType + type FieldOptional "sType" VkSamplerYcbcrConversionCreateInfoKHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkSamplerYcbcrConversionCreateInfoKHR = + #{offset VkSamplerYcbcrConversionCreateInfoKHR, sType} + type FieldIsArray "sType" VkSamplerYcbcrConversionCreateInfoKHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSamplerYcbcrConversionCreateInfoKHR, sType} + +instance CanReadField "sType" VkSamplerYcbcrConversionCreateInfoKHR + where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" + VkSamplerYcbcrConversionCreateInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkSamplerYcbcrConversionCreateInfoKHR where + type VkPNextMType VkSamplerYcbcrConversionCreateInfoKHR = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSamplerYcbcrConversionCreateInfoKHR, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkSamplerYcbcrConversionCreateInfoKHR, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkSamplerYcbcrConversionCreateInfoKHR, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkSamplerYcbcrConversionCreateInfoKHR, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkSamplerYcbcrConversionCreateInfoKHR where + type FieldType "pNext" VkSamplerYcbcrConversionCreateInfoKHR = + Ptr Void + type FieldOptional "pNext" VkSamplerYcbcrConversionCreateInfoKHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkSamplerYcbcrConversionCreateInfoKHR = + #{offset VkSamplerYcbcrConversionCreateInfoKHR, pNext} + type FieldIsArray "pNext" VkSamplerYcbcrConversionCreateInfoKHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSamplerYcbcrConversionCreateInfoKHR, pNext} + +instance CanReadField "pNext" VkSamplerYcbcrConversionCreateInfoKHR + where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" + VkSamplerYcbcrConversionCreateInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkFormat VkSamplerYcbcrConversionCreateInfoKHR where + type VkFormatMType VkSamplerYcbcrConversionCreateInfoKHR = VkFormat + + {-# NOINLINE vkFormat #-} + vkFormat x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSamplerYcbcrConversionCreateInfoKHR, format}) + + {-# INLINE vkFormatByteOffset #-} + vkFormatByteOffset ~_ + = #{offset VkSamplerYcbcrConversionCreateInfoKHR, format} + + {-# INLINE readVkFormat #-} + readVkFormat p + = peekByteOff p #{offset VkSamplerYcbcrConversionCreateInfoKHR, format} + + {-# INLINE writeVkFormat #-} + writeVkFormat p + = pokeByteOff p #{offset VkSamplerYcbcrConversionCreateInfoKHR, format} + +instance {-# OVERLAPPING #-} + HasField "format" VkSamplerYcbcrConversionCreateInfoKHR where + type FieldType "format" VkSamplerYcbcrConversionCreateInfoKHR = + VkFormat + type FieldOptional "format" VkSamplerYcbcrConversionCreateInfoKHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "format" VkSamplerYcbcrConversionCreateInfoKHR = + #{offset VkSamplerYcbcrConversionCreateInfoKHR, format} + type FieldIsArray "format" VkSamplerYcbcrConversionCreateInfoKHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSamplerYcbcrConversionCreateInfoKHR, format} + +instance CanReadField "format" + VkSamplerYcbcrConversionCreateInfoKHR + where + {-# INLINE getField #-} + getField = vkFormat + + {-# INLINE readField #-} + readField = readVkFormat + +instance CanWriteField "format" + VkSamplerYcbcrConversionCreateInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkFormat + +instance {-# OVERLAPPING #-} + HasVkYcbcrModel VkSamplerYcbcrConversionCreateInfoKHR where + type VkYcbcrModelMType VkSamplerYcbcrConversionCreateInfoKHR = + VkSamplerYcbcrModelConversionKHR + + {-# NOINLINE vkYcbcrModel #-} + vkYcbcrModel x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSamplerYcbcrConversionCreateInfoKHR, ycbcrModel}) + + {-# INLINE vkYcbcrModelByteOffset #-} + vkYcbcrModelByteOffset ~_ + = #{offset VkSamplerYcbcrConversionCreateInfoKHR, ycbcrModel} + + {-# INLINE readVkYcbcrModel #-} + readVkYcbcrModel p + = peekByteOff p #{offset VkSamplerYcbcrConversionCreateInfoKHR, ycbcrModel} + + {-# INLINE writeVkYcbcrModel #-} + writeVkYcbcrModel p + = pokeByteOff p #{offset VkSamplerYcbcrConversionCreateInfoKHR, ycbcrModel} + +instance {-# OVERLAPPING #-} + HasField "ycbcrModel" VkSamplerYcbcrConversionCreateInfoKHR where + type FieldType "ycbcrModel" VkSamplerYcbcrConversionCreateInfoKHR = + VkSamplerYcbcrModelConversionKHR + type FieldOptional "ycbcrModel" + VkSamplerYcbcrConversionCreateInfoKHR + = 'False -- ' closing tick for hsc2hs + type FieldOffset "ycbcrModel" VkSamplerYcbcrConversionCreateInfoKHR + = + #{offset VkSamplerYcbcrConversionCreateInfoKHR, ycbcrModel} + type FieldIsArray "ycbcrModel" + VkSamplerYcbcrConversionCreateInfoKHR + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSamplerYcbcrConversionCreateInfoKHR, ycbcrModel} + +instance CanReadField "ycbcrModel" + VkSamplerYcbcrConversionCreateInfoKHR + where + {-# INLINE getField #-} + getField = vkYcbcrModel + + {-# INLINE readField #-} + readField = readVkYcbcrModel + +instance CanWriteField "ycbcrModel" + VkSamplerYcbcrConversionCreateInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkYcbcrModel + +instance {-# OVERLAPPING #-} + HasVkYcbcrRange VkSamplerYcbcrConversionCreateInfoKHR where + type VkYcbcrRangeMType VkSamplerYcbcrConversionCreateInfoKHR = + VkSamplerYcbcrRangeKHR + + {-# NOINLINE vkYcbcrRange #-} + vkYcbcrRange x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSamplerYcbcrConversionCreateInfoKHR, ycbcrRange}) + + {-# INLINE vkYcbcrRangeByteOffset #-} + vkYcbcrRangeByteOffset ~_ + = #{offset VkSamplerYcbcrConversionCreateInfoKHR, ycbcrRange} + + {-# INLINE readVkYcbcrRange #-} + readVkYcbcrRange p + = peekByteOff p #{offset VkSamplerYcbcrConversionCreateInfoKHR, ycbcrRange} + + {-# INLINE writeVkYcbcrRange #-} + writeVkYcbcrRange p + = pokeByteOff p #{offset VkSamplerYcbcrConversionCreateInfoKHR, ycbcrRange} + +instance {-# OVERLAPPING #-} + HasField "ycbcrRange" VkSamplerYcbcrConversionCreateInfoKHR where + type FieldType "ycbcrRange" VkSamplerYcbcrConversionCreateInfoKHR = + VkSamplerYcbcrRangeKHR + type FieldOptional "ycbcrRange" + VkSamplerYcbcrConversionCreateInfoKHR + = 'False -- ' closing tick for hsc2hs + type FieldOffset "ycbcrRange" VkSamplerYcbcrConversionCreateInfoKHR + = + #{offset VkSamplerYcbcrConversionCreateInfoKHR, ycbcrRange} + type FieldIsArray "ycbcrRange" + VkSamplerYcbcrConversionCreateInfoKHR + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSamplerYcbcrConversionCreateInfoKHR, ycbcrRange} + +instance CanReadField "ycbcrRange" + VkSamplerYcbcrConversionCreateInfoKHR + where + {-# INLINE getField #-} + getField = vkYcbcrRange + + {-# INLINE readField #-} + readField = readVkYcbcrRange + +instance CanWriteField "ycbcrRange" + VkSamplerYcbcrConversionCreateInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkYcbcrRange + +instance {-# OVERLAPPING #-} + HasVkComponents VkSamplerYcbcrConversionCreateInfoKHR where + type VkComponentsMType VkSamplerYcbcrConversionCreateInfoKHR = + VkComponentMapping + + {-# NOINLINE vkComponents #-} + vkComponents x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSamplerYcbcrConversionCreateInfoKHR, components}) + + {-# INLINE vkComponentsByteOffset #-} + vkComponentsByteOffset ~_ + = #{offset VkSamplerYcbcrConversionCreateInfoKHR, components} + + {-# INLINE readVkComponents #-} + readVkComponents p + = peekByteOff p #{offset VkSamplerYcbcrConversionCreateInfoKHR, components} + + {-# INLINE writeVkComponents #-} + writeVkComponents p + = pokeByteOff p #{offset VkSamplerYcbcrConversionCreateInfoKHR, components} + +instance {-# OVERLAPPING #-} + HasField "components" VkSamplerYcbcrConversionCreateInfoKHR where + type FieldType "components" VkSamplerYcbcrConversionCreateInfoKHR = + VkComponentMapping + type FieldOptional "components" + VkSamplerYcbcrConversionCreateInfoKHR + = 'False -- ' closing tick for hsc2hs + type FieldOffset "components" VkSamplerYcbcrConversionCreateInfoKHR + = + #{offset VkSamplerYcbcrConversionCreateInfoKHR, components} + type FieldIsArray "components" + VkSamplerYcbcrConversionCreateInfoKHR + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSamplerYcbcrConversionCreateInfoKHR, components} + +instance CanReadField "components" + VkSamplerYcbcrConversionCreateInfoKHR + where + {-# INLINE getField #-} + getField = vkComponents + + {-# INLINE readField #-} + readField = readVkComponents + +instance CanWriteField "components" + VkSamplerYcbcrConversionCreateInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkComponents + +instance {-# OVERLAPPING #-} + HasVkXChromaOffset VkSamplerYcbcrConversionCreateInfoKHR where + type VkXChromaOffsetMType VkSamplerYcbcrConversionCreateInfoKHR = + VkChromaLocationKHR + + {-# NOINLINE vkXChromaOffset #-} + vkXChromaOffset x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSamplerYcbcrConversionCreateInfoKHR, xChromaOffset}) + + {-# INLINE vkXChromaOffsetByteOffset #-} + vkXChromaOffsetByteOffset ~_ + = #{offset VkSamplerYcbcrConversionCreateInfoKHR, xChromaOffset} + + {-# INLINE readVkXChromaOffset #-} + readVkXChromaOffset p + = peekByteOff p #{offset VkSamplerYcbcrConversionCreateInfoKHR, xChromaOffset} + + {-# INLINE writeVkXChromaOffset #-} + writeVkXChromaOffset p + = pokeByteOff p #{offset VkSamplerYcbcrConversionCreateInfoKHR, xChromaOffset} + +instance {-# OVERLAPPING #-} + HasField "xChromaOffset" VkSamplerYcbcrConversionCreateInfoKHR + where + type FieldType "xChromaOffset" + VkSamplerYcbcrConversionCreateInfoKHR + = VkChromaLocationKHR + type FieldOptional "xChromaOffset" + VkSamplerYcbcrConversionCreateInfoKHR + = 'False -- ' closing tick for hsc2hs + type FieldOffset "xChromaOffset" + VkSamplerYcbcrConversionCreateInfoKHR + = + #{offset VkSamplerYcbcrConversionCreateInfoKHR, xChromaOffset} + type FieldIsArray "xChromaOffset" + VkSamplerYcbcrConversionCreateInfoKHR + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSamplerYcbcrConversionCreateInfoKHR, xChromaOffset} + +instance CanReadField "xChromaOffset" + VkSamplerYcbcrConversionCreateInfoKHR + where + {-# INLINE getField #-} + getField = vkXChromaOffset + + {-# INLINE readField #-} + readField = readVkXChromaOffset + +instance CanWriteField "xChromaOffset" + VkSamplerYcbcrConversionCreateInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkXChromaOffset + +instance {-# OVERLAPPING #-} + HasVkYChromaOffset VkSamplerYcbcrConversionCreateInfoKHR where + type VkYChromaOffsetMType VkSamplerYcbcrConversionCreateInfoKHR = + VkChromaLocationKHR + + {-# NOINLINE vkYChromaOffset #-} + vkYChromaOffset x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSamplerYcbcrConversionCreateInfoKHR, yChromaOffset}) + + {-# INLINE vkYChromaOffsetByteOffset #-} + vkYChromaOffsetByteOffset ~_ + = #{offset VkSamplerYcbcrConversionCreateInfoKHR, yChromaOffset} + + {-# INLINE readVkYChromaOffset #-} + readVkYChromaOffset p + = peekByteOff p #{offset VkSamplerYcbcrConversionCreateInfoKHR, yChromaOffset} + + {-# INLINE writeVkYChromaOffset #-} + writeVkYChromaOffset p + = pokeByteOff p #{offset VkSamplerYcbcrConversionCreateInfoKHR, yChromaOffset} + +instance {-# OVERLAPPING #-} + HasField "yChromaOffset" VkSamplerYcbcrConversionCreateInfoKHR + where + type FieldType "yChromaOffset" + VkSamplerYcbcrConversionCreateInfoKHR + = VkChromaLocationKHR + type FieldOptional "yChromaOffset" + VkSamplerYcbcrConversionCreateInfoKHR + = 'False -- ' closing tick for hsc2hs + type FieldOffset "yChromaOffset" + VkSamplerYcbcrConversionCreateInfoKHR + = + #{offset VkSamplerYcbcrConversionCreateInfoKHR, yChromaOffset} + type FieldIsArray "yChromaOffset" + VkSamplerYcbcrConversionCreateInfoKHR + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSamplerYcbcrConversionCreateInfoKHR, yChromaOffset} + +instance CanReadField "yChromaOffset" + VkSamplerYcbcrConversionCreateInfoKHR + where + {-# INLINE getField #-} + getField = vkYChromaOffset + + {-# INLINE readField #-} + readField = readVkYChromaOffset + +instance CanWriteField "yChromaOffset" + VkSamplerYcbcrConversionCreateInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkYChromaOffset + +instance {-# OVERLAPPING #-} + HasVkChromaFilter VkSamplerYcbcrConversionCreateInfoKHR where + type VkChromaFilterMType VkSamplerYcbcrConversionCreateInfoKHR = + VkFilter + + {-# NOINLINE vkChromaFilter #-} + vkChromaFilter x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSamplerYcbcrConversionCreateInfoKHR, chromaFilter}) + + {-# INLINE vkChromaFilterByteOffset #-} + vkChromaFilterByteOffset ~_ + = #{offset VkSamplerYcbcrConversionCreateInfoKHR, chromaFilter} + + {-# INLINE readVkChromaFilter #-} + readVkChromaFilter p + = peekByteOff p #{offset VkSamplerYcbcrConversionCreateInfoKHR, chromaFilter} + + {-# INLINE writeVkChromaFilter #-} + writeVkChromaFilter p + = pokeByteOff p #{offset VkSamplerYcbcrConversionCreateInfoKHR, chromaFilter} + +instance {-# OVERLAPPING #-} + HasField "chromaFilter" VkSamplerYcbcrConversionCreateInfoKHR where + type FieldType "chromaFilter" VkSamplerYcbcrConversionCreateInfoKHR + = VkFilter + type FieldOptional "chromaFilter" + VkSamplerYcbcrConversionCreateInfoKHR + = 'False -- ' closing tick for hsc2hs + type FieldOffset "chromaFilter" + VkSamplerYcbcrConversionCreateInfoKHR + = + #{offset VkSamplerYcbcrConversionCreateInfoKHR, chromaFilter} + type FieldIsArray "chromaFilter" + VkSamplerYcbcrConversionCreateInfoKHR + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSamplerYcbcrConversionCreateInfoKHR, chromaFilter} + +instance CanReadField "chromaFilter" + VkSamplerYcbcrConversionCreateInfoKHR + where + {-# INLINE getField #-} + getField = vkChromaFilter + + {-# INLINE readField #-} + readField = readVkChromaFilter + +instance CanWriteField "chromaFilter" + VkSamplerYcbcrConversionCreateInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkChromaFilter + +instance {-# OVERLAPPING #-} + HasVkForceExplicitReconstruction + VkSamplerYcbcrConversionCreateInfoKHR + where + type VkForceExplicitReconstructionMType + VkSamplerYcbcrConversionCreateInfoKHR + = VkBool32 + + {-# NOINLINE vkForceExplicitReconstruction #-} + vkForceExplicitReconstruction x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSamplerYcbcrConversionCreateInfoKHR, forceExplicitReconstruction}) + + {-# INLINE vkForceExplicitReconstructionByteOffset #-} + vkForceExplicitReconstructionByteOffset ~_ + = #{offset VkSamplerYcbcrConversionCreateInfoKHR, forceExplicitReconstruction} + + {-# INLINE readVkForceExplicitReconstruction #-} + readVkForceExplicitReconstruction p + = peekByteOff p #{offset VkSamplerYcbcrConversionCreateInfoKHR, forceExplicitReconstruction} + + {-# INLINE writeVkForceExplicitReconstruction #-} + writeVkForceExplicitReconstruction p + = pokeByteOff p #{offset VkSamplerYcbcrConversionCreateInfoKHR, forceExplicitReconstruction} + +instance {-# OVERLAPPING #-} + HasField "forceExplicitReconstruction" + VkSamplerYcbcrConversionCreateInfoKHR + where + type FieldType "forceExplicitReconstruction" + VkSamplerYcbcrConversionCreateInfoKHR + = VkBool32 + type FieldOptional "forceExplicitReconstruction" + VkSamplerYcbcrConversionCreateInfoKHR + = 'False -- ' closing tick for hsc2hs + type FieldOffset "forceExplicitReconstruction" + VkSamplerYcbcrConversionCreateInfoKHR + = + #{offset VkSamplerYcbcrConversionCreateInfoKHR, forceExplicitReconstruction} + type FieldIsArray "forceExplicitReconstruction" + VkSamplerYcbcrConversionCreateInfoKHR + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSamplerYcbcrConversionCreateInfoKHR, forceExplicitReconstruction} + +instance CanReadField "forceExplicitReconstruction" + VkSamplerYcbcrConversionCreateInfoKHR + where + {-# INLINE getField #-} + getField = vkForceExplicitReconstruction + + {-# INLINE readField #-} + readField = readVkForceExplicitReconstruction + +instance CanWriteField "forceExplicitReconstruction" + VkSamplerYcbcrConversionCreateInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkForceExplicitReconstruction + +instance Show VkSamplerYcbcrConversionCreateInfoKHR where + showsPrec d x + = showString "VkSamplerYcbcrConversionCreateInfoKHR {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkFormat = " . + showsPrec d (vkFormat x) . + showString ", " . + showString "vkYcbcrModel = " . + showsPrec d (vkYcbcrModel x) . + showString ", " . + showString "vkYcbcrRange = " . + showsPrec d (vkYcbcrRange x) . + showString ", " . + showString "vkComponents = " . + showsPrec d (vkComponents x) . + showString ", " . + showString "vkXChromaOffset = " . + showsPrec d (vkXChromaOffset x) . + showString ", " . + showString "vkYChromaOffset = " . + showsPrec d (vkYChromaOffset x) . + showString ", " . + showString "vkChromaFilter = " . + showsPrec d (vkChromaFilter x) . + showString ", " . + showString + "vkForceExplicitReconstruction = " + . + showsPrec d + (vkForceExplicitReconstruction + x) + . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkSamplerYcbcrConversionImageFormatPropertiesKHR.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkSamplerYcbcrConversionImageFormatPropertiesKHR.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkSamplerYcbcrConversionImageFormatPropertiesKHR.hsc @@ -0,0 +1,272 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkSamplerYcbcrConversionImageFormatPropertiesKHR + (VkSamplerYcbcrConversionImageFormatPropertiesKHR(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Struct.VkImageFormatProperties2KHR (VkImageFormatProperties2KHR) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkSamplerYcbcrConversionImageFormatPropertiesKHR { +-- > VkStructureType sType; +-- > void* pNext; +-- > uint32_t combinedImageSamplerDescriptorCount; +-- > } VkSamplerYcbcrConversionImageFormatPropertiesKHR; +-- +-- +data VkSamplerYcbcrConversionImageFormatPropertiesKHR = VkSamplerYcbcrConversionImageFormatPropertiesKHR## Addr## + ByteArray## + +instance Eq VkSamplerYcbcrConversionImageFormatPropertiesKHR where + (VkSamplerYcbcrConversionImageFormatPropertiesKHR## a _) == + x@(VkSamplerYcbcrConversionImageFormatPropertiesKHR## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkSamplerYcbcrConversionImageFormatPropertiesKHR where + (VkSamplerYcbcrConversionImageFormatPropertiesKHR## a _) `compare` + x@(VkSamplerYcbcrConversionImageFormatPropertiesKHR## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkSamplerYcbcrConversionImageFormatPropertiesKHR + where + sizeOf ~_ + = #{size VkSamplerYcbcrConversionImageFormatPropertiesKHR} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkSamplerYcbcrConversionImageFormatPropertiesKHR} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim + VkSamplerYcbcrConversionImageFormatPropertiesKHR + where + unsafeAddr (VkSamplerYcbcrConversionImageFormatPropertiesKHR## a _) + = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray + (VkSamplerYcbcrConversionImageFormatPropertiesKHR## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkSamplerYcbcrConversionImageFormatPropertiesKHR## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal + VkSamplerYcbcrConversionImageFormatPropertiesKHR + where + type StructFields VkSamplerYcbcrConversionImageFormatPropertiesKHR + = '["sType", "pNext", "combinedImageSamplerDescriptorCount"] -- ' closing tick for hsc2hs + type CUnionType VkSamplerYcbcrConversionImageFormatPropertiesKHR = + 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkSamplerYcbcrConversionImageFormatPropertiesKHR + = 'True -- ' closing tick for hsc2hs + type StructExtends VkSamplerYcbcrConversionImageFormatPropertiesKHR + = '[VkImageFormatProperties2KHR] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkSamplerYcbcrConversionImageFormatPropertiesKHR where + type VkSTypeMType VkSamplerYcbcrConversionImageFormatPropertiesKHR + = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSamplerYcbcrConversionImageFormatPropertiesKHR, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkSamplerYcbcrConversionImageFormatPropertiesKHR, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkSamplerYcbcrConversionImageFormatPropertiesKHR, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkSamplerYcbcrConversionImageFormatPropertiesKHR, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkSamplerYcbcrConversionImageFormatPropertiesKHR + where + type FieldType "sType" + VkSamplerYcbcrConversionImageFormatPropertiesKHR + = VkStructureType + type FieldOptional "sType" + VkSamplerYcbcrConversionImageFormatPropertiesKHR + = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" + VkSamplerYcbcrConversionImageFormatPropertiesKHR + = + #{offset VkSamplerYcbcrConversionImageFormatPropertiesKHR, sType} + type FieldIsArray "sType" + VkSamplerYcbcrConversionImageFormatPropertiesKHR + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSamplerYcbcrConversionImageFormatPropertiesKHR, sType} + +instance CanReadField "sType" + VkSamplerYcbcrConversionImageFormatPropertiesKHR + where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkSamplerYcbcrConversionImageFormatPropertiesKHR where + type VkPNextMType VkSamplerYcbcrConversionImageFormatPropertiesKHR + = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSamplerYcbcrConversionImageFormatPropertiesKHR, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkSamplerYcbcrConversionImageFormatPropertiesKHR, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkSamplerYcbcrConversionImageFormatPropertiesKHR, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkSamplerYcbcrConversionImageFormatPropertiesKHR, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkSamplerYcbcrConversionImageFormatPropertiesKHR + where + type FieldType "pNext" + VkSamplerYcbcrConversionImageFormatPropertiesKHR + = Ptr Void + type FieldOptional "pNext" + VkSamplerYcbcrConversionImageFormatPropertiesKHR + = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" + VkSamplerYcbcrConversionImageFormatPropertiesKHR + = + #{offset VkSamplerYcbcrConversionImageFormatPropertiesKHR, pNext} + type FieldIsArray "pNext" + VkSamplerYcbcrConversionImageFormatPropertiesKHR + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSamplerYcbcrConversionImageFormatPropertiesKHR, pNext} + +instance CanReadField "pNext" + VkSamplerYcbcrConversionImageFormatPropertiesKHR + where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance {-# OVERLAPPING #-} + HasVkCombinedImageSamplerDescriptorCount + VkSamplerYcbcrConversionImageFormatPropertiesKHR + where + type VkCombinedImageSamplerDescriptorCountMType + VkSamplerYcbcrConversionImageFormatPropertiesKHR + = Word32 + + {-# NOINLINE vkCombinedImageSamplerDescriptorCount #-} + vkCombinedImageSamplerDescriptorCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSamplerYcbcrConversionImageFormatPropertiesKHR, combinedImageSamplerDescriptorCount}) + + {-# INLINE vkCombinedImageSamplerDescriptorCountByteOffset #-} + vkCombinedImageSamplerDescriptorCountByteOffset ~_ + = #{offset VkSamplerYcbcrConversionImageFormatPropertiesKHR, combinedImageSamplerDescriptorCount} + + {-# INLINE readVkCombinedImageSamplerDescriptorCount #-} + readVkCombinedImageSamplerDescriptorCount p + = peekByteOff p #{offset VkSamplerYcbcrConversionImageFormatPropertiesKHR, combinedImageSamplerDescriptorCount} + + {-# INLINE writeVkCombinedImageSamplerDescriptorCount #-} + writeVkCombinedImageSamplerDescriptorCount p + = pokeByteOff p #{offset VkSamplerYcbcrConversionImageFormatPropertiesKHR, combinedImageSamplerDescriptorCount} + +instance {-# OVERLAPPING #-} + HasField "combinedImageSamplerDescriptorCount" + VkSamplerYcbcrConversionImageFormatPropertiesKHR + where + type FieldType "combinedImageSamplerDescriptorCount" + VkSamplerYcbcrConversionImageFormatPropertiesKHR + = Word32 + type FieldOptional "combinedImageSamplerDescriptorCount" + VkSamplerYcbcrConversionImageFormatPropertiesKHR + = 'False -- ' closing tick for hsc2hs + type FieldOffset "combinedImageSamplerDescriptorCount" + VkSamplerYcbcrConversionImageFormatPropertiesKHR + = + #{offset VkSamplerYcbcrConversionImageFormatPropertiesKHR, combinedImageSamplerDescriptorCount} + type FieldIsArray "combinedImageSamplerDescriptorCount" + VkSamplerYcbcrConversionImageFormatPropertiesKHR + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSamplerYcbcrConversionImageFormatPropertiesKHR, combinedImageSamplerDescriptorCount} + +instance CanReadField "combinedImageSamplerDescriptorCount" + VkSamplerYcbcrConversionImageFormatPropertiesKHR + where + {-# INLINE getField #-} + getField = vkCombinedImageSamplerDescriptorCount + + {-# INLINE readField #-} + readField = readVkCombinedImageSamplerDescriptorCount + +instance Show VkSamplerYcbcrConversionImageFormatPropertiesKHR + where + showsPrec d x + = showString "VkSamplerYcbcrConversionImageFormatPropertiesKHR {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkCombinedImageSamplerDescriptorCount = " . + showsPrec d (vkCombinedImageSamplerDescriptorCount x) . + showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkSamplerYcbcrConversionInfoKHR.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkSamplerYcbcrConversionInfoKHR.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkSamplerYcbcrConversionInfoKHR.hsc @@ -0,0 +1,242 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkSamplerYcbcrConversionInfoKHR + (VkSamplerYcbcrConversionInfoKHR(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Handles (VkSamplerYcbcrConversionKHR) +import Graphics.Vulkan.Types.Struct.VkImageViewCreateInfo (VkImageViewCreateInfo) +import Graphics.Vulkan.Types.Struct.VkSamplerCreateInfo (VkSamplerCreateInfo) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkSamplerYcbcrConversionInfoKHR { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkSamplerYcbcrConversionKHR conversion; +-- > } VkSamplerYcbcrConversionInfoKHR; +-- +-- +data VkSamplerYcbcrConversionInfoKHR = VkSamplerYcbcrConversionInfoKHR## Addr## + ByteArray## + +instance Eq VkSamplerYcbcrConversionInfoKHR where + (VkSamplerYcbcrConversionInfoKHR## a _) == + x@(VkSamplerYcbcrConversionInfoKHR## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkSamplerYcbcrConversionInfoKHR where + (VkSamplerYcbcrConversionInfoKHR## a _) `compare` + x@(VkSamplerYcbcrConversionInfoKHR## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkSamplerYcbcrConversionInfoKHR where + sizeOf ~_ = #{size VkSamplerYcbcrConversionInfoKHR} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkSamplerYcbcrConversionInfoKHR} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkSamplerYcbcrConversionInfoKHR where + unsafeAddr (VkSamplerYcbcrConversionInfoKHR## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkSamplerYcbcrConversionInfoKHR## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkSamplerYcbcrConversionInfoKHR## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkSamplerYcbcrConversionInfoKHR where + type StructFields VkSamplerYcbcrConversionInfoKHR = + '["sType", "pNext", "conversion"] -- ' closing tick for hsc2hs + type CUnionType VkSamplerYcbcrConversionInfoKHR = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkSamplerYcbcrConversionInfoKHR = 'False -- ' closing tick for hsc2hs + type StructExtends VkSamplerYcbcrConversionInfoKHR = + '[VkSamplerCreateInfo, VkImageViewCreateInfo] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkSamplerYcbcrConversionInfoKHR where + type VkSTypeMType VkSamplerYcbcrConversionInfoKHR = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSamplerYcbcrConversionInfoKHR, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkSamplerYcbcrConversionInfoKHR, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkSamplerYcbcrConversionInfoKHR, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkSamplerYcbcrConversionInfoKHR, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkSamplerYcbcrConversionInfoKHR where + type FieldType "sType" VkSamplerYcbcrConversionInfoKHR = + VkStructureType + type FieldOptional "sType" VkSamplerYcbcrConversionInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkSamplerYcbcrConversionInfoKHR = + #{offset VkSamplerYcbcrConversionInfoKHR, sType} + type FieldIsArray "sType" VkSamplerYcbcrConversionInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSamplerYcbcrConversionInfoKHR, sType} + +instance CanReadField "sType" VkSamplerYcbcrConversionInfoKHR where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkSamplerYcbcrConversionInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkSamplerYcbcrConversionInfoKHR where + type VkPNextMType VkSamplerYcbcrConversionInfoKHR = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSamplerYcbcrConversionInfoKHR, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkSamplerYcbcrConversionInfoKHR, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkSamplerYcbcrConversionInfoKHR, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkSamplerYcbcrConversionInfoKHR, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkSamplerYcbcrConversionInfoKHR where + type FieldType "pNext" VkSamplerYcbcrConversionInfoKHR = Ptr Void + type FieldOptional "pNext" VkSamplerYcbcrConversionInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkSamplerYcbcrConversionInfoKHR = + #{offset VkSamplerYcbcrConversionInfoKHR, pNext} + type FieldIsArray "pNext" VkSamplerYcbcrConversionInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSamplerYcbcrConversionInfoKHR, pNext} + +instance CanReadField "pNext" VkSamplerYcbcrConversionInfoKHR where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkSamplerYcbcrConversionInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkConversion VkSamplerYcbcrConversionInfoKHR where + type VkConversionMType VkSamplerYcbcrConversionInfoKHR = + VkSamplerYcbcrConversionKHR + + {-# NOINLINE vkConversion #-} + vkConversion x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSamplerYcbcrConversionInfoKHR, conversion}) + + {-# INLINE vkConversionByteOffset #-} + vkConversionByteOffset ~_ + = #{offset VkSamplerYcbcrConversionInfoKHR, conversion} + + {-# INLINE readVkConversion #-} + readVkConversion p + = peekByteOff p #{offset VkSamplerYcbcrConversionInfoKHR, conversion} + + {-# INLINE writeVkConversion #-} + writeVkConversion p + = pokeByteOff p #{offset VkSamplerYcbcrConversionInfoKHR, conversion} + +instance {-# OVERLAPPING #-} + HasField "conversion" VkSamplerYcbcrConversionInfoKHR where + type FieldType "conversion" VkSamplerYcbcrConversionInfoKHR = + VkSamplerYcbcrConversionKHR + type FieldOptional "conversion" VkSamplerYcbcrConversionInfoKHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "conversion" VkSamplerYcbcrConversionInfoKHR = + #{offset VkSamplerYcbcrConversionInfoKHR, conversion} + type FieldIsArray "conversion" VkSamplerYcbcrConversionInfoKHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSamplerYcbcrConversionInfoKHR, conversion} + +instance CanReadField "conversion" VkSamplerYcbcrConversionInfoKHR + where + {-# INLINE getField #-} + getField = vkConversion + + {-# INLINE readField #-} + readField = readVkConversion + +instance CanWriteField "conversion" VkSamplerYcbcrConversionInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkConversion + +instance Show VkSamplerYcbcrConversionInfoKHR where + showsPrec d x + = showString "VkSamplerYcbcrConversionInfoKHR {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkConversion = " . + showsPrec d (vkConversion x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkSemaphoreCreateInfo.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkSemaphoreCreateInfo.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkSemaphoreCreateInfo.hsc @@ -0,0 +1,220 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkSemaphoreCreateInfo + (VkSemaphoreCreateInfo(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Bitmasks (VkSemaphoreCreateFlags) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkSemaphoreCreateInfo { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkSemaphoreCreateFlags flags; +-- > } VkSemaphoreCreateInfo; +-- +-- +data VkSemaphoreCreateInfo = VkSemaphoreCreateInfo## Addr## + ByteArray## + +instance Eq VkSemaphoreCreateInfo where + (VkSemaphoreCreateInfo## a _) == x@(VkSemaphoreCreateInfo## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkSemaphoreCreateInfo where + (VkSemaphoreCreateInfo## a _) `compare` + x@(VkSemaphoreCreateInfo## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkSemaphoreCreateInfo where + sizeOf ~_ = #{size VkSemaphoreCreateInfo} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkSemaphoreCreateInfo} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkSemaphoreCreateInfo where + unsafeAddr (VkSemaphoreCreateInfo## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkSemaphoreCreateInfo## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkSemaphoreCreateInfo## (plusAddr## (byteArrayContents## b) off) b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkSemaphoreCreateInfo where + type StructFields VkSemaphoreCreateInfo = + '["sType", "pNext", "flags"] -- ' closing tick for hsc2hs + type CUnionType VkSemaphoreCreateInfo = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkSemaphoreCreateInfo = 'False -- ' closing tick for hsc2hs + type StructExtends VkSemaphoreCreateInfo = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkSType VkSemaphoreCreateInfo where + type VkSTypeMType VkSemaphoreCreateInfo = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSemaphoreCreateInfo, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkSemaphoreCreateInfo, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkSemaphoreCreateInfo, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkSemaphoreCreateInfo, sType} + +instance {-# OVERLAPPING #-} HasField "sType" VkSemaphoreCreateInfo + where + type FieldType "sType" VkSemaphoreCreateInfo = VkStructureType + type FieldOptional "sType" VkSemaphoreCreateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkSemaphoreCreateInfo = + #{offset VkSemaphoreCreateInfo, sType} + type FieldIsArray "sType" VkSemaphoreCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkSemaphoreCreateInfo, sType} + +instance CanReadField "sType" VkSemaphoreCreateInfo where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkSemaphoreCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} HasVkPNext VkSemaphoreCreateInfo where + type VkPNextMType VkSemaphoreCreateInfo = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSemaphoreCreateInfo, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkSemaphoreCreateInfo, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkSemaphoreCreateInfo, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkSemaphoreCreateInfo, pNext} + +instance {-# OVERLAPPING #-} HasField "pNext" VkSemaphoreCreateInfo + where + type FieldType "pNext" VkSemaphoreCreateInfo = Ptr Void + type FieldOptional "pNext" VkSemaphoreCreateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkSemaphoreCreateInfo = + #{offset VkSemaphoreCreateInfo, pNext} + type FieldIsArray "pNext" VkSemaphoreCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkSemaphoreCreateInfo, pNext} + +instance CanReadField "pNext" VkSemaphoreCreateInfo where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkSemaphoreCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} HasVkFlags VkSemaphoreCreateInfo where + type VkFlagsMType VkSemaphoreCreateInfo = VkSemaphoreCreateFlags + + {-# NOINLINE vkFlags #-} + vkFlags x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSemaphoreCreateInfo, flags}) + + {-# INLINE vkFlagsByteOffset #-} + vkFlagsByteOffset ~_ + = #{offset VkSemaphoreCreateInfo, flags} + + {-# INLINE readVkFlags #-} + readVkFlags p + = peekByteOff p #{offset VkSemaphoreCreateInfo, flags} + + {-# INLINE writeVkFlags #-} + writeVkFlags p + = pokeByteOff p #{offset VkSemaphoreCreateInfo, flags} + +instance {-# OVERLAPPING #-} HasField "flags" VkSemaphoreCreateInfo + where + type FieldType "flags" VkSemaphoreCreateInfo = + VkSemaphoreCreateFlags + type FieldOptional "flags" VkSemaphoreCreateInfo = 'True -- ' closing tick for hsc2hs + type FieldOffset "flags" VkSemaphoreCreateInfo = + #{offset VkSemaphoreCreateInfo, flags} + type FieldIsArray "flags" VkSemaphoreCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkSemaphoreCreateInfo, flags} + +instance CanReadField "flags" VkSemaphoreCreateInfo where + {-# INLINE getField #-} + getField = vkFlags + + {-# INLINE readField #-} + readField = readVkFlags + +instance CanWriteField "flags" VkSemaphoreCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkFlags + +instance Show VkSemaphoreCreateInfo where + showsPrec d x + = showString "VkSemaphoreCreateInfo {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkFlags = " . showsPrec d (vkFlags x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkSemaphoreGetFdInfoKHR.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkSemaphoreGetFdInfoKHR.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkSemaphoreGetFdInfoKHR.hsc @@ -0,0 +1,283 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkSemaphoreGetFdInfoKHR + (VkSemaphoreGetFdInfoKHR(..)) where +import Foreign.Storable + (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkExternalSemaphoreHandleTypeFlagsKHR + (VkExternalSemaphoreHandleTypeFlagBitsKHR) +import Graphics.Vulkan.Types.Enum.VkStructureType + (VkStructureType) +import Graphics.Vulkan.Types.Handles + (VkSemaphore) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe + (unsafeDupablePerformIO) + +-- | > typedef struct VkSemaphoreGetFdInfoKHR { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkSemaphore semaphore; +-- > VkExternalSemaphoreHandleTypeFlagBitsKHR handleType; +-- > } VkSemaphoreGetFdInfoKHR; +-- +-- +data VkSemaphoreGetFdInfoKHR = VkSemaphoreGetFdInfoKHR## Addr## + ByteArray## + +instance Eq VkSemaphoreGetFdInfoKHR where + (VkSemaphoreGetFdInfoKHR## a _) == x@(VkSemaphoreGetFdInfoKHR## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkSemaphoreGetFdInfoKHR where + (VkSemaphoreGetFdInfoKHR## a _) `compare` + x@(VkSemaphoreGetFdInfoKHR## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkSemaphoreGetFdInfoKHR where + sizeOf ~_ = #{size VkSemaphoreGetFdInfoKHR} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkSemaphoreGetFdInfoKHR} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkSemaphoreGetFdInfoKHR where + unsafeAddr (VkSemaphoreGetFdInfoKHR## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkSemaphoreGetFdInfoKHR## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkSemaphoreGetFdInfoKHR## (plusAddr## (byteArrayContents## b) off) b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkSemaphoreGetFdInfoKHR where + type StructFields VkSemaphoreGetFdInfoKHR = + '["sType", "pNext", "semaphore", "handleType"] -- ' closing tick for hsc2hs + type CUnionType VkSemaphoreGetFdInfoKHR = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkSemaphoreGetFdInfoKHR = 'False -- ' closing tick for hsc2hs + type StructExtends VkSemaphoreGetFdInfoKHR = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkSType VkSemaphoreGetFdInfoKHR + where + type VkSTypeMType VkSemaphoreGetFdInfoKHR = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSemaphoreGetFdInfoKHR, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkSemaphoreGetFdInfoKHR, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkSemaphoreGetFdInfoKHR, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkSemaphoreGetFdInfoKHR, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkSemaphoreGetFdInfoKHR where + type FieldType "sType" VkSemaphoreGetFdInfoKHR = VkStructureType + type FieldOptional "sType" VkSemaphoreGetFdInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkSemaphoreGetFdInfoKHR = + #{offset VkSemaphoreGetFdInfoKHR, sType} + type FieldIsArray "sType" VkSemaphoreGetFdInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkSemaphoreGetFdInfoKHR, sType} + +instance CanReadField "sType" VkSemaphoreGetFdInfoKHR where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkSemaphoreGetFdInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} HasVkPNext VkSemaphoreGetFdInfoKHR + where + type VkPNextMType VkSemaphoreGetFdInfoKHR = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSemaphoreGetFdInfoKHR, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkSemaphoreGetFdInfoKHR, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkSemaphoreGetFdInfoKHR, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkSemaphoreGetFdInfoKHR, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkSemaphoreGetFdInfoKHR where + type FieldType "pNext" VkSemaphoreGetFdInfoKHR = Ptr Void + type FieldOptional "pNext" VkSemaphoreGetFdInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkSemaphoreGetFdInfoKHR = + #{offset VkSemaphoreGetFdInfoKHR, pNext} + type FieldIsArray "pNext" VkSemaphoreGetFdInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkSemaphoreGetFdInfoKHR, pNext} + +instance CanReadField "pNext" VkSemaphoreGetFdInfoKHR where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkSemaphoreGetFdInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} HasVkSemaphore VkSemaphoreGetFdInfoKHR + where + type VkSemaphoreMType VkSemaphoreGetFdInfoKHR = VkSemaphore + + {-# NOINLINE vkSemaphore #-} + vkSemaphore x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSemaphoreGetFdInfoKHR, semaphore}) + + {-# INLINE vkSemaphoreByteOffset #-} + vkSemaphoreByteOffset ~_ + = #{offset VkSemaphoreGetFdInfoKHR, semaphore} + + {-# INLINE readVkSemaphore #-} + readVkSemaphore p + = peekByteOff p #{offset VkSemaphoreGetFdInfoKHR, semaphore} + + {-# INLINE writeVkSemaphore #-} + writeVkSemaphore p + = pokeByteOff p #{offset VkSemaphoreGetFdInfoKHR, semaphore} + +instance {-# OVERLAPPING #-} + HasField "semaphore" VkSemaphoreGetFdInfoKHR where + type FieldType "semaphore" VkSemaphoreGetFdInfoKHR = VkSemaphore + type FieldOptional "semaphore" VkSemaphoreGetFdInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "semaphore" VkSemaphoreGetFdInfoKHR = + #{offset VkSemaphoreGetFdInfoKHR, semaphore} + type FieldIsArray "semaphore" VkSemaphoreGetFdInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSemaphoreGetFdInfoKHR, semaphore} + +instance CanReadField "semaphore" VkSemaphoreGetFdInfoKHR where + {-# INLINE getField #-} + getField = vkSemaphore + + {-# INLINE readField #-} + readField = readVkSemaphore + +instance CanWriteField "semaphore" VkSemaphoreGetFdInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkSemaphore + +instance {-# OVERLAPPING #-} + HasVkHandleType VkSemaphoreGetFdInfoKHR where + type VkHandleTypeMType VkSemaphoreGetFdInfoKHR = + VkExternalSemaphoreHandleTypeFlagBitsKHR + + {-# NOINLINE vkHandleType #-} + vkHandleType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSemaphoreGetFdInfoKHR, handleType}) + + {-# INLINE vkHandleTypeByteOffset #-} + vkHandleTypeByteOffset ~_ + = #{offset VkSemaphoreGetFdInfoKHR, handleType} + + {-# INLINE readVkHandleType #-} + readVkHandleType p + = peekByteOff p #{offset VkSemaphoreGetFdInfoKHR, handleType} + + {-# INLINE writeVkHandleType #-} + writeVkHandleType p + = pokeByteOff p #{offset VkSemaphoreGetFdInfoKHR, handleType} + +instance {-# OVERLAPPING #-} + HasField "handleType" VkSemaphoreGetFdInfoKHR where + type FieldType "handleType" VkSemaphoreGetFdInfoKHR = + VkExternalSemaphoreHandleTypeFlagBitsKHR + type FieldOptional "handleType" VkSemaphoreGetFdInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "handleType" VkSemaphoreGetFdInfoKHR = + #{offset VkSemaphoreGetFdInfoKHR, handleType} + type FieldIsArray "handleType" VkSemaphoreGetFdInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSemaphoreGetFdInfoKHR, handleType} + +instance CanReadField "handleType" VkSemaphoreGetFdInfoKHR where + {-# INLINE getField #-} + getField = vkHandleType + + {-# INLINE readField #-} + readField = readVkHandleType + +instance CanWriteField "handleType" VkSemaphoreGetFdInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkHandleType + +instance Show VkSemaphoreGetFdInfoKHR where + showsPrec d x + = showString "VkSemaphoreGetFdInfoKHR {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkSemaphore = " . + showsPrec d (vkSemaphore x) . + showString ", " . + showString "vkHandleType = " . + showsPrec d (vkHandleType x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkSemaphoreGetWin32HandleInfoKHR.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkSemaphoreGetWin32HandleInfoKHR.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkSemaphoreGetWin32HandleInfoKHR.hsc @@ -0,0 +1,309 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkSemaphoreGetWin32HandleInfoKHR + (VkSemaphoreGetWin32HandleInfoKHR(..)) where +import Foreign.Storable + (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkExternalSemaphoreHandleTypeFlagsKHR + (VkExternalSemaphoreHandleTypeFlagBitsKHR) +import Graphics.Vulkan.Types.Enum.VkStructureType + (VkStructureType) +import Graphics.Vulkan.Types.Handles + (VkSemaphore) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe + (unsafeDupablePerformIO) + +-- | > typedef struct VkSemaphoreGetWin32HandleInfoKHR { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkSemaphore semaphore; +-- > VkExternalSemaphoreHandleTypeFlagBitsKHR handleType; +-- > } VkSemaphoreGetWin32HandleInfoKHR; +-- +-- +data VkSemaphoreGetWin32HandleInfoKHR = VkSemaphoreGetWin32HandleInfoKHR## Addr## + ByteArray## + +instance Eq VkSemaphoreGetWin32HandleInfoKHR where + (VkSemaphoreGetWin32HandleInfoKHR## a _) == + x@(VkSemaphoreGetWin32HandleInfoKHR## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkSemaphoreGetWin32HandleInfoKHR where + (VkSemaphoreGetWin32HandleInfoKHR## a _) `compare` + x@(VkSemaphoreGetWin32HandleInfoKHR## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkSemaphoreGetWin32HandleInfoKHR where + sizeOf ~_ = #{size VkSemaphoreGetWin32HandleInfoKHR} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkSemaphoreGetWin32HandleInfoKHR} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkSemaphoreGetWin32HandleInfoKHR where + unsafeAddr (VkSemaphoreGetWin32HandleInfoKHR## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkSemaphoreGetWin32HandleInfoKHR## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkSemaphoreGetWin32HandleInfoKHR## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkSemaphoreGetWin32HandleInfoKHR where + type StructFields VkSemaphoreGetWin32HandleInfoKHR = + '["sType", "pNext", "semaphore", "handleType"] -- ' closing tick for hsc2hs + type CUnionType VkSemaphoreGetWin32HandleInfoKHR = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkSemaphoreGetWin32HandleInfoKHR = 'False -- ' closing tick for hsc2hs + type StructExtends VkSemaphoreGetWin32HandleInfoKHR = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkSemaphoreGetWin32HandleInfoKHR where + type VkSTypeMType VkSemaphoreGetWin32HandleInfoKHR = + VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSemaphoreGetWin32HandleInfoKHR, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkSemaphoreGetWin32HandleInfoKHR, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkSemaphoreGetWin32HandleInfoKHR, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkSemaphoreGetWin32HandleInfoKHR, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkSemaphoreGetWin32HandleInfoKHR where + type FieldType "sType" VkSemaphoreGetWin32HandleInfoKHR = + VkStructureType + type FieldOptional "sType" VkSemaphoreGetWin32HandleInfoKHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkSemaphoreGetWin32HandleInfoKHR = + #{offset VkSemaphoreGetWin32HandleInfoKHR, sType} + type FieldIsArray "sType" VkSemaphoreGetWin32HandleInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSemaphoreGetWin32HandleInfoKHR, sType} + +instance CanReadField "sType" VkSemaphoreGetWin32HandleInfoKHR + where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkSemaphoreGetWin32HandleInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkSemaphoreGetWin32HandleInfoKHR where + type VkPNextMType VkSemaphoreGetWin32HandleInfoKHR = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSemaphoreGetWin32HandleInfoKHR, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkSemaphoreGetWin32HandleInfoKHR, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkSemaphoreGetWin32HandleInfoKHR, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkSemaphoreGetWin32HandleInfoKHR, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkSemaphoreGetWin32HandleInfoKHR where + type FieldType "pNext" VkSemaphoreGetWin32HandleInfoKHR = Ptr Void + type FieldOptional "pNext" VkSemaphoreGetWin32HandleInfoKHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkSemaphoreGetWin32HandleInfoKHR = + #{offset VkSemaphoreGetWin32HandleInfoKHR, pNext} + type FieldIsArray "pNext" VkSemaphoreGetWin32HandleInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSemaphoreGetWin32HandleInfoKHR, pNext} + +instance CanReadField "pNext" VkSemaphoreGetWin32HandleInfoKHR + where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkSemaphoreGetWin32HandleInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkSemaphore VkSemaphoreGetWin32HandleInfoKHR where + type VkSemaphoreMType VkSemaphoreGetWin32HandleInfoKHR = + VkSemaphore + + {-# NOINLINE vkSemaphore #-} + vkSemaphore x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSemaphoreGetWin32HandleInfoKHR, semaphore}) + + {-# INLINE vkSemaphoreByteOffset #-} + vkSemaphoreByteOffset ~_ + = #{offset VkSemaphoreGetWin32HandleInfoKHR, semaphore} + + {-# INLINE readVkSemaphore #-} + readVkSemaphore p + = peekByteOff p #{offset VkSemaphoreGetWin32HandleInfoKHR, semaphore} + + {-# INLINE writeVkSemaphore #-} + writeVkSemaphore p + = pokeByteOff p #{offset VkSemaphoreGetWin32HandleInfoKHR, semaphore} + +instance {-# OVERLAPPING #-} + HasField "semaphore" VkSemaphoreGetWin32HandleInfoKHR where + type FieldType "semaphore" VkSemaphoreGetWin32HandleInfoKHR = + VkSemaphore + type FieldOptional "semaphore" VkSemaphoreGetWin32HandleInfoKHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "semaphore" VkSemaphoreGetWin32HandleInfoKHR = + #{offset VkSemaphoreGetWin32HandleInfoKHR, semaphore} + type FieldIsArray "semaphore" VkSemaphoreGetWin32HandleInfoKHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSemaphoreGetWin32HandleInfoKHR, semaphore} + +instance CanReadField "semaphore" VkSemaphoreGetWin32HandleInfoKHR + where + {-# INLINE getField #-} + getField = vkSemaphore + + {-# INLINE readField #-} + readField = readVkSemaphore + +instance CanWriteField "semaphore" VkSemaphoreGetWin32HandleInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkSemaphore + +instance {-# OVERLAPPING #-} + HasVkHandleType VkSemaphoreGetWin32HandleInfoKHR where + type VkHandleTypeMType VkSemaphoreGetWin32HandleInfoKHR = + VkExternalSemaphoreHandleTypeFlagBitsKHR + + {-# NOINLINE vkHandleType #-} + vkHandleType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSemaphoreGetWin32HandleInfoKHR, handleType}) + + {-# INLINE vkHandleTypeByteOffset #-} + vkHandleTypeByteOffset ~_ + = #{offset VkSemaphoreGetWin32HandleInfoKHR, handleType} + + {-# INLINE readVkHandleType #-} + readVkHandleType p + = peekByteOff p #{offset VkSemaphoreGetWin32HandleInfoKHR, handleType} + + {-# INLINE writeVkHandleType #-} + writeVkHandleType p + = pokeByteOff p #{offset VkSemaphoreGetWin32HandleInfoKHR, handleType} + +instance {-# OVERLAPPING #-} + HasField "handleType" VkSemaphoreGetWin32HandleInfoKHR where + type FieldType "handleType" VkSemaphoreGetWin32HandleInfoKHR = + VkExternalSemaphoreHandleTypeFlagBitsKHR + type FieldOptional "handleType" VkSemaphoreGetWin32HandleInfoKHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "handleType" VkSemaphoreGetWin32HandleInfoKHR = + #{offset VkSemaphoreGetWin32HandleInfoKHR, handleType} + type FieldIsArray "handleType" VkSemaphoreGetWin32HandleInfoKHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSemaphoreGetWin32HandleInfoKHR, handleType} + +instance CanReadField "handleType" VkSemaphoreGetWin32HandleInfoKHR + where + {-# INLINE getField #-} + getField = vkHandleType + + {-# INLINE readField #-} + readField = readVkHandleType + +instance CanWriteField "handleType" + VkSemaphoreGetWin32HandleInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkHandleType + +instance Show VkSemaphoreGetWin32HandleInfoKHR where + showsPrec d x + = showString "VkSemaphoreGetWin32HandleInfoKHR {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkSemaphore = " . + showsPrec d (vkSemaphore x) . + showString ", " . + showString "vkHandleType = " . + showsPrec d (vkHandleType x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkShaderModuleCreateInfo.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkShaderModuleCreateInfo.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkShaderModuleCreateInfo.hsc @@ -0,0 +1,327 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkShaderModuleCreateInfo + (VkShaderModuleCreateInfo(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Bitmasks (VkShaderModuleCreateFlags) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkShaderModuleCreateInfo { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkShaderModuleCreateFlags flags; +-- > size_t codeSize; +-- > const uint32_t* pCode; +-- > } VkShaderModuleCreateInfo; +-- +-- +data VkShaderModuleCreateInfo = VkShaderModuleCreateInfo## Addr## + ByteArray## + +instance Eq VkShaderModuleCreateInfo where + (VkShaderModuleCreateInfo## a _) == + x@(VkShaderModuleCreateInfo## b _) = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkShaderModuleCreateInfo where + (VkShaderModuleCreateInfo## a _) `compare` + x@(VkShaderModuleCreateInfo## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkShaderModuleCreateInfo where + sizeOf ~_ = #{size VkShaderModuleCreateInfo} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkShaderModuleCreateInfo} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkShaderModuleCreateInfo where + unsafeAddr (VkShaderModuleCreateInfo## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkShaderModuleCreateInfo## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkShaderModuleCreateInfo## (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkShaderModuleCreateInfo where + type StructFields VkShaderModuleCreateInfo = + '["sType", "pNext", "flags", "codeSize", "pCode"] -- ' closing tick for hsc2hs + type CUnionType VkShaderModuleCreateInfo = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkShaderModuleCreateInfo = 'False -- ' closing tick for hsc2hs + type StructExtends VkShaderModuleCreateInfo = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkSType VkShaderModuleCreateInfo + where + type VkSTypeMType VkShaderModuleCreateInfo = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkShaderModuleCreateInfo, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkShaderModuleCreateInfo, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkShaderModuleCreateInfo, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkShaderModuleCreateInfo, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkShaderModuleCreateInfo where + type FieldType "sType" VkShaderModuleCreateInfo = VkStructureType + type FieldOptional "sType" VkShaderModuleCreateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkShaderModuleCreateInfo = + #{offset VkShaderModuleCreateInfo, sType} + type FieldIsArray "sType" VkShaderModuleCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkShaderModuleCreateInfo, sType} + +instance CanReadField "sType" VkShaderModuleCreateInfo where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkShaderModuleCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} HasVkPNext VkShaderModuleCreateInfo + where + type VkPNextMType VkShaderModuleCreateInfo = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkShaderModuleCreateInfo, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkShaderModuleCreateInfo, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkShaderModuleCreateInfo, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkShaderModuleCreateInfo, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkShaderModuleCreateInfo where + type FieldType "pNext" VkShaderModuleCreateInfo = Ptr Void + type FieldOptional "pNext" VkShaderModuleCreateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkShaderModuleCreateInfo = + #{offset VkShaderModuleCreateInfo, pNext} + type FieldIsArray "pNext" VkShaderModuleCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkShaderModuleCreateInfo, pNext} + +instance CanReadField "pNext" VkShaderModuleCreateInfo where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkShaderModuleCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} HasVkFlags VkShaderModuleCreateInfo + where + type VkFlagsMType VkShaderModuleCreateInfo = + VkShaderModuleCreateFlags + + {-# NOINLINE vkFlags #-} + vkFlags x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkShaderModuleCreateInfo, flags}) + + {-# INLINE vkFlagsByteOffset #-} + vkFlagsByteOffset ~_ + = #{offset VkShaderModuleCreateInfo, flags} + + {-# INLINE readVkFlags #-} + readVkFlags p + = peekByteOff p #{offset VkShaderModuleCreateInfo, flags} + + {-# INLINE writeVkFlags #-} + writeVkFlags p + = pokeByteOff p #{offset VkShaderModuleCreateInfo, flags} + +instance {-# OVERLAPPING #-} + HasField "flags" VkShaderModuleCreateInfo where + type FieldType "flags" VkShaderModuleCreateInfo = + VkShaderModuleCreateFlags + type FieldOptional "flags" VkShaderModuleCreateInfo = 'True -- ' closing tick for hsc2hs + type FieldOffset "flags" VkShaderModuleCreateInfo = + #{offset VkShaderModuleCreateInfo, flags} + type FieldIsArray "flags" VkShaderModuleCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkShaderModuleCreateInfo, flags} + +instance CanReadField "flags" VkShaderModuleCreateInfo where + {-# INLINE getField #-} + getField = vkFlags + + {-# INLINE readField #-} + readField = readVkFlags + +instance CanWriteField "flags" VkShaderModuleCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkFlags + +instance {-# OVERLAPPING #-} HasVkCodeSize VkShaderModuleCreateInfo + where + type VkCodeSizeMType VkShaderModuleCreateInfo = CSize + + {-# NOINLINE vkCodeSize #-} + vkCodeSize x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkShaderModuleCreateInfo, codeSize}) + + {-# INLINE vkCodeSizeByteOffset #-} + vkCodeSizeByteOffset ~_ + = #{offset VkShaderModuleCreateInfo, codeSize} + + {-# INLINE readVkCodeSize #-} + readVkCodeSize p + = peekByteOff p #{offset VkShaderModuleCreateInfo, codeSize} + + {-# INLINE writeVkCodeSize #-} + writeVkCodeSize p + = pokeByteOff p #{offset VkShaderModuleCreateInfo, codeSize} + +instance {-# OVERLAPPING #-} + HasField "codeSize" VkShaderModuleCreateInfo where + type FieldType "codeSize" VkShaderModuleCreateInfo = CSize + type FieldOptional "codeSize" VkShaderModuleCreateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "codeSize" VkShaderModuleCreateInfo = + #{offset VkShaderModuleCreateInfo, codeSize} + type FieldIsArray "codeSize" VkShaderModuleCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkShaderModuleCreateInfo, codeSize} + +instance CanReadField "codeSize" VkShaderModuleCreateInfo where + {-# INLINE getField #-} + getField = vkCodeSize + + {-# INLINE readField #-} + readField = readVkCodeSize + +instance CanWriteField "codeSize" VkShaderModuleCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkCodeSize + +instance {-# OVERLAPPING #-} HasVkPCode VkShaderModuleCreateInfo + where + type VkPCodeMType VkShaderModuleCreateInfo = Ptr Word32 + + {-# NOINLINE vkPCode #-} + vkPCode x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkShaderModuleCreateInfo, pCode}) + + {-# INLINE vkPCodeByteOffset #-} + vkPCodeByteOffset ~_ + = #{offset VkShaderModuleCreateInfo, pCode} + + {-# INLINE readVkPCode #-} + readVkPCode p + = peekByteOff p #{offset VkShaderModuleCreateInfo, pCode} + + {-# INLINE writeVkPCode #-} + writeVkPCode p + = pokeByteOff p #{offset VkShaderModuleCreateInfo, pCode} + +instance {-# OVERLAPPING #-} + HasField "pCode" VkShaderModuleCreateInfo where + type FieldType "pCode" VkShaderModuleCreateInfo = Ptr Word32 + type FieldOptional "pCode" VkShaderModuleCreateInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "pCode" VkShaderModuleCreateInfo = + #{offset VkShaderModuleCreateInfo, pCode} + type FieldIsArray "pCode" VkShaderModuleCreateInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkShaderModuleCreateInfo, pCode} + +instance CanReadField "pCode" VkShaderModuleCreateInfo where + {-# INLINE getField #-} + getField = vkPCode + + {-# INLINE readField #-} + readField = readVkPCode + +instance CanWriteField "pCode" VkShaderModuleCreateInfo where + {-# INLINE writeField #-} + writeField = writeVkPCode + +instance Show VkShaderModuleCreateInfo where + showsPrec d x + = showString "VkShaderModuleCreateInfo {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkFlags = " . + showsPrec d (vkFlags x) . + showString ", " . + showString "vkCodeSize = " . + showsPrec d (vkCodeSize x) . + showString ", " . + showString "vkPCode = " . + showsPrec d (vkPCode x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkShaderModuleValidationCacheCreateInfoEXT.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkShaderModuleValidationCacheCreateInfoEXT.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkShaderModuleValidationCacheCreateInfoEXT.hsc @@ -0,0 +1,278 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkShaderModuleValidationCacheCreateInfoEXT + (VkShaderModuleValidationCacheCreateInfoEXT(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Handles (VkValidationCacheEXT) +import Graphics.Vulkan.Types.Struct.VkShaderModuleCreateInfo (VkShaderModuleCreateInfo) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkShaderModuleValidationCacheCreateInfoEXT { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkValidationCacheEXT validationCache; +-- > } VkShaderModuleValidationCacheCreateInfoEXT; +-- +-- +data VkShaderModuleValidationCacheCreateInfoEXT = VkShaderModuleValidationCacheCreateInfoEXT## Addr## + ByteArray## + +instance Eq VkShaderModuleValidationCacheCreateInfoEXT where + (VkShaderModuleValidationCacheCreateInfoEXT## a _) == + x@(VkShaderModuleValidationCacheCreateInfoEXT## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkShaderModuleValidationCacheCreateInfoEXT where + (VkShaderModuleValidationCacheCreateInfoEXT## a _) `compare` + x@(VkShaderModuleValidationCacheCreateInfoEXT## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkShaderModuleValidationCacheCreateInfoEXT where + sizeOf ~_ + = #{size VkShaderModuleValidationCacheCreateInfoEXT} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkShaderModuleValidationCacheCreateInfoEXT} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim + VkShaderModuleValidationCacheCreateInfoEXT + where + unsafeAddr (VkShaderModuleValidationCacheCreateInfoEXT## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkShaderModuleValidationCacheCreateInfoEXT## _ b) + = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkShaderModuleValidationCacheCreateInfoEXT## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkShaderModuleValidationCacheCreateInfoEXT + where + type StructFields VkShaderModuleValidationCacheCreateInfoEXT = + '["sType", "pNext", "validationCache"] -- ' closing tick for hsc2hs + type CUnionType VkShaderModuleValidationCacheCreateInfoEXT = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkShaderModuleValidationCacheCreateInfoEXT = + 'False -- ' closing tick for hsc2hs + type StructExtends VkShaderModuleValidationCacheCreateInfoEXT = + '[VkShaderModuleCreateInfo] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkShaderModuleValidationCacheCreateInfoEXT where + type VkSTypeMType VkShaderModuleValidationCacheCreateInfoEXT = + VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkShaderModuleValidationCacheCreateInfoEXT, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkShaderModuleValidationCacheCreateInfoEXT, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkShaderModuleValidationCacheCreateInfoEXT, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkShaderModuleValidationCacheCreateInfoEXT, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkShaderModuleValidationCacheCreateInfoEXT where + type FieldType "sType" VkShaderModuleValidationCacheCreateInfoEXT = + VkStructureType + type FieldOptional "sType" + VkShaderModuleValidationCacheCreateInfoEXT + = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkShaderModuleValidationCacheCreateInfoEXT + = + #{offset VkShaderModuleValidationCacheCreateInfoEXT, sType} + type FieldIsArray "sType" + VkShaderModuleValidationCacheCreateInfoEXT + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkShaderModuleValidationCacheCreateInfoEXT, sType} + +instance CanReadField "sType" + VkShaderModuleValidationCacheCreateInfoEXT + where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" + VkShaderModuleValidationCacheCreateInfoEXT + where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkShaderModuleValidationCacheCreateInfoEXT where + type VkPNextMType VkShaderModuleValidationCacheCreateInfoEXT = + Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkShaderModuleValidationCacheCreateInfoEXT, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkShaderModuleValidationCacheCreateInfoEXT, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkShaderModuleValidationCacheCreateInfoEXT, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkShaderModuleValidationCacheCreateInfoEXT, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkShaderModuleValidationCacheCreateInfoEXT where + type FieldType "pNext" VkShaderModuleValidationCacheCreateInfoEXT = + Ptr Void + type FieldOptional "pNext" + VkShaderModuleValidationCacheCreateInfoEXT + = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkShaderModuleValidationCacheCreateInfoEXT + = + #{offset VkShaderModuleValidationCacheCreateInfoEXT, pNext} + type FieldIsArray "pNext" + VkShaderModuleValidationCacheCreateInfoEXT + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkShaderModuleValidationCacheCreateInfoEXT, pNext} + +instance CanReadField "pNext" + VkShaderModuleValidationCacheCreateInfoEXT + where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" + VkShaderModuleValidationCacheCreateInfoEXT + where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkValidationCache VkShaderModuleValidationCacheCreateInfoEXT + where + type VkValidationCacheMType + VkShaderModuleValidationCacheCreateInfoEXT + = VkValidationCacheEXT + + {-# NOINLINE vkValidationCache #-} + vkValidationCache x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkShaderModuleValidationCacheCreateInfoEXT, validationCache}) + + {-# INLINE vkValidationCacheByteOffset #-} + vkValidationCacheByteOffset ~_ + = #{offset VkShaderModuleValidationCacheCreateInfoEXT, validationCache} + + {-# INLINE readVkValidationCache #-} + readVkValidationCache p + = peekByteOff p #{offset VkShaderModuleValidationCacheCreateInfoEXT, validationCache} + + {-# INLINE writeVkValidationCache #-} + writeVkValidationCache p + = pokeByteOff p #{offset VkShaderModuleValidationCacheCreateInfoEXT, validationCache} + +instance {-# OVERLAPPING #-} + HasField "validationCache" + VkShaderModuleValidationCacheCreateInfoEXT + where + type FieldType "validationCache" + VkShaderModuleValidationCacheCreateInfoEXT + = VkValidationCacheEXT + type FieldOptional "validationCache" + VkShaderModuleValidationCacheCreateInfoEXT + = 'False -- ' closing tick for hsc2hs + type FieldOffset "validationCache" + VkShaderModuleValidationCacheCreateInfoEXT + = + #{offset VkShaderModuleValidationCacheCreateInfoEXT, validationCache} + type FieldIsArray "validationCache" + VkShaderModuleValidationCacheCreateInfoEXT + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkShaderModuleValidationCacheCreateInfoEXT, validationCache} + +instance CanReadField "validationCache" + VkShaderModuleValidationCacheCreateInfoEXT + where + {-# INLINE getField #-} + getField = vkValidationCache + + {-# INLINE readField #-} + readField = readVkValidationCache + +instance CanWriteField "validationCache" + VkShaderModuleValidationCacheCreateInfoEXT + where + {-# INLINE writeField #-} + writeField = writeVkValidationCache + +instance Show VkShaderModuleValidationCacheCreateInfoEXT where + showsPrec d x + = showString "VkShaderModuleValidationCacheCreateInfoEXT {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkValidationCache = " . + showsPrec d (vkValidationCache x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkShaderResourceUsageAMD.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkShaderResourceUsageAMD.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkShaderResourceUsageAMD.hsc @@ -0,0 +1,330 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkShaderResourceUsageAMD + (VkShaderResourceUsageAMD(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkShaderResourceUsageAMD { +-- > uint32_t numUsedVgprs; +-- > uint32_t numUsedSgprs; +-- > uint32_t ldsSizePerLocalWorkGroup; +-- > size_t ldsUsageSizeInBytes; +-- > size_t scratchMemUsageInBytes; +-- > } VkShaderResourceUsageAMD; +-- +-- +data VkShaderResourceUsageAMD = VkShaderResourceUsageAMD## Addr## + ByteArray## + +instance Eq VkShaderResourceUsageAMD where + (VkShaderResourceUsageAMD## a _) == + x@(VkShaderResourceUsageAMD## b _) = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkShaderResourceUsageAMD where + (VkShaderResourceUsageAMD## a _) `compare` + x@(VkShaderResourceUsageAMD## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkShaderResourceUsageAMD where + sizeOf ~_ = #{size VkShaderResourceUsageAMD} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkShaderResourceUsageAMD} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkShaderResourceUsageAMD where + unsafeAddr (VkShaderResourceUsageAMD## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkShaderResourceUsageAMD## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkShaderResourceUsageAMD## (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkShaderResourceUsageAMD where + type StructFields VkShaderResourceUsageAMD = + '["numUsedVgprs", "numUsedSgprs", "ldsSizePerLocalWorkGroup", -- ' closing tick for hsc2hs + "ldsUsageSizeInBytes", "scratchMemUsageInBytes"] + type CUnionType VkShaderResourceUsageAMD = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkShaderResourceUsageAMD = 'True -- ' closing tick for hsc2hs + type StructExtends VkShaderResourceUsageAMD = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkNumUsedVgprs VkShaderResourceUsageAMD where + type VkNumUsedVgprsMType VkShaderResourceUsageAMD = Word32 + + {-# NOINLINE vkNumUsedVgprs #-} + vkNumUsedVgprs x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkShaderResourceUsageAMD, numUsedVgprs}) + + {-# INLINE vkNumUsedVgprsByteOffset #-} + vkNumUsedVgprsByteOffset ~_ + = #{offset VkShaderResourceUsageAMD, numUsedVgprs} + + {-# INLINE readVkNumUsedVgprs #-} + readVkNumUsedVgprs p + = peekByteOff p #{offset VkShaderResourceUsageAMD, numUsedVgprs} + + {-# INLINE writeVkNumUsedVgprs #-} + writeVkNumUsedVgprs p + = pokeByteOff p #{offset VkShaderResourceUsageAMD, numUsedVgprs} + +instance {-# OVERLAPPING #-} + HasField "numUsedVgprs" VkShaderResourceUsageAMD where + type FieldType "numUsedVgprs" VkShaderResourceUsageAMD = Word32 + type FieldOptional "numUsedVgprs" VkShaderResourceUsageAMD = 'False -- ' closing tick for hsc2hs + type FieldOffset "numUsedVgprs" VkShaderResourceUsageAMD = + #{offset VkShaderResourceUsageAMD, numUsedVgprs} + type FieldIsArray "numUsedVgprs" VkShaderResourceUsageAMD = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkShaderResourceUsageAMD, numUsedVgprs} + +instance CanReadField "numUsedVgprs" VkShaderResourceUsageAMD where + {-# INLINE getField #-} + getField = vkNumUsedVgprs + + {-# INLINE readField #-} + readField = readVkNumUsedVgprs + +instance {-# OVERLAPPING #-} + HasVkNumUsedSgprs VkShaderResourceUsageAMD where + type VkNumUsedSgprsMType VkShaderResourceUsageAMD = Word32 + + {-# NOINLINE vkNumUsedSgprs #-} + vkNumUsedSgprs x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkShaderResourceUsageAMD, numUsedSgprs}) + + {-# INLINE vkNumUsedSgprsByteOffset #-} + vkNumUsedSgprsByteOffset ~_ + = #{offset VkShaderResourceUsageAMD, numUsedSgprs} + + {-# INLINE readVkNumUsedSgprs #-} + readVkNumUsedSgprs p + = peekByteOff p #{offset VkShaderResourceUsageAMD, numUsedSgprs} + + {-# INLINE writeVkNumUsedSgprs #-} + writeVkNumUsedSgprs p + = pokeByteOff p #{offset VkShaderResourceUsageAMD, numUsedSgprs} + +instance {-# OVERLAPPING #-} + HasField "numUsedSgprs" VkShaderResourceUsageAMD where + type FieldType "numUsedSgprs" VkShaderResourceUsageAMD = Word32 + type FieldOptional "numUsedSgprs" VkShaderResourceUsageAMD = 'False -- ' closing tick for hsc2hs + type FieldOffset "numUsedSgprs" VkShaderResourceUsageAMD = + #{offset VkShaderResourceUsageAMD, numUsedSgprs} + type FieldIsArray "numUsedSgprs" VkShaderResourceUsageAMD = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkShaderResourceUsageAMD, numUsedSgprs} + +instance CanReadField "numUsedSgprs" VkShaderResourceUsageAMD where + {-# INLINE getField #-} + getField = vkNumUsedSgprs + + {-# INLINE readField #-} + readField = readVkNumUsedSgprs + +instance {-# OVERLAPPING #-} + HasVkLdsSizePerLocalWorkGroup VkShaderResourceUsageAMD where + type VkLdsSizePerLocalWorkGroupMType VkShaderResourceUsageAMD = + Word32 + + {-# NOINLINE vkLdsSizePerLocalWorkGroup #-} + vkLdsSizePerLocalWorkGroup x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkShaderResourceUsageAMD, ldsSizePerLocalWorkGroup}) + + {-# INLINE vkLdsSizePerLocalWorkGroupByteOffset #-} + vkLdsSizePerLocalWorkGroupByteOffset ~_ + = #{offset VkShaderResourceUsageAMD, ldsSizePerLocalWorkGroup} + + {-# INLINE readVkLdsSizePerLocalWorkGroup #-} + readVkLdsSizePerLocalWorkGroup p + = peekByteOff p #{offset VkShaderResourceUsageAMD, ldsSizePerLocalWorkGroup} + + {-# INLINE writeVkLdsSizePerLocalWorkGroup #-} + writeVkLdsSizePerLocalWorkGroup p + = pokeByteOff p #{offset VkShaderResourceUsageAMD, ldsSizePerLocalWorkGroup} + +instance {-# OVERLAPPING #-} + HasField "ldsSizePerLocalWorkGroup" VkShaderResourceUsageAMD where + type FieldType "ldsSizePerLocalWorkGroup" VkShaderResourceUsageAMD + = Word32 + type FieldOptional "ldsSizePerLocalWorkGroup" + VkShaderResourceUsageAMD + = 'False -- ' closing tick for hsc2hs + type FieldOffset "ldsSizePerLocalWorkGroup" + VkShaderResourceUsageAMD + = + #{offset VkShaderResourceUsageAMD, ldsSizePerLocalWorkGroup} + type FieldIsArray "ldsSizePerLocalWorkGroup" + VkShaderResourceUsageAMD + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkShaderResourceUsageAMD, ldsSizePerLocalWorkGroup} + +instance CanReadField "ldsSizePerLocalWorkGroup" + VkShaderResourceUsageAMD + where + {-# INLINE getField #-} + getField = vkLdsSizePerLocalWorkGroup + + {-# INLINE readField #-} + readField = readVkLdsSizePerLocalWorkGroup + +instance {-# OVERLAPPING #-} + HasVkLdsUsageSizeInBytes VkShaderResourceUsageAMD where + type VkLdsUsageSizeInBytesMType VkShaderResourceUsageAMD = CSize + + {-# NOINLINE vkLdsUsageSizeInBytes #-} + vkLdsUsageSizeInBytes x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkShaderResourceUsageAMD, ldsUsageSizeInBytes}) + + {-# INLINE vkLdsUsageSizeInBytesByteOffset #-} + vkLdsUsageSizeInBytesByteOffset ~_ + = #{offset VkShaderResourceUsageAMD, ldsUsageSizeInBytes} + + {-# INLINE readVkLdsUsageSizeInBytes #-} + readVkLdsUsageSizeInBytes p + = peekByteOff p #{offset VkShaderResourceUsageAMD, ldsUsageSizeInBytes} + + {-# INLINE writeVkLdsUsageSizeInBytes #-} + writeVkLdsUsageSizeInBytes p + = pokeByteOff p #{offset VkShaderResourceUsageAMD, ldsUsageSizeInBytes} + +instance {-# OVERLAPPING #-} + HasField "ldsUsageSizeInBytes" VkShaderResourceUsageAMD where + type FieldType "ldsUsageSizeInBytes" VkShaderResourceUsageAMD = + CSize + type FieldOptional "ldsUsageSizeInBytes" VkShaderResourceUsageAMD = + 'False -- ' closing tick for hsc2hs + type FieldOffset "ldsUsageSizeInBytes" VkShaderResourceUsageAMD = + #{offset VkShaderResourceUsageAMD, ldsUsageSizeInBytes} + type FieldIsArray "ldsUsageSizeInBytes" VkShaderResourceUsageAMD = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkShaderResourceUsageAMD, ldsUsageSizeInBytes} + +instance CanReadField "ldsUsageSizeInBytes" + VkShaderResourceUsageAMD + where + {-# INLINE getField #-} + getField = vkLdsUsageSizeInBytes + + {-# INLINE readField #-} + readField = readVkLdsUsageSizeInBytes + +instance {-# OVERLAPPING #-} + HasVkScratchMemUsageInBytes VkShaderResourceUsageAMD where + type VkScratchMemUsageInBytesMType VkShaderResourceUsageAMD = CSize + + {-# NOINLINE vkScratchMemUsageInBytes #-} + vkScratchMemUsageInBytes x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkShaderResourceUsageAMD, scratchMemUsageInBytes}) + + {-# INLINE vkScratchMemUsageInBytesByteOffset #-} + vkScratchMemUsageInBytesByteOffset ~_ + = #{offset VkShaderResourceUsageAMD, scratchMemUsageInBytes} + + {-# INLINE readVkScratchMemUsageInBytes #-} + readVkScratchMemUsageInBytes p + = peekByteOff p #{offset VkShaderResourceUsageAMD, scratchMemUsageInBytes} + + {-# INLINE writeVkScratchMemUsageInBytes #-} + writeVkScratchMemUsageInBytes p + = pokeByteOff p #{offset VkShaderResourceUsageAMD, scratchMemUsageInBytes} + +instance {-# OVERLAPPING #-} + HasField "scratchMemUsageInBytes" VkShaderResourceUsageAMD where + type FieldType "scratchMemUsageInBytes" VkShaderResourceUsageAMD = + CSize + type FieldOptional "scratchMemUsageInBytes" + VkShaderResourceUsageAMD + = 'False -- ' closing tick for hsc2hs + type FieldOffset "scratchMemUsageInBytes" VkShaderResourceUsageAMD + = + #{offset VkShaderResourceUsageAMD, scratchMemUsageInBytes} + type FieldIsArray "scratchMemUsageInBytes" VkShaderResourceUsageAMD + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkShaderResourceUsageAMD, scratchMemUsageInBytes} + +instance CanReadField "scratchMemUsageInBytes" + VkShaderResourceUsageAMD + where + {-# INLINE getField #-} + getField = vkScratchMemUsageInBytes + + {-# INLINE readField #-} + readField = readVkScratchMemUsageInBytes + +instance Show VkShaderResourceUsageAMD where + showsPrec d x + = showString "VkShaderResourceUsageAMD {" . + showString "vkNumUsedVgprs = " . + showsPrec d (vkNumUsedVgprs x) . + showString ", " . + showString "vkNumUsedSgprs = " . + showsPrec d (vkNumUsedSgprs x) . + showString ", " . + showString "vkLdsSizePerLocalWorkGroup = " . + showsPrec d (vkLdsSizePerLocalWorkGroup x) . + showString ", " . + showString "vkLdsUsageSizeInBytes = " . + showsPrec d (vkLdsUsageSizeInBytes x) . + showString ", " . + showString "vkScratchMemUsageInBytes = " . + showsPrec d (vkScratchMemUsageInBytes x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkShaderStatisticsInfoAMD.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkShaderStatisticsInfoAMD.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkShaderStatisticsInfoAMD.hsc @@ -0,0 +1,479 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleContexts #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE ScopedTypeVariables #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +{-# LANGUAGE UndecidableInstances #-} +module Graphics.Vulkan.Types.Struct.VkShaderStatisticsInfoAMD + (VkShaderStatisticsInfoAMD(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import GHC.TypeLits (KnownNat, + natVal') -- ' closing tick for hsc2hs +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkShaderStageFlags (VkShaderStageFlags) +import Graphics.Vulkan.Types.Struct.VkShaderResourceUsageAMD (VkShaderResourceUsageAMD) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkShaderStatisticsInfoAMD { +-- > VkShaderStageFlags shaderStageMask; +-- > VkShaderResourceUsageAMD resourceUsage; +-- > uint32_t numPhysicalVgprs; +-- > uint32_t numPhysicalSgprs; +-- > uint32_t numAvailableVgprs; +-- > uint32_t numAvailableSgprs; +-- > uint32_t computeWorkGroupSize[3]; +-- > } VkShaderStatisticsInfoAMD; +-- +-- +data VkShaderStatisticsInfoAMD = VkShaderStatisticsInfoAMD## Addr## + ByteArray## + +instance Eq VkShaderStatisticsInfoAMD where + (VkShaderStatisticsInfoAMD## a _) == + x@(VkShaderStatisticsInfoAMD## b _) = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkShaderStatisticsInfoAMD where + (VkShaderStatisticsInfoAMD## a _) `compare` + x@(VkShaderStatisticsInfoAMD## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkShaderStatisticsInfoAMD where + sizeOf ~_ = #{size VkShaderStatisticsInfoAMD} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkShaderStatisticsInfoAMD} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkShaderStatisticsInfoAMD where + unsafeAddr (VkShaderStatisticsInfoAMD## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkShaderStatisticsInfoAMD## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkShaderStatisticsInfoAMD## (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkShaderStatisticsInfoAMD where + type StructFields VkShaderStatisticsInfoAMD = + '["shaderStageMask", "resourceUsage", "numPhysicalVgprs", -- ' closing tick for hsc2hs + "numPhysicalSgprs", "numAvailableVgprs", "numAvailableSgprs", + "computeWorkGroupSize"] + type CUnionType VkShaderStatisticsInfoAMD = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkShaderStatisticsInfoAMD = 'True -- ' closing tick for hsc2hs + type StructExtends VkShaderStatisticsInfoAMD = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkShaderStageMask VkShaderStatisticsInfoAMD where + type VkShaderStageMaskMType VkShaderStatisticsInfoAMD = + VkShaderStageFlags + + {-# NOINLINE vkShaderStageMask #-} + vkShaderStageMask x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkShaderStatisticsInfoAMD, shaderStageMask}) + + {-# INLINE vkShaderStageMaskByteOffset #-} + vkShaderStageMaskByteOffset ~_ + = #{offset VkShaderStatisticsInfoAMD, shaderStageMask} + + {-# INLINE readVkShaderStageMask #-} + readVkShaderStageMask p + = peekByteOff p #{offset VkShaderStatisticsInfoAMD, shaderStageMask} + + {-# INLINE writeVkShaderStageMask #-} + writeVkShaderStageMask p + = pokeByteOff p #{offset VkShaderStatisticsInfoAMD, shaderStageMask} + +instance {-# OVERLAPPING #-} + HasField "shaderStageMask" VkShaderStatisticsInfoAMD where + type FieldType "shaderStageMask" VkShaderStatisticsInfoAMD = + VkShaderStageFlags + type FieldOptional "shaderStageMask" VkShaderStatisticsInfoAMD = + 'False -- ' closing tick for hsc2hs + type FieldOffset "shaderStageMask" VkShaderStatisticsInfoAMD = + #{offset VkShaderStatisticsInfoAMD, shaderStageMask} + type FieldIsArray "shaderStageMask" VkShaderStatisticsInfoAMD = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkShaderStatisticsInfoAMD, shaderStageMask} + +instance CanReadField "shaderStageMask" VkShaderStatisticsInfoAMD + where + {-# INLINE getField #-} + getField = vkShaderStageMask + + {-# INLINE readField #-} + readField = readVkShaderStageMask + +instance {-# OVERLAPPING #-} + HasVkResourceUsage VkShaderStatisticsInfoAMD where + type VkResourceUsageMType VkShaderStatisticsInfoAMD = + VkShaderResourceUsageAMD + + {-# NOINLINE vkResourceUsage #-} + vkResourceUsage x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkShaderStatisticsInfoAMD, resourceUsage}) + + {-# INLINE vkResourceUsageByteOffset #-} + vkResourceUsageByteOffset ~_ + = #{offset VkShaderStatisticsInfoAMD, resourceUsage} + + {-# INLINE readVkResourceUsage #-} + readVkResourceUsage p + = peekByteOff p #{offset VkShaderStatisticsInfoAMD, resourceUsage} + + {-# INLINE writeVkResourceUsage #-} + writeVkResourceUsage p + = pokeByteOff p #{offset VkShaderStatisticsInfoAMD, resourceUsage} + +instance {-# OVERLAPPING #-} + HasField "resourceUsage" VkShaderStatisticsInfoAMD where + type FieldType "resourceUsage" VkShaderStatisticsInfoAMD = + VkShaderResourceUsageAMD + type FieldOptional "resourceUsage" VkShaderStatisticsInfoAMD = + 'False -- ' closing tick for hsc2hs + type FieldOffset "resourceUsage" VkShaderStatisticsInfoAMD = + #{offset VkShaderStatisticsInfoAMD, resourceUsage} + type FieldIsArray "resourceUsage" VkShaderStatisticsInfoAMD = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkShaderStatisticsInfoAMD, resourceUsage} + +instance CanReadField "resourceUsage" VkShaderStatisticsInfoAMD + where + {-# INLINE getField #-} + getField = vkResourceUsage + + {-# INLINE readField #-} + readField = readVkResourceUsage + +instance {-# OVERLAPPING #-} + HasVkNumPhysicalVgprs VkShaderStatisticsInfoAMD where + type VkNumPhysicalVgprsMType VkShaderStatisticsInfoAMD = Word32 + + {-# NOINLINE vkNumPhysicalVgprs #-} + vkNumPhysicalVgprs x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkShaderStatisticsInfoAMD, numPhysicalVgprs}) + + {-# INLINE vkNumPhysicalVgprsByteOffset #-} + vkNumPhysicalVgprsByteOffset ~_ + = #{offset VkShaderStatisticsInfoAMD, numPhysicalVgprs} + + {-# INLINE readVkNumPhysicalVgprs #-} + readVkNumPhysicalVgprs p + = peekByteOff p #{offset VkShaderStatisticsInfoAMD, numPhysicalVgprs} + + {-# INLINE writeVkNumPhysicalVgprs #-} + writeVkNumPhysicalVgprs p + = pokeByteOff p #{offset VkShaderStatisticsInfoAMD, numPhysicalVgprs} + +instance {-# OVERLAPPING #-} + HasField "numPhysicalVgprs" VkShaderStatisticsInfoAMD where + type FieldType "numPhysicalVgprs" VkShaderStatisticsInfoAMD = + Word32 + type FieldOptional "numPhysicalVgprs" VkShaderStatisticsInfoAMD = + 'False -- ' closing tick for hsc2hs + type FieldOffset "numPhysicalVgprs" VkShaderStatisticsInfoAMD = + #{offset VkShaderStatisticsInfoAMD, numPhysicalVgprs} + type FieldIsArray "numPhysicalVgprs" VkShaderStatisticsInfoAMD = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkShaderStatisticsInfoAMD, numPhysicalVgprs} + +instance CanReadField "numPhysicalVgprs" VkShaderStatisticsInfoAMD + where + {-# INLINE getField #-} + getField = vkNumPhysicalVgprs + + {-# INLINE readField #-} + readField = readVkNumPhysicalVgprs + +instance {-# OVERLAPPING #-} + HasVkNumPhysicalSgprs VkShaderStatisticsInfoAMD where + type VkNumPhysicalSgprsMType VkShaderStatisticsInfoAMD = Word32 + + {-# NOINLINE vkNumPhysicalSgprs #-} + vkNumPhysicalSgprs x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkShaderStatisticsInfoAMD, numPhysicalSgprs}) + + {-# INLINE vkNumPhysicalSgprsByteOffset #-} + vkNumPhysicalSgprsByteOffset ~_ + = #{offset VkShaderStatisticsInfoAMD, numPhysicalSgprs} + + {-# INLINE readVkNumPhysicalSgprs #-} + readVkNumPhysicalSgprs p + = peekByteOff p #{offset VkShaderStatisticsInfoAMD, numPhysicalSgprs} + + {-# INLINE writeVkNumPhysicalSgprs #-} + writeVkNumPhysicalSgprs p + = pokeByteOff p #{offset VkShaderStatisticsInfoAMD, numPhysicalSgprs} + +instance {-# OVERLAPPING #-} + HasField "numPhysicalSgprs" VkShaderStatisticsInfoAMD where + type FieldType "numPhysicalSgprs" VkShaderStatisticsInfoAMD = + Word32 + type FieldOptional "numPhysicalSgprs" VkShaderStatisticsInfoAMD = + 'False -- ' closing tick for hsc2hs + type FieldOffset "numPhysicalSgprs" VkShaderStatisticsInfoAMD = + #{offset VkShaderStatisticsInfoAMD, numPhysicalSgprs} + type FieldIsArray "numPhysicalSgprs" VkShaderStatisticsInfoAMD = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkShaderStatisticsInfoAMD, numPhysicalSgprs} + +instance CanReadField "numPhysicalSgprs" VkShaderStatisticsInfoAMD + where + {-# INLINE getField #-} + getField = vkNumPhysicalSgprs + + {-# INLINE readField #-} + readField = readVkNumPhysicalSgprs + +instance {-# OVERLAPPING #-} + HasVkNumAvailableVgprs VkShaderStatisticsInfoAMD where + type VkNumAvailableVgprsMType VkShaderStatisticsInfoAMD = Word32 + + {-# NOINLINE vkNumAvailableVgprs #-} + vkNumAvailableVgprs x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkShaderStatisticsInfoAMD, numAvailableVgprs}) + + {-# INLINE vkNumAvailableVgprsByteOffset #-} + vkNumAvailableVgprsByteOffset ~_ + = #{offset VkShaderStatisticsInfoAMD, numAvailableVgprs} + + {-# INLINE readVkNumAvailableVgprs #-} + readVkNumAvailableVgprs p + = peekByteOff p #{offset VkShaderStatisticsInfoAMD, numAvailableVgprs} + + {-# INLINE writeVkNumAvailableVgprs #-} + writeVkNumAvailableVgprs p + = pokeByteOff p #{offset VkShaderStatisticsInfoAMD, numAvailableVgprs} + +instance {-# OVERLAPPING #-} + HasField "numAvailableVgprs" VkShaderStatisticsInfoAMD where + type FieldType "numAvailableVgprs" VkShaderStatisticsInfoAMD = + Word32 + type FieldOptional "numAvailableVgprs" VkShaderStatisticsInfoAMD = + 'False -- ' closing tick for hsc2hs + type FieldOffset "numAvailableVgprs" VkShaderStatisticsInfoAMD = + #{offset VkShaderStatisticsInfoAMD, numAvailableVgprs} + type FieldIsArray "numAvailableVgprs" VkShaderStatisticsInfoAMD = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkShaderStatisticsInfoAMD, numAvailableVgprs} + +instance CanReadField "numAvailableVgprs" VkShaderStatisticsInfoAMD + where + {-# INLINE getField #-} + getField = vkNumAvailableVgprs + + {-# INLINE readField #-} + readField = readVkNumAvailableVgprs + +instance {-# OVERLAPPING #-} + HasVkNumAvailableSgprs VkShaderStatisticsInfoAMD where + type VkNumAvailableSgprsMType VkShaderStatisticsInfoAMD = Word32 + + {-# NOINLINE vkNumAvailableSgprs #-} + vkNumAvailableSgprs x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkShaderStatisticsInfoAMD, numAvailableSgprs}) + + {-# INLINE vkNumAvailableSgprsByteOffset #-} + vkNumAvailableSgprsByteOffset ~_ + = #{offset VkShaderStatisticsInfoAMD, numAvailableSgprs} + + {-# INLINE readVkNumAvailableSgprs #-} + readVkNumAvailableSgprs p + = peekByteOff p #{offset VkShaderStatisticsInfoAMD, numAvailableSgprs} + + {-# INLINE writeVkNumAvailableSgprs #-} + writeVkNumAvailableSgprs p + = pokeByteOff p #{offset VkShaderStatisticsInfoAMD, numAvailableSgprs} + +instance {-# OVERLAPPING #-} + HasField "numAvailableSgprs" VkShaderStatisticsInfoAMD where + type FieldType "numAvailableSgprs" VkShaderStatisticsInfoAMD = + Word32 + type FieldOptional "numAvailableSgprs" VkShaderStatisticsInfoAMD = + 'False -- ' closing tick for hsc2hs + type FieldOffset "numAvailableSgprs" VkShaderStatisticsInfoAMD = + #{offset VkShaderStatisticsInfoAMD, numAvailableSgprs} + type FieldIsArray "numAvailableSgprs" VkShaderStatisticsInfoAMD = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkShaderStatisticsInfoAMD, numAvailableSgprs} + +instance CanReadField "numAvailableSgprs" VkShaderStatisticsInfoAMD + where + {-# INLINE getField #-} + getField = vkNumAvailableSgprs + + {-# INLINE readField #-} + readField = readVkNumAvailableSgprs + +instance {-# OVERLAPPING #-} + HasVkComputeWorkGroupSizeArray VkShaderStatisticsInfoAMD where + type VkComputeWorkGroupSizeArrayMType VkShaderStatisticsInfoAMD = + Word32 + + {-# NOINLINE vkComputeWorkGroupSizeArray #-} + vkComputeWorkGroupSizeArray x idx + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) + (idx * sizeOf (undefined :: Word32) + + #{offset VkShaderStatisticsInfoAMD, computeWorkGroupSize})) + + {-# INLINE vkComputeWorkGroupSizeArrayByteOffset #-} + vkComputeWorkGroupSizeArrayByteOffset ~_ + = #{offset VkShaderStatisticsInfoAMD, computeWorkGroupSize} + + {-# INLINE readVkComputeWorkGroupSizeArray #-} + readVkComputeWorkGroupSizeArray p idx + = peekByteOff p + (idx * sizeOf (undefined :: Word32) + + #{offset VkShaderStatisticsInfoAMD, computeWorkGroupSize}) + + {-# INLINE writeVkComputeWorkGroupSizeArray #-} + writeVkComputeWorkGroupSizeArray p idx + = pokeByteOff p + (idx * sizeOf (undefined :: Word32) + + #{offset VkShaderStatisticsInfoAMD, computeWorkGroupSize}) + +instance {-# OVERLAPPING #-} + HasField "computeWorkGroupSize" VkShaderStatisticsInfoAMD where + type FieldType "computeWorkGroupSize" VkShaderStatisticsInfoAMD = + Word32 + type FieldOptional "computeWorkGroupSize" VkShaderStatisticsInfoAMD + = 'False -- ' closing tick for hsc2hs + type FieldOffset "computeWorkGroupSize" VkShaderStatisticsInfoAMD = + #{offset VkShaderStatisticsInfoAMD, computeWorkGroupSize} + type FieldIsArray "computeWorkGroupSize" VkShaderStatisticsInfoAMD + = 'True -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkShaderStatisticsInfoAMD, computeWorkGroupSize} + +instance (KnownNat idx, + IndexInBounds "computeWorkGroupSize" idx + VkShaderStatisticsInfoAMD) => + CanReadFieldArray "computeWorkGroupSize" idx + VkShaderStatisticsInfoAMD + where + {-# SPECIALISE instance + CanReadFieldArray "computeWorkGroupSize" 0 + VkShaderStatisticsInfoAMD + #-} + + {-# SPECIALISE instance + CanReadFieldArray "computeWorkGroupSize" 1 + VkShaderStatisticsInfoAMD + #-} + + {-# SPECIALISE instance + CanReadFieldArray "computeWorkGroupSize" 2 + VkShaderStatisticsInfoAMD + #-} + type FieldArrayLength "computeWorkGroupSize" + VkShaderStatisticsInfoAMD + = 3 + + {-# INLINE fieldArrayLength #-} + fieldArrayLength = 3 + + {-# INLINE getFieldArray #-} + getFieldArray x + = vkComputeWorkGroupSizeArray x + (fromInteger $ natVal' (proxy## :: Proxy## idx)) -- ' closing tick for hsc2hs + + {-# INLINE readFieldArray #-} + readFieldArray x + = readVkComputeWorkGroupSizeArray x + (fromInteger $ natVal' (proxy## :: Proxy## idx)) -- ' closing tick for hsc2hs + +instance Show VkShaderStatisticsInfoAMD where + showsPrec d x + = showString "VkShaderStatisticsInfoAMD {" . + showString "vkShaderStageMask = " . + showsPrec d (vkShaderStageMask x) . + showString ", " . + showString "vkResourceUsage = " . + showsPrec d (vkResourceUsage x) . + showString ", " . + showString "vkNumPhysicalVgprs = " . + showsPrec d (vkNumPhysicalVgprs x) . + showString ", " . + showString "vkNumPhysicalSgprs = " . + showsPrec d (vkNumPhysicalSgprs x) . + showString ", " . + showString "vkNumAvailableVgprs = " . + showsPrec d (vkNumAvailableVgprs x) . + showString ", " . + showString "vkNumAvailableSgprs = " . + showsPrec d (vkNumAvailableSgprs x) . + showString ", " . + showString "vkComputeWorkGroupSizeArray = [" . + showsPrec d + (map (vkComputeWorkGroupSizeArray x) [1 .. 3]) + . showChar ']' . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkSharedPresentSurfaceCapabilitiesKHR.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkSharedPresentSurfaceCapabilitiesKHR.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkSharedPresentSurfaceCapabilitiesKHR.hsc @@ -0,0 +1,248 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkSharedPresentSurfaceCapabilitiesKHR + (VkSharedPresentSurfaceCapabilitiesKHR(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkImageUsageFlags (VkImageUsageFlags) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Struct.VkSurfaceCapabilities2KHR (VkSurfaceCapabilities2KHR) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkSharedPresentSurfaceCapabilitiesKHR { +-- > VkStructureType sType; +-- > void* pNext; +-- > VkImageUsageFlags sharedPresentSupportedUsageFlags; +-- > } VkSharedPresentSurfaceCapabilitiesKHR; +-- +-- +data VkSharedPresentSurfaceCapabilitiesKHR = VkSharedPresentSurfaceCapabilitiesKHR## Addr## + ByteArray## + +instance Eq VkSharedPresentSurfaceCapabilitiesKHR where + (VkSharedPresentSurfaceCapabilitiesKHR## a _) == + x@(VkSharedPresentSurfaceCapabilitiesKHR## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkSharedPresentSurfaceCapabilitiesKHR where + (VkSharedPresentSurfaceCapabilitiesKHR## a _) `compare` + x@(VkSharedPresentSurfaceCapabilitiesKHR## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkSharedPresentSurfaceCapabilitiesKHR where + sizeOf ~_ + = #{size VkSharedPresentSurfaceCapabilitiesKHR} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkSharedPresentSurfaceCapabilitiesKHR} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkSharedPresentSurfaceCapabilitiesKHR + where + unsafeAddr (VkSharedPresentSurfaceCapabilitiesKHR## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkSharedPresentSurfaceCapabilitiesKHR## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkSharedPresentSurfaceCapabilitiesKHR## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkSharedPresentSurfaceCapabilitiesKHR where + type StructFields VkSharedPresentSurfaceCapabilitiesKHR = + '["sType", "pNext", "sharedPresentSupportedUsageFlags"] -- ' closing tick for hsc2hs + type CUnionType VkSharedPresentSurfaceCapabilitiesKHR = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkSharedPresentSurfaceCapabilitiesKHR = 'True -- ' closing tick for hsc2hs + type StructExtends VkSharedPresentSurfaceCapabilitiesKHR = + '[VkSurfaceCapabilities2KHR] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkSharedPresentSurfaceCapabilitiesKHR where + type VkSTypeMType VkSharedPresentSurfaceCapabilitiesKHR = + VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSharedPresentSurfaceCapabilitiesKHR, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkSharedPresentSurfaceCapabilitiesKHR, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkSharedPresentSurfaceCapabilitiesKHR, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkSharedPresentSurfaceCapabilitiesKHR, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkSharedPresentSurfaceCapabilitiesKHR where + type FieldType "sType" VkSharedPresentSurfaceCapabilitiesKHR = + VkStructureType + type FieldOptional "sType" VkSharedPresentSurfaceCapabilitiesKHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkSharedPresentSurfaceCapabilitiesKHR = + #{offset VkSharedPresentSurfaceCapabilitiesKHR, sType} + type FieldIsArray "sType" VkSharedPresentSurfaceCapabilitiesKHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSharedPresentSurfaceCapabilitiesKHR, sType} + +instance CanReadField "sType" VkSharedPresentSurfaceCapabilitiesKHR + where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkSharedPresentSurfaceCapabilitiesKHR where + type VkPNextMType VkSharedPresentSurfaceCapabilitiesKHR = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSharedPresentSurfaceCapabilitiesKHR, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkSharedPresentSurfaceCapabilitiesKHR, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkSharedPresentSurfaceCapabilitiesKHR, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkSharedPresentSurfaceCapabilitiesKHR, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkSharedPresentSurfaceCapabilitiesKHR where + type FieldType "pNext" VkSharedPresentSurfaceCapabilitiesKHR = + Ptr Void + type FieldOptional "pNext" VkSharedPresentSurfaceCapabilitiesKHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkSharedPresentSurfaceCapabilitiesKHR = + #{offset VkSharedPresentSurfaceCapabilitiesKHR, pNext} + type FieldIsArray "pNext" VkSharedPresentSurfaceCapabilitiesKHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSharedPresentSurfaceCapabilitiesKHR, pNext} + +instance CanReadField "pNext" VkSharedPresentSurfaceCapabilitiesKHR + where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance {-# OVERLAPPING #-} + HasVkSharedPresentSupportedUsageFlags + VkSharedPresentSurfaceCapabilitiesKHR + where + type VkSharedPresentSupportedUsageFlagsMType + VkSharedPresentSurfaceCapabilitiesKHR + = VkImageUsageFlags + + {-# NOINLINE vkSharedPresentSupportedUsageFlags #-} + vkSharedPresentSupportedUsageFlags x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSharedPresentSurfaceCapabilitiesKHR, sharedPresentSupportedUsageFlags}) + + {-# INLINE vkSharedPresentSupportedUsageFlagsByteOffset #-} + vkSharedPresentSupportedUsageFlagsByteOffset ~_ + = #{offset VkSharedPresentSurfaceCapabilitiesKHR, sharedPresentSupportedUsageFlags} + + {-# INLINE readVkSharedPresentSupportedUsageFlags #-} + readVkSharedPresentSupportedUsageFlags p + = peekByteOff p #{offset VkSharedPresentSurfaceCapabilitiesKHR, sharedPresentSupportedUsageFlags} + + {-# INLINE writeVkSharedPresentSupportedUsageFlags #-} + writeVkSharedPresentSupportedUsageFlags p + = pokeByteOff p #{offset VkSharedPresentSurfaceCapabilitiesKHR, sharedPresentSupportedUsageFlags} + +instance {-# OVERLAPPING #-} + HasField "sharedPresentSupportedUsageFlags" + VkSharedPresentSurfaceCapabilitiesKHR + where + type FieldType "sharedPresentSupportedUsageFlags" + VkSharedPresentSurfaceCapabilitiesKHR + = VkImageUsageFlags + type FieldOptional "sharedPresentSupportedUsageFlags" + VkSharedPresentSurfaceCapabilitiesKHR + = 'True -- ' closing tick for hsc2hs + type FieldOffset "sharedPresentSupportedUsageFlags" + VkSharedPresentSurfaceCapabilitiesKHR + = + #{offset VkSharedPresentSurfaceCapabilitiesKHR, sharedPresentSupportedUsageFlags} + type FieldIsArray "sharedPresentSupportedUsageFlags" + VkSharedPresentSurfaceCapabilitiesKHR + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSharedPresentSurfaceCapabilitiesKHR, sharedPresentSupportedUsageFlags} + +instance CanReadField "sharedPresentSupportedUsageFlags" + VkSharedPresentSurfaceCapabilitiesKHR + where + {-# INLINE getField #-} + getField = vkSharedPresentSupportedUsageFlags + + {-# INLINE readField #-} + readField = readVkSharedPresentSupportedUsageFlags + +instance Show VkSharedPresentSurfaceCapabilitiesKHR where + showsPrec d x + = showString "VkSharedPresentSurfaceCapabilitiesKHR {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkSharedPresentSupportedUsageFlags = " . + showsPrec d (vkSharedPresentSupportedUsageFlags x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkSparseBufferMemoryBindInfo.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkSparseBufferMemoryBindInfo.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkSparseBufferMemoryBindInfo.hsc @@ -0,0 +1,234 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkSparseBufferMemoryBindInfo + (VkSparseBufferMemoryBindInfo(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Handles (VkBuffer) +import Graphics.Vulkan.Types.Struct.VkSparseMemoryBind (VkSparseMemoryBind) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkSparseBufferMemoryBindInfo { +-- > VkBuffer buffer; +-- > uint32_t bindCount; +-- > const VkSparseMemoryBind* pBinds; +-- > } VkSparseBufferMemoryBindInfo; +-- +-- +data VkSparseBufferMemoryBindInfo = VkSparseBufferMemoryBindInfo## Addr## + ByteArray## + +instance Eq VkSparseBufferMemoryBindInfo where + (VkSparseBufferMemoryBindInfo## a _) == + x@(VkSparseBufferMemoryBindInfo## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkSparseBufferMemoryBindInfo where + (VkSparseBufferMemoryBindInfo## a _) `compare` + x@(VkSparseBufferMemoryBindInfo## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkSparseBufferMemoryBindInfo where + sizeOf ~_ = #{size VkSparseBufferMemoryBindInfo} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkSparseBufferMemoryBindInfo} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkSparseBufferMemoryBindInfo where + unsafeAddr (VkSparseBufferMemoryBindInfo## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkSparseBufferMemoryBindInfo## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkSparseBufferMemoryBindInfo## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkSparseBufferMemoryBindInfo where + type StructFields VkSparseBufferMemoryBindInfo = + '["buffer", "bindCount", "pBinds"] -- ' closing tick for hsc2hs + type CUnionType VkSparseBufferMemoryBindInfo = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkSparseBufferMemoryBindInfo = 'False -- ' closing tick for hsc2hs + type StructExtends VkSparseBufferMemoryBindInfo = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkBuffer VkSparseBufferMemoryBindInfo where + type VkBufferMType VkSparseBufferMemoryBindInfo = VkBuffer + + {-# NOINLINE vkBuffer #-} + vkBuffer x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSparseBufferMemoryBindInfo, buffer}) + + {-# INLINE vkBufferByteOffset #-} + vkBufferByteOffset ~_ + = #{offset VkSparseBufferMemoryBindInfo, buffer} + + {-# INLINE readVkBuffer #-} + readVkBuffer p + = peekByteOff p #{offset VkSparseBufferMemoryBindInfo, buffer} + + {-# INLINE writeVkBuffer #-} + writeVkBuffer p + = pokeByteOff p #{offset VkSparseBufferMemoryBindInfo, buffer} + +instance {-# OVERLAPPING #-} + HasField "buffer" VkSparseBufferMemoryBindInfo where + type FieldType "buffer" VkSparseBufferMemoryBindInfo = VkBuffer + type FieldOptional "buffer" VkSparseBufferMemoryBindInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "buffer" VkSparseBufferMemoryBindInfo = + #{offset VkSparseBufferMemoryBindInfo, buffer} + type FieldIsArray "buffer" VkSparseBufferMemoryBindInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSparseBufferMemoryBindInfo, buffer} + +instance CanReadField "buffer" VkSparseBufferMemoryBindInfo where + {-# INLINE getField #-} + getField = vkBuffer + + {-# INLINE readField #-} + readField = readVkBuffer + +instance CanWriteField "buffer" VkSparseBufferMemoryBindInfo where + {-# INLINE writeField #-} + writeField = writeVkBuffer + +instance {-# OVERLAPPING #-} + HasVkBindCount VkSparseBufferMemoryBindInfo where + type VkBindCountMType VkSparseBufferMemoryBindInfo = Word32 + + {-# NOINLINE vkBindCount #-} + vkBindCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSparseBufferMemoryBindInfo, bindCount}) + + {-# INLINE vkBindCountByteOffset #-} + vkBindCountByteOffset ~_ + = #{offset VkSparseBufferMemoryBindInfo, bindCount} + + {-# INLINE readVkBindCount #-} + readVkBindCount p + = peekByteOff p #{offset VkSparseBufferMemoryBindInfo, bindCount} + + {-# INLINE writeVkBindCount #-} + writeVkBindCount p + = pokeByteOff p #{offset VkSparseBufferMemoryBindInfo, bindCount} + +instance {-# OVERLAPPING #-} + HasField "bindCount" VkSparseBufferMemoryBindInfo where + type FieldType "bindCount" VkSparseBufferMemoryBindInfo = Word32 + type FieldOptional "bindCount" VkSparseBufferMemoryBindInfo = + 'False -- ' closing tick for hsc2hs + type FieldOffset "bindCount" VkSparseBufferMemoryBindInfo = + #{offset VkSparseBufferMemoryBindInfo, bindCount} + type FieldIsArray "bindCount" VkSparseBufferMemoryBindInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSparseBufferMemoryBindInfo, bindCount} + +instance CanReadField "bindCount" VkSparseBufferMemoryBindInfo + where + {-# INLINE getField #-} + getField = vkBindCount + + {-# INLINE readField #-} + readField = readVkBindCount + +instance CanWriteField "bindCount" VkSparseBufferMemoryBindInfo + where + {-# INLINE writeField #-} + writeField = writeVkBindCount + +instance {-# OVERLAPPING #-} + HasVkPBinds VkSparseBufferMemoryBindInfo where + type VkPBindsMType VkSparseBufferMemoryBindInfo = + Ptr VkSparseMemoryBind + + {-# NOINLINE vkPBinds #-} + vkPBinds x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSparseBufferMemoryBindInfo, pBinds}) + + {-# INLINE vkPBindsByteOffset #-} + vkPBindsByteOffset ~_ + = #{offset VkSparseBufferMemoryBindInfo, pBinds} + + {-# INLINE readVkPBinds #-} + readVkPBinds p + = peekByteOff p #{offset VkSparseBufferMemoryBindInfo, pBinds} + + {-# INLINE writeVkPBinds #-} + writeVkPBinds p + = pokeByteOff p #{offset VkSparseBufferMemoryBindInfo, pBinds} + +instance {-# OVERLAPPING #-} + HasField "pBinds" VkSparseBufferMemoryBindInfo where + type FieldType "pBinds" VkSparseBufferMemoryBindInfo = + Ptr VkSparseMemoryBind + type FieldOptional "pBinds" VkSparseBufferMemoryBindInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "pBinds" VkSparseBufferMemoryBindInfo = + #{offset VkSparseBufferMemoryBindInfo, pBinds} + type FieldIsArray "pBinds" VkSparseBufferMemoryBindInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSparseBufferMemoryBindInfo, pBinds} + +instance CanReadField "pBinds" VkSparseBufferMemoryBindInfo where + {-# INLINE getField #-} + getField = vkPBinds + + {-# INLINE readField #-} + readField = readVkPBinds + +instance CanWriteField "pBinds" VkSparseBufferMemoryBindInfo where + {-# INLINE writeField #-} + writeField = writeVkPBinds + +instance Show VkSparseBufferMemoryBindInfo where + showsPrec d x + = showString "VkSparseBufferMemoryBindInfo {" . + showString "vkBuffer = " . + showsPrec d (vkBuffer x) . + showString ", " . + showString "vkBindCount = " . + showsPrec d (vkBindCount x) . + showString ", " . + showString "vkPBinds = " . showsPrec d (vkPBinds x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkSparseImageFormatProperties.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkSparseImageFormatProperties.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkSparseImageFormatProperties.hsc @@ -0,0 +1,231 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkSparseImageFormatProperties + (VkSparseImageFormatProperties(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkImageAspectFlags (VkImageAspectFlags) +import Graphics.Vulkan.Types.Enum.VkSparseImageFormatFlags (VkSparseImageFormatFlags) +import Graphics.Vulkan.Types.Struct.VkExtent3D (VkExtent3D) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkSparseImageFormatProperties { +-- > VkImageAspectFlags aspectMask; +-- > VkExtent3D imageGranularity; +-- > VkSparseImageFormatFlags flags; +-- > } VkSparseImageFormatProperties; +-- +-- +data VkSparseImageFormatProperties = VkSparseImageFormatProperties## Addr## + ByteArray## + +instance Eq VkSparseImageFormatProperties where + (VkSparseImageFormatProperties## a _) == + x@(VkSparseImageFormatProperties## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkSparseImageFormatProperties where + (VkSparseImageFormatProperties## a _) `compare` + x@(VkSparseImageFormatProperties## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkSparseImageFormatProperties where + sizeOf ~_ = #{size VkSparseImageFormatProperties} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkSparseImageFormatProperties} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkSparseImageFormatProperties where + unsafeAddr (VkSparseImageFormatProperties## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkSparseImageFormatProperties## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkSparseImageFormatProperties## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkSparseImageFormatProperties where + type StructFields VkSparseImageFormatProperties = + '["aspectMask", "imageGranularity", "flags"] -- ' closing tick for hsc2hs + type CUnionType VkSparseImageFormatProperties = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkSparseImageFormatProperties = 'True -- ' closing tick for hsc2hs + type StructExtends VkSparseImageFormatProperties = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkAspectMask VkSparseImageFormatProperties where + type VkAspectMaskMType VkSparseImageFormatProperties = + VkImageAspectFlags + + {-# NOINLINE vkAspectMask #-} + vkAspectMask x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSparseImageFormatProperties, aspectMask}) + + {-# INLINE vkAspectMaskByteOffset #-} + vkAspectMaskByteOffset ~_ + = #{offset VkSparseImageFormatProperties, aspectMask} + + {-# INLINE readVkAspectMask #-} + readVkAspectMask p + = peekByteOff p #{offset VkSparseImageFormatProperties, aspectMask} + + {-# INLINE writeVkAspectMask #-} + writeVkAspectMask p + = pokeByteOff p #{offset VkSparseImageFormatProperties, aspectMask} + +instance {-# OVERLAPPING #-} + HasField "aspectMask" VkSparseImageFormatProperties where + type FieldType "aspectMask" VkSparseImageFormatProperties = + VkImageAspectFlags + type FieldOptional "aspectMask" VkSparseImageFormatProperties = + 'True -- ' closing tick for hsc2hs + type FieldOffset "aspectMask" VkSparseImageFormatProperties = + #{offset VkSparseImageFormatProperties, aspectMask} + type FieldIsArray "aspectMask" VkSparseImageFormatProperties = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSparseImageFormatProperties, aspectMask} + +instance CanReadField "aspectMask" VkSparseImageFormatProperties + where + {-# INLINE getField #-} + getField = vkAspectMask + + {-# INLINE readField #-} + readField = readVkAspectMask + +instance {-# OVERLAPPING #-} + HasVkImageGranularity VkSparseImageFormatProperties where + type VkImageGranularityMType VkSparseImageFormatProperties = + VkExtent3D + + {-# NOINLINE vkImageGranularity #-} + vkImageGranularity x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSparseImageFormatProperties, imageGranularity}) + + {-# INLINE vkImageGranularityByteOffset #-} + vkImageGranularityByteOffset ~_ + = #{offset VkSparseImageFormatProperties, imageGranularity} + + {-# INLINE readVkImageGranularity #-} + readVkImageGranularity p + = peekByteOff p #{offset VkSparseImageFormatProperties, imageGranularity} + + {-# INLINE writeVkImageGranularity #-} + writeVkImageGranularity p + = pokeByteOff p #{offset VkSparseImageFormatProperties, imageGranularity} + +instance {-# OVERLAPPING #-} + HasField "imageGranularity" VkSparseImageFormatProperties where + type FieldType "imageGranularity" VkSparseImageFormatProperties = + VkExtent3D + type FieldOptional "imageGranularity" VkSparseImageFormatProperties + = 'False -- ' closing tick for hsc2hs + type FieldOffset "imageGranularity" VkSparseImageFormatProperties = + #{offset VkSparseImageFormatProperties, imageGranularity} + type FieldIsArray "imageGranularity" VkSparseImageFormatProperties + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSparseImageFormatProperties, imageGranularity} + +instance CanReadField "imageGranularity" + VkSparseImageFormatProperties + where + {-# INLINE getField #-} + getField = vkImageGranularity + + {-# INLINE readField #-} + readField = readVkImageGranularity + +instance {-# OVERLAPPING #-} + HasVkFlags VkSparseImageFormatProperties where + type VkFlagsMType VkSparseImageFormatProperties = + VkSparseImageFormatFlags + + {-# NOINLINE vkFlags #-} + vkFlags x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSparseImageFormatProperties, flags}) + + {-# INLINE vkFlagsByteOffset #-} + vkFlagsByteOffset ~_ + = #{offset VkSparseImageFormatProperties, flags} + + {-# INLINE readVkFlags #-} + readVkFlags p + = peekByteOff p #{offset VkSparseImageFormatProperties, flags} + + {-# INLINE writeVkFlags #-} + writeVkFlags p + = pokeByteOff p #{offset VkSparseImageFormatProperties, flags} + +instance {-# OVERLAPPING #-} + HasField "flags" VkSparseImageFormatProperties where + type FieldType "flags" VkSparseImageFormatProperties = + VkSparseImageFormatFlags + type FieldOptional "flags" VkSparseImageFormatProperties = 'True -- ' closing tick for hsc2hs + type FieldOffset "flags" VkSparseImageFormatProperties = + #{offset VkSparseImageFormatProperties, flags} + type FieldIsArray "flags" VkSparseImageFormatProperties = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSparseImageFormatProperties, flags} + +instance CanReadField "flags" VkSparseImageFormatProperties where + {-# INLINE getField #-} + getField = vkFlags + + {-# INLINE readField #-} + readField = readVkFlags + +instance Show VkSparseImageFormatProperties where + showsPrec d x + = showString "VkSparseImageFormatProperties {" . + showString "vkAspectMask = " . + showsPrec d (vkAspectMask x) . + showString ", " . + showString "vkImageGranularity = " . + showsPrec d (vkImageGranularity x) . + showString ", " . + showString "vkFlags = " . showsPrec d (vkFlags x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkSparseImageFormatProperties2KHR.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkSparseImageFormatProperties2KHR.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkSparseImageFormatProperties2KHR.hsc @@ -0,0 +1,233 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkSparseImageFormatProperties2KHR + (VkSparseImageFormatProperties2KHR(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Struct.VkSparseImageFormatProperties (VkSparseImageFormatProperties) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkSparseImageFormatProperties2KHR { +-- > VkStructureType sType; +-- > void* pNext; +-- > VkSparseImageFormatProperties properties; +-- > } VkSparseImageFormatProperties2KHR; +-- +-- +data VkSparseImageFormatProperties2KHR = VkSparseImageFormatProperties2KHR## Addr## + ByteArray## + +instance Eq VkSparseImageFormatProperties2KHR where + (VkSparseImageFormatProperties2KHR## a _) == + x@(VkSparseImageFormatProperties2KHR## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkSparseImageFormatProperties2KHR where + (VkSparseImageFormatProperties2KHR## a _) `compare` + x@(VkSparseImageFormatProperties2KHR## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkSparseImageFormatProperties2KHR where + sizeOf ~_ = #{size VkSparseImageFormatProperties2KHR} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkSparseImageFormatProperties2KHR} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkSparseImageFormatProperties2KHR where + unsafeAddr (VkSparseImageFormatProperties2KHR## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkSparseImageFormatProperties2KHR## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkSparseImageFormatProperties2KHR## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkSparseImageFormatProperties2KHR where + type StructFields VkSparseImageFormatProperties2KHR = + '["sType", "pNext", "properties"] -- ' closing tick for hsc2hs + type CUnionType VkSparseImageFormatProperties2KHR = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkSparseImageFormatProperties2KHR = 'True -- ' closing tick for hsc2hs + type StructExtends VkSparseImageFormatProperties2KHR = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkSparseImageFormatProperties2KHR where + type VkSTypeMType VkSparseImageFormatProperties2KHR = + VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSparseImageFormatProperties2KHR, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkSparseImageFormatProperties2KHR, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkSparseImageFormatProperties2KHR, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkSparseImageFormatProperties2KHR, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkSparseImageFormatProperties2KHR where + type FieldType "sType" VkSparseImageFormatProperties2KHR = + VkStructureType + type FieldOptional "sType" VkSparseImageFormatProperties2KHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkSparseImageFormatProperties2KHR = + #{offset VkSparseImageFormatProperties2KHR, sType} + type FieldIsArray "sType" VkSparseImageFormatProperties2KHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSparseImageFormatProperties2KHR, sType} + +instance CanReadField "sType" VkSparseImageFormatProperties2KHR + where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkSparseImageFormatProperties2KHR where + type VkPNextMType VkSparseImageFormatProperties2KHR = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSparseImageFormatProperties2KHR, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkSparseImageFormatProperties2KHR, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkSparseImageFormatProperties2KHR, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkSparseImageFormatProperties2KHR, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkSparseImageFormatProperties2KHR where + type FieldType "pNext" VkSparseImageFormatProperties2KHR = Ptr Void + type FieldOptional "pNext" VkSparseImageFormatProperties2KHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkSparseImageFormatProperties2KHR = + #{offset VkSparseImageFormatProperties2KHR, pNext} + type FieldIsArray "pNext" VkSparseImageFormatProperties2KHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSparseImageFormatProperties2KHR, pNext} + +instance CanReadField "pNext" VkSparseImageFormatProperties2KHR + where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance {-# OVERLAPPING #-} + HasVkProperties VkSparseImageFormatProperties2KHR where + type VkPropertiesMType VkSparseImageFormatProperties2KHR = + VkSparseImageFormatProperties + + {-# NOINLINE vkProperties #-} + vkProperties x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSparseImageFormatProperties2KHR, properties}) + + {-# INLINE vkPropertiesByteOffset #-} + vkPropertiesByteOffset ~_ + = #{offset VkSparseImageFormatProperties2KHR, properties} + + {-# INLINE readVkProperties #-} + readVkProperties p + = peekByteOff p #{offset VkSparseImageFormatProperties2KHR, properties} + + {-# INLINE writeVkProperties #-} + writeVkProperties p + = pokeByteOff p #{offset VkSparseImageFormatProperties2KHR, properties} + +instance {-# OVERLAPPING #-} + HasField "properties" VkSparseImageFormatProperties2KHR where + type FieldType "properties" VkSparseImageFormatProperties2KHR = + VkSparseImageFormatProperties + type FieldOptional "properties" VkSparseImageFormatProperties2KHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "properties" VkSparseImageFormatProperties2KHR = + #{offset VkSparseImageFormatProperties2KHR, properties} + type FieldIsArray "properties" VkSparseImageFormatProperties2KHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSparseImageFormatProperties2KHR, properties} + +instance CanReadField "properties" + VkSparseImageFormatProperties2KHR + where + {-# INLINE getField #-} + getField = vkProperties + + {-# INLINE readField #-} + readField = readVkProperties + +instance Show VkSparseImageFormatProperties2KHR where + showsPrec d x + = showString "VkSparseImageFormatProperties2KHR {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkProperties = " . + showsPrec d (vkProperties x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkSparseImageMemoryBind.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkSparseImageMemoryBind.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkSparseImageMemoryBind.hsc @@ -0,0 +1,384 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkSparseImageMemoryBind + (VkSparseImageMemoryBind(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.BaseTypes (VkDeviceSize) +import Graphics.Vulkan.Types.Enum.VkSparseMemoryBindFlags (VkSparseMemoryBindFlags) +import Graphics.Vulkan.Types.Handles (VkDeviceMemory) +import Graphics.Vulkan.Types.Struct.VkExtent3D (VkExtent3D) +import Graphics.Vulkan.Types.Struct.VkImageSubresource (VkImageSubresource) +import Graphics.Vulkan.Types.Struct.VkOffset3D (VkOffset3D) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkSparseImageMemoryBind { +-- > VkImageSubresource subresource; +-- > VkOffset3D offset; +-- > VkExtent3D extent; +-- > VkDeviceMemory memory; +-- > VkDeviceSize memoryOffset; +-- > VkSparseMemoryBindFlagsflags; +-- > } VkSparseImageMemoryBind; +-- +-- +data VkSparseImageMemoryBind = VkSparseImageMemoryBind## Addr## + ByteArray## + +instance Eq VkSparseImageMemoryBind where + (VkSparseImageMemoryBind## a _) == x@(VkSparseImageMemoryBind## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkSparseImageMemoryBind where + (VkSparseImageMemoryBind## a _) `compare` + x@(VkSparseImageMemoryBind## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkSparseImageMemoryBind where + sizeOf ~_ = #{size VkSparseImageMemoryBind} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkSparseImageMemoryBind} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkSparseImageMemoryBind where + unsafeAddr (VkSparseImageMemoryBind## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkSparseImageMemoryBind## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkSparseImageMemoryBind## (plusAddr## (byteArrayContents## b) off) b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkSparseImageMemoryBind where + type StructFields VkSparseImageMemoryBind = + '["subresource", "offset", "extent", "memory", "memoryOffset", -- ' closing tick for hsc2hs + "flags"] + type CUnionType VkSparseImageMemoryBind = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkSparseImageMemoryBind = 'False -- ' closing tick for hsc2hs + type StructExtends VkSparseImageMemoryBind = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSubresource VkSparseImageMemoryBind where + type VkSubresourceMType VkSparseImageMemoryBind = + VkImageSubresource + + {-# NOINLINE vkSubresource #-} + vkSubresource x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSparseImageMemoryBind, subresource}) + + {-# INLINE vkSubresourceByteOffset #-} + vkSubresourceByteOffset ~_ + = #{offset VkSparseImageMemoryBind, subresource} + + {-# INLINE readVkSubresource #-} + readVkSubresource p + = peekByteOff p #{offset VkSparseImageMemoryBind, subresource} + + {-# INLINE writeVkSubresource #-} + writeVkSubresource p + = pokeByteOff p #{offset VkSparseImageMemoryBind, subresource} + +instance {-# OVERLAPPING #-} + HasField "subresource" VkSparseImageMemoryBind where + type FieldType "subresource" VkSparseImageMemoryBind = + VkImageSubresource + type FieldOptional "subresource" VkSparseImageMemoryBind = 'False -- ' closing tick for hsc2hs + type FieldOffset "subresource" VkSparseImageMemoryBind = + #{offset VkSparseImageMemoryBind, subresource} + type FieldIsArray "subresource" VkSparseImageMemoryBind = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSparseImageMemoryBind, subresource} + +instance CanReadField "subresource" VkSparseImageMemoryBind where + {-# INLINE getField #-} + getField = vkSubresource + + {-# INLINE readField #-} + readField = readVkSubresource + +instance CanWriteField "subresource" VkSparseImageMemoryBind where + {-# INLINE writeField #-} + writeField = writeVkSubresource + +instance {-# OVERLAPPING #-} HasVkOffset VkSparseImageMemoryBind + where + type VkOffsetMType VkSparseImageMemoryBind = VkOffset3D + + {-# NOINLINE vkOffset #-} + vkOffset x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSparseImageMemoryBind, offset}) + + {-# INLINE vkOffsetByteOffset #-} + vkOffsetByteOffset ~_ + = #{offset VkSparseImageMemoryBind, offset} + + {-# INLINE readVkOffset #-} + readVkOffset p + = peekByteOff p #{offset VkSparseImageMemoryBind, offset} + + {-# INLINE writeVkOffset #-} + writeVkOffset p + = pokeByteOff p #{offset VkSparseImageMemoryBind, offset} + +instance {-# OVERLAPPING #-} + HasField "offset" VkSparseImageMemoryBind where + type FieldType "offset" VkSparseImageMemoryBind = VkOffset3D + type FieldOptional "offset" VkSparseImageMemoryBind = 'False -- ' closing tick for hsc2hs + type FieldOffset "offset" VkSparseImageMemoryBind = + #{offset VkSparseImageMemoryBind, offset} + type FieldIsArray "offset" VkSparseImageMemoryBind = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkSparseImageMemoryBind, offset} + +instance CanReadField "offset" VkSparseImageMemoryBind where + {-# INLINE getField #-} + getField = vkOffset + + {-# INLINE readField #-} + readField = readVkOffset + +instance CanWriteField "offset" VkSparseImageMemoryBind where + {-# INLINE writeField #-} + writeField = writeVkOffset + +instance {-# OVERLAPPING #-} HasVkExtent VkSparseImageMemoryBind + where + type VkExtentMType VkSparseImageMemoryBind = VkExtent3D + + {-# NOINLINE vkExtent #-} + vkExtent x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSparseImageMemoryBind, extent}) + + {-# INLINE vkExtentByteOffset #-} + vkExtentByteOffset ~_ + = #{offset VkSparseImageMemoryBind, extent} + + {-# INLINE readVkExtent #-} + readVkExtent p + = peekByteOff p #{offset VkSparseImageMemoryBind, extent} + + {-# INLINE writeVkExtent #-} + writeVkExtent p + = pokeByteOff p #{offset VkSparseImageMemoryBind, extent} + +instance {-# OVERLAPPING #-} + HasField "extent" VkSparseImageMemoryBind where + type FieldType "extent" VkSparseImageMemoryBind = VkExtent3D + type FieldOptional "extent" VkSparseImageMemoryBind = 'False -- ' closing tick for hsc2hs + type FieldOffset "extent" VkSparseImageMemoryBind = + #{offset VkSparseImageMemoryBind, extent} + type FieldIsArray "extent" VkSparseImageMemoryBind = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkSparseImageMemoryBind, extent} + +instance CanReadField "extent" VkSparseImageMemoryBind where + {-# INLINE getField #-} + getField = vkExtent + + {-# INLINE readField #-} + readField = readVkExtent + +instance CanWriteField "extent" VkSparseImageMemoryBind where + {-# INLINE writeField #-} + writeField = writeVkExtent + +instance {-# OVERLAPPING #-} HasVkMemory VkSparseImageMemoryBind + where + type VkMemoryMType VkSparseImageMemoryBind = VkDeviceMemory + + {-# NOINLINE vkMemory #-} + vkMemory x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSparseImageMemoryBind, memory}) + + {-# INLINE vkMemoryByteOffset #-} + vkMemoryByteOffset ~_ + = #{offset VkSparseImageMemoryBind, memory} + + {-# INLINE readVkMemory #-} + readVkMemory p + = peekByteOff p #{offset VkSparseImageMemoryBind, memory} + + {-# INLINE writeVkMemory #-} + writeVkMemory p + = pokeByteOff p #{offset VkSparseImageMemoryBind, memory} + +instance {-# OVERLAPPING #-} + HasField "memory" VkSparseImageMemoryBind where + type FieldType "memory" VkSparseImageMemoryBind = VkDeviceMemory + type FieldOptional "memory" VkSparseImageMemoryBind = 'True -- ' closing tick for hsc2hs + type FieldOffset "memory" VkSparseImageMemoryBind = + #{offset VkSparseImageMemoryBind, memory} + type FieldIsArray "memory" VkSparseImageMemoryBind = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkSparseImageMemoryBind, memory} + +instance CanReadField "memory" VkSparseImageMemoryBind where + {-# INLINE getField #-} + getField = vkMemory + + {-# INLINE readField #-} + readField = readVkMemory + +instance CanWriteField "memory" VkSparseImageMemoryBind where + {-# INLINE writeField #-} + writeField = writeVkMemory + +instance {-# OVERLAPPING #-} + HasVkMemoryOffset VkSparseImageMemoryBind where + type VkMemoryOffsetMType VkSparseImageMemoryBind = VkDeviceSize + + {-# NOINLINE vkMemoryOffset #-} + vkMemoryOffset x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSparseImageMemoryBind, memoryOffset}) + + {-# INLINE vkMemoryOffsetByteOffset #-} + vkMemoryOffsetByteOffset ~_ + = #{offset VkSparseImageMemoryBind, memoryOffset} + + {-# INLINE readVkMemoryOffset #-} + readVkMemoryOffset p + = peekByteOff p #{offset VkSparseImageMemoryBind, memoryOffset} + + {-# INLINE writeVkMemoryOffset #-} + writeVkMemoryOffset p + = pokeByteOff p #{offset VkSparseImageMemoryBind, memoryOffset} + +instance {-# OVERLAPPING #-} + HasField "memoryOffset" VkSparseImageMemoryBind where + type FieldType "memoryOffset" VkSparseImageMemoryBind = + VkDeviceSize + type FieldOptional "memoryOffset" VkSparseImageMemoryBind = 'False -- ' closing tick for hsc2hs + type FieldOffset "memoryOffset" VkSparseImageMemoryBind = + #{offset VkSparseImageMemoryBind, memoryOffset} + type FieldIsArray "memoryOffset" VkSparseImageMemoryBind = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSparseImageMemoryBind, memoryOffset} + +instance CanReadField "memoryOffset" VkSparseImageMemoryBind where + {-# INLINE getField #-} + getField = vkMemoryOffset + + {-# INLINE readField #-} + readField = readVkMemoryOffset + +instance CanWriteField "memoryOffset" VkSparseImageMemoryBind where + {-# INLINE writeField #-} + writeField = writeVkMemoryOffset + +instance {-# OVERLAPPING #-} HasVkFlags VkSparseImageMemoryBind + where + type VkFlagsMType VkSparseImageMemoryBind = VkSparseMemoryBindFlags + + {-# NOINLINE vkFlags #-} + vkFlags x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSparseImageMemoryBind, flags}) + + {-# INLINE vkFlagsByteOffset #-} + vkFlagsByteOffset ~_ + = #{offset VkSparseImageMemoryBind, flags} + + {-# INLINE readVkFlags #-} + readVkFlags p + = peekByteOff p #{offset VkSparseImageMemoryBind, flags} + + {-# INLINE writeVkFlags #-} + writeVkFlags p + = pokeByteOff p #{offset VkSparseImageMemoryBind, flags} + +instance {-# OVERLAPPING #-} + HasField "flags" VkSparseImageMemoryBind where + type FieldType "flags" VkSparseImageMemoryBind = + VkSparseMemoryBindFlags + type FieldOptional "flags" VkSparseImageMemoryBind = 'True -- ' closing tick for hsc2hs + type FieldOffset "flags" VkSparseImageMemoryBind = + #{offset VkSparseImageMemoryBind, flags} + type FieldIsArray "flags" VkSparseImageMemoryBind = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkSparseImageMemoryBind, flags} + +instance CanReadField "flags" VkSparseImageMemoryBind where + {-# INLINE getField #-} + getField = vkFlags + + {-# INLINE readField #-} + readField = readVkFlags + +instance CanWriteField "flags" VkSparseImageMemoryBind where + {-# INLINE writeField #-} + writeField = writeVkFlags + +instance Show VkSparseImageMemoryBind where + showsPrec d x + = showString "VkSparseImageMemoryBind {" . + showString "vkSubresource = " . + showsPrec d (vkSubresource x) . + showString ", " . + showString "vkOffset = " . + showsPrec d (vkOffset x) . + showString ", " . + showString "vkExtent = " . + showsPrec d (vkExtent x) . + showString ", " . + showString "vkMemory = " . + showsPrec d (vkMemory x) . + showString ", " . + showString "vkMemoryOffset = " . + showsPrec d (vkMemoryOffset x) . + showString ", " . + showString "vkFlags = " . + showsPrec d (vkFlags x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkSparseImageMemoryBindInfo.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkSparseImageMemoryBindInfo.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkSparseImageMemoryBindInfo.hsc @@ -0,0 +1,231 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkSparseImageMemoryBindInfo + (VkSparseImageMemoryBindInfo(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Handles (VkImage) +import Graphics.Vulkan.Types.Struct.VkSparseImageMemoryBind (VkSparseImageMemoryBind) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkSparseImageMemoryBindInfo { +-- > VkImage image; +-- > uint32_t bindCount; +-- > const VkSparseImageMemoryBind* pBinds; +-- > } VkSparseImageMemoryBindInfo; +-- +-- +data VkSparseImageMemoryBindInfo = VkSparseImageMemoryBindInfo## Addr## + ByteArray## + +instance Eq VkSparseImageMemoryBindInfo where + (VkSparseImageMemoryBindInfo## a _) == + x@(VkSparseImageMemoryBindInfo## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkSparseImageMemoryBindInfo where + (VkSparseImageMemoryBindInfo## a _) `compare` + x@(VkSparseImageMemoryBindInfo## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkSparseImageMemoryBindInfo where + sizeOf ~_ = #{size VkSparseImageMemoryBindInfo} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkSparseImageMemoryBindInfo} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkSparseImageMemoryBindInfo where + unsafeAddr (VkSparseImageMemoryBindInfo## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkSparseImageMemoryBindInfo## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkSparseImageMemoryBindInfo## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkSparseImageMemoryBindInfo where + type StructFields VkSparseImageMemoryBindInfo = + '["image", "bindCount", "pBinds"] -- ' closing tick for hsc2hs + type CUnionType VkSparseImageMemoryBindInfo = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkSparseImageMemoryBindInfo = 'False -- ' closing tick for hsc2hs + type StructExtends VkSparseImageMemoryBindInfo = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkImage VkSparseImageMemoryBindInfo + where + type VkImageMType VkSparseImageMemoryBindInfo = VkImage + + {-# NOINLINE vkImage #-} + vkImage x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSparseImageMemoryBindInfo, image}) + + {-# INLINE vkImageByteOffset #-} + vkImageByteOffset ~_ + = #{offset VkSparseImageMemoryBindInfo, image} + + {-# INLINE readVkImage #-} + readVkImage p + = peekByteOff p #{offset VkSparseImageMemoryBindInfo, image} + + {-# INLINE writeVkImage #-} + writeVkImage p + = pokeByteOff p #{offset VkSparseImageMemoryBindInfo, image} + +instance {-# OVERLAPPING #-} + HasField "image" VkSparseImageMemoryBindInfo where + type FieldType "image" VkSparseImageMemoryBindInfo = VkImage + type FieldOptional "image" VkSparseImageMemoryBindInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "image" VkSparseImageMemoryBindInfo = + #{offset VkSparseImageMemoryBindInfo, image} + type FieldIsArray "image" VkSparseImageMemoryBindInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSparseImageMemoryBindInfo, image} + +instance CanReadField "image" VkSparseImageMemoryBindInfo where + {-# INLINE getField #-} + getField = vkImage + + {-# INLINE readField #-} + readField = readVkImage + +instance CanWriteField "image" VkSparseImageMemoryBindInfo where + {-# INLINE writeField #-} + writeField = writeVkImage + +instance {-# OVERLAPPING #-} + HasVkBindCount VkSparseImageMemoryBindInfo where + type VkBindCountMType VkSparseImageMemoryBindInfo = Word32 + + {-# NOINLINE vkBindCount #-} + vkBindCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSparseImageMemoryBindInfo, bindCount}) + + {-# INLINE vkBindCountByteOffset #-} + vkBindCountByteOffset ~_ + = #{offset VkSparseImageMemoryBindInfo, bindCount} + + {-# INLINE readVkBindCount #-} + readVkBindCount p + = peekByteOff p #{offset VkSparseImageMemoryBindInfo, bindCount} + + {-# INLINE writeVkBindCount #-} + writeVkBindCount p + = pokeByteOff p #{offset VkSparseImageMemoryBindInfo, bindCount} + +instance {-# OVERLAPPING #-} + HasField "bindCount" VkSparseImageMemoryBindInfo where + type FieldType "bindCount" VkSparseImageMemoryBindInfo = Word32 + type FieldOptional "bindCount" VkSparseImageMemoryBindInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "bindCount" VkSparseImageMemoryBindInfo = + #{offset VkSparseImageMemoryBindInfo, bindCount} + type FieldIsArray "bindCount" VkSparseImageMemoryBindInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSparseImageMemoryBindInfo, bindCount} + +instance CanReadField "bindCount" VkSparseImageMemoryBindInfo where + {-# INLINE getField #-} + getField = vkBindCount + + {-# INLINE readField #-} + readField = readVkBindCount + +instance CanWriteField "bindCount" VkSparseImageMemoryBindInfo + where + {-# INLINE writeField #-} + writeField = writeVkBindCount + +instance {-# OVERLAPPING #-} + HasVkPBinds VkSparseImageMemoryBindInfo where + type VkPBindsMType VkSparseImageMemoryBindInfo = + Ptr VkSparseImageMemoryBind + + {-# NOINLINE vkPBinds #-} + vkPBinds x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSparseImageMemoryBindInfo, pBinds}) + + {-# INLINE vkPBindsByteOffset #-} + vkPBindsByteOffset ~_ + = #{offset VkSparseImageMemoryBindInfo, pBinds} + + {-# INLINE readVkPBinds #-} + readVkPBinds p + = peekByteOff p #{offset VkSparseImageMemoryBindInfo, pBinds} + + {-# INLINE writeVkPBinds #-} + writeVkPBinds p + = pokeByteOff p #{offset VkSparseImageMemoryBindInfo, pBinds} + +instance {-# OVERLAPPING #-} + HasField "pBinds" VkSparseImageMemoryBindInfo where + type FieldType "pBinds" VkSparseImageMemoryBindInfo = + Ptr VkSparseImageMemoryBind + type FieldOptional "pBinds" VkSparseImageMemoryBindInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "pBinds" VkSparseImageMemoryBindInfo = + #{offset VkSparseImageMemoryBindInfo, pBinds} + type FieldIsArray "pBinds" VkSparseImageMemoryBindInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSparseImageMemoryBindInfo, pBinds} + +instance CanReadField "pBinds" VkSparseImageMemoryBindInfo where + {-# INLINE getField #-} + getField = vkPBinds + + {-# INLINE readField #-} + readField = readVkPBinds + +instance CanWriteField "pBinds" VkSparseImageMemoryBindInfo where + {-# INLINE writeField #-} + writeField = writeVkPBinds + +instance Show VkSparseImageMemoryBindInfo where + showsPrec d x + = showString "VkSparseImageMemoryBindInfo {" . + showString "vkImage = " . + showsPrec d (vkImage x) . + showString ", " . + showString "vkBindCount = " . + showsPrec d (vkBindCount x) . + showString ", " . + showString "vkPBinds = " . showsPrec d (vkPBinds x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkSparseImageMemoryRequirements.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkSparseImageMemoryRequirements.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkSparseImageMemoryRequirements.hsc @@ -0,0 +1,363 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkSparseImageMemoryRequirements + (VkSparseImageMemoryRequirements(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.BaseTypes (VkDeviceSize) +import Graphics.Vulkan.Types.Struct.VkSparseImageFormatProperties (VkSparseImageFormatProperties) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkSparseImageMemoryRequirements { +-- > VkSparseImageFormatProperties formatProperties; +-- > uint32_t imageMipTailFirstLod; +-- > VkDeviceSize imageMipTailSize; +-- > VkDeviceSize imageMipTailOffset; +-- > VkDeviceSize imageMipTailStride; +-- > } VkSparseImageMemoryRequirements; +-- +-- +data VkSparseImageMemoryRequirements = VkSparseImageMemoryRequirements## Addr## + ByteArray## + +instance Eq VkSparseImageMemoryRequirements where + (VkSparseImageMemoryRequirements## a _) == + x@(VkSparseImageMemoryRequirements## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkSparseImageMemoryRequirements where + (VkSparseImageMemoryRequirements## a _) `compare` + x@(VkSparseImageMemoryRequirements## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkSparseImageMemoryRequirements where + sizeOf ~_ = #{size VkSparseImageMemoryRequirements} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkSparseImageMemoryRequirements} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkSparseImageMemoryRequirements where + unsafeAddr (VkSparseImageMemoryRequirements## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkSparseImageMemoryRequirements## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkSparseImageMemoryRequirements## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkSparseImageMemoryRequirements where + type StructFields VkSparseImageMemoryRequirements = + '["formatProperties", "imageMipTailFirstLod", "imageMipTailSize", -- ' closing tick for hsc2hs + "imageMipTailOffset", "imageMipTailStride"] + type CUnionType VkSparseImageMemoryRequirements = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkSparseImageMemoryRequirements = 'True -- ' closing tick for hsc2hs + type StructExtends VkSparseImageMemoryRequirements = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkFormatProperties VkSparseImageMemoryRequirements where + type VkFormatPropertiesMType VkSparseImageMemoryRequirements = + VkSparseImageFormatProperties + + {-# NOINLINE vkFormatProperties #-} + vkFormatProperties x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSparseImageMemoryRequirements, formatProperties}) + + {-# INLINE vkFormatPropertiesByteOffset #-} + vkFormatPropertiesByteOffset ~_ + = #{offset VkSparseImageMemoryRequirements, formatProperties} + + {-# INLINE readVkFormatProperties #-} + readVkFormatProperties p + = peekByteOff p #{offset VkSparseImageMemoryRequirements, formatProperties} + + {-# INLINE writeVkFormatProperties #-} + writeVkFormatProperties p + = pokeByteOff p #{offset VkSparseImageMemoryRequirements, formatProperties} + +instance {-# OVERLAPPING #-} + HasField "formatProperties" VkSparseImageMemoryRequirements where + type FieldType "formatProperties" VkSparseImageMemoryRequirements = + VkSparseImageFormatProperties + type FieldOptional "formatProperties" + VkSparseImageMemoryRequirements + = 'False -- ' closing tick for hsc2hs + type FieldOffset "formatProperties" VkSparseImageMemoryRequirements + = + #{offset VkSparseImageMemoryRequirements, formatProperties} + type FieldIsArray "formatProperties" + VkSparseImageMemoryRequirements + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSparseImageMemoryRequirements, formatProperties} + +instance CanReadField "formatProperties" + VkSparseImageMemoryRequirements + where + {-# INLINE getField #-} + getField = vkFormatProperties + + {-# INLINE readField #-} + readField = readVkFormatProperties + +instance {-# OVERLAPPING #-} + HasVkImageMipTailFirstLod VkSparseImageMemoryRequirements where + type VkImageMipTailFirstLodMType VkSparseImageMemoryRequirements = + Word32 + + {-# NOINLINE vkImageMipTailFirstLod #-} + vkImageMipTailFirstLod x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSparseImageMemoryRequirements, imageMipTailFirstLod}) + + {-# INLINE vkImageMipTailFirstLodByteOffset #-} + vkImageMipTailFirstLodByteOffset ~_ + = #{offset VkSparseImageMemoryRequirements, imageMipTailFirstLod} + + {-# INLINE readVkImageMipTailFirstLod #-} + readVkImageMipTailFirstLod p + = peekByteOff p #{offset VkSparseImageMemoryRequirements, imageMipTailFirstLod} + + {-# INLINE writeVkImageMipTailFirstLod #-} + writeVkImageMipTailFirstLod p + = pokeByteOff p #{offset VkSparseImageMemoryRequirements, imageMipTailFirstLod} + +instance {-# OVERLAPPING #-} + HasField "imageMipTailFirstLod" VkSparseImageMemoryRequirements + where + type FieldType "imageMipTailFirstLod" + VkSparseImageMemoryRequirements + = Word32 + type FieldOptional "imageMipTailFirstLod" + VkSparseImageMemoryRequirements + = 'False -- ' closing tick for hsc2hs + type FieldOffset "imageMipTailFirstLod" + VkSparseImageMemoryRequirements + = + #{offset VkSparseImageMemoryRequirements, imageMipTailFirstLod} + type FieldIsArray "imageMipTailFirstLod" + VkSparseImageMemoryRequirements + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSparseImageMemoryRequirements, imageMipTailFirstLod} + +instance CanReadField "imageMipTailFirstLod" + VkSparseImageMemoryRequirements + where + {-# INLINE getField #-} + getField = vkImageMipTailFirstLod + + {-# INLINE readField #-} + readField = readVkImageMipTailFirstLod + +instance {-# OVERLAPPING #-} + HasVkImageMipTailSize VkSparseImageMemoryRequirements where + type VkImageMipTailSizeMType VkSparseImageMemoryRequirements = + VkDeviceSize + + {-# NOINLINE vkImageMipTailSize #-} + vkImageMipTailSize x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSparseImageMemoryRequirements, imageMipTailSize}) + + {-# INLINE vkImageMipTailSizeByteOffset #-} + vkImageMipTailSizeByteOffset ~_ + = #{offset VkSparseImageMemoryRequirements, imageMipTailSize} + + {-# INLINE readVkImageMipTailSize #-} + readVkImageMipTailSize p + = peekByteOff p #{offset VkSparseImageMemoryRequirements, imageMipTailSize} + + {-# INLINE writeVkImageMipTailSize #-} + writeVkImageMipTailSize p + = pokeByteOff p #{offset VkSparseImageMemoryRequirements, imageMipTailSize} + +instance {-# OVERLAPPING #-} + HasField "imageMipTailSize" VkSparseImageMemoryRequirements where + type FieldType "imageMipTailSize" VkSparseImageMemoryRequirements = + VkDeviceSize + type FieldOptional "imageMipTailSize" + VkSparseImageMemoryRequirements + = 'False -- ' closing tick for hsc2hs + type FieldOffset "imageMipTailSize" VkSparseImageMemoryRequirements + = + #{offset VkSparseImageMemoryRequirements, imageMipTailSize} + type FieldIsArray "imageMipTailSize" + VkSparseImageMemoryRequirements + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSparseImageMemoryRequirements, imageMipTailSize} + +instance CanReadField "imageMipTailSize" + VkSparseImageMemoryRequirements + where + {-# INLINE getField #-} + getField = vkImageMipTailSize + + {-# INLINE readField #-} + readField = readVkImageMipTailSize + +instance {-# OVERLAPPING #-} + HasVkImageMipTailOffset VkSparseImageMemoryRequirements where + type VkImageMipTailOffsetMType VkSparseImageMemoryRequirements = + VkDeviceSize + + {-# NOINLINE vkImageMipTailOffset #-} + vkImageMipTailOffset x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSparseImageMemoryRequirements, imageMipTailOffset}) + + {-# INLINE vkImageMipTailOffsetByteOffset #-} + vkImageMipTailOffsetByteOffset ~_ + = #{offset VkSparseImageMemoryRequirements, imageMipTailOffset} + + {-# INLINE readVkImageMipTailOffset #-} + readVkImageMipTailOffset p + = peekByteOff p #{offset VkSparseImageMemoryRequirements, imageMipTailOffset} + + {-# INLINE writeVkImageMipTailOffset #-} + writeVkImageMipTailOffset p + = pokeByteOff p #{offset VkSparseImageMemoryRequirements, imageMipTailOffset} + +instance {-# OVERLAPPING #-} + HasField "imageMipTailOffset" VkSparseImageMemoryRequirements where + type FieldType "imageMipTailOffset" VkSparseImageMemoryRequirements + = VkDeviceSize + type FieldOptional "imageMipTailOffset" + VkSparseImageMemoryRequirements + = 'False -- ' closing tick for hsc2hs + type FieldOffset "imageMipTailOffset" + VkSparseImageMemoryRequirements + = + #{offset VkSparseImageMemoryRequirements, imageMipTailOffset} + type FieldIsArray "imageMipTailOffset" + VkSparseImageMemoryRequirements + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSparseImageMemoryRequirements, imageMipTailOffset} + +instance CanReadField "imageMipTailOffset" + VkSparseImageMemoryRequirements + where + {-# INLINE getField #-} + getField = vkImageMipTailOffset + + {-# INLINE readField #-} + readField = readVkImageMipTailOffset + +instance {-# OVERLAPPING #-} + HasVkImageMipTailStride VkSparseImageMemoryRequirements where + type VkImageMipTailStrideMType VkSparseImageMemoryRequirements = + VkDeviceSize + + {-# NOINLINE vkImageMipTailStride #-} + vkImageMipTailStride x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSparseImageMemoryRequirements, imageMipTailStride}) + + {-# INLINE vkImageMipTailStrideByteOffset #-} + vkImageMipTailStrideByteOffset ~_ + = #{offset VkSparseImageMemoryRequirements, imageMipTailStride} + + {-# INLINE readVkImageMipTailStride #-} + readVkImageMipTailStride p + = peekByteOff p #{offset VkSparseImageMemoryRequirements, imageMipTailStride} + + {-# INLINE writeVkImageMipTailStride #-} + writeVkImageMipTailStride p + = pokeByteOff p #{offset VkSparseImageMemoryRequirements, imageMipTailStride} + +instance {-# OVERLAPPING #-} + HasField "imageMipTailStride" VkSparseImageMemoryRequirements where + type FieldType "imageMipTailStride" VkSparseImageMemoryRequirements + = VkDeviceSize + type FieldOptional "imageMipTailStride" + VkSparseImageMemoryRequirements + = 'False -- ' closing tick for hsc2hs + type FieldOffset "imageMipTailStride" + VkSparseImageMemoryRequirements + = + #{offset VkSparseImageMemoryRequirements, imageMipTailStride} + type FieldIsArray "imageMipTailStride" + VkSparseImageMemoryRequirements + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSparseImageMemoryRequirements, imageMipTailStride} + +instance CanReadField "imageMipTailStride" + VkSparseImageMemoryRequirements + where + {-# INLINE getField #-} + getField = vkImageMipTailStride + + {-# INLINE readField #-} + readField = readVkImageMipTailStride + +instance Show VkSparseImageMemoryRequirements where + showsPrec d x + = showString "VkSparseImageMemoryRequirements {" . + showString "vkFormatProperties = " . + showsPrec d (vkFormatProperties x) . + showString ", " . + showString "vkImageMipTailFirstLod = " . + showsPrec d (vkImageMipTailFirstLod x) . + showString ", " . + showString "vkImageMipTailSize = " . + showsPrec d (vkImageMipTailSize x) . + showString ", " . + showString "vkImageMipTailOffset = " . + showsPrec d (vkImageMipTailOffset x) . + showString ", " . + showString "vkImageMipTailStride = " . + showsPrec d (vkImageMipTailStride x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkSparseImageMemoryRequirements2KHR.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkSparseImageMemoryRequirements2KHR.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkSparseImageMemoryRequirements2KHR.hsc @@ -0,0 +1,241 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkSparseImageMemoryRequirements2KHR + (VkSparseImageMemoryRequirements2KHR(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Struct.VkSparseImageMemoryRequirements (VkSparseImageMemoryRequirements) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkSparseImageMemoryRequirements2KHR { +-- > VkStructureType sType; +-- > void* pNext; +-- > VkSparseImageMemoryRequirements memoryRequirements; +-- > } VkSparseImageMemoryRequirements2KHR; +-- +-- +data VkSparseImageMemoryRequirements2KHR = VkSparseImageMemoryRequirements2KHR## Addr## + ByteArray## + +instance Eq VkSparseImageMemoryRequirements2KHR where + (VkSparseImageMemoryRequirements2KHR## a _) == + x@(VkSparseImageMemoryRequirements2KHR## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkSparseImageMemoryRequirements2KHR where + (VkSparseImageMemoryRequirements2KHR## a _) `compare` + x@(VkSparseImageMemoryRequirements2KHR## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkSparseImageMemoryRequirements2KHR where + sizeOf ~_ = #{size VkSparseImageMemoryRequirements2KHR} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkSparseImageMemoryRequirements2KHR} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkSparseImageMemoryRequirements2KHR + where + unsafeAddr (VkSparseImageMemoryRequirements2KHR## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkSparseImageMemoryRequirements2KHR## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkSparseImageMemoryRequirements2KHR## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkSparseImageMemoryRequirements2KHR where + type StructFields VkSparseImageMemoryRequirements2KHR = + '["sType", "pNext", "memoryRequirements"] -- ' closing tick for hsc2hs + type CUnionType VkSparseImageMemoryRequirements2KHR = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkSparseImageMemoryRequirements2KHR = 'True -- ' closing tick for hsc2hs + type StructExtends VkSparseImageMemoryRequirements2KHR = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkSparseImageMemoryRequirements2KHR where + type VkSTypeMType VkSparseImageMemoryRequirements2KHR = + VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSparseImageMemoryRequirements2KHR, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkSparseImageMemoryRequirements2KHR, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkSparseImageMemoryRequirements2KHR, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkSparseImageMemoryRequirements2KHR, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkSparseImageMemoryRequirements2KHR where + type FieldType "sType" VkSparseImageMemoryRequirements2KHR = + VkStructureType + type FieldOptional "sType" VkSparseImageMemoryRequirements2KHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkSparseImageMemoryRequirements2KHR = + #{offset VkSparseImageMemoryRequirements2KHR, sType} + type FieldIsArray "sType" VkSparseImageMemoryRequirements2KHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSparseImageMemoryRequirements2KHR, sType} + +instance CanReadField "sType" VkSparseImageMemoryRequirements2KHR + where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkSparseImageMemoryRequirements2KHR where + type VkPNextMType VkSparseImageMemoryRequirements2KHR = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSparseImageMemoryRequirements2KHR, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkSparseImageMemoryRequirements2KHR, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkSparseImageMemoryRequirements2KHR, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkSparseImageMemoryRequirements2KHR, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkSparseImageMemoryRequirements2KHR where + type FieldType "pNext" VkSparseImageMemoryRequirements2KHR = + Ptr Void + type FieldOptional "pNext" VkSparseImageMemoryRequirements2KHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkSparseImageMemoryRequirements2KHR = + #{offset VkSparseImageMemoryRequirements2KHR, pNext} + type FieldIsArray "pNext" VkSparseImageMemoryRequirements2KHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSparseImageMemoryRequirements2KHR, pNext} + +instance CanReadField "pNext" VkSparseImageMemoryRequirements2KHR + where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance {-# OVERLAPPING #-} + HasVkMemoryRequirements VkSparseImageMemoryRequirements2KHR where + type VkMemoryRequirementsMType VkSparseImageMemoryRequirements2KHR + = VkSparseImageMemoryRequirements + + {-# NOINLINE vkMemoryRequirements #-} + vkMemoryRequirements x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSparseImageMemoryRequirements2KHR, memoryRequirements}) + + {-# INLINE vkMemoryRequirementsByteOffset #-} + vkMemoryRequirementsByteOffset ~_ + = #{offset VkSparseImageMemoryRequirements2KHR, memoryRequirements} + + {-# INLINE readVkMemoryRequirements #-} + readVkMemoryRequirements p + = peekByteOff p #{offset VkSparseImageMemoryRequirements2KHR, memoryRequirements} + + {-# INLINE writeVkMemoryRequirements #-} + writeVkMemoryRequirements p + = pokeByteOff p #{offset VkSparseImageMemoryRequirements2KHR, memoryRequirements} + +instance {-# OVERLAPPING #-} + HasField "memoryRequirements" VkSparseImageMemoryRequirements2KHR + where + type FieldType "memoryRequirements" + VkSparseImageMemoryRequirements2KHR + = VkSparseImageMemoryRequirements + type FieldOptional "memoryRequirements" + VkSparseImageMemoryRequirements2KHR + = 'False -- ' closing tick for hsc2hs + type FieldOffset "memoryRequirements" + VkSparseImageMemoryRequirements2KHR + = + #{offset VkSparseImageMemoryRequirements2KHR, memoryRequirements} + type FieldIsArray "memoryRequirements" + VkSparseImageMemoryRequirements2KHR + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSparseImageMemoryRequirements2KHR, memoryRequirements} + +instance CanReadField "memoryRequirements" + VkSparseImageMemoryRequirements2KHR + where + {-# INLINE getField #-} + getField = vkMemoryRequirements + + {-# INLINE readField #-} + readField = readVkMemoryRequirements + +instance Show VkSparseImageMemoryRequirements2KHR where + showsPrec d x + = showString "VkSparseImageMemoryRequirements2KHR {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkMemoryRequirements = " . + showsPrec d (vkMemoryRequirements x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkSparseImageOpaqueMemoryBindInfo.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkSparseImageOpaqueMemoryBindInfo.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkSparseImageOpaqueMemoryBindInfo.hsc @@ -0,0 +1,246 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkSparseImageOpaqueMemoryBindInfo + (VkSparseImageOpaqueMemoryBindInfo(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Handles (VkImage) +import Graphics.Vulkan.Types.Struct.VkSparseMemoryBind (VkSparseMemoryBind) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkSparseImageOpaqueMemoryBindInfo { +-- > VkImage image; +-- > uint32_t bindCount; +-- > const VkSparseMemoryBind* pBinds; +-- > } VkSparseImageOpaqueMemoryBindInfo; +-- +-- +data VkSparseImageOpaqueMemoryBindInfo = VkSparseImageOpaqueMemoryBindInfo## Addr## + ByteArray## + +instance Eq VkSparseImageOpaqueMemoryBindInfo where + (VkSparseImageOpaqueMemoryBindInfo## a _) == + x@(VkSparseImageOpaqueMemoryBindInfo## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkSparseImageOpaqueMemoryBindInfo where + (VkSparseImageOpaqueMemoryBindInfo## a _) `compare` + x@(VkSparseImageOpaqueMemoryBindInfo## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkSparseImageOpaqueMemoryBindInfo where + sizeOf ~_ = #{size VkSparseImageOpaqueMemoryBindInfo} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkSparseImageOpaqueMemoryBindInfo} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkSparseImageOpaqueMemoryBindInfo where + unsafeAddr (VkSparseImageOpaqueMemoryBindInfo## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkSparseImageOpaqueMemoryBindInfo## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkSparseImageOpaqueMemoryBindInfo## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkSparseImageOpaqueMemoryBindInfo where + type StructFields VkSparseImageOpaqueMemoryBindInfo = + '["image", "bindCount", "pBinds"] -- ' closing tick for hsc2hs + type CUnionType VkSparseImageOpaqueMemoryBindInfo = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkSparseImageOpaqueMemoryBindInfo = 'False -- ' closing tick for hsc2hs + type StructExtends VkSparseImageOpaqueMemoryBindInfo = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkImage VkSparseImageOpaqueMemoryBindInfo where + type VkImageMType VkSparseImageOpaqueMemoryBindInfo = VkImage + + {-# NOINLINE vkImage #-} + vkImage x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSparseImageOpaqueMemoryBindInfo, image}) + + {-# INLINE vkImageByteOffset #-} + vkImageByteOffset ~_ + = #{offset VkSparseImageOpaqueMemoryBindInfo, image} + + {-# INLINE readVkImage #-} + readVkImage p + = peekByteOff p #{offset VkSparseImageOpaqueMemoryBindInfo, image} + + {-# INLINE writeVkImage #-} + writeVkImage p + = pokeByteOff p #{offset VkSparseImageOpaqueMemoryBindInfo, image} + +instance {-# OVERLAPPING #-} + HasField "image" VkSparseImageOpaqueMemoryBindInfo where + type FieldType "image" VkSparseImageOpaqueMemoryBindInfo = VkImage + type FieldOptional "image" VkSparseImageOpaqueMemoryBindInfo = + 'False -- ' closing tick for hsc2hs + type FieldOffset "image" VkSparseImageOpaqueMemoryBindInfo = + #{offset VkSparseImageOpaqueMemoryBindInfo, image} + type FieldIsArray "image" VkSparseImageOpaqueMemoryBindInfo = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSparseImageOpaqueMemoryBindInfo, image} + +instance CanReadField "image" VkSparseImageOpaqueMemoryBindInfo + where + {-# INLINE getField #-} + getField = vkImage + + {-# INLINE readField #-} + readField = readVkImage + +instance CanWriteField "image" VkSparseImageOpaqueMemoryBindInfo + where + {-# INLINE writeField #-} + writeField = writeVkImage + +instance {-# OVERLAPPING #-} + HasVkBindCount VkSparseImageOpaqueMemoryBindInfo where + type VkBindCountMType VkSparseImageOpaqueMemoryBindInfo = Word32 + + {-# NOINLINE vkBindCount #-} + vkBindCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSparseImageOpaqueMemoryBindInfo, bindCount}) + + {-# INLINE vkBindCountByteOffset #-} + vkBindCountByteOffset ~_ + = #{offset VkSparseImageOpaqueMemoryBindInfo, bindCount} + + {-# INLINE readVkBindCount #-} + readVkBindCount p + = peekByteOff p #{offset VkSparseImageOpaqueMemoryBindInfo, bindCount} + + {-# INLINE writeVkBindCount #-} + writeVkBindCount p + = pokeByteOff p #{offset VkSparseImageOpaqueMemoryBindInfo, bindCount} + +instance {-# OVERLAPPING #-} + HasField "bindCount" VkSparseImageOpaqueMemoryBindInfo where + type FieldType "bindCount" VkSparseImageOpaqueMemoryBindInfo = + Word32 + type FieldOptional "bindCount" VkSparseImageOpaqueMemoryBindInfo = + 'False -- ' closing tick for hsc2hs + type FieldOffset "bindCount" VkSparseImageOpaqueMemoryBindInfo = + #{offset VkSparseImageOpaqueMemoryBindInfo, bindCount} + type FieldIsArray "bindCount" VkSparseImageOpaqueMemoryBindInfo = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSparseImageOpaqueMemoryBindInfo, bindCount} + +instance CanReadField "bindCount" VkSparseImageOpaqueMemoryBindInfo + where + {-# INLINE getField #-} + getField = vkBindCount + + {-# INLINE readField #-} + readField = readVkBindCount + +instance CanWriteField "bindCount" + VkSparseImageOpaqueMemoryBindInfo + where + {-# INLINE writeField #-} + writeField = writeVkBindCount + +instance {-# OVERLAPPING #-} + HasVkPBinds VkSparseImageOpaqueMemoryBindInfo where + type VkPBindsMType VkSparseImageOpaqueMemoryBindInfo = + Ptr VkSparseMemoryBind + + {-# NOINLINE vkPBinds #-} + vkPBinds x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSparseImageOpaqueMemoryBindInfo, pBinds}) + + {-# INLINE vkPBindsByteOffset #-} + vkPBindsByteOffset ~_ + = #{offset VkSparseImageOpaqueMemoryBindInfo, pBinds} + + {-# INLINE readVkPBinds #-} + readVkPBinds p + = peekByteOff p #{offset VkSparseImageOpaqueMemoryBindInfo, pBinds} + + {-# INLINE writeVkPBinds #-} + writeVkPBinds p + = pokeByteOff p #{offset VkSparseImageOpaqueMemoryBindInfo, pBinds} + +instance {-# OVERLAPPING #-} + HasField "pBinds" VkSparseImageOpaqueMemoryBindInfo where + type FieldType "pBinds" VkSparseImageOpaqueMemoryBindInfo = + Ptr VkSparseMemoryBind + type FieldOptional "pBinds" VkSparseImageOpaqueMemoryBindInfo = + 'False -- ' closing tick for hsc2hs + type FieldOffset "pBinds" VkSparseImageOpaqueMemoryBindInfo = + #{offset VkSparseImageOpaqueMemoryBindInfo, pBinds} + type FieldIsArray "pBinds" VkSparseImageOpaqueMemoryBindInfo = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSparseImageOpaqueMemoryBindInfo, pBinds} + +instance CanReadField "pBinds" VkSparseImageOpaqueMemoryBindInfo + where + {-# INLINE getField #-} + getField = vkPBinds + + {-# INLINE readField #-} + readField = readVkPBinds + +instance CanWriteField "pBinds" VkSparseImageOpaqueMemoryBindInfo + where + {-# INLINE writeField #-} + writeField = writeVkPBinds + +instance Show VkSparseImageOpaqueMemoryBindInfo where + showsPrec d x + = showString "VkSparseImageOpaqueMemoryBindInfo {" . + showString "vkImage = " . + showsPrec d (vkImage x) . + showString ", " . + showString "vkBindCount = " . + showsPrec d (vkBindCount x) . + showString ", " . + showString "vkPBinds = " . showsPrec d (vkPBinds x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkSparseMemoryBind.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkSparseMemoryBind.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkSparseMemoryBind.hsc @@ -0,0 +1,322 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkSparseMemoryBind + (VkSparseMemoryBind(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.BaseTypes (VkDeviceSize) +import Graphics.Vulkan.Types.Enum.VkSparseMemoryBindFlags (VkSparseMemoryBindFlags) +import Graphics.Vulkan.Types.Handles (VkDeviceMemory) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkSparseMemoryBind { +-- > VkDeviceSize resourceOffset; +-- > VkDeviceSize size; +-- > VkDeviceMemory memory; +-- > VkDeviceSize memoryOffset; +-- > VkSparseMemoryBindFlagsflags; +-- > } VkSparseMemoryBind; +-- +-- +data VkSparseMemoryBind = VkSparseMemoryBind## Addr## ByteArray## + +instance Eq VkSparseMemoryBind where + (VkSparseMemoryBind## a _) == x@(VkSparseMemoryBind## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkSparseMemoryBind where + (VkSparseMemoryBind## a _) `compare` x@(VkSparseMemoryBind## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkSparseMemoryBind where + sizeOf ~_ = #{size VkSparseMemoryBind} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkSparseMemoryBind} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkSparseMemoryBind where + unsafeAddr (VkSparseMemoryBind## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkSparseMemoryBind## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkSparseMemoryBind## (plusAddr## (byteArrayContents## b) off) b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkSparseMemoryBind where + type StructFields VkSparseMemoryBind = + '["resourceOffset", "size", "memory", "memoryOffset", "flags"] -- ' closing tick for hsc2hs + type CUnionType VkSparseMemoryBind = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkSparseMemoryBind = 'False -- ' closing tick for hsc2hs + type StructExtends VkSparseMemoryBind = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkResourceOffset VkSparseMemoryBind + where + type VkResourceOffsetMType VkSparseMemoryBind = VkDeviceSize + + {-# NOINLINE vkResourceOffset #-} + vkResourceOffset x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSparseMemoryBind, resourceOffset}) + + {-# INLINE vkResourceOffsetByteOffset #-} + vkResourceOffsetByteOffset ~_ + = #{offset VkSparseMemoryBind, resourceOffset} + + {-# INLINE readVkResourceOffset #-} + readVkResourceOffset p + = peekByteOff p #{offset VkSparseMemoryBind, resourceOffset} + + {-# INLINE writeVkResourceOffset #-} + writeVkResourceOffset p + = pokeByteOff p #{offset VkSparseMemoryBind, resourceOffset} + +instance {-# OVERLAPPING #-} + HasField "resourceOffset" VkSparseMemoryBind where + type FieldType "resourceOffset" VkSparseMemoryBind = VkDeviceSize + type FieldOptional "resourceOffset" VkSparseMemoryBind = 'False -- ' closing tick for hsc2hs + type FieldOffset "resourceOffset" VkSparseMemoryBind = + #{offset VkSparseMemoryBind, resourceOffset} + type FieldIsArray "resourceOffset" VkSparseMemoryBind = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSparseMemoryBind, resourceOffset} + +instance CanReadField "resourceOffset" VkSparseMemoryBind where + {-# INLINE getField #-} + getField = vkResourceOffset + + {-# INLINE readField #-} + readField = readVkResourceOffset + +instance CanWriteField "resourceOffset" VkSparseMemoryBind where + {-# INLINE writeField #-} + writeField = writeVkResourceOffset + +instance {-# OVERLAPPING #-} HasVkSize VkSparseMemoryBind where + type VkSizeMType VkSparseMemoryBind = VkDeviceSize + + {-# NOINLINE vkSize #-} + vkSize x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSparseMemoryBind, size}) + + {-# INLINE vkSizeByteOffset #-} + vkSizeByteOffset ~_ + = #{offset VkSparseMemoryBind, size} + + {-# INLINE readVkSize #-} + readVkSize p + = peekByteOff p #{offset VkSparseMemoryBind, size} + + {-# INLINE writeVkSize #-} + writeVkSize p + = pokeByteOff p #{offset VkSparseMemoryBind, size} + +instance {-# OVERLAPPING #-} HasField "size" VkSparseMemoryBind + where + type FieldType "size" VkSparseMemoryBind = VkDeviceSize + type FieldOptional "size" VkSparseMemoryBind = 'False -- ' closing tick for hsc2hs + type FieldOffset "size" VkSparseMemoryBind = + #{offset VkSparseMemoryBind, size} + type FieldIsArray "size" VkSparseMemoryBind = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkSparseMemoryBind, size} + +instance CanReadField "size" VkSparseMemoryBind where + {-# INLINE getField #-} + getField = vkSize + + {-# INLINE readField #-} + readField = readVkSize + +instance CanWriteField "size" VkSparseMemoryBind where + {-# INLINE writeField #-} + writeField = writeVkSize + +instance {-# OVERLAPPING #-} HasVkMemory VkSparseMemoryBind where + type VkMemoryMType VkSparseMemoryBind = VkDeviceMemory + + {-# NOINLINE vkMemory #-} + vkMemory x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSparseMemoryBind, memory}) + + {-# INLINE vkMemoryByteOffset #-} + vkMemoryByteOffset ~_ + = #{offset VkSparseMemoryBind, memory} + + {-# INLINE readVkMemory #-} + readVkMemory p + = peekByteOff p #{offset VkSparseMemoryBind, memory} + + {-# INLINE writeVkMemory #-} + writeVkMemory p + = pokeByteOff p #{offset VkSparseMemoryBind, memory} + +instance {-# OVERLAPPING #-} HasField "memory" VkSparseMemoryBind + where + type FieldType "memory" VkSparseMemoryBind = VkDeviceMemory + type FieldOptional "memory" VkSparseMemoryBind = 'True -- ' closing tick for hsc2hs + type FieldOffset "memory" VkSparseMemoryBind = + #{offset VkSparseMemoryBind, memory} + type FieldIsArray "memory" VkSparseMemoryBind = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkSparseMemoryBind, memory} + +instance CanReadField "memory" VkSparseMemoryBind where + {-# INLINE getField #-} + getField = vkMemory + + {-# INLINE readField #-} + readField = readVkMemory + +instance CanWriteField "memory" VkSparseMemoryBind where + {-# INLINE writeField #-} + writeField = writeVkMemory + +instance {-# OVERLAPPING #-} HasVkMemoryOffset VkSparseMemoryBind + where + type VkMemoryOffsetMType VkSparseMemoryBind = VkDeviceSize + + {-# NOINLINE vkMemoryOffset #-} + vkMemoryOffset x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSparseMemoryBind, memoryOffset}) + + {-# INLINE vkMemoryOffsetByteOffset #-} + vkMemoryOffsetByteOffset ~_ + = #{offset VkSparseMemoryBind, memoryOffset} + + {-# INLINE readVkMemoryOffset #-} + readVkMemoryOffset p + = peekByteOff p #{offset VkSparseMemoryBind, memoryOffset} + + {-# INLINE writeVkMemoryOffset #-} + writeVkMemoryOffset p + = pokeByteOff p #{offset VkSparseMemoryBind, memoryOffset} + +instance {-# OVERLAPPING #-} + HasField "memoryOffset" VkSparseMemoryBind where + type FieldType "memoryOffset" VkSparseMemoryBind = VkDeviceSize + type FieldOptional "memoryOffset" VkSparseMemoryBind = 'False -- ' closing tick for hsc2hs + type FieldOffset "memoryOffset" VkSparseMemoryBind = + #{offset VkSparseMemoryBind, memoryOffset} + type FieldIsArray "memoryOffset" VkSparseMemoryBind = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSparseMemoryBind, memoryOffset} + +instance CanReadField "memoryOffset" VkSparseMemoryBind where + {-# INLINE getField #-} + getField = vkMemoryOffset + + {-# INLINE readField #-} + readField = readVkMemoryOffset + +instance CanWriteField "memoryOffset" VkSparseMemoryBind where + {-# INLINE writeField #-} + writeField = writeVkMemoryOffset + +instance {-# OVERLAPPING #-} HasVkFlags VkSparseMemoryBind where + type VkFlagsMType VkSparseMemoryBind = VkSparseMemoryBindFlags + + {-# NOINLINE vkFlags #-} + vkFlags x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSparseMemoryBind, flags}) + + {-# INLINE vkFlagsByteOffset #-} + vkFlagsByteOffset ~_ + = #{offset VkSparseMemoryBind, flags} + + {-# INLINE readVkFlags #-} + readVkFlags p + = peekByteOff p #{offset VkSparseMemoryBind, flags} + + {-# INLINE writeVkFlags #-} + writeVkFlags p + = pokeByteOff p #{offset VkSparseMemoryBind, flags} + +instance {-# OVERLAPPING #-} HasField "flags" VkSparseMemoryBind + where + type FieldType "flags" VkSparseMemoryBind = VkSparseMemoryBindFlags + type FieldOptional "flags" VkSparseMemoryBind = 'True -- ' closing tick for hsc2hs + type FieldOffset "flags" VkSparseMemoryBind = + #{offset VkSparseMemoryBind, flags} + type FieldIsArray "flags" VkSparseMemoryBind = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkSparseMemoryBind, flags} + +instance CanReadField "flags" VkSparseMemoryBind where + {-# INLINE getField #-} + getField = vkFlags + + {-# INLINE readField #-} + readField = readVkFlags + +instance CanWriteField "flags" VkSparseMemoryBind where + {-# INLINE writeField #-} + writeField = writeVkFlags + +instance Show VkSparseMemoryBind where + showsPrec d x + = showString "VkSparseMemoryBind {" . + showString "vkResourceOffset = " . + showsPrec d (vkResourceOffset x) . + showString ", " . + showString "vkSize = " . + showsPrec d (vkSize x) . + showString ", " . + showString "vkMemory = " . + showsPrec d (vkMemory x) . + showString ", " . + showString "vkMemoryOffset = " . + showsPrec d (vkMemoryOffset x) . + showString ", " . + showString "vkFlags = " . + showsPrec d (vkFlags x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkSpecializationInfo.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkSpecializationInfo.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkSpecializationInfo.hsc @@ -0,0 +1,273 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkSpecializationInfo + (VkSpecializationInfo(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Struct.VkSpecializationMapEntry (VkSpecializationMapEntry) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkSpecializationInfo { +-- > uint32_t mapEntryCount; +-- > const VkSpecializationMapEntry* pMapEntries; +-- > size_t dataSize; +-- > const void* pData; +-- > } VkSpecializationInfo; +-- +-- +data VkSpecializationInfo = VkSpecializationInfo## Addr## ByteArray## + +instance Eq VkSpecializationInfo where + (VkSpecializationInfo## a _) == x@(VkSpecializationInfo## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkSpecializationInfo where + (VkSpecializationInfo## a _) `compare` x@(VkSpecializationInfo## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkSpecializationInfo where + sizeOf ~_ = #{size VkSpecializationInfo} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkSpecializationInfo} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkSpecializationInfo where + unsafeAddr (VkSpecializationInfo## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkSpecializationInfo## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkSpecializationInfo## (plusAddr## (byteArrayContents## b) off) b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkSpecializationInfo where + type StructFields VkSpecializationInfo = + '["mapEntryCount", "pMapEntries", "dataSize", "pData"] -- ' closing tick for hsc2hs + type CUnionType VkSpecializationInfo = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkSpecializationInfo = 'False -- ' closing tick for hsc2hs + type StructExtends VkSpecializationInfo = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkMapEntryCount VkSpecializationInfo where + type VkMapEntryCountMType VkSpecializationInfo = Word32 + + {-# NOINLINE vkMapEntryCount #-} + vkMapEntryCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSpecializationInfo, mapEntryCount}) + + {-# INLINE vkMapEntryCountByteOffset #-} + vkMapEntryCountByteOffset ~_ + = #{offset VkSpecializationInfo, mapEntryCount} + + {-# INLINE readVkMapEntryCount #-} + readVkMapEntryCount p + = peekByteOff p #{offset VkSpecializationInfo, mapEntryCount} + + {-# INLINE writeVkMapEntryCount #-} + writeVkMapEntryCount p + = pokeByteOff p #{offset VkSpecializationInfo, mapEntryCount} + +instance {-# OVERLAPPING #-} + HasField "mapEntryCount" VkSpecializationInfo where + type FieldType "mapEntryCount" VkSpecializationInfo = Word32 + type FieldOptional "mapEntryCount" VkSpecializationInfo = 'True -- ' closing tick for hsc2hs + type FieldOffset "mapEntryCount" VkSpecializationInfo = + #{offset VkSpecializationInfo, mapEntryCount} + type FieldIsArray "mapEntryCount" VkSpecializationInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSpecializationInfo, mapEntryCount} + +instance CanReadField "mapEntryCount" VkSpecializationInfo where + {-# INLINE getField #-} + getField = vkMapEntryCount + + {-# INLINE readField #-} + readField = readVkMapEntryCount + +instance CanWriteField "mapEntryCount" VkSpecializationInfo where + {-# INLINE writeField #-} + writeField = writeVkMapEntryCount + +instance {-# OVERLAPPING #-} HasVkPMapEntries VkSpecializationInfo + where + type VkPMapEntriesMType VkSpecializationInfo = + Ptr VkSpecializationMapEntry + + {-# NOINLINE vkPMapEntries #-} + vkPMapEntries x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSpecializationInfo, pMapEntries}) + + {-# INLINE vkPMapEntriesByteOffset #-} + vkPMapEntriesByteOffset ~_ + = #{offset VkSpecializationInfo, pMapEntries} + + {-# INLINE readVkPMapEntries #-} + readVkPMapEntries p + = peekByteOff p #{offset VkSpecializationInfo, pMapEntries} + + {-# INLINE writeVkPMapEntries #-} + writeVkPMapEntries p + = pokeByteOff p #{offset VkSpecializationInfo, pMapEntries} + +instance {-# OVERLAPPING #-} + HasField "pMapEntries" VkSpecializationInfo where + type FieldType "pMapEntries" VkSpecializationInfo = + Ptr VkSpecializationMapEntry + type FieldOptional "pMapEntries" VkSpecializationInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "pMapEntries" VkSpecializationInfo = + #{offset VkSpecializationInfo, pMapEntries} + type FieldIsArray "pMapEntries" VkSpecializationInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSpecializationInfo, pMapEntries} + +instance CanReadField "pMapEntries" VkSpecializationInfo where + {-# INLINE getField #-} + getField = vkPMapEntries + + {-# INLINE readField #-} + readField = readVkPMapEntries + +instance CanWriteField "pMapEntries" VkSpecializationInfo where + {-# INLINE writeField #-} + writeField = writeVkPMapEntries + +instance {-# OVERLAPPING #-} HasVkDataSize VkSpecializationInfo + where + type VkDataSizeMType VkSpecializationInfo = CSize + + {-# NOINLINE vkDataSize #-} + vkDataSize x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSpecializationInfo, dataSize}) + + {-# INLINE vkDataSizeByteOffset #-} + vkDataSizeByteOffset ~_ + = #{offset VkSpecializationInfo, dataSize} + + {-# INLINE readVkDataSize #-} + readVkDataSize p + = peekByteOff p #{offset VkSpecializationInfo, dataSize} + + {-# INLINE writeVkDataSize #-} + writeVkDataSize p + = pokeByteOff p #{offset VkSpecializationInfo, dataSize} + +instance {-# OVERLAPPING #-} + HasField "dataSize" VkSpecializationInfo where + type FieldType "dataSize" VkSpecializationInfo = CSize + type FieldOptional "dataSize" VkSpecializationInfo = 'True -- ' closing tick for hsc2hs + type FieldOffset "dataSize" VkSpecializationInfo = + #{offset VkSpecializationInfo, dataSize} + type FieldIsArray "dataSize" VkSpecializationInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkSpecializationInfo, dataSize} + +instance CanReadField "dataSize" VkSpecializationInfo where + {-# INLINE getField #-} + getField = vkDataSize + + {-# INLINE readField #-} + readField = readVkDataSize + +instance CanWriteField "dataSize" VkSpecializationInfo where + {-# INLINE writeField #-} + writeField = writeVkDataSize + +instance {-# OVERLAPPING #-} HasVkPData VkSpecializationInfo where + type VkPDataMType VkSpecializationInfo = Ptr Void + + {-# NOINLINE vkPData #-} + vkPData x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSpecializationInfo, pData}) + + {-# INLINE vkPDataByteOffset #-} + vkPDataByteOffset ~_ + = #{offset VkSpecializationInfo, pData} + + {-# INLINE readVkPData #-} + readVkPData p + = peekByteOff p #{offset VkSpecializationInfo, pData} + + {-# INLINE writeVkPData #-} + writeVkPData p + = pokeByteOff p #{offset VkSpecializationInfo, pData} + +instance {-# OVERLAPPING #-} HasField "pData" VkSpecializationInfo + where + type FieldType "pData" VkSpecializationInfo = Ptr Void + type FieldOptional "pData" VkSpecializationInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "pData" VkSpecializationInfo = + #{offset VkSpecializationInfo, pData} + type FieldIsArray "pData" VkSpecializationInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkSpecializationInfo, pData} + +instance CanReadField "pData" VkSpecializationInfo where + {-# INLINE getField #-} + getField = vkPData + + {-# INLINE readField #-} + readField = readVkPData + +instance CanWriteField "pData" VkSpecializationInfo where + {-# INLINE writeField #-} + writeField = writeVkPData + +instance Show VkSpecializationInfo where + showsPrec d x + = showString "VkSpecializationInfo {" . + showString "vkMapEntryCount = " . + showsPrec d (vkMapEntryCount x) . + showString ", " . + showString "vkPMapEntries = " . + showsPrec d (vkPMapEntries x) . + showString ", " . + showString "vkDataSize = " . + showsPrec d (vkDataSize x) . + showString ", " . + showString "vkPData = " . showsPrec d (vkPData x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkSpecializationMapEntry.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkSpecializationMapEntry.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkSpecializationMapEntry.hsc @@ -0,0 +1,223 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkSpecializationMapEntry + (VkSpecializationMapEntry(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkSpecializationMapEntry { +-- > uint32_t constantID; +-- > uint32_t offset; +-- > size_t size; +-- > } VkSpecializationMapEntry; +-- +-- +data VkSpecializationMapEntry = VkSpecializationMapEntry## Addr## + ByteArray## + +instance Eq VkSpecializationMapEntry where + (VkSpecializationMapEntry## a _) == + x@(VkSpecializationMapEntry## b _) = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkSpecializationMapEntry where + (VkSpecializationMapEntry## a _) `compare` + x@(VkSpecializationMapEntry## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkSpecializationMapEntry where + sizeOf ~_ = #{size VkSpecializationMapEntry} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkSpecializationMapEntry} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkSpecializationMapEntry where + unsafeAddr (VkSpecializationMapEntry## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkSpecializationMapEntry## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkSpecializationMapEntry## (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkSpecializationMapEntry where + type StructFields VkSpecializationMapEntry = + '["constantID", "offset", "size"] -- ' closing tick for hsc2hs + type CUnionType VkSpecializationMapEntry = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkSpecializationMapEntry = 'False -- ' closing tick for hsc2hs + type StructExtends VkSpecializationMapEntry = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkConstantID VkSpecializationMapEntry where + type VkConstantIDMType VkSpecializationMapEntry = Word32 + + {-# NOINLINE vkConstantID #-} + vkConstantID x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSpecializationMapEntry, constantID}) + + {-# INLINE vkConstantIDByteOffset #-} + vkConstantIDByteOffset ~_ + = #{offset VkSpecializationMapEntry, constantID} + + {-# INLINE readVkConstantID #-} + readVkConstantID p + = peekByteOff p #{offset VkSpecializationMapEntry, constantID} + + {-# INLINE writeVkConstantID #-} + writeVkConstantID p + = pokeByteOff p #{offset VkSpecializationMapEntry, constantID} + +instance {-# OVERLAPPING #-} + HasField "constantID" VkSpecializationMapEntry where + type FieldType "constantID" VkSpecializationMapEntry = Word32 + type FieldOptional "constantID" VkSpecializationMapEntry = 'False -- ' closing tick for hsc2hs + type FieldOffset "constantID" VkSpecializationMapEntry = + #{offset VkSpecializationMapEntry, constantID} + type FieldIsArray "constantID" VkSpecializationMapEntry = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSpecializationMapEntry, constantID} + +instance CanReadField "constantID" VkSpecializationMapEntry where + {-# INLINE getField #-} + getField = vkConstantID + + {-# INLINE readField #-} + readField = readVkConstantID + +instance CanWriteField "constantID" VkSpecializationMapEntry where + {-# INLINE writeField #-} + writeField = writeVkConstantID + +instance {-# OVERLAPPING #-} HasVkOffset VkSpecializationMapEntry + where + type VkOffsetMType VkSpecializationMapEntry = Word32 + + {-# NOINLINE vkOffset #-} + vkOffset x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSpecializationMapEntry, offset}) + + {-# INLINE vkOffsetByteOffset #-} + vkOffsetByteOffset ~_ + = #{offset VkSpecializationMapEntry, offset} + + {-# INLINE readVkOffset #-} + readVkOffset p + = peekByteOff p #{offset VkSpecializationMapEntry, offset} + + {-# INLINE writeVkOffset #-} + writeVkOffset p + = pokeByteOff p #{offset VkSpecializationMapEntry, offset} + +instance {-# OVERLAPPING #-} + HasField "offset" VkSpecializationMapEntry where + type FieldType "offset" VkSpecializationMapEntry = Word32 + type FieldOptional "offset" VkSpecializationMapEntry = 'False -- ' closing tick for hsc2hs + type FieldOffset "offset" VkSpecializationMapEntry = + #{offset VkSpecializationMapEntry, offset} + type FieldIsArray "offset" VkSpecializationMapEntry = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSpecializationMapEntry, offset} + +instance CanReadField "offset" VkSpecializationMapEntry where + {-# INLINE getField #-} + getField = vkOffset + + {-# INLINE readField #-} + readField = readVkOffset + +instance CanWriteField "offset" VkSpecializationMapEntry where + {-# INLINE writeField #-} + writeField = writeVkOffset + +instance {-# OVERLAPPING #-} HasVkSize VkSpecializationMapEntry + where + type VkSizeMType VkSpecializationMapEntry = CSize + + {-# NOINLINE vkSize #-} + vkSize x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSpecializationMapEntry, size}) + + {-# INLINE vkSizeByteOffset #-} + vkSizeByteOffset ~_ + = #{offset VkSpecializationMapEntry, size} + + {-# INLINE readVkSize #-} + readVkSize p + = peekByteOff p #{offset VkSpecializationMapEntry, size} + + {-# INLINE writeVkSize #-} + writeVkSize p + = pokeByteOff p #{offset VkSpecializationMapEntry, size} + +instance {-# OVERLAPPING #-} + HasField "size" VkSpecializationMapEntry where + type FieldType "size" VkSpecializationMapEntry = CSize + type FieldOptional "size" VkSpecializationMapEntry = 'False -- ' closing tick for hsc2hs + type FieldOffset "size" VkSpecializationMapEntry = + #{offset VkSpecializationMapEntry, size} + type FieldIsArray "size" VkSpecializationMapEntry = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkSpecializationMapEntry, size} + +instance CanReadField "size" VkSpecializationMapEntry where + {-# INLINE getField #-} + getField = vkSize + + {-# INLINE readField #-} + readField = readVkSize + +instance CanWriteField "size" VkSpecializationMapEntry where + {-# INLINE writeField #-} + writeField = writeVkSize + +instance Show VkSpecializationMapEntry where + showsPrec d x + = showString "VkSpecializationMapEntry {" . + showString "vkConstantID = " . + showsPrec d (vkConstantID x) . + showString ", " . + showString "vkOffset = " . + showsPrec d (vkOffset x) . + showString ", " . + showString "vkSize = " . showsPrec d (vkSize x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkStencilOpState.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkStencilOpState.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkStencilOpState.hsc @@ -0,0 +1,418 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkStencilOpState + (VkStencilOpState(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkCompareOp (VkCompareOp) +import Graphics.Vulkan.Types.Enum.VkStencilOp (VkStencilOp) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkStencilOpState { +-- > VkStencilOp failOp; +-- > VkStencilOp passOp; +-- > VkStencilOp depthFailOp; +-- > VkCompareOp compareOp; +-- > uint32_t compareMask; +-- > uint32_t writeMask; +-- > uint32_t reference; +-- > } VkStencilOpState; +-- +-- +data VkStencilOpState = VkStencilOpState## Addr## ByteArray## + +instance Eq VkStencilOpState where + (VkStencilOpState## a _) == x@(VkStencilOpState## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkStencilOpState where + (VkStencilOpState## a _) `compare` x@(VkStencilOpState## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkStencilOpState where + sizeOf ~_ = #{size VkStencilOpState} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkStencilOpState} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkStencilOpState where + unsafeAddr (VkStencilOpState## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkStencilOpState## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkStencilOpState## (plusAddr## (byteArrayContents## b) off) b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkStencilOpState where + type StructFields VkStencilOpState = + '["failOp", "passOp", "depthFailOp", "compareOp", "compareMask", -- ' closing tick for hsc2hs + "writeMask", "reference"] + type CUnionType VkStencilOpState = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkStencilOpState = 'False -- ' closing tick for hsc2hs + type StructExtends VkStencilOpState = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkFailOp VkStencilOpState where + type VkFailOpMType VkStencilOpState = VkStencilOp + + {-# NOINLINE vkFailOp #-} + vkFailOp x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkStencilOpState, failOp}) + + {-# INLINE vkFailOpByteOffset #-} + vkFailOpByteOffset ~_ + = #{offset VkStencilOpState, failOp} + + {-# INLINE readVkFailOp #-} + readVkFailOp p + = peekByteOff p #{offset VkStencilOpState, failOp} + + {-# INLINE writeVkFailOp #-} + writeVkFailOp p + = pokeByteOff p #{offset VkStencilOpState, failOp} + +instance {-# OVERLAPPING #-} HasField "failOp" VkStencilOpState + where + type FieldType "failOp" VkStencilOpState = VkStencilOp + type FieldOptional "failOp" VkStencilOpState = 'False -- ' closing tick for hsc2hs + type FieldOffset "failOp" VkStencilOpState = + #{offset VkStencilOpState, failOp} + type FieldIsArray "failOp" VkStencilOpState = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkStencilOpState, failOp} + +instance CanReadField "failOp" VkStencilOpState where + {-# INLINE getField #-} + getField = vkFailOp + + {-# INLINE readField #-} + readField = readVkFailOp + +instance CanWriteField "failOp" VkStencilOpState where + {-# INLINE writeField #-} + writeField = writeVkFailOp + +instance {-# OVERLAPPING #-} HasVkPassOp VkStencilOpState where + type VkPassOpMType VkStencilOpState = VkStencilOp + + {-# NOINLINE vkPassOp #-} + vkPassOp x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkStencilOpState, passOp}) + + {-# INLINE vkPassOpByteOffset #-} + vkPassOpByteOffset ~_ + = #{offset VkStencilOpState, passOp} + + {-# INLINE readVkPassOp #-} + readVkPassOp p + = peekByteOff p #{offset VkStencilOpState, passOp} + + {-# INLINE writeVkPassOp #-} + writeVkPassOp p + = pokeByteOff p #{offset VkStencilOpState, passOp} + +instance {-# OVERLAPPING #-} HasField "passOp" VkStencilOpState + where + type FieldType "passOp" VkStencilOpState = VkStencilOp + type FieldOptional "passOp" VkStencilOpState = 'False -- ' closing tick for hsc2hs + type FieldOffset "passOp" VkStencilOpState = + #{offset VkStencilOpState, passOp} + type FieldIsArray "passOp" VkStencilOpState = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkStencilOpState, passOp} + +instance CanReadField "passOp" VkStencilOpState where + {-# INLINE getField #-} + getField = vkPassOp + + {-# INLINE readField #-} + readField = readVkPassOp + +instance CanWriteField "passOp" VkStencilOpState where + {-# INLINE writeField #-} + writeField = writeVkPassOp + +instance {-# OVERLAPPING #-} HasVkDepthFailOp VkStencilOpState + where + type VkDepthFailOpMType VkStencilOpState = VkStencilOp + + {-# NOINLINE vkDepthFailOp #-} + vkDepthFailOp x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkStencilOpState, depthFailOp}) + + {-# INLINE vkDepthFailOpByteOffset #-} + vkDepthFailOpByteOffset ~_ + = #{offset VkStencilOpState, depthFailOp} + + {-# INLINE readVkDepthFailOp #-} + readVkDepthFailOp p + = peekByteOff p #{offset VkStencilOpState, depthFailOp} + + {-# INLINE writeVkDepthFailOp #-} + writeVkDepthFailOp p + = pokeByteOff p #{offset VkStencilOpState, depthFailOp} + +instance {-# OVERLAPPING #-} + HasField "depthFailOp" VkStencilOpState where + type FieldType "depthFailOp" VkStencilOpState = VkStencilOp + type FieldOptional "depthFailOp" VkStencilOpState = 'False -- ' closing tick for hsc2hs + type FieldOffset "depthFailOp" VkStencilOpState = + #{offset VkStencilOpState, depthFailOp} + type FieldIsArray "depthFailOp" VkStencilOpState = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkStencilOpState, depthFailOp} + +instance CanReadField "depthFailOp" VkStencilOpState where + {-# INLINE getField #-} + getField = vkDepthFailOp + + {-# INLINE readField #-} + readField = readVkDepthFailOp + +instance CanWriteField "depthFailOp" VkStencilOpState where + {-# INLINE writeField #-} + writeField = writeVkDepthFailOp + +instance {-# OVERLAPPING #-} HasVkCompareOp VkStencilOpState where + type VkCompareOpMType VkStencilOpState = VkCompareOp + + {-# NOINLINE vkCompareOp #-} + vkCompareOp x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkStencilOpState, compareOp}) + + {-# INLINE vkCompareOpByteOffset #-} + vkCompareOpByteOffset ~_ + = #{offset VkStencilOpState, compareOp} + + {-# INLINE readVkCompareOp #-} + readVkCompareOp p + = peekByteOff p #{offset VkStencilOpState, compareOp} + + {-# INLINE writeVkCompareOp #-} + writeVkCompareOp p + = pokeByteOff p #{offset VkStencilOpState, compareOp} + +instance {-# OVERLAPPING #-} HasField "compareOp" VkStencilOpState + where + type FieldType "compareOp" VkStencilOpState = VkCompareOp + type FieldOptional "compareOp" VkStencilOpState = 'False -- ' closing tick for hsc2hs + type FieldOffset "compareOp" VkStencilOpState = + #{offset VkStencilOpState, compareOp} + type FieldIsArray "compareOp" VkStencilOpState = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkStencilOpState, compareOp} + +instance CanReadField "compareOp" VkStencilOpState where + {-# INLINE getField #-} + getField = vkCompareOp + + {-# INLINE readField #-} + readField = readVkCompareOp + +instance CanWriteField "compareOp" VkStencilOpState where + {-# INLINE writeField #-} + writeField = writeVkCompareOp + +instance {-# OVERLAPPING #-} HasVkCompareMask VkStencilOpState + where + type VkCompareMaskMType VkStencilOpState = Word32 + + {-# NOINLINE vkCompareMask #-} + vkCompareMask x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkStencilOpState, compareMask}) + + {-# INLINE vkCompareMaskByteOffset #-} + vkCompareMaskByteOffset ~_ + = #{offset VkStencilOpState, compareMask} + + {-# INLINE readVkCompareMask #-} + readVkCompareMask p + = peekByteOff p #{offset VkStencilOpState, compareMask} + + {-# INLINE writeVkCompareMask #-} + writeVkCompareMask p + = pokeByteOff p #{offset VkStencilOpState, compareMask} + +instance {-# OVERLAPPING #-} + HasField "compareMask" VkStencilOpState where + type FieldType "compareMask" VkStencilOpState = Word32 + type FieldOptional "compareMask" VkStencilOpState = 'False -- ' closing tick for hsc2hs + type FieldOffset "compareMask" VkStencilOpState = + #{offset VkStencilOpState, compareMask} + type FieldIsArray "compareMask" VkStencilOpState = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkStencilOpState, compareMask} + +instance CanReadField "compareMask" VkStencilOpState where + {-# INLINE getField #-} + getField = vkCompareMask + + {-# INLINE readField #-} + readField = readVkCompareMask + +instance CanWriteField "compareMask" VkStencilOpState where + {-# INLINE writeField #-} + writeField = writeVkCompareMask + +instance {-# OVERLAPPING #-} HasVkWriteMask VkStencilOpState where + type VkWriteMaskMType VkStencilOpState = Word32 + + {-# NOINLINE vkWriteMask #-} + vkWriteMask x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkStencilOpState, writeMask}) + + {-# INLINE vkWriteMaskByteOffset #-} + vkWriteMaskByteOffset ~_ + = #{offset VkStencilOpState, writeMask} + + {-# INLINE readVkWriteMask #-} + readVkWriteMask p + = peekByteOff p #{offset VkStencilOpState, writeMask} + + {-# INLINE writeVkWriteMask #-} + writeVkWriteMask p + = pokeByteOff p #{offset VkStencilOpState, writeMask} + +instance {-# OVERLAPPING #-} HasField "writeMask" VkStencilOpState + where + type FieldType "writeMask" VkStencilOpState = Word32 + type FieldOptional "writeMask" VkStencilOpState = 'False -- ' closing tick for hsc2hs + type FieldOffset "writeMask" VkStencilOpState = + #{offset VkStencilOpState, writeMask} + type FieldIsArray "writeMask" VkStencilOpState = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkStencilOpState, writeMask} + +instance CanReadField "writeMask" VkStencilOpState where + {-# INLINE getField #-} + getField = vkWriteMask + + {-# INLINE readField #-} + readField = readVkWriteMask + +instance CanWriteField "writeMask" VkStencilOpState where + {-# INLINE writeField #-} + writeField = writeVkWriteMask + +instance {-# OVERLAPPING #-} HasVkReference VkStencilOpState where + type VkReferenceMType VkStencilOpState = Word32 + + {-# NOINLINE vkReference #-} + vkReference x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkStencilOpState, reference}) + + {-# INLINE vkReferenceByteOffset #-} + vkReferenceByteOffset ~_ + = #{offset VkStencilOpState, reference} + + {-# INLINE readVkReference #-} + readVkReference p + = peekByteOff p #{offset VkStencilOpState, reference} + + {-# INLINE writeVkReference #-} + writeVkReference p + = pokeByteOff p #{offset VkStencilOpState, reference} + +instance {-# OVERLAPPING #-} HasField "reference" VkStencilOpState + where + type FieldType "reference" VkStencilOpState = Word32 + type FieldOptional "reference" VkStencilOpState = 'False -- ' closing tick for hsc2hs + type FieldOffset "reference" VkStencilOpState = + #{offset VkStencilOpState, reference} + type FieldIsArray "reference" VkStencilOpState = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkStencilOpState, reference} + +instance CanReadField "reference" VkStencilOpState where + {-# INLINE getField #-} + getField = vkReference + + {-# INLINE readField #-} + readField = readVkReference + +instance CanWriteField "reference" VkStencilOpState where + {-# INLINE writeField #-} + writeField = writeVkReference + +instance Show VkStencilOpState where + showsPrec d x + = showString "VkStencilOpState {" . + showString "vkFailOp = " . + showsPrec d (vkFailOp x) . + showString ", " . + showString "vkPassOp = " . + showsPrec d (vkPassOp x) . + showString ", " . + showString "vkDepthFailOp = " . + showsPrec d (vkDepthFailOp x) . + showString ", " . + showString "vkCompareOp = " . + showsPrec d (vkCompareOp x) . + showString ", " . + showString "vkCompareMask = " . + showsPrec d (vkCompareMask x) . + showString ", " . + showString "vkWriteMask = " . + showsPrec d (vkWriteMask x) . + showString ", " . + showString "vkReference = " . + showsPrec d (vkReference x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkSubmitInfo.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkSubmitInfo.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkSubmitInfo.hsc @@ -0,0 +1,526 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkSubmitInfo (VkSubmitInfo(..)) + where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkPipelineStageFlags (VkPipelineStageFlags) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Handles (VkCommandBuffer, + VkSemaphore) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkSubmitInfo { +-- > VkStructureType sType; +-- > const void* pNext; +-- > uint32_t waitSemaphoreCount; +-- > const VkSemaphore* pWaitSemaphores; +-- > const VkPipelineStageFlags* pWaitDstStageMask; +-- > uint32_t commandBufferCount; +-- > const VkCommandBuffer* pCommandBuffers; +-- > uint32_t signalSemaphoreCount; +-- > const VkSemaphore* pSignalSemaphores; +-- > } VkSubmitInfo; +-- +-- +data VkSubmitInfo = VkSubmitInfo## Addr## ByteArray## + +instance Eq VkSubmitInfo where + (VkSubmitInfo## a _) == x@(VkSubmitInfo## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkSubmitInfo where + (VkSubmitInfo## a _) `compare` x@(VkSubmitInfo## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkSubmitInfo where + sizeOf ~_ = #{size VkSubmitInfo} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkSubmitInfo} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkSubmitInfo where + unsafeAddr (VkSubmitInfo## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkSubmitInfo## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkSubmitInfo## (plusAddr## (byteArrayContents## b) off) b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkSubmitInfo where + type StructFields VkSubmitInfo = + '["sType", "pNext", "waitSemaphoreCount", "pWaitSemaphores", -- ' closing tick for hsc2hs + "pWaitDstStageMask", "commandBufferCount", "pCommandBuffers", + "signalSemaphoreCount", "pSignalSemaphores"] + type CUnionType VkSubmitInfo = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkSubmitInfo = 'False -- ' closing tick for hsc2hs + type StructExtends VkSubmitInfo = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkSType VkSubmitInfo where + type VkSTypeMType VkSubmitInfo = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSubmitInfo, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ = #{offset VkSubmitInfo, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkSubmitInfo, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkSubmitInfo, sType} + +instance {-# OVERLAPPING #-} HasField "sType" VkSubmitInfo where + type FieldType "sType" VkSubmitInfo = VkStructureType + type FieldOptional "sType" VkSubmitInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkSubmitInfo = + #{offset VkSubmitInfo, sType} + type FieldIsArray "sType" VkSubmitInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkSubmitInfo, sType} + +instance CanReadField "sType" VkSubmitInfo where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkSubmitInfo where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} HasVkPNext VkSubmitInfo where + type VkPNextMType VkSubmitInfo = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSubmitInfo, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ = #{offset VkSubmitInfo, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkSubmitInfo, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkSubmitInfo, pNext} + +instance {-# OVERLAPPING #-} HasField "pNext" VkSubmitInfo where + type FieldType "pNext" VkSubmitInfo = Ptr Void + type FieldOptional "pNext" VkSubmitInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkSubmitInfo = + #{offset VkSubmitInfo, pNext} + type FieldIsArray "pNext" VkSubmitInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkSubmitInfo, pNext} + +instance CanReadField "pNext" VkSubmitInfo where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkSubmitInfo where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} HasVkWaitSemaphoreCount VkSubmitInfo + where + type VkWaitSemaphoreCountMType VkSubmitInfo = Word32 + + {-# NOINLINE vkWaitSemaphoreCount #-} + vkWaitSemaphoreCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSubmitInfo, waitSemaphoreCount}) + + {-# INLINE vkWaitSemaphoreCountByteOffset #-} + vkWaitSemaphoreCountByteOffset ~_ + = #{offset VkSubmitInfo, waitSemaphoreCount} + + {-# INLINE readVkWaitSemaphoreCount #-} + readVkWaitSemaphoreCount p + = peekByteOff p #{offset VkSubmitInfo, waitSemaphoreCount} + + {-# INLINE writeVkWaitSemaphoreCount #-} + writeVkWaitSemaphoreCount p + = pokeByteOff p #{offset VkSubmitInfo, waitSemaphoreCount} + +instance {-# OVERLAPPING #-} + HasField "waitSemaphoreCount" VkSubmitInfo where + type FieldType "waitSemaphoreCount" VkSubmitInfo = Word32 + type FieldOptional "waitSemaphoreCount" VkSubmitInfo = 'True -- ' closing tick for hsc2hs + type FieldOffset "waitSemaphoreCount" VkSubmitInfo = + #{offset VkSubmitInfo, waitSemaphoreCount} + type FieldIsArray "waitSemaphoreCount" VkSubmitInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSubmitInfo, waitSemaphoreCount} + +instance CanReadField "waitSemaphoreCount" VkSubmitInfo where + {-# INLINE getField #-} + getField = vkWaitSemaphoreCount + + {-# INLINE readField #-} + readField = readVkWaitSemaphoreCount + +instance CanWriteField "waitSemaphoreCount" VkSubmitInfo where + {-# INLINE writeField #-} + writeField = writeVkWaitSemaphoreCount + +instance {-# OVERLAPPING #-} HasVkPWaitSemaphores VkSubmitInfo + where + type VkPWaitSemaphoresMType VkSubmitInfo = Ptr VkSemaphore + + {-# NOINLINE vkPWaitSemaphores #-} + vkPWaitSemaphores x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSubmitInfo, pWaitSemaphores}) + + {-# INLINE vkPWaitSemaphoresByteOffset #-} + vkPWaitSemaphoresByteOffset ~_ + = #{offset VkSubmitInfo, pWaitSemaphores} + + {-# INLINE readVkPWaitSemaphores #-} + readVkPWaitSemaphores p + = peekByteOff p #{offset VkSubmitInfo, pWaitSemaphores} + + {-# INLINE writeVkPWaitSemaphores #-} + writeVkPWaitSemaphores p + = pokeByteOff p #{offset VkSubmitInfo, pWaitSemaphores} + +instance {-# OVERLAPPING #-} + HasField "pWaitSemaphores" VkSubmitInfo where + type FieldType "pWaitSemaphores" VkSubmitInfo = Ptr VkSemaphore + type FieldOptional "pWaitSemaphores" VkSubmitInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "pWaitSemaphores" VkSubmitInfo = + #{offset VkSubmitInfo, pWaitSemaphores} + type FieldIsArray "pWaitSemaphores" VkSubmitInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkSubmitInfo, pWaitSemaphores} + +instance CanReadField "pWaitSemaphores" VkSubmitInfo where + {-# INLINE getField #-} + getField = vkPWaitSemaphores + + {-# INLINE readField #-} + readField = readVkPWaitSemaphores + +instance CanWriteField "pWaitSemaphores" VkSubmitInfo where + {-# INLINE writeField #-} + writeField = writeVkPWaitSemaphores + +instance {-# OVERLAPPING #-} HasVkPWaitDstStageMask VkSubmitInfo + where + type VkPWaitDstStageMaskMType VkSubmitInfo = + Ptr VkPipelineStageFlags + + {-# NOINLINE vkPWaitDstStageMask #-} + vkPWaitDstStageMask x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSubmitInfo, pWaitDstStageMask}) + + {-# INLINE vkPWaitDstStageMaskByteOffset #-} + vkPWaitDstStageMaskByteOffset ~_ + = #{offset VkSubmitInfo, pWaitDstStageMask} + + {-# INLINE readVkPWaitDstStageMask #-} + readVkPWaitDstStageMask p + = peekByteOff p #{offset VkSubmitInfo, pWaitDstStageMask} + + {-# INLINE writeVkPWaitDstStageMask #-} + writeVkPWaitDstStageMask p + = pokeByteOff p #{offset VkSubmitInfo, pWaitDstStageMask} + +instance {-# OVERLAPPING #-} + HasField "pWaitDstStageMask" VkSubmitInfo where + type FieldType "pWaitDstStageMask" VkSubmitInfo = + Ptr VkPipelineStageFlags + type FieldOptional "pWaitDstStageMask" VkSubmitInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "pWaitDstStageMask" VkSubmitInfo = + #{offset VkSubmitInfo, pWaitDstStageMask} + type FieldIsArray "pWaitDstStageMask" VkSubmitInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkSubmitInfo, pWaitDstStageMask} + +instance CanReadField "pWaitDstStageMask" VkSubmitInfo where + {-# INLINE getField #-} + getField = vkPWaitDstStageMask + + {-# INLINE readField #-} + readField = readVkPWaitDstStageMask + +instance CanWriteField "pWaitDstStageMask" VkSubmitInfo where + {-# INLINE writeField #-} + writeField = writeVkPWaitDstStageMask + +instance {-# OVERLAPPING #-} HasVkCommandBufferCount VkSubmitInfo + where + type VkCommandBufferCountMType VkSubmitInfo = Word32 + + {-# NOINLINE vkCommandBufferCount #-} + vkCommandBufferCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSubmitInfo, commandBufferCount}) + + {-# INLINE vkCommandBufferCountByteOffset #-} + vkCommandBufferCountByteOffset ~_ + = #{offset VkSubmitInfo, commandBufferCount} + + {-# INLINE readVkCommandBufferCount #-} + readVkCommandBufferCount p + = peekByteOff p #{offset VkSubmitInfo, commandBufferCount} + + {-# INLINE writeVkCommandBufferCount #-} + writeVkCommandBufferCount p + = pokeByteOff p #{offset VkSubmitInfo, commandBufferCount} + +instance {-# OVERLAPPING #-} + HasField "commandBufferCount" VkSubmitInfo where + type FieldType "commandBufferCount" VkSubmitInfo = Word32 + type FieldOptional "commandBufferCount" VkSubmitInfo = 'True -- ' closing tick for hsc2hs + type FieldOffset "commandBufferCount" VkSubmitInfo = + #{offset VkSubmitInfo, commandBufferCount} + type FieldIsArray "commandBufferCount" VkSubmitInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSubmitInfo, commandBufferCount} + +instance CanReadField "commandBufferCount" VkSubmitInfo where + {-# INLINE getField #-} + getField = vkCommandBufferCount + + {-# INLINE readField #-} + readField = readVkCommandBufferCount + +instance CanWriteField "commandBufferCount" VkSubmitInfo where + {-# INLINE writeField #-} + writeField = writeVkCommandBufferCount + +instance {-# OVERLAPPING #-} HasVkPCommandBuffers VkSubmitInfo + where + type VkPCommandBuffersMType VkSubmitInfo = Ptr VkCommandBuffer + + {-# NOINLINE vkPCommandBuffers #-} + vkPCommandBuffers x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSubmitInfo, pCommandBuffers}) + + {-# INLINE vkPCommandBuffersByteOffset #-} + vkPCommandBuffersByteOffset ~_ + = #{offset VkSubmitInfo, pCommandBuffers} + + {-# INLINE readVkPCommandBuffers #-} + readVkPCommandBuffers p + = peekByteOff p #{offset VkSubmitInfo, pCommandBuffers} + + {-# INLINE writeVkPCommandBuffers #-} + writeVkPCommandBuffers p + = pokeByteOff p #{offset VkSubmitInfo, pCommandBuffers} + +instance {-# OVERLAPPING #-} + HasField "pCommandBuffers" VkSubmitInfo where + type FieldType "pCommandBuffers" VkSubmitInfo = Ptr VkCommandBuffer + type FieldOptional "pCommandBuffers" VkSubmitInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "pCommandBuffers" VkSubmitInfo = + #{offset VkSubmitInfo, pCommandBuffers} + type FieldIsArray "pCommandBuffers" VkSubmitInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkSubmitInfo, pCommandBuffers} + +instance CanReadField "pCommandBuffers" VkSubmitInfo where + {-# INLINE getField #-} + getField = vkPCommandBuffers + + {-# INLINE readField #-} + readField = readVkPCommandBuffers + +instance CanWriteField "pCommandBuffers" VkSubmitInfo where + {-# INLINE writeField #-} + writeField = writeVkPCommandBuffers + +instance {-# OVERLAPPING #-} HasVkSignalSemaphoreCount VkSubmitInfo + where + type VkSignalSemaphoreCountMType VkSubmitInfo = Word32 + + {-# NOINLINE vkSignalSemaphoreCount #-} + vkSignalSemaphoreCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSubmitInfo, signalSemaphoreCount}) + + {-# INLINE vkSignalSemaphoreCountByteOffset #-} + vkSignalSemaphoreCountByteOffset ~_ + = #{offset VkSubmitInfo, signalSemaphoreCount} + + {-# INLINE readVkSignalSemaphoreCount #-} + readVkSignalSemaphoreCount p + = peekByteOff p #{offset VkSubmitInfo, signalSemaphoreCount} + + {-# INLINE writeVkSignalSemaphoreCount #-} + writeVkSignalSemaphoreCount p + = pokeByteOff p #{offset VkSubmitInfo, signalSemaphoreCount} + +instance {-# OVERLAPPING #-} + HasField "signalSemaphoreCount" VkSubmitInfo where + type FieldType "signalSemaphoreCount" VkSubmitInfo = Word32 + type FieldOptional "signalSemaphoreCount" VkSubmitInfo = 'True -- ' closing tick for hsc2hs + type FieldOffset "signalSemaphoreCount" VkSubmitInfo = + #{offset VkSubmitInfo, signalSemaphoreCount} + type FieldIsArray "signalSemaphoreCount" VkSubmitInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSubmitInfo, signalSemaphoreCount} + +instance CanReadField "signalSemaphoreCount" VkSubmitInfo where + {-# INLINE getField #-} + getField = vkSignalSemaphoreCount + + {-# INLINE readField #-} + readField = readVkSignalSemaphoreCount + +instance CanWriteField "signalSemaphoreCount" VkSubmitInfo where + {-# INLINE writeField #-} + writeField = writeVkSignalSemaphoreCount + +instance {-# OVERLAPPING #-} HasVkPSignalSemaphores VkSubmitInfo + where + type VkPSignalSemaphoresMType VkSubmitInfo = Ptr VkSemaphore + + {-# NOINLINE vkPSignalSemaphores #-} + vkPSignalSemaphores x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSubmitInfo, pSignalSemaphores}) + + {-# INLINE vkPSignalSemaphoresByteOffset #-} + vkPSignalSemaphoresByteOffset ~_ + = #{offset VkSubmitInfo, pSignalSemaphores} + + {-# INLINE readVkPSignalSemaphores #-} + readVkPSignalSemaphores p + = peekByteOff p #{offset VkSubmitInfo, pSignalSemaphores} + + {-# INLINE writeVkPSignalSemaphores #-} + writeVkPSignalSemaphores p + = pokeByteOff p #{offset VkSubmitInfo, pSignalSemaphores} + +instance {-# OVERLAPPING #-} + HasField "pSignalSemaphores" VkSubmitInfo where + type FieldType "pSignalSemaphores" VkSubmitInfo = Ptr VkSemaphore + type FieldOptional "pSignalSemaphores" VkSubmitInfo = 'False -- ' closing tick for hsc2hs + type FieldOffset "pSignalSemaphores" VkSubmitInfo = + #{offset VkSubmitInfo, pSignalSemaphores} + type FieldIsArray "pSignalSemaphores" VkSubmitInfo = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkSubmitInfo, pSignalSemaphores} + +instance CanReadField "pSignalSemaphores" VkSubmitInfo where + {-# INLINE getField #-} + getField = vkPSignalSemaphores + + {-# INLINE readField #-} + readField = readVkPSignalSemaphores + +instance CanWriteField "pSignalSemaphores" VkSubmitInfo where + {-# INLINE writeField #-} + writeField = writeVkPSignalSemaphores + +instance Show VkSubmitInfo where + showsPrec d x + = showString "VkSubmitInfo {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkWaitSemaphoreCount = " . + showsPrec d (vkWaitSemaphoreCount x) . + showString ", " . + showString "vkPWaitSemaphores = " . + showsPrec d (vkPWaitSemaphores x) . + showString ", " . + showString "vkPWaitDstStageMask = " . + showsPrec d (vkPWaitDstStageMask x) . + showString ", " . + showString "vkCommandBufferCount = " . + showsPrec d (vkCommandBufferCount x) . + showString ", " . + showString "vkPCommandBuffers = " . + showsPrec d (vkPCommandBuffers x) . + showString ", " . + showString "vkSignalSemaphoreCount = " . + showsPrec d (vkSignalSemaphoreCount x) . + showString ", " . + showString "vkPSignalSemaphores = " . + showsPrec d (vkPSignalSemaphores x) + . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkSubpassDependency.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkSubpassDependency.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkSubpassDependency.hsc @@ -0,0 +1,432 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkSubpassDependency + (VkSubpassDependency(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkAccessFlags (VkAccessFlags) +import Graphics.Vulkan.Types.Enum.VkDependencyFlags (VkDependencyFlags) +import Graphics.Vulkan.Types.Enum.VkPipelineStageFlags (VkPipelineStageFlags) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkSubpassDependency { +-- > uint32_t srcSubpass; +-- > uint32_t dstSubpass; +-- > VkPipelineStageFlags srcStageMask; +-- > VkPipelineStageFlags dstStageMask; +-- > VkAccessFlags srcAccessMask; +-- > VkAccessFlags dstAccessMask; +-- > VkDependencyFlags dependencyFlags; +-- > } VkSubpassDependency; +-- +-- +data VkSubpassDependency = VkSubpassDependency## Addr## ByteArray## + +instance Eq VkSubpassDependency where + (VkSubpassDependency## a _) == x@(VkSubpassDependency## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkSubpassDependency where + (VkSubpassDependency## a _) `compare` x@(VkSubpassDependency## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkSubpassDependency where + sizeOf ~_ = #{size VkSubpassDependency} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkSubpassDependency} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkSubpassDependency where + unsafeAddr (VkSubpassDependency## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkSubpassDependency## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkSubpassDependency## (plusAddr## (byteArrayContents## b) off) b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkSubpassDependency where + type StructFields VkSubpassDependency = + '["srcSubpass", "dstSubpass", "srcStageMask", "dstStageMask", -- ' closing tick for hsc2hs + "srcAccessMask", "dstAccessMask", "dependencyFlags"] + type CUnionType VkSubpassDependency = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkSubpassDependency = 'False -- ' closing tick for hsc2hs + type StructExtends VkSubpassDependency = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkSrcSubpass VkSubpassDependency + where + type VkSrcSubpassMType VkSubpassDependency = Word32 + + {-# NOINLINE vkSrcSubpass #-} + vkSrcSubpass x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSubpassDependency, srcSubpass}) + + {-# INLINE vkSrcSubpassByteOffset #-} + vkSrcSubpassByteOffset ~_ + = #{offset VkSubpassDependency, srcSubpass} + + {-# INLINE readVkSrcSubpass #-} + readVkSrcSubpass p + = peekByteOff p #{offset VkSubpassDependency, srcSubpass} + + {-# INLINE writeVkSrcSubpass #-} + writeVkSrcSubpass p + = pokeByteOff p #{offset VkSubpassDependency, srcSubpass} + +instance {-# OVERLAPPING #-} + HasField "srcSubpass" VkSubpassDependency where + type FieldType "srcSubpass" VkSubpassDependency = Word32 + type FieldOptional "srcSubpass" VkSubpassDependency = 'False -- ' closing tick for hsc2hs + type FieldOffset "srcSubpass" VkSubpassDependency = + #{offset VkSubpassDependency, srcSubpass} + type FieldIsArray "srcSubpass" VkSubpassDependency = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkSubpassDependency, srcSubpass} + +instance CanReadField "srcSubpass" VkSubpassDependency where + {-# INLINE getField #-} + getField = vkSrcSubpass + + {-# INLINE readField #-} + readField = readVkSrcSubpass + +instance CanWriteField "srcSubpass" VkSubpassDependency where + {-# INLINE writeField #-} + writeField = writeVkSrcSubpass + +instance {-# OVERLAPPING #-} HasVkDstSubpass VkSubpassDependency + where + type VkDstSubpassMType VkSubpassDependency = Word32 + + {-# NOINLINE vkDstSubpass #-} + vkDstSubpass x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSubpassDependency, dstSubpass}) + + {-# INLINE vkDstSubpassByteOffset #-} + vkDstSubpassByteOffset ~_ + = #{offset VkSubpassDependency, dstSubpass} + + {-# INLINE readVkDstSubpass #-} + readVkDstSubpass p + = peekByteOff p #{offset VkSubpassDependency, dstSubpass} + + {-# INLINE writeVkDstSubpass #-} + writeVkDstSubpass p + = pokeByteOff p #{offset VkSubpassDependency, dstSubpass} + +instance {-# OVERLAPPING #-} + HasField "dstSubpass" VkSubpassDependency where + type FieldType "dstSubpass" VkSubpassDependency = Word32 + type FieldOptional "dstSubpass" VkSubpassDependency = 'False -- ' closing tick for hsc2hs + type FieldOffset "dstSubpass" VkSubpassDependency = + #{offset VkSubpassDependency, dstSubpass} + type FieldIsArray "dstSubpass" VkSubpassDependency = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkSubpassDependency, dstSubpass} + +instance CanReadField "dstSubpass" VkSubpassDependency where + {-# INLINE getField #-} + getField = vkDstSubpass + + {-# INLINE readField #-} + readField = readVkDstSubpass + +instance CanWriteField "dstSubpass" VkSubpassDependency where + {-# INLINE writeField #-} + writeField = writeVkDstSubpass + +instance {-# OVERLAPPING #-} HasVkSrcStageMask VkSubpassDependency + where + type VkSrcStageMaskMType VkSubpassDependency = VkPipelineStageFlags + + {-# NOINLINE vkSrcStageMask #-} + vkSrcStageMask x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSubpassDependency, srcStageMask}) + + {-# INLINE vkSrcStageMaskByteOffset #-} + vkSrcStageMaskByteOffset ~_ + = #{offset VkSubpassDependency, srcStageMask} + + {-# INLINE readVkSrcStageMask #-} + readVkSrcStageMask p + = peekByteOff p #{offset VkSubpassDependency, srcStageMask} + + {-# INLINE writeVkSrcStageMask #-} + writeVkSrcStageMask p + = pokeByteOff p #{offset VkSubpassDependency, srcStageMask} + +instance {-# OVERLAPPING #-} + HasField "srcStageMask" VkSubpassDependency where + type FieldType "srcStageMask" VkSubpassDependency = + VkPipelineStageFlags + type FieldOptional "srcStageMask" VkSubpassDependency = 'False -- ' closing tick for hsc2hs + type FieldOffset "srcStageMask" VkSubpassDependency = + #{offset VkSubpassDependency, srcStageMask} + type FieldIsArray "srcStageMask" VkSubpassDependency = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSubpassDependency, srcStageMask} + +instance CanReadField "srcStageMask" VkSubpassDependency where + {-# INLINE getField #-} + getField = vkSrcStageMask + + {-# INLINE readField #-} + readField = readVkSrcStageMask + +instance CanWriteField "srcStageMask" VkSubpassDependency where + {-# INLINE writeField #-} + writeField = writeVkSrcStageMask + +instance {-# OVERLAPPING #-} HasVkDstStageMask VkSubpassDependency + where + type VkDstStageMaskMType VkSubpassDependency = VkPipelineStageFlags + + {-# NOINLINE vkDstStageMask #-} + vkDstStageMask x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSubpassDependency, dstStageMask}) + + {-# INLINE vkDstStageMaskByteOffset #-} + vkDstStageMaskByteOffset ~_ + = #{offset VkSubpassDependency, dstStageMask} + + {-# INLINE readVkDstStageMask #-} + readVkDstStageMask p + = peekByteOff p #{offset VkSubpassDependency, dstStageMask} + + {-# INLINE writeVkDstStageMask #-} + writeVkDstStageMask p + = pokeByteOff p #{offset VkSubpassDependency, dstStageMask} + +instance {-# OVERLAPPING #-} + HasField "dstStageMask" VkSubpassDependency where + type FieldType "dstStageMask" VkSubpassDependency = + VkPipelineStageFlags + type FieldOptional "dstStageMask" VkSubpassDependency = 'False -- ' closing tick for hsc2hs + type FieldOffset "dstStageMask" VkSubpassDependency = + #{offset VkSubpassDependency, dstStageMask} + type FieldIsArray "dstStageMask" VkSubpassDependency = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSubpassDependency, dstStageMask} + +instance CanReadField "dstStageMask" VkSubpassDependency where + {-# INLINE getField #-} + getField = vkDstStageMask + + {-# INLINE readField #-} + readField = readVkDstStageMask + +instance CanWriteField "dstStageMask" VkSubpassDependency where + {-# INLINE writeField #-} + writeField = writeVkDstStageMask + +instance {-# OVERLAPPING #-} HasVkSrcAccessMask VkSubpassDependency + where + type VkSrcAccessMaskMType VkSubpassDependency = VkAccessFlags + + {-# NOINLINE vkSrcAccessMask #-} + vkSrcAccessMask x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSubpassDependency, srcAccessMask}) + + {-# INLINE vkSrcAccessMaskByteOffset #-} + vkSrcAccessMaskByteOffset ~_ + = #{offset VkSubpassDependency, srcAccessMask} + + {-# INLINE readVkSrcAccessMask #-} + readVkSrcAccessMask p + = peekByteOff p #{offset VkSubpassDependency, srcAccessMask} + + {-# INLINE writeVkSrcAccessMask #-} + writeVkSrcAccessMask p + = pokeByteOff p #{offset VkSubpassDependency, srcAccessMask} + +instance {-# OVERLAPPING #-} + HasField "srcAccessMask" VkSubpassDependency where + type FieldType "srcAccessMask" VkSubpassDependency = VkAccessFlags + type FieldOptional "srcAccessMask" VkSubpassDependency = 'True -- ' closing tick for hsc2hs + type FieldOffset "srcAccessMask" VkSubpassDependency = + #{offset VkSubpassDependency, srcAccessMask} + type FieldIsArray "srcAccessMask" VkSubpassDependency = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSubpassDependency, srcAccessMask} + +instance CanReadField "srcAccessMask" VkSubpassDependency where + {-# INLINE getField #-} + getField = vkSrcAccessMask + + {-# INLINE readField #-} + readField = readVkSrcAccessMask + +instance CanWriteField "srcAccessMask" VkSubpassDependency where + {-# INLINE writeField #-} + writeField = writeVkSrcAccessMask + +instance {-# OVERLAPPING #-} HasVkDstAccessMask VkSubpassDependency + where + type VkDstAccessMaskMType VkSubpassDependency = VkAccessFlags + + {-# NOINLINE vkDstAccessMask #-} + vkDstAccessMask x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSubpassDependency, dstAccessMask}) + + {-# INLINE vkDstAccessMaskByteOffset #-} + vkDstAccessMaskByteOffset ~_ + = #{offset VkSubpassDependency, dstAccessMask} + + {-# INLINE readVkDstAccessMask #-} + readVkDstAccessMask p + = peekByteOff p #{offset VkSubpassDependency, dstAccessMask} + + {-# INLINE writeVkDstAccessMask #-} + writeVkDstAccessMask p + = pokeByteOff p #{offset VkSubpassDependency, dstAccessMask} + +instance {-# OVERLAPPING #-} + HasField "dstAccessMask" VkSubpassDependency where + type FieldType "dstAccessMask" VkSubpassDependency = VkAccessFlags + type FieldOptional "dstAccessMask" VkSubpassDependency = 'True -- ' closing tick for hsc2hs + type FieldOffset "dstAccessMask" VkSubpassDependency = + #{offset VkSubpassDependency, dstAccessMask} + type FieldIsArray "dstAccessMask" VkSubpassDependency = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSubpassDependency, dstAccessMask} + +instance CanReadField "dstAccessMask" VkSubpassDependency where + {-# INLINE getField #-} + getField = vkDstAccessMask + + {-# INLINE readField #-} + readField = readVkDstAccessMask + +instance CanWriteField "dstAccessMask" VkSubpassDependency where + {-# INLINE writeField #-} + writeField = writeVkDstAccessMask + +instance {-# OVERLAPPING #-} + HasVkDependencyFlags VkSubpassDependency where + type VkDependencyFlagsMType VkSubpassDependency = VkDependencyFlags + + {-# NOINLINE vkDependencyFlags #-} + vkDependencyFlags x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSubpassDependency, dependencyFlags}) + + {-# INLINE vkDependencyFlagsByteOffset #-} + vkDependencyFlagsByteOffset ~_ + = #{offset VkSubpassDependency, dependencyFlags} + + {-# INLINE readVkDependencyFlags #-} + readVkDependencyFlags p + = peekByteOff p #{offset VkSubpassDependency, dependencyFlags} + + {-# INLINE writeVkDependencyFlags #-} + writeVkDependencyFlags p + = pokeByteOff p #{offset VkSubpassDependency, dependencyFlags} + +instance {-# OVERLAPPING #-} + HasField "dependencyFlags" VkSubpassDependency where + type FieldType "dependencyFlags" VkSubpassDependency = + VkDependencyFlags + type FieldOptional "dependencyFlags" VkSubpassDependency = 'True -- ' closing tick for hsc2hs + type FieldOffset "dependencyFlags" VkSubpassDependency = + #{offset VkSubpassDependency, dependencyFlags} + type FieldIsArray "dependencyFlags" VkSubpassDependency = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSubpassDependency, dependencyFlags} + +instance CanReadField "dependencyFlags" VkSubpassDependency where + {-# INLINE getField #-} + getField = vkDependencyFlags + + {-# INLINE readField #-} + readField = readVkDependencyFlags + +instance CanWriteField "dependencyFlags" VkSubpassDependency where + {-# INLINE writeField #-} + writeField = writeVkDependencyFlags + +instance Show VkSubpassDependency where + showsPrec d x + = showString "VkSubpassDependency {" . + showString "vkSrcSubpass = " . + showsPrec d (vkSrcSubpass x) . + showString ", " . + showString "vkDstSubpass = " . + showsPrec d (vkDstSubpass x) . + showString ", " . + showString "vkSrcStageMask = " . + showsPrec d (vkSrcStageMask x) . + showString ", " . + showString "vkDstStageMask = " . + showsPrec d (vkDstStageMask x) . + showString ", " . + showString "vkSrcAccessMask = " . + showsPrec d (vkSrcAccessMask x) . + showString ", " . + showString "vkDstAccessMask = " . + showsPrec d (vkDstAccessMask x) . + showString ", " . + showString "vkDependencyFlags = " . + showsPrec d (vkDependencyFlags x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkSubpassDescription.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkSubpassDescription.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkSubpassDescription.hsc @@ -0,0 +1,643 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkSubpassDescription + (VkSubpassDescription(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkPipelineBindPoint (VkPipelineBindPoint) +import Graphics.Vulkan.Types.Enum.VkSubpassDescriptionFlags (VkSubpassDescriptionFlags) +import Graphics.Vulkan.Types.Struct.VkAttachmentReference (VkAttachmentReference) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkSubpassDescription { +-- > VkSubpassDescriptionFlags flags; +-- > VkPipelineBindPoint pipelineBindPoint; +-- > uint32_t inputAttachmentCount; +-- > const VkAttachmentReference* pInputAttachments; +-- > uint32_t colorAttachmentCount; +-- > const VkAttachmentReference* pColorAttachments; +-- > const VkAttachmentReference* pResolveAttachments; +-- > const VkAttachmentReference* pDepthStencilAttachment; +-- > uint32_t preserveAttachmentCount; +-- > const uint32_t* pPreserveAttachments; +-- > } VkSubpassDescription; +-- +-- +data VkSubpassDescription = VkSubpassDescription## Addr## ByteArray## + +instance Eq VkSubpassDescription where + (VkSubpassDescription## a _) == x@(VkSubpassDescription## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkSubpassDescription where + (VkSubpassDescription## a _) `compare` x@(VkSubpassDescription## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkSubpassDescription where + sizeOf ~_ = #{size VkSubpassDescription} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkSubpassDescription} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkSubpassDescription where + unsafeAddr (VkSubpassDescription## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkSubpassDescription## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkSubpassDescription## (plusAddr## (byteArrayContents## b) off) b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkSubpassDescription where + type StructFields VkSubpassDescription = + '["flags", "pipelineBindPoint", "inputAttachmentCount", -- ' closing tick for hsc2hs + "pInputAttachments", "colorAttachmentCount", "pColorAttachments", + "pResolveAttachments", "pDepthStencilAttachment", + "preserveAttachmentCount", "pPreserveAttachments"] + type CUnionType VkSubpassDescription = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkSubpassDescription = 'False -- ' closing tick for hsc2hs + type StructExtends VkSubpassDescription = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkFlags VkSubpassDescription where + type VkFlagsMType VkSubpassDescription = VkSubpassDescriptionFlags + + {-# NOINLINE vkFlags #-} + vkFlags x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSubpassDescription, flags}) + + {-# INLINE vkFlagsByteOffset #-} + vkFlagsByteOffset ~_ + = #{offset VkSubpassDescription, flags} + + {-# INLINE readVkFlags #-} + readVkFlags p + = peekByteOff p #{offset VkSubpassDescription, flags} + + {-# INLINE writeVkFlags #-} + writeVkFlags p + = pokeByteOff p #{offset VkSubpassDescription, flags} + +instance {-# OVERLAPPING #-} HasField "flags" VkSubpassDescription + where + type FieldType "flags" VkSubpassDescription = + VkSubpassDescriptionFlags + type FieldOptional "flags" VkSubpassDescription = 'True -- ' closing tick for hsc2hs + type FieldOffset "flags" VkSubpassDescription = + #{offset VkSubpassDescription, flags} + type FieldIsArray "flags" VkSubpassDescription = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkSubpassDescription, flags} + +instance CanReadField "flags" VkSubpassDescription where + {-# INLINE getField #-} + getField = vkFlags + + {-# INLINE readField #-} + readField = readVkFlags + +instance CanWriteField "flags" VkSubpassDescription where + {-# INLINE writeField #-} + writeField = writeVkFlags + +instance {-# OVERLAPPING #-} + HasVkPipelineBindPoint VkSubpassDescription where + type VkPipelineBindPointMType VkSubpassDescription = + VkPipelineBindPoint + + {-# NOINLINE vkPipelineBindPoint #-} + vkPipelineBindPoint x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSubpassDescription, pipelineBindPoint}) + + {-# INLINE vkPipelineBindPointByteOffset #-} + vkPipelineBindPointByteOffset ~_ + = #{offset VkSubpassDescription, pipelineBindPoint} + + {-# INLINE readVkPipelineBindPoint #-} + readVkPipelineBindPoint p + = peekByteOff p #{offset VkSubpassDescription, pipelineBindPoint} + + {-# INLINE writeVkPipelineBindPoint #-} + writeVkPipelineBindPoint p + = pokeByteOff p #{offset VkSubpassDescription, pipelineBindPoint} + +instance {-# OVERLAPPING #-} + HasField "pipelineBindPoint" VkSubpassDescription where + type FieldType "pipelineBindPoint" VkSubpassDescription = + VkPipelineBindPoint + type FieldOptional "pipelineBindPoint" VkSubpassDescription = + 'False -- ' closing tick for hsc2hs + type FieldOffset "pipelineBindPoint" VkSubpassDescription = + #{offset VkSubpassDescription, pipelineBindPoint} + type FieldIsArray "pipelineBindPoint" VkSubpassDescription = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSubpassDescription, pipelineBindPoint} + +instance CanReadField "pipelineBindPoint" VkSubpassDescription + where + {-# INLINE getField #-} + getField = vkPipelineBindPoint + + {-# INLINE readField #-} + readField = readVkPipelineBindPoint + +instance CanWriteField "pipelineBindPoint" VkSubpassDescription + where + {-# INLINE writeField #-} + writeField = writeVkPipelineBindPoint + +instance {-# OVERLAPPING #-} + HasVkInputAttachmentCount VkSubpassDescription where + type VkInputAttachmentCountMType VkSubpassDescription = Word32 + + {-# NOINLINE vkInputAttachmentCount #-} + vkInputAttachmentCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSubpassDescription, inputAttachmentCount}) + + {-# INLINE vkInputAttachmentCountByteOffset #-} + vkInputAttachmentCountByteOffset ~_ + = #{offset VkSubpassDescription, inputAttachmentCount} + + {-# INLINE readVkInputAttachmentCount #-} + readVkInputAttachmentCount p + = peekByteOff p #{offset VkSubpassDescription, inputAttachmentCount} + + {-# INLINE writeVkInputAttachmentCount #-} + writeVkInputAttachmentCount p + = pokeByteOff p #{offset VkSubpassDescription, inputAttachmentCount} + +instance {-# OVERLAPPING #-} + HasField "inputAttachmentCount" VkSubpassDescription where + type FieldType "inputAttachmentCount" VkSubpassDescription = Word32 + type FieldOptional "inputAttachmentCount" VkSubpassDescription = + 'True -- ' closing tick for hsc2hs + type FieldOffset "inputAttachmentCount" VkSubpassDescription = + #{offset VkSubpassDescription, inputAttachmentCount} + type FieldIsArray "inputAttachmentCount" VkSubpassDescription = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSubpassDescription, inputAttachmentCount} + +instance CanReadField "inputAttachmentCount" VkSubpassDescription + where + {-# INLINE getField #-} + getField = vkInputAttachmentCount + + {-# INLINE readField #-} + readField = readVkInputAttachmentCount + +instance CanWriteField "inputAttachmentCount" VkSubpassDescription + where + {-# INLINE writeField #-} + writeField = writeVkInputAttachmentCount + +instance {-# OVERLAPPING #-} + HasVkPInputAttachments VkSubpassDescription where + type VkPInputAttachmentsMType VkSubpassDescription = + Ptr VkAttachmentReference + + {-# NOINLINE vkPInputAttachments #-} + vkPInputAttachments x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSubpassDescription, pInputAttachments}) + + {-# INLINE vkPInputAttachmentsByteOffset #-} + vkPInputAttachmentsByteOffset ~_ + = #{offset VkSubpassDescription, pInputAttachments} + + {-# INLINE readVkPInputAttachments #-} + readVkPInputAttachments p + = peekByteOff p #{offset VkSubpassDescription, pInputAttachments} + + {-# INLINE writeVkPInputAttachments #-} + writeVkPInputAttachments p + = pokeByteOff p #{offset VkSubpassDescription, pInputAttachments} + +instance {-# OVERLAPPING #-} + HasField "pInputAttachments" VkSubpassDescription where + type FieldType "pInputAttachments" VkSubpassDescription = + Ptr VkAttachmentReference + type FieldOptional "pInputAttachments" VkSubpassDescription = + 'False -- ' closing tick for hsc2hs + type FieldOffset "pInputAttachments" VkSubpassDescription = + #{offset VkSubpassDescription, pInputAttachments} + type FieldIsArray "pInputAttachments" VkSubpassDescription = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSubpassDescription, pInputAttachments} + +instance CanReadField "pInputAttachments" VkSubpassDescription + where + {-# INLINE getField #-} + getField = vkPInputAttachments + + {-# INLINE readField #-} + readField = readVkPInputAttachments + +instance CanWriteField "pInputAttachments" VkSubpassDescription + where + {-# INLINE writeField #-} + writeField = writeVkPInputAttachments + +instance {-# OVERLAPPING #-} + HasVkColorAttachmentCount VkSubpassDescription where + type VkColorAttachmentCountMType VkSubpassDescription = Word32 + + {-# NOINLINE vkColorAttachmentCount #-} + vkColorAttachmentCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSubpassDescription, colorAttachmentCount}) + + {-# INLINE vkColorAttachmentCountByteOffset #-} + vkColorAttachmentCountByteOffset ~_ + = #{offset VkSubpassDescription, colorAttachmentCount} + + {-# INLINE readVkColorAttachmentCount #-} + readVkColorAttachmentCount p + = peekByteOff p #{offset VkSubpassDescription, colorAttachmentCount} + + {-# INLINE writeVkColorAttachmentCount #-} + writeVkColorAttachmentCount p + = pokeByteOff p #{offset VkSubpassDescription, colorAttachmentCount} + +instance {-# OVERLAPPING #-} + HasField "colorAttachmentCount" VkSubpassDescription where + type FieldType "colorAttachmentCount" VkSubpassDescription = Word32 + type FieldOptional "colorAttachmentCount" VkSubpassDescription = + 'True -- ' closing tick for hsc2hs + type FieldOffset "colorAttachmentCount" VkSubpassDescription = + #{offset VkSubpassDescription, colorAttachmentCount} + type FieldIsArray "colorAttachmentCount" VkSubpassDescription = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSubpassDescription, colorAttachmentCount} + +instance CanReadField "colorAttachmentCount" VkSubpassDescription + where + {-# INLINE getField #-} + getField = vkColorAttachmentCount + + {-# INLINE readField #-} + readField = readVkColorAttachmentCount + +instance CanWriteField "colorAttachmentCount" VkSubpassDescription + where + {-# INLINE writeField #-} + writeField = writeVkColorAttachmentCount + +instance {-# OVERLAPPING #-} + HasVkPColorAttachments VkSubpassDescription where + type VkPColorAttachmentsMType VkSubpassDescription = + Ptr VkAttachmentReference + + {-# NOINLINE vkPColorAttachments #-} + vkPColorAttachments x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSubpassDescription, pColorAttachments}) + + {-# INLINE vkPColorAttachmentsByteOffset #-} + vkPColorAttachmentsByteOffset ~_ + = #{offset VkSubpassDescription, pColorAttachments} + + {-# INLINE readVkPColorAttachments #-} + readVkPColorAttachments p + = peekByteOff p #{offset VkSubpassDescription, pColorAttachments} + + {-# INLINE writeVkPColorAttachments #-} + writeVkPColorAttachments p + = pokeByteOff p #{offset VkSubpassDescription, pColorAttachments} + +instance {-# OVERLAPPING #-} + HasField "pColorAttachments" VkSubpassDescription where + type FieldType "pColorAttachments" VkSubpassDescription = + Ptr VkAttachmentReference + type FieldOptional "pColorAttachments" VkSubpassDescription = + 'False -- ' closing tick for hsc2hs + type FieldOffset "pColorAttachments" VkSubpassDescription = + #{offset VkSubpassDescription, pColorAttachments} + type FieldIsArray "pColorAttachments" VkSubpassDescription = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSubpassDescription, pColorAttachments} + +instance CanReadField "pColorAttachments" VkSubpassDescription + where + {-# INLINE getField #-} + getField = vkPColorAttachments + + {-# INLINE readField #-} + readField = readVkPColorAttachments + +instance CanWriteField "pColorAttachments" VkSubpassDescription + where + {-# INLINE writeField #-} + writeField = writeVkPColorAttachments + +instance {-# OVERLAPPING #-} + HasVkPResolveAttachments VkSubpassDescription where + type VkPResolveAttachmentsMType VkSubpassDescription = + Ptr VkAttachmentReference + + {-# NOINLINE vkPResolveAttachments #-} + vkPResolveAttachments x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSubpassDescription, pResolveAttachments}) + + {-# INLINE vkPResolveAttachmentsByteOffset #-} + vkPResolveAttachmentsByteOffset ~_ + = #{offset VkSubpassDescription, pResolveAttachments} + + {-# INLINE readVkPResolveAttachments #-} + readVkPResolveAttachments p + = peekByteOff p #{offset VkSubpassDescription, pResolveAttachments} + + {-# INLINE writeVkPResolveAttachments #-} + writeVkPResolveAttachments p + = pokeByteOff p #{offset VkSubpassDescription, pResolveAttachments} + +instance {-# OVERLAPPING #-} + HasField "pResolveAttachments" VkSubpassDescription where + type FieldType "pResolveAttachments" VkSubpassDescription = + Ptr VkAttachmentReference + type FieldOptional "pResolveAttachments" VkSubpassDescription = + 'True -- ' closing tick for hsc2hs + type FieldOffset "pResolveAttachments" VkSubpassDescription = + #{offset VkSubpassDescription, pResolveAttachments} + type FieldIsArray "pResolveAttachments" VkSubpassDescription = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSubpassDescription, pResolveAttachments} + +instance CanReadField "pResolveAttachments" VkSubpassDescription + where + {-# INLINE getField #-} + getField = vkPResolveAttachments + + {-# INLINE readField #-} + readField = readVkPResolveAttachments + +instance CanWriteField "pResolveAttachments" VkSubpassDescription + where + {-# INLINE writeField #-} + writeField = writeVkPResolveAttachments + +instance {-# OVERLAPPING #-} + HasVkPDepthStencilAttachment VkSubpassDescription where + type VkPDepthStencilAttachmentMType VkSubpassDescription = + Ptr VkAttachmentReference + + {-# NOINLINE vkPDepthStencilAttachment #-} + vkPDepthStencilAttachment x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSubpassDescription, pDepthStencilAttachment}) + + {-# INLINE vkPDepthStencilAttachmentByteOffset #-} + vkPDepthStencilAttachmentByteOffset ~_ + = #{offset VkSubpassDescription, pDepthStencilAttachment} + + {-# INLINE readVkPDepthStencilAttachment #-} + readVkPDepthStencilAttachment p + = peekByteOff p #{offset VkSubpassDescription, pDepthStencilAttachment} + + {-# INLINE writeVkPDepthStencilAttachment #-} + writeVkPDepthStencilAttachment p + = pokeByteOff p #{offset VkSubpassDescription, pDepthStencilAttachment} + +instance {-# OVERLAPPING #-} + HasField "pDepthStencilAttachment" VkSubpassDescription where + type FieldType "pDepthStencilAttachment" VkSubpassDescription = + Ptr VkAttachmentReference + type FieldOptional "pDepthStencilAttachment" VkSubpassDescription = + 'True -- ' closing tick for hsc2hs + type FieldOffset "pDepthStencilAttachment" VkSubpassDescription = + #{offset VkSubpassDescription, pDepthStencilAttachment} + type FieldIsArray "pDepthStencilAttachment" VkSubpassDescription = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSubpassDescription, pDepthStencilAttachment} + +instance CanReadField "pDepthStencilAttachment" + VkSubpassDescription + where + {-# INLINE getField #-} + getField = vkPDepthStencilAttachment + + {-# INLINE readField #-} + readField = readVkPDepthStencilAttachment + +instance CanWriteField "pDepthStencilAttachment" + VkSubpassDescription + where + {-# INLINE writeField #-} + writeField = writeVkPDepthStencilAttachment + +instance {-# OVERLAPPING #-} + HasVkPreserveAttachmentCount VkSubpassDescription where + type VkPreserveAttachmentCountMType VkSubpassDescription = Word32 + + {-# NOINLINE vkPreserveAttachmentCount #-} + vkPreserveAttachmentCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSubpassDescription, preserveAttachmentCount}) + + {-# INLINE vkPreserveAttachmentCountByteOffset #-} + vkPreserveAttachmentCountByteOffset ~_ + = #{offset VkSubpassDescription, preserveAttachmentCount} + + {-# INLINE readVkPreserveAttachmentCount #-} + readVkPreserveAttachmentCount p + = peekByteOff p #{offset VkSubpassDescription, preserveAttachmentCount} + + {-# INLINE writeVkPreserveAttachmentCount #-} + writeVkPreserveAttachmentCount p + = pokeByteOff p #{offset VkSubpassDescription, preserveAttachmentCount} + +instance {-# OVERLAPPING #-} + HasField "preserveAttachmentCount" VkSubpassDescription where + type FieldType "preserveAttachmentCount" VkSubpassDescription = + Word32 + type FieldOptional "preserveAttachmentCount" VkSubpassDescription = + 'True -- ' closing tick for hsc2hs + type FieldOffset "preserveAttachmentCount" VkSubpassDescription = + #{offset VkSubpassDescription, preserveAttachmentCount} + type FieldIsArray "preserveAttachmentCount" VkSubpassDescription = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSubpassDescription, preserveAttachmentCount} + +instance CanReadField "preserveAttachmentCount" + VkSubpassDescription + where + {-# INLINE getField #-} + getField = vkPreserveAttachmentCount + + {-# INLINE readField #-} + readField = readVkPreserveAttachmentCount + +instance CanWriteField "preserveAttachmentCount" + VkSubpassDescription + where + {-# INLINE writeField #-} + writeField = writeVkPreserveAttachmentCount + +instance {-# OVERLAPPING #-} + HasVkPPreserveAttachments VkSubpassDescription where + type VkPPreserveAttachmentsMType VkSubpassDescription = Ptr Word32 + + {-# NOINLINE vkPPreserveAttachments #-} + vkPPreserveAttachments x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSubpassDescription, pPreserveAttachments}) + + {-# INLINE vkPPreserveAttachmentsByteOffset #-} + vkPPreserveAttachmentsByteOffset ~_ + = #{offset VkSubpassDescription, pPreserveAttachments} + + {-# INLINE readVkPPreserveAttachments #-} + readVkPPreserveAttachments p + = peekByteOff p #{offset VkSubpassDescription, pPreserveAttachments} + + {-# INLINE writeVkPPreserveAttachments #-} + writeVkPPreserveAttachments p + = pokeByteOff p #{offset VkSubpassDescription, pPreserveAttachments} + +instance {-# OVERLAPPING #-} + HasField "pPreserveAttachments" VkSubpassDescription where + type FieldType "pPreserveAttachments" VkSubpassDescription = + Ptr Word32 + type FieldOptional "pPreserveAttachments" VkSubpassDescription = + 'False -- ' closing tick for hsc2hs + type FieldOffset "pPreserveAttachments" VkSubpassDescription = + #{offset VkSubpassDescription, pPreserveAttachments} + type FieldIsArray "pPreserveAttachments" VkSubpassDescription = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSubpassDescription, pPreserveAttachments} + +instance CanReadField "pPreserveAttachments" VkSubpassDescription + where + {-# INLINE getField #-} + getField = vkPPreserveAttachments + + {-# INLINE readField #-} + readField = readVkPPreserveAttachments + +instance CanWriteField "pPreserveAttachments" VkSubpassDescription + where + {-# INLINE writeField #-} + writeField = writeVkPPreserveAttachments + +instance Show VkSubpassDescription where + showsPrec d x + = showString "VkSubpassDescription {" . + showString "vkFlags = " . + showsPrec d (vkFlags x) . + showString ", " . + showString "vkPipelineBindPoint = " . + showsPrec d (vkPipelineBindPoint x) . + showString ", " . + showString "vkInputAttachmentCount = " . + showsPrec d (vkInputAttachmentCount x) . + showString ", " . + showString "vkPInputAttachments = " . + showsPrec d (vkPInputAttachments x) . + showString ", " . + showString "vkColorAttachmentCount = " . + showsPrec d (vkColorAttachmentCount x) . + showString ", " . + showString "vkPColorAttachments = " . + showsPrec d (vkPColorAttachments x) . + showString ", " . + showString "vkPResolveAttachments = " . + showsPrec d (vkPResolveAttachments x) . + showString ", " . + showString "vkPDepthStencilAttachment = " . + showsPrec d (vkPDepthStencilAttachment x) + . + showString ", " . + showString + "vkPreserveAttachmentCount = " + . + showsPrec d + (vkPreserveAttachmentCount x) + . + showString ", " . + showString + "vkPPreserveAttachments = " + . + showsPrec d + (vkPPreserveAttachments x) + . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkSubpassSampleLocationsEXT.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkSubpassSampleLocationsEXT.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkSubpassSampleLocationsEXT.hsc @@ -0,0 +1,191 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkSubpassSampleLocationsEXT + (VkSubpassSampleLocationsEXT(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Struct.VkSampleLocationsInfoEXT (VkSampleLocationsInfoEXT) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkSubpassSampleLocationsEXT { +-- > uint32_t subpassIndex; +-- > VkSampleLocationsInfoEXT sampleLocationsInfo; +-- > } VkSubpassSampleLocationsEXT; +-- +-- +data VkSubpassSampleLocationsEXT = VkSubpassSampleLocationsEXT## Addr## + ByteArray## + +instance Eq VkSubpassSampleLocationsEXT where + (VkSubpassSampleLocationsEXT## a _) == + x@(VkSubpassSampleLocationsEXT## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkSubpassSampleLocationsEXT where + (VkSubpassSampleLocationsEXT## a _) `compare` + x@(VkSubpassSampleLocationsEXT## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkSubpassSampleLocationsEXT where + sizeOf ~_ = #{size VkSubpassSampleLocationsEXT} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkSubpassSampleLocationsEXT} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkSubpassSampleLocationsEXT where + unsafeAddr (VkSubpassSampleLocationsEXT## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkSubpassSampleLocationsEXT## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkSubpassSampleLocationsEXT## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkSubpassSampleLocationsEXT where + type StructFields VkSubpassSampleLocationsEXT = + '["subpassIndex", "sampleLocationsInfo"] -- ' closing tick for hsc2hs + type CUnionType VkSubpassSampleLocationsEXT = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkSubpassSampleLocationsEXT = 'False -- ' closing tick for hsc2hs + type StructExtends VkSubpassSampleLocationsEXT = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSubpassIndex VkSubpassSampleLocationsEXT where + type VkSubpassIndexMType VkSubpassSampleLocationsEXT = Word32 + + {-# NOINLINE vkSubpassIndex #-} + vkSubpassIndex x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSubpassSampleLocationsEXT, subpassIndex}) + + {-# INLINE vkSubpassIndexByteOffset #-} + vkSubpassIndexByteOffset ~_ + = #{offset VkSubpassSampleLocationsEXT, subpassIndex} + + {-# INLINE readVkSubpassIndex #-} + readVkSubpassIndex p + = peekByteOff p #{offset VkSubpassSampleLocationsEXT, subpassIndex} + + {-# INLINE writeVkSubpassIndex #-} + writeVkSubpassIndex p + = pokeByteOff p #{offset VkSubpassSampleLocationsEXT, subpassIndex} + +instance {-# OVERLAPPING #-} + HasField "subpassIndex" VkSubpassSampleLocationsEXT where + type FieldType "subpassIndex" VkSubpassSampleLocationsEXT = Word32 + type FieldOptional "subpassIndex" VkSubpassSampleLocationsEXT = + 'False -- ' closing tick for hsc2hs + type FieldOffset "subpassIndex" VkSubpassSampleLocationsEXT = + #{offset VkSubpassSampleLocationsEXT, subpassIndex} + type FieldIsArray "subpassIndex" VkSubpassSampleLocationsEXT = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSubpassSampleLocationsEXT, subpassIndex} + +instance CanReadField "subpassIndex" VkSubpassSampleLocationsEXT + where + {-# INLINE getField #-} + getField = vkSubpassIndex + + {-# INLINE readField #-} + readField = readVkSubpassIndex + +instance CanWriteField "subpassIndex" VkSubpassSampleLocationsEXT + where + {-# INLINE writeField #-} + writeField = writeVkSubpassIndex + +instance {-# OVERLAPPING #-} + HasVkSampleLocationsInfo VkSubpassSampleLocationsEXT where + type VkSampleLocationsInfoMType VkSubpassSampleLocationsEXT = + VkSampleLocationsInfoEXT + + {-# NOINLINE vkSampleLocationsInfo #-} + vkSampleLocationsInfo x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSubpassSampleLocationsEXT, sampleLocationsInfo}) + + {-# INLINE vkSampleLocationsInfoByteOffset #-} + vkSampleLocationsInfoByteOffset ~_ + = #{offset VkSubpassSampleLocationsEXT, sampleLocationsInfo} + + {-# INLINE readVkSampleLocationsInfo #-} + readVkSampleLocationsInfo p + = peekByteOff p #{offset VkSubpassSampleLocationsEXT, sampleLocationsInfo} + + {-# INLINE writeVkSampleLocationsInfo #-} + writeVkSampleLocationsInfo p + = pokeByteOff p #{offset VkSubpassSampleLocationsEXT, sampleLocationsInfo} + +instance {-# OVERLAPPING #-} + HasField "sampleLocationsInfo" VkSubpassSampleLocationsEXT where + type FieldType "sampleLocationsInfo" VkSubpassSampleLocationsEXT = + VkSampleLocationsInfoEXT + type FieldOptional "sampleLocationsInfo" + VkSubpassSampleLocationsEXT + = 'False -- ' closing tick for hsc2hs + type FieldOffset "sampleLocationsInfo" VkSubpassSampleLocationsEXT + = + #{offset VkSubpassSampleLocationsEXT, sampleLocationsInfo} + type FieldIsArray "sampleLocationsInfo" VkSubpassSampleLocationsEXT + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSubpassSampleLocationsEXT, sampleLocationsInfo} + +instance CanReadField "sampleLocationsInfo" + VkSubpassSampleLocationsEXT + where + {-# INLINE getField #-} + getField = vkSampleLocationsInfo + + {-# INLINE readField #-} + readField = readVkSampleLocationsInfo + +instance CanWriteField "sampleLocationsInfo" + VkSubpassSampleLocationsEXT + where + {-# INLINE writeField #-} + writeField = writeVkSampleLocationsInfo + +instance Show VkSubpassSampleLocationsEXT where + showsPrec d x + = showString "VkSubpassSampleLocationsEXT {" . + showString "vkSubpassIndex = " . + showsPrec d (vkSubpassIndex x) . + showString ", " . + showString "vkSampleLocationsInfo = " . + showsPrec d (vkSampleLocationsInfo x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkSubresourceLayout.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkSubresourceLayout.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkSubresourceLayout.hsc @@ -0,0 +1,299 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkSubresourceLayout + (VkSubresourceLayout(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.BaseTypes (VkDeviceSize) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkSubresourceLayout { +-- > VkDeviceSize offset; +-- > VkDeviceSize size; +-- > VkDeviceSize rowPitch; +-- > VkDeviceSize arrayPitch; +-- > VkDeviceSize depthPitch; +-- > } VkSubresourceLayout; +-- +-- +data VkSubresourceLayout = VkSubresourceLayout## Addr## ByteArray## + +instance Eq VkSubresourceLayout where + (VkSubresourceLayout## a _) == x@(VkSubresourceLayout## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkSubresourceLayout where + (VkSubresourceLayout## a _) `compare` x@(VkSubresourceLayout## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkSubresourceLayout where + sizeOf ~_ = #{size VkSubresourceLayout} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkSubresourceLayout} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkSubresourceLayout where + unsafeAddr (VkSubresourceLayout## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkSubresourceLayout## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkSubresourceLayout## (plusAddr## (byteArrayContents## b) off) b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkSubresourceLayout where + type StructFields VkSubresourceLayout = + '["offset", "size", "rowPitch", "arrayPitch", "depthPitch"] -- ' closing tick for hsc2hs + type CUnionType VkSubresourceLayout = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkSubresourceLayout = 'True -- ' closing tick for hsc2hs + type StructExtends VkSubresourceLayout = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkOffset VkSubresourceLayout where + type VkOffsetMType VkSubresourceLayout = VkDeviceSize + + {-# NOINLINE vkOffset #-} + vkOffset x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSubresourceLayout, offset}) + + {-# INLINE vkOffsetByteOffset #-} + vkOffsetByteOffset ~_ + = #{offset VkSubresourceLayout, offset} + + {-# INLINE readVkOffset #-} + readVkOffset p + = peekByteOff p #{offset VkSubresourceLayout, offset} + + {-# INLINE writeVkOffset #-} + writeVkOffset p + = pokeByteOff p #{offset VkSubresourceLayout, offset} + +instance {-# OVERLAPPING #-} HasField "offset" VkSubresourceLayout + where + type FieldType "offset" VkSubresourceLayout = VkDeviceSize + type FieldOptional "offset" VkSubresourceLayout = 'False -- ' closing tick for hsc2hs + type FieldOffset "offset" VkSubresourceLayout = + #{offset VkSubresourceLayout, offset} + type FieldIsArray "offset" VkSubresourceLayout = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkSubresourceLayout, offset} + +instance CanReadField "offset" VkSubresourceLayout where + {-# INLINE getField #-} + getField = vkOffset + + {-# INLINE readField #-} + readField = readVkOffset + +instance {-# OVERLAPPING #-} HasVkSize VkSubresourceLayout where + type VkSizeMType VkSubresourceLayout = VkDeviceSize + + {-# NOINLINE vkSize #-} + vkSize x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSubresourceLayout, size}) + + {-# INLINE vkSizeByteOffset #-} + vkSizeByteOffset ~_ + = #{offset VkSubresourceLayout, size} + + {-# INLINE readVkSize #-} + readVkSize p + = peekByteOff p #{offset VkSubresourceLayout, size} + + {-# INLINE writeVkSize #-} + writeVkSize p + = pokeByteOff p #{offset VkSubresourceLayout, size} + +instance {-# OVERLAPPING #-} HasField "size" VkSubresourceLayout + where + type FieldType "size" VkSubresourceLayout = VkDeviceSize + type FieldOptional "size" VkSubresourceLayout = 'False -- ' closing tick for hsc2hs + type FieldOffset "size" VkSubresourceLayout = + #{offset VkSubresourceLayout, size} + type FieldIsArray "size" VkSubresourceLayout = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkSubresourceLayout, size} + +instance CanReadField "size" VkSubresourceLayout where + {-# INLINE getField #-} + getField = vkSize + + {-# INLINE readField #-} + readField = readVkSize + +instance {-# OVERLAPPING #-} HasVkRowPitch VkSubresourceLayout + where + type VkRowPitchMType VkSubresourceLayout = VkDeviceSize + + {-# NOINLINE vkRowPitch #-} + vkRowPitch x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSubresourceLayout, rowPitch}) + + {-# INLINE vkRowPitchByteOffset #-} + vkRowPitchByteOffset ~_ + = #{offset VkSubresourceLayout, rowPitch} + + {-# INLINE readVkRowPitch #-} + readVkRowPitch p + = peekByteOff p #{offset VkSubresourceLayout, rowPitch} + + {-# INLINE writeVkRowPitch #-} + writeVkRowPitch p + = pokeByteOff p #{offset VkSubresourceLayout, rowPitch} + +instance {-# OVERLAPPING #-} + HasField "rowPitch" VkSubresourceLayout where + type FieldType "rowPitch" VkSubresourceLayout = VkDeviceSize + type FieldOptional "rowPitch" VkSubresourceLayout = 'False -- ' closing tick for hsc2hs + type FieldOffset "rowPitch" VkSubresourceLayout = + #{offset VkSubresourceLayout, rowPitch} + type FieldIsArray "rowPitch" VkSubresourceLayout = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkSubresourceLayout, rowPitch} + +instance CanReadField "rowPitch" VkSubresourceLayout where + {-# INLINE getField #-} + getField = vkRowPitch + + {-# INLINE readField #-} + readField = readVkRowPitch + +instance {-# OVERLAPPING #-} HasVkArrayPitch VkSubresourceLayout + where + type VkArrayPitchMType VkSubresourceLayout = VkDeviceSize + + {-# NOINLINE vkArrayPitch #-} + vkArrayPitch x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSubresourceLayout, arrayPitch}) + + {-# INLINE vkArrayPitchByteOffset #-} + vkArrayPitchByteOffset ~_ + = #{offset VkSubresourceLayout, arrayPitch} + + {-# INLINE readVkArrayPitch #-} + readVkArrayPitch p + = peekByteOff p #{offset VkSubresourceLayout, arrayPitch} + + {-# INLINE writeVkArrayPitch #-} + writeVkArrayPitch p + = pokeByteOff p #{offset VkSubresourceLayout, arrayPitch} + +instance {-# OVERLAPPING #-} + HasField "arrayPitch" VkSubresourceLayout where + type FieldType "arrayPitch" VkSubresourceLayout = VkDeviceSize + type FieldOptional "arrayPitch" VkSubresourceLayout = 'False -- ' closing tick for hsc2hs + type FieldOffset "arrayPitch" VkSubresourceLayout = + #{offset VkSubresourceLayout, arrayPitch} + type FieldIsArray "arrayPitch" VkSubresourceLayout = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkSubresourceLayout, arrayPitch} + +instance CanReadField "arrayPitch" VkSubresourceLayout where + {-# INLINE getField #-} + getField = vkArrayPitch + + {-# INLINE readField #-} + readField = readVkArrayPitch + +instance {-# OVERLAPPING #-} HasVkDepthPitch VkSubresourceLayout + where + type VkDepthPitchMType VkSubresourceLayout = VkDeviceSize + + {-# NOINLINE vkDepthPitch #-} + vkDepthPitch x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSubresourceLayout, depthPitch}) + + {-# INLINE vkDepthPitchByteOffset #-} + vkDepthPitchByteOffset ~_ + = #{offset VkSubresourceLayout, depthPitch} + + {-# INLINE readVkDepthPitch #-} + readVkDepthPitch p + = peekByteOff p #{offset VkSubresourceLayout, depthPitch} + + {-# INLINE writeVkDepthPitch #-} + writeVkDepthPitch p + = pokeByteOff p #{offset VkSubresourceLayout, depthPitch} + +instance {-# OVERLAPPING #-} + HasField "depthPitch" VkSubresourceLayout where + type FieldType "depthPitch" VkSubresourceLayout = VkDeviceSize + type FieldOptional "depthPitch" VkSubresourceLayout = 'False -- ' closing tick for hsc2hs + type FieldOffset "depthPitch" VkSubresourceLayout = + #{offset VkSubresourceLayout, depthPitch} + type FieldIsArray "depthPitch" VkSubresourceLayout = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkSubresourceLayout, depthPitch} + +instance CanReadField "depthPitch" VkSubresourceLayout where + {-# INLINE getField #-} + getField = vkDepthPitch + + {-# INLINE readField #-} + readField = readVkDepthPitch + +instance Show VkSubresourceLayout where + showsPrec d x + = showString "VkSubresourceLayout {" . + showString "vkOffset = " . + showsPrec d (vkOffset x) . + showString ", " . + showString "vkSize = " . + showsPrec d (vkSize x) . + showString ", " . + showString "vkRowPitch = " . + showsPrec d (vkRowPitch x) . + showString ", " . + showString "vkArrayPitch = " . + showsPrec d (vkArrayPitch x) . + showString ", " . + showString "vkDepthPitch = " . + showsPrec d (vkDepthPitch x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkSurfaceCapabilities2EXT.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkSurfaceCapabilities2EXT.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkSurfaceCapabilities2EXT.hsc @@ -0,0 +1,779 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkSurfaceCapabilities2EXT + (VkSurfaceCapabilities2EXT(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkCompositeAlphaFlagsKHR (VkCompositeAlphaFlagsKHR) +import Graphics.Vulkan.Types.Enum.VkImageUsageFlags (VkImageUsageFlags) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Enum.VkSurfaceCounterFlagsEXT (VkSurfaceCounterFlagsEXT) +import Graphics.Vulkan.Types.Enum.VkSurfaceTransformFlagsKHR (VkSurfaceTransformFlagBitsKHR, + VkSurfaceTransformFlagsKHR) +import Graphics.Vulkan.Types.Struct.VkExtent2D (VkExtent2D) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkSurfaceCapabilities2EXT { +-- > VkStructureType sType; +-- > void* pNext; +-- > uint32_t minImageCount; +-- > uint32_t maxImageCount; +-- > VkExtent2D currentExtent; +-- > VkExtent2D minImageExtent; +-- > VkExtent2D maxImageExtent; +-- > uint32_t maxImageArrayLayers; +-- > VkSurfaceTransformFlagsKHR supportedTransforms; +-- > VkSurfaceTransformFlagBitsKHR currentTransform; +-- > VkCompositeAlphaFlagsKHR supportedCompositeAlpha; +-- > VkImageUsageFlags supportedUsageFlags; +-- > VkSurfaceCounterFlagsEXT supportedSurfaceCounters; +-- > } VkSurfaceCapabilities2EXT; +-- +-- +data VkSurfaceCapabilities2EXT = VkSurfaceCapabilities2EXT## Addr## + ByteArray## + +instance Eq VkSurfaceCapabilities2EXT where + (VkSurfaceCapabilities2EXT## a _) == + x@(VkSurfaceCapabilities2EXT## b _) = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkSurfaceCapabilities2EXT where + (VkSurfaceCapabilities2EXT## a _) `compare` + x@(VkSurfaceCapabilities2EXT## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkSurfaceCapabilities2EXT where + sizeOf ~_ = #{size VkSurfaceCapabilities2EXT} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkSurfaceCapabilities2EXT} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkSurfaceCapabilities2EXT where + unsafeAddr (VkSurfaceCapabilities2EXT## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkSurfaceCapabilities2EXT## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkSurfaceCapabilities2EXT## (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkSurfaceCapabilities2EXT where + type StructFields VkSurfaceCapabilities2EXT = + '["sType", "pNext", "minImageCount", "maxImageCount", -- ' closing tick for hsc2hs + "currentExtent", "minImageExtent", "maxImageExtent", + "maxImageArrayLayers", "supportedTransforms", "currentTransform", + "supportedCompositeAlpha", "supportedUsageFlags", + "supportedSurfaceCounters"] + type CUnionType VkSurfaceCapabilities2EXT = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkSurfaceCapabilities2EXT = 'True -- ' closing tick for hsc2hs + type StructExtends VkSurfaceCapabilities2EXT = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkSType VkSurfaceCapabilities2EXT + where + type VkSTypeMType VkSurfaceCapabilities2EXT = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSurfaceCapabilities2EXT, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkSurfaceCapabilities2EXT, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkSurfaceCapabilities2EXT, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkSurfaceCapabilities2EXT, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkSurfaceCapabilities2EXT where + type FieldType "sType" VkSurfaceCapabilities2EXT = VkStructureType + type FieldOptional "sType" VkSurfaceCapabilities2EXT = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkSurfaceCapabilities2EXT = + #{offset VkSurfaceCapabilities2EXT, sType} + type FieldIsArray "sType" VkSurfaceCapabilities2EXT = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSurfaceCapabilities2EXT, sType} + +instance CanReadField "sType" VkSurfaceCapabilities2EXT where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance {-# OVERLAPPING #-} HasVkPNext VkSurfaceCapabilities2EXT + where + type VkPNextMType VkSurfaceCapabilities2EXT = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSurfaceCapabilities2EXT, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkSurfaceCapabilities2EXT, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkSurfaceCapabilities2EXT, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkSurfaceCapabilities2EXT, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkSurfaceCapabilities2EXT where + type FieldType "pNext" VkSurfaceCapabilities2EXT = Ptr Void + type FieldOptional "pNext" VkSurfaceCapabilities2EXT = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkSurfaceCapabilities2EXT = + #{offset VkSurfaceCapabilities2EXT, pNext} + type FieldIsArray "pNext" VkSurfaceCapabilities2EXT = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSurfaceCapabilities2EXT, pNext} + +instance CanReadField "pNext" VkSurfaceCapabilities2EXT where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance {-# OVERLAPPING #-} + HasVkMinImageCount VkSurfaceCapabilities2EXT where + type VkMinImageCountMType VkSurfaceCapabilities2EXT = Word32 + + {-# NOINLINE vkMinImageCount #-} + vkMinImageCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSurfaceCapabilities2EXT, minImageCount}) + + {-# INLINE vkMinImageCountByteOffset #-} + vkMinImageCountByteOffset ~_ + = #{offset VkSurfaceCapabilities2EXT, minImageCount} + + {-# INLINE readVkMinImageCount #-} + readVkMinImageCount p + = peekByteOff p #{offset VkSurfaceCapabilities2EXT, minImageCount} + + {-# INLINE writeVkMinImageCount #-} + writeVkMinImageCount p + = pokeByteOff p #{offset VkSurfaceCapabilities2EXT, minImageCount} + +instance {-# OVERLAPPING #-} + HasField "minImageCount" VkSurfaceCapabilities2EXT where + type FieldType "minImageCount" VkSurfaceCapabilities2EXT = Word32 + type FieldOptional "minImageCount" VkSurfaceCapabilities2EXT = + 'False -- ' closing tick for hsc2hs + type FieldOffset "minImageCount" VkSurfaceCapabilities2EXT = + #{offset VkSurfaceCapabilities2EXT, minImageCount} + type FieldIsArray "minImageCount" VkSurfaceCapabilities2EXT = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSurfaceCapabilities2EXT, minImageCount} + +instance CanReadField "minImageCount" VkSurfaceCapabilities2EXT + where + {-# INLINE getField #-} + getField = vkMinImageCount + + {-# INLINE readField #-} + readField = readVkMinImageCount + +instance {-# OVERLAPPING #-} + HasVkMaxImageCount VkSurfaceCapabilities2EXT where + type VkMaxImageCountMType VkSurfaceCapabilities2EXT = Word32 + + {-# NOINLINE vkMaxImageCount #-} + vkMaxImageCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSurfaceCapabilities2EXT, maxImageCount}) + + {-# INLINE vkMaxImageCountByteOffset #-} + vkMaxImageCountByteOffset ~_ + = #{offset VkSurfaceCapabilities2EXT, maxImageCount} + + {-# INLINE readVkMaxImageCount #-} + readVkMaxImageCount p + = peekByteOff p #{offset VkSurfaceCapabilities2EXT, maxImageCount} + + {-# INLINE writeVkMaxImageCount #-} + writeVkMaxImageCount p + = pokeByteOff p #{offset VkSurfaceCapabilities2EXT, maxImageCount} + +instance {-# OVERLAPPING #-} + HasField "maxImageCount" VkSurfaceCapabilities2EXT where + type FieldType "maxImageCount" VkSurfaceCapabilities2EXT = Word32 + type FieldOptional "maxImageCount" VkSurfaceCapabilities2EXT = + 'False -- ' closing tick for hsc2hs + type FieldOffset "maxImageCount" VkSurfaceCapabilities2EXT = + #{offset VkSurfaceCapabilities2EXT, maxImageCount} + type FieldIsArray "maxImageCount" VkSurfaceCapabilities2EXT = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSurfaceCapabilities2EXT, maxImageCount} + +instance CanReadField "maxImageCount" VkSurfaceCapabilities2EXT + where + {-# INLINE getField #-} + getField = vkMaxImageCount + + {-# INLINE readField #-} + readField = readVkMaxImageCount + +instance {-# OVERLAPPING #-} + HasVkCurrentExtent VkSurfaceCapabilities2EXT where + type VkCurrentExtentMType VkSurfaceCapabilities2EXT = VkExtent2D + + {-# NOINLINE vkCurrentExtent #-} + vkCurrentExtent x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSurfaceCapabilities2EXT, currentExtent}) + + {-# INLINE vkCurrentExtentByteOffset #-} + vkCurrentExtentByteOffset ~_ + = #{offset VkSurfaceCapabilities2EXT, currentExtent} + + {-# INLINE readVkCurrentExtent #-} + readVkCurrentExtent p + = peekByteOff p #{offset VkSurfaceCapabilities2EXT, currentExtent} + + {-# INLINE writeVkCurrentExtent #-} + writeVkCurrentExtent p + = pokeByteOff p #{offset VkSurfaceCapabilities2EXT, currentExtent} + +instance {-# OVERLAPPING #-} + HasField "currentExtent" VkSurfaceCapabilities2EXT where + type FieldType "currentExtent" VkSurfaceCapabilities2EXT = + VkExtent2D + type FieldOptional "currentExtent" VkSurfaceCapabilities2EXT = + 'False -- ' closing tick for hsc2hs + type FieldOffset "currentExtent" VkSurfaceCapabilities2EXT = + #{offset VkSurfaceCapabilities2EXT, currentExtent} + type FieldIsArray "currentExtent" VkSurfaceCapabilities2EXT = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSurfaceCapabilities2EXT, currentExtent} + +instance CanReadField "currentExtent" VkSurfaceCapabilities2EXT + where + {-# INLINE getField #-} + getField = vkCurrentExtent + + {-# INLINE readField #-} + readField = readVkCurrentExtent + +instance {-# OVERLAPPING #-} + HasVkMinImageExtent VkSurfaceCapabilities2EXT where + type VkMinImageExtentMType VkSurfaceCapabilities2EXT = VkExtent2D + + {-# NOINLINE vkMinImageExtent #-} + vkMinImageExtent x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSurfaceCapabilities2EXT, minImageExtent}) + + {-# INLINE vkMinImageExtentByteOffset #-} + vkMinImageExtentByteOffset ~_ + = #{offset VkSurfaceCapabilities2EXT, minImageExtent} + + {-# INLINE readVkMinImageExtent #-} + readVkMinImageExtent p + = peekByteOff p #{offset VkSurfaceCapabilities2EXT, minImageExtent} + + {-# INLINE writeVkMinImageExtent #-} + writeVkMinImageExtent p + = pokeByteOff p #{offset VkSurfaceCapabilities2EXT, minImageExtent} + +instance {-# OVERLAPPING #-} + HasField "minImageExtent" VkSurfaceCapabilities2EXT where + type FieldType "minImageExtent" VkSurfaceCapabilities2EXT = + VkExtent2D + type FieldOptional "minImageExtent" VkSurfaceCapabilities2EXT = + 'False -- ' closing tick for hsc2hs + type FieldOffset "minImageExtent" VkSurfaceCapabilities2EXT = + #{offset VkSurfaceCapabilities2EXT, minImageExtent} + type FieldIsArray "minImageExtent" VkSurfaceCapabilities2EXT = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSurfaceCapabilities2EXT, minImageExtent} + +instance CanReadField "minImageExtent" VkSurfaceCapabilities2EXT + where + {-# INLINE getField #-} + getField = vkMinImageExtent + + {-# INLINE readField #-} + readField = readVkMinImageExtent + +instance {-# OVERLAPPING #-} + HasVkMaxImageExtent VkSurfaceCapabilities2EXT where + type VkMaxImageExtentMType VkSurfaceCapabilities2EXT = VkExtent2D + + {-# NOINLINE vkMaxImageExtent #-} + vkMaxImageExtent x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSurfaceCapabilities2EXT, maxImageExtent}) + + {-# INLINE vkMaxImageExtentByteOffset #-} + vkMaxImageExtentByteOffset ~_ + = #{offset VkSurfaceCapabilities2EXT, maxImageExtent} + + {-# INLINE readVkMaxImageExtent #-} + readVkMaxImageExtent p + = peekByteOff p #{offset VkSurfaceCapabilities2EXT, maxImageExtent} + + {-# INLINE writeVkMaxImageExtent #-} + writeVkMaxImageExtent p + = pokeByteOff p #{offset VkSurfaceCapabilities2EXT, maxImageExtent} + +instance {-# OVERLAPPING #-} + HasField "maxImageExtent" VkSurfaceCapabilities2EXT where + type FieldType "maxImageExtent" VkSurfaceCapabilities2EXT = + VkExtent2D + type FieldOptional "maxImageExtent" VkSurfaceCapabilities2EXT = + 'False -- ' closing tick for hsc2hs + type FieldOffset "maxImageExtent" VkSurfaceCapabilities2EXT = + #{offset VkSurfaceCapabilities2EXT, maxImageExtent} + type FieldIsArray "maxImageExtent" VkSurfaceCapabilities2EXT = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSurfaceCapabilities2EXT, maxImageExtent} + +instance CanReadField "maxImageExtent" VkSurfaceCapabilities2EXT + where + {-# INLINE getField #-} + getField = vkMaxImageExtent + + {-# INLINE readField #-} + readField = readVkMaxImageExtent + +instance {-# OVERLAPPING #-} + HasVkMaxImageArrayLayers VkSurfaceCapabilities2EXT where + type VkMaxImageArrayLayersMType VkSurfaceCapabilities2EXT = Word32 + + {-# NOINLINE vkMaxImageArrayLayers #-} + vkMaxImageArrayLayers x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSurfaceCapabilities2EXT, maxImageArrayLayers}) + + {-# INLINE vkMaxImageArrayLayersByteOffset #-} + vkMaxImageArrayLayersByteOffset ~_ + = #{offset VkSurfaceCapabilities2EXT, maxImageArrayLayers} + + {-# INLINE readVkMaxImageArrayLayers #-} + readVkMaxImageArrayLayers p + = peekByteOff p #{offset VkSurfaceCapabilities2EXT, maxImageArrayLayers} + + {-# INLINE writeVkMaxImageArrayLayers #-} + writeVkMaxImageArrayLayers p + = pokeByteOff p #{offset VkSurfaceCapabilities2EXT, maxImageArrayLayers} + +instance {-# OVERLAPPING #-} + HasField "maxImageArrayLayers" VkSurfaceCapabilities2EXT where + type FieldType "maxImageArrayLayers" VkSurfaceCapabilities2EXT = + Word32 + type FieldOptional "maxImageArrayLayers" VkSurfaceCapabilities2EXT + = 'False -- ' closing tick for hsc2hs + type FieldOffset "maxImageArrayLayers" VkSurfaceCapabilities2EXT = + #{offset VkSurfaceCapabilities2EXT, maxImageArrayLayers} + type FieldIsArray "maxImageArrayLayers" VkSurfaceCapabilities2EXT = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSurfaceCapabilities2EXT, maxImageArrayLayers} + +instance CanReadField "maxImageArrayLayers" + VkSurfaceCapabilities2EXT + where + {-# INLINE getField #-} + getField = vkMaxImageArrayLayers + + {-# INLINE readField #-} + readField = readVkMaxImageArrayLayers + +instance {-# OVERLAPPING #-} + HasVkSupportedTransforms VkSurfaceCapabilities2EXT where + type VkSupportedTransformsMType VkSurfaceCapabilities2EXT = + VkSurfaceTransformFlagsKHR + + {-# NOINLINE vkSupportedTransforms #-} + vkSupportedTransforms x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSurfaceCapabilities2EXT, supportedTransforms}) + + {-# INLINE vkSupportedTransformsByteOffset #-} + vkSupportedTransformsByteOffset ~_ + = #{offset VkSurfaceCapabilities2EXT, supportedTransforms} + + {-# INLINE readVkSupportedTransforms #-} + readVkSupportedTransforms p + = peekByteOff p #{offset VkSurfaceCapabilities2EXT, supportedTransforms} + + {-# INLINE writeVkSupportedTransforms #-} + writeVkSupportedTransforms p + = pokeByteOff p #{offset VkSurfaceCapabilities2EXT, supportedTransforms} + +instance {-# OVERLAPPING #-} + HasField "supportedTransforms" VkSurfaceCapabilities2EXT where + type FieldType "supportedTransforms" VkSurfaceCapabilities2EXT = + VkSurfaceTransformFlagsKHR + type FieldOptional "supportedTransforms" VkSurfaceCapabilities2EXT + = 'True -- ' closing tick for hsc2hs + type FieldOffset "supportedTransforms" VkSurfaceCapabilities2EXT = + #{offset VkSurfaceCapabilities2EXT, supportedTransforms} + type FieldIsArray "supportedTransforms" VkSurfaceCapabilities2EXT = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSurfaceCapabilities2EXT, supportedTransforms} + +instance CanReadField "supportedTransforms" + VkSurfaceCapabilities2EXT + where + {-# INLINE getField #-} + getField = vkSupportedTransforms + + {-# INLINE readField #-} + readField = readVkSupportedTransforms + +instance {-# OVERLAPPING #-} + HasVkCurrentTransform VkSurfaceCapabilities2EXT where + type VkCurrentTransformMType VkSurfaceCapabilities2EXT = + VkSurfaceTransformFlagBitsKHR + + {-# NOINLINE vkCurrentTransform #-} + vkCurrentTransform x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSurfaceCapabilities2EXT, currentTransform}) + + {-# INLINE vkCurrentTransformByteOffset #-} + vkCurrentTransformByteOffset ~_ + = #{offset VkSurfaceCapabilities2EXT, currentTransform} + + {-# INLINE readVkCurrentTransform #-} + readVkCurrentTransform p + = peekByteOff p #{offset VkSurfaceCapabilities2EXT, currentTransform} + + {-# INLINE writeVkCurrentTransform #-} + writeVkCurrentTransform p + = pokeByteOff p #{offset VkSurfaceCapabilities2EXT, currentTransform} + +instance {-# OVERLAPPING #-} + HasField "currentTransform" VkSurfaceCapabilities2EXT where + type FieldType "currentTransform" VkSurfaceCapabilities2EXT = + VkSurfaceTransformFlagBitsKHR + type FieldOptional "currentTransform" VkSurfaceCapabilities2EXT = + 'False -- ' closing tick for hsc2hs + type FieldOffset "currentTransform" VkSurfaceCapabilities2EXT = + #{offset VkSurfaceCapabilities2EXT, currentTransform} + type FieldIsArray "currentTransform" VkSurfaceCapabilities2EXT = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSurfaceCapabilities2EXT, currentTransform} + +instance CanReadField "currentTransform" VkSurfaceCapabilities2EXT + where + {-# INLINE getField #-} + getField = vkCurrentTransform + + {-# INLINE readField #-} + readField = readVkCurrentTransform + +instance {-# OVERLAPPING #-} + HasVkSupportedCompositeAlpha VkSurfaceCapabilities2EXT where + type VkSupportedCompositeAlphaMType VkSurfaceCapabilities2EXT = + VkCompositeAlphaFlagsKHR + + {-# NOINLINE vkSupportedCompositeAlpha #-} + vkSupportedCompositeAlpha x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSurfaceCapabilities2EXT, supportedCompositeAlpha}) + + {-# INLINE vkSupportedCompositeAlphaByteOffset #-} + vkSupportedCompositeAlphaByteOffset ~_ + = #{offset VkSurfaceCapabilities2EXT, supportedCompositeAlpha} + + {-# INLINE readVkSupportedCompositeAlpha #-} + readVkSupportedCompositeAlpha p + = peekByteOff p #{offset VkSurfaceCapabilities2EXT, supportedCompositeAlpha} + + {-# INLINE writeVkSupportedCompositeAlpha #-} + writeVkSupportedCompositeAlpha p + = pokeByteOff p #{offset VkSurfaceCapabilities2EXT, supportedCompositeAlpha} + +instance {-# OVERLAPPING #-} + HasField "supportedCompositeAlpha" VkSurfaceCapabilities2EXT where + type FieldType "supportedCompositeAlpha" VkSurfaceCapabilities2EXT + = VkCompositeAlphaFlagsKHR + type FieldOptional "supportedCompositeAlpha" + VkSurfaceCapabilities2EXT + = 'True -- ' closing tick for hsc2hs + type FieldOffset "supportedCompositeAlpha" + VkSurfaceCapabilities2EXT + = + #{offset VkSurfaceCapabilities2EXT, supportedCompositeAlpha} + type FieldIsArray "supportedCompositeAlpha" + VkSurfaceCapabilities2EXT + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSurfaceCapabilities2EXT, supportedCompositeAlpha} + +instance CanReadField "supportedCompositeAlpha" + VkSurfaceCapabilities2EXT + where + {-# INLINE getField #-} + getField = vkSupportedCompositeAlpha + + {-# INLINE readField #-} + readField = readVkSupportedCompositeAlpha + +instance {-# OVERLAPPING #-} + HasVkSupportedUsageFlags VkSurfaceCapabilities2EXT where + type VkSupportedUsageFlagsMType VkSurfaceCapabilities2EXT = + VkImageUsageFlags + + {-# NOINLINE vkSupportedUsageFlags #-} + vkSupportedUsageFlags x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSurfaceCapabilities2EXT, supportedUsageFlags}) + + {-# INLINE vkSupportedUsageFlagsByteOffset #-} + vkSupportedUsageFlagsByteOffset ~_ + = #{offset VkSurfaceCapabilities2EXT, supportedUsageFlags} + + {-# INLINE readVkSupportedUsageFlags #-} + readVkSupportedUsageFlags p + = peekByteOff p #{offset VkSurfaceCapabilities2EXT, supportedUsageFlags} + + {-# INLINE writeVkSupportedUsageFlags #-} + writeVkSupportedUsageFlags p + = pokeByteOff p #{offset VkSurfaceCapabilities2EXT, supportedUsageFlags} + +instance {-# OVERLAPPING #-} + HasField "supportedUsageFlags" VkSurfaceCapabilities2EXT where + type FieldType "supportedUsageFlags" VkSurfaceCapabilities2EXT = + VkImageUsageFlags + type FieldOptional "supportedUsageFlags" VkSurfaceCapabilities2EXT + = 'True -- ' closing tick for hsc2hs + type FieldOffset "supportedUsageFlags" VkSurfaceCapabilities2EXT = + #{offset VkSurfaceCapabilities2EXT, supportedUsageFlags} + type FieldIsArray "supportedUsageFlags" VkSurfaceCapabilities2EXT = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSurfaceCapabilities2EXT, supportedUsageFlags} + +instance CanReadField "supportedUsageFlags" + VkSurfaceCapabilities2EXT + where + {-# INLINE getField #-} + getField = vkSupportedUsageFlags + + {-# INLINE readField #-} + readField = readVkSupportedUsageFlags + +instance {-# OVERLAPPING #-} + HasVkSupportedSurfaceCounters VkSurfaceCapabilities2EXT where + type VkSupportedSurfaceCountersMType VkSurfaceCapabilities2EXT = + VkSurfaceCounterFlagsEXT + + {-# NOINLINE vkSupportedSurfaceCounters #-} + vkSupportedSurfaceCounters x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSurfaceCapabilities2EXT, supportedSurfaceCounters}) + + {-# INLINE vkSupportedSurfaceCountersByteOffset #-} + vkSupportedSurfaceCountersByteOffset ~_ + = #{offset VkSurfaceCapabilities2EXT, supportedSurfaceCounters} + + {-# INLINE readVkSupportedSurfaceCounters #-} + readVkSupportedSurfaceCounters p + = peekByteOff p #{offset VkSurfaceCapabilities2EXT, supportedSurfaceCounters} + + {-# INLINE writeVkSupportedSurfaceCounters #-} + writeVkSupportedSurfaceCounters p + = pokeByteOff p #{offset VkSurfaceCapabilities2EXT, supportedSurfaceCounters} + +instance {-# OVERLAPPING #-} + HasField "supportedSurfaceCounters" VkSurfaceCapabilities2EXT where + type FieldType "supportedSurfaceCounters" VkSurfaceCapabilities2EXT + = VkSurfaceCounterFlagsEXT + type FieldOptional "supportedSurfaceCounters" + VkSurfaceCapabilities2EXT + = 'True -- ' closing tick for hsc2hs + type FieldOffset "supportedSurfaceCounters" + VkSurfaceCapabilities2EXT + = + #{offset VkSurfaceCapabilities2EXT, supportedSurfaceCounters} + type FieldIsArray "supportedSurfaceCounters" + VkSurfaceCapabilities2EXT + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSurfaceCapabilities2EXT, supportedSurfaceCounters} + +instance CanReadField "supportedSurfaceCounters" + VkSurfaceCapabilities2EXT + where + {-# INLINE getField #-} + getField = vkSupportedSurfaceCounters + + {-# INLINE readField #-} + readField = readVkSupportedSurfaceCounters + +instance Show VkSurfaceCapabilities2EXT where + showsPrec d x + = showString "VkSurfaceCapabilities2EXT {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkMinImageCount = " . + showsPrec d (vkMinImageCount x) . + showString ", " . + showString "vkMaxImageCount = " . + showsPrec d (vkMaxImageCount x) . + showString ", " . + showString "vkCurrentExtent = " . + showsPrec d (vkCurrentExtent x) . + showString ", " . + showString "vkMinImageExtent = " . + showsPrec d (vkMinImageExtent x) . + showString ", " . + showString "vkMaxImageExtent = " . + showsPrec d (vkMaxImageExtent x) . + showString ", " . + showString "vkMaxImageArrayLayers = " . + showsPrec d (vkMaxImageArrayLayers x) . + showString ", " . + showString "vkSupportedTransforms = " + . + showsPrec d + (vkSupportedTransforms x) + . + showString ", " . + showString + "vkCurrentTransform = " + . + showsPrec d + (vkCurrentTransform x) + . + showString ", " . + showString + "vkSupportedCompositeAlpha = " + . + showsPrec d + (vkSupportedCompositeAlpha + x) + . + showString ", " . + showString + "vkSupportedUsageFlags = " + . + showsPrec d + (vkSupportedUsageFlags + x) + . + showString ", " + . + showString + "vkSupportedSurfaceCounters = " + . + showsPrec d + (vkSupportedSurfaceCounters + x) + . + showChar + '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkSurfaceCapabilities2KHR.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkSurfaceCapabilities2KHR.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkSurfaceCapabilities2KHR.hsc @@ -0,0 +1,221 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkSurfaceCapabilities2KHR + (VkSurfaceCapabilities2KHR(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Struct.VkSurfaceCapabilitiesKHR (VkSurfaceCapabilitiesKHR) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkSurfaceCapabilities2KHR { +-- > VkStructureType sType; +-- > void* pNext; +-- > VkSurfaceCapabilitiesKHR surfaceCapabilities; +-- > } VkSurfaceCapabilities2KHR; +-- +-- +data VkSurfaceCapabilities2KHR = VkSurfaceCapabilities2KHR## Addr## + ByteArray## + +instance Eq VkSurfaceCapabilities2KHR where + (VkSurfaceCapabilities2KHR## a _) == + x@(VkSurfaceCapabilities2KHR## b _) = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkSurfaceCapabilities2KHR where + (VkSurfaceCapabilities2KHR## a _) `compare` + x@(VkSurfaceCapabilities2KHR## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkSurfaceCapabilities2KHR where + sizeOf ~_ = #{size VkSurfaceCapabilities2KHR} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkSurfaceCapabilities2KHR} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkSurfaceCapabilities2KHR where + unsafeAddr (VkSurfaceCapabilities2KHR## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkSurfaceCapabilities2KHR## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkSurfaceCapabilities2KHR## (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkSurfaceCapabilities2KHR where + type StructFields VkSurfaceCapabilities2KHR = + '["sType", "pNext", "surfaceCapabilities"] -- ' closing tick for hsc2hs + type CUnionType VkSurfaceCapabilities2KHR = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkSurfaceCapabilities2KHR = 'True -- ' closing tick for hsc2hs + type StructExtends VkSurfaceCapabilities2KHR = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkSType VkSurfaceCapabilities2KHR + where + type VkSTypeMType VkSurfaceCapabilities2KHR = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSurfaceCapabilities2KHR, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkSurfaceCapabilities2KHR, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkSurfaceCapabilities2KHR, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkSurfaceCapabilities2KHR, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkSurfaceCapabilities2KHR where + type FieldType "sType" VkSurfaceCapabilities2KHR = VkStructureType + type FieldOptional "sType" VkSurfaceCapabilities2KHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkSurfaceCapabilities2KHR = + #{offset VkSurfaceCapabilities2KHR, sType} + type FieldIsArray "sType" VkSurfaceCapabilities2KHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSurfaceCapabilities2KHR, sType} + +instance CanReadField "sType" VkSurfaceCapabilities2KHR where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance {-# OVERLAPPING #-} HasVkPNext VkSurfaceCapabilities2KHR + where + type VkPNextMType VkSurfaceCapabilities2KHR = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSurfaceCapabilities2KHR, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkSurfaceCapabilities2KHR, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkSurfaceCapabilities2KHR, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkSurfaceCapabilities2KHR, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkSurfaceCapabilities2KHR where + type FieldType "pNext" VkSurfaceCapabilities2KHR = Ptr Void + type FieldOptional "pNext" VkSurfaceCapabilities2KHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkSurfaceCapabilities2KHR = + #{offset VkSurfaceCapabilities2KHR, pNext} + type FieldIsArray "pNext" VkSurfaceCapabilities2KHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSurfaceCapabilities2KHR, pNext} + +instance CanReadField "pNext" VkSurfaceCapabilities2KHR where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance {-# OVERLAPPING #-} + HasVkSurfaceCapabilities VkSurfaceCapabilities2KHR where + type VkSurfaceCapabilitiesMType VkSurfaceCapabilities2KHR = + VkSurfaceCapabilitiesKHR + + {-# NOINLINE vkSurfaceCapabilities #-} + vkSurfaceCapabilities x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSurfaceCapabilities2KHR, surfaceCapabilities}) + + {-# INLINE vkSurfaceCapabilitiesByteOffset #-} + vkSurfaceCapabilitiesByteOffset ~_ + = #{offset VkSurfaceCapabilities2KHR, surfaceCapabilities} + + {-# INLINE readVkSurfaceCapabilities #-} + readVkSurfaceCapabilities p + = peekByteOff p #{offset VkSurfaceCapabilities2KHR, surfaceCapabilities} + + {-# INLINE writeVkSurfaceCapabilities #-} + writeVkSurfaceCapabilities p + = pokeByteOff p #{offset VkSurfaceCapabilities2KHR, surfaceCapabilities} + +instance {-# OVERLAPPING #-} + HasField "surfaceCapabilities" VkSurfaceCapabilities2KHR where + type FieldType "surfaceCapabilities" VkSurfaceCapabilities2KHR = + VkSurfaceCapabilitiesKHR + type FieldOptional "surfaceCapabilities" VkSurfaceCapabilities2KHR + = 'False -- ' closing tick for hsc2hs + type FieldOffset "surfaceCapabilities" VkSurfaceCapabilities2KHR = + #{offset VkSurfaceCapabilities2KHR, surfaceCapabilities} + type FieldIsArray "surfaceCapabilities" VkSurfaceCapabilities2KHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSurfaceCapabilities2KHR, surfaceCapabilities} + +instance CanReadField "surfaceCapabilities" + VkSurfaceCapabilities2KHR + where + {-# INLINE getField #-} + getField = vkSurfaceCapabilities + + {-# INLINE readField #-} + readField = readVkSurfaceCapabilities + +instance Show VkSurfaceCapabilities2KHR where + showsPrec d x + = showString "VkSurfaceCapabilities2KHR {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkSurfaceCapabilities = " . + showsPrec d (vkSurfaceCapabilities x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkSurfaceCapabilitiesKHR.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkSurfaceCapabilitiesKHR.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkSurfaceCapabilitiesKHR.hsc @@ -0,0 +1,604 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkSurfaceCapabilitiesKHR + (VkSurfaceCapabilitiesKHR(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkCompositeAlphaFlagsKHR (VkCompositeAlphaFlagsKHR) +import Graphics.Vulkan.Types.Enum.VkImageUsageFlags (VkImageUsageFlags) +import Graphics.Vulkan.Types.Enum.VkSurfaceTransformFlagsKHR (VkSurfaceTransformFlagBitsKHR, + VkSurfaceTransformFlagsKHR) +import Graphics.Vulkan.Types.Struct.VkExtent2D (VkExtent2D) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkSurfaceCapabilitiesKHR { +-- > uint32_t minImageCount; +-- > uint32_t maxImageCount; +-- > VkExtent2D currentExtent; +-- > VkExtent2D minImageExtent; +-- > VkExtent2D maxImageExtent; +-- > uint32_t maxImageArrayLayers; +-- > VkSurfaceTransformFlagsKHR supportedTransforms; +-- > VkSurfaceTransformFlagBitsKHR currentTransform; +-- > VkCompositeAlphaFlagsKHR supportedCompositeAlpha; +-- > VkImageUsageFlags supportedUsageFlags; +-- > } VkSurfaceCapabilitiesKHR; +-- +-- +data VkSurfaceCapabilitiesKHR = VkSurfaceCapabilitiesKHR## Addr## + ByteArray## + +instance Eq VkSurfaceCapabilitiesKHR where + (VkSurfaceCapabilitiesKHR## a _) == + x@(VkSurfaceCapabilitiesKHR## b _) = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkSurfaceCapabilitiesKHR where + (VkSurfaceCapabilitiesKHR## a _) `compare` + x@(VkSurfaceCapabilitiesKHR## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkSurfaceCapabilitiesKHR where + sizeOf ~_ = #{size VkSurfaceCapabilitiesKHR} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkSurfaceCapabilitiesKHR} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkSurfaceCapabilitiesKHR where + unsafeAddr (VkSurfaceCapabilitiesKHR## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkSurfaceCapabilitiesKHR## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkSurfaceCapabilitiesKHR## (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkSurfaceCapabilitiesKHR where + type StructFields VkSurfaceCapabilitiesKHR = + '["minImageCount", "maxImageCount", "currentExtent", -- ' closing tick for hsc2hs + "minImageExtent", "maxImageExtent", "maxImageArrayLayers", + "supportedTransforms", "currentTransform", + "supportedCompositeAlpha", "supportedUsageFlags"] + type CUnionType VkSurfaceCapabilitiesKHR = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkSurfaceCapabilitiesKHR = 'True -- ' closing tick for hsc2hs + type StructExtends VkSurfaceCapabilitiesKHR = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkMinImageCount VkSurfaceCapabilitiesKHR where + type VkMinImageCountMType VkSurfaceCapabilitiesKHR = Word32 + + {-# NOINLINE vkMinImageCount #-} + vkMinImageCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSurfaceCapabilitiesKHR, minImageCount}) + + {-# INLINE vkMinImageCountByteOffset #-} + vkMinImageCountByteOffset ~_ + = #{offset VkSurfaceCapabilitiesKHR, minImageCount} + + {-# INLINE readVkMinImageCount #-} + readVkMinImageCount p + = peekByteOff p #{offset VkSurfaceCapabilitiesKHR, minImageCount} + + {-# INLINE writeVkMinImageCount #-} + writeVkMinImageCount p + = pokeByteOff p #{offset VkSurfaceCapabilitiesKHR, minImageCount} + +instance {-# OVERLAPPING #-} + HasField "minImageCount" VkSurfaceCapabilitiesKHR where + type FieldType "minImageCount" VkSurfaceCapabilitiesKHR = Word32 + type FieldOptional "minImageCount" VkSurfaceCapabilitiesKHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "minImageCount" VkSurfaceCapabilitiesKHR = + #{offset VkSurfaceCapabilitiesKHR, minImageCount} + type FieldIsArray "minImageCount" VkSurfaceCapabilitiesKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSurfaceCapabilitiesKHR, minImageCount} + +instance CanReadField "minImageCount" VkSurfaceCapabilitiesKHR + where + {-# INLINE getField #-} + getField = vkMinImageCount + + {-# INLINE readField #-} + readField = readVkMinImageCount + +instance {-# OVERLAPPING #-} + HasVkMaxImageCount VkSurfaceCapabilitiesKHR where + type VkMaxImageCountMType VkSurfaceCapabilitiesKHR = Word32 + + {-# NOINLINE vkMaxImageCount #-} + vkMaxImageCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSurfaceCapabilitiesKHR, maxImageCount}) + + {-# INLINE vkMaxImageCountByteOffset #-} + vkMaxImageCountByteOffset ~_ + = #{offset VkSurfaceCapabilitiesKHR, maxImageCount} + + {-# INLINE readVkMaxImageCount #-} + readVkMaxImageCount p + = peekByteOff p #{offset VkSurfaceCapabilitiesKHR, maxImageCount} + + {-# INLINE writeVkMaxImageCount #-} + writeVkMaxImageCount p + = pokeByteOff p #{offset VkSurfaceCapabilitiesKHR, maxImageCount} + +instance {-# OVERLAPPING #-} + HasField "maxImageCount" VkSurfaceCapabilitiesKHR where + type FieldType "maxImageCount" VkSurfaceCapabilitiesKHR = Word32 + type FieldOptional "maxImageCount" VkSurfaceCapabilitiesKHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "maxImageCount" VkSurfaceCapabilitiesKHR = + #{offset VkSurfaceCapabilitiesKHR, maxImageCount} + type FieldIsArray "maxImageCount" VkSurfaceCapabilitiesKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSurfaceCapabilitiesKHR, maxImageCount} + +instance CanReadField "maxImageCount" VkSurfaceCapabilitiesKHR + where + {-# INLINE getField #-} + getField = vkMaxImageCount + + {-# INLINE readField #-} + readField = readVkMaxImageCount + +instance {-# OVERLAPPING #-} + HasVkCurrentExtent VkSurfaceCapabilitiesKHR where + type VkCurrentExtentMType VkSurfaceCapabilitiesKHR = VkExtent2D + + {-# NOINLINE vkCurrentExtent #-} + vkCurrentExtent x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSurfaceCapabilitiesKHR, currentExtent}) + + {-# INLINE vkCurrentExtentByteOffset #-} + vkCurrentExtentByteOffset ~_ + = #{offset VkSurfaceCapabilitiesKHR, currentExtent} + + {-# INLINE readVkCurrentExtent #-} + readVkCurrentExtent p + = peekByteOff p #{offset VkSurfaceCapabilitiesKHR, currentExtent} + + {-# INLINE writeVkCurrentExtent #-} + writeVkCurrentExtent p + = pokeByteOff p #{offset VkSurfaceCapabilitiesKHR, currentExtent} + +instance {-# OVERLAPPING #-} + HasField "currentExtent" VkSurfaceCapabilitiesKHR where + type FieldType "currentExtent" VkSurfaceCapabilitiesKHR = + VkExtent2D + type FieldOptional "currentExtent" VkSurfaceCapabilitiesKHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "currentExtent" VkSurfaceCapabilitiesKHR = + #{offset VkSurfaceCapabilitiesKHR, currentExtent} + type FieldIsArray "currentExtent" VkSurfaceCapabilitiesKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSurfaceCapabilitiesKHR, currentExtent} + +instance CanReadField "currentExtent" VkSurfaceCapabilitiesKHR + where + {-# INLINE getField #-} + getField = vkCurrentExtent + + {-# INLINE readField #-} + readField = readVkCurrentExtent + +instance {-# OVERLAPPING #-} + HasVkMinImageExtent VkSurfaceCapabilitiesKHR where + type VkMinImageExtentMType VkSurfaceCapabilitiesKHR = VkExtent2D + + {-# NOINLINE vkMinImageExtent #-} + vkMinImageExtent x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSurfaceCapabilitiesKHR, minImageExtent}) + + {-# INLINE vkMinImageExtentByteOffset #-} + vkMinImageExtentByteOffset ~_ + = #{offset VkSurfaceCapabilitiesKHR, minImageExtent} + + {-# INLINE readVkMinImageExtent #-} + readVkMinImageExtent p + = peekByteOff p #{offset VkSurfaceCapabilitiesKHR, minImageExtent} + + {-# INLINE writeVkMinImageExtent #-} + writeVkMinImageExtent p + = pokeByteOff p #{offset VkSurfaceCapabilitiesKHR, minImageExtent} + +instance {-# OVERLAPPING #-} + HasField "minImageExtent" VkSurfaceCapabilitiesKHR where + type FieldType "minImageExtent" VkSurfaceCapabilitiesKHR = + VkExtent2D + type FieldOptional "minImageExtent" VkSurfaceCapabilitiesKHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "minImageExtent" VkSurfaceCapabilitiesKHR = + #{offset VkSurfaceCapabilitiesKHR, minImageExtent} + type FieldIsArray "minImageExtent" VkSurfaceCapabilitiesKHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSurfaceCapabilitiesKHR, minImageExtent} + +instance CanReadField "minImageExtent" VkSurfaceCapabilitiesKHR + where + {-# INLINE getField #-} + getField = vkMinImageExtent + + {-# INLINE readField #-} + readField = readVkMinImageExtent + +instance {-# OVERLAPPING #-} + HasVkMaxImageExtent VkSurfaceCapabilitiesKHR where + type VkMaxImageExtentMType VkSurfaceCapabilitiesKHR = VkExtent2D + + {-# NOINLINE vkMaxImageExtent #-} + vkMaxImageExtent x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSurfaceCapabilitiesKHR, maxImageExtent}) + + {-# INLINE vkMaxImageExtentByteOffset #-} + vkMaxImageExtentByteOffset ~_ + = #{offset VkSurfaceCapabilitiesKHR, maxImageExtent} + + {-# INLINE readVkMaxImageExtent #-} + readVkMaxImageExtent p + = peekByteOff p #{offset VkSurfaceCapabilitiesKHR, maxImageExtent} + + {-# INLINE writeVkMaxImageExtent #-} + writeVkMaxImageExtent p + = pokeByteOff p #{offset VkSurfaceCapabilitiesKHR, maxImageExtent} + +instance {-# OVERLAPPING #-} + HasField "maxImageExtent" VkSurfaceCapabilitiesKHR where + type FieldType "maxImageExtent" VkSurfaceCapabilitiesKHR = + VkExtent2D + type FieldOptional "maxImageExtent" VkSurfaceCapabilitiesKHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "maxImageExtent" VkSurfaceCapabilitiesKHR = + #{offset VkSurfaceCapabilitiesKHR, maxImageExtent} + type FieldIsArray "maxImageExtent" VkSurfaceCapabilitiesKHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSurfaceCapabilitiesKHR, maxImageExtent} + +instance CanReadField "maxImageExtent" VkSurfaceCapabilitiesKHR + where + {-# INLINE getField #-} + getField = vkMaxImageExtent + + {-# INLINE readField #-} + readField = readVkMaxImageExtent + +instance {-# OVERLAPPING #-} + HasVkMaxImageArrayLayers VkSurfaceCapabilitiesKHR where + type VkMaxImageArrayLayersMType VkSurfaceCapabilitiesKHR = Word32 + + {-# NOINLINE vkMaxImageArrayLayers #-} + vkMaxImageArrayLayers x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSurfaceCapabilitiesKHR, maxImageArrayLayers}) + + {-# INLINE vkMaxImageArrayLayersByteOffset #-} + vkMaxImageArrayLayersByteOffset ~_ + = #{offset VkSurfaceCapabilitiesKHR, maxImageArrayLayers} + + {-# INLINE readVkMaxImageArrayLayers #-} + readVkMaxImageArrayLayers p + = peekByteOff p #{offset VkSurfaceCapabilitiesKHR, maxImageArrayLayers} + + {-# INLINE writeVkMaxImageArrayLayers #-} + writeVkMaxImageArrayLayers p + = pokeByteOff p #{offset VkSurfaceCapabilitiesKHR, maxImageArrayLayers} + +instance {-# OVERLAPPING #-} + HasField "maxImageArrayLayers" VkSurfaceCapabilitiesKHR where + type FieldType "maxImageArrayLayers" VkSurfaceCapabilitiesKHR = + Word32 + type FieldOptional "maxImageArrayLayers" VkSurfaceCapabilitiesKHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "maxImageArrayLayers" VkSurfaceCapabilitiesKHR = + #{offset VkSurfaceCapabilitiesKHR, maxImageArrayLayers} + type FieldIsArray "maxImageArrayLayers" VkSurfaceCapabilitiesKHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSurfaceCapabilitiesKHR, maxImageArrayLayers} + +instance CanReadField "maxImageArrayLayers" + VkSurfaceCapabilitiesKHR + where + {-# INLINE getField #-} + getField = vkMaxImageArrayLayers + + {-# INLINE readField #-} + readField = readVkMaxImageArrayLayers + +instance {-# OVERLAPPING #-} + HasVkSupportedTransforms VkSurfaceCapabilitiesKHR where + type VkSupportedTransformsMType VkSurfaceCapabilitiesKHR = + VkSurfaceTransformFlagsKHR + + {-# NOINLINE vkSupportedTransforms #-} + vkSupportedTransforms x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSurfaceCapabilitiesKHR, supportedTransforms}) + + {-# INLINE vkSupportedTransformsByteOffset #-} + vkSupportedTransformsByteOffset ~_ + = #{offset VkSurfaceCapabilitiesKHR, supportedTransforms} + + {-# INLINE readVkSupportedTransforms #-} + readVkSupportedTransforms p + = peekByteOff p #{offset VkSurfaceCapabilitiesKHR, supportedTransforms} + + {-# INLINE writeVkSupportedTransforms #-} + writeVkSupportedTransforms p + = pokeByteOff p #{offset VkSurfaceCapabilitiesKHR, supportedTransforms} + +instance {-# OVERLAPPING #-} + HasField "supportedTransforms" VkSurfaceCapabilitiesKHR where + type FieldType "supportedTransforms" VkSurfaceCapabilitiesKHR = + VkSurfaceTransformFlagsKHR + type FieldOptional "supportedTransforms" VkSurfaceCapabilitiesKHR = + 'True -- ' closing tick for hsc2hs + type FieldOffset "supportedTransforms" VkSurfaceCapabilitiesKHR = + #{offset VkSurfaceCapabilitiesKHR, supportedTransforms} + type FieldIsArray "supportedTransforms" VkSurfaceCapabilitiesKHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSurfaceCapabilitiesKHR, supportedTransforms} + +instance CanReadField "supportedTransforms" + VkSurfaceCapabilitiesKHR + where + {-# INLINE getField #-} + getField = vkSupportedTransforms + + {-# INLINE readField #-} + readField = readVkSupportedTransforms + +instance {-# OVERLAPPING #-} + HasVkCurrentTransform VkSurfaceCapabilitiesKHR where + type VkCurrentTransformMType VkSurfaceCapabilitiesKHR = + VkSurfaceTransformFlagBitsKHR + + {-# NOINLINE vkCurrentTransform #-} + vkCurrentTransform x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSurfaceCapabilitiesKHR, currentTransform}) + + {-# INLINE vkCurrentTransformByteOffset #-} + vkCurrentTransformByteOffset ~_ + = #{offset VkSurfaceCapabilitiesKHR, currentTransform} + + {-# INLINE readVkCurrentTransform #-} + readVkCurrentTransform p + = peekByteOff p #{offset VkSurfaceCapabilitiesKHR, currentTransform} + + {-# INLINE writeVkCurrentTransform #-} + writeVkCurrentTransform p + = pokeByteOff p #{offset VkSurfaceCapabilitiesKHR, currentTransform} + +instance {-# OVERLAPPING #-} + HasField "currentTransform" VkSurfaceCapabilitiesKHR where + type FieldType "currentTransform" VkSurfaceCapabilitiesKHR = + VkSurfaceTransformFlagBitsKHR + type FieldOptional "currentTransform" VkSurfaceCapabilitiesKHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "currentTransform" VkSurfaceCapabilitiesKHR = + #{offset VkSurfaceCapabilitiesKHR, currentTransform} + type FieldIsArray "currentTransform" VkSurfaceCapabilitiesKHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSurfaceCapabilitiesKHR, currentTransform} + +instance CanReadField "currentTransform" VkSurfaceCapabilitiesKHR + where + {-# INLINE getField #-} + getField = vkCurrentTransform + + {-# INLINE readField #-} + readField = readVkCurrentTransform + +instance {-# OVERLAPPING #-} + HasVkSupportedCompositeAlpha VkSurfaceCapabilitiesKHR where + type VkSupportedCompositeAlphaMType VkSurfaceCapabilitiesKHR = + VkCompositeAlphaFlagsKHR + + {-# NOINLINE vkSupportedCompositeAlpha #-} + vkSupportedCompositeAlpha x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSurfaceCapabilitiesKHR, supportedCompositeAlpha}) + + {-# INLINE vkSupportedCompositeAlphaByteOffset #-} + vkSupportedCompositeAlphaByteOffset ~_ + = #{offset VkSurfaceCapabilitiesKHR, supportedCompositeAlpha} + + {-# INLINE readVkSupportedCompositeAlpha #-} + readVkSupportedCompositeAlpha p + = peekByteOff p #{offset VkSurfaceCapabilitiesKHR, supportedCompositeAlpha} + + {-# INLINE writeVkSupportedCompositeAlpha #-} + writeVkSupportedCompositeAlpha p + = pokeByteOff p #{offset VkSurfaceCapabilitiesKHR, supportedCompositeAlpha} + +instance {-# OVERLAPPING #-} + HasField "supportedCompositeAlpha" VkSurfaceCapabilitiesKHR where + type FieldType "supportedCompositeAlpha" VkSurfaceCapabilitiesKHR = + VkCompositeAlphaFlagsKHR + type FieldOptional "supportedCompositeAlpha" + VkSurfaceCapabilitiesKHR + = 'True -- ' closing tick for hsc2hs + type FieldOffset "supportedCompositeAlpha" VkSurfaceCapabilitiesKHR + = + #{offset VkSurfaceCapabilitiesKHR, supportedCompositeAlpha} + type FieldIsArray "supportedCompositeAlpha" + VkSurfaceCapabilitiesKHR + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSurfaceCapabilitiesKHR, supportedCompositeAlpha} + +instance CanReadField "supportedCompositeAlpha" + VkSurfaceCapabilitiesKHR + where + {-# INLINE getField #-} + getField = vkSupportedCompositeAlpha + + {-# INLINE readField #-} + readField = readVkSupportedCompositeAlpha + +instance {-# OVERLAPPING #-} + HasVkSupportedUsageFlags VkSurfaceCapabilitiesKHR where + type VkSupportedUsageFlagsMType VkSurfaceCapabilitiesKHR = + VkImageUsageFlags + + {-# NOINLINE vkSupportedUsageFlags #-} + vkSupportedUsageFlags x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSurfaceCapabilitiesKHR, supportedUsageFlags}) + + {-# INLINE vkSupportedUsageFlagsByteOffset #-} + vkSupportedUsageFlagsByteOffset ~_ + = #{offset VkSurfaceCapabilitiesKHR, supportedUsageFlags} + + {-# INLINE readVkSupportedUsageFlags #-} + readVkSupportedUsageFlags p + = peekByteOff p #{offset VkSurfaceCapabilitiesKHR, supportedUsageFlags} + + {-# INLINE writeVkSupportedUsageFlags #-} + writeVkSupportedUsageFlags p + = pokeByteOff p #{offset VkSurfaceCapabilitiesKHR, supportedUsageFlags} + +instance {-# OVERLAPPING #-} + HasField "supportedUsageFlags" VkSurfaceCapabilitiesKHR where + type FieldType "supportedUsageFlags" VkSurfaceCapabilitiesKHR = + VkImageUsageFlags + type FieldOptional "supportedUsageFlags" VkSurfaceCapabilitiesKHR = + 'True -- ' closing tick for hsc2hs + type FieldOffset "supportedUsageFlags" VkSurfaceCapabilitiesKHR = + #{offset VkSurfaceCapabilitiesKHR, supportedUsageFlags} + type FieldIsArray "supportedUsageFlags" VkSurfaceCapabilitiesKHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSurfaceCapabilitiesKHR, supportedUsageFlags} + +instance CanReadField "supportedUsageFlags" + VkSurfaceCapabilitiesKHR + where + {-# INLINE getField #-} + getField = vkSupportedUsageFlags + + {-# INLINE readField #-} + readField = readVkSupportedUsageFlags + +instance Show VkSurfaceCapabilitiesKHR where + showsPrec d x + = showString "VkSurfaceCapabilitiesKHR {" . + showString "vkMinImageCount = " . + showsPrec d (vkMinImageCount x) . + showString ", " . + showString "vkMaxImageCount = " . + showsPrec d (vkMaxImageCount x) . + showString ", " . + showString "vkCurrentExtent = " . + showsPrec d (vkCurrentExtent x) . + showString ", " . + showString "vkMinImageExtent = " . + showsPrec d (vkMinImageExtent x) . + showString ", " . + showString "vkMaxImageExtent = " . + showsPrec d (vkMaxImageExtent x) . + showString ", " . + showString "vkMaxImageArrayLayers = " . + showsPrec d (vkMaxImageArrayLayers x) . + showString ", " . + showString "vkSupportedTransforms = " . + showsPrec d (vkSupportedTransforms x) . + showString ", " . + showString "vkCurrentTransform = " . + showsPrec d (vkCurrentTransform x) . + showString ", " . + showString + "vkSupportedCompositeAlpha = " + . + showsPrec d + (vkSupportedCompositeAlpha x) + . + showString ", " . + showString + "vkSupportedUsageFlags = " + . + showsPrec d + (vkSupportedUsageFlags x) + . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkSurfaceFormat2KHR.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkSurfaceFormat2KHR.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkSurfaceFormat2KHR.hsc @@ -0,0 +1,210 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkSurfaceFormat2KHR + (VkSurfaceFormat2KHR(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Struct.VkSurfaceFormatKHR (VkSurfaceFormatKHR) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkSurfaceFormat2KHR { +-- > VkStructureType sType; +-- > void* pNext; +-- > VkSurfaceFormatKHR surfaceFormat; +-- > } VkSurfaceFormat2KHR; +-- +-- +data VkSurfaceFormat2KHR = VkSurfaceFormat2KHR## Addr## ByteArray## + +instance Eq VkSurfaceFormat2KHR where + (VkSurfaceFormat2KHR## a _) == x@(VkSurfaceFormat2KHR## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkSurfaceFormat2KHR where + (VkSurfaceFormat2KHR## a _) `compare` x@(VkSurfaceFormat2KHR## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkSurfaceFormat2KHR where + sizeOf ~_ = #{size VkSurfaceFormat2KHR} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkSurfaceFormat2KHR} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkSurfaceFormat2KHR where + unsafeAddr (VkSurfaceFormat2KHR## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkSurfaceFormat2KHR## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkSurfaceFormat2KHR## (plusAddr## (byteArrayContents## b) off) b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkSurfaceFormat2KHR where + type StructFields VkSurfaceFormat2KHR = + '["sType", "pNext", "surfaceFormat"] -- ' closing tick for hsc2hs + type CUnionType VkSurfaceFormat2KHR = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkSurfaceFormat2KHR = 'True -- ' closing tick for hsc2hs + type StructExtends VkSurfaceFormat2KHR = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkSType VkSurfaceFormat2KHR where + type VkSTypeMType VkSurfaceFormat2KHR = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSurfaceFormat2KHR, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkSurfaceFormat2KHR, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkSurfaceFormat2KHR, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkSurfaceFormat2KHR, sType} + +instance {-# OVERLAPPING #-} HasField "sType" VkSurfaceFormat2KHR + where + type FieldType "sType" VkSurfaceFormat2KHR = VkStructureType + type FieldOptional "sType" VkSurfaceFormat2KHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkSurfaceFormat2KHR = + #{offset VkSurfaceFormat2KHR, sType} + type FieldIsArray "sType" VkSurfaceFormat2KHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkSurfaceFormat2KHR, sType} + +instance CanReadField "sType" VkSurfaceFormat2KHR where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance {-# OVERLAPPING #-} HasVkPNext VkSurfaceFormat2KHR where + type VkPNextMType VkSurfaceFormat2KHR = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSurfaceFormat2KHR, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkSurfaceFormat2KHR, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkSurfaceFormat2KHR, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkSurfaceFormat2KHR, pNext} + +instance {-# OVERLAPPING #-} HasField "pNext" VkSurfaceFormat2KHR + where + type FieldType "pNext" VkSurfaceFormat2KHR = Ptr Void + type FieldOptional "pNext" VkSurfaceFormat2KHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkSurfaceFormat2KHR = + #{offset VkSurfaceFormat2KHR, pNext} + type FieldIsArray "pNext" VkSurfaceFormat2KHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkSurfaceFormat2KHR, pNext} + +instance CanReadField "pNext" VkSurfaceFormat2KHR where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance {-# OVERLAPPING #-} HasVkSurfaceFormat VkSurfaceFormat2KHR + where + type VkSurfaceFormatMType VkSurfaceFormat2KHR = VkSurfaceFormatKHR + + {-# NOINLINE vkSurfaceFormat #-} + vkSurfaceFormat x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSurfaceFormat2KHR, surfaceFormat}) + + {-# INLINE vkSurfaceFormatByteOffset #-} + vkSurfaceFormatByteOffset ~_ + = #{offset VkSurfaceFormat2KHR, surfaceFormat} + + {-# INLINE readVkSurfaceFormat #-} + readVkSurfaceFormat p + = peekByteOff p #{offset VkSurfaceFormat2KHR, surfaceFormat} + + {-# INLINE writeVkSurfaceFormat #-} + writeVkSurfaceFormat p + = pokeByteOff p #{offset VkSurfaceFormat2KHR, surfaceFormat} + +instance {-# OVERLAPPING #-} + HasField "surfaceFormat" VkSurfaceFormat2KHR where + type FieldType "surfaceFormat" VkSurfaceFormat2KHR = + VkSurfaceFormatKHR + type FieldOptional "surfaceFormat" VkSurfaceFormat2KHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "surfaceFormat" VkSurfaceFormat2KHR = + #{offset VkSurfaceFormat2KHR, surfaceFormat} + type FieldIsArray "surfaceFormat" VkSurfaceFormat2KHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSurfaceFormat2KHR, surfaceFormat} + +instance CanReadField "surfaceFormat" VkSurfaceFormat2KHR where + {-# INLINE getField #-} + getField = vkSurfaceFormat + + {-# INLINE readField #-} + readField = readVkSurfaceFormat + +instance Show VkSurfaceFormat2KHR where + showsPrec d x + = showString "VkSurfaceFormat2KHR {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkSurfaceFormat = " . + showsPrec d (vkSurfaceFormat x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkSurfaceFormatKHR.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkSurfaceFormatKHR.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkSurfaceFormatKHR.hsc @@ -0,0 +1,162 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkSurfaceFormatKHR + (VkSurfaceFormatKHR(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkColorSpaceKHR (VkColorSpaceKHR) +import Graphics.Vulkan.Types.Enum.VkFormat (VkFormat) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkSurfaceFormatKHR { +-- > VkFormat format; +-- > VkColorSpaceKHR colorSpace; +-- > } VkSurfaceFormatKHR; +-- +-- +data VkSurfaceFormatKHR = VkSurfaceFormatKHR## Addr## ByteArray## + +instance Eq VkSurfaceFormatKHR where + (VkSurfaceFormatKHR## a _) == x@(VkSurfaceFormatKHR## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkSurfaceFormatKHR where + (VkSurfaceFormatKHR## a _) `compare` x@(VkSurfaceFormatKHR## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkSurfaceFormatKHR where + sizeOf ~_ = #{size VkSurfaceFormatKHR} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkSurfaceFormatKHR} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkSurfaceFormatKHR where + unsafeAddr (VkSurfaceFormatKHR## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkSurfaceFormatKHR## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkSurfaceFormatKHR## (plusAddr## (byteArrayContents## b) off) b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkSurfaceFormatKHR where + type StructFields VkSurfaceFormatKHR = '["format", "colorSpace"] -- ' closing tick for hsc2hs + type CUnionType VkSurfaceFormatKHR = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkSurfaceFormatKHR = 'True -- ' closing tick for hsc2hs + type StructExtends VkSurfaceFormatKHR = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkFormat VkSurfaceFormatKHR where + type VkFormatMType VkSurfaceFormatKHR = VkFormat + + {-# NOINLINE vkFormat #-} + vkFormat x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSurfaceFormatKHR, format}) + + {-# INLINE vkFormatByteOffset #-} + vkFormatByteOffset ~_ + = #{offset VkSurfaceFormatKHR, format} + + {-# INLINE readVkFormat #-} + readVkFormat p + = peekByteOff p #{offset VkSurfaceFormatKHR, format} + + {-# INLINE writeVkFormat #-} + writeVkFormat p + = pokeByteOff p #{offset VkSurfaceFormatKHR, format} + +instance {-# OVERLAPPING #-} HasField "format" VkSurfaceFormatKHR + where + type FieldType "format" VkSurfaceFormatKHR = VkFormat + type FieldOptional "format" VkSurfaceFormatKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "format" VkSurfaceFormatKHR = + #{offset VkSurfaceFormatKHR, format} + type FieldIsArray "format" VkSurfaceFormatKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkSurfaceFormatKHR, format} + +instance CanReadField "format" VkSurfaceFormatKHR where + {-# INLINE getField #-} + getField = vkFormat + + {-# INLINE readField #-} + readField = readVkFormat + +instance {-# OVERLAPPING #-} HasVkColorSpace VkSurfaceFormatKHR + where + type VkColorSpaceMType VkSurfaceFormatKHR = VkColorSpaceKHR + + {-# NOINLINE vkColorSpace #-} + vkColorSpace x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSurfaceFormatKHR, colorSpace}) + + {-# INLINE vkColorSpaceByteOffset #-} + vkColorSpaceByteOffset ~_ + = #{offset VkSurfaceFormatKHR, colorSpace} + + {-# INLINE readVkColorSpace #-} + readVkColorSpace p + = peekByteOff p #{offset VkSurfaceFormatKHR, colorSpace} + + {-# INLINE writeVkColorSpace #-} + writeVkColorSpace p + = pokeByteOff p #{offset VkSurfaceFormatKHR, colorSpace} + +instance {-# OVERLAPPING #-} + HasField "colorSpace" VkSurfaceFormatKHR where + type FieldType "colorSpace" VkSurfaceFormatKHR = VkColorSpaceKHR + type FieldOptional "colorSpace" VkSurfaceFormatKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "colorSpace" VkSurfaceFormatKHR = + #{offset VkSurfaceFormatKHR, colorSpace} + type FieldIsArray "colorSpace" VkSurfaceFormatKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkSurfaceFormatKHR, colorSpace} + +instance CanReadField "colorSpace" VkSurfaceFormatKHR where + {-# INLINE getField #-} + getField = vkColorSpace + + {-# INLINE readField #-} + readField = readVkColorSpace + +instance Show VkSurfaceFormatKHR where + showsPrec d x + = showString "VkSurfaceFormatKHR {" . + showString "vkFormat = " . + showsPrec d (vkFormat x) . + showString ", " . + showString "vkColorSpace = " . + showsPrec d (vkColorSpace x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkSwapchainCounterCreateInfoEXT.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkSwapchainCounterCreateInfoEXT.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkSwapchainCounterCreateInfoEXT.hsc @@ -0,0 +1,245 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkSwapchainCounterCreateInfoEXT + (VkSwapchainCounterCreateInfoEXT(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Enum.VkSurfaceCounterFlagsEXT (VkSurfaceCounterFlagsEXT) +import Graphics.Vulkan.Types.Struct.VkSwapchainCreateInfoKHR (VkSwapchainCreateInfoKHR) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkSwapchainCounterCreateInfoEXT { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkSurfaceCounterFlagsEXT surfaceCounters; +-- > } VkSwapchainCounterCreateInfoEXT; +-- +-- +data VkSwapchainCounterCreateInfoEXT = VkSwapchainCounterCreateInfoEXT## Addr## + ByteArray## + +instance Eq VkSwapchainCounterCreateInfoEXT where + (VkSwapchainCounterCreateInfoEXT## a _) == + x@(VkSwapchainCounterCreateInfoEXT## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkSwapchainCounterCreateInfoEXT where + (VkSwapchainCounterCreateInfoEXT## a _) `compare` + x@(VkSwapchainCounterCreateInfoEXT## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkSwapchainCounterCreateInfoEXT where + sizeOf ~_ = #{size VkSwapchainCounterCreateInfoEXT} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkSwapchainCounterCreateInfoEXT} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkSwapchainCounterCreateInfoEXT where + unsafeAddr (VkSwapchainCounterCreateInfoEXT## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkSwapchainCounterCreateInfoEXT## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkSwapchainCounterCreateInfoEXT## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkSwapchainCounterCreateInfoEXT where + type StructFields VkSwapchainCounterCreateInfoEXT = + '["sType", "pNext", "surfaceCounters"] -- ' closing tick for hsc2hs + type CUnionType VkSwapchainCounterCreateInfoEXT = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkSwapchainCounterCreateInfoEXT = 'False -- ' closing tick for hsc2hs + type StructExtends VkSwapchainCounterCreateInfoEXT = + '[VkSwapchainCreateInfoKHR] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkSwapchainCounterCreateInfoEXT where + type VkSTypeMType VkSwapchainCounterCreateInfoEXT = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSwapchainCounterCreateInfoEXT, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkSwapchainCounterCreateInfoEXT, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkSwapchainCounterCreateInfoEXT, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkSwapchainCounterCreateInfoEXT, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkSwapchainCounterCreateInfoEXT where + type FieldType "sType" VkSwapchainCounterCreateInfoEXT = + VkStructureType + type FieldOptional "sType" VkSwapchainCounterCreateInfoEXT = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkSwapchainCounterCreateInfoEXT = + #{offset VkSwapchainCounterCreateInfoEXT, sType} + type FieldIsArray "sType" VkSwapchainCounterCreateInfoEXT = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSwapchainCounterCreateInfoEXT, sType} + +instance CanReadField "sType" VkSwapchainCounterCreateInfoEXT where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkSwapchainCounterCreateInfoEXT + where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkSwapchainCounterCreateInfoEXT where + type VkPNextMType VkSwapchainCounterCreateInfoEXT = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSwapchainCounterCreateInfoEXT, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkSwapchainCounterCreateInfoEXT, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkSwapchainCounterCreateInfoEXT, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkSwapchainCounterCreateInfoEXT, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkSwapchainCounterCreateInfoEXT where + type FieldType "pNext" VkSwapchainCounterCreateInfoEXT = Ptr Void + type FieldOptional "pNext" VkSwapchainCounterCreateInfoEXT = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkSwapchainCounterCreateInfoEXT = + #{offset VkSwapchainCounterCreateInfoEXT, pNext} + type FieldIsArray "pNext" VkSwapchainCounterCreateInfoEXT = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSwapchainCounterCreateInfoEXT, pNext} + +instance CanReadField "pNext" VkSwapchainCounterCreateInfoEXT where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkSwapchainCounterCreateInfoEXT + where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkSurfaceCounters VkSwapchainCounterCreateInfoEXT where + type VkSurfaceCountersMType VkSwapchainCounterCreateInfoEXT = + VkSurfaceCounterFlagsEXT + + {-# NOINLINE vkSurfaceCounters #-} + vkSurfaceCounters x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSwapchainCounterCreateInfoEXT, surfaceCounters}) + + {-# INLINE vkSurfaceCountersByteOffset #-} + vkSurfaceCountersByteOffset ~_ + = #{offset VkSwapchainCounterCreateInfoEXT, surfaceCounters} + + {-# INLINE readVkSurfaceCounters #-} + readVkSurfaceCounters p + = peekByteOff p #{offset VkSwapchainCounterCreateInfoEXT, surfaceCounters} + + {-# INLINE writeVkSurfaceCounters #-} + writeVkSurfaceCounters p + = pokeByteOff p #{offset VkSwapchainCounterCreateInfoEXT, surfaceCounters} + +instance {-# OVERLAPPING #-} + HasField "surfaceCounters" VkSwapchainCounterCreateInfoEXT where + type FieldType "surfaceCounters" VkSwapchainCounterCreateInfoEXT = + VkSurfaceCounterFlagsEXT + type FieldOptional "surfaceCounters" + VkSwapchainCounterCreateInfoEXT + = 'True -- ' closing tick for hsc2hs + type FieldOffset "surfaceCounters" VkSwapchainCounterCreateInfoEXT + = + #{offset VkSwapchainCounterCreateInfoEXT, surfaceCounters} + type FieldIsArray "surfaceCounters" VkSwapchainCounterCreateInfoEXT + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSwapchainCounterCreateInfoEXT, surfaceCounters} + +instance CanReadField "surfaceCounters" + VkSwapchainCounterCreateInfoEXT + where + {-# INLINE getField #-} + getField = vkSurfaceCounters + + {-# INLINE readField #-} + readField = readVkSurfaceCounters + +instance CanWriteField "surfaceCounters" + VkSwapchainCounterCreateInfoEXT + where + {-# INLINE writeField #-} + writeField = writeVkSurfaceCounters + +instance Show VkSwapchainCounterCreateInfoEXT where + showsPrec d x + = showString "VkSwapchainCounterCreateInfoEXT {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkSurfaceCounters = " . + showsPrec d (vkSurfaceCounters x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkSwapchainCreateInfoKHR.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkSwapchainCreateInfoKHR.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkSwapchainCreateInfoKHR.hsc @@ -0,0 +1,1110 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkSwapchainCreateInfoKHR + (VkSwapchainCreateInfoKHR(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.BaseTypes (VkBool32) +import Graphics.Vulkan.Types.Enum.VkColorSpaceKHR (VkColorSpaceKHR) +import Graphics.Vulkan.Types.Enum.VkCompositeAlphaFlagsKHR (VkCompositeAlphaFlagBitsKHR) +import Graphics.Vulkan.Types.Enum.VkFormat (VkFormat) +import Graphics.Vulkan.Types.Enum.VkImageUsageFlags (VkImageUsageFlags) +import Graphics.Vulkan.Types.Enum.VkPresentModeKHR (VkPresentModeKHR) +import Graphics.Vulkan.Types.Enum.VkSharingMode (VkSharingMode) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Enum.VkSurfaceTransformFlagsKHR (VkSurfaceTransformFlagBitsKHR) +import Graphics.Vulkan.Types.Enum.VkSwapchainCreateFlagsKHR (VkSwapchainCreateFlagsKHR) +import Graphics.Vulkan.Types.Handles (VkSurfaceKHR, + VkSwapchainKHR) +import Graphics.Vulkan.Types.Struct.VkExtent2D (VkExtent2D) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkSwapchainCreateInfoKHR { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkSwapchainCreateFlagsKHR flags; +-- > VkSurfaceKHR surface; +-- > uint32_t minImageCount; +-- > VkFormat imageFormat; +-- > VkColorSpaceKHR imageColorSpace; +-- > VkExtent2D imageExtent; +-- > uint32_t imageArrayLayers; +-- > VkImageUsageFlags imageUsage; +-- > VkSharingMode imageSharingMode; +-- > uint32_t queueFamilyIndexCount; +-- > const uint32_t* pQueueFamilyIndices; +-- > VkSurfaceTransformFlagBitsKHR preTransform; +-- > VkCompositeAlphaFlagBitsKHR compositeAlpha; +-- > VkPresentModeKHR presentMode; +-- > VkBool32 clipped; +-- > VkSwapchainKHR oldSwapchain; +-- > } VkSwapchainCreateInfoKHR; +-- +-- +data VkSwapchainCreateInfoKHR = VkSwapchainCreateInfoKHR## Addr## + ByteArray## + +instance Eq VkSwapchainCreateInfoKHR where + (VkSwapchainCreateInfoKHR## a _) == + x@(VkSwapchainCreateInfoKHR## b _) = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkSwapchainCreateInfoKHR where + (VkSwapchainCreateInfoKHR## a _) `compare` + x@(VkSwapchainCreateInfoKHR## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkSwapchainCreateInfoKHR where + sizeOf ~_ = #{size VkSwapchainCreateInfoKHR} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkSwapchainCreateInfoKHR} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkSwapchainCreateInfoKHR where + unsafeAddr (VkSwapchainCreateInfoKHR## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkSwapchainCreateInfoKHR## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkSwapchainCreateInfoKHR## (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkSwapchainCreateInfoKHR where + type StructFields VkSwapchainCreateInfoKHR = + '["sType", "pNext", "flags", "surface", "minImageCount", -- ' closing tick for hsc2hs + "imageFormat", "imageColorSpace", "imageExtent", + "imageArrayLayers", "imageUsage", "imageSharingMode", + "queueFamilyIndexCount", "pQueueFamilyIndices", "preTransform", + "compositeAlpha", "presentMode", "clipped", "oldSwapchain"] + type CUnionType VkSwapchainCreateInfoKHR = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkSwapchainCreateInfoKHR = 'False -- ' closing tick for hsc2hs + type StructExtends VkSwapchainCreateInfoKHR = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkSType VkSwapchainCreateInfoKHR + where + type VkSTypeMType VkSwapchainCreateInfoKHR = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSwapchainCreateInfoKHR, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkSwapchainCreateInfoKHR, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkSwapchainCreateInfoKHR, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkSwapchainCreateInfoKHR, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkSwapchainCreateInfoKHR where + type FieldType "sType" VkSwapchainCreateInfoKHR = VkStructureType + type FieldOptional "sType" VkSwapchainCreateInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkSwapchainCreateInfoKHR = + #{offset VkSwapchainCreateInfoKHR, sType} + type FieldIsArray "sType" VkSwapchainCreateInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkSwapchainCreateInfoKHR, sType} + +instance CanReadField "sType" VkSwapchainCreateInfoKHR where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkSwapchainCreateInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} HasVkPNext VkSwapchainCreateInfoKHR + where + type VkPNextMType VkSwapchainCreateInfoKHR = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSwapchainCreateInfoKHR, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkSwapchainCreateInfoKHR, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkSwapchainCreateInfoKHR, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkSwapchainCreateInfoKHR, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkSwapchainCreateInfoKHR where + type FieldType "pNext" VkSwapchainCreateInfoKHR = Ptr Void + type FieldOptional "pNext" VkSwapchainCreateInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkSwapchainCreateInfoKHR = + #{offset VkSwapchainCreateInfoKHR, pNext} + type FieldIsArray "pNext" VkSwapchainCreateInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkSwapchainCreateInfoKHR, pNext} + +instance CanReadField "pNext" VkSwapchainCreateInfoKHR where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkSwapchainCreateInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} HasVkFlags VkSwapchainCreateInfoKHR + where + type VkFlagsMType VkSwapchainCreateInfoKHR = + VkSwapchainCreateFlagsKHR + + {-# NOINLINE vkFlags #-} + vkFlags x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSwapchainCreateInfoKHR, flags}) + + {-# INLINE vkFlagsByteOffset #-} + vkFlagsByteOffset ~_ + = #{offset VkSwapchainCreateInfoKHR, flags} + + {-# INLINE readVkFlags #-} + readVkFlags p + = peekByteOff p #{offset VkSwapchainCreateInfoKHR, flags} + + {-# INLINE writeVkFlags #-} + writeVkFlags p + = pokeByteOff p #{offset VkSwapchainCreateInfoKHR, flags} + +instance {-# OVERLAPPING #-} + HasField "flags" VkSwapchainCreateInfoKHR where + type FieldType "flags" VkSwapchainCreateInfoKHR = + VkSwapchainCreateFlagsKHR + type FieldOptional "flags" VkSwapchainCreateInfoKHR = 'True -- ' closing tick for hsc2hs + type FieldOffset "flags" VkSwapchainCreateInfoKHR = + #{offset VkSwapchainCreateInfoKHR, flags} + type FieldIsArray "flags" VkSwapchainCreateInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkSwapchainCreateInfoKHR, flags} + +instance CanReadField "flags" VkSwapchainCreateInfoKHR where + {-# INLINE getField #-} + getField = vkFlags + + {-# INLINE readField #-} + readField = readVkFlags + +instance CanWriteField "flags" VkSwapchainCreateInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkFlags + +instance {-# OVERLAPPING #-} HasVkSurface VkSwapchainCreateInfoKHR + where + type VkSurfaceMType VkSwapchainCreateInfoKHR = VkSurfaceKHR + + {-# NOINLINE vkSurface #-} + vkSurface x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSwapchainCreateInfoKHR, surface}) + + {-# INLINE vkSurfaceByteOffset #-} + vkSurfaceByteOffset ~_ + = #{offset VkSwapchainCreateInfoKHR, surface} + + {-# INLINE readVkSurface #-} + readVkSurface p + = peekByteOff p #{offset VkSwapchainCreateInfoKHR, surface} + + {-# INLINE writeVkSurface #-} + writeVkSurface p + = pokeByteOff p #{offset VkSwapchainCreateInfoKHR, surface} + +instance {-# OVERLAPPING #-} + HasField "surface" VkSwapchainCreateInfoKHR where + type FieldType "surface" VkSwapchainCreateInfoKHR = VkSurfaceKHR + type FieldOptional "surface" VkSwapchainCreateInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "surface" VkSwapchainCreateInfoKHR = + #{offset VkSwapchainCreateInfoKHR, surface} + type FieldIsArray "surface" VkSwapchainCreateInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSwapchainCreateInfoKHR, surface} + +instance CanReadField "surface" VkSwapchainCreateInfoKHR where + {-# INLINE getField #-} + getField = vkSurface + + {-# INLINE readField #-} + readField = readVkSurface + +instance CanWriteField "surface" VkSwapchainCreateInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkSurface + +instance {-# OVERLAPPING #-} + HasVkMinImageCount VkSwapchainCreateInfoKHR where + type VkMinImageCountMType VkSwapchainCreateInfoKHR = Word32 + + {-# NOINLINE vkMinImageCount #-} + vkMinImageCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSwapchainCreateInfoKHR, minImageCount}) + + {-# INLINE vkMinImageCountByteOffset #-} + vkMinImageCountByteOffset ~_ + = #{offset VkSwapchainCreateInfoKHR, minImageCount} + + {-# INLINE readVkMinImageCount #-} + readVkMinImageCount p + = peekByteOff p #{offset VkSwapchainCreateInfoKHR, minImageCount} + + {-# INLINE writeVkMinImageCount #-} + writeVkMinImageCount p + = pokeByteOff p #{offset VkSwapchainCreateInfoKHR, minImageCount} + +instance {-# OVERLAPPING #-} + HasField "minImageCount" VkSwapchainCreateInfoKHR where + type FieldType "minImageCount" VkSwapchainCreateInfoKHR = Word32 + type FieldOptional "minImageCount" VkSwapchainCreateInfoKHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "minImageCount" VkSwapchainCreateInfoKHR = + #{offset VkSwapchainCreateInfoKHR, minImageCount} + type FieldIsArray "minImageCount" VkSwapchainCreateInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSwapchainCreateInfoKHR, minImageCount} + +instance CanReadField "minImageCount" VkSwapchainCreateInfoKHR + where + {-# INLINE getField #-} + getField = vkMinImageCount + + {-# INLINE readField #-} + readField = readVkMinImageCount + +instance CanWriteField "minImageCount" VkSwapchainCreateInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkMinImageCount + +instance {-# OVERLAPPING #-} + HasVkImageFormat VkSwapchainCreateInfoKHR where + type VkImageFormatMType VkSwapchainCreateInfoKHR = VkFormat + + {-# NOINLINE vkImageFormat #-} + vkImageFormat x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSwapchainCreateInfoKHR, imageFormat}) + + {-# INLINE vkImageFormatByteOffset #-} + vkImageFormatByteOffset ~_ + = #{offset VkSwapchainCreateInfoKHR, imageFormat} + + {-# INLINE readVkImageFormat #-} + readVkImageFormat p + = peekByteOff p #{offset VkSwapchainCreateInfoKHR, imageFormat} + + {-# INLINE writeVkImageFormat #-} + writeVkImageFormat p + = pokeByteOff p #{offset VkSwapchainCreateInfoKHR, imageFormat} + +instance {-# OVERLAPPING #-} + HasField "imageFormat" VkSwapchainCreateInfoKHR where + type FieldType "imageFormat" VkSwapchainCreateInfoKHR = VkFormat + type FieldOptional "imageFormat" VkSwapchainCreateInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "imageFormat" VkSwapchainCreateInfoKHR = + #{offset VkSwapchainCreateInfoKHR, imageFormat} + type FieldIsArray "imageFormat" VkSwapchainCreateInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSwapchainCreateInfoKHR, imageFormat} + +instance CanReadField "imageFormat" VkSwapchainCreateInfoKHR where + {-# INLINE getField #-} + getField = vkImageFormat + + {-# INLINE readField #-} + readField = readVkImageFormat + +instance CanWriteField "imageFormat" VkSwapchainCreateInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkImageFormat + +instance {-# OVERLAPPING #-} + HasVkImageColorSpace VkSwapchainCreateInfoKHR where + type VkImageColorSpaceMType VkSwapchainCreateInfoKHR = + VkColorSpaceKHR + + {-# NOINLINE vkImageColorSpace #-} + vkImageColorSpace x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSwapchainCreateInfoKHR, imageColorSpace}) + + {-# INLINE vkImageColorSpaceByteOffset #-} + vkImageColorSpaceByteOffset ~_ + = #{offset VkSwapchainCreateInfoKHR, imageColorSpace} + + {-# INLINE readVkImageColorSpace #-} + readVkImageColorSpace p + = peekByteOff p #{offset VkSwapchainCreateInfoKHR, imageColorSpace} + + {-# INLINE writeVkImageColorSpace #-} + writeVkImageColorSpace p + = pokeByteOff p #{offset VkSwapchainCreateInfoKHR, imageColorSpace} + +instance {-# OVERLAPPING #-} + HasField "imageColorSpace" VkSwapchainCreateInfoKHR where + type FieldType "imageColorSpace" VkSwapchainCreateInfoKHR = + VkColorSpaceKHR + type FieldOptional "imageColorSpace" VkSwapchainCreateInfoKHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "imageColorSpace" VkSwapchainCreateInfoKHR = + #{offset VkSwapchainCreateInfoKHR, imageColorSpace} + type FieldIsArray "imageColorSpace" VkSwapchainCreateInfoKHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSwapchainCreateInfoKHR, imageColorSpace} + +instance CanReadField "imageColorSpace" VkSwapchainCreateInfoKHR + where + {-# INLINE getField #-} + getField = vkImageColorSpace + + {-# INLINE readField #-} + readField = readVkImageColorSpace + +instance CanWriteField "imageColorSpace" VkSwapchainCreateInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkImageColorSpace + +instance {-# OVERLAPPING #-} + HasVkImageExtent VkSwapchainCreateInfoKHR where + type VkImageExtentMType VkSwapchainCreateInfoKHR = VkExtent2D + + {-# NOINLINE vkImageExtent #-} + vkImageExtent x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSwapchainCreateInfoKHR, imageExtent}) + + {-# INLINE vkImageExtentByteOffset #-} + vkImageExtentByteOffset ~_ + = #{offset VkSwapchainCreateInfoKHR, imageExtent} + + {-# INLINE readVkImageExtent #-} + readVkImageExtent p + = peekByteOff p #{offset VkSwapchainCreateInfoKHR, imageExtent} + + {-# INLINE writeVkImageExtent #-} + writeVkImageExtent p + = pokeByteOff p #{offset VkSwapchainCreateInfoKHR, imageExtent} + +instance {-# OVERLAPPING #-} + HasField "imageExtent" VkSwapchainCreateInfoKHR where + type FieldType "imageExtent" VkSwapchainCreateInfoKHR = VkExtent2D + type FieldOptional "imageExtent" VkSwapchainCreateInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "imageExtent" VkSwapchainCreateInfoKHR = + #{offset VkSwapchainCreateInfoKHR, imageExtent} + type FieldIsArray "imageExtent" VkSwapchainCreateInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSwapchainCreateInfoKHR, imageExtent} + +instance CanReadField "imageExtent" VkSwapchainCreateInfoKHR where + {-# INLINE getField #-} + getField = vkImageExtent + + {-# INLINE readField #-} + readField = readVkImageExtent + +instance CanWriteField "imageExtent" VkSwapchainCreateInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkImageExtent + +instance {-# OVERLAPPING #-} + HasVkImageArrayLayers VkSwapchainCreateInfoKHR where + type VkImageArrayLayersMType VkSwapchainCreateInfoKHR = Word32 + + {-# NOINLINE vkImageArrayLayers #-} + vkImageArrayLayers x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSwapchainCreateInfoKHR, imageArrayLayers}) + + {-# INLINE vkImageArrayLayersByteOffset #-} + vkImageArrayLayersByteOffset ~_ + = #{offset VkSwapchainCreateInfoKHR, imageArrayLayers} + + {-# INLINE readVkImageArrayLayers #-} + readVkImageArrayLayers p + = peekByteOff p #{offset VkSwapchainCreateInfoKHR, imageArrayLayers} + + {-# INLINE writeVkImageArrayLayers #-} + writeVkImageArrayLayers p + = pokeByteOff p #{offset VkSwapchainCreateInfoKHR, imageArrayLayers} + +instance {-# OVERLAPPING #-} + HasField "imageArrayLayers" VkSwapchainCreateInfoKHR where + type FieldType "imageArrayLayers" VkSwapchainCreateInfoKHR = Word32 + type FieldOptional "imageArrayLayers" VkSwapchainCreateInfoKHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "imageArrayLayers" VkSwapchainCreateInfoKHR = + #{offset VkSwapchainCreateInfoKHR, imageArrayLayers} + type FieldIsArray "imageArrayLayers" VkSwapchainCreateInfoKHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSwapchainCreateInfoKHR, imageArrayLayers} + +instance CanReadField "imageArrayLayers" VkSwapchainCreateInfoKHR + where + {-# INLINE getField #-} + getField = vkImageArrayLayers + + {-# INLINE readField #-} + readField = readVkImageArrayLayers + +instance CanWriteField "imageArrayLayers" VkSwapchainCreateInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkImageArrayLayers + +instance {-# OVERLAPPING #-} + HasVkImageUsage VkSwapchainCreateInfoKHR where + type VkImageUsageMType VkSwapchainCreateInfoKHR = VkImageUsageFlags + + {-# NOINLINE vkImageUsage #-} + vkImageUsage x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSwapchainCreateInfoKHR, imageUsage}) + + {-# INLINE vkImageUsageByteOffset #-} + vkImageUsageByteOffset ~_ + = #{offset VkSwapchainCreateInfoKHR, imageUsage} + + {-# INLINE readVkImageUsage #-} + readVkImageUsage p + = peekByteOff p #{offset VkSwapchainCreateInfoKHR, imageUsage} + + {-# INLINE writeVkImageUsage #-} + writeVkImageUsage p + = pokeByteOff p #{offset VkSwapchainCreateInfoKHR, imageUsage} + +instance {-# OVERLAPPING #-} + HasField "imageUsage" VkSwapchainCreateInfoKHR where + type FieldType "imageUsage" VkSwapchainCreateInfoKHR = + VkImageUsageFlags + type FieldOptional "imageUsage" VkSwapchainCreateInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "imageUsage" VkSwapchainCreateInfoKHR = + #{offset VkSwapchainCreateInfoKHR, imageUsage} + type FieldIsArray "imageUsage" VkSwapchainCreateInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSwapchainCreateInfoKHR, imageUsage} + +instance CanReadField "imageUsage" VkSwapchainCreateInfoKHR where + {-# INLINE getField #-} + getField = vkImageUsage + + {-# INLINE readField #-} + readField = readVkImageUsage + +instance CanWriteField "imageUsage" VkSwapchainCreateInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkImageUsage + +instance {-# OVERLAPPING #-} + HasVkImageSharingMode VkSwapchainCreateInfoKHR where + type VkImageSharingModeMType VkSwapchainCreateInfoKHR = + VkSharingMode + + {-# NOINLINE vkImageSharingMode #-} + vkImageSharingMode x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSwapchainCreateInfoKHR, imageSharingMode}) + + {-# INLINE vkImageSharingModeByteOffset #-} + vkImageSharingModeByteOffset ~_ + = #{offset VkSwapchainCreateInfoKHR, imageSharingMode} + + {-# INLINE readVkImageSharingMode #-} + readVkImageSharingMode p + = peekByteOff p #{offset VkSwapchainCreateInfoKHR, imageSharingMode} + + {-# INLINE writeVkImageSharingMode #-} + writeVkImageSharingMode p + = pokeByteOff p #{offset VkSwapchainCreateInfoKHR, imageSharingMode} + +instance {-# OVERLAPPING #-} + HasField "imageSharingMode" VkSwapchainCreateInfoKHR where + type FieldType "imageSharingMode" VkSwapchainCreateInfoKHR = + VkSharingMode + type FieldOptional "imageSharingMode" VkSwapchainCreateInfoKHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "imageSharingMode" VkSwapchainCreateInfoKHR = + #{offset VkSwapchainCreateInfoKHR, imageSharingMode} + type FieldIsArray "imageSharingMode" VkSwapchainCreateInfoKHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSwapchainCreateInfoKHR, imageSharingMode} + +instance CanReadField "imageSharingMode" VkSwapchainCreateInfoKHR + where + {-# INLINE getField #-} + getField = vkImageSharingMode + + {-# INLINE readField #-} + readField = readVkImageSharingMode + +instance CanWriteField "imageSharingMode" VkSwapchainCreateInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkImageSharingMode + +instance {-# OVERLAPPING #-} + HasVkQueueFamilyIndexCount VkSwapchainCreateInfoKHR where + type VkQueueFamilyIndexCountMType VkSwapchainCreateInfoKHR = Word32 + + {-# NOINLINE vkQueueFamilyIndexCount #-} + vkQueueFamilyIndexCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSwapchainCreateInfoKHR, queueFamilyIndexCount}) + + {-# INLINE vkQueueFamilyIndexCountByteOffset #-} + vkQueueFamilyIndexCountByteOffset ~_ + = #{offset VkSwapchainCreateInfoKHR, queueFamilyIndexCount} + + {-# INLINE readVkQueueFamilyIndexCount #-} + readVkQueueFamilyIndexCount p + = peekByteOff p #{offset VkSwapchainCreateInfoKHR, queueFamilyIndexCount} + + {-# INLINE writeVkQueueFamilyIndexCount #-} + writeVkQueueFamilyIndexCount p + = pokeByteOff p #{offset VkSwapchainCreateInfoKHR, queueFamilyIndexCount} + +instance {-# OVERLAPPING #-} + HasField "queueFamilyIndexCount" VkSwapchainCreateInfoKHR where + type FieldType "queueFamilyIndexCount" VkSwapchainCreateInfoKHR = + Word32 + type FieldOptional "queueFamilyIndexCount" VkSwapchainCreateInfoKHR + = 'True -- ' closing tick for hsc2hs + type FieldOffset "queueFamilyIndexCount" VkSwapchainCreateInfoKHR = + #{offset VkSwapchainCreateInfoKHR, queueFamilyIndexCount} + type FieldIsArray "queueFamilyIndexCount" VkSwapchainCreateInfoKHR + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSwapchainCreateInfoKHR, queueFamilyIndexCount} + +instance CanReadField "queueFamilyIndexCount" + VkSwapchainCreateInfoKHR + where + {-# INLINE getField #-} + getField = vkQueueFamilyIndexCount + + {-# INLINE readField #-} + readField = readVkQueueFamilyIndexCount + +instance CanWriteField "queueFamilyIndexCount" + VkSwapchainCreateInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkQueueFamilyIndexCount + +instance {-# OVERLAPPING #-} + HasVkPQueueFamilyIndices VkSwapchainCreateInfoKHR where + type VkPQueueFamilyIndicesMType VkSwapchainCreateInfoKHR = + Ptr Word32 + + {-# NOINLINE vkPQueueFamilyIndices #-} + vkPQueueFamilyIndices x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSwapchainCreateInfoKHR, pQueueFamilyIndices}) + + {-# INLINE vkPQueueFamilyIndicesByteOffset #-} + vkPQueueFamilyIndicesByteOffset ~_ + = #{offset VkSwapchainCreateInfoKHR, pQueueFamilyIndices} + + {-# INLINE readVkPQueueFamilyIndices #-} + readVkPQueueFamilyIndices p + = peekByteOff p #{offset VkSwapchainCreateInfoKHR, pQueueFamilyIndices} + + {-# INLINE writeVkPQueueFamilyIndices #-} + writeVkPQueueFamilyIndices p + = pokeByteOff p #{offset VkSwapchainCreateInfoKHR, pQueueFamilyIndices} + +instance {-# OVERLAPPING #-} + HasField "pQueueFamilyIndices" VkSwapchainCreateInfoKHR where + type FieldType "pQueueFamilyIndices" VkSwapchainCreateInfoKHR = + Ptr Word32 + type FieldOptional "pQueueFamilyIndices" VkSwapchainCreateInfoKHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "pQueueFamilyIndices" VkSwapchainCreateInfoKHR = + #{offset VkSwapchainCreateInfoKHR, pQueueFamilyIndices} + type FieldIsArray "pQueueFamilyIndices" VkSwapchainCreateInfoKHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSwapchainCreateInfoKHR, pQueueFamilyIndices} + +instance CanReadField "pQueueFamilyIndices" + VkSwapchainCreateInfoKHR + where + {-# INLINE getField #-} + getField = vkPQueueFamilyIndices + + {-# INLINE readField #-} + readField = readVkPQueueFamilyIndices + +instance CanWriteField "pQueueFamilyIndices" + VkSwapchainCreateInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkPQueueFamilyIndices + +instance {-# OVERLAPPING #-} + HasVkPreTransform VkSwapchainCreateInfoKHR where + type VkPreTransformMType VkSwapchainCreateInfoKHR = + VkSurfaceTransformFlagBitsKHR + + {-# NOINLINE vkPreTransform #-} + vkPreTransform x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSwapchainCreateInfoKHR, preTransform}) + + {-# INLINE vkPreTransformByteOffset #-} + vkPreTransformByteOffset ~_ + = #{offset VkSwapchainCreateInfoKHR, preTransform} + + {-# INLINE readVkPreTransform #-} + readVkPreTransform p + = peekByteOff p #{offset VkSwapchainCreateInfoKHR, preTransform} + + {-# INLINE writeVkPreTransform #-} + writeVkPreTransform p + = pokeByteOff p #{offset VkSwapchainCreateInfoKHR, preTransform} + +instance {-# OVERLAPPING #-} + HasField "preTransform" VkSwapchainCreateInfoKHR where + type FieldType "preTransform" VkSwapchainCreateInfoKHR = + VkSurfaceTransformFlagBitsKHR + type FieldOptional "preTransform" VkSwapchainCreateInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "preTransform" VkSwapchainCreateInfoKHR = + #{offset VkSwapchainCreateInfoKHR, preTransform} + type FieldIsArray "preTransform" VkSwapchainCreateInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSwapchainCreateInfoKHR, preTransform} + +instance CanReadField "preTransform" VkSwapchainCreateInfoKHR where + {-# INLINE getField #-} + getField = vkPreTransform + + {-# INLINE readField #-} + readField = readVkPreTransform + +instance CanWriteField "preTransform" VkSwapchainCreateInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkPreTransform + +instance {-# OVERLAPPING #-} + HasVkCompositeAlpha VkSwapchainCreateInfoKHR where + type VkCompositeAlphaMType VkSwapchainCreateInfoKHR = + VkCompositeAlphaFlagBitsKHR + + {-# NOINLINE vkCompositeAlpha #-} + vkCompositeAlpha x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSwapchainCreateInfoKHR, compositeAlpha}) + + {-# INLINE vkCompositeAlphaByteOffset #-} + vkCompositeAlphaByteOffset ~_ + = #{offset VkSwapchainCreateInfoKHR, compositeAlpha} + + {-# INLINE readVkCompositeAlpha #-} + readVkCompositeAlpha p + = peekByteOff p #{offset VkSwapchainCreateInfoKHR, compositeAlpha} + + {-# INLINE writeVkCompositeAlpha #-} + writeVkCompositeAlpha p + = pokeByteOff p #{offset VkSwapchainCreateInfoKHR, compositeAlpha} + +instance {-# OVERLAPPING #-} + HasField "compositeAlpha" VkSwapchainCreateInfoKHR where + type FieldType "compositeAlpha" VkSwapchainCreateInfoKHR = + VkCompositeAlphaFlagBitsKHR + type FieldOptional "compositeAlpha" VkSwapchainCreateInfoKHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "compositeAlpha" VkSwapchainCreateInfoKHR = + #{offset VkSwapchainCreateInfoKHR, compositeAlpha} + type FieldIsArray "compositeAlpha" VkSwapchainCreateInfoKHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSwapchainCreateInfoKHR, compositeAlpha} + +instance CanReadField "compositeAlpha" VkSwapchainCreateInfoKHR + where + {-# INLINE getField #-} + getField = vkCompositeAlpha + + {-# INLINE readField #-} + readField = readVkCompositeAlpha + +instance CanWriteField "compositeAlpha" VkSwapchainCreateInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkCompositeAlpha + +instance {-# OVERLAPPING #-} + HasVkPresentMode VkSwapchainCreateInfoKHR where + type VkPresentModeMType VkSwapchainCreateInfoKHR = VkPresentModeKHR + + {-# NOINLINE vkPresentMode #-} + vkPresentMode x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSwapchainCreateInfoKHR, presentMode}) + + {-# INLINE vkPresentModeByteOffset #-} + vkPresentModeByteOffset ~_ + = #{offset VkSwapchainCreateInfoKHR, presentMode} + + {-# INLINE readVkPresentMode #-} + readVkPresentMode p + = peekByteOff p #{offset VkSwapchainCreateInfoKHR, presentMode} + + {-# INLINE writeVkPresentMode #-} + writeVkPresentMode p + = pokeByteOff p #{offset VkSwapchainCreateInfoKHR, presentMode} + +instance {-# OVERLAPPING #-} + HasField "presentMode" VkSwapchainCreateInfoKHR where + type FieldType "presentMode" VkSwapchainCreateInfoKHR = + VkPresentModeKHR + type FieldOptional "presentMode" VkSwapchainCreateInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "presentMode" VkSwapchainCreateInfoKHR = + #{offset VkSwapchainCreateInfoKHR, presentMode} + type FieldIsArray "presentMode" VkSwapchainCreateInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSwapchainCreateInfoKHR, presentMode} + +instance CanReadField "presentMode" VkSwapchainCreateInfoKHR where + {-# INLINE getField #-} + getField = vkPresentMode + + {-# INLINE readField #-} + readField = readVkPresentMode + +instance CanWriteField "presentMode" VkSwapchainCreateInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkPresentMode + +instance {-# OVERLAPPING #-} HasVkClipped VkSwapchainCreateInfoKHR + where + type VkClippedMType VkSwapchainCreateInfoKHR = VkBool32 + + {-# NOINLINE vkClipped #-} + vkClipped x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSwapchainCreateInfoKHR, clipped}) + + {-# INLINE vkClippedByteOffset #-} + vkClippedByteOffset ~_ + = #{offset VkSwapchainCreateInfoKHR, clipped} + + {-# INLINE readVkClipped #-} + readVkClipped p + = peekByteOff p #{offset VkSwapchainCreateInfoKHR, clipped} + + {-# INLINE writeVkClipped #-} + writeVkClipped p + = pokeByteOff p #{offset VkSwapchainCreateInfoKHR, clipped} + +instance {-# OVERLAPPING #-} + HasField "clipped" VkSwapchainCreateInfoKHR where + type FieldType "clipped" VkSwapchainCreateInfoKHR = VkBool32 + type FieldOptional "clipped" VkSwapchainCreateInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "clipped" VkSwapchainCreateInfoKHR = + #{offset VkSwapchainCreateInfoKHR, clipped} + type FieldIsArray "clipped" VkSwapchainCreateInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSwapchainCreateInfoKHR, clipped} + +instance CanReadField "clipped" VkSwapchainCreateInfoKHR where + {-# INLINE getField #-} + getField = vkClipped + + {-# INLINE readField #-} + readField = readVkClipped + +instance CanWriteField "clipped" VkSwapchainCreateInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkClipped + +instance {-# OVERLAPPING #-} + HasVkOldSwapchain VkSwapchainCreateInfoKHR where + type VkOldSwapchainMType VkSwapchainCreateInfoKHR = VkSwapchainKHR + + {-# NOINLINE vkOldSwapchain #-} + vkOldSwapchain x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkSwapchainCreateInfoKHR, oldSwapchain}) + + {-# INLINE vkOldSwapchainByteOffset #-} + vkOldSwapchainByteOffset ~_ + = #{offset VkSwapchainCreateInfoKHR, oldSwapchain} + + {-# INLINE readVkOldSwapchain #-} + readVkOldSwapchain p + = peekByteOff p #{offset VkSwapchainCreateInfoKHR, oldSwapchain} + + {-# INLINE writeVkOldSwapchain #-} + writeVkOldSwapchain p + = pokeByteOff p #{offset VkSwapchainCreateInfoKHR, oldSwapchain} + +instance {-# OVERLAPPING #-} + HasField "oldSwapchain" VkSwapchainCreateInfoKHR where + type FieldType "oldSwapchain" VkSwapchainCreateInfoKHR = + VkSwapchainKHR + type FieldOptional "oldSwapchain" VkSwapchainCreateInfoKHR = 'True -- ' closing tick for hsc2hs + type FieldOffset "oldSwapchain" VkSwapchainCreateInfoKHR = + #{offset VkSwapchainCreateInfoKHR, oldSwapchain} + type FieldIsArray "oldSwapchain" VkSwapchainCreateInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkSwapchainCreateInfoKHR, oldSwapchain} + +instance CanReadField "oldSwapchain" VkSwapchainCreateInfoKHR where + {-# INLINE getField #-} + getField = vkOldSwapchain + + {-# INLINE readField #-} + readField = readVkOldSwapchain + +instance CanWriteField "oldSwapchain" VkSwapchainCreateInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkOldSwapchain + +instance Show VkSwapchainCreateInfoKHR where + showsPrec d x + = showString "VkSwapchainCreateInfoKHR {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkFlags = " . + showsPrec d (vkFlags x) . + showString ", " . + showString "vkSurface = " . + showsPrec d (vkSurface x) . + showString ", " . + showString "vkMinImageCount = " . + showsPrec d (vkMinImageCount x) . + showString ", " . + showString "vkImageFormat = " . + showsPrec d (vkImageFormat x) . + showString ", " . + showString "vkImageColorSpace = " . + showsPrec d (vkImageColorSpace x) . + showString ", " . + showString "vkImageExtent = " . + showsPrec d (vkImageExtent x) . + showString ", " . + showString "vkImageArrayLayers = " . + showsPrec d (vkImageArrayLayers x) . + showString ", " . + showString "vkImageUsage = " . + showsPrec d (vkImageUsage x) . + showString ", " . + showString + "vkImageSharingMode = " + . + showsPrec d + (vkImageSharingMode x) + . + showString ", " . + showString + "vkQueueFamilyIndexCount = " + . + showsPrec d + (vkQueueFamilyIndexCount + x) + . + showString ", " + . + showString + "vkPQueueFamilyIndices = " + . + showsPrec d + (vkPQueueFamilyIndices + x) + . + showString + ", " + . + showString + "vkPreTransform = " + . + showsPrec + d + (vkPreTransform + x) + . + showString + ", " + . + showString + "vkCompositeAlpha = " + . + showsPrec + d + (vkCompositeAlpha + x) + . + showString + ", " + . + showString + "vkPresentMode = " + . + showsPrec + d + (vkPresentMode + x) + . + showString + ", " + . + showString + "vkClipped = " + . + showsPrec + d + (vkClipped + x) + . + showString + ", " + . + showString + "vkOldSwapchain = " + . + showsPrec + d + (vkOldSwapchain + x) + . + showChar + '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkTextureLODGatherFormatPropertiesAMD.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkTextureLODGatherFormatPropertiesAMD.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkTextureLODGatherFormatPropertiesAMD.hsc @@ -0,0 +1,248 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkTextureLODGatherFormatPropertiesAMD + (VkTextureLODGatherFormatPropertiesAMD(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.BaseTypes (VkBool32) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Struct.VkImageFormatProperties2KHR (VkImageFormatProperties2KHR) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkTextureLODGatherFormatPropertiesAMD { +-- > VkStructureType sType; +-- > void* pNext; +-- > VkBool32 supportsTextureGatherLODBiasAMD; +-- > } VkTextureLODGatherFormatPropertiesAMD; +-- +-- +data VkTextureLODGatherFormatPropertiesAMD = VkTextureLODGatherFormatPropertiesAMD## Addr## + ByteArray## + +instance Eq VkTextureLODGatherFormatPropertiesAMD where + (VkTextureLODGatherFormatPropertiesAMD## a _) == + x@(VkTextureLODGatherFormatPropertiesAMD## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkTextureLODGatherFormatPropertiesAMD where + (VkTextureLODGatherFormatPropertiesAMD## a _) `compare` + x@(VkTextureLODGatherFormatPropertiesAMD## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkTextureLODGatherFormatPropertiesAMD where + sizeOf ~_ + = #{size VkTextureLODGatherFormatPropertiesAMD} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkTextureLODGatherFormatPropertiesAMD} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkTextureLODGatherFormatPropertiesAMD + where + unsafeAddr (VkTextureLODGatherFormatPropertiesAMD## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkTextureLODGatherFormatPropertiesAMD## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkTextureLODGatherFormatPropertiesAMD## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkTextureLODGatherFormatPropertiesAMD where + type StructFields VkTextureLODGatherFormatPropertiesAMD = + '["sType", "pNext", "supportsTextureGatherLODBiasAMD"] -- ' closing tick for hsc2hs + type CUnionType VkTextureLODGatherFormatPropertiesAMD = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkTextureLODGatherFormatPropertiesAMD = 'True -- ' closing tick for hsc2hs + type StructExtends VkTextureLODGatherFormatPropertiesAMD = + '[VkImageFormatProperties2KHR] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkTextureLODGatherFormatPropertiesAMD where + type VkSTypeMType VkTextureLODGatherFormatPropertiesAMD = + VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkTextureLODGatherFormatPropertiesAMD, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkTextureLODGatherFormatPropertiesAMD, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkTextureLODGatherFormatPropertiesAMD, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkTextureLODGatherFormatPropertiesAMD, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkTextureLODGatherFormatPropertiesAMD where + type FieldType "sType" VkTextureLODGatherFormatPropertiesAMD = + VkStructureType + type FieldOptional "sType" VkTextureLODGatherFormatPropertiesAMD = + 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkTextureLODGatherFormatPropertiesAMD = + #{offset VkTextureLODGatherFormatPropertiesAMD, sType} + type FieldIsArray "sType" VkTextureLODGatherFormatPropertiesAMD = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkTextureLODGatherFormatPropertiesAMD, sType} + +instance CanReadField "sType" VkTextureLODGatherFormatPropertiesAMD + where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkTextureLODGatherFormatPropertiesAMD where + type VkPNextMType VkTextureLODGatherFormatPropertiesAMD = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkTextureLODGatherFormatPropertiesAMD, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkTextureLODGatherFormatPropertiesAMD, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkTextureLODGatherFormatPropertiesAMD, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkTextureLODGatherFormatPropertiesAMD, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkTextureLODGatherFormatPropertiesAMD where + type FieldType "pNext" VkTextureLODGatherFormatPropertiesAMD = + Ptr Void + type FieldOptional "pNext" VkTextureLODGatherFormatPropertiesAMD = + 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkTextureLODGatherFormatPropertiesAMD = + #{offset VkTextureLODGatherFormatPropertiesAMD, pNext} + type FieldIsArray "pNext" VkTextureLODGatherFormatPropertiesAMD = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkTextureLODGatherFormatPropertiesAMD, pNext} + +instance CanReadField "pNext" VkTextureLODGatherFormatPropertiesAMD + where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance {-# OVERLAPPING #-} + HasVkSupportsTextureGatherLODBiasAMD + VkTextureLODGatherFormatPropertiesAMD + where + type VkSupportsTextureGatherLODBiasAMDMType + VkTextureLODGatherFormatPropertiesAMD + = VkBool32 + + {-# NOINLINE vkSupportsTextureGatherLODBiasAMD #-} + vkSupportsTextureGatherLODBiasAMD x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkTextureLODGatherFormatPropertiesAMD, supportsTextureGatherLODBiasAMD}) + + {-# INLINE vkSupportsTextureGatherLODBiasAMDByteOffset #-} + vkSupportsTextureGatherLODBiasAMDByteOffset ~_ + = #{offset VkTextureLODGatherFormatPropertiesAMD, supportsTextureGatherLODBiasAMD} + + {-# INLINE readVkSupportsTextureGatherLODBiasAMD #-} + readVkSupportsTextureGatherLODBiasAMD p + = peekByteOff p #{offset VkTextureLODGatherFormatPropertiesAMD, supportsTextureGatherLODBiasAMD} + + {-# INLINE writeVkSupportsTextureGatherLODBiasAMD #-} + writeVkSupportsTextureGatherLODBiasAMD p + = pokeByteOff p #{offset VkTextureLODGatherFormatPropertiesAMD, supportsTextureGatherLODBiasAMD} + +instance {-# OVERLAPPING #-} + HasField "supportsTextureGatherLODBiasAMD" + VkTextureLODGatherFormatPropertiesAMD + where + type FieldType "supportsTextureGatherLODBiasAMD" + VkTextureLODGatherFormatPropertiesAMD + = VkBool32 + type FieldOptional "supportsTextureGatherLODBiasAMD" + VkTextureLODGatherFormatPropertiesAMD + = 'False -- ' closing tick for hsc2hs + type FieldOffset "supportsTextureGatherLODBiasAMD" + VkTextureLODGatherFormatPropertiesAMD + = + #{offset VkTextureLODGatherFormatPropertiesAMD, supportsTextureGatherLODBiasAMD} + type FieldIsArray "supportsTextureGatherLODBiasAMD" + VkTextureLODGatherFormatPropertiesAMD + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkTextureLODGatherFormatPropertiesAMD, supportsTextureGatherLODBiasAMD} + +instance CanReadField "supportsTextureGatherLODBiasAMD" + VkTextureLODGatherFormatPropertiesAMD + where + {-# INLINE getField #-} + getField = vkSupportsTextureGatherLODBiasAMD + + {-# INLINE readField #-} + readField = readVkSupportsTextureGatherLODBiasAMD + +instance Show VkTextureLODGatherFormatPropertiesAMD where + showsPrec d x + = showString "VkTextureLODGatherFormatPropertiesAMD {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkSupportsTextureGatherLODBiasAMD = " . + showsPrec d (vkSupportsTextureGatherLODBiasAMD x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkValidationCacheCreateInfoEXT.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkValidationCacheCreateInfoEXT.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkValidationCacheCreateInfoEXT.hsc @@ -0,0 +1,348 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkValidationCacheCreateInfoEXT + (VkValidationCacheCreateInfoEXT(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Bitmasks (VkValidationCacheCreateFlagsEXT) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkValidationCacheCreateInfoEXT { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkValidationCacheCreateFlagsEXT flags; +-- > size_t initialDataSize; +-- > const void* pInitialData; +-- > } VkValidationCacheCreateInfoEXT; +-- +-- +data VkValidationCacheCreateInfoEXT = VkValidationCacheCreateInfoEXT## Addr## + ByteArray## + +instance Eq VkValidationCacheCreateInfoEXT where + (VkValidationCacheCreateInfoEXT## a _) == + x@(VkValidationCacheCreateInfoEXT## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkValidationCacheCreateInfoEXT where + (VkValidationCacheCreateInfoEXT## a _) `compare` + x@(VkValidationCacheCreateInfoEXT## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkValidationCacheCreateInfoEXT where + sizeOf ~_ = #{size VkValidationCacheCreateInfoEXT} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkValidationCacheCreateInfoEXT} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkValidationCacheCreateInfoEXT where + unsafeAddr (VkValidationCacheCreateInfoEXT## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkValidationCacheCreateInfoEXT## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkValidationCacheCreateInfoEXT## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkValidationCacheCreateInfoEXT where + type StructFields VkValidationCacheCreateInfoEXT = + '["sType", "pNext", "flags", "initialDataSize", "pInitialData"] -- ' closing tick for hsc2hs + type CUnionType VkValidationCacheCreateInfoEXT = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkValidationCacheCreateInfoEXT = 'False -- ' closing tick for hsc2hs + type StructExtends VkValidationCacheCreateInfoEXT = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkValidationCacheCreateInfoEXT where + type VkSTypeMType VkValidationCacheCreateInfoEXT = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkValidationCacheCreateInfoEXT, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkValidationCacheCreateInfoEXT, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkValidationCacheCreateInfoEXT, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkValidationCacheCreateInfoEXT, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkValidationCacheCreateInfoEXT where + type FieldType "sType" VkValidationCacheCreateInfoEXT = + VkStructureType + type FieldOptional "sType" VkValidationCacheCreateInfoEXT = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkValidationCacheCreateInfoEXT = + #{offset VkValidationCacheCreateInfoEXT, sType} + type FieldIsArray "sType" VkValidationCacheCreateInfoEXT = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkValidationCacheCreateInfoEXT, sType} + +instance CanReadField "sType" VkValidationCacheCreateInfoEXT where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkValidationCacheCreateInfoEXT where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkValidationCacheCreateInfoEXT where + type VkPNextMType VkValidationCacheCreateInfoEXT = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkValidationCacheCreateInfoEXT, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkValidationCacheCreateInfoEXT, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkValidationCacheCreateInfoEXT, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkValidationCacheCreateInfoEXT, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkValidationCacheCreateInfoEXT where + type FieldType "pNext" VkValidationCacheCreateInfoEXT = Ptr Void + type FieldOptional "pNext" VkValidationCacheCreateInfoEXT = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkValidationCacheCreateInfoEXT = + #{offset VkValidationCacheCreateInfoEXT, pNext} + type FieldIsArray "pNext" VkValidationCacheCreateInfoEXT = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkValidationCacheCreateInfoEXT, pNext} + +instance CanReadField "pNext" VkValidationCacheCreateInfoEXT where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkValidationCacheCreateInfoEXT where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkFlags VkValidationCacheCreateInfoEXT where + type VkFlagsMType VkValidationCacheCreateInfoEXT = + VkValidationCacheCreateFlagsEXT + + {-# NOINLINE vkFlags #-} + vkFlags x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkValidationCacheCreateInfoEXT, flags}) + + {-# INLINE vkFlagsByteOffset #-} + vkFlagsByteOffset ~_ + = #{offset VkValidationCacheCreateInfoEXT, flags} + + {-# INLINE readVkFlags #-} + readVkFlags p + = peekByteOff p #{offset VkValidationCacheCreateInfoEXT, flags} + + {-# INLINE writeVkFlags #-} + writeVkFlags p + = pokeByteOff p #{offset VkValidationCacheCreateInfoEXT, flags} + +instance {-# OVERLAPPING #-} + HasField "flags" VkValidationCacheCreateInfoEXT where + type FieldType "flags" VkValidationCacheCreateInfoEXT = + VkValidationCacheCreateFlagsEXT + type FieldOptional "flags" VkValidationCacheCreateInfoEXT = 'True -- ' closing tick for hsc2hs + type FieldOffset "flags" VkValidationCacheCreateInfoEXT = + #{offset VkValidationCacheCreateInfoEXT, flags} + type FieldIsArray "flags" VkValidationCacheCreateInfoEXT = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkValidationCacheCreateInfoEXT, flags} + +instance CanReadField "flags" VkValidationCacheCreateInfoEXT where + {-# INLINE getField #-} + getField = vkFlags + + {-# INLINE readField #-} + readField = readVkFlags + +instance CanWriteField "flags" VkValidationCacheCreateInfoEXT where + {-# INLINE writeField #-} + writeField = writeVkFlags + +instance {-# OVERLAPPING #-} + HasVkInitialDataSize VkValidationCacheCreateInfoEXT where + type VkInitialDataSizeMType VkValidationCacheCreateInfoEXT = CSize + + {-# NOINLINE vkInitialDataSize #-} + vkInitialDataSize x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkValidationCacheCreateInfoEXT, initialDataSize}) + + {-# INLINE vkInitialDataSizeByteOffset #-} + vkInitialDataSizeByteOffset ~_ + = #{offset VkValidationCacheCreateInfoEXT, initialDataSize} + + {-# INLINE readVkInitialDataSize #-} + readVkInitialDataSize p + = peekByteOff p #{offset VkValidationCacheCreateInfoEXT, initialDataSize} + + {-# INLINE writeVkInitialDataSize #-} + writeVkInitialDataSize p + = pokeByteOff p #{offset VkValidationCacheCreateInfoEXT, initialDataSize} + +instance {-# OVERLAPPING #-} + HasField "initialDataSize" VkValidationCacheCreateInfoEXT where + type FieldType "initialDataSize" VkValidationCacheCreateInfoEXT = + CSize + type FieldOptional "initialDataSize" VkValidationCacheCreateInfoEXT + = 'True -- ' closing tick for hsc2hs + type FieldOffset "initialDataSize" VkValidationCacheCreateInfoEXT = + #{offset VkValidationCacheCreateInfoEXT, initialDataSize} + type FieldIsArray "initialDataSize" VkValidationCacheCreateInfoEXT + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkValidationCacheCreateInfoEXT, initialDataSize} + +instance CanReadField "initialDataSize" + VkValidationCacheCreateInfoEXT + where + {-# INLINE getField #-} + getField = vkInitialDataSize + + {-# INLINE readField #-} + readField = readVkInitialDataSize + +instance CanWriteField "initialDataSize" + VkValidationCacheCreateInfoEXT + where + {-# INLINE writeField #-} + writeField = writeVkInitialDataSize + +instance {-# OVERLAPPING #-} + HasVkPInitialData VkValidationCacheCreateInfoEXT where + type VkPInitialDataMType VkValidationCacheCreateInfoEXT = Ptr Void + + {-# NOINLINE vkPInitialData #-} + vkPInitialData x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkValidationCacheCreateInfoEXT, pInitialData}) + + {-# INLINE vkPInitialDataByteOffset #-} + vkPInitialDataByteOffset ~_ + = #{offset VkValidationCacheCreateInfoEXT, pInitialData} + + {-# INLINE readVkPInitialData #-} + readVkPInitialData p + = peekByteOff p #{offset VkValidationCacheCreateInfoEXT, pInitialData} + + {-# INLINE writeVkPInitialData #-} + writeVkPInitialData p + = pokeByteOff p #{offset VkValidationCacheCreateInfoEXT, pInitialData} + +instance {-# OVERLAPPING #-} + HasField "pInitialData" VkValidationCacheCreateInfoEXT where + type FieldType "pInitialData" VkValidationCacheCreateInfoEXT = + Ptr Void + type FieldOptional "pInitialData" VkValidationCacheCreateInfoEXT = + 'False -- ' closing tick for hsc2hs + type FieldOffset "pInitialData" VkValidationCacheCreateInfoEXT = + #{offset VkValidationCacheCreateInfoEXT, pInitialData} + type FieldIsArray "pInitialData" VkValidationCacheCreateInfoEXT = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkValidationCacheCreateInfoEXT, pInitialData} + +instance CanReadField "pInitialData" VkValidationCacheCreateInfoEXT + where + {-# INLINE getField #-} + getField = vkPInitialData + + {-# INLINE readField #-} + readField = readVkPInitialData + +instance CanWriteField "pInitialData" + VkValidationCacheCreateInfoEXT + where + {-# INLINE writeField #-} + writeField = writeVkPInitialData + +instance Show VkValidationCacheCreateInfoEXT where + showsPrec d x + = showString "VkValidationCacheCreateInfoEXT {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkFlags = " . + showsPrec d (vkFlags x) . + showString ", " . + showString "vkInitialDataSize = " . + showsPrec d (vkInitialDataSize x) . + showString ", " . + showString "vkPInitialData = " . + showsPrec d (vkPInitialData x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkValidationFlagsEXT.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkValidationFlagsEXT.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkValidationFlagsEXT.hsc @@ -0,0 +1,294 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkValidationFlagsEXT + (VkValidationFlagsEXT(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Enum.VkValidationCheckEXT (VkValidationCheckEXT) +import Graphics.Vulkan.Types.Struct.VkInstanceCreateInfo (VkInstanceCreateInfo) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkValidationFlagsEXT { +-- > VkStructureType sType; +-- > const void* pNext; +-- > uint32_t disabledValidationCheckCount; +-- > VkValidationCheckEXT* pDisabledValidationChecks; +-- > } VkValidationFlagsEXT; +-- +-- +data VkValidationFlagsEXT = VkValidationFlagsEXT## Addr## ByteArray## + +instance Eq VkValidationFlagsEXT where + (VkValidationFlagsEXT## a _) == x@(VkValidationFlagsEXT## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkValidationFlagsEXT where + (VkValidationFlagsEXT## a _) `compare` x@(VkValidationFlagsEXT## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkValidationFlagsEXT where + sizeOf ~_ = #{size VkValidationFlagsEXT} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkValidationFlagsEXT} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkValidationFlagsEXT where + unsafeAddr (VkValidationFlagsEXT## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkValidationFlagsEXT## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkValidationFlagsEXT## (plusAddr## (byteArrayContents## b) off) b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkValidationFlagsEXT where + type StructFields VkValidationFlagsEXT = + '["sType", "pNext", "disabledValidationCheckCount", -- ' closing tick for hsc2hs + "pDisabledValidationChecks"] + type CUnionType VkValidationFlagsEXT = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkValidationFlagsEXT = 'False -- ' closing tick for hsc2hs + type StructExtends VkValidationFlagsEXT = '[VkInstanceCreateInfo] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkSType VkValidationFlagsEXT where + type VkSTypeMType VkValidationFlagsEXT = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkValidationFlagsEXT, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkValidationFlagsEXT, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkValidationFlagsEXT, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkValidationFlagsEXT, sType} + +instance {-# OVERLAPPING #-} HasField "sType" VkValidationFlagsEXT + where + type FieldType "sType" VkValidationFlagsEXT = VkStructureType + type FieldOptional "sType" VkValidationFlagsEXT = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkValidationFlagsEXT = + #{offset VkValidationFlagsEXT, sType} + type FieldIsArray "sType" VkValidationFlagsEXT = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkValidationFlagsEXT, sType} + +instance CanReadField "sType" VkValidationFlagsEXT where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkValidationFlagsEXT where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} HasVkPNext VkValidationFlagsEXT where + type VkPNextMType VkValidationFlagsEXT = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkValidationFlagsEXT, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkValidationFlagsEXT, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkValidationFlagsEXT, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkValidationFlagsEXT, pNext} + +instance {-# OVERLAPPING #-} HasField "pNext" VkValidationFlagsEXT + where + type FieldType "pNext" VkValidationFlagsEXT = Ptr Void + type FieldOptional "pNext" VkValidationFlagsEXT = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkValidationFlagsEXT = + #{offset VkValidationFlagsEXT, pNext} + type FieldIsArray "pNext" VkValidationFlagsEXT = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkValidationFlagsEXT, pNext} + +instance CanReadField "pNext" VkValidationFlagsEXT where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkValidationFlagsEXT where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkDisabledValidationCheckCount VkValidationFlagsEXT where + type VkDisabledValidationCheckCountMType VkValidationFlagsEXT = + Word32 + + {-# NOINLINE vkDisabledValidationCheckCount #-} + vkDisabledValidationCheckCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkValidationFlagsEXT, disabledValidationCheckCount}) + + {-# INLINE vkDisabledValidationCheckCountByteOffset #-} + vkDisabledValidationCheckCountByteOffset ~_ + = #{offset VkValidationFlagsEXT, disabledValidationCheckCount} + + {-# INLINE readVkDisabledValidationCheckCount #-} + readVkDisabledValidationCheckCount p + = peekByteOff p #{offset VkValidationFlagsEXT, disabledValidationCheckCount} + + {-# INLINE writeVkDisabledValidationCheckCount #-} + writeVkDisabledValidationCheckCount p + = pokeByteOff p #{offset VkValidationFlagsEXT, disabledValidationCheckCount} + +instance {-# OVERLAPPING #-} + HasField "disabledValidationCheckCount" VkValidationFlagsEXT where + type FieldType "disabledValidationCheckCount" VkValidationFlagsEXT + = Word32 + type FieldOptional "disabledValidationCheckCount" + VkValidationFlagsEXT + = 'False -- ' closing tick for hsc2hs + type FieldOffset "disabledValidationCheckCount" + VkValidationFlagsEXT + = + #{offset VkValidationFlagsEXT, disabledValidationCheckCount} + type FieldIsArray "disabledValidationCheckCount" + VkValidationFlagsEXT + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkValidationFlagsEXT, disabledValidationCheckCount} + +instance CanReadField "disabledValidationCheckCount" + VkValidationFlagsEXT + where + {-# INLINE getField #-} + getField = vkDisabledValidationCheckCount + + {-# INLINE readField #-} + readField = readVkDisabledValidationCheckCount + +instance CanWriteField "disabledValidationCheckCount" + VkValidationFlagsEXT + where + {-# INLINE writeField #-} + writeField = writeVkDisabledValidationCheckCount + +instance {-# OVERLAPPING #-} + HasVkPDisabledValidationChecks VkValidationFlagsEXT where + type VkPDisabledValidationChecksMType VkValidationFlagsEXT = + Ptr VkValidationCheckEXT + + {-# NOINLINE vkPDisabledValidationChecks #-} + vkPDisabledValidationChecks x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkValidationFlagsEXT, pDisabledValidationChecks}) + + {-# INLINE vkPDisabledValidationChecksByteOffset #-} + vkPDisabledValidationChecksByteOffset ~_ + = #{offset VkValidationFlagsEXT, pDisabledValidationChecks} + + {-# INLINE readVkPDisabledValidationChecks #-} + readVkPDisabledValidationChecks p + = peekByteOff p #{offset VkValidationFlagsEXT, pDisabledValidationChecks} + + {-# INLINE writeVkPDisabledValidationChecks #-} + writeVkPDisabledValidationChecks p + = pokeByteOff p #{offset VkValidationFlagsEXT, pDisabledValidationChecks} + +instance {-# OVERLAPPING #-} + HasField "pDisabledValidationChecks" VkValidationFlagsEXT where + type FieldType "pDisabledValidationChecks" VkValidationFlagsEXT = + Ptr VkValidationCheckEXT + type FieldOptional "pDisabledValidationChecks" VkValidationFlagsEXT + = 'False -- ' closing tick for hsc2hs + type FieldOffset "pDisabledValidationChecks" VkValidationFlagsEXT = + #{offset VkValidationFlagsEXT, pDisabledValidationChecks} + type FieldIsArray "pDisabledValidationChecks" VkValidationFlagsEXT + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkValidationFlagsEXT, pDisabledValidationChecks} + +instance CanReadField "pDisabledValidationChecks" + VkValidationFlagsEXT + where + {-# INLINE getField #-} + getField = vkPDisabledValidationChecks + + {-# INLINE readField #-} + readField = readVkPDisabledValidationChecks + +instance CanWriteField "pDisabledValidationChecks" + VkValidationFlagsEXT + where + {-# INLINE writeField #-} + writeField = writeVkPDisabledValidationChecks + +instance Show VkValidationFlagsEXT where + showsPrec d x + = showString "VkValidationFlagsEXT {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkDisabledValidationCheckCount = " . + showsPrec d (vkDisabledValidationCheckCount x) . + showString ", " . + showString "vkPDisabledValidationChecks = " . + showsPrec d (vkPDisabledValidationChecks x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkVertexInputAttributeDescription.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkVertexInputAttributeDescription.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkVertexInputAttributeDescription.hsc @@ -0,0 +1,298 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkVertexInputAttributeDescription + (VkVertexInputAttributeDescription(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkFormat (VkFormat) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkVertexInputAttributeDescription { +-- > uint32_t location; +-- > uint32_t binding; +-- > VkFormat format; +-- > uint32_t offset; +-- > } VkVertexInputAttributeDescription; +-- +-- +data VkVertexInputAttributeDescription = VkVertexInputAttributeDescription## Addr## + ByteArray## + +instance Eq VkVertexInputAttributeDescription where + (VkVertexInputAttributeDescription## a _) == + x@(VkVertexInputAttributeDescription## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkVertexInputAttributeDescription where + (VkVertexInputAttributeDescription## a _) `compare` + x@(VkVertexInputAttributeDescription## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkVertexInputAttributeDescription where + sizeOf ~_ = #{size VkVertexInputAttributeDescription} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkVertexInputAttributeDescription} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkVertexInputAttributeDescription where + unsafeAddr (VkVertexInputAttributeDescription## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkVertexInputAttributeDescription## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkVertexInputAttributeDescription## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkVertexInputAttributeDescription where + type StructFields VkVertexInputAttributeDescription = + '["location", "binding", "format", "offset"] -- ' closing tick for hsc2hs + type CUnionType VkVertexInputAttributeDescription = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkVertexInputAttributeDescription = 'False -- ' closing tick for hsc2hs + type StructExtends VkVertexInputAttributeDescription = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkLocation VkVertexInputAttributeDescription where + type VkLocationMType VkVertexInputAttributeDescription = Word32 + + {-# NOINLINE vkLocation #-} + vkLocation x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkVertexInputAttributeDescription, location}) + + {-# INLINE vkLocationByteOffset #-} + vkLocationByteOffset ~_ + = #{offset VkVertexInputAttributeDescription, location} + + {-# INLINE readVkLocation #-} + readVkLocation p + = peekByteOff p #{offset VkVertexInputAttributeDescription, location} + + {-# INLINE writeVkLocation #-} + writeVkLocation p + = pokeByteOff p #{offset VkVertexInputAttributeDescription, location} + +instance {-# OVERLAPPING #-} + HasField "location" VkVertexInputAttributeDescription where + type FieldType "location" VkVertexInputAttributeDescription = + Word32 + type FieldOptional "location" VkVertexInputAttributeDescription = + 'False -- ' closing tick for hsc2hs + type FieldOffset "location" VkVertexInputAttributeDescription = + #{offset VkVertexInputAttributeDescription, location} + type FieldIsArray "location" VkVertexInputAttributeDescription = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkVertexInputAttributeDescription, location} + +instance CanReadField "location" VkVertexInputAttributeDescription + where + {-# INLINE getField #-} + getField = vkLocation + + {-# INLINE readField #-} + readField = readVkLocation + +instance CanWriteField "location" VkVertexInputAttributeDescription + where + {-# INLINE writeField #-} + writeField = writeVkLocation + +instance {-# OVERLAPPING #-} + HasVkBinding VkVertexInputAttributeDescription where + type VkBindingMType VkVertexInputAttributeDescription = Word32 + + {-# NOINLINE vkBinding #-} + vkBinding x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkVertexInputAttributeDescription, binding}) + + {-# INLINE vkBindingByteOffset #-} + vkBindingByteOffset ~_ + = #{offset VkVertexInputAttributeDescription, binding} + + {-# INLINE readVkBinding #-} + readVkBinding p + = peekByteOff p #{offset VkVertexInputAttributeDescription, binding} + + {-# INLINE writeVkBinding #-} + writeVkBinding p + = pokeByteOff p #{offset VkVertexInputAttributeDescription, binding} + +instance {-# OVERLAPPING #-} + HasField "binding" VkVertexInputAttributeDescription where + type FieldType "binding" VkVertexInputAttributeDescription = Word32 + type FieldOptional "binding" VkVertexInputAttributeDescription = + 'False -- ' closing tick for hsc2hs + type FieldOffset "binding" VkVertexInputAttributeDescription = + #{offset VkVertexInputAttributeDescription, binding} + type FieldIsArray "binding" VkVertexInputAttributeDescription = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkVertexInputAttributeDescription, binding} + +instance CanReadField "binding" VkVertexInputAttributeDescription + where + {-# INLINE getField #-} + getField = vkBinding + + {-# INLINE readField #-} + readField = readVkBinding + +instance CanWriteField "binding" VkVertexInputAttributeDescription + where + {-# INLINE writeField #-} + writeField = writeVkBinding + +instance {-# OVERLAPPING #-} + HasVkFormat VkVertexInputAttributeDescription where + type VkFormatMType VkVertexInputAttributeDescription = VkFormat + + {-# NOINLINE vkFormat #-} + vkFormat x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkVertexInputAttributeDescription, format}) + + {-# INLINE vkFormatByteOffset #-} + vkFormatByteOffset ~_ + = #{offset VkVertexInputAttributeDescription, format} + + {-# INLINE readVkFormat #-} + readVkFormat p + = peekByteOff p #{offset VkVertexInputAttributeDescription, format} + + {-# INLINE writeVkFormat #-} + writeVkFormat p + = pokeByteOff p #{offset VkVertexInputAttributeDescription, format} + +instance {-# OVERLAPPING #-} + HasField "format" VkVertexInputAttributeDescription where + type FieldType "format" VkVertexInputAttributeDescription = + VkFormat + type FieldOptional "format" VkVertexInputAttributeDescription = + 'False -- ' closing tick for hsc2hs + type FieldOffset "format" VkVertexInputAttributeDescription = + #{offset VkVertexInputAttributeDescription, format} + type FieldIsArray "format" VkVertexInputAttributeDescription = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkVertexInputAttributeDescription, format} + +instance CanReadField "format" VkVertexInputAttributeDescription + where + {-# INLINE getField #-} + getField = vkFormat + + {-# INLINE readField #-} + readField = readVkFormat + +instance CanWriteField "format" VkVertexInputAttributeDescription + where + {-# INLINE writeField #-} + writeField = writeVkFormat + +instance {-# OVERLAPPING #-} + HasVkOffset VkVertexInputAttributeDescription where + type VkOffsetMType VkVertexInputAttributeDescription = Word32 + + {-# NOINLINE vkOffset #-} + vkOffset x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkVertexInputAttributeDescription, offset}) + + {-# INLINE vkOffsetByteOffset #-} + vkOffsetByteOffset ~_ + = #{offset VkVertexInputAttributeDescription, offset} + + {-# INLINE readVkOffset #-} + readVkOffset p + = peekByteOff p #{offset VkVertexInputAttributeDescription, offset} + + {-# INLINE writeVkOffset #-} + writeVkOffset p + = pokeByteOff p #{offset VkVertexInputAttributeDescription, offset} + +instance {-# OVERLAPPING #-} + HasField "offset" VkVertexInputAttributeDescription where + type FieldType "offset" VkVertexInputAttributeDescription = Word32 + type FieldOptional "offset" VkVertexInputAttributeDescription = + 'False -- ' closing tick for hsc2hs + type FieldOffset "offset" VkVertexInputAttributeDescription = + #{offset VkVertexInputAttributeDescription, offset} + type FieldIsArray "offset" VkVertexInputAttributeDescription = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkVertexInputAttributeDescription, offset} + +instance CanReadField "offset" VkVertexInputAttributeDescription + where + {-# INLINE getField #-} + getField = vkOffset + + {-# INLINE readField #-} + readField = readVkOffset + +instance CanWriteField "offset" VkVertexInputAttributeDescription + where + {-# INLINE writeField #-} + writeField = writeVkOffset + +instance Show VkVertexInputAttributeDescription where + showsPrec d x + = showString "VkVertexInputAttributeDescription {" . + showString "vkLocation = " . + showsPrec d (vkLocation x) . + showString ", " . + showString "vkBinding = " . + showsPrec d (vkBinding x) . + showString ", " . + showString "vkFormat = " . + showsPrec d (vkFormat x) . + showString ", " . + showString "vkOffset = " . showsPrec d (vkOffset x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkVertexInputBindingDescription.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkVertexInputBindingDescription.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkVertexInputBindingDescription.hsc @@ -0,0 +1,242 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkVertexInputBindingDescription + (VkVertexInputBindingDescription(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkVertexInputRate (VkVertexInputRate) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkVertexInputBindingDescription { +-- > uint32_t binding; +-- > uint32_t stride; +-- > VkVertexInputRate inputRate; +-- > } VkVertexInputBindingDescription; +-- +-- +data VkVertexInputBindingDescription = VkVertexInputBindingDescription## Addr## + ByteArray## + +instance Eq VkVertexInputBindingDescription where + (VkVertexInputBindingDescription## a _) == + x@(VkVertexInputBindingDescription## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkVertexInputBindingDescription where + (VkVertexInputBindingDescription## a _) `compare` + x@(VkVertexInputBindingDescription## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkVertexInputBindingDescription where + sizeOf ~_ = #{size VkVertexInputBindingDescription} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkVertexInputBindingDescription} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkVertexInputBindingDescription where + unsafeAddr (VkVertexInputBindingDescription## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkVertexInputBindingDescription## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkVertexInputBindingDescription## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkVertexInputBindingDescription where + type StructFields VkVertexInputBindingDescription = + '["binding", "stride", "inputRate"] -- ' closing tick for hsc2hs + type CUnionType VkVertexInputBindingDescription = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkVertexInputBindingDescription = 'False -- ' closing tick for hsc2hs + type StructExtends VkVertexInputBindingDescription = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkBinding VkVertexInputBindingDescription where + type VkBindingMType VkVertexInputBindingDescription = Word32 + + {-# NOINLINE vkBinding #-} + vkBinding x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkVertexInputBindingDescription, binding}) + + {-# INLINE vkBindingByteOffset #-} + vkBindingByteOffset ~_ + = #{offset VkVertexInputBindingDescription, binding} + + {-# INLINE readVkBinding #-} + readVkBinding p + = peekByteOff p #{offset VkVertexInputBindingDescription, binding} + + {-# INLINE writeVkBinding #-} + writeVkBinding p + = pokeByteOff p #{offset VkVertexInputBindingDescription, binding} + +instance {-# OVERLAPPING #-} + HasField "binding" VkVertexInputBindingDescription where + type FieldType "binding" VkVertexInputBindingDescription = Word32 + type FieldOptional "binding" VkVertexInputBindingDescription = + 'False -- ' closing tick for hsc2hs + type FieldOffset "binding" VkVertexInputBindingDescription = + #{offset VkVertexInputBindingDescription, binding} + type FieldIsArray "binding" VkVertexInputBindingDescription = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkVertexInputBindingDescription, binding} + +instance CanReadField "binding" VkVertexInputBindingDescription + where + {-# INLINE getField #-} + getField = vkBinding + + {-# INLINE readField #-} + readField = readVkBinding + +instance CanWriteField "binding" VkVertexInputBindingDescription + where + {-# INLINE writeField #-} + writeField = writeVkBinding + +instance {-# OVERLAPPING #-} + HasVkStride VkVertexInputBindingDescription where + type VkStrideMType VkVertexInputBindingDescription = Word32 + + {-# NOINLINE vkStride #-} + vkStride x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkVertexInputBindingDescription, stride}) + + {-# INLINE vkStrideByteOffset #-} + vkStrideByteOffset ~_ + = #{offset VkVertexInputBindingDescription, stride} + + {-# INLINE readVkStride #-} + readVkStride p + = peekByteOff p #{offset VkVertexInputBindingDescription, stride} + + {-# INLINE writeVkStride #-} + writeVkStride p + = pokeByteOff p #{offset VkVertexInputBindingDescription, stride} + +instance {-# OVERLAPPING #-} + HasField "stride" VkVertexInputBindingDescription where + type FieldType "stride" VkVertexInputBindingDescription = Word32 + type FieldOptional "stride" VkVertexInputBindingDescription = + 'False -- ' closing tick for hsc2hs + type FieldOffset "stride" VkVertexInputBindingDescription = + #{offset VkVertexInputBindingDescription, stride} + type FieldIsArray "stride" VkVertexInputBindingDescription = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkVertexInputBindingDescription, stride} + +instance CanReadField "stride" VkVertexInputBindingDescription + where + {-# INLINE getField #-} + getField = vkStride + + {-# INLINE readField #-} + readField = readVkStride + +instance CanWriteField "stride" VkVertexInputBindingDescription + where + {-# INLINE writeField #-} + writeField = writeVkStride + +instance {-# OVERLAPPING #-} + HasVkInputRate VkVertexInputBindingDescription where + type VkInputRateMType VkVertexInputBindingDescription = + VkVertexInputRate + + {-# NOINLINE vkInputRate #-} + vkInputRate x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkVertexInputBindingDescription, inputRate}) + + {-# INLINE vkInputRateByteOffset #-} + vkInputRateByteOffset ~_ + = #{offset VkVertexInputBindingDescription, inputRate} + + {-# INLINE readVkInputRate #-} + readVkInputRate p + = peekByteOff p #{offset VkVertexInputBindingDescription, inputRate} + + {-# INLINE writeVkInputRate #-} + writeVkInputRate p + = pokeByteOff p #{offset VkVertexInputBindingDescription, inputRate} + +instance {-# OVERLAPPING #-} + HasField "inputRate" VkVertexInputBindingDescription where + type FieldType "inputRate" VkVertexInputBindingDescription = + VkVertexInputRate + type FieldOptional "inputRate" VkVertexInputBindingDescription = + 'False -- ' closing tick for hsc2hs + type FieldOffset "inputRate" VkVertexInputBindingDescription = + #{offset VkVertexInputBindingDescription, inputRate} + type FieldIsArray "inputRate" VkVertexInputBindingDescription = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkVertexInputBindingDescription, inputRate} + +instance CanReadField "inputRate" VkVertexInputBindingDescription + where + {-# INLINE getField #-} + getField = vkInputRate + + {-# INLINE readField #-} + readField = readVkInputRate + +instance CanWriteField "inputRate" VkVertexInputBindingDescription + where + {-# INLINE writeField #-} + writeField = writeVkInputRate + +instance Show VkVertexInputBindingDescription where + showsPrec d x + = showString "VkVertexInputBindingDescription {" . + showString "vkBinding = " . + showsPrec d (vkBinding x) . + showString ", " . + showString "vkStride = " . + showsPrec d (vkStride x) . + showString ", " . + showString "vkInputRate = " . + showsPrec d (vkInputRate x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkViSurfaceCreateInfoNN.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkViSurfaceCreateInfoNN.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkViSurfaceCreateInfoNN.hsc @@ -0,0 +1,274 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkViSurfaceCreateInfoNN + (VkViSurfaceCreateInfoNN(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Bitmasks (VkViSurfaceCreateFlagsNN) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkViSurfaceCreateInfoNN { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkViSurfaceCreateFlagsNN flags; +-- > void* window; +-- > } VkViSurfaceCreateInfoNN; +-- +-- +data VkViSurfaceCreateInfoNN = VkViSurfaceCreateInfoNN## Addr## + ByteArray## + +instance Eq VkViSurfaceCreateInfoNN where + (VkViSurfaceCreateInfoNN## a _) == x@(VkViSurfaceCreateInfoNN## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkViSurfaceCreateInfoNN where + (VkViSurfaceCreateInfoNN## a _) `compare` + x@(VkViSurfaceCreateInfoNN## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkViSurfaceCreateInfoNN where + sizeOf ~_ = #{size VkViSurfaceCreateInfoNN} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkViSurfaceCreateInfoNN} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkViSurfaceCreateInfoNN where + unsafeAddr (VkViSurfaceCreateInfoNN## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkViSurfaceCreateInfoNN## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkViSurfaceCreateInfoNN## (plusAddr## (byteArrayContents## b) off) b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkViSurfaceCreateInfoNN where + type StructFields VkViSurfaceCreateInfoNN = + '["sType", "pNext", "flags", "window"] -- ' closing tick for hsc2hs + type CUnionType VkViSurfaceCreateInfoNN = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkViSurfaceCreateInfoNN = 'False -- ' closing tick for hsc2hs + type StructExtends VkViSurfaceCreateInfoNN = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkSType VkViSurfaceCreateInfoNN + where + type VkSTypeMType VkViSurfaceCreateInfoNN = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkViSurfaceCreateInfoNN, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkViSurfaceCreateInfoNN, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkViSurfaceCreateInfoNN, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkViSurfaceCreateInfoNN, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkViSurfaceCreateInfoNN where + type FieldType "sType" VkViSurfaceCreateInfoNN = VkStructureType + type FieldOptional "sType" VkViSurfaceCreateInfoNN = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkViSurfaceCreateInfoNN = + #{offset VkViSurfaceCreateInfoNN, sType} + type FieldIsArray "sType" VkViSurfaceCreateInfoNN = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkViSurfaceCreateInfoNN, sType} + +instance CanReadField "sType" VkViSurfaceCreateInfoNN where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkViSurfaceCreateInfoNN where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} HasVkPNext VkViSurfaceCreateInfoNN + where + type VkPNextMType VkViSurfaceCreateInfoNN = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkViSurfaceCreateInfoNN, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkViSurfaceCreateInfoNN, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkViSurfaceCreateInfoNN, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkViSurfaceCreateInfoNN, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkViSurfaceCreateInfoNN where + type FieldType "pNext" VkViSurfaceCreateInfoNN = Ptr Void + type FieldOptional "pNext" VkViSurfaceCreateInfoNN = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkViSurfaceCreateInfoNN = + #{offset VkViSurfaceCreateInfoNN, pNext} + type FieldIsArray "pNext" VkViSurfaceCreateInfoNN = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkViSurfaceCreateInfoNN, pNext} + +instance CanReadField "pNext" VkViSurfaceCreateInfoNN where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkViSurfaceCreateInfoNN where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} HasVkFlags VkViSurfaceCreateInfoNN + where + type VkFlagsMType VkViSurfaceCreateInfoNN = + VkViSurfaceCreateFlagsNN + + {-# NOINLINE vkFlags #-} + vkFlags x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkViSurfaceCreateInfoNN, flags}) + + {-# INLINE vkFlagsByteOffset #-} + vkFlagsByteOffset ~_ + = #{offset VkViSurfaceCreateInfoNN, flags} + + {-# INLINE readVkFlags #-} + readVkFlags p + = peekByteOff p #{offset VkViSurfaceCreateInfoNN, flags} + + {-# INLINE writeVkFlags #-} + writeVkFlags p + = pokeByteOff p #{offset VkViSurfaceCreateInfoNN, flags} + +instance {-# OVERLAPPING #-} + HasField "flags" VkViSurfaceCreateInfoNN where + type FieldType "flags" VkViSurfaceCreateInfoNN = + VkViSurfaceCreateFlagsNN + type FieldOptional "flags" VkViSurfaceCreateInfoNN = 'True -- ' closing tick for hsc2hs + type FieldOffset "flags" VkViSurfaceCreateInfoNN = + #{offset VkViSurfaceCreateInfoNN, flags} + type FieldIsArray "flags" VkViSurfaceCreateInfoNN = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkViSurfaceCreateInfoNN, flags} + +instance CanReadField "flags" VkViSurfaceCreateInfoNN where + {-# INLINE getField #-} + getField = vkFlags + + {-# INLINE readField #-} + readField = readVkFlags + +instance CanWriteField "flags" VkViSurfaceCreateInfoNN where + {-# INLINE writeField #-} + writeField = writeVkFlags + +instance {-# OVERLAPPING #-} HasVkWindow VkViSurfaceCreateInfoNN + where + type VkWindowMType VkViSurfaceCreateInfoNN = Ptr Void + + {-# NOINLINE vkWindow #-} + vkWindow x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkViSurfaceCreateInfoNN, window}) + + {-# INLINE vkWindowByteOffset #-} + vkWindowByteOffset ~_ + = #{offset VkViSurfaceCreateInfoNN, window} + + {-# INLINE readVkWindow #-} + readVkWindow p + = peekByteOff p #{offset VkViSurfaceCreateInfoNN, window} + + {-# INLINE writeVkWindow #-} + writeVkWindow p + = pokeByteOff p #{offset VkViSurfaceCreateInfoNN, window} + +instance {-# OVERLAPPING #-} + HasField "window" VkViSurfaceCreateInfoNN where + type FieldType "window" VkViSurfaceCreateInfoNN = Ptr Void + type FieldOptional "window" VkViSurfaceCreateInfoNN = 'False -- ' closing tick for hsc2hs + type FieldOffset "window" VkViSurfaceCreateInfoNN = + #{offset VkViSurfaceCreateInfoNN, window} + type FieldIsArray "window" VkViSurfaceCreateInfoNN = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkViSurfaceCreateInfoNN, window} + +instance CanReadField "window" VkViSurfaceCreateInfoNN where + {-# INLINE getField #-} + getField = vkWindow + + {-# INLINE readField #-} + readField = readVkWindow + +instance CanWriteField "window" VkViSurfaceCreateInfoNN where + {-# INLINE writeField #-} + writeField = writeVkWindow + +instance Show VkViSurfaceCreateInfoNN where + showsPrec d x + = showString "VkViSurfaceCreateInfoNN {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkFlags = " . + showsPrec d (vkFlags x) . + showString ", " . + showString "vkWindow = " . showsPrec d (vkWindow x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkViewport.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkViewport.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkViewport.hsc @@ -0,0 +1,350 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkViewport (VkViewport(..)) + where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkViewport { +-- > float x; +-- > float y; +-- > float width; +-- > float height; +-- > float minDepth; +-- > float maxDepth; +-- > } VkViewport; +-- +-- +data VkViewport = VkViewport## Addr## ByteArray## + +instance Eq VkViewport where + (VkViewport## a _) == x@(VkViewport## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkViewport where + (VkViewport## a _) `compare` x@(VkViewport## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkViewport where + sizeOf ~_ = #{size VkViewport} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkViewport} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkViewport where + unsafeAddr (VkViewport## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkViewport## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkViewport## (plusAddr## (byteArrayContents## b) off) b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkViewport where + type StructFields VkViewport = + '["x", "y", "width", "height", "minDepth", "maxDepth"] -- ' closing tick for hsc2hs + type CUnionType VkViewport = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkViewport = 'False -- ' closing tick for hsc2hs + type StructExtends VkViewport = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkX VkViewport where + type VkXMType VkViewport = #{type float} + + {-# NOINLINE vkX #-} + vkX x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkViewport, x}) + + {-# INLINE vkXByteOffset #-} + vkXByteOffset ~_ = #{offset VkViewport, x} + + {-# INLINE readVkX #-} + readVkX p = peekByteOff p #{offset VkViewport, x} + + {-# INLINE writeVkX #-} + writeVkX p = pokeByteOff p #{offset VkViewport, x} + +instance {-# OVERLAPPING #-} HasField "x" VkViewport where + type FieldType "x" VkViewport = #{type float} + type FieldOptional "x" VkViewport = 'False -- ' closing tick for hsc2hs + type FieldOffset "x" VkViewport = + #{offset VkViewport, x} + type FieldIsArray "x" VkViewport = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkViewport, x} + +instance CanReadField "x" VkViewport where + {-# INLINE getField #-} + getField = vkX + + {-# INLINE readField #-} + readField = readVkX + +instance CanWriteField "x" VkViewport where + {-# INLINE writeField #-} + writeField = writeVkX + +instance {-# OVERLAPPING #-} HasVkY VkViewport where + type VkYMType VkViewport = #{type float} + + {-# NOINLINE vkY #-} + vkY x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkViewport, y}) + + {-# INLINE vkYByteOffset #-} + vkYByteOffset ~_ = #{offset VkViewport, y} + + {-# INLINE readVkY #-} + readVkY p = peekByteOff p #{offset VkViewport, y} + + {-# INLINE writeVkY #-} + writeVkY p = pokeByteOff p #{offset VkViewport, y} + +instance {-# OVERLAPPING #-} HasField "y" VkViewport where + type FieldType "y" VkViewport = #{type float} + type FieldOptional "y" VkViewport = 'False -- ' closing tick for hsc2hs + type FieldOffset "y" VkViewport = + #{offset VkViewport, y} + type FieldIsArray "y" VkViewport = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkViewport, y} + +instance CanReadField "y" VkViewport where + {-# INLINE getField #-} + getField = vkY + + {-# INLINE readField #-} + readField = readVkY + +instance CanWriteField "y" VkViewport where + {-# INLINE writeField #-} + writeField = writeVkY + +instance {-# OVERLAPPING #-} HasVkWidth VkViewport where + type VkWidthMType VkViewport = #{type float} + + {-# NOINLINE vkWidth #-} + vkWidth x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkViewport, width}) + + {-# INLINE vkWidthByteOffset #-} + vkWidthByteOffset ~_ = #{offset VkViewport, width} + + {-# INLINE readVkWidth #-} + readVkWidth p + = peekByteOff p #{offset VkViewport, width} + + {-# INLINE writeVkWidth #-} + writeVkWidth p + = pokeByteOff p #{offset VkViewport, width} + +instance {-# OVERLAPPING #-} HasField "width" VkViewport where + type FieldType "width" VkViewport = #{type float} + type FieldOptional "width" VkViewport = 'False -- ' closing tick for hsc2hs + type FieldOffset "width" VkViewport = + #{offset VkViewport, width} + type FieldIsArray "width" VkViewport = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkViewport, width} + +instance CanReadField "width" VkViewport where + {-# INLINE getField #-} + getField = vkWidth + + {-# INLINE readField #-} + readField = readVkWidth + +instance CanWriteField "width" VkViewport where + {-# INLINE writeField #-} + writeField = writeVkWidth + +instance {-# OVERLAPPING #-} HasVkHeight VkViewport where + type VkHeightMType VkViewport = #{type float} + + {-# NOINLINE vkHeight #-} + vkHeight x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkViewport, height}) + + {-# INLINE vkHeightByteOffset #-} + vkHeightByteOffset ~_ = #{offset VkViewport, height} + + {-# INLINE readVkHeight #-} + readVkHeight p + = peekByteOff p #{offset VkViewport, height} + + {-# INLINE writeVkHeight #-} + writeVkHeight p + = pokeByteOff p #{offset VkViewport, height} + +instance {-# OVERLAPPING #-} HasField "height" VkViewport where + type FieldType "height" VkViewport = #{type float} + type FieldOptional "height" VkViewport = 'False -- ' closing tick for hsc2hs + type FieldOffset "height" VkViewport = + #{offset VkViewport, height} + type FieldIsArray "height" VkViewport = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkViewport, height} + +instance CanReadField "height" VkViewport where + {-# INLINE getField #-} + getField = vkHeight + + {-# INLINE readField #-} + readField = readVkHeight + +instance CanWriteField "height" VkViewport where + {-# INLINE writeField #-} + writeField = writeVkHeight + +instance {-# OVERLAPPING #-} HasVkMinDepth VkViewport where + type VkMinDepthMType VkViewport = #{type float} + + {-# NOINLINE vkMinDepth #-} + vkMinDepth x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkViewport, minDepth}) + + {-# INLINE vkMinDepthByteOffset #-} + vkMinDepthByteOffset ~_ + = #{offset VkViewport, minDepth} + + {-# INLINE readVkMinDepth #-} + readVkMinDepth p + = peekByteOff p #{offset VkViewport, minDepth} + + {-# INLINE writeVkMinDepth #-} + writeVkMinDepth p + = pokeByteOff p #{offset VkViewport, minDepth} + +instance {-# OVERLAPPING #-} HasField "minDepth" VkViewport where + type FieldType "minDepth" VkViewport = #{type float} + type FieldOptional "minDepth" VkViewport = 'False -- ' closing tick for hsc2hs + type FieldOffset "minDepth" VkViewport = + #{offset VkViewport, minDepth} + type FieldIsArray "minDepth" VkViewport = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkViewport, minDepth} + +instance CanReadField "minDepth" VkViewport where + {-# INLINE getField #-} + getField = vkMinDepth + + {-# INLINE readField #-} + readField = readVkMinDepth + +instance CanWriteField "minDepth" VkViewport where + {-# INLINE writeField #-} + writeField = writeVkMinDepth + +instance {-# OVERLAPPING #-} HasVkMaxDepth VkViewport where + type VkMaxDepthMType VkViewport = #{type float} + + {-# NOINLINE vkMaxDepth #-} + vkMaxDepth x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkViewport, maxDepth}) + + {-# INLINE vkMaxDepthByteOffset #-} + vkMaxDepthByteOffset ~_ + = #{offset VkViewport, maxDepth} + + {-# INLINE readVkMaxDepth #-} + readVkMaxDepth p + = peekByteOff p #{offset VkViewport, maxDepth} + + {-# INLINE writeVkMaxDepth #-} + writeVkMaxDepth p + = pokeByteOff p #{offset VkViewport, maxDepth} + +instance {-# OVERLAPPING #-} HasField "maxDepth" VkViewport where + type FieldType "maxDepth" VkViewport = #{type float} + type FieldOptional "maxDepth" VkViewport = 'False -- ' closing tick for hsc2hs + type FieldOffset "maxDepth" VkViewport = + #{offset VkViewport, maxDepth} + type FieldIsArray "maxDepth" VkViewport = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkViewport, maxDepth} + +instance CanReadField "maxDepth" VkViewport where + {-# INLINE getField #-} + getField = vkMaxDepth + + {-# INLINE readField #-} + readField = readVkMaxDepth + +instance CanWriteField "maxDepth" VkViewport where + {-# INLINE writeField #-} + writeField = writeVkMaxDepth + +instance Show VkViewport where + showsPrec d x + = showString "VkViewport {" . + showString "vkX = " . + showsPrec d (vkX x) . + showString ", " . + showString "vkY = " . + showsPrec d (vkY x) . + showString ", " . + showString "vkWidth = " . + showsPrec d (vkWidth x) . + showString ", " . + showString "vkHeight = " . + showsPrec d (vkHeight x) . + showString ", " . + showString "vkMinDepth = " . + showsPrec d (vkMinDepth x) . + showString ", " . + showString "vkMaxDepth = " . + showsPrec d (vkMaxDepth x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkViewportSwizzleNV.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkViewportSwizzleNV.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkViewportSwizzleNV.hsc @@ -0,0 +1,261 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkViewportSwizzleNV + (VkViewportSwizzleNV(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkViewportCoordinateSwizzleNV (VkViewportCoordinateSwizzleNV) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkViewportSwizzleNV { +-- > VkViewportCoordinateSwizzleNV x; +-- > VkViewportCoordinateSwizzleNV y; +-- > VkViewportCoordinateSwizzleNV z; +-- > VkViewportCoordinateSwizzleNV w; +-- > } VkViewportSwizzleNV; +-- +-- +data VkViewportSwizzleNV = VkViewportSwizzleNV## Addr## ByteArray## + +instance Eq VkViewportSwizzleNV where + (VkViewportSwizzleNV## a _) == x@(VkViewportSwizzleNV## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkViewportSwizzleNV where + (VkViewportSwizzleNV## a _) `compare` x@(VkViewportSwizzleNV## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkViewportSwizzleNV where + sizeOf ~_ = #{size VkViewportSwizzleNV} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkViewportSwizzleNV} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkViewportSwizzleNV where + unsafeAddr (VkViewportSwizzleNV## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkViewportSwizzleNV## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkViewportSwizzleNV## (plusAddr## (byteArrayContents## b) off) b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkViewportSwizzleNV where + type StructFields VkViewportSwizzleNV = '["x", "y", "z", "w"] -- ' closing tick for hsc2hs + type CUnionType VkViewportSwizzleNV = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkViewportSwizzleNV = 'False -- ' closing tick for hsc2hs + type StructExtends VkViewportSwizzleNV = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkX VkViewportSwizzleNV where + type VkXMType VkViewportSwizzleNV = VkViewportCoordinateSwizzleNV + + {-# NOINLINE vkX #-} + vkX x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkViewportSwizzleNV, x}) + + {-# INLINE vkXByteOffset #-} + vkXByteOffset ~_ = #{offset VkViewportSwizzleNV, x} + + {-# INLINE readVkX #-} + readVkX p + = peekByteOff p #{offset VkViewportSwizzleNV, x} + + {-# INLINE writeVkX #-} + writeVkX p + = pokeByteOff p #{offset VkViewportSwizzleNV, x} + +instance {-# OVERLAPPING #-} HasField "x" VkViewportSwizzleNV where + type FieldType "x" VkViewportSwizzleNV = + VkViewportCoordinateSwizzleNV + type FieldOptional "x" VkViewportSwizzleNV = 'False -- ' closing tick for hsc2hs + type FieldOffset "x" VkViewportSwizzleNV = + #{offset VkViewportSwizzleNV, x} + type FieldIsArray "x" VkViewportSwizzleNV = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkViewportSwizzleNV, x} + +instance CanReadField "x" VkViewportSwizzleNV where + {-# INLINE getField #-} + getField = vkX + + {-# INLINE readField #-} + readField = readVkX + +instance CanWriteField "x" VkViewportSwizzleNV where + {-# INLINE writeField #-} + writeField = writeVkX + +instance {-# OVERLAPPING #-} HasVkY VkViewportSwizzleNV where + type VkYMType VkViewportSwizzleNV = VkViewportCoordinateSwizzleNV + + {-# NOINLINE vkY #-} + vkY x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkViewportSwizzleNV, y}) + + {-# INLINE vkYByteOffset #-} + vkYByteOffset ~_ = #{offset VkViewportSwizzleNV, y} + + {-# INLINE readVkY #-} + readVkY p + = peekByteOff p #{offset VkViewportSwizzleNV, y} + + {-# INLINE writeVkY #-} + writeVkY p + = pokeByteOff p #{offset VkViewportSwizzleNV, y} + +instance {-# OVERLAPPING #-} HasField "y" VkViewportSwizzleNV where + type FieldType "y" VkViewportSwizzleNV = + VkViewportCoordinateSwizzleNV + type FieldOptional "y" VkViewportSwizzleNV = 'False -- ' closing tick for hsc2hs + type FieldOffset "y" VkViewportSwizzleNV = + #{offset VkViewportSwizzleNV, y} + type FieldIsArray "y" VkViewportSwizzleNV = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkViewportSwizzleNV, y} + +instance CanReadField "y" VkViewportSwizzleNV where + {-# INLINE getField #-} + getField = vkY + + {-# INLINE readField #-} + readField = readVkY + +instance CanWriteField "y" VkViewportSwizzleNV where + {-# INLINE writeField #-} + writeField = writeVkY + +instance {-# OVERLAPPING #-} HasVkZ VkViewportSwizzleNV where + type VkZMType VkViewportSwizzleNV = VkViewportCoordinateSwizzleNV + + {-# NOINLINE vkZ #-} + vkZ x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkViewportSwizzleNV, z}) + + {-# INLINE vkZByteOffset #-} + vkZByteOffset ~_ = #{offset VkViewportSwizzleNV, z} + + {-# INLINE readVkZ #-} + readVkZ p + = peekByteOff p #{offset VkViewportSwizzleNV, z} + + {-# INLINE writeVkZ #-} + writeVkZ p + = pokeByteOff p #{offset VkViewportSwizzleNV, z} + +instance {-# OVERLAPPING #-} HasField "z" VkViewportSwizzleNV where + type FieldType "z" VkViewportSwizzleNV = + VkViewportCoordinateSwizzleNV + type FieldOptional "z" VkViewportSwizzleNV = 'False -- ' closing tick for hsc2hs + type FieldOffset "z" VkViewportSwizzleNV = + #{offset VkViewportSwizzleNV, z} + type FieldIsArray "z" VkViewportSwizzleNV = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkViewportSwizzleNV, z} + +instance CanReadField "z" VkViewportSwizzleNV where + {-# INLINE getField #-} + getField = vkZ + + {-# INLINE readField #-} + readField = readVkZ + +instance CanWriteField "z" VkViewportSwizzleNV where + {-# INLINE writeField #-} + writeField = writeVkZ + +instance {-# OVERLAPPING #-} HasVkW VkViewportSwizzleNV where + type VkWMType VkViewportSwizzleNV = VkViewportCoordinateSwizzleNV + + {-# NOINLINE vkW #-} + vkW x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkViewportSwizzleNV, w}) + + {-# INLINE vkWByteOffset #-} + vkWByteOffset ~_ = #{offset VkViewportSwizzleNV, w} + + {-# INLINE readVkW #-} + readVkW p + = peekByteOff p #{offset VkViewportSwizzleNV, w} + + {-# INLINE writeVkW #-} + writeVkW p + = pokeByteOff p #{offset VkViewportSwizzleNV, w} + +instance {-# OVERLAPPING #-} HasField "w" VkViewportSwizzleNV where + type FieldType "w" VkViewportSwizzleNV = + VkViewportCoordinateSwizzleNV + type FieldOptional "w" VkViewportSwizzleNV = 'False -- ' closing tick for hsc2hs + type FieldOffset "w" VkViewportSwizzleNV = + #{offset VkViewportSwizzleNV, w} + type FieldIsArray "w" VkViewportSwizzleNV = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkViewportSwizzleNV, w} + +instance CanReadField "w" VkViewportSwizzleNV where + {-# INLINE getField #-} + getField = vkW + + {-# INLINE readField #-} + readField = readVkW + +instance CanWriteField "w" VkViewportSwizzleNV where + {-# INLINE writeField #-} + writeField = writeVkW + +instance Show VkViewportSwizzleNV where + showsPrec d x + = showString "VkViewportSwizzleNV {" . + showString "vkX = " . + showsPrec d (vkX x) . + showString ", " . + showString "vkY = " . + showsPrec d (vkY x) . + showString ", " . + showString "vkZ = " . + showsPrec d (vkZ x) . + showString ", " . + showString "vkW = " . showsPrec d (vkW x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkViewportWScalingNV.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkViewportWScalingNV.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkViewportWScalingNV.hsc @@ -0,0 +1,168 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkViewportWScalingNV + (VkViewportWScalingNV(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkViewportWScalingNV { +-- > float xcoeff; +-- > float ycoeff; +-- > } VkViewportWScalingNV; +-- +-- +data VkViewportWScalingNV = VkViewportWScalingNV## Addr## ByteArray## + +instance Eq VkViewportWScalingNV where + (VkViewportWScalingNV## a _) == x@(VkViewportWScalingNV## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkViewportWScalingNV where + (VkViewportWScalingNV## a _) `compare` x@(VkViewportWScalingNV## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkViewportWScalingNV where + sizeOf ~_ = #{size VkViewportWScalingNV} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkViewportWScalingNV} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkViewportWScalingNV where + unsafeAddr (VkViewportWScalingNV## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkViewportWScalingNV## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkViewportWScalingNV## (plusAddr## (byteArrayContents## b) off) b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkViewportWScalingNV where + type StructFields VkViewportWScalingNV = '["xcoeff", "ycoeff"] -- ' closing tick for hsc2hs + type CUnionType VkViewportWScalingNV = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkViewportWScalingNV = 'False -- ' closing tick for hsc2hs + type StructExtends VkViewportWScalingNV = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkXcoeff VkViewportWScalingNV where + type VkXcoeffMType VkViewportWScalingNV = #{type float} + + {-# NOINLINE vkXcoeff #-} + vkXcoeff x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkViewportWScalingNV, xcoeff}) + + {-# INLINE vkXcoeffByteOffset #-} + vkXcoeffByteOffset ~_ + = #{offset VkViewportWScalingNV, xcoeff} + + {-# INLINE readVkXcoeff #-} + readVkXcoeff p + = peekByteOff p #{offset VkViewportWScalingNV, xcoeff} + + {-# INLINE writeVkXcoeff #-} + writeVkXcoeff p + = pokeByteOff p #{offset VkViewportWScalingNV, xcoeff} + +instance {-# OVERLAPPING #-} HasField "xcoeff" VkViewportWScalingNV + where + type FieldType "xcoeff" VkViewportWScalingNV = + #{type float} + type FieldOptional "xcoeff" VkViewportWScalingNV = 'False -- ' closing tick for hsc2hs + type FieldOffset "xcoeff" VkViewportWScalingNV = + #{offset VkViewportWScalingNV, xcoeff} + type FieldIsArray "xcoeff" VkViewportWScalingNV = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkViewportWScalingNV, xcoeff} + +instance CanReadField "xcoeff" VkViewportWScalingNV where + {-# INLINE getField #-} + getField = vkXcoeff + + {-# INLINE readField #-} + readField = readVkXcoeff + +instance CanWriteField "xcoeff" VkViewportWScalingNV where + {-# INLINE writeField #-} + writeField = writeVkXcoeff + +instance {-# OVERLAPPING #-} HasVkYcoeff VkViewportWScalingNV where + type VkYcoeffMType VkViewportWScalingNV = #{type float} + + {-# NOINLINE vkYcoeff #-} + vkYcoeff x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkViewportWScalingNV, ycoeff}) + + {-# INLINE vkYcoeffByteOffset #-} + vkYcoeffByteOffset ~_ + = #{offset VkViewportWScalingNV, ycoeff} + + {-# INLINE readVkYcoeff #-} + readVkYcoeff p + = peekByteOff p #{offset VkViewportWScalingNV, ycoeff} + + {-# INLINE writeVkYcoeff #-} + writeVkYcoeff p + = pokeByteOff p #{offset VkViewportWScalingNV, ycoeff} + +instance {-# OVERLAPPING #-} HasField "ycoeff" VkViewportWScalingNV + where + type FieldType "ycoeff" VkViewportWScalingNV = + #{type float} + type FieldOptional "ycoeff" VkViewportWScalingNV = 'False -- ' closing tick for hsc2hs + type FieldOffset "ycoeff" VkViewportWScalingNV = + #{offset VkViewportWScalingNV, ycoeff} + type FieldIsArray "ycoeff" VkViewportWScalingNV = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkViewportWScalingNV, ycoeff} + +instance CanReadField "ycoeff" VkViewportWScalingNV where + {-# INLINE getField #-} + getField = vkYcoeff + + {-# INLINE readField #-} + readField = readVkYcoeff + +instance CanWriteField "ycoeff" VkViewportWScalingNV where + {-# INLINE writeField #-} + writeField = writeVkYcoeff + +instance Show VkViewportWScalingNV where + showsPrec d x + = showString "VkViewportWScalingNV {" . + showString "vkXcoeff = " . + showsPrec d (vkXcoeff x) . + showString ", " . + showString "vkYcoeff = " . showsPrec d (vkYcoeff x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkWaylandSurfaceCreateInfoKHR.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkWaylandSurfaceCreateInfoKHR.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkWaylandSurfaceCreateInfoKHR.hsc @@ -0,0 +1,341 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkWaylandSurfaceCreateInfoKHR + (VkWaylandSurfaceCreateInfoKHR(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Bitmasks (VkWaylandSurfaceCreateFlagsKHR) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Include (WlDisplay, + WlSurface) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkWaylandSurfaceCreateInfoKHR { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkWaylandSurfaceCreateFlagsKHR flags; +-- > struct wl_display* display; +-- > struct wl_surface* surface; +-- > } VkWaylandSurfaceCreateInfoKHR; +-- +-- +data VkWaylandSurfaceCreateInfoKHR = VkWaylandSurfaceCreateInfoKHR## Addr## + ByteArray## + +instance Eq VkWaylandSurfaceCreateInfoKHR where + (VkWaylandSurfaceCreateInfoKHR## a _) == + x@(VkWaylandSurfaceCreateInfoKHR## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkWaylandSurfaceCreateInfoKHR where + (VkWaylandSurfaceCreateInfoKHR## a _) `compare` + x@(VkWaylandSurfaceCreateInfoKHR## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkWaylandSurfaceCreateInfoKHR where + sizeOf ~_ = #{size VkWaylandSurfaceCreateInfoKHR} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkWaylandSurfaceCreateInfoKHR} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkWaylandSurfaceCreateInfoKHR where + unsafeAddr (VkWaylandSurfaceCreateInfoKHR## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkWaylandSurfaceCreateInfoKHR## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkWaylandSurfaceCreateInfoKHR## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkWaylandSurfaceCreateInfoKHR where + type StructFields VkWaylandSurfaceCreateInfoKHR = + '["sType", "pNext", "flags", "display", "surface"] -- ' closing tick for hsc2hs + type CUnionType VkWaylandSurfaceCreateInfoKHR = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkWaylandSurfaceCreateInfoKHR = 'False -- ' closing tick for hsc2hs + type StructExtends VkWaylandSurfaceCreateInfoKHR = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkWaylandSurfaceCreateInfoKHR where + type VkSTypeMType VkWaylandSurfaceCreateInfoKHR = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkWaylandSurfaceCreateInfoKHR, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkWaylandSurfaceCreateInfoKHR, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkWaylandSurfaceCreateInfoKHR, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkWaylandSurfaceCreateInfoKHR, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkWaylandSurfaceCreateInfoKHR where + type FieldType "sType" VkWaylandSurfaceCreateInfoKHR = + VkStructureType + type FieldOptional "sType" VkWaylandSurfaceCreateInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkWaylandSurfaceCreateInfoKHR = + #{offset VkWaylandSurfaceCreateInfoKHR, sType} + type FieldIsArray "sType" VkWaylandSurfaceCreateInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkWaylandSurfaceCreateInfoKHR, sType} + +instance CanReadField "sType" VkWaylandSurfaceCreateInfoKHR where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkWaylandSurfaceCreateInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkWaylandSurfaceCreateInfoKHR where + type VkPNextMType VkWaylandSurfaceCreateInfoKHR = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkWaylandSurfaceCreateInfoKHR, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkWaylandSurfaceCreateInfoKHR, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkWaylandSurfaceCreateInfoKHR, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkWaylandSurfaceCreateInfoKHR, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkWaylandSurfaceCreateInfoKHR where + type FieldType "pNext" VkWaylandSurfaceCreateInfoKHR = Ptr Void + type FieldOptional "pNext" VkWaylandSurfaceCreateInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkWaylandSurfaceCreateInfoKHR = + #{offset VkWaylandSurfaceCreateInfoKHR, pNext} + type FieldIsArray "pNext" VkWaylandSurfaceCreateInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkWaylandSurfaceCreateInfoKHR, pNext} + +instance CanReadField "pNext" VkWaylandSurfaceCreateInfoKHR where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkWaylandSurfaceCreateInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkFlags VkWaylandSurfaceCreateInfoKHR where + type VkFlagsMType VkWaylandSurfaceCreateInfoKHR = + VkWaylandSurfaceCreateFlagsKHR + + {-# NOINLINE vkFlags #-} + vkFlags x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkWaylandSurfaceCreateInfoKHR, flags}) + + {-# INLINE vkFlagsByteOffset #-} + vkFlagsByteOffset ~_ + = #{offset VkWaylandSurfaceCreateInfoKHR, flags} + + {-# INLINE readVkFlags #-} + readVkFlags p + = peekByteOff p #{offset VkWaylandSurfaceCreateInfoKHR, flags} + + {-# INLINE writeVkFlags #-} + writeVkFlags p + = pokeByteOff p #{offset VkWaylandSurfaceCreateInfoKHR, flags} + +instance {-# OVERLAPPING #-} + HasField "flags" VkWaylandSurfaceCreateInfoKHR where + type FieldType "flags" VkWaylandSurfaceCreateInfoKHR = + VkWaylandSurfaceCreateFlagsKHR + type FieldOptional "flags" VkWaylandSurfaceCreateInfoKHR = 'True -- ' closing tick for hsc2hs + type FieldOffset "flags" VkWaylandSurfaceCreateInfoKHR = + #{offset VkWaylandSurfaceCreateInfoKHR, flags} + type FieldIsArray "flags" VkWaylandSurfaceCreateInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkWaylandSurfaceCreateInfoKHR, flags} + +instance CanReadField "flags" VkWaylandSurfaceCreateInfoKHR where + {-# INLINE getField #-} + getField = vkFlags + + {-# INLINE readField #-} + readField = readVkFlags + +instance CanWriteField "flags" VkWaylandSurfaceCreateInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkFlags + +instance {-# OVERLAPPING #-} + HasVkDisplay VkWaylandSurfaceCreateInfoKHR where + type VkDisplayMType VkWaylandSurfaceCreateInfoKHR = Ptr WlDisplay + + {-# NOINLINE vkDisplay #-} + vkDisplay x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkWaylandSurfaceCreateInfoKHR, display}) + + {-# INLINE vkDisplayByteOffset #-} + vkDisplayByteOffset ~_ + = #{offset VkWaylandSurfaceCreateInfoKHR, display} + + {-# INLINE readVkDisplay #-} + readVkDisplay p + = peekByteOff p #{offset VkWaylandSurfaceCreateInfoKHR, display} + + {-# INLINE writeVkDisplay #-} + writeVkDisplay p + = pokeByteOff p #{offset VkWaylandSurfaceCreateInfoKHR, display} + +instance {-# OVERLAPPING #-} + HasField "display" VkWaylandSurfaceCreateInfoKHR where + type FieldType "display" VkWaylandSurfaceCreateInfoKHR = + Ptr WlDisplay + type FieldOptional "display" VkWaylandSurfaceCreateInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "display" VkWaylandSurfaceCreateInfoKHR = + #{offset VkWaylandSurfaceCreateInfoKHR, display} + type FieldIsArray "display" VkWaylandSurfaceCreateInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkWaylandSurfaceCreateInfoKHR, display} + +instance CanReadField "display" VkWaylandSurfaceCreateInfoKHR where + {-# INLINE getField #-} + getField = vkDisplay + + {-# INLINE readField #-} + readField = readVkDisplay + +instance CanWriteField "display" VkWaylandSurfaceCreateInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkDisplay + +instance {-# OVERLAPPING #-} + HasVkSurface VkWaylandSurfaceCreateInfoKHR where + type VkSurfaceMType VkWaylandSurfaceCreateInfoKHR = Ptr WlSurface + + {-# NOINLINE vkSurface #-} + vkSurface x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkWaylandSurfaceCreateInfoKHR, surface}) + + {-# INLINE vkSurfaceByteOffset #-} + vkSurfaceByteOffset ~_ + = #{offset VkWaylandSurfaceCreateInfoKHR, surface} + + {-# INLINE readVkSurface #-} + readVkSurface p + = peekByteOff p #{offset VkWaylandSurfaceCreateInfoKHR, surface} + + {-# INLINE writeVkSurface #-} + writeVkSurface p + = pokeByteOff p #{offset VkWaylandSurfaceCreateInfoKHR, surface} + +instance {-# OVERLAPPING #-} + HasField "surface" VkWaylandSurfaceCreateInfoKHR where + type FieldType "surface" VkWaylandSurfaceCreateInfoKHR = + Ptr WlSurface + type FieldOptional "surface" VkWaylandSurfaceCreateInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "surface" VkWaylandSurfaceCreateInfoKHR = + #{offset VkWaylandSurfaceCreateInfoKHR, surface} + type FieldIsArray "surface" VkWaylandSurfaceCreateInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkWaylandSurfaceCreateInfoKHR, surface} + +instance CanReadField "surface" VkWaylandSurfaceCreateInfoKHR where + {-# INLINE getField #-} + getField = vkSurface + + {-# INLINE readField #-} + readField = readVkSurface + +instance CanWriteField "surface" VkWaylandSurfaceCreateInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkSurface + +instance Show VkWaylandSurfaceCreateInfoKHR where + showsPrec d x + = showString "VkWaylandSurfaceCreateInfoKHR {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkFlags = " . + showsPrec d (vkFlags x) . + showString ", " . + showString "vkDisplay = " . + showsPrec d (vkDisplay x) . + showString ", " . + showString "vkSurface = " . + showsPrec d (vkSurface x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkWin32KeyedMutexAcquireReleaseInfoKHR.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkWin32KeyedMutexAcquireReleaseInfoKHR.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkWin32KeyedMutexAcquireReleaseInfoKHR.hsc @@ -0,0 +1,657 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkWin32KeyedMutexAcquireReleaseInfoKHR + (VkWin32KeyedMutexAcquireReleaseInfoKHR(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Handles (VkDeviceMemory) +import Graphics.Vulkan.Types.Struct.VkSubmitInfo (VkSubmitInfo) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkWin32KeyedMutexAcquireReleaseInfoKHR { +-- > VkStructureType sType; +-- > const void* pNext; +-- > uint32_t acquireCount; +-- > const VkDeviceMemory* pAcquireSyncs; +-- > const uint64_t* pAcquireKeys; +-- > const uint32_t* pAcquireTimeouts; +-- > uint32_t releaseCount; +-- > const VkDeviceMemory* pReleaseSyncs; +-- > const uint64_t* pReleaseKeys; +-- > } VkWin32KeyedMutexAcquireReleaseInfoKHR; +-- +-- +data VkWin32KeyedMutexAcquireReleaseInfoKHR = VkWin32KeyedMutexAcquireReleaseInfoKHR## Addr## + ByteArray## + +instance Eq VkWin32KeyedMutexAcquireReleaseInfoKHR where + (VkWin32KeyedMutexAcquireReleaseInfoKHR## a _) == + x@(VkWin32KeyedMutexAcquireReleaseInfoKHR## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkWin32KeyedMutexAcquireReleaseInfoKHR where + (VkWin32KeyedMutexAcquireReleaseInfoKHR## a _) `compare` + x@(VkWin32KeyedMutexAcquireReleaseInfoKHR## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkWin32KeyedMutexAcquireReleaseInfoKHR where + sizeOf ~_ + = #{size VkWin32KeyedMutexAcquireReleaseInfoKHR} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkWin32KeyedMutexAcquireReleaseInfoKHR} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkWin32KeyedMutexAcquireReleaseInfoKHR + where + unsafeAddr (VkWin32KeyedMutexAcquireReleaseInfoKHR## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkWin32KeyedMutexAcquireReleaseInfoKHR## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkWin32KeyedMutexAcquireReleaseInfoKHR## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkWin32KeyedMutexAcquireReleaseInfoKHR where + type StructFields VkWin32KeyedMutexAcquireReleaseInfoKHR = + '["sType", "pNext", "acquireCount", "pAcquireSyncs", -- ' closing tick for hsc2hs + "pAcquireKeys", "pAcquireTimeouts", "releaseCount", + "pReleaseSyncs", "pReleaseKeys"] + type CUnionType VkWin32KeyedMutexAcquireReleaseInfoKHR = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkWin32KeyedMutexAcquireReleaseInfoKHR = 'False -- ' closing tick for hsc2hs + type StructExtends VkWin32KeyedMutexAcquireReleaseInfoKHR = + '[VkSubmitInfo] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkWin32KeyedMutexAcquireReleaseInfoKHR where + type VkSTypeMType VkWin32KeyedMutexAcquireReleaseInfoKHR = + VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkWin32KeyedMutexAcquireReleaseInfoKHR, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkWin32KeyedMutexAcquireReleaseInfoKHR, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkWin32KeyedMutexAcquireReleaseInfoKHR, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkWin32KeyedMutexAcquireReleaseInfoKHR, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkWin32KeyedMutexAcquireReleaseInfoKHR where + type FieldType "sType" VkWin32KeyedMutexAcquireReleaseInfoKHR = + VkStructureType + type FieldOptional "sType" VkWin32KeyedMutexAcquireReleaseInfoKHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkWin32KeyedMutexAcquireReleaseInfoKHR = + #{offset VkWin32KeyedMutexAcquireReleaseInfoKHR, sType} + type FieldIsArray "sType" VkWin32KeyedMutexAcquireReleaseInfoKHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkWin32KeyedMutexAcquireReleaseInfoKHR, sType} + +instance CanReadField "sType" + VkWin32KeyedMutexAcquireReleaseInfoKHR + where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" + VkWin32KeyedMutexAcquireReleaseInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkWin32KeyedMutexAcquireReleaseInfoKHR where + type VkPNextMType VkWin32KeyedMutexAcquireReleaseInfoKHR = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkWin32KeyedMutexAcquireReleaseInfoKHR, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkWin32KeyedMutexAcquireReleaseInfoKHR, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkWin32KeyedMutexAcquireReleaseInfoKHR, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkWin32KeyedMutexAcquireReleaseInfoKHR, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkWin32KeyedMutexAcquireReleaseInfoKHR where + type FieldType "pNext" VkWin32KeyedMutexAcquireReleaseInfoKHR = + Ptr Void + type FieldOptional "pNext" VkWin32KeyedMutexAcquireReleaseInfoKHR = + 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkWin32KeyedMutexAcquireReleaseInfoKHR = + #{offset VkWin32KeyedMutexAcquireReleaseInfoKHR, pNext} + type FieldIsArray "pNext" VkWin32KeyedMutexAcquireReleaseInfoKHR = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkWin32KeyedMutexAcquireReleaseInfoKHR, pNext} + +instance CanReadField "pNext" + VkWin32KeyedMutexAcquireReleaseInfoKHR + where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" + VkWin32KeyedMutexAcquireReleaseInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkAcquireCount VkWin32KeyedMutexAcquireReleaseInfoKHR where + type VkAcquireCountMType VkWin32KeyedMutexAcquireReleaseInfoKHR = + Word32 + + {-# NOINLINE vkAcquireCount #-} + vkAcquireCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkWin32KeyedMutexAcquireReleaseInfoKHR, acquireCount}) + + {-# INLINE vkAcquireCountByteOffset #-} + vkAcquireCountByteOffset ~_ + = #{offset VkWin32KeyedMutexAcquireReleaseInfoKHR, acquireCount} + + {-# INLINE readVkAcquireCount #-} + readVkAcquireCount p + = peekByteOff p #{offset VkWin32KeyedMutexAcquireReleaseInfoKHR, acquireCount} + + {-# INLINE writeVkAcquireCount #-} + writeVkAcquireCount p + = pokeByteOff p #{offset VkWin32KeyedMutexAcquireReleaseInfoKHR, acquireCount} + +instance {-# OVERLAPPING #-} + HasField "acquireCount" VkWin32KeyedMutexAcquireReleaseInfoKHR + where + type FieldType "acquireCount" + VkWin32KeyedMutexAcquireReleaseInfoKHR + = Word32 + type FieldOptional "acquireCount" + VkWin32KeyedMutexAcquireReleaseInfoKHR + = 'True -- ' closing tick for hsc2hs + type FieldOffset "acquireCount" + VkWin32KeyedMutexAcquireReleaseInfoKHR + = + #{offset VkWin32KeyedMutexAcquireReleaseInfoKHR, acquireCount} + type FieldIsArray "acquireCount" + VkWin32KeyedMutexAcquireReleaseInfoKHR + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkWin32KeyedMutexAcquireReleaseInfoKHR, acquireCount} + +instance CanReadField "acquireCount" + VkWin32KeyedMutexAcquireReleaseInfoKHR + where + {-# INLINE getField #-} + getField = vkAcquireCount + + {-# INLINE readField #-} + readField = readVkAcquireCount + +instance CanWriteField "acquireCount" + VkWin32KeyedMutexAcquireReleaseInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkAcquireCount + +instance {-# OVERLAPPING #-} + HasVkPAcquireSyncs VkWin32KeyedMutexAcquireReleaseInfoKHR where + type VkPAcquireSyncsMType VkWin32KeyedMutexAcquireReleaseInfoKHR = + Ptr VkDeviceMemory + + {-# NOINLINE vkPAcquireSyncs #-} + vkPAcquireSyncs x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkWin32KeyedMutexAcquireReleaseInfoKHR, pAcquireSyncs}) + + {-# INLINE vkPAcquireSyncsByteOffset #-} + vkPAcquireSyncsByteOffset ~_ + = #{offset VkWin32KeyedMutexAcquireReleaseInfoKHR, pAcquireSyncs} + + {-# INLINE readVkPAcquireSyncs #-} + readVkPAcquireSyncs p + = peekByteOff p #{offset VkWin32KeyedMutexAcquireReleaseInfoKHR, pAcquireSyncs} + + {-# INLINE writeVkPAcquireSyncs #-} + writeVkPAcquireSyncs p + = pokeByteOff p #{offset VkWin32KeyedMutexAcquireReleaseInfoKHR, pAcquireSyncs} + +instance {-# OVERLAPPING #-} + HasField "pAcquireSyncs" VkWin32KeyedMutexAcquireReleaseInfoKHR + where + type FieldType "pAcquireSyncs" + VkWin32KeyedMutexAcquireReleaseInfoKHR + = Ptr VkDeviceMemory + type FieldOptional "pAcquireSyncs" + VkWin32KeyedMutexAcquireReleaseInfoKHR + = 'False -- ' closing tick for hsc2hs + type FieldOffset "pAcquireSyncs" + VkWin32KeyedMutexAcquireReleaseInfoKHR + = + #{offset VkWin32KeyedMutexAcquireReleaseInfoKHR, pAcquireSyncs} + type FieldIsArray "pAcquireSyncs" + VkWin32KeyedMutexAcquireReleaseInfoKHR + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkWin32KeyedMutexAcquireReleaseInfoKHR, pAcquireSyncs} + +instance CanReadField "pAcquireSyncs" + VkWin32KeyedMutexAcquireReleaseInfoKHR + where + {-# INLINE getField #-} + getField = vkPAcquireSyncs + + {-# INLINE readField #-} + readField = readVkPAcquireSyncs + +instance CanWriteField "pAcquireSyncs" + VkWin32KeyedMutexAcquireReleaseInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkPAcquireSyncs + +instance {-# OVERLAPPING #-} + HasVkPAcquireKeys VkWin32KeyedMutexAcquireReleaseInfoKHR where + type VkPAcquireKeysMType VkWin32KeyedMutexAcquireReleaseInfoKHR = + Ptr Word64 + + {-# NOINLINE vkPAcquireKeys #-} + vkPAcquireKeys x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkWin32KeyedMutexAcquireReleaseInfoKHR, pAcquireKeys}) + + {-# INLINE vkPAcquireKeysByteOffset #-} + vkPAcquireKeysByteOffset ~_ + = #{offset VkWin32KeyedMutexAcquireReleaseInfoKHR, pAcquireKeys} + + {-# INLINE readVkPAcquireKeys #-} + readVkPAcquireKeys p + = peekByteOff p #{offset VkWin32KeyedMutexAcquireReleaseInfoKHR, pAcquireKeys} + + {-# INLINE writeVkPAcquireKeys #-} + writeVkPAcquireKeys p + = pokeByteOff p #{offset VkWin32KeyedMutexAcquireReleaseInfoKHR, pAcquireKeys} + +instance {-# OVERLAPPING #-} + HasField "pAcquireKeys" VkWin32KeyedMutexAcquireReleaseInfoKHR + where + type FieldType "pAcquireKeys" + VkWin32KeyedMutexAcquireReleaseInfoKHR + = Ptr Word64 + type FieldOptional "pAcquireKeys" + VkWin32KeyedMutexAcquireReleaseInfoKHR + = 'False -- ' closing tick for hsc2hs + type FieldOffset "pAcquireKeys" + VkWin32KeyedMutexAcquireReleaseInfoKHR + = + #{offset VkWin32KeyedMutexAcquireReleaseInfoKHR, pAcquireKeys} + type FieldIsArray "pAcquireKeys" + VkWin32KeyedMutexAcquireReleaseInfoKHR + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkWin32KeyedMutexAcquireReleaseInfoKHR, pAcquireKeys} + +instance CanReadField "pAcquireKeys" + VkWin32KeyedMutexAcquireReleaseInfoKHR + where + {-# INLINE getField #-} + getField = vkPAcquireKeys + + {-# INLINE readField #-} + readField = readVkPAcquireKeys + +instance CanWriteField "pAcquireKeys" + VkWin32KeyedMutexAcquireReleaseInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkPAcquireKeys + +instance {-# OVERLAPPING #-} + HasVkPAcquireTimeouts VkWin32KeyedMutexAcquireReleaseInfoKHR where + type VkPAcquireTimeoutsMType VkWin32KeyedMutexAcquireReleaseInfoKHR + = Ptr Word32 + + {-# NOINLINE vkPAcquireTimeouts #-} + vkPAcquireTimeouts x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkWin32KeyedMutexAcquireReleaseInfoKHR, pAcquireTimeouts}) + + {-# INLINE vkPAcquireTimeoutsByteOffset #-} + vkPAcquireTimeoutsByteOffset ~_ + = #{offset VkWin32KeyedMutexAcquireReleaseInfoKHR, pAcquireTimeouts} + + {-# INLINE readVkPAcquireTimeouts #-} + readVkPAcquireTimeouts p + = peekByteOff p #{offset VkWin32KeyedMutexAcquireReleaseInfoKHR, pAcquireTimeouts} + + {-# INLINE writeVkPAcquireTimeouts #-} + writeVkPAcquireTimeouts p + = pokeByteOff p #{offset VkWin32KeyedMutexAcquireReleaseInfoKHR, pAcquireTimeouts} + +instance {-# OVERLAPPING #-} + HasField "pAcquireTimeouts" VkWin32KeyedMutexAcquireReleaseInfoKHR + where + type FieldType "pAcquireTimeouts" + VkWin32KeyedMutexAcquireReleaseInfoKHR + = Ptr Word32 + type FieldOptional "pAcquireTimeouts" + VkWin32KeyedMutexAcquireReleaseInfoKHR + = 'False -- ' closing tick for hsc2hs + type FieldOffset "pAcquireTimeouts" + VkWin32KeyedMutexAcquireReleaseInfoKHR + = + #{offset VkWin32KeyedMutexAcquireReleaseInfoKHR, pAcquireTimeouts} + type FieldIsArray "pAcquireTimeouts" + VkWin32KeyedMutexAcquireReleaseInfoKHR + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkWin32KeyedMutexAcquireReleaseInfoKHR, pAcquireTimeouts} + +instance CanReadField "pAcquireTimeouts" + VkWin32KeyedMutexAcquireReleaseInfoKHR + where + {-# INLINE getField #-} + getField = vkPAcquireTimeouts + + {-# INLINE readField #-} + readField = readVkPAcquireTimeouts + +instance CanWriteField "pAcquireTimeouts" + VkWin32KeyedMutexAcquireReleaseInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkPAcquireTimeouts + +instance {-# OVERLAPPING #-} + HasVkReleaseCount VkWin32KeyedMutexAcquireReleaseInfoKHR where + type VkReleaseCountMType VkWin32KeyedMutexAcquireReleaseInfoKHR = + Word32 + + {-# NOINLINE vkReleaseCount #-} + vkReleaseCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkWin32KeyedMutexAcquireReleaseInfoKHR, releaseCount}) + + {-# INLINE vkReleaseCountByteOffset #-} + vkReleaseCountByteOffset ~_ + = #{offset VkWin32KeyedMutexAcquireReleaseInfoKHR, releaseCount} + + {-# INLINE readVkReleaseCount #-} + readVkReleaseCount p + = peekByteOff p #{offset VkWin32KeyedMutexAcquireReleaseInfoKHR, releaseCount} + + {-# INLINE writeVkReleaseCount #-} + writeVkReleaseCount p + = pokeByteOff p #{offset VkWin32KeyedMutexAcquireReleaseInfoKHR, releaseCount} + +instance {-# OVERLAPPING #-} + HasField "releaseCount" VkWin32KeyedMutexAcquireReleaseInfoKHR + where + type FieldType "releaseCount" + VkWin32KeyedMutexAcquireReleaseInfoKHR + = Word32 + type FieldOptional "releaseCount" + VkWin32KeyedMutexAcquireReleaseInfoKHR + = 'True -- ' closing tick for hsc2hs + type FieldOffset "releaseCount" + VkWin32KeyedMutexAcquireReleaseInfoKHR + = + #{offset VkWin32KeyedMutexAcquireReleaseInfoKHR, releaseCount} + type FieldIsArray "releaseCount" + VkWin32KeyedMutexAcquireReleaseInfoKHR + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkWin32KeyedMutexAcquireReleaseInfoKHR, releaseCount} + +instance CanReadField "releaseCount" + VkWin32KeyedMutexAcquireReleaseInfoKHR + where + {-# INLINE getField #-} + getField = vkReleaseCount + + {-# INLINE readField #-} + readField = readVkReleaseCount + +instance CanWriteField "releaseCount" + VkWin32KeyedMutexAcquireReleaseInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkReleaseCount + +instance {-# OVERLAPPING #-} + HasVkPReleaseSyncs VkWin32KeyedMutexAcquireReleaseInfoKHR where + type VkPReleaseSyncsMType VkWin32KeyedMutexAcquireReleaseInfoKHR = + Ptr VkDeviceMemory + + {-# NOINLINE vkPReleaseSyncs #-} + vkPReleaseSyncs x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkWin32KeyedMutexAcquireReleaseInfoKHR, pReleaseSyncs}) + + {-# INLINE vkPReleaseSyncsByteOffset #-} + vkPReleaseSyncsByteOffset ~_ + = #{offset VkWin32KeyedMutexAcquireReleaseInfoKHR, pReleaseSyncs} + + {-# INLINE readVkPReleaseSyncs #-} + readVkPReleaseSyncs p + = peekByteOff p #{offset VkWin32KeyedMutexAcquireReleaseInfoKHR, pReleaseSyncs} + + {-# INLINE writeVkPReleaseSyncs #-} + writeVkPReleaseSyncs p + = pokeByteOff p #{offset VkWin32KeyedMutexAcquireReleaseInfoKHR, pReleaseSyncs} + +instance {-# OVERLAPPING #-} + HasField "pReleaseSyncs" VkWin32KeyedMutexAcquireReleaseInfoKHR + where + type FieldType "pReleaseSyncs" + VkWin32KeyedMutexAcquireReleaseInfoKHR + = Ptr VkDeviceMemory + type FieldOptional "pReleaseSyncs" + VkWin32KeyedMutexAcquireReleaseInfoKHR + = 'False -- ' closing tick for hsc2hs + type FieldOffset "pReleaseSyncs" + VkWin32KeyedMutexAcquireReleaseInfoKHR + = + #{offset VkWin32KeyedMutexAcquireReleaseInfoKHR, pReleaseSyncs} + type FieldIsArray "pReleaseSyncs" + VkWin32KeyedMutexAcquireReleaseInfoKHR + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkWin32KeyedMutexAcquireReleaseInfoKHR, pReleaseSyncs} + +instance CanReadField "pReleaseSyncs" + VkWin32KeyedMutexAcquireReleaseInfoKHR + where + {-# INLINE getField #-} + getField = vkPReleaseSyncs + + {-# INLINE readField #-} + readField = readVkPReleaseSyncs + +instance CanWriteField "pReleaseSyncs" + VkWin32KeyedMutexAcquireReleaseInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkPReleaseSyncs + +instance {-# OVERLAPPING #-} + HasVkPReleaseKeys VkWin32KeyedMutexAcquireReleaseInfoKHR where + type VkPReleaseKeysMType VkWin32KeyedMutexAcquireReleaseInfoKHR = + Ptr Word64 + + {-# NOINLINE vkPReleaseKeys #-} + vkPReleaseKeys x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkWin32KeyedMutexAcquireReleaseInfoKHR, pReleaseKeys}) + + {-# INLINE vkPReleaseKeysByteOffset #-} + vkPReleaseKeysByteOffset ~_ + = #{offset VkWin32KeyedMutexAcquireReleaseInfoKHR, pReleaseKeys} + + {-# INLINE readVkPReleaseKeys #-} + readVkPReleaseKeys p + = peekByteOff p #{offset VkWin32KeyedMutexAcquireReleaseInfoKHR, pReleaseKeys} + + {-# INLINE writeVkPReleaseKeys #-} + writeVkPReleaseKeys p + = pokeByteOff p #{offset VkWin32KeyedMutexAcquireReleaseInfoKHR, pReleaseKeys} + +instance {-# OVERLAPPING #-} + HasField "pReleaseKeys" VkWin32KeyedMutexAcquireReleaseInfoKHR + where + type FieldType "pReleaseKeys" + VkWin32KeyedMutexAcquireReleaseInfoKHR + = Ptr Word64 + type FieldOptional "pReleaseKeys" + VkWin32KeyedMutexAcquireReleaseInfoKHR + = 'False -- ' closing tick for hsc2hs + type FieldOffset "pReleaseKeys" + VkWin32KeyedMutexAcquireReleaseInfoKHR + = + #{offset VkWin32KeyedMutexAcquireReleaseInfoKHR, pReleaseKeys} + type FieldIsArray "pReleaseKeys" + VkWin32KeyedMutexAcquireReleaseInfoKHR + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkWin32KeyedMutexAcquireReleaseInfoKHR, pReleaseKeys} + +instance CanReadField "pReleaseKeys" + VkWin32KeyedMutexAcquireReleaseInfoKHR + where + {-# INLINE getField #-} + getField = vkPReleaseKeys + + {-# INLINE readField #-} + readField = readVkPReleaseKeys + +instance CanWriteField "pReleaseKeys" + VkWin32KeyedMutexAcquireReleaseInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkPReleaseKeys + +instance Show VkWin32KeyedMutexAcquireReleaseInfoKHR where + showsPrec d x + = showString "VkWin32KeyedMutexAcquireReleaseInfoKHR {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkAcquireCount = " . + showsPrec d (vkAcquireCount x) . + showString ", " . + showString "vkPAcquireSyncs = " . + showsPrec d (vkPAcquireSyncs x) . + showString ", " . + showString "vkPAcquireKeys = " . + showsPrec d (vkPAcquireKeys x) . + showString ", " . + showString "vkPAcquireTimeouts = " . + showsPrec d (vkPAcquireTimeouts x) . + showString ", " . + showString "vkReleaseCount = " . + showsPrec d (vkReleaseCount x) . + showString ", " . + showString "vkPReleaseSyncs = " . + showsPrec d (vkPReleaseSyncs x) . + showString ", " . + showString "vkPReleaseKeys = " . + showsPrec d (vkPReleaseKeys x) . + showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkWin32KeyedMutexAcquireReleaseInfoNV.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkWin32KeyedMutexAcquireReleaseInfoNV.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkWin32KeyedMutexAcquireReleaseInfoNV.hsc @@ -0,0 +1,651 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkWin32KeyedMutexAcquireReleaseInfoNV + (VkWin32KeyedMutexAcquireReleaseInfoNV(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Handles (VkDeviceMemory) +import Graphics.Vulkan.Types.Struct.VkSubmitInfo (VkSubmitInfo) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkWin32KeyedMutexAcquireReleaseInfoNV { +-- > VkStructureType sType; +-- > const void* pNext; +-- > uint32_t acquireCount; +-- > const VkDeviceMemory* pAcquireSyncs; +-- > const uint64_t* pAcquireKeys; +-- > const uint32_t* pAcquireTimeoutMilliseconds; +-- > uint32_t releaseCount; +-- > const VkDeviceMemory* pReleaseSyncs; +-- > const uint64_t* pReleaseKeys; +-- > } VkWin32KeyedMutexAcquireReleaseInfoNV; +-- +-- +data VkWin32KeyedMutexAcquireReleaseInfoNV = VkWin32KeyedMutexAcquireReleaseInfoNV## Addr## + ByteArray## + +instance Eq VkWin32KeyedMutexAcquireReleaseInfoNV where + (VkWin32KeyedMutexAcquireReleaseInfoNV## a _) == + x@(VkWin32KeyedMutexAcquireReleaseInfoNV## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkWin32KeyedMutexAcquireReleaseInfoNV where + (VkWin32KeyedMutexAcquireReleaseInfoNV## a _) `compare` + x@(VkWin32KeyedMutexAcquireReleaseInfoNV## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkWin32KeyedMutexAcquireReleaseInfoNV where + sizeOf ~_ + = #{size VkWin32KeyedMutexAcquireReleaseInfoNV} + + {-# INLINE sizeOf #-} + alignment ~_ + = #{alignment VkWin32KeyedMutexAcquireReleaseInfoNV} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkWin32KeyedMutexAcquireReleaseInfoNV + where + unsafeAddr (VkWin32KeyedMutexAcquireReleaseInfoNV## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkWin32KeyedMutexAcquireReleaseInfoNV## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkWin32KeyedMutexAcquireReleaseInfoNV## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkWin32KeyedMutexAcquireReleaseInfoNV where + type StructFields VkWin32KeyedMutexAcquireReleaseInfoNV = + '["sType", "pNext", "acquireCount", "pAcquireSyncs", -- ' closing tick for hsc2hs + "pAcquireKeys", "pAcquireTimeoutMilliseconds", "releaseCount", + "pReleaseSyncs", "pReleaseKeys"] + type CUnionType VkWin32KeyedMutexAcquireReleaseInfoNV = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkWin32KeyedMutexAcquireReleaseInfoNV = 'False -- ' closing tick for hsc2hs + type StructExtends VkWin32KeyedMutexAcquireReleaseInfoNV = + '[VkSubmitInfo] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} + HasVkSType VkWin32KeyedMutexAcquireReleaseInfoNV where + type VkSTypeMType VkWin32KeyedMutexAcquireReleaseInfoNV = + VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkWin32KeyedMutexAcquireReleaseInfoNV, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkWin32KeyedMutexAcquireReleaseInfoNV, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkWin32KeyedMutexAcquireReleaseInfoNV, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkWin32KeyedMutexAcquireReleaseInfoNV, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkWin32KeyedMutexAcquireReleaseInfoNV where + type FieldType "sType" VkWin32KeyedMutexAcquireReleaseInfoNV = + VkStructureType + type FieldOptional "sType" VkWin32KeyedMutexAcquireReleaseInfoNV = + 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkWin32KeyedMutexAcquireReleaseInfoNV = + #{offset VkWin32KeyedMutexAcquireReleaseInfoNV, sType} + type FieldIsArray "sType" VkWin32KeyedMutexAcquireReleaseInfoNV = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkWin32KeyedMutexAcquireReleaseInfoNV, sType} + +instance CanReadField "sType" VkWin32KeyedMutexAcquireReleaseInfoNV + where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" + VkWin32KeyedMutexAcquireReleaseInfoNV + where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} + HasVkPNext VkWin32KeyedMutexAcquireReleaseInfoNV where + type VkPNextMType VkWin32KeyedMutexAcquireReleaseInfoNV = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkWin32KeyedMutexAcquireReleaseInfoNV, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkWin32KeyedMutexAcquireReleaseInfoNV, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkWin32KeyedMutexAcquireReleaseInfoNV, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkWin32KeyedMutexAcquireReleaseInfoNV, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkWin32KeyedMutexAcquireReleaseInfoNV where + type FieldType "pNext" VkWin32KeyedMutexAcquireReleaseInfoNV = + Ptr Void + type FieldOptional "pNext" VkWin32KeyedMutexAcquireReleaseInfoNV = + 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkWin32KeyedMutexAcquireReleaseInfoNV = + #{offset VkWin32KeyedMutexAcquireReleaseInfoNV, pNext} + type FieldIsArray "pNext" VkWin32KeyedMutexAcquireReleaseInfoNV = + 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkWin32KeyedMutexAcquireReleaseInfoNV, pNext} + +instance CanReadField "pNext" VkWin32KeyedMutexAcquireReleaseInfoNV + where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" + VkWin32KeyedMutexAcquireReleaseInfoNV + where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} + HasVkAcquireCount VkWin32KeyedMutexAcquireReleaseInfoNV where + type VkAcquireCountMType VkWin32KeyedMutexAcquireReleaseInfoNV = + Word32 + + {-# NOINLINE vkAcquireCount #-} + vkAcquireCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkWin32KeyedMutexAcquireReleaseInfoNV, acquireCount}) + + {-# INLINE vkAcquireCountByteOffset #-} + vkAcquireCountByteOffset ~_ + = #{offset VkWin32KeyedMutexAcquireReleaseInfoNV, acquireCount} + + {-# INLINE readVkAcquireCount #-} + readVkAcquireCount p + = peekByteOff p #{offset VkWin32KeyedMutexAcquireReleaseInfoNV, acquireCount} + + {-# INLINE writeVkAcquireCount #-} + writeVkAcquireCount p + = pokeByteOff p #{offset VkWin32KeyedMutexAcquireReleaseInfoNV, acquireCount} + +instance {-# OVERLAPPING #-} + HasField "acquireCount" VkWin32KeyedMutexAcquireReleaseInfoNV where + type FieldType "acquireCount" VkWin32KeyedMutexAcquireReleaseInfoNV + = Word32 + type FieldOptional "acquireCount" + VkWin32KeyedMutexAcquireReleaseInfoNV + = 'True -- ' closing tick for hsc2hs + type FieldOffset "acquireCount" + VkWin32KeyedMutexAcquireReleaseInfoNV + = + #{offset VkWin32KeyedMutexAcquireReleaseInfoNV, acquireCount} + type FieldIsArray "acquireCount" + VkWin32KeyedMutexAcquireReleaseInfoNV + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkWin32KeyedMutexAcquireReleaseInfoNV, acquireCount} + +instance CanReadField "acquireCount" + VkWin32KeyedMutexAcquireReleaseInfoNV + where + {-# INLINE getField #-} + getField = vkAcquireCount + + {-# INLINE readField #-} + readField = readVkAcquireCount + +instance CanWriteField "acquireCount" + VkWin32KeyedMutexAcquireReleaseInfoNV + where + {-# INLINE writeField #-} + writeField = writeVkAcquireCount + +instance {-# OVERLAPPING #-} + HasVkPAcquireSyncs VkWin32KeyedMutexAcquireReleaseInfoNV where + type VkPAcquireSyncsMType VkWin32KeyedMutexAcquireReleaseInfoNV = + Ptr VkDeviceMemory + + {-# NOINLINE vkPAcquireSyncs #-} + vkPAcquireSyncs x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkWin32KeyedMutexAcquireReleaseInfoNV, pAcquireSyncs}) + + {-# INLINE vkPAcquireSyncsByteOffset #-} + vkPAcquireSyncsByteOffset ~_ + = #{offset VkWin32KeyedMutexAcquireReleaseInfoNV, pAcquireSyncs} + + {-# INLINE readVkPAcquireSyncs #-} + readVkPAcquireSyncs p + = peekByteOff p #{offset VkWin32KeyedMutexAcquireReleaseInfoNV, pAcquireSyncs} + + {-# INLINE writeVkPAcquireSyncs #-} + writeVkPAcquireSyncs p + = pokeByteOff p #{offset VkWin32KeyedMutexAcquireReleaseInfoNV, pAcquireSyncs} + +instance {-# OVERLAPPING #-} + HasField "pAcquireSyncs" VkWin32KeyedMutexAcquireReleaseInfoNV + where + type FieldType "pAcquireSyncs" + VkWin32KeyedMutexAcquireReleaseInfoNV + = Ptr VkDeviceMemory + type FieldOptional "pAcquireSyncs" + VkWin32KeyedMutexAcquireReleaseInfoNV + = 'False -- ' closing tick for hsc2hs + type FieldOffset "pAcquireSyncs" + VkWin32KeyedMutexAcquireReleaseInfoNV + = + #{offset VkWin32KeyedMutexAcquireReleaseInfoNV, pAcquireSyncs} + type FieldIsArray "pAcquireSyncs" + VkWin32KeyedMutexAcquireReleaseInfoNV + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkWin32KeyedMutexAcquireReleaseInfoNV, pAcquireSyncs} + +instance CanReadField "pAcquireSyncs" + VkWin32KeyedMutexAcquireReleaseInfoNV + where + {-# INLINE getField #-} + getField = vkPAcquireSyncs + + {-# INLINE readField #-} + readField = readVkPAcquireSyncs + +instance CanWriteField "pAcquireSyncs" + VkWin32KeyedMutexAcquireReleaseInfoNV + where + {-# INLINE writeField #-} + writeField = writeVkPAcquireSyncs + +instance {-# OVERLAPPING #-} + HasVkPAcquireKeys VkWin32KeyedMutexAcquireReleaseInfoNV where + type VkPAcquireKeysMType VkWin32KeyedMutexAcquireReleaseInfoNV = + Ptr Word64 + + {-# NOINLINE vkPAcquireKeys #-} + vkPAcquireKeys x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkWin32KeyedMutexAcquireReleaseInfoNV, pAcquireKeys}) + + {-# INLINE vkPAcquireKeysByteOffset #-} + vkPAcquireKeysByteOffset ~_ + = #{offset VkWin32KeyedMutexAcquireReleaseInfoNV, pAcquireKeys} + + {-# INLINE readVkPAcquireKeys #-} + readVkPAcquireKeys p + = peekByteOff p #{offset VkWin32KeyedMutexAcquireReleaseInfoNV, pAcquireKeys} + + {-# INLINE writeVkPAcquireKeys #-} + writeVkPAcquireKeys p + = pokeByteOff p #{offset VkWin32KeyedMutexAcquireReleaseInfoNV, pAcquireKeys} + +instance {-# OVERLAPPING #-} + HasField "pAcquireKeys" VkWin32KeyedMutexAcquireReleaseInfoNV where + type FieldType "pAcquireKeys" VkWin32KeyedMutexAcquireReleaseInfoNV + = Ptr Word64 + type FieldOptional "pAcquireKeys" + VkWin32KeyedMutexAcquireReleaseInfoNV + = 'False -- ' closing tick for hsc2hs + type FieldOffset "pAcquireKeys" + VkWin32KeyedMutexAcquireReleaseInfoNV + = + #{offset VkWin32KeyedMutexAcquireReleaseInfoNV, pAcquireKeys} + type FieldIsArray "pAcquireKeys" + VkWin32KeyedMutexAcquireReleaseInfoNV + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkWin32KeyedMutexAcquireReleaseInfoNV, pAcquireKeys} + +instance CanReadField "pAcquireKeys" + VkWin32KeyedMutexAcquireReleaseInfoNV + where + {-# INLINE getField #-} + getField = vkPAcquireKeys + + {-# INLINE readField #-} + readField = readVkPAcquireKeys + +instance CanWriteField "pAcquireKeys" + VkWin32KeyedMutexAcquireReleaseInfoNV + where + {-# INLINE writeField #-} + writeField = writeVkPAcquireKeys + +instance {-# OVERLAPPING #-} + HasVkPAcquireTimeoutMilliseconds + VkWin32KeyedMutexAcquireReleaseInfoNV + where + type VkPAcquireTimeoutMillisecondsMType + VkWin32KeyedMutexAcquireReleaseInfoNV + = Ptr Word32 + + {-# NOINLINE vkPAcquireTimeoutMilliseconds #-} + vkPAcquireTimeoutMilliseconds x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkWin32KeyedMutexAcquireReleaseInfoNV, pAcquireTimeoutMilliseconds}) + + {-# INLINE vkPAcquireTimeoutMillisecondsByteOffset #-} + vkPAcquireTimeoutMillisecondsByteOffset ~_ + = #{offset VkWin32KeyedMutexAcquireReleaseInfoNV, pAcquireTimeoutMilliseconds} + + {-# INLINE readVkPAcquireTimeoutMilliseconds #-} + readVkPAcquireTimeoutMilliseconds p + = peekByteOff p #{offset VkWin32KeyedMutexAcquireReleaseInfoNV, pAcquireTimeoutMilliseconds} + + {-# INLINE writeVkPAcquireTimeoutMilliseconds #-} + writeVkPAcquireTimeoutMilliseconds p + = pokeByteOff p #{offset VkWin32KeyedMutexAcquireReleaseInfoNV, pAcquireTimeoutMilliseconds} + +instance {-# OVERLAPPING #-} + HasField "pAcquireTimeoutMilliseconds" + VkWin32KeyedMutexAcquireReleaseInfoNV + where + type FieldType "pAcquireTimeoutMilliseconds" + VkWin32KeyedMutexAcquireReleaseInfoNV + = Ptr Word32 + type FieldOptional "pAcquireTimeoutMilliseconds" + VkWin32KeyedMutexAcquireReleaseInfoNV + = 'False -- ' closing tick for hsc2hs + type FieldOffset "pAcquireTimeoutMilliseconds" + VkWin32KeyedMutexAcquireReleaseInfoNV + = + #{offset VkWin32KeyedMutexAcquireReleaseInfoNV, pAcquireTimeoutMilliseconds} + type FieldIsArray "pAcquireTimeoutMilliseconds" + VkWin32KeyedMutexAcquireReleaseInfoNV + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkWin32KeyedMutexAcquireReleaseInfoNV, pAcquireTimeoutMilliseconds} + +instance CanReadField "pAcquireTimeoutMilliseconds" + VkWin32KeyedMutexAcquireReleaseInfoNV + where + {-# INLINE getField #-} + getField = vkPAcquireTimeoutMilliseconds + + {-# INLINE readField #-} + readField = readVkPAcquireTimeoutMilliseconds + +instance CanWriteField "pAcquireTimeoutMilliseconds" + VkWin32KeyedMutexAcquireReleaseInfoNV + where + {-# INLINE writeField #-} + writeField = writeVkPAcquireTimeoutMilliseconds + +instance {-# OVERLAPPING #-} + HasVkReleaseCount VkWin32KeyedMutexAcquireReleaseInfoNV where + type VkReleaseCountMType VkWin32KeyedMutexAcquireReleaseInfoNV = + Word32 + + {-# NOINLINE vkReleaseCount #-} + vkReleaseCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkWin32KeyedMutexAcquireReleaseInfoNV, releaseCount}) + + {-# INLINE vkReleaseCountByteOffset #-} + vkReleaseCountByteOffset ~_ + = #{offset VkWin32KeyedMutexAcquireReleaseInfoNV, releaseCount} + + {-# INLINE readVkReleaseCount #-} + readVkReleaseCount p + = peekByteOff p #{offset VkWin32KeyedMutexAcquireReleaseInfoNV, releaseCount} + + {-# INLINE writeVkReleaseCount #-} + writeVkReleaseCount p + = pokeByteOff p #{offset VkWin32KeyedMutexAcquireReleaseInfoNV, releaseCount} + +instance {-# OVERLAPPING #-} + HasField "releaseCount" VkWin32KeyedMutexAcquireReleaseInfoNV where + type FieldType "releaseCount" VkWin32KeyedMutexAcquireReleaseInfoNV + = Word32 + type FieldOptional "releaseCount" + VkWin32KeyedMutexAcquireReleaseInfoNV + = 'True -- ' closing tick for hsc2hs + type FieldOffset "releaseCount" + VkWin32KeyedMutexAcquireReleaseInfoNV + = + #{offset VkWin32KeyedMutexAcquireReleaseInfoNV, releaseCount} + type FieldIsArray "releaseCount" + VkWin32KeyedMutexAcquireReleaseInfoNV + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkWin32KeyedMutexAcquireReleaseInfoNV, releaseCount} + +instance CanReadField "releaseCount" + VkWin32KeyedMutexAcquireReleaseInfoNV + where + {-# INLINE getField #-} + getField = vkReleaseCount + + {-# INLINE readField #-} + readField = readVkReleaseCount + +instance CanWriteField "releaseCount" + VkWin32KeyedMutexAcquireReleaseInfoNV + where + {-# INLINE writeField #-} + writeField = writeVkReleaseCount + +instance {-# OVERLAPPING #-} + HasVkPReleaseSyncs VkWin32KeyedMutexAcquireReleaseInfoNV where + type VkPReleaseSyncsMType VkWin32KeyedMutexAcquireReleaseInfoNV = + Ptr VkDeviceMemory + + {-# NOINLINE vkPReleaseSyncs #-} + vkPReleaseSyncs x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkWin32KeyedMutexAcquireReleaseInfoNV, pReleaseSyncs}) + + {-# INLINE vkPReleaseSyncsByteOffset #-} + vkPReleaseSyncsByteOffset ~_ + = #{offset VkWin32KeyedMutexAcquireReleaseInfoNV, pReleaseSyncs} + + {-# INLINE readVkPReleaseSyncs #-} + readVkPReleaseSyncs p + = peekByteOff p #{offset VkWin32KeyedMutexAcquireReleaseInfoNV, pReleaseSyncs} + + {-# INLINE writeVkPReleaseSyncs #-} + writeVkPReleaseSyncs p + = pokeByteOff p #{offset VkWin32KeyedMutexAcquireReleaseInfoNV, pReleaseSyncs} + +instance {-# OVERLAPPING #-} + HasField "pReleaseSyncs" VkWin32KeyedMutexAcquireReleaseInfoNV + where + type FieldType "pReleaseSyncs" + VkWin32KeyedMutexAcquireReleaseInfoNV + = Ptr VkDeviceMemory + type FieldOptional "pReleaseSyncs" + VkWin32KeyedMutexAcquireReleaseInfoNV + = 'False -- ' closing tick for hsc2hs + type FieldOffset "pReleaseSyncs" + VkWin32KeyedMutexAcquireReleaseInfoNV + = + #{offset VkWin32KeyedMutexAcquireReleaseInfoNV, pReleaseSyncs} + type FieldIsArray "pReleaseSyncs" + VkWin32KeyedMutexAcquireReleaseInfoNV + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkWin32KeyedMutexAcquireReleaseInfoNV, pReleaseSyncs} + +instance CanReadField "pReleaseSyncs" + VkWin32KeyedMutexAcquireReleaseInfoNV + where + {-# INLINE getField #-} + getField = vkPReleaseSyncs + + {-# INLINE readField #-} + readField = readVkPReleaseSyncs + +instance CanWriteField "pReleaseSyncs" + VkWin32KeyedMutexAcquireReleaseInfoNV + where + {-# INLINE writeField #-} + writeField = writeVkPReleaseSyncs + +instance {-# OVERLAPPING #-} + HasVkPReleaseKeys VkWin32KeyedMutexAcquireReleaseInfoNV where + type VkPReleaseKeysMType VkWin32KeyedMutexAcquireReleaseInfoNV = + Ptr Word64 + + {-# NOINLINE vkPReleaseKeys #-} + vkPReleaseKeys x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkWin32KeyedMutexAcquireReleaseInfoNV, pReleaseKeys}) + + {-# INLINE vkPReleaseKeysByteOffset #-} + vkPReleaseKeysByteOffset ~_ + = #{offset VkWin32KeyedMutexAcquireReleaseInfoNV, pReleaseKeys} + + {-# INLINE readVkPReleaseKeys #-} + readVkPReleaseKeys p + = peekByteOff p #{offset VkWin32KeyedMutexAcquireReleaseInfoNV, pReleaseKeys} + + {-# INLINE writeVkPReleaseKeys #-} + writeVkPReleaseKeys p + = pokeByteOff p #{offset VkWin32KeyedMutexAcquireReleaseInfoNV, pReleaseKeys} + +instance {-# OVERLAPPING #-} + HasField "pReleaseKeys" VkWin32KeyedMutexAcquireReleaseInfoNV where + type FieldType "pReleaseKeys" VkWin32KeyedMutexAcquireReleaseInfoNV + = Ptr Word64 + type FieldOptional "pReleaseKeys" + VkWin32KeyedMutexAcquireReleaseInfoNV + = 'False -- ' closing tick for hsc2hs + type FieldOffset "pReleaseKeys" + VkWin32KeyedMutexAcquireReleaseInfoNV + = + #{offset VkWin32KeyedMutexAcquireReleaseInfoNV, pReleaseKeys} + type FieldIsArray "pReleaseKeys" + VkWin32KeyedMutexAcquireReleaseInfoNV + = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkWin32KeyedMutexAcquireReleaseInfoNV, pReleaseKeys} + +instance CanReadField "pReleaseKeys" + VkWin32KeyedMutexAcquireReleaseInfoNV + where + {-# INLINE getField #-} + getField = vkPReleaseKeys + + {-# INLINE readField #-} + readField = readVkPReleaseKeys + +instance CanWriteField "pReleaseKeys" + VkWin32KeyedMutexAcquireReleaseInfoNV + where + {-# INLINE writeField #-} + writeField = writeVkPReleaseKeys + +instance Show VkWin32KeyedMutexAcquireReleaseInfoNV where + showsPrec d x + = showString "VkWin32KeyedMutexAcquireReleaseInfoNV {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkAcquireCount = " . + showsPrec d (vkAcquireCount x) . + showString ", " . + showString "vkPAcquireSyncs = " . + showsPrec d (vkPAcquireSyncs x) . + showString ", " . + showString "vkPAcquireKeys = " . + showsPrec d (vkPAcquireKeys x) . + showString ", " . + showString "vkPAcquireTimeoutMilliseconds = " . + showsPrec d (vkPAcquireTimeoutMilliseconds x) . + showString ", " . + showString "vkReleaseCount = " . + showsPrec d (vkReleaseCount x) . + showString ", " . + showString "vkPReleaseSyncs = " . + showsPrec d (vkPReleaseSyncs x) . + showString ", " . + showString "vkPReleaseKeys = " . + showsPrec d (vkPReleaseKeys x) . + showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkWin32SurfaceCreateInfoKHR.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkWin32SurfaceCreateInfoKHR.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkWin32SurfaceCreateInfoKHR.hsc @@ -0,0 +1,335 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkWin32SurfaceCreateInfoKHR + (VkWin32SurfaceCreateInfoKHR(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Bitmasks (VkWin32SurfaceCreateFlagsKHR) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Include (HINSTANCE, HWND) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkWin32SurfaceCreateInfoKHR { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkWin32SurfaceCreateFlagsKHR flags; +-- > HINSTANCE hinstance; +-- > HWND hwnd; +-- > } VkWin32SurfaceCreateInfoKHR; +-- +-- +data VkWin32SurfaceCreateInfoKHR = VkWin32SurfaceCreateInfoKHR## Addr## + ByteArray## + +instance Eq VkWin32SurfaceCreateInfoKHR where + (VkWin32SurfaceCreateInfoKHR## a _) == + x@(VkWin32SurfaceCreateInfoKHR## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkWin32SurfaceCreateInfoKHR where + (VkWin32SurfaceCreateInfoKHR## a _) `compare` + x@(VkWin32SurfaceCreateInfoKHR## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkWin32SurfaceCreateInfoKHR where + sizeOf ~_ = #{size VkWin32SurfaceCreateInfoKHR} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkWin32SurfaceCreateInfoKHR} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkWin32SurfaceCreateInfoKHR where + unsafeAddr (VkWin32SurfaceCreateInfoKHR## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkWin32SurfaceCreateInfoKHR## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkWin32SurfaceCreateInfoKHR## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkWin32SurfaceCreateInfoKHR where + type StructFields VkWin32SurfaceCreateInfoKHR = + '["sType", "pNext", "flags", "hinstance", "hwnd"] -- ' closing tick for hsc2hs + type CUnionType VkWin32SurfaceCreateInfoKHR = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkWin32SurfaceCreateInfoKHR = 'False -- ' closing tick for hsc2hs + type StructExtends VkWin32SurfaceCreateInfoKHR = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkSType VkWin32SurfaceCreateInfoKHR + where + type VkSTypeMType VkWin32SurfaceCreateInfoKHR = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkWin32SurfaceCreateInfoKHR, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkWin32SurfaceCreateInfoKHR, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkWin32SurfaceCreateInfoKHR, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkWin32SurfaceCreateInfoKHR, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkWin32SurfaceCreateInfoKHR where + type FieldType "sType" VkWin32SurfaceCreateInfoKHR = + VkStructureType + type FieldOptional "sType" VkWin32SurfaceCreateInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkWin32SurfaceCreateInfoKHR = + #{offset VkWin32SurfaceCreateInfoKHR, sType} + type FieldIsArray "sType" VkWin32SurfaceCreateInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkWin32SurfaceCreateInfoKHR, sType} + +instance CanReadField "sType" VkWin32SurfaceCreateInfoKHR where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkWin32SurfaceCreateInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} HasVkPNext VkWin32SurfaceCreateInfoKHR + where + type VkPNextMType VkWin32SurfaceCreateInfoKHR = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkWin32SurfaceCreateInfoKHR, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkWin32SurfaceCreateInfoKHR, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkWin32SurfaceCreateInfoKHR, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkWin32SurfaceCreateInfoKHR, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkWin32SurfaceCreateInfoKHR where + type FieldType "pNext" VkWin32SurfaceCreateInfoKHR = Ptr Void + type FieldOptional "pNext" VkWin32SurfaceCreateInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkWin32SurfaceCreateInfoKHR = + #{offset VkWin32SurfaceCreateInfoKHR, pNext} + type FieldIsArray "pNext" VkWin32SurfaceCreateInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkWin32SurfaceCreateInfoKHR, pNext} + +instance CanReadField "pNext" VkWin32SurfaceCreateInfoKHR where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkWin32SurfaceCreateInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} HasVkFlags VkWin32SurfaceCreateInfoKHR + where + type VkFlagsMType VkWin32SurfaceCreateInfoKHR = + VkWin32SurfaceCreateFlagsKHR + + {-# NOINLINE vkFlags #-} + vkFlags x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkWin32SurfaceCreateInfoKHR, flags}) + + {-# INLINE vkFlagsByteOffset #-} + vkFlagsByteOffset ~_ + = #{offset VkWin32SurfaceCreateInfoKHR, flags} + + {-# INLINE readVkFlags #-} + readVkFlags p + = peekByteOff p #{offset VkWin32SurfaceCreateInfoKHR, flags} + + {-# INLINE writeVkFlags #-} + writeVkFlags p + = pokeByteOff p #{offset VkWin32SurfaceCreateInfoKHR, flags} + +instance {-# OVERLAPPING #-} + HasField "flags" VkWin32SurfaceCreateInfoKHR where + type FieldType "flags" VkWin32SurfaceCreateInfoKHR = + VkWin32SurfaceCreateFlagsKHR + type FieldOptional "flags" VkWin32SurfaceCreateInfoKHR = 'True -- ' closing tick for hsc2hs + type FieldOffset "flags" VkWin32SurfaceCreateInfoKHR = + #{offset VkWin32SurfaceCreateInfoKHR, flags} + type FieldIsArray "flags" VkWin32SurfaceCreateInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkWin32SurfaceCreateInfoKHR, flags} + +instance CanReadField "flags" VkWin32SurfaceCreateInfoKHR where + {-# INLINE getField #-} + getField = vkFlags + + {-# INLINE readField #-} + readField = readVkFlags + +instance CanWriteField "flags" VkWin32SurfaceCreateInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkFlags + +instance {-# OVERLAPPING #-} + HasVkHinstance VkWin32SurfaceCreateInfoKHR where + type VkHinstanceMType VkWin32SurfaceCreateInfoKHR = HINSTANCE + + {-# NOINLINE vkHinstance #-} + vkHinstance x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkWin32SurfaceCreateInfoKHR, hinstance}) + + {-# INLINE vkHinstanceByteOffset #-} + vkHinstanceByteOffset ~_ + = #{offset VkWin32SurfaceCreateInfoKHR, hinstance} + + {-# INLINE readVkHinstance #-} + readVkHinstance p + = peekByteOff p #{offset VkWin32SurfaceCreateInfoKHR, hinstance} + + {-# INLINE writeVkHinstance #-} + writeVkHinstance p + = pokeByteOff p #{offset VkWin32SurfaceCreateInfoKHR, hinstance} + +instance {-# OVERLAPPING #-} + HasField "hinstance" VkWin32SurfaceCreateInfoKHR where + type FieldType "hinstance" VkWin32SurfaceCreateInfoKHR = HINSTANCE + type FieldOptional "hinstance" VkWin32SurfaceCreateInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "hinstance" VkWin32SurfaceCreateInfoKHR = + #{offset VkWin32SurfaceCreateInfoKHR, hinstance} + type FieldIsArray "hinstance" VkWin32SurfaceCreateInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkWin32SurfaceCreateInfoKHR, hinstance} + +instance CanReadField "hinstance" VkWin32SurfaceCreateInfoKHR where + {-# INLINE getField #-} + getField = vkHinstance + + {-# INLINE readField #-} + readField = readVkHinstance + +instance CanWriteField "hinstance" VkWin32SurfaceCreateInfoKHR + where + {-# INLINE writeField #-} + writeField = writeVkHinstance + +instance {-# OVERLAPPING #-} HasVkHwnd VkWin32SurfaceCreateInfoKHR + where + type VkHwndMType VkWin32SurfaceCreateInfoKHR = HWND + + {-# NOINLINE vkHwnd #-} + vkHwnd x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkWin32SurfaceCreateInfoKHR, hwnd}) + + {-# INLINE vkHwndByteOffset #-} + vkHwndByteOffset ~_ + = #{offset VkWin32SurfaceCreateInfoKHR, hwnd} + + {-# INLINE readVkHwnd #-} + readVkHwnd p + = peekByteOff p #{offset VkWin32SurfaceCreateInfoKHR, hwnd} + + {-# INLINE writeVkHwnd #-} + writeVkHwnd p + = pokeByteOff p #{offset VkWin32SurfaceCreateInfoKHR, hwnd} + +instance {-# OVERLAPPING #-} + HasField "hwnd" VkWin32SurfaceCreateInfoKHR where + type FieldType "hwnd" VkWin32SurfaceCreateInfoKHR = HWND + type FieldOptional "hwnd" VkWin32SurfaceCreateInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "hwnd" VkWin32SurfaceCreateInfoKHR = + #{offset VkWin32SurfaceCreateInfoKHR, hwnd} + type FieldIsArray "hwnd" VkWin32SurfaceCreateInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkWin32SurfaceCreateInfoKHR, hwnd} + +instance CanReadField "hwnd" VkWin32SurfaceCreateInfoKHR where + {-# INLINE getField #-} + getField = vkHwnd + + {-# INLINE readField #-} + readField = readVkHwnd + +instance CanWriteField "hwnd" VkWin32SurfaceCreateInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkHwnd + +instance Show VkWin32SurfaceCreateInfoKHR where + showsPrec d x + = showString "VkWin32SurfaceCreateInfoKHR {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkFlags = " . + showsPrec d (vkFlags x) . + showString ", " . + showString "vkHinstance = " . + showsPrec d (vkHinstance x) . + showString ", " . + showString "vkHwnd = " . showsPrec d (vkHwnd x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkWriteDescriptorSet.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkWriteDescriptorSet.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkWriteDescriptorSet.hsc @@ -0,0 +1,594 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkWriteDescriptorSet + (VkWriteDescriptorSet(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Enum.VkDescriptorType (VkDescriptorType) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Handles (VkBufferView, + VkDescriptorSet) +import Graphics.Vulkan.Types.Struct.VkDescriptorBufferInfo (VkDescriptorBufferInfo) +import Graphics.Vulkan.Types.Struct.VkDescriptorImageInfo (VkDescriptorImageInfo) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkWriteDescriptorSet { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkDescriptorSet dstSet; +-- > uint32_t dstBinding; +-- > uint32_t dstArrayElement; +-- > uint32_t descriptorCount; +-- > VkDescriptorType descriptorType; +-- > const VkDescriptorImageInfo* pImageInfo; +-- > const VkDescriptorBufferInfo* pBufferInfo; +-- > const VkBufferView* pTexelBufferView; +-- > } VkWriteDescriptorSet; +-- +-- +data VkWriteDescriptorSet = VkWriteDescriptorSet## Addr## ByteArray## + +instance Eq VkWriteDescriptorSet where + (VkWriteDescriptorSet## a _) == x@(VkWriteDescriptorSet## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkWriteDescriptorSet where + (VkWriteDescriptorSet## a _) `compare` x@(VkWriteDescriptorSet## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkWriteDescriptorSet where + sizeOf ~_ = #{size VkWriteDescriptorSet} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkWriteDescriptorSet} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkWriteDescriptorSet where + unsafeAddr (VkWriteDescriptorSet## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkWriteDescriptorSet## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkWriteDescriptorSet## (plusAddr## (byteArrayContents## b) off) b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkWriteDescriptorSet where + type StructFields VkWriteDescriptorSet = + '["sType", "pNext", "dstSet", "dstBinding", "dstArrayElement", -- ' closing tick for hsc2hs + "descriptorCount", "descriptorType", "pImageInfo", "pBufferInfo", + "pTexelBufferView"] + type CUnionType VkWriteDescriptorSet = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkWriteDescriptorSet = 'False -- ' closing tick for hsc2hs + type StructExtends VkWriteDescriptorSet = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkSType VkWriteDescriptorSet where + type VkSTypeMType VkWriteDescriptorSet = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkWriteDescriptorSet, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkWriteDescriptorSet, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkWriteDescriptorSet, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkWriteDescriptorSet, sType} + +instance {-# OVERLAPPING #-} HasField "sType" VkWriteDescriptorSet + where + type FieldType "sType" VkWriteDescriptorSet = VkStructureType + type FieldOptional "sType" VkWriteDescriptorSet = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkWriteDescriptorSet = + #{offset VkWriteDescriptorSet, sType} + type FieldIsArray "sType" VkWriteDescriptorSet = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkWriteDescriptorSet, sType} + +instance CanReadField "sType" VkWriteDescriptorSet where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkWriteDescriptorSet where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} HasVkPNext VkWriteDescriptorSet where + type VkPNextMType VkWriteDescriptorSet = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkWriteDescriptorSet, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkWriteDescriptorSet, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkWriteDescriptorSet, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkWriteDescriptorSet, pNext} + +instance {-# OVERLAPPING #-} HasField "pNext" VkWriteDescriptorSet + where + type FieldType "pNext" VkWriteDescriptorSet = Ptr Void + type FieldOptional "pNext" VkWriteDescriptorSet = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkWriteDescriptorSet = + #{offset VkWriteDescriptorSet, pNext} + type FieldIsArray "pNext" VkWriteDescriptorSet = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkWriteDescriptorSet, pNext} + +instance CanReadField "pNext" VkWriteDescriptorSet where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkWriteDescriptorSet where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} HasVkDstSet VkWriteDescriptorSet where + type VkDstSetMType VkWriteDescriptorSet = VkDescriptorSet + + {-# NOINLINE vkDstSet #-} + vkDstSet x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkWriteDescriptorSet, dstSet}) + + {-# INLINE vkDstSetByteOffset #-} + vkDstSetByteOffset ~_ + = #{offset VkWriteDescriptorSet, dstSet} + + {-# INLINE readVkDstSet #-} + readVkDstSet p + = peekByteOff p #{offset VkWriteDescriptorSet, dstSet} + + {-# INLINE writeVkDstSet #-} + writeVkDstSet p + = pokeByteOff p #{offset VkWriteDescriptorSet, dstSet} + +instance {-# OVERLAPPING #-} HasField "dstSet" VkWriteDescriptorSet + where + type FieldType "dstSet" VkWriteDescriptorSet = VkDescriptorSet + type FieldOptional "dstSet" VkWriteDescriptorSet = 'False -- ' closing tick for hsc2hs + type FieldOffset "dstSet" VkWriteDescriptorSet = + #{offset VkWriteDescriptorSet, dstSet} + type FieldIsArray "dstSet" VkWriteDescriptorSet = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkWriteDescriptorSet, dstSet} + +instance CanReadField "dstSet" VkWriteDescriptorSet where + {-# INLINE getField #-} + getField = vkDstSet + + {-# INLINE readField #-} + readField = readVkDstSet + +instance CanWriteField "dstSet" VkWriteDescriptorSet where + {-# INLINE writeField #-} + writeField = writeVkDstSet + +instance {-# OVERLAPPING #-} HasVkDstBinding VkWriteDescriptorSet + where + type VkDstBindingMType VkWriteDescriptorSet = Word32 + + {-# NOINLINE vkDstBinding #-} + vkDstBinding x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkWriteDescriptorSet, dstBinding}) + + {-# INLINE vkDstBindingByteOffset #-} + vkDstBindingByteOffset ~_ + = #{offset VkWriteDescriptorSet, dstBinding} + + {-# INLINE readVkDstBinding #-} + readVkDstBinding p + = peekByteOff p #{offset VkWriteDescriptorSet, dstBinding} + + {-# INLINE writeVkDstBinding #-} + writeVkDstBinding p + = pokeByteOff p #{offset VkWriteDescriptorSet, dstBinding} + +instance {-# OVERLAPPING #-} + HasField "dstBinding" VkWriteDescriptorSet where + type FieldType "dstBinding" VkWriteDescriptorSet = Word32 + type FieldOptional "dstBinding" VkWriteDescriptorSet = 'False -- ' closing tick for hsc2hs + type FieldOffset "dstBinding" VkWriteDescriptorSet = + #{offset VkWriteDescriptorSet, dstBinding} + type FieldIsArray "dstBinding" VkWriteDescriptorSet = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkWriteDescriptorSet, dstBinding} + +instance CanReadField "dstBinding" VkWriteDescriptorSet where + {-# INLINE getField #-} + getField = vkDstBinding + + {-# INLINE readField #-} + readField = readVkDstBinding + +instance CanWriteField "dstBinding" VkWriteDescriptorSet where + {-# INLINE writeField #-} + writeField = writeVkDstBinding + +instance {-# OVERLAPPING #-} + HasVkDstArrayElement VkWriteDescriptorSet where + type VkDstArrayElementMType VkWriteDescriptorSet = Word32 + + {-# NOINLINE vkDstArrayElement #-} + vkDstArrayElement x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkWriteDescriptorSet, dstArrayElement}) + + {-# INLINE vkDstArrayElementByteOffset #-} + vkDstArrayElementByteOffset ~_ + = #{offset VkWriteDescriptorSet, dstArrayElement} + + {-# INLINE readVkDstArrayElement #-} + readVkDstArrayElement p + = peekByteOff p #{offset VkWriteDescriptorSet, dstArrayElement} + + {-# INLINE writeVkDstArrayElement #-} + writeVkDstArrayElement p + = pokeByteOff p #{offset VkWriteDescriptorSet, dstArrayElement} + +instance {-# OVERLAPPING #-} + HasField "dstArrayElement" VkWriteDescriptorSet where + type FieldType "dstArrayElement" VkWriteDescriptorSet = Word32 + type FieldOptional "dstArrayElement" VkWriteDescriptorSet = 'False -- ' closing tick for hsc2hs + type FieldOffset "dstArrayElement" VkWriteDescriptorSet = + #{offset VkWriteDescriptorSet, dstArrayElement} + type FieldIsArray "dstArrayElement" VkWriteDescriptorSet = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkWriteDescriptorSet, dstArrayElement} + +instance CanReadField "dstArrayElement" VkWriteDescriptorSet where + {-# INLINE getField #-} + getField = vkDstArrayElement + + {-# INLINE readField #-} + readField = readVkDstArrayElement + +instance CanWriteField "dstArrayElement" VkWriteDescriptorSet where + {-# INLINE writeField #-} + writeField = writeVkDstArrayElement + +instance {-# OVERLAPPING #-} + HasVkDescriptorCount VkWriteDescriptorSet where + type VkDescriptorCountMType VkWriteDescriptorSet = Word32 + + {-# NOINLINE vkDescriptorCount #-} + vkDescriptorCount x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkWriteDescriptorSet, descriptorCount}) + + {-# INLINE vkDescriptorCountByteOffset #-} + vkDescriptorCountByteOffset ~_ + = #{offset VkWriteDescriptorSet, descriptorCount} + + {-# INLINE readVkDescriptorCount #-} + readVkDescriptorCount p + = peekByteOff p #{offset VkWriteDescriptorSet, descriptorCount} + + {-# INLINE writeVkDescriptorCount #-} + writeVkDescriptorCount p + = pokeByteOff p #{offset VkWriteDescriptorSet, descriptorCount} + +instance {-# OVERLAPPING #-} + HasField "descriptorCount" VkWriteDescriptorSet where + type FieldType "descriptorCount" VkWriteDescriptorSet = Word32 + type FieldOptional "descriptorCount" VkWriteDescriptorSet = 'False -- ' closing tick for hsc2hs + type FieldOffset "descriptorCount" VkWriteDescriptorSet = + #{offset VkWriteDescriptorSet, descriptorCount} + type FieldIsArray "descriptorCount" VkWriteDescriptorSet = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkWriteDescriptorSet, descriptorCount} + +instance CanReadField "descriptorCount" VkWriteDescriptorSet where + {-# INLINE getField #-} + getField = vkDescriptorCount + + {-# INLINE readField #-} + readField = readVkDescriptorCount + +instance CanWriteField "descriptorCount" VkWriteDescriptorSet where + {-# INLINE writeField #-} + writeField = writeVkDescriptorCount + +instance {-# OVERLAPPING #-} + HasVkDescriptorType VkWriteDescriptorSet where + type VkDescriptorTypeMType VkWriteDescriptorSet = VkDescriptorType + + {-# NOINLINE vkDescriptorType #-} + vkDescriptorType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkWriteDescriptorSet, descriptorType}) + + {-# INLINE vkDescriptorTypeByteOffset #-} + vkDescriptorTypeByteOffset ~_ + = #{offset VkWriteDescriptorSet, descriptorType} + + {-# INLINE readVkDescriptorType #-} + readVkDescriptorType p + = peekByteOff p #{offset VkWriteDescriptorSet, descriptorType} + + {-# INLINE writeVkDescriptorType #-} + writeVkDescriptorType p + = pokeByteOff p #{offset VkWriteDescriptorSet, descriptorType} + +instance {-# OVERLAPPING #-} + HasField "descriptorType" VkWriteDescriptorSet where + type FieldType "descriptorType" VkWriteDescriptorSet = + VkDescriptorType + type FieldOptional "descriptorType" VkWriteDescriptorSet = 'False -- ' closing tick for hsc2hs + type FieldOffset "descriptorType" VkWriteDescriptorSet = + #{offset VkWriteDescriptorSet, descriptorType} + type FieldIsArray "descriptorType" VkWriteDescriptorSet = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkWriteDescriptorSet, descriptorType} + +instance CanReadField "descriptorType" VkWriteDescriptorSet where + {-# INLINE getField #-} + getField = vkDescriptorType + + {-# INLINE readField #-} + readField = readVkDescriptorType + +instance CanWriteField "descriptorType" VkWriteDescriptorSet where + {-# INLINE writeField #-} + writeField = writeVkDescriptorType + +instance {-# OVERLAPPING #-} HasVkPImageInfo VkWriteDescriptorSet + where + type VkPImageInfoMType VkWriteDescriptorSet = + Ptr VkDescriptorImageInfo + + {-# NOINLINE vkPImageInfo #-} + vkPImageInfo x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkWriteDescriptorSet, pImageInfo}) + + {-# INLINE vkPImageInfoByteOffset #-} + vkPImageInfoByteOffset ~_ + = #{offset VkWriteDescriptorSet, pImageInfo} + + {-# INLINE readVkPImageInfo #-} + readVkPImageInfo p + = peekByteOff p #{offset VkWriteDescriptorSet, pImageInfo} + + {-# INLINE writeVkPImageInfo #-} + writeVkPImageInfo p + = pokeByteOff p #{offset VkWriteDescriptorSet, pImageInfo} + +instance {-# OVERLAPPING #-} + HasField "pImageInfo" VkWriteDescriptorSet where + type FieldType "pImageInfo" VkWriteDescriptorSet = + Ptr VkDescriptorImageInfo + type FieldOptional "pImageInfo" VkWriteDescriptorSet = 'False -- ' closing tick for hsc2hs + type FieldOffset "pImageInfo" VkWriteDescriptorSet = + #{offset VkWriteDescriptorSet, pImageInfo} + type FieldIsArray "pImageInfo" VkWriteDescriptorSet = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkWriteDescriptorSet, pImageInfo} + +instance CanReadField "pImageInfo" VkWriteDescriptorSet where + {-# INLINE getField #-} + getField = vkPImageInfo + + {-# INLINE readField #-} + readField = readVkPImageInfo + +instance CanWriteField "pImageInfo" VkWriteDescriptorSet where + {-# INLINE writeField #-} + writeField = writeVkPImageInfo + +instance {-# OVERLAPPING #-} HasVkPBufferInfo VkWriteDescriptorSet + where + type VkPBufferInfoMType VkWriteDescriptorSet = + Ptr VkDescriptorBufferInfo + + {-# NOINLINE vkPBufferInfo #-} + vkPBufferInfo x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkWriteDescriptorSet, pBufferInfo}) + + {-# INLINE vkPBufferInfoByteOffset #-} + vkPBufferInfoByteOffset ~_ + = #{offset VkWriteDescriptorSet, pBufferInfo} + + {-# INLINE readVkPBufferInfo #-} + readVkPBufferInfo p + = peekByteOff p #{offset VkWriteDescriptorSet, pBufferInfo} + + {-# INLINE writeVkPBufferInfo #-} + writeVkPBufferInfo p + = pokeByteOff p #{offset VkWriteDescriptorSet, pBufferInfo} + +instance {-# OVERLAPPING #-} + HasField "pBufferInfo" VkWriteDescriptorSet where + type FieldType "pBufferInfo" VkWriteDescriptorSet = + Ptr VkDescriptorBufferInfo + type FieldOptional "pBufferInfo" VkWriteDescriptorSet = 'False -- ' closing tick for hsc2hs + type FieldOffset "pBufferInfo" VkWriteDescriptorSet = + #{offset VkWriteDescriptorSet, pBufferInfo} + type FieldIsArray "pBufferInfo" VkWriteDescriptorSet = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkWriteDescriptorSet, pBufferInfo} + +instance CanReadField "pBufferInfo" VkWriteDescriptorSet where + {-# INLINE getField #-} + getField = vkPBufferInfo + + {-# INLINE readField #-} + readField = readVkPBufferInfo + +instance CanWriteField "pBufferInfo" VkWriteDescriptorSet where + {-# INLINE writeField #-} + writeField = writeVkPBufferInfo + +instance {-# OVERLAPPING #-} + HasVkPTexelBufferView VkWriteDescriptorSet where + type VkPTexelBufferViewMType VkWriteDescriptorSet = + Ptr VkBufferView + + {-# NOINLINE vkPTexelBufferView #-} + vkPTexelBufferView x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkWriteDescriptorSet, pTexelBufferView}) + + {-# INLINE vkPTexelBufferViewByteOffset #-} + vkPTexelBufferViewByteOffset ~_ + = #{offset VkWriteDescriptorSet, pTexelBufferView} + + {-# INLINE readVkPTexelBufferView #-} + readVkPTexelBufferView p + = peekByteOff p #{offset VkWriteDescriptorSet, pTexelBufferView} + + {-# INLINE writeVkPTexelBufferView #-} + writeVkPTexelBufferView p + = pokeByteOff p #{offset VkWriteDescriptorSet, pTexelBufferView} + +instance {-# OVERLAPPING #-} + HasField "pTexelBufferView" VkWriteDescriptorSet where + type FieldType "pTexelBufferView" VkWriteDescriptorSet = + Ptr VkBufferView + type FieldOptional "pTexelBufferView" VkWriteDescriptorSet = 'False -- ' closing tick for hsc2hs + type FieldOffset "pTexelBufferView" VkWriteDescriptorSet = + #{offset VkWriteDescriptorSet, pTexelBufferView} + type FieldIsArray "pTexelBufferView" VkWriteDescriptorSet = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkWriteDescriptorSet, pTexelBufferView} + +instance CanReadField "pTexelBufferView" VkWriteDescriptorSet where + {-# INLINE getField #-} + getField = vkPTexelBufferView + + {-# INLINE readField #-} + readField = readVkPTexelBufferView + +instance CanWriteField "pTexelBufferView" VkWriteDescriptorSet + where + {-# INLINE writeField #-} + writeField = writeVkPTexelBufferView + +instance Show VkWriteDescriptorSet where + showsPrec d x + = showString "VkWriteDescriptorSet {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkDstSet = " . + showsPrec d (vkDstSet x) . + showString ", " . + showString "vkDstBinding = " . + showsPrec d (vkDstBinding x) . + showString ", " . + showString "vkDstArrayElement = " . + showsPrec d (vkDstArrayElement x) . + showString ", " . + showString "vkDescriptorCount = " . + showsPrec d (vkDescriptorCount x) . + showString ", " . + showString "vkDescriptorType = " . + showsPrec d (vkDescriptorType x) . + showString ", " . + showString "vkPImageInfo = " . + showsPrec d (vkPImageInfo x) . + showString ", " . + showString "vkPBufferInfo = " . + showsPrec d (vkPBufferInfo x) . + showString ", " . + showString + "vkPTexelBufferView = " + . + showsPrec d + (vkPTexelBufferView x) + . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkXYColorEXT.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkXYColorEXT.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkXYColorEXT.hsc @@ -0,0 +1,160 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkXYColorEXT (VkXYColorEXT(..)) + where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | Chromaticity coordinate +-- +-- > typedef struct VkXYColorEXT { +-- > float x; +-- > float y; +-- > } VkXYColorEXT; +-- +-- +data VkXYColorEXT = VkXYColorEXT## Addr## ByteArray## + +instance Eq VkXYColorEXT where + (VkXYColorEXT## a _) == x@(VkXYColorEXT## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkXYColorEXT where + (VkXYColorEXT## a _) `compare` x@(VkXYColorEXT## b _) + = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkXYColorEXT where + sizeOf ~_ = #{size VkXYColorEXT} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkXYColorEXT} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkXYColorEXT where + unsafeAddr (VkXYColorEXT## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkXYColorEXT## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkXYColorEXT## (plusAddr## (byteArrayContents## b) off) b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkXYColorEXT where + type StructFields VkXYColorEXT = '["x", "y"] -- ' closing tick for hsc2hs + type CUnionType VkXYColorEXT = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkXYColorEXT = 'False -- ' closing tick for hsc2hs + type StructExtends VkXYColorEXT = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkX VkXYColorEXT where + type VkXMType VkXYColorEXT = #{type float} + + {-# NOINLINE vkX #-} + vkX x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkXYColorEXT, x}) + + {-# INLINE vkXByteOffset #-} + vkXByteOffset ~_ = #{offset VkXYColorEXT, x} + + {-# INLINE readVkX #-} + readVkX p = peekByteOff p #{offset VkXYColorEXT, x} + + {-# INLINE writeVkX #-} + writeVkX p = pokeByteOff p #{offset VkXYColorEXT, x} + +instance {-# OVERLAPPING #-} HasField "x" VkXYColorEXT where + type FieldType "x" VkXYColorEXT = #{type float} + type FieldOptional "x" VkXYColorEXT = 'False -- ' closing tick for hsc2hs + type FieldOffset "x" VkXYColorEXT = + #{offset VkXYColorEXT, x} + type FieldIsArray "x" VkXYColorEXT = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkXYColorEXT, x} + +instance CanReadField "x" VkXYColorEXT where + {-# INLINE getField #-} + getField = vkX + + {-# INLINE readField #-} + readField = readVkX + +instance CanWriteField "x" VkXYColorEXT where + {-# INLINE writeField #-} + writeField = writeVkX + +instance {-# OVERLAPPING #-} HasVkY VkXYColorEXT where + type VkYMType VkXYColorEXT = #{type float} + + {-# NOINLINE vkY #-} + vkY x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkXYColorEXT, y}) + + {-# INLINE vkYByteOffset #-} + vkYByteOffset ~_ = #{offset VkXYColorEXT, y} + + {-# INLINE readVkY #-} + readVkY p = peekByteOff p #{offset VkXYColorEXT, y} + + {-# INLINE writeVkY #-} + writeVkY p = pokeByteOff p #{offset VkXYColorEXT, y} + +instance {-# OVERLAPPING #-} HasField "y" VkXYColorEXT where + type FieldType "y" VkXYColorEXT = #{type float} + type FieldOptional "y" VkXYColorEXT = 'False -- ' closing tick for hsc2hs + type FieldOffset "y" VkXYColorEXT = + #{offset VkXYColorEXT, y} + type FieldIsArray "y" VkXYColorEXT = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkXYColorEXT, y} + +instance CanReadField "y" VkXYColorEXT where + {-# INLINE getField #-} + getField = vkY + + {-# INLINE readField #-} + readField = readVkY + +instance CanWriteField "y" VkXYColorEXT where + {-# INLINE writeField #-} + writeField = writeVkY + +instance Show VkXYColorEXT where + showsPrec d x + = showString "VkXYColorEXT {" . + showString "vkX = " . + showsPrec d (vkX x) . + showString ", " . + showString "vkY = " . showsPrec d (vkY x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkXcbSurfaceCreateInfoKHR.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkXcbSurfaceCreateInfoKHR.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkXcbSurfaceCreateInfoKHR.hsc @@ -0,0 +1,335 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkXcbSurfaceCreateInfoKHR + (VkXcbSurfaceCreateInfoKHR(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Bitmasks (VkXcbSurfaceCreateFlagsKHR) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Include (XcbConnectionT, + XcbWindowT) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkXcbSurfaceCreateInfoKHR { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkXcbSurfaceCreateFlagsKHR flags; +-- > xcb_connection_t* connection; +-- > xcb_window_t window; +-- > } VkXcbSurfaceCreateInfoKHR; +-- +-- +data VkXcbSurfaceCreateInfoKHR = VkXcbSurfaceCreateInfoKHR## Addr## + ByteArray## + +instance Eq VkXcbSurfaceCreateInfoKHR where + (VkXcbSurfaceCreateInfoKHR## a _) == + x@(VkXcbSurfaceCreateInfoKHR## b _) = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkXcbSurfaceCreateInfoKHR where + (VkXcbSurfaceCreateInfoKHR## a _) `compare` + x@(VkXcbSurfaceCreateInfoKHR## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkXcbSurfaceCreateInfoKHR where + sizeOf ~_ = #{size VkXcbSurfaceCreateInfoKHR} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkXcbSurfaceCreateInfoKHR} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkXcbSurfaceCreateInfoKHR where + unsafeAddr (VkXcbSurfaceCreateInfoKHR## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkXcbSurfaceCreateInfoKHR## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkXcbSurfaceCreateInfoKHR## (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkXcbSurfaceCreateInfoKHR where + type StructFields VkXcbSurfaceCreateInfoKHR = + '["sType", "pNext", "flags", "connection", "window"] -- ' closing tick for hsc2hs + type CUnionType VkXcbSurfaceCreateInfoKHR = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkXcbSurfaceCreateInfoKHR = 'False -- ' closing tick for hsc2hs + type StructExtends VkXcbSurfaceCreateInfoKHR = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkSType VkXcbSurfaceCreateInfoKHR + where + type VkSTypeMType VkXcbSurfaceCreateInfoKHR = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkXcbSurfaceCreateInfoKHR, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkXcbSurfaceCreateInfoKHR, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkXcbSurfaceCreateInfoKHR, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkXcbSurfaceCreateInfoKHR, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkXcbSurfaceCreateInfoKHR where + type FieldType "sType" VkXcbSurfaceCreateInfoKHR = VkStructureType + type FieldOptional "sType" VkXcbSurfaceCreateInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkXcbSurfaceCreateInfoKHR = + #{offset VkXcbSurfaceCreateInfoKHR, sType} + type FieldIsArray "sType" VkXcbSurfaceCreateInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkXcbSurfaceCreateInfoKHR, sType} + +instance CanReadField "sType" VkXcbSurfaceCreateInfoKHR where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkXcbSurfaceCreateInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} HasVkPNext VkXcbSurfaceCreateInfoKHR + where + type VkPNextMType VkXcbSurfaceCreateInfoKHR = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkXcbSurfaceCreateInfoKHR, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkXcbSurfaceCreateInfoKHR, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkXcbSurfaceCreateInfoKHR, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkXcbSurfaceCreateInfoKHR, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkXcbSurfaceCreateInfoKHR where + type FieldType "pNext" VkXcbSurfaceCreateInfoKHR = Ptr Void + type FieldOptional "pNext" VkXcbSurfaceCreateInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkXcbSurfaceCreateInfoKHR = + #{offset VkXcbSurfaceCreateInfoKHR, pNext} + type FieldIsArray "pNext" VkXcbSurfaceCreateInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkXcbSurfaceCreateInfoKHR, pNext} + +instance CanReadField "pNext" VkXcbSurfaceCreateInfoKHR where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkXcbSurfaceCreateInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} HasVkFlags VkXcbSurfaceCreateInfoKHR + where + type VkFlagsMType VkXcbSurfaceCreateInfoKHR = + VkXcbSurfaceCreateFlagsKHR + + {-# NOINLINE vkFlags #-} + vkFlags x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkXcbSurfaceCreateInfoKHR, flags}) + + {-# INLINE vkFlagsByteOffset #-} + vkFlagsByteOffset ~_ + = #{offset VkXcbSurfaceCreateInfoKHR, flags} + + {-# INLINE readVkFlags #-} + readVkFlags p + = peekByteOff p #{offset VkXcbSurfaceCreateInfoKHR, flags} + + {-# INLINE writeVkFlags #-} + writeVkFlags p + = pokeByteOff p #{offset VkXcbSurfaceCreateInfoKHR, flags} + +instance {-# OVERLAPPING #-} + HasField "flags" VkXcbSurfaceCreateInfoKHR where + type FieldType "flags" VkXcbSurfaceCreateInfoKHR = + VkXcbSurfaceCreateFlagsKHR + type FieldOptional "flags" VkXcbSurfaceCreateInfoKHR = 'True -- ' closing tick for hsc2hs + type FieldOffset "flags" VkXcbSurfaceCreateInfoKHR = + #{offset VkXcbSurfaceCreateInfoKHR, flags} + type FieldIsArray "flags" VkXcbSurfaceCreateInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkXcbSurfaceCreateInfoKHR, flags} + +instance CanReadField "flags" VkXcbSurfaceCreateInfoKHR where + {-# INLINE getField #-} + getField = vkFlags + + {-# INLINE readField #-} + readField = readVkFlags + +instance CanWriteField "flags" VkXcbSurfaceCreateInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkFlags + +instance {-# OVERLAPPING #-} + HasVkConnection VkXcbSurfaceCreateInfoKHR where + type VkConnectionMType VkXcbSurfaceCreateInfoKHR = + Ptr XcbConnectionT + + {-# NOINLINE vkConnection #-} + vkConnection x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkXcbSurfaceCreateInfoKHR, connection}) + + {-# INLINE vkConnectionByteOffset #-} + vkConnectionByteOffset ~_ + = #{offset VkXcbSurfaceCreateInfoKHR, connection} + + {-# INLINE readVkConnection #-} + readVkConnection p + = peekByteOff p #{offset VkXcbSurfaceCreateInfoKHR, connection} + + {-# INLINE writeVkConnection #-} + writeVkConnection p + = pokeByteOff p #{offset VkXcbSurfaceCreateInfoKHR, connection} + +instance {-# OVERLAPPING #-} + HasField "connection" VkXcbSurfaceCreateInfoKHR where + type FieldType "connection" VkXcbSurfaceCreateInfoKHR = + Ptr XcbConnectionT + type FieldOptional "connection" VkXcbSurfaceCreateInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "connection" VkXcbSurfaceCreateInfoKHR = + #{offset VkXcbSurfaceCreateInfoKHR, connection} + type FieldIsArray "connection" VkXcbSurfaceCreateInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkXcbSurfaceCreateInfoKHR, connection} + +instance CanReadField "connection" VkXcbSurfaceCreateInfoKHR where + {-# INLINE getField #-} + getField = vkConnection + + {-# INLINE readField #-} + readField = readVkConnection + +instance CanWriteField "connection" VkXcbSurfaceCreateInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkConnection + +instance {-# OVERLAPPING #-} HasVkWindow VkXcbSurfaceCreateInfoKHR + where + type VkWindowMType VkXcbSurfaceCreateInfoKHR = XcbWindowT + + {-# NOINLINE vkWindow #-} + vkWindow x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkXcbSurfaceCreateInfoKHR, window}) + + {-# INLINE vkWindowByteOffset #-} + vkWindowByteOffset ~_ + = #{offset VkXcbSurfaceCreateInfoKHR, window} + + {-# INLINE readVkWindow #-} + readVkWindow p + = peekByteOff p #{offset VkXcbSurfaceCreateInfoKHR, window} + + {-# INLINE writeVkWindow #-} + writeVkWindow p + = pokeByteOff p #{offset VkXcbSurfaceCreateInfoKHR, window} + +instance {-# OVERLAPPING #-} + HasField "window" VkXcbSurfaceCreateInfoKHR where + type FieldType "window" VkXcbSurfaceCreateInfoKHR = XcbWindowT + type FieldOptional "window" VkXcbSurfaceCreateInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "window" VkXcbSurfaceCreateInfoKHR = + #{offset VkXcbSurfaceCreateInfoKHR, window} + type FieldIsArray "window" VkXcbSurfaceCreateInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkXcbSurfaceCreateInfoKHR, window} + +instance CanReadField "window" VkXcbSurfaceCreateInfoKHR where + {-# INLINE getField #-} + getField = vkWindow + + {-# INLINE readField #-} + readField = readVkWindow + +instance CanWriteField "window" VkXcbSurfaceCreateInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkWindow + +instance Show VkXcbSurfaceCreateInfoKHR where + showsPrec d x + = showString "VkXcbSurfaceCreateInfoKHR {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkFlags = " . + showsPrec d (vkFlags x) . + showString ", " . + showString "vkConnection = " . + showsPrec d (vkConnection x) . + showString ", " . + showString "vkWindow = " . + showsPrec d (vkWindow x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/Struct/VkXlibSurfaceCreateInfoKHR.hsc b/src-gen/Graphics/Vulkan/Types/Struct/VkXlibSurfaceCreateInfoKHR.hsc new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/Struct/VkXlibSurfaceCreateInfoKHR.hsc @@ -0,0 +1,333 @@ +#include "vulkan/vulkan.h" + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +module Graphics.Vulkan.Types.Struct.VkXlibSurfaceCreateInfoKHR + (VkXlibSurfaceCreateInfoKHR(..)) where +import Foreign.Storable (Storable (..)) +import GHC.Prim +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal +import Graphics.Vulkan.Types.Bitmasks (VkXlibSurfaceCreateFlagsKHR) +import Graphics.Vulkan.Types.Enum.VkStructureType (VkStructureType) +import Graphics.Vulkan.Types.Include (Display, Window) +import Graphics.Vulkan.Types.StructMembers +import System.IO.Unsafe (unsafeDupablePerformIO) + +-- | > typedef struct VkXlibSurfaceCreateInfoKHR { +-- > VkStructureType sType; +-- > const void* pNext; +-- > VkXlibSurfaceCreateFlagsKHR flags; +-- > Display* dpy; +-- > Window window; +-- > } VkXlibSurfaceCreateInfoKHR; +-- +-- +data VkXlibSurfaceCreateInfoKHR = VkXlibSurfaceCreateInfoKHR## Addr## + ByteArray## + +instance Eq VkXlibSurfaceCreateInfoKHR where + (VkXlibSurfaceCreateInfoKHR## a _) == + x@(VkXlibSurfaceCreateInfoKHR## b _) + = EQ == cmpBytes## (sizeOf x) a b + + {-# INLINE (==) #-} + +instance Ord VkXlibSurfaceCreateInfoKHR where + (VkXlibSurfaceCreateInfoKHR## a _) `compare` + x@(VkXlibSurfaceCreateInfoKHR## b _) = cmpBytes## (sizeOf x) a b + + {-# INLINE compare #-} + +instance Storable VkXlibSurfaceCreateInfoKHR where + sizeOf ~_ = #{size VkXlibSurfaceCreateInfoKHR} + + {-# INLINE sizeOf #-} + alignment ~_ = #{alignment VkXlibSurfaceCreateInfoKHR} + + {-# INLINE alignment #-} + peek = peekVkData## + + {-# INLINE peek #-} + poke = pokeVkData## + + {-# INLINE poke #-} + +instance VulkanMarshalPrim VkXlibSurfaceCreateInfoKHR where + unsafeAddr (VkXlibSurfaceCreateInfoKHR## a _) = a + + {-# INLINE unsafeAddr #-} + unsafeByteArray (VkXlibSurfaceCreateInfoKHR## _ b) = b + + {-# INLINE unsafeByteArray #-} + unsafeFromByteArrayOffset off b + = VkXlibSurfaceCreateInfoKHR## + (plusAddr## (byteArrayContents## b) off) + b + + {-# INLINE unsafeFromByteArrayOffset #-} + +instance VulkanMarshal VkXlibSurfaceCreateInfoKHR where + type StructFields VkXlibSurfaceCreateInfoKHR = + '["sType", "pNext", "flags", "dpy", "window"] -- ' closing tick for hsc2hs + type CUnionType VkXlibSurfaceCreateInfoKHR = 'False -- ' closing tick for hsc2hs + type ReturnedOnly VkXlibSurfaceCreateInfoKHR = 'False -- ' closing tick for hsc2hs + type StructExtends VkXlibSurfaceCreateInfoKHR = '[] -- ' closing tick for hsc2hs + +instance {-# OVERLAPPING #-} HasVkSType VkXlibSurfaceCreateInfoKHR + where + type VkSTypeMType VkXlibSurfaceCreateInfoKHR = VkStructureType + + {-# NOINLINE vkSType #-} + vkSType x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkXlibSurfaceCreateInfoKHR, sType}) + + {-# INLINE vkSTypeByteOffset #-} + vkSTypeByteOffset ~_ + = #{offset VkXlibSurfaceCreateInfoKHR, sType} + + {-# INLINE readVkSType #-} + readVkSType p + = peekByteOff p #{offset VkXlibSurfaceCreateInfoKHR, sType} + + {-# INLINE writeVkSType #-} + writeVkSType p + = pokeByteOff p #{offset VkXlibSurfaceCreateInfoKHR, sType} + +instance {-# OVERLAPPING #-} + HasField "sType" VkXlibSurfaceCreateInfoKHR where + type FieldType "sType" VkXlibSurfaceCreateInfoKHR = VkStructureType + type FieldOptional "sType" VkXlibSurfaceCreateInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "sType" VkXlibSurfaceCreateInfoKHR = + #{offset VkXlibSurfaceCreateInfoKHR, sType} + type FieldIsArray "sType" VkXlibSurfaceCreateInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkXlibSurfaceCreateInfoKHR, sType} + +instance CanReadField "sType" VkXlibSurfaceCreateInfoKHR where + {-# INLINE getField #-} + getField = vkSType + + {-# INLINE readField #-} + readField = readVkSType + +instance CanWriteField "sType" VkXlibSurfaceCreateInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkSType + +instance {-# OVERLAPPING #-} HasVkPNext VkXlibSurfaceCreateInfoKHR + where + type VkPNextMType VkXlibSurfaceCreateInfoKHR = Ptr Void + + {-# NOINLINE vkPNext #-} + vkPNext x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkXlibSurfaceCreateInfoKHR, pNext}) + + {-# INLINE vkPNextByteOffset #-} + vkPNextByteOffset ~_ + = #{offset VkXlibSurfaceCreateInfoKHR, pNext} + + {-# INLINE readVkPNext #-} + readVkPNext p + = peekByteOff p #{offset VkXlibSurfaceCreateInfoKHR, pNext} + + {-# INLINE writeVkPNext #-} + writeVkPNext p + = pokeByteOff p #{offset VkXlibSurfaceCreateInfoKHR, pNext} + +instance {-# OVERLAPPING #-} + HasField "pNext" VkXlibSurfaceCreateInfoKHR where + type FieldType "pNext" VkXlibSurfaceCreateInfoKHR = Ptr Void + type FieldOptional "pNext" VkXlibSurfaceCreateInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "pNext" VkXlibSurfaceCreateInfoKHR = + #{offset VkXlibSurfaceCreateInfoKHR, pNext} + type FieldIsArray "pNext" VkXlibSurfaceCreateInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkXlibSurfaceCreateInfoKHR, pNext} + +instance CanReadField "pNext" VkXlibSurfaceCreateInfoKHR where + {-# INLINE getField #-} + getField = vkPNext + + {-# INLINE readField #-} + readField = readVkPNext + +instance CanWriteField "pNext" VkXlibSurfaceCreateInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkPNext + +instance {-# OVERLAPPING #-} HasVkFlags VkXlibSurfaceCreateInfoKHR + where + type VkFlagsMType VkXlibSurfaceCreateInfoKHR = + VkXlibSurfaceCreateFlagsKHR + + {-# NOINLINE vkFlags #-} + vkFlags x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkXlibSurfaceCreateInfoKHR, flags}) + + {-# INLINE vkFlagsByteOffset #-} + vkFlagsByteOffset ~_ + = #{offset VkXlibSurfaceCreateInfoKHR, flags} + + {-# INLINE readVkFlags #-} + readVkFlags p + = peekByteOff p #{offset VkXlibSurfaceCreateInfoKHR, flags} + + {-# INLINE writeVkFlags #-} + writeVkFlags p + = pokeByteOff p #{offset VkXlibSurfaceCreateInfoKHR, flags} + +instance {-# OVERLAPPING #-} + HasField "flags" VkXlibSurfaceCreateInfoKHR where + type FieldType "flags" VkXlibSurfaceCreateInfoKHR = + VkXlibSurfaceCreateFlagsKHR + type FieldOptional "flags" VkXlibSurfaceCreateInfoKHR = 'True -- ' closing tick for hsc2hs + type FieldOffset "flags" VkXlibSurfaceCreateInfoKHR = + #{offset VkXlibSurfaceCreateInfoKHR, flags} + type FieldIsArray "flags" VkXlibSurfaceCreateInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = True + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkXlibSurfaceCreateInfoKHR, flags} + +instance CanReadField "flags" VkXlibSurfaceCreateInfoKHR where + {-# INLINE getField #-} + getField = vkFlags + + {-# INLINE readField #-} + readField = readVkFlags + +instance CanWriteField "flags" VkXlibSurfaceCreateInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkFlags + +instance {-# OVERLAPPING #-} HasVkDpy VkXlibSurfaceCreateInfoKHR + where + type VkDpyMType VkXlibSurfaceCreateInfoKHR = Ptr Display + + {-# NOINLINE vkDpy #-} + vkDpy x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkXlibSurfaceCreateInfoKHR, dpy}) + + {-# INLINE vkDpyByteOffset #-} + vkDpyByteOffset ~_ + = #{offset VkXlibSurfaceCreateInfoKHR, dpy} + + {-# INLINE readVkDpy #-} + readVkDpy p + = peekByteOff p #{offset VkXlibSurfaceCreateInfoKHR, dpy} + + {-# INLINE writeVkDpy #-} + writeVkDpy p + = pokeByteOff p #{offset VkXlibSurfaceCreateInfoKHR, dpy} + +instance {-# OVERLAPPING #-} + HasField "dpy" VkXlibSurfaceCreateInfoKHR where + type FieldType "dpy" VkXlibSurfaceCreateInfoKHR = Ptr Display + type FieldOptional "dpy" VkXlibSurfaceCreateInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "dpy" VkXlibSurfaceCreateInfoKHR = + #{offset VkXlibSurfaceCreateInfoKHR, dpy} + type FieldIsArray "dpy" VkXlibSurfaceCreateInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset = #{offset VkXlibSurfaceCreateInfoKHR, dpy} + +instance CanReadField "dpy" VkXlibSurfaceCreateInfoKHR where + {-# INLINE getField #-} + getField = vkDpy + + {-# INLINE readField #-} + readField = readVkDpy + +instance CanWriteField "dpy" VkXlibSurfaceCreateInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkDpy + +instance {-# OVERLAPPING #-} HasVkWindow VkXlibSurfaceCreateInfoKHR + where + type VkWindowMType VkXlibSurfaceCreateInfoKHR = Window + + {-# NOINLINE vkWindow #-} + vkWindow x + = unsafeDupablePerformIO + (peekByteOff (unsafePtr x) #{offset VkXlibSurfaceCreateInfoKHR, window}) + + {-# INLINE vkWindowByteOffset #-} + vkWindowByteOffset ~_ + = #{offset VkXlibSurfaceCreateInfoKHR, window} + + {-# INLINE readVkWindow #-} + readVkWindow p + = peekByteOff p #{offset VkXlibSurfaceCreateInfoKHR, window} + + {-# INLINE writeVkWindow #-} + writeVkWindow p + = pokeByteOff p #{offset VkXlibSurfaceCreateInfoKHR, window} + +instance {-# OVERLAPPING #-} + HasField "window" VkXlibSurfaceCreateInfoKHR where + type FieldType "window" VkXlibSurfaceCreateInfoKHR = Window + type FieldOptional "window" VkXlibSurfaceCreateInfoKHR = 'False -- ' closing tick for hsc2hs + type FieldOffset "window" VkXlibSurfaceCreateInfoKHR = + #{offset VkXlibSurfaceCreateInfoKHR, window} + type FieldIsArray "window" VkXlibSurfaceCreateInfoKHR = 'False -- ' closing tick for hsc2hs + + {-# INLINE fieldOptional #-} + fieldOptional = False + + {-# INLINE fieldOffset #-} + fieldOffset + = #{offset VkXlibSurfaceCreateInfoKHR, window} + +instance CanReadField "window" VkXlibSurfaceCreateInfoKHR where + {-# INLINE getField #-} + getField = vkWindow + + {-# INLINE readField #-} + readField = readVkWindow + +instance CanWriteField "window" VkXlibSurfaceCreateInfoKHR where + {-# INLINE writeField #-} + writeField = writeVkWindow + +instance Show VkXlibSurfaceCreateInfoKHR where + showsPrec d x + = showString "VkXlibSurfaceCreateInfoKHR {" . + showString "vkSType = " . + showsPrec d (vkSType x) . + showString ", " . + showString "vkPNext = " . + showsPrec d (vkPNext x) . + showString ", " . + showString "vkFlags = " . + showsPrec d (vkFlags x) . + showString ", " . + showString "vkDpy = " . + showsPrec d (vkDpy x) . + showString ", " . + showString "vkWindow = " . + showsPrec d (vkWindow x) . showChar '}' diff --git a/src-gen/Graphics/Vulkan/Types/StructMembers.hs b/src-gen/Graphics/Vulkan/Types/StructMembers.hs new file mode 100644 --- /dev/null +++ b/src-gen/Graphics/Vulkan/Types/StructMembers.hs @@ -0,0 +1,17303 @@ +{-# OPTIONS_GHC -fno-warn-missing-methods#-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleContexts #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeFamilies #-} +{-# LANGUAGE TypeOperators #-} +{-# LANGUAGE UndecidableInstances #-} +module Graphics.Vulkan.Types.StructMembers + (HasVkA(..), HasVkAcquireCount(..), HasVkActualPresentTime(..), + HasVkAddressModeU(..), HasVkAddressModeV(..), + HasVkAddressModeW(..), HasVkAdvancedBlendAllOperations(..), + HasVkAdvancedBlendCoherentOperations(..), + HasVkAdvancedBlendCorrelatedOverlap(..), + HasVkAdvancedBlendIndependentBlend(..), + HasVkAdvancedBlendMaxColorAttachments(..), + HasVkAdvancedBlendNonPremultipliedDstColor(..), + HasVkAdvancedBlendNonPremultipliedSrcColor(..), HasVkAlignment(..), + HasVkAllocationSize(..), HasVkAlphaBlendOp(..), HasVkAlphaMode(..), + HasVkAlphaToCoverageEnable(..), HasVkAlphaToOne(..), + HasVkAlphaToOneEnable(..), HasVkAnisotropyEnable(..), + HasVkApiVersion(..), HasVkApplicationVersion(..), + HasVkArrayLayer(..), HasVkArrayLayers(..), HasVkArrayPitch(..), + HasVkAspectMask(..), HasVkAspectReferenceCount(..), + HasVkAttachment(..), HasVkAttachmentCount(..), + HasVkAttachmentIndex(..), + HasVkAttachmentInitialSampleLocationsCount(..), HasVkB(..), + HasVkBack(..), HasVkBaseArrayLayer(..), HasVkBaseMipLevel(..), + HasVkBasePipelineHandle(..), HasVkBasePipelineIndex(..), + HasVkBindCount(..), HasVkBinding(..), HasVkBindingCount(..), + HasVkBindingUnit(..), HasVkBlendConstantsArray(..), + HasVkBlendEnable(..), HasVkBlendOverlap(..), HasVkBorderColor(..), + HasVkBuffer(..), HasVkBufferBindCount(..), HasVkBufferFeatures(..), + HasVkBufferImageGranularity(..), HasVkBufferImageHeight(..), + HasVkBufferOffset(..), HasVkBufferRowLength(..), + HasVkChromaFilter(..), HasVkClearValue(..), + HasVkClearValueCount(..), HasVkClipped(..), HasVkCodeSize(..), + HasVkColor(..), HasVkColorArray(..), HasVkColorAttachment(..), + HasVkColorAttachmentCount(..), HasVkColorBlendOp(..), + HasVkColorSpace(..), HasVkColorWriteMask(..), + HasVkCombinedImageSamplerDescriptorCount(..), + HasVkCommandBufferCount(..), HasVkCommandPool(..), + HasVkCompareEnable(..), HasVkCompareMask(..), HasVkCompareOp(..), + HasVkCompatibleHandleTypes(..), HasVkComponents(..), + HasVkCompositeAlpha(..), HasVkComputeBindingPointSupport(..), + HasVkComputeWorkGroupSizeArray(..), HasVkConnection(..), + HasVkConservativePointAndLineRasterization(..), + HasVkConservativeRasterizationMode(..), + HasVkConservativeRasterizationPostDepthCoverage(..), + HasVkConstantID(..), HasVkConversion(..), + HasVkCorrelationMaskCount(..), HasVkCoverageModulationMode(..), + HasVkCoverageModulationTableCount(..), + HasVkCoverageModulationTableEnable(..), + HasVkCoverageToColorEnable(..), HasVkCoverageToColorLocation(..), + HasVkCullMode(..), HasVkCurrentDisplay(..), HasVkCurrentExtent(..), + HasVkCurrentStackIndex(..), HasVkCurrentTransform(..), + HasVkDataSize(..), HasVkDedicatedAllocation(..), + HasVkDegenerateLinesRasterized(..), + HasVkDegenerateTrianglesRasterized(..), HasVkDependencyCount(..), + HasVkDependencyFlags(..), HasVkDepth(..), HasVkDepthBiasClamp(..), + HasVkDepthBiasConstantFactor(..), HasVkDepthBiasEnable(..), + HasVkDepthBiasSlopeFactor(..), HasVkDepthBounds(..), + HasVkDepthBoundsTestEnable(..), HasVkDepthClamp(..), + HasVkDepthClampEnable(..), HasVkDepthCompareOp(..), + HasVkDepthFailOp(..), HasVkDepthPitch(..), HasVkDepthStencil(..), + HasVkDepthTestEnable(..), HasVkDepthWriteEnable(..), + HasVkDescriptionArray(..), HasVkDescriptorCount(..), + HasVkDescriptorPool(..), HasVkDescriptorSet(..), + HasVkDescriptorSetCount(..), HasVkDescriptorSetLayout(..), + HasVkDescriptorType(..), HasVkDescriptorUpdateEntryCount(..), + HasVkDesiredPresentTime(..), HasVkDeviceEvent(..), + HasVkDeviceID(..), HasVkDeviceIndexCount(..), + HasVkDeviceLUIDArray(..), HasVkDeviceLUIDValid(..), + HasVkDeviceMask(..), HasVkDeviceNameArray(..), + HasVkDeviceNodeMask(..), HasVkDeviceRenderAreaCount(..), + HasVkDeviceType(..), HasVkDeviceUUIDArray(..), + HasVkDisabledValidationCheckCount(..), + HasVkDiscardRectangleCount(..), HasVkDiscardRectangleMode(..), + HasVkDiscreteQueuePriorities(..), HasVkDisplay(..), + HasVkDisplayEvent(..), HasVkDisplayMode(..), HasVkDisplayName(..), + HasVkDisplayPrimaryBlue(..), HasVkDisplayPrimaryGreen(..), + HasVkDisplayPrimaryRed(..), HasVkDivisor(..), + HasVkDomainOrigin(..), HasVkDpy(..), + HasVkDrawIndirectFirstInstance(..), HasVkDriverUUIDArray(..), + HasVkDriverVersion(..), HasVkDstAccessMask(..), + HasVkDstAlphaBlendFactor(..), HasVkDstArrayElement(..), + HasVkDstBinding(..), HasVkDstColorBlendFactor(..), + HasVkDstOffset(..), HasVkDstOffsetsArray(..), + HasVkDstPremultiplied(..), HasVkDstQueueFamilyIndex(..), + HasVkDstRect(..), HasVkDstSet(..), HasVkDstStageMask(..), + HasVkDstSubpass(..), HasVkDstSubresource(..), + HasVkDualSrcBlend(..), HasVkDwAccess(..), HasVkDynamicCount(..), + HasVkDynamicStateCount(..), HasVkEarliestPresentTime(..), + HasVkEnabledExtensionCount(..), HasVkEnabledLayerCount(..), + HasVkEngineVersion(..), HasVkExportFromImportedHandleTypes(..), + HasVkExtensionNameArray(..), HasVkExtent(..), + HasVkExternalFenceFeatures(..), HasVkExternalMemoryFeatures(..), + HasVkExternalMemoryProperties(..), + HasVkExternalSemaphoreFeatures(..), + HasVkExtraPrimitiveOverestimationSize(..), + HasVkExtraPrimitiveOverestimationSizeGranularity(..), + HasVkFailOp(..), HasVkFd(..), HasVkFeatures(..), HasVkFence(..), + HasVkFillModeNonSolid(..), + HasVkFilterMinmaxImageComponentMapping(..), + HasVkFilterMinmaxSingleComponentFormats(..), HasVkFinalLayout(..), + HasVkFirstIndex(..), HasVkFirstInstance(..), HasVkFirstVertex(..), + HasVkFlags(..), HasVkFloat32Array(..), + HasVkForceExplicitReconstruction(..), HasVkFormat(..), + HasVkFormatProperties(..), HasVkFragmentStoresAndAtomics(..), + HasVkFramebuffer(..), HasVkFramebufferColorSampleCounts(..), + HasVkFramebufferDepthSampleCounts(..), + HasVkFramebufferNoAttachmentsSampleCounts(..), + HasVkFramebufferStencilSampleCounts(..), HasVkFront(..), + HasVkFrontFace(..), HasVkFullDrawIndexUint32(..), + HasVkFullyCoveredFragmentShaderInputVariable(..), HasVkG(..), + HasVkGeometryShader(..), HasVkGlobalAlpha(..), + HasVkGlobalPriority(..), HasVkHandle(..), HasVkHandleType(..), + HasVkHandleTypes(..), HasVkHeapIndex(..), HasVkHeight(..), + HasVkHinstance(..), HasVkHwnd(..), HasVkImage(..), + HasVkImageArrayLayers(..), HasVkImageBindCount(..), + HasVkImageColorSpace(..), HasVkImageCubeArray(..), + HasVkImageExtent(..), HasVkImageFormat(..), + HasVkImageFormatProperties(..), HasVkImageGranularity(..), + HasVkImageIndex(..), HasVkImageLayout(..), + HasVkImageMipTailFirstLod(..), HasVkImageMipTailOffset(..), + HasVkImageMipTailSize(..), HasVkImageMipTailStride(..), + HasVkImageOffset(..), HasVkImageOpaqueBindCount(..), + HasVkImageSharingMode(..), HasVkImageSubresource(..), + HasVkImageType(..), HasVkImageUsage(..), HasVkImageView(..), + HasVkImplementationVersion(..), HasVkIndependentBlend(..), + HasVkIndexCount(..), HasVkIndexType(..), + HasVkIndirectCommandsLayout(..), + HasVkIndirectCommandsTokenCount(..), HasVkInheritedQueries(..), + HasVkInitialDataSize(..), HasVkInitialLayout(..), + HasVkInputAttachmentCount(..), HasVkInputAttachmentIndex(..), + HasVkInputRate(..), HasVkInstanceCount(..), HasVkInt32Array(..), + HasVkLargePoints(..), HasVkLayer(..), HasVkLayerCount(..), + HasVkLayerNameArray(..), HasVkLayers(..), HasVkLayout(..), + HasVkLdsSizePerLocalWorkGroup(..), HasVkLdsUsageSizeInBytes(..), + HasVkLevel(..), HasVkLevelCount(..), HasVkLimits(..), + HasVkLineWidth(..), HasVkLineWidthGranularity(..), + HasVkLineWidthRangeArray(..), HasVkLinearTilingFeatures(..), + HasVkLoadOp(..), HasVkLocation(..), HasVkLogicOp(..), + HasVkLogicOpEnable(..), HasVkMagFilter(..), HasVkMapEntryCount(..), + HasVkMaxAnisotropy(..), HasVkMaxArrayLayers(..), + HasVkMaxBoundDescriptorSets(..), HasVkMaxClipDistances(..), + HasVkMaxColorAttachments(..), + HasVkMaxCombinedClipAndCullDistances(..), + HasVkMaxComputeSharedMemorySize(..), + HasVkMaxComputeWorkGroupCountArray(..), + HasVkMaxComputeWorkGroupInvocations(..), + HasVkMaxComputeWorkGroupSizeArray(..), + HasVkMaxContentLightLevel(..), HasVkMaxCullDistances(..), + HasVkMaxDepth(..), HasVkMaxDepthBounds(..), + HasVkMaxDescriptorSetInputAttachments(..), + HasVkMaxDescriptorSetSampledImages(..), + HasVkMaxDescriptorSetSamplers(..), + HasVkMaxDescriptorSetStorageBuffers(..), + HasVkMaxDescriptorSetStorageBuffersDynamic(..), + HasVkMaxDescriptorSetStorageImages(..), + HasVkMaxDescriptorSetUniformBuffers(..), + HasVkMaxDescriptorSetUniformBuffersDynamic(..), + HasVkMaxDiscardRectangles(..), HasVkMaxDrawIndexedIndexValue(..), + HasVkMaxDrawIndirectCount(..), HasVkMaxDstExtent(..), + HasVkMaxDstPosition(..), HasVkMaxExtent(..), + HasVkMaxExtraPrimitiveOverestimationSize(..), + HasVkMaxFragmentCombinedOutputResources(..), + HasVkMaxFragmentDualSrcAttachments(..), + HasVkMaxFragmentInputComponents(..), + HasVkMaxFragmentOutputAttachments(..), + HasVkMaxFrameAverageLightLevel(..), HasVkMaxFramebufferHeight(..), + HasVkMaxFramebufferLayers(..), HasVkMaxFramebufferWidth(..), + HasVkMaxGeometryInputComponents(..), + HasVkMaxGeometryOutputComponents(..), + HasVkMaxGeometryOutputVertices(..), + HasVkMaxGeometryShaderInvocations(..), + HasVkMaxGeometryTotalOutputComponents(..), + HasVkMaxImageArrayLayers(..), HasVkMaxImageCount(..), + HasVkMaxImageDimension1D(..), HasVkMaxImageDimension2D(..), + HasVkMaxImageDimension3D(..), HasVkMaxImageDimensionCube(..), + HasVkMaxImageExtent(..), + HasVkMaxIndirectCommandsLayoutTokenCount(..), + HasVkMaxInterpolationOffset(..), HasVkMaxLod(..), + HasVkMaxLuminance(..), HasVkMaxMemoryAllocationCount(..), + HasVkMaxMipLevels(..), HasVkMaxMultiviewInstanceIndex(..), + HasVkMaxMultiviewViewCount(..), HasVkMaxObjectEntryCounts(..), + HasVkMaxPerStageDescriptorInputAttachments(..), + HasVkMaxPerStageDescriptorSampledImages(..), + HasVkMaxPerStageDescriptorSamplers(..), + HasVkMaxPerStageDescriptorStorageBuffers(..), + HasVkMaxPerStageDescriptorStorageImages(..), + HasVkMaxPerStageDescriptorUniformBuffers(..), + HasVkMaxPerStageResources(..), HasVkMaxPipelineLayouts(..), + HasVkMaxPushConstantsSize(..), HasVkMaxPushDescriptors(..), + HasVkMaxResourceSize(..), HasVkMaxSampleLocationGridSize(..), + HasVkMaxSampleMaskWords(..), + HasVkMaxSampledImagesPerDescriptor(..), + HasVkMaxSamplerAllocationCount(..), HasVkMaxSamplerAnisotropy(..), + HasVkMaxSamplerLodBias(..), HasVkMaxSequencesCount(..), + HasVkMaxSets(..), HasVkMaxSrcExtent(..), HasVkMaxSrcPosition(..), + HasVkMaxStorageBufferRange(..), + HasVkMaxStorageBuffersPerDescriptor(..), + HasVkMaxStorageImagesPerDescriptor(..), + HasVkMaxTessellationControlPerPatchOutputComponents(..), + HasVkMaxTessellationControlPerVertexInputComponents(..), + HasVkMaxTessellationControlPerVertexOutputComponents(..), + HasVkMaxTessellationControlTotalOutputComponents(..), + HasVkMaxTessellationEvaluationInputComponents(..), + HasVkMaxTessellationEvaluationOutputComponents(..), + HasVkMaxTessellationGenerationLevel(..), + HasVkMaxTessellationPatchSize(..), HasVkMaxTexelBufferElements(..), + HasVkMaxTexelGatherOffset(..), HasVkMaxTexelOffset(..), + HasVkMaxUniformBufferRange(..), + HasVkMaxUniformBuffersPerDescriptor(..), + HasVkMaxVertexInputAttributeOffset(..), + HasVkMaxVertexInputAttributes(..), + HasVkMaxVertexInputBindingStride(..), + HasVkMaxVertexInputBindings(..), + HasVkMaxVertexOutputComponents(..), + HasVkMaxViewportDimensionsArray(..), HasVkMaxViewports(..), + HasVkMemory(..), HasVkMemoryDeviceIndex(..), + HasVkMemoryHeapCount(..), HasVkMemoryHeapsArray(..), + HasVkMemoryOffset(..), HasVkMemoryProperties(..), + HasVkMemoryRequirements(..), HasVkMemoryTypeBits(..), + HasVkMemoryTypeCount(..), HasVkMemoryTypeIndex(..), + HasVkMemoryTypesArray(..), + HasVkMinCommandsTokenBufferOffsetAlignment(..), HasVkMinDepth(..), + HasVkMinDepthBounds(..), HasVkMinDstExtent(..), + HasVkMinDstPosition(..), HasVkMinFilter(..), + HasVkMinImageCount(..), HasVkMinImageExtent(..), + HasVkMinImageTransferGranularity(..), + HasVkMinImportedHostPointerAlignment(..), + HasVkMinInterpolationOffset(..), HasVkMinLod(..), + HasVkMinLuminance(..), HasVkMinMemoryMapAlignment(..), + HasVkMinSampleShading(..), + HasVkMinSequenceCountBufferOffsetAlignment(..), + HasVkMinSequenceIndexBufferOffsetAlignment(..), + HasVkMinSrcExtent(..), HasVkMinSrcPosition(..), + HasVkMinStorageBufferOffsetAlignment(..), + HasVkMinTexelBufferOffsetAlignment(..), + HasVkMinTexelGatherOffset(..), HasVkMinTexelOffset(..), + HasVkMinUniformBufferOffsetAlignment(..), HasVkMipLevel(..), + HasVkMipLevels(..), HasVkMipLodBias(..), HasVkMipmapMode(..), + HasVkMipmapPrecisionBits(..), HasVkMirSurface(..), HasVkMode(..), + HasVkModes(..), HasVkModule(..), HasVkMultiDrawIndirect(..), + HasVkMultiViewport(..), HasVkMultiview(..), + HasVkMultiviewGeometryShader(..), + HasVkMultiviewTessellationShader(..), HasVkName(..), + HasVkNewLayout(..), HasVkNonCoherentAtomSize(..), + HasVkNumAvailableSgprs(..), HasVkNumAvailableVgprs(..), + HasVkNumPhysicalSgprs(..), HasVkNumPhysicalVgprs(..), + HasVkNumUsedSgprs(..), HasVkNumUsedVgprs(..), HasVkObject(..), + HasVkObjectCount(..), HasVkObjectTable(..), HasVkObjectType(..), + HasVkOcclusionQueryEnable(..), HasVkOcclusionQueryPrecise(..), + HasVkOffset(..), HasVkOldLayout(..), HasVkOldSwapchain(..), + HasVkOptimalBufferCopyOffsetAlignment(..), + HasVkOptimalBufferCopyRowPitchAlignment(..), + HasVkOptimalTilingFeatures(..), HasVkPAcquireKeys(..), + HasVkPAcquireSyncs(..), HasVkPAcquireTimeoutMilliseconds(..), + HasVkPAcquireTimeouts(..), HasVkPApplicationInfo(..), + HasVkPApplicationName(..), HasVkPAspectReferences(..), + HasVkPAttachmentInitialSampleLocations(..), HasVkPAttachments(..), + HasVkPAttributes(..), HasVkPBindings(..), HasVkPBinds(..), + HasVkPBufferBinds(..), HasVkPBufferInfo(..), HasVkPClearValues(..), + HasVkPCode(..), HasVkPColorAttachments(..), + HasVkPColorBlendState(..), HasVkPCommandBufferDeviceMasks(..), + HasVkPCommandBuffers(..), HasVkPCorrelationMasks(..), + HasVkPCoverageModulationTable(..), HasVkPData(..), + HasVkPDependencies(..), HasVkPDepthStencilAttachment(..), + HasVkPDepthStencilState(..), HasVkPDescriptorUpdateEntries(..), + HasVkPDeviceIndices(..), HasVkPDeviceMasks(..), + HasVkPDeviceRenderAreas(..), HasVkPDisabledValidationChecks(..), + HasVkPDiscardRectangles(..), HasVkPDynamicState(..), + HasVkPDynamicStates(..), HasVkPEnabledFeatures(..), + HasVkPEngineName(..), HasVkPHostPointer(..), HasVkPImageBinds(..), + HasVkPImageIndices(..), HasVkPImageInfo(..), + HasVkPImageOpaqueBinds(..), HasVkPImmutableSamplers(..), + HasVkPIndirectCommandsTokens(..), HasVkPInheritanceInfo(..), + HasVkPInitialData(..), HasVkPInputAssemblyState(..), + HasVkPInputAttachments(..), HasVkPMapEntries(..), + HasVkPMarkerName(..), HasVkPMultisampleState(..), HasVkPName(..), + HasVkPNext(..), HasVkPObjectEntryCounts(..), + HasVkPObjectEntryTypes(..), HasVkPObjectEntryUsageFlags(..), + HasVkPObjectName(..), HasVkPPhysicalDevices(..), + HasVkPPoolSizes(..), HasVkPPostSubpassSampleLocations(..), + HasVkPPreserveAttachments(..), HasVkPPushConstantRanges(..), + HasVkPQueueCreateInfos(..), HasVkPQueueFamilyIndices(..), + HasVkPQueuePriorities(..), HasVkPRasterizationState(..), + HasVkPRectangles(..), HasVkPRegions(..), HasVkPReleaseKeys(..), + HasVkPReleaseSyncs(..), HasVkPResolveAttachments(..), + HasVkPResults(..), HasVkPSFRRects(..), HasVkPSampleLocations(..), + HasVkPSampleMask(..), HasVkPScissors(..), HasVkPSetLayouts(..), + HasVkPSignalSemaphoreDeviceIndices(..), + HasVkPSignalSemaphoreValues(..), HasVkPSignalSemaphores(..), + HasVkPSpecializationInfo(..), HasVkPStages(..), + HasVkPSubpasses(..), HasVkPSwapchains(..), HasVkPTag(..), + HasVkPTessellationState(..), HasVkPTexelBufferView(..), + HasVkPTimes(..), HasVkPTokens(..), HasVkPUserData(..), + HasVkPVertexAttributeDescriptions(..), + HasVkPVertexBindingDescriptions(..), HasVkPVertexInputState(..), + HasVkPView(..), HasVkPViewFormats(..), HasVkPViewMasks(..), + HasVkPViewOffsets(..), HasVkPViewportState(..), + HasVkPViewportSwizzles(..), HasVkPViewportWScalings(..), + HasVkPViewports(..), HasVkPWaitDstStageMask(..), + HasVkPWaitSemaphoreDeviceIndices(..), + HasVkPWaitSemaphoreValues(..), HasVkPWaitSemaphores(..), + HasVkParameters(..), HasVkPassOp(..), HasVkPatchControlPoints(..), + HasVkPerViewPositionAllComponents(..), HasVkPersistent(..), + HasVkPersistentContent(..), HasVkPfnAllocation(..), + HasVkPfnCallback(..), HasVkPfnFree(..), + HasVkPfnInternalAllocation(..), HasVkPfnInternalFree(..), + HasVkPfnReallocation(..), HasVkPhysicalDeviceCount(..), + HasVkPhysicalDevicesArray(..), HasVkPhysicalDimensions(..), + HasVkPhysicalResolution(..), HasVkPipeline(..), + HasVkPipelineBindPoint(..), HasVkPipelineCacheUUIDArray(..), + HasVkPipelineLayout(..), HasVkPipelineStatistics(..), + HasVkPipelineStatisticsQuery(..), HasVkPlaneAspect(..), + HasVkPlaneIndex(..), HasVkPlaneReorderPossible(..), + HasVkPlaneStackIndex(..), HasVkPointClippingBehavior(..), + HasVkPointSizeGranularity(..), HasVkPointSizeRangeArray(..), + HasVkPolygonMode(..), HasVkPoolSizeCount(..), + HasVkPostSubpassSampleLocationsCount(..), HasVkPowerState(..), + HasVkPpEnabledExtensionNames(..), HasVkPpEnabledLayerNames(..), + HasVkPreTransform(..), HasVkPrefersDedicatedAllocation(..), + HasVkPresentID(..), HasVkPresentMargin(..), + HasVkPresentMaskArray(..), HasVkPresentMode(..), + HasVkPreserveAttachmentCount(..), + HasVkPrimitiveOverestimationSize(..), + HasVkPrimitiveRestartEnable(..), HasVkPrimitiveUnderestimation(..), + HasVkProperties(..), HasVkPropertyFlags(..), + HasVkPushConstantRangeCount(..), HasVkQueryCount(..), + HasVkQueryFlags(..), HasVkQueryType(..), HasVkQueueCount(..), + HasVkQueueCreateInfoCount(..), HasVkQueueFamilyIndex(..), + HasVkQueueFamilyIndexCount(..), HasVkQueueFamilyProperties(..), + HasVkQueueFlags(..), HasVkR(..), HasVkRange(..), + HasVkRasterizationOrder(..), HasVkRasterizationSamples(..), + HasVkRasterizerDiscardEnable(..), HasVkRect(..), + HasVkRectangleCount(..), HasVkReductionMode(..), + HasVkReference(..), HasVkRefreshDuration(..), HasVkRefreshRate(..), + HasVkReleaseCount(..), HasVkRenderArea(..), HasVkRenderPass(..), + HasVkRequiresDedicatedAllocation(..), + HasVkResidencyAlignedMipSize(..), + HasVkResidencyNonResidentStrict(..), + HasVkResidencyStandard2DBlockShape(..), + HasVkResidencyStandard2DMultisampleBlockShape(..), + HasVkResidencyStandard3DBlockShape(..), + HasVkResourceDeviceIndex(..), HasVkResourceOffset(..), + HasVkResourceUsage(..), HasVkRobustBufferAccess(..), + HasVkRowPitch(..), HasVkSFRRectCount(..), HasVkSType(..), + HasVkSampleCounts(..), HasVkSampleLocationCoordinateRangeArray(..), + HasVkSampleLocationGridSize(..), + HasVkSampleLocationSampleCounts(..), + HasVkSampleLocationSubPixelBits(..), HasVkSampleLocationsCount(..), + HasVkSampleLocationsEnable(..), HasVkSampleLocationsInfo(..), + HasVkSampleLocationsPerPixel(..), HasVkSampleRateShading(..), + HasVkSampleShadingEnable(..), + HasVkSampledImageColorSampleCounts(..), + HasVkSampledImageDepthSampleCounts(..), + HasVkSampledImageIntegerSampleCounts(..), + HasVkSampledImageStencilSampleCounts(..), HasVkSampler(..), + HasVkSamplerAnisotropy(..), HasVkSamplerYcbcrConversion(..), + HasVkSamples(..), HasVkScissorCount(..), + HasVkScratchMemUsageInBytes(..), HasVkSemaphore(..), + HasVkSequencesCountBuffer(..), HasVkSequencesCountOffset(..), + HasVkSequencesIndexBuffer(..), HasVkSequencesIndexOffset(..), + HasVkSet(..), HasVkSetLayoutCount(..), HasVkShaderClipDistance(..), + HasVkShaderCullDistance(..), HasVkShaderFloat64(..), + HasVkShaderImageGatherExtended(..), HasVkShaderInt16(..), + HasVkShaderInt64(..), HasVkShaderResourceMinLod(..), + HasVkShaderResourceResidency(..), + HasVkShaderSampledImageArrayDynamicIndexing(..), + HasVkShaderStageMask(..), + HasVkShaderStorageBufferArrayDynamicIndexing(..), + HasVkShaderStorageImageArrayDynamicIndexing(..), + HasVkShaderStorageImageExtendedFormats(..), + HasVkShaderStorageImageMultisample(..), + HasVkShaderStorageImageReadWithoutFormat(..), + HasVkShaderStorageImageWriteWithoutFormat(..), + HasVkShaderTessellationAndGeometryPointSize(..), + HasVkShaderUniformBufferArrayDynamicIndexing(..), + HasVkSharedPresentSupportedUsageFlags(..), HasVkSharingMode(..), + HasVkSignalSemaphoreCount(..), HasVkSignalSemaphoreValuesCount(..), + HasVkSize(..), HasVkSparseAddressSpaceSize(..), + HasVkSparseBinding(..), HasVkSparseProperties(..), + HasVkSparseResidency16Samples(..), + HasVkSparseResidency2Samples(..), HasVkSparseResidency4Samples(..), + HasVkSparseResidency8Samples(..), HasVkSparseResidencyAliased(..), + HasVkSparseResidencyBuffer(..), HasVkSparseResidencyImage2D(..), + HasVkSparseResidencyImage3D(..), HasVkSpecVersion(..), + HasVkSrcAccessMask(..), HasVkSrcAlphaBlendFactor(..), + HasVkSrcArrayElement(..), HasVkSrcBinding(..), + HasVkSrcColorBlendFactor(..), HasVkSrcOffset(..), + HasVkSrcOffsetsArray(..), HasVkSrcPremultiplied(..), + HasVkSrcQueueFamilyIndex(..), HasVkSrcRect(..), HasVkSrcSet(..), + HasVkSrcStageMask(..), HasVkSrcSubpass(..), + HasVkSrcSubresource(..), HasVkStage(..), HasVkStageCount(..), + HasVkStageFlags(..), HasVkStandardSampleLocations(..), + HasVkStencil(..), HasVkStencilLoadOp(..), HasVkStencilStoreOp(..), + HasVkStencilTestEnable(..), HasVkStorageBuffer16BitAccess(..), + HasVkStorageImageSampleCounts(..), HasVkStorageInputOutput16(..), + HasVkStoragePushConstant16(..), HasVkStoreOp(..), + HasVkStrictLines(..), HasVkStride(..), + HasVkSubPixelInterpolationOffsetBits(..), + HasVkSubPixelPrecisionBits(..), HasVkSubTexelPrecisionBits(..), + HasVkSubpass(..), HasVkSubpassCount(..), HasVkSubpassIndex(..), + HasVkSubresource(..), HasVkSubresourceRange(..), + HasVkSubsetAllocation(..), HasVkSupportedAlpha(..), + HasVkSupportedCompositeAlpha(..), + HasVkSupportedSurfaceCounters(..), HasVkSupportedTransforms(..), + HasVkSupportedUsageFlags(..), + HasVkSupportsTextureGatherLODBiasAMD(..), HasVkSurface(..), + HasVkSurfaceCapabilities(..), HasVkSurfaceCounters(..), + HasVkSurfaceFormat(..), HasVkSwapchain(..), + HasVkSwapchainCount(..), HasVkTagName(..), HasVkTagSize(..), + HasVkTargetCommandBuffer(..), HasVkTemplateType(..), + HasVkTessellationShader(..), HasVkTextureCompressionASTC_LDR(..), + HasVkTextureCompressionBC(..), HasVkTextureCompressionETC2(..), + HasVkTiling(..), HasVkTimeout(..), + HasVkTimestampComputeAndGraphics(..), HasVkTimestampPeriod(..), + HasVkTimestampValidBits(..), HasVkTokenCount(..), + HasVkTokenType(..), HasVkTopology(..), HasVkTransform(..), + HasVkType(..), HasVkUint32Array(..), + HasVkUniformAndStorageBuffer16BitAccess(..), + HasVkUnnormalizedCoordinates(..), HasVkUsage(..), + HasVkValidationCache(..), HasVkVariableMultisampleRate(..), + HasVkVariablePointers(..), HasVkVariablePointersStorageBuffer(..), + HasVkVariableSampleLocations(..), HasVkVendorID(..), + HasVkVertexAttributeDescriptionCount(..), + HasVkVertexBindingDescriptionCount(..), HasVkVertexCount(..), + HasVkVertexOffset(..), HasVkVertexPipelineStoresAndAtomics(..), + HasVkViewFormatCount(..), HasVkViewType(..), + HasVkViewportBoundsRangeArray(..), HasVkViewportCount(..), + HasVkViewportSubPixelBits(..), HasVkViewportWScalingEnable(..), + HasVkVisibleRegion(..), HasVkW(..), HasVkWaitSemaphoreCount(..), + HasVkWaitSemaphoreValuesCount(..), HasVkWhitePoint(..), + HasVkWideLines(..), HasVkWidth(..), HasVkWindow(..), + HasVkWriteMask(..), HasVkX(..), HasVkXChromaOffset(..), + HasVkXcoeff(..), HasVkY(..), HasVkYChromaOffset(..), + HasVkYcbcrModel(..), HasVkYcbcrRange(..), HasVkYcoeff(..), + HasVkZ(..)) + where +import GHC.TypeLits (ErrorMessage (..), TypeError) +import Graphics.Vulkan.Marshal + +class HasVkA a where + type VkAMType a :: * + + vkA :: a -> VkAMType a + + vkAByteOffset :: a -> Int + + readVkA :: Ptr a -> IO (VkAMType a) + + writeVkA :: Ptr a -> VkAMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'a'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkA a + +class HasVkAcquireCount a where + type VkAcquireCountMType a :: * + + vkAcquireCount :: a -> VkAcquireCountMType a + + vkAcquireCountByteOffset :: a -> Int + + readVkAcquireCount :: Ptr a -> IO (VkAcquireCountMType a) + + writeVkAcquireCount :: Ptr a -> VkAcquireCountMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'acquireCount'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkAcquireCount a + +class HasVkActualPresentTime a where + type VkActualPresentTimeMType a :: * + + vkActualPresentTime :: a -> VkActualPresentTimeMType a + + vkActualPresentTimeByteOffset :: a -> Int + + readVkActualPresentTime :: Ptr a -> IO (VkActualPresentTimeMType a) + + writeVkActualPresentTime :: + Ptr a -> VkActualPresentTimeMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'actualPresentTime'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkActualPresentTime a + +class HasVkAddressModeU a where + type VkAddressModeUMType a :: * + + vkAddressModeU :: a -> VkAddressModeUMType a + + vkAddressModeUByteOffset :: a -> Int + + readVkAddressModeU :: Ptr a -> IO (VkAddressModeUMType a) + + writeVkAddressModeU :: Ptr a -> VkAddressModeUMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'addressModeU'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkAddressModeU a + +class HasVkAddressModeV a where + type VkAddressModeVMType a :: * + + vkAddressModeV :: a -> VkAddressModeVMType a + + vkAddressModeVByteOffset :: a -> Int + + readVkAddressModeV :: Ptr a -> IO (VkAddressModeVMType a) + + writeVkAddressModeV :: Ptr a -> VkAddressModeVMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'addressModeV'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkAddressModeV a + +class HasVkAddressModeW a where + type VkAddressModeWMType a :: * + + vkAddressModeW :: a -> VkAddressModeWMType a + + vkAddressModeWByteOffset :: a -> Int + + readVkAddressModeW :: Ptr a -> IO (VkAddressModeWMType a) + + writeVkAddressModeW :: Ptr a -> VkAddressModeWMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'addressModeW'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkAddressModeW a + +class HasVkAdvancedBlendAllOperations a where + type VkAdvancedBlendAllOperationsMType a :: * + + vkAdvancedBlendAllOperations :: + a -> VkAdvancedBlendAllOperationsMType a + + vkAdvancedBlendAllOperationsByteOffset :: a -> Int + + readVkAdvancedBlendAllOperations :: + Ptr a -> IO (VkAdvancedBlendAllOperationsMType a) + + writeVkAdvancedBlendAllOperations :: + Ptr a -> VkAdvancedBlendAllOperationsMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'advancedBlendAllOperations'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkAdvancedBlendAllOperations a + +class HasVkAdvancedBlendCoherentOperations a where + type VkAdvancedBlendCoherentOperationsMType a :: * + + vkAdvancedBlendCoherentOperations :: + a -> VkAdvancedBlendCoherentOperationsMType a + + vkAdvancedBlendCoherentOperationsByteOffset :: a -> Int + + readVkAdvancedBlendCoherentOperations :: + Ptr a -> IO (VkAdvancedBlendCoherentOperationsMType a) + + writeVkAdvancedBlendCoherentOperations :: + Ptr a -> + VkAdvancedBlendCoherentOperationsMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text + " does not seem to have field 'advancedBlendCoherentOperations'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkAdvancedBlendCoherentOperations a + +class HasVkAdvancedBlendCorrelatedOverlap a where + type VkAdvancedBlendCorrelatedOverlapMType a :: * + + vkAdvancedBlendCorrelatedOverlap :: + a -> VkAdvancedBlendCorrelatedOverlapMType a + + vkAdvancedBlendCorrelatedOverlapByteOffset :: a -> Int + + readVkAdvancedBlendCorrelatedOverlap :: + Ptr a -> IO (VkAdvancedBlendCorrelatedOverlapMType a) + + writeVkAdvancedBlendCorrelatedOverlap :: + Ptr a -> + VkAdvancedBlendCorrelatedOverlapMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text + " does not seem to have field 'advancedBlendCorrelatedOverlap'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkAdvancedBlendCorrelatedOverlap a + +class HasVkAdvancedBlendIndependentBlend a where + type VkAdvancedBlendIndependentBlendMType a :: * + + vkAdvancedBlendIndependentBlend :: + a -> VkAdvancedBlendIndependentBlendMType a + + vkAdvancedBlendIndependentBlendByteOffset :: a -> Int + + readVkAdvancedBlendIndependentBlend :: + Ptr a -> IO (VkAdvancedBlendIndependentBlendMType a) + + writeVkAdvancedBlendIndependentBlend :: + Ptr a -> + VkAdvancedBlendIndependentBlendMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text + " does not seem to have field 'advancedBlendIndependentBlend'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkAdvancedBlendIndependentBlend a + +class HasVkAdvancedBlendMaxColorAttachments a where + type VkAdvancedBlendMaxColorAttachmentsMType a :: * + + vkAdvancedBlendMaxColorAttachments :: + a -> VkAdvancedBlendMaxColorAttachmentsMType a + + vkAdvancedBlendMaxColorAttachmentsByteOffset :: a -> Int + + readVkAdvancedBlendMaxColorAttachments :: + Ptr a -> + IO (VkAdvancedBlendMaxColorAttachmentsMType a) + + writeVkAdvancedBlendMaxColorAttachments :: + Ptr a -> + VkAdvancedBlendMaxColorAttachmentsMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text + " does not seem to have field 'advancedBlendMaxColorAttachments'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkAdvancedBlendMaxColorAttachments a + +class HasVkAdvancedBlendNonPremultipliedDstColor a where + type VkAdvancedBlendNonPremultipliedDstColorMType a :: * + + vkAdvancedBlendNonPremultipliedDstColor :: + a -> VkAdvancedBlendNonPremultipliedDstColorMType a + + vkAdvancedBlendNonPremultipliedDstColorByteOffset :: a -> Int + + readVkAdvancedBlendNonPremultipliedDstColor :: + Ptr a -> + IO + (VkAdvancedBlendNonPremultipliedDstColorMType + a) + + writeVkAdvancedBlendNonPremultipliedDstColor :: + Ptr a -> + VkAdvancedBlendNonPremultipliedDstColorMType + a + -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text + " does not seem to have field 'advancedBlendNonPremultipliedDstColor'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkAdvancedBlendNonPremultipliedDstColor a + +class HasVkAdvancedBlendNonPremultipliedSrcColor a where + type VkAdvancedBlendNonPremultipliedSrcColorMType a :: * + + vkAdvancedBlendNonPremultipliedSrcColor :: + a -> VkAdvancedBlendNonPremultipliedSrcColorMType a + + vkAdvancedBlendNonPremultipliedSrcColorByteOffset :: a -> Int + + readVkAdvancedBlendNonPremultipliedSrcColor :: + Ptr a -> + IO + (VkAdvancedBlendNonPremultipliedSrcColorMType + a) + + writeVkAdvancedBlendNonPremultipliedSrcColor :: + Ptr a -> + VkAdvancedBlendNonPremultipliedSrcColorMType + a + -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text + " does not seem to have field 'advancedBlendNonPremultipliedSrcColor'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkAdvancedBlendNonPremultipliedSrcColor a + +class HasVkAlignment a where + type VkAlignmentMType a :: * + + vkAlignment :: a -> VkAlignmentMType a + + vkAlignmentByteOffset :: a -> Int + + readVkAlignment :: Ptr a -> IO (VkAlignmentMType a) + + writeVkAlignment :: Ptr a -> VkAlignmentMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'alignment'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkAlignment a + +class HasVkAllocationSize a where + type VkAllocationSizeMType a :: * + + vkAllocationSize :: a -> VkAllocationSizeMType a + + vkAllocationSizeByteOffset :: a -> Int + + readVkAllocationSize :: Ptr a -> IO (VkAllocationSizeMType a) + + writeVkAllocationSize :: Ptr a -> VkAllocationSizeMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'allocationSize'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkAllocationSize a + +class HasVkAlphaBlendOp a where + type VkAlphaBlendOpMType a :: * + + vkAlphaBlendOp :: a -> VkAlphaBlendOpMType a + + vkAlphaBlendOpByteOffset :: a -> Int + + readVkAlphaBlendOp :: Ptr a -> IO (VkAlphaBlendOpMType a) + + writeVkAlphaBlendOp :: Ptr a -> VkAlphaBlendOpMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'alphaBlendOp'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkAlphaBlendOp a + +class HasVkAlphaMode a where + type VkAlphaModeMType a :: * + + vkAlphaMode :: a -> VkAlphaModeMType a + + vkAlphaModeByteOffset :: a -> Int + + readVkAlphaMode :: Ptr a -> IO (VkAlphaModeMType a) + + writeVkAlphaMode :: Ptr a -> VkAlphaModeMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'alphaMode'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkAlphaMode a + +class HasVkAlphaToCoverageEnable a where + type VkAlphaToCoverageEnableMType a :: * + + vkAlphaToCoverageEnable :: a -> VkAlphaToCoverageEnableMType a + + vkAlphaToCoverageEnableByteOffset :: a -> Int + + readVkAlphaToCoverageEnable :: + Ptr a -> IO (VkAlphaToCoverageEnableMType a) + + writeVkAlphaToCoverageEnable :: + Ptr a -> VkAlphaToCoverageEnableMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'alphaToCoverageEnable'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkAlphaToCoverageEnable a + +class HasVkAlphaToOne a where + type VkAlphaToOneMType a :: * + + vkAlphaToOne :: a -> VkAlphaToOneMType a + + vkAlphaToOneByteOffset :: a -> Int + + readVkAlphaToOne :: Ptr a -> IO (VkAlphaToOneMType a) + + writeVkAlphaToOne :: Ptr a -> VkAlphaToOneMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'alphaToOne'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkAlphaToOne a + +class HasVkAlphaToOneEnable a where + type VkAlphaToOneEnableMType a :: * + + vkAlphaToOneEnable :: a -> VkAlphaToOneEnableMType a + + vkAlphaToOneEnableByteOffset :: a -> Int + + readVkAlphaToOneEnable :: Ptr a -> IO (VkAlphaToOneEnableMType a) + + writeVkAlphaToOneEnable :: + Ptr a -> VkAlphaToOneEnableMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'alphaToOneEnable'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkAlphaToOneEnable a + +class HasVkAnisotropyEnable a where + type VkAnisotropyEnableMType a :: * + + vkAnisotropyEnable :: a -> VkAnisotropyEnableMType a + + vkAnisotropyEnableByteOffset :: a -> Int + + readVkAnisotropyEnable :: Ptr a -> IO (VkAnisotropyEnableMType a) + + writeVkAnisotropyEnable :: + Ptr a -> VkAnisotropyEnableMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'anisotropyEnable'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkAnisotropyEnable a + +class HasVkApiVersion a where + type VkApiVersionMType a :: * + + vkApiVersion :: a -> VkApiVersionMType a + + vkApiVersionByteOffset :: a -> Int + + readVkApiVersion :: Ptr a -> IO (VkApiVersionMType a) + + writeVkApiVersion :: Ptr a -> VkApiVersionMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'apiVersion'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkApiVersion a + +class HasVkApplicationVersion a where + type VkApplicationVersionMType a :: * + + vkApplicationVersion :: a -> VkApplicationVersionMType a + + vkApplicationVersionByteOffset :: a -> Int + + readVkApplicationVersion :: + Ptr a -> IO (VkApplicationVersionMType a) + + writeVkApplicationVersion :: + Ptr a -> VkApplicationVersionMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'applicationVersion'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkApplicationVersion a + +class HasVkArrayLayer a where + type VkArrayLayerMType a :: * + + vkArrayLayer :: a -> VkArrayLayerMType a + + vkArrayLayerByteOffset :: a -> Int + + readVkArrayLayer :: Ptr a -> IO (VkArrayLayerMType a) + + writeVkArrayLayer :: Ptr a -> VkArrayLayerMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'arrayLayer'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkArrayLayer a + +class HasVkArrayLayers a where + type VkArrayLayersMType a :: * + + vkArrayLayers :: a -> VkArrayLayersMType a + + vkArrayLayersByteOffset :: a -> Int + + readVkArrayLayers :: Ptr a -> IO (VkArrayLayersMType a) + + writeVkArrayLayers :: Ptr a -> VkArrayLayersMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'arrayLayers'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkArrayLayers a + +class HasVkArrayPitch a where + type VkArrayPitchMType a :: * + + vkArrayPitch :: a -> VkArrayPitchMType a + + vkArrayPitchByteOffset :: a -> Int + + readVkArrayPitch :: Ptr a -> IO (VkArrayPitchMType a) + + writeVkArrayPitch :: Ptr a -> VkArrayPitchMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'arrayPitch'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkArrayPitch a + +class HasVkAspectMask a where + type VkAspectMaskMType a :: * + + vkAspectMask :: a -> VkAspectMaskMType a + + vkAspectMaskByteOffset :: a -> Int + + readVkAspectMask :: Ptr a -> IO (VkAspectMaskMType a) + + writeVkAspectMask :: Ptr a -> VkAspectMaskMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'aspectMask'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkAspectMask a + +class HasVkAspectReferenceCount a where + type VkAspectReferenceCountMType a :: * + + vkAspectReferenceCount :: a -> VkAspectReferenceCountMType a + + vkAspectReferenceCountByteOffset :: a -> Int + + readVkAspectReferenceCount :: + Ptr a -> IO (VkAspectReferenceCountMType a) + + writeVkAspectReferenceCount :: + Ptr a -> VkAspectReferenceCountMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'aspectReferenceCount'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkAspectReferenceCount a + +class HasVkAttachment a where + type VkAttachmentMType a :: * + + vkAttachment :: a -> VkAttachmentMType a + + vkAttachmentByteOffset :: a -> Int + + readVkAttachment :: Ptr a -> IO (VkAttachmentMType a) + + writeVkAttachment :: Ptr a -> VkAttachmentMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'attachment'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkAttachment a + +class HasVkAttachmentCount a where + type VkAttachmentCountMType a :: * + + vkAttachmentCount :: a -> VkAttachmentCountMType a + + vkAttachmentCountByteOffset :: a -> Int + + readVkAttachmentCount :: Ptr a -> IO (VkAttachmentCountMType a) + + writeVkAttachmentCount :: + Ptr a -> VkAttachmentCountMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'attachmentCount'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkAttachmentCount a + +class HasVkAttachmentIndex a where + type VkAttachmentIndexMType a :: * + + vkAttachmentIndex :: a -> VkAttachmentIndexMType a + + vkAttachmentIndexByteOffset :: a -> Int + + readVkAttachmentIndex :: Ptr a -> IO (VkAttachmentIndexMType a) + + writeVkAttachmentIndex :: + Ptr a -> VkAttachmentIndexMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'attachmentIndex'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkAttachmentIndex a + +class HasVkAttachmentInitialSampleLocationsCount a where + type VkAttachmentInitialSampleLocationsCountMType a :: * + + vkAttachmentInitialSampleLocationsCount :: + a -> VkAttachmentInitialSampleLocationsCountMType a + + vkAttachmentInitialSampleLocationsCountByteOffset :: a -> Int + + readVkAttachmentInitialSampleLocationsCount :: + Ptr a -> + IO + (VkAttachmentInitialSampleLocationsCountMType + a) + + writeVkAttachmentInitialSampleLocationsCount :: + Ptr a -> + VkAttachmentInitialSampleLocationsCountMType + a + -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text + " does not seem to have field 'attachmentInitialSampleLocationsCount'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkAttachmentInitialSampleLocationsCount a + +class HasVkB a where + type VkBMType a :: * + + vkB :: a -> VkBMType a + + vkBByteOffset :: a -> Int + + readVkB :: Ptr a -> IO (VkBMType a) + + writeVkB :: Ptr a -> VkBMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'b'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkB a + +class HasVkBack a where + type VkBackMType a :: * + + vkBack :: a -> VkBackMType a + + vkBackByteOffset :: a -> Int + + readVkBack :: Ptr a -> IO (VkBackMType a) + + writeVkBack :: Ptr a -> VkBackMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'back'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkBack a + +class HasVkBaseArrayLayer a where + type VkBaseArrayLayerMType a :: * + + vkBaseArrayLayer :: a -> VkBaseArrayLayerMType a + + vkBaseArrayLayerByteOffset :: a -> Int + + readVkBaseArrayLayer :: Ptr a -> IO (VkBaseArrayLayerMType a) + + writeVkBaseArrayLayer :: Ptr a -> VkBaseArrayLayerMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'baseArrayLayer'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkBaseArrayLayer a + +class HasVkBaseMipLevel a where + type VkBaseMipLevelMType a :: * + + vkBaseMipLevel :: a -> VkBaseMipLevelMType a + + vkBaseMipLevelByteOffset :: a -> Int + + readVkBaseMipLevel :: Ptr a -> IO (VkBaseMipLevelMType a) + + writeVkBaseMipLevel :: Ptr a -> VkBaseMipLevelMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'baseMipLevel'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkBaseMipLevel a + +class HasVkBasePipelineHandle a where + type VkBasePipelineHandleMType a :: * + + vkBasePipelineHandle :: a -> VkBasePipelineHandleMType a + + vkBasePipelineHandleByteOffset :: a -> Int + + readVkBasePipelineHandle :: + Ptr a -> IO (VkBasePipelineHandleMType a) + + writeVkBasePipelineHandle :: + Ptr a -> VkBasePipelineHandleMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'basePipelineHandle'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkBasePipelineHandle a + +class HasVkBasePipelineIndex a where + type VkBasePipelineIndexMType a :: * + + vkBasePipelineIndex :: a -> VkBasePipelineIndexMType a + + vkBasePipelineIndexByteOffset :: a -> Int + + readVkBasePipelineIndex :: Ptr a -> IO (VkBasePipelineIndexMType a) + + writeVkBasePipelineIndex :: + Ptr a -> VkBasePipelineIndexMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'basePipelineIndex'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkBasePipelineIndex a + +class HasVkBindCount a where + type VkBindCountMType a :: * + + vkBindCount :: a -> VkBindCountMType a + + vkBindCountByteOffset :: a -> Int + + readVkBindCount :: Ptr a -> IO (VkBindCountMType a) + + writeVkBindCount :: Ptr a -> VkBindCountMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'bindCount'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkBindCount a + +class HasVkBinding a where + type VkBindingMType a :: * + + vkBinding :: a -> VkBindingMType a + + vkBindingByteOffset :: a -> Int + + readVkBinding :: Ptr a -> IO (VkBindingMType a) + + writeVkBinding :: Ptr a -> VkBindingMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'binding'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkBinding a + +class HasVkBindingCount a where + type VkBindingCountMType a :: * + + vkBindingCount :: a -> VkBindingCountMType a + + vkBindingCountByteOffset :: a -> Int + + readVkBindingCount :: Ptr a -> IO (VkBindingCountMType a) + + writeVkBindingCount :: Ptr a -> VkBindingCountMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'bindingCount'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkBindingCount a + +class HasVkBindingUnit a where + type VkBindingUnitMType a :: * + + vkBindingUnit :: a -> VkBindingUnitMType a + + vkBindingUnitByteOffset :: a -> Int + + readVkBindingUnit :: Ptr a -> IO (VkBindingUnitMType a) + + writeVkBindingUnit :: Ptr a -> VkBindingUnitMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'bindingUnit'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkBindingUnit a + +class HasVkBlendConstantsArray a where + type VkBlendConstantsArrayMType a :: * + + vkBlendConstantsArray :: a -> Int -> VkBlendConstantsArrayMType a + + vkBlendConstantsArrayByteOffset :: a -> Int + + readVkBlendConstantsArray :: + Ptr a -> Int -> IO (VkBlendConstantsArrayMType a) + + writeVkBlendConstantsArray :: + Ptr a -> Int -> VkBlendConstantsArrayMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'blendConstants'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkBlendConstantsArray a + +class HasVkBlendEnable a where + type VkBlendEnableMType a :: * + + vkBlendEnable :: a -> VkBlendEnableMType a + + vkBlendEnableByteOffset :: a -> Int + + readVkBlendEnable :: Ptr a -> IO (VkBlendEnableMType a) + + writeVkBlendEnable :: Ptr a -> VkBlendEnableMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'blendEnable'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkBlendEnable a + +class HasVkBlendOverlap a where + type VkBlendOverlapMType a :: * + + vkBlendOverlap :: a -> VkBlendOverlapMType a + + vkBlendOverlapByteOffset :: a -> Int + + readVkBlendOverlap :: Ptr a -> IO (VkBlendOverlapMType a) + + writeVkBlendOverlap :: Ptr a -> VkBlendOverlapMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'blendOverlap'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkBlendOverlap a + +class HasVkBorderColor a where + type VkBorderColorMType a :: * + + vkBorderColor :: a -> VkBorderColorMType a + + vkBorderColorByteOffset :: a -> Int + + readVkBorderColor :: Ptr a -> IO (VkBorderColorMType a) + + writeVkBorderColor :: Ptr a -> VkBorderColorMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'borderColor'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkBorderColor a + +class HasVkBuffer a where + type VkBufferMType a :: * + + vkBuffer :: a -> VkBufferMType a + + vkBufferByteOffset :: a -> Int + + readVkBuffer :: Ptr a -> IO (VkBufferMType a) + + writeVkBuffer :: Ptr a -> VkBufferMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'buffer'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkBuffer a + +class HasVkBufferBindCount a where + type VkBufferBindCountMType a :: * + + vkBufferBindCount :: a -> VkBufferBindCountMType a + + vkBufferBindCountByteOffset :: a -> Int + + readVkBufferBindCount :: Ptr a -> IO (VkBufferBindCountMType a) + + writeVkBufferBindCount :: + Ptr a -> VkBufferBindCountMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'bufferBindCount'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkBufferBindCount a + +class HasVkBufferFeatures a where + type VkBufferFeaturesMType a :: * + + vkBufferFeatures :: a -> VkBufferFeaturesMType a + + vkBufferFeaturesByteOffset :: a -> Int + + readVkBufferFeatures :: Ptr a -> IO (VkBufferFeaturesMType a) + + writeVkBufferFeatures :: Ptr a -> VkBufferFeaturesMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'bufferFeatures'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkBufferFeatures a + +class HasVkBufferImageGranularity a where + type VkBufferImageGranularityMType a :: * + + vkBufferImageGranularity :: a -> VkBufferImageGranularityMType a + + vkBufferImageGranularityByteOffset :: a -> Int + + readVkBufferImageGranularity :: + Ptr a -> IO (VkBufferImageGranularityMType a) + + writeVkBufferImageGranularity :: + Ptr a -> VkBufferImageGranularityMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'bufferImageGranularity'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkBufferImageGranularity a + +class HasVkBufferImageHeight a where + type VkBufferImageHeightMType a :: * + + vkBufferImageHeight :: a -> VkBufferImageHeightMType a + + vkBufferImageHeightByteOffset :: a -> Int + + readVkBufferImageHeight :: Ptr a -> IO (VkBufferImageHeightMType a) + + writeVkBufferImageHeight :: + Ptr a -> VkBufferImageHeightMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'bufferImageHeight'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkBufferImageHeight a + +class HasVkBufferOffset a where + type VkBufferOffsetMType a :: * + + vkBufferOffset :: a -> VkBufferOffsetMType a + + vkBufferOffsetByteOffset :: a -> Int + + readVkBufferOffset :: Ptr a -> IO (VkBufferOffsetMType a) + + writeVkBufferOffset :: Ptr a -> VkBufferOffsetMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'bufferOffset'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkBufferOffset a + +class HasVkBufferRowLength a where + type VkBufferRowLengthMType a :: * + + vkBufferRowLength :: a -> VkBufferRowLengthMType a + + vkBufferRowLengthByteOffset :: a -> Int + + readVkBufferRowLength :: Ptr a -> IO (VkBufferRowLengthMType a) + + writeVkBufferRowLength :: + Ptr a -> VkBufferRowLengthMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'bufferRowLength'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkBufferRowLength a + +class HasVkChromaFilter a where + type VkChromaFilterMType a :: * + + vkChromaFilter :: a -> VkChromaFilterMType a + + vkChromaFilterByteOffset :: a -> Int + + readVkChromaFilter :: Ptr a -> IO (VkChromaFilterMType a) + + writeVkChromaFilter :: Ptr a -> VkChromaFilterMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'chromaFilter'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkChromaFilter a + +class HasVkClearValue a where + type VkClearValueMType a :: * + + vkClearValue :: a -> VkClearValueMType a + + vkClearValueByteOffset :: a -> Int + + readVkClearValue :: Ptr a -> IO (VkClearValueMType a) + + writeVkClearValue :: Ptr a -> VkClearValueMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'clearValue'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkClearValue a + +class HasVkClearValueCount a where + type VkClearValueCountMType a :: * + + vkClearValueCount :: a -> VkClearValueCountMType a + + vkClearValueCountByteOffset :: a -> Int + + readVkClearValueCount :: Ptr a -> IO (VkClearValueCountMType a) + + writeVkClearValueCount :: + Ptr a -> VkClearValueCountMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'clearValueCount'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkClearValueCount a + +class HasVkClipped a where + type VkClippedMType a :: * + + vkClipped :: a -> VkClippedMType a + + vkClippedByteOffset :: a -> Int + + readVkClipped :: Ptr a -> IO (VkClippedMType a) + + writeVkClipped :: Ptr a -> VkClippedMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'clipped'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkClipped a + +class HasVkCodeSize a where + type VkCodeSizeMType a :: * + + vkCodeSize :: a -> VkCodeSizeMType a + + vkCodeSizeByteOffset :: a -> Int + + readVkCodeSize :: Ptr a -> IO (VkCodeSizeMType a) + + writeVkCodeSize :: Ptr a -> VkCodeSizeMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'codeSize'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkCodeSize a + +class HasVkColor a where + type VkColorMType a :: * + + vkColor :: a -> VkColorMType a + + vkColorByteOffset :: a -> Int + + readVkColor :: Ptr a -> IO (VkColorMType a) + + writeVkColor :: Ptr a -> VkColorMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'color'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkColor a + +class HasVkColorArray a where + type VkColorArrayMType a :: * + + vkColorArray :: a -> Int -> VkColorArrayMType a + + vkColorArrayByteOffset :: a -> Int + + readVkColorArray :: Ptr a -> Int -> IO (VkColorArrayMType a) + + writeVkColorArray :: Ptr a -> Int -> VkColorArrayMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'color'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkColorArray a + +class HasVkColorAttachment a where + type VkColorAttachmentMType a :: * + + vkColorAttachment :: a -> VkColorAttachmentMType a + + vkColorAttachmentByteOffset :: a -> Int + + readVkColorAttachment :: Ptr a -> IO (VkColorAttachmentMType a) + + writeVkColorAttachment :: + Ptr a -> VkColorAttachmentMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'colorAttachment'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkColorAttachment a + +class HasVkColorAttachmentCount a where + type VkColorAttachmentCountMType a :: * + + vkColorAttachmentCount :: a -> VkColorAttachmentCountMType a + + vkColorAttachmentCountByteOffset :: a -> Int + + readVkColorAttachmentCount :: + Ptr a -> IO (VkColorAttachmentCountMType a) + + writeVkColorAttachmentCount :: + Ptr a -> VkColorAttachmentCountMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'colorAttachmentCount'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkColorAttachmentCount a + +class HasVkColorBlendOp a where + type VkColorBlendOpMType a :: * + + vkColorBlendOp :: a -> VkColorBlendOpMType a + + vkColorBlendOpByteOffset :: a -> Int + + readVkColorBlendOp :: Ptr a -> IO (VkColorBlendOpMType a) + + writeVkColorBlendOp :: Ptr a -> VkColorBlendOpMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'colorBlendOp'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkColorBlendOp a + +class HasVkColorSpace a where + type VkColorSpaceMType a :: * + + vkColorSpace :: a -> VkColorSpaceMType a + + vkColorSpaceByteOffset :: a -> Int + + readVkColorSpace :: Ptr a -> IO (VkColorSpaceMType a) + + writeVkColorSpace :: Ptr a -> VkColorSpaceMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'colorSpace'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkColorSpace a + +class HasVkColorWriteMask a where + type VkColorWriteMaskMType a :: * + + vkColorWriteMask :: a -> VkColorWriteMaskMType a + + vkColorWriteMaskByteOffset :: a -> Int + + readVkColorWriteMask :: Ptr a -> IO (VkColorWriteMaskMType a) + + writeVkColorWriteMask :: Ptr a -> VkColorWriteMaskMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'colorWriteMask'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkColorWriteMask a + +class HasVkCombinedImageSamplerDescriptorCount a where + type VkCombinedImageSamplerDescriptorCountMType a :: * + + vkCombinedImageSamplerDescriptorCount :: + a -> VkCombinedImageSamplerDescriptorCountMType a + + vkCombinedImageSamplerDescriptorCountByteOffset :: a -> Int + + readVkCombinedImageSamplerDescriptorCount :: + Ptr a -> + IO + (VkCombinedImageSamplerDescriptorCountMType a) + + writeVkCombinedImageSamplerDescriptorCount :: + Ptr a -> + VkCombinedImageSamplerDescriptorCountMType a -> + IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text + " does not seem to have field 'combinedImageSamplerDescriptorCount'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkCombinedImageSamplerDescriptorCount a + +class HasVkCommandBufferCount a where + type VkCommandBufferCountMType a :: * + + vkCommandBufferCount :: a -> VkCommandBufferCountMType a + + vkCommandBufferCountByteOffset :: a -> Int + + readVkCommandBufferCount :: + Ptr a -> IO (VkCommandBufferCountMType a) + + writeVkCommandBufferCount :: + Ptr a -> VkCommandBufferCountMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'commandBufferCount'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkCommandBufferCount a + +class HasVkCommandPool a where + type VkCommandPoolMType a :: * + + vkCommandPool :: a -> VkCommandPoolMType a + + vkCommandPoolByteOffset :: a -> Int + + readVkCommandPool :: Ptr a -> IO (VkCommandPoolMType a) + + writeVkCommandPool :: Ptr a -> VkCommandPoolMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'commandPool'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkCommandPool a + +class HasVkCompareEnable a where + type VkCompareEnableMType a :: * + + vkCompareEnable :: a -> VkCompareEnableMType a + + vkCompareEnableByteOffset :: a -> Int + + readVkCompareEnable :: Ptr a -> IO (VkCompareEnableMType a) + + writeVkCompareEnable :: Ptr a -> VkCompareEnableMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'compareEnable'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkCompareEnable a + +class HasVkCompareMask a where + type VkCompareMaskMType a :: * + + vkCompareMask :: a -> VkCompareMaskMType a + + vkCompareMaskByteOffset :: a -> Int + + readVkCompareMask :: Ptr a -> IO (VkCompareMaskMType a) + + writeVkCompareMask :: Ptr a -> VkCompareMaskMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'compareMask'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkCompareMask a + +class HasVkCompareOp a where + type VkCompareOpMType a :: * + + vkCompareOp :: a -> VkCompareOpMType a + + vkCompareOpByteOffset :: a -> Int + + readVkCompareOp :: Ptr a -> IO (VkCompareOpMType a) + + writeVkCompareOp :: Ptr a -> VkCompareOpMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'compareOp'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkCompareOp a + +class HasVkCompatibleHandleTypes a where + type VkCompatibleHandleTypesMType a :: * + + vkCompatibleHandleTypes :: a -> VkCompatibleHandleTypesMType a + + vkCompatibleHandleTypesByteOffset :: a -> Int + + readVkCompatibleHandleTypes :: + Ptr a -> IO (VkCompatibleHandleTypesMType a) + + writeVkCompatibleHandleTypes :: + Ptr a -> VkCompatibleHandleTypesMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'compatibleHandleTypes'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkCompatibleHandleTypes a + +class HasVkComponents a where + type VkComponentsMType a :: * + + vkComponents :: a -> VkComponentsMType a + + vkComponentsByteOffset :: a -> Int + + readVkComponents :: Ptr a -> IO (VkComponentsMType a) + + writeVkComponents :: Ptr a -> VkComponentsMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'components'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkComponents a + +class HasVkCompositeAlpha a where + type VkCompositeAlphaMType a :: * + + vkCompositeAlpha :: a -> VkCompositeAlphaMType a + + vkCompositeAlphaByteOffset :: a -> Int + + readVkCompositeAlpha :: Ptr a -> IO (VkCompositeAlphaMType a) + + writeVkCompositeAlpha :: Ptr a -> VkCompositeAlphaMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'compositeAlpha'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkCompositeAlpha a + +class HasVkComputeBindingPointSupport a where + type VkComputeBindingPointSupportMType a :: * + + vkComputeBindingPointSupport :: + a -> VkComputeBindingPointSupportMType a + + vkComputeBindingPointSupportByteOffset :: a -> Int + + readVkComputeBindingPointSupport :: + Ptr a -> IO (VkComputeBindingPointSupportMType a) + + writeVkComputeBindingPointSupport :: + Ptr a -> VkComputeBindingPointSupportMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'computeBindingPointSupport'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkComputeBindingPointSupport a + +class HasVkComputeWorkGroupSizeArray a where + type VkComputeWorkGroupSizeArrayMType a :: * + + vkComputeWorkGroupSizeArray :: + a -> Int -> VkComputeWorkGroupSizeArrayMType a + + vkComputeWorkGroupSizeArrayByteOffset :: a -> Int + + readVkComputeWorkGroupSizeArray :: + Ptr a -> Int -> IO (VkComputeWorkGroupSizeArrayMType a) + + writeVkComputeWorkGroupSizeArray :: + Ptr a -> Int -> VkComputeWorkGroupSizeArrayMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'computeWorkGroupSize'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkComputeWorkGroupSizeArray a + +class HasVkConnection a where + type VkConnectionMType a :: * + + vkConnection :: a -> VkConnectionMType a + + vkConnectionByteOffset :: a -> Int + + readVkConnection :: Ptr a -> IO (VkConnectionMType a) + + writeVkConnection :: Ptr a -> VkConnectionMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'connection'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkConnection a + +class HasVkConservativePointAndLineRasterization a where + type VkConservativePointAndLineRasterizationMType a :: * + + vkConservativePointAndLineRasterization :: + a -> VkConservativePointAndLineRasterizationMType a + + vkConservativePointAndLineRasterizationByteOffset :: a -> Int + + readVkConservativePointAndLineRasterization :: + Ptr a -> + IO + (VkConservativePointAndLineRasterizationMType + a) + + writeVkConservativePointAndLineRasterization :: + Ptr a -> + VkConservativePointAndLineRasterizationMType + a + -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text + " does not seem to have field 'conservativePointAndLineRasterization'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkConservativePointAndLineRasterization a + +class HasVkConservativeRasterizationMode a where + type VkConservativeRasterizationModeMType a :: * + + vkConservativeRasterizationMode :: + a -> VkConservativeRasterizationModeMType a + + vkConservativeRasterizationModeByteOffset :: a -> Int + + readVkConservativeRasterizationMode :: + Ptr a -> IO (VkConservativeRasterizationModeMType a) + + writeVkConservativeRasterizationMode :: + Ptr a -> + VkConservativeRasterizationModeMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text + " does not seem to have field 'conservativeRasterizationMode'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkConservativeRasterizationMode a + +class HasVkConservativeRasterizationPostDepthCoverage a where + type VkConservativeRasterizationPostDepthCoverageMType a :: * + + vkConservativeRasterizationPostDepthCoverage :: + a -> + VkConservativeRasterizationPostDepthCoverageMType + a + + vkConservativeRasterizationPostDepthCoverageByteOffset :: a -> Int + + readVkConservativeRasterizationPostDepthCoverage :: + Ptr a -> + IO + (VkConservativeRasterizationPostDepthCoverageMType + a) + + writeVkConservativeRasterizationPostDepthCoverage :: + Ptr a -> + VkConservativeRasterizationPostDepthCoverageMType + a + -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text + " does not seem to have field 'conservativeRasterizationPostDepthCoverage'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkConservativeRasterizationPostDepthCoverage a + +class HasVkConstantID a where + type VkConstantIDMType a :: * + + vkConstantID :: a -> VkConstantIDMType a + + vkConstantIDByteOffset :: a -> Int + + readVkConstantID :: Ptr a -> IO (VkConstantIDMType a) + + writeVkConstantID :: Ptr a -> VkConstantIDMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'constantID'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkConstantID a + +class HasVkConversion a where + type VkConversionMType a :: * + + vkConversion :: a -> VkConversionMType a + + vkConversionByteOffset :: a -> Int + + readVkConversion :: Ptr a -> IO (VkConversionMType a) + + writeVkConversion :: Ptr a -> VkConversionMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'conversion'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkConversion a + +class HasVkCorrelationMaskCount a where + type VkCorrelationMaskCountMType a :: * + + vkCorrelationMaskCount :: a -> VkCorrelationMaskCountMType a + + vkCorrelationMaskCountByteOffset :: a -> Int + + readVkCorrelationMaskCount :: + Ptr a -> IO (VkCorrelationMaskCountMType a) + + writeVkCorrelationMaskCount :: + Ptr a -> VkCorrelationMaskCountMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'correlationMaskCount'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkCorrelationMaskCount a + +class HasVkCoverageModulationMode a where + type VkCoverageModulationModeMType a :: * + + vkCoverageModulationMode :: a -> VkCoverageModulationModeMType a + + vkCoverageModulationModeByteOffset :: a -> Int + + readVkCoverageModulationMode :: + Ptr a -> IO (VkCoverageModulationModeMType a) + + writeVkCoverageModulationMode :: + Ptr a -> VkCoverageModulationModeMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'coverageModulationMode'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkCoverageModulationMode a + +class HasVkCoverageModulationTableCount a where + type VkCoverageModulationTableCountMType a :: * + + vkCoverageModulationTableCount :: + a -> VkCoverageModulationTableCountMType a + + vkCoverageModulationTableCountByteOffset :: a -> Int + + readVkCoverageModulationTableCount :: + Ptr a -> IO (VkCoverageModulationTableCountMType a) + + writeVkCoverageModulationTableCount :: + Ptr a -> VkCoverageModulationTableCountMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text + " does not seem to have field 'coverageModulationTableCount'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkCoverageModulationTableCount a + +class HasVkCoverageModulationTableEnable a where + type VkCoverageModulationTableEnableMType a :: * + + vkCoverageModulationTableEnable :: + a -> VkCoverageModulationTableEnableMType a + + vkCoverageModulationTableEnableByteOffset :: a -> Int + + readVkCoverageModulationTableEnable :: + Ptr a -> IO (VkCoverageModulationTableEnableMType a) + + writeVkCoverageModulationTableEnable :: + Ptr a -> + VkCoverageModulationTableEnableMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text + " does not seem to have field 'coverageModulationTableEnable'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkCoverageModulationTableEnable a + +class HasVkCoverageToColorEnable a where + type VkCoverageToColorEnableMType a :: * + + vkCoverageToColorEnable :: a -> VkCoverageToColorEnableMType a + + vkCoverageToColorEnableByteOffset :: a -> Int + + readVkCoverageToColorEnable :: + Ptr a -> IO (VkCoverageToColorEnableMType a) + + writeVkCoverageToColorEnable :: + Ptr a -> VkCoverageToColorEnableMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'coverageToColorEnable'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkCoverageToColorEnable a + +class HasVkCoverageToColorLocation a where + type VkCoverageToColorLocationMType a :: * + + vkCoverageToColorLocation :: a -> VkCoverageToColorLocationMType a + + vkCoverageToColorLocationByteOffset :: a -> Int + + readVkCoverageToColorLocation :: + Ptr a -> IO (VkCoverageToColorLocationMType a) + + writeVkCoverageToColorLocation :: + Ptr a -> VkCoverageToColorLocationMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'coverageToColorLocation'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkCoverageToColorLocation a + +class HasVkCullMode a where + type VkCullModeMType a :: * + + vkCullMode :: a -> VkCullModeMType a + + vkCullModeByteOffset :: a -> Int + + readVkCullMode :: Ptr a -> IO (VkCullModeMType a) + + writeVkCullMode :: Ptr a -> VkCullModeMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'cullMode'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkCullMode a + +class HasVkCurrentDisplay a where + type VkCurrentDisplayMType a :: * + + vkCurrentDisplay :: a -> VkCurrentDisplayMType a + + vkCurrentDisplayByteOffset :: a -> Int + + readVkCurrentDisplay :: Ptr a -> IO (VkCurrentDisplayMType a) + + writeVkCurrentDisplay :: Ptr a -> VkCurrentDisplayMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'currentDisplay'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkCurrentDisplay a + +class HasVkCurrentExtent a where + type VkCurrentExtentMType a :: * + + vkCurrentExtent :: a -> VkCurrentExtentMType a + + vkCurrentExtentByteOffset :: a -> Int + + readVkCurrentExtent :: Ptr a -> IO (VkCurrentExtentMType a) + + writeVkCurrentExtent :: Ptr a -> VkCurrentExtentMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'currentExtent'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkCurrentExtent a + +class HasVkCurrentStackIndex a where + type VkCurrentStackIndexMType a :: * + + vkCurrentStackIndex :: a -> VkCurrentStackIndexMType a + + vkCurrentStackIndexByteOffset :: a -> Int + + readVkCurrentStackIndex :: Ptr a -> IO (VkCurrentStackIndexMType a) + + writeVkCurrentStackIndex :: + Ptr a -> VkCurrentStackIndexMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'currentStackIndex'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkCurrentStackIndex a + +class HasVkCurrentTransform a where + type VkCurrentTransformMType a :: * + + vkCurrentTransform :: a -> VkCurrentTransformMType a + + vkCurrentTransformByteOffset :: a -> Int + + readVkCurrentTransform :: Ptr a -> IO (VkCurrentTransformMType a) + + writeVkCurrentTransform :: + Ptr a -> VkCurrentTransformMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'currentTransform'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkCurrentTransform a + +class HasVkDataSize a where + type VkDataSizeMType a :: * + + vkDataSize :: a -> VkDataSizeMType a + + vkDataSizeByteOffset :: a -> Int + + readVkDataSize :: Ptr a -> IO (VkDataSizeMType a) + + writeVkDataSize :: Ptr a -> VkDataSizeMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'dataSize'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkDataSize a + +class HasVkDedicatedAllocation a where + type VkDedicatedAllocationMType a :: * + + vkDedicatedAllocation :: a -> VkDedicatedAllocationMType a + + vkDedicatedAllocationByteOffset :: a -> Int + + readVkDedicatedAllocation :: + Ptr a -> IO (VkDedicatedAllocationMType a) + + writeVkDedicatedAllocation :: + Ptr a -> VkDedicatedAllocationMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'dedicatedAllocation'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkDedicatedAllocation a + +class HasVkDegenerateLinesRasterized a where + type VkDegenerateLinesRasterizedMType a :: * + + vkDegenerateLinesRasterized :: + a -> VkDegenerateLinesRasterizedMType a + + vkDegenerateLinesRasterizedByteOffset :: a -> Int + + readVkDegenerateLinesRasterized :: + Ptr a -> IO (VkDegenerateLinesRasterizedMType a) + + writeVkDegenerateLinesRasterized :: + Ptr a -> VkDegenerateLinesRasterizedMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'degenerateLinesRasterized'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkDegenerateLinesRasterized a + +class HasVkDegenerateTrianglesRasterized a where + type VkDegenerateTrianglesRasterizedMType a :: * + + vkDegenerateTrianglesRasterized :: + a -> VkDegenerateTrianglesRasterizedMType a + + vkDegenerateTrianglesRasterizedByteOffset :: a -> Int + + readVkDegenerateTrianglesRasterized :: + Ptr a -> IO (VkDegenerateTrianglesRasterizedMType a) + + writeVkDegenerateTrianglesRasterized :: + Ptr a -> + VkDegenerateTrianglesRasterizedMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text + " does not seem to have field 'degenerateTrianglesRasterized'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkDegenerateTrianglesRasterized a + +class HasVkDependencyCount a where + type VkDependencyCountMType a :: * + + vkDependencyCount :: a -> VkDependencyCountMType a + + vkDependencyCountByteOffset :: a -> Int + + readVkDependencyCount :: Ptr a -> IO (VkDependencyCountMType a) + + writeVkDependencyCount :: + Ptr a -> VkDependencyCountMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'dependencyCount'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkDependencyCount a + +class HasVkDependencyFlags a where + type VkDependencyFlagsMType a :: * + + vkDependencyFlags :: a -> VkDependencyFlagsMType a + + vkDependencyFlagsByteOffset :: a -> Int + + readVkDependencyFlags :: Ptr a -> IO (VkDependencyFlagsMType a) + + writeVkDependencyFlags :: + Ptr a -> VkDependencyFlagsMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'dependencyFlags'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkDependencyFlags a + +class HasVkDepth a where + type VkDepthMType a :: * + + vkDepth :: a -> VkDepthMType a + + vkDepthByteOffset :: a -> Int + + readVkDepth :: Ptr a -> IO (VkDepthMType a) + + writeVkDepth :: Ptr a -> VkDepthMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'depth'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkDepth a + +class HasVkDepthBiasClamp a where + type VkDepthBiasClampMType a :: * + + vkDepthBiasClamp :: a -> VkDepthBiasClampMType a + + vkDepthBiasClampByteOffset :: a -> Int + + readVkDepthBiasClamp :: Ptr a -> IO (VkDepthBiasClampMType a) + + writeVkDepthBiasClamp :: Ptr a -> VkDepthBiasClampMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'depthBiasClamp'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkDepthBiasClamp a + +class HasVkDepthBiasConstantFactor a where + type VkDepthBiasConstantFactorMType a :: * + + vkDepthBiasConstantFactor :: a -> VkDepthBiasConstantFactorMType a + + vkDepthBiasConstantFactorByteOffset :: a -> Int + + readVkDepthBiasConstantFactor :: + Ptr a -> IO (VkDepthBiasConstantFactorMType a) + + writeVkDepthBiasConstantFactor :: + Ptr a -> VkDepthBiasConstantFactorMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'depthBiasConstantFactor'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkDepthBiasConstantFactor a + +class HasVkDepthBiasEnable a where + type VkDepthBiasEnableMType a :: * + + vkDepthBiasEnable :: a -> VkDepthBiasEnableMType a + + vkDepthBiasEnableByteOffset :: a -> Int + + readVkDepthBiasEnable :: Ptr a -> IO (VkDepthBiasEnableMType a) + + writeVkDepthBiasEnable :: + Ptr a -> VkDepthBiasEnableMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'depthBiasEnable'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkDepthBiasEnable a + +class HasVkDepthBiasSlopeFactor a where + type VkDepthBiasSlopeFactorMType a :: * + + vkDepthBiasSlopeFactor :: a -> VkDepthBiasSlopeFactorMType a + + vkDepthBiasSlopeFactorByteOffset :: a -> Int + + readVkDepthBiasSlopeFactor :: + Ptr a -> IO (VkDepthBiasSlopeFactorMType a) + + writeVkDepthBiasSlopeFactor :: + Ptr a -> VkDepthBiasSlopeFactorMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'depthBiasSlopeFactor'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkDepthBiasSlopeFactor a + +class HasVkDepthBounds a where + type VkDepthBoundsMType a :: * + + vkDepthBounds :: a -> VkDepthBoundsMType a + + vkDepthBoundsByteOffset :: a -> Int + + readVkDepthBounds :: Ptr a -> IO (VkDepthBoundsMType a) + + writeVkDepthBounds :: Ptr a -> VkDepthBoundsMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'depthBounds'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkDepthBounds a + +class HasVkDepthBoundsTestEnable a where + type VkDepthBoundsTestEnableMType a :: * + + vkDepthBoundsTestEnable :: a -> VkDepthBoundsTestEnableMType a + + vkDepthBoundsTestEnableByteOffset :: a -> Int + + readVkDepthBoundsTestEnable :: + Ptr a -> IO (VkDepthBoundsTestEnableMType a) + + writeVkDepthBoundsTestEnable :: + Ptr a -> VkDepthBoundsTestEnableMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'depthBoundsTestEnable'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkDepthBoundsTestEnable a + +class HasVkDepthClamp a where + type VkDepthClampMType a :: * + + vkDepthClamp :: a -> VkDepthClampMType a + + vkDepthClampByteOffset :: a -> Int + + readVkDepthClamp :: Ptr a -> IO (VkDepthClampMType a) + + writeVkDepthClamp :: Ptr a -> VkDepthClampMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'depthClamp'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkDepthClamp a + +class HasVkDepthClampEnable a where + type VkDepthClampEnableMType a :: * + + vkDepthClampEnable :: a -> VkDepthClampEnableMType a + + vkDepthClampEnableByteOffset :: a -> Int + + readVkDepthClampEnable :: Ptr a -> IO (VkDepthClampEnableMType a) + + writeVkDepthClampEnable :: + Ptr a -> VkDepthClampEnableMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'depthClampEnable'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkDepthClampEnable a + +class HasVkDepthCompareOp a where + type VkDepthCompareOpMType a :: * + + vkDepthCompareOp :: a -> VkDepthCompareOpMType a + + vkDepthCompareOpByteOffset :: a -> Int + + readVkDepthCompareOp :: Ptr a -> IO (VkDepthCompareOpMType a) + + writeVkDepthCompareOp :: Ptr a -> VkDepthCompareOpMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'depthCompareOp'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkDepthCompareOp a + +class HasVkDepthFailOp a where + type VkDepthFailOpMType a :: * + + vkDepthFailOp :: a -> VkDepthFailOpMType a + + vkDepthFailOpByteOffset :: a -> Int + + readVkDepthFailOp :: Ptr a -> IO (VkDepthFailOpMType a) + + writeVkDepthFailOp :: Ptr a -> VkDepthFailOpMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'depthFailOp'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkDepthFailOp a + +class HasVkDepthPitch a where + type VkDepthPitchMType a :: * + + vkDepthPitch :: a -> VkDepthPitchMType a + + vkDepthPitchByteOffset :: a -> Int + + readVkDepthPitch :: Ptr a -> IO (VkDepthPitchMType a) + + writeVkDepthPitch :: Ptr a -> VkDepthPitchMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'depthPitch'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkDepthPitch a + +class HasVkDepthStencil a where + type VkDepthStencilMType a :: * + + vkDepthStencil :: a -> VkDepthStencilMType a + + vkDepthStencilByteOffset :: a -> Int + + readVkDepthStencil :: Ptr a -> IO (VkDepthStencilMType a) + + writeVkDepthStencil :: Ptr a -> VkDepthStencilMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'depthStencil'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkDepthStencil a + +class HasVkDepthTestEnable a where + type VkDepthTestEnableMType a :: * + + vkDepthTestEnable :: a -> VkDepthTestEnableMType a + + vkDepthTestEnableByteOffset :: a -> Int + + readVkDepthTestEnable :: Ptr a -> IO (VkDepthTestEnableMType a) + + writeVkDepthTestEnable :: + Ptr a -> VkDepthTestEnableMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'depthTestEnable'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkDepthTestEnable a + +class HasVkDepthWriteEnable a where + type VkDepthWriteEnableMType a :: * + + vkDepthWriteEnable :: a -> VkDepthWriteEnableMType a + + vkDepthWriteEnableByteOffset :: a -> Int + + readVkDepthWriteEnable :: Ptr a -> IO (VkDepthWriteEnableMType a) + + writeVkDepthWriteEnable :: + Ptr a -> VkDepthWriteEnableMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'depthWriteEnable'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkDepthWriteEnable a + +class HasVkDescriptionArray a where + type VkDescriptionArrayMType a :: * + + vkDescriptionArray :: a -> Int -> VkDescriptionArrayMType a + + vkDescriptionArrayByteOffset :: a -> Int + + readVkDescriptionArray :: + Ptr a -> Int -> IO (VkDescriptionArrayMType a) + + writeVkDescriptionArray :: + Ptr a -> Int -> VkDescriptionArrayMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'description'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkDescriptionArray a + +class HasVkDescriptorCount a where + type VkDescriptorCountMType a :: * + + vkDescriptorCount :: a -> VkDescriptorCountMType a + + vkDescriptorCountByteOffset :: a -> Int + + readVkDescriptorCount :: Ptr a -> IO (VkDescriptorCountMType a) + + writeVkDescriptorCount :: + Ptr a -> VkDescriptorCountMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'descriptorCount'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkDescriptorCount a + +class HasVkDescriptorPool a where + type VkDescriptorPoolMType a :: * + + vkDescriptorPool :: a -> VkDescriptorPoolMType a + + vkDescriptorPoolByteOffset :: a -> Int + + readVkDescriptorPool :: Ptr a -> IO (VkDescriptorPoolMType a) + + writeVkDescriptorPool :: Ptr a -> VkDescriptorPoolMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'descriptorPool'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkDescriptorPool a + +class HasVkDescriptorSet a where + type VkDescriptorSetMType a :: * + + vkDescriptorSet :: a -> VkDescriptorSetMType a + + vkDescriptorSetByteOffset :: a -> Int + + readVkDescriptorSet :: Ptr a -> IO (VkDescriptorSetMType a) + + writeVkDescriptorSet :: Ptr a -> VkDescriptorSetMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'descriptorSet'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkDescriptorSet a + +class HasVkDescriptorSetCount a where + type VkDescriptorSetCountMType a :: * + + vkDescriptorSetCount :: a -> VkDescriptorSetCountMType a + + vkDescriptorSetCountByteOffset :: a -> Int + + readVkDescriptorSetCount :: + Ptr a -> IO (VkDescriptorSetCountMType a) + + writeVkDescriptorSetCount :: + Ptr a -> VkDescriptorSetCountMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'descriptorSetCount'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkDescriptorSetCount a + +class HasVkDescriptorSetLayout a where + type VkDescriptorSetLayoutMType a :: * + + vkDescriptorSetLayout :: a -> VkDescriptorSetLayoutMType a + + vkDescriptorSetLayoutByteOffset :: a -> Int + + readVkDescriptorSetLayout :: + Ptr a -> IO (VkDescriptorSetLayoutMType a) + + writeVkDescriptorSetLayout :: + Ptr a -> VkDescriptorSetLayoutMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'descriptorSetLayout'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkDescriptorSetLayout a + +class HasVkDescriptorType a where + type VkDescriptorTypeMType a :: * + + vkDescriptorType :: a -> VkDescriptorTypeMType a + + vkDescriptorTypeByteOffset :: a -> Int + + readVkDescriptorType :: Ptr a -> IO (VkDescriptorTypeMType a) + + writeVkDescriptorType :: Ptr a -> VkDescriptorTypeMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'descriptorType'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkDescriptorType a + +class HasVkDescriptorUpdateEntryCount a where + type VkDescriptorUpdateEntryCountMType a :: * + + vkDescriptorUpdateEntryCount :: + a -> VkDescriptorUpdateEntryCountMType a + + vkDescriptorUpdateEntryCountByteOffset :: a -> Int + + readVkDescriptorUpdateEntryCount :: + Ptr a -> IO (VkDescriptorUpdateEntryCountMType a) + + writeVkDescriptorUpdateEntryCount :: + Ptr a -> VkDescriptorUpdateEntryCountMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'descriptorUpdateEntryCount'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkDescriptorUpdateEntryCount a + +class HasVkDesiredPresentTime a where + type VkDesiredPresentTimeMType a :: * + + vkDesiredPresentTime :: a -> VkDesiredPresentTimeMType a + + vkDesiredPresentTimeByteOffset :: a -> Int + + readVkDesiredPresentTime :: + Ptr a -> IO (VkDesiredPresentTimeMType a) + + writeVkDesiredPresentTime :: + Ptr a -> VkDesiredPresentTimeMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'desiredPresentTime'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkDesiredPresentTime a + +class HasVkDeviceEvent a where + type VkDeviceEventMType a :: * + + vkDeviceEvent :: a -> VkDeviceEventMType a + + vkDeviceEventByteOffset :: a -> Int + + readVkDeviceEvent :: Ptr a -> IO (VkDeviceEventMType a) + + writeVkDeviceEvent :: Ptr a -> VkDeviceEventMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'deviceEvent'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkDeviceEvent a + +class HasVkDeviceID a where + type VkDeviceIDMType a :: * + + vkDeviceID :: a -> VkDeviceIDMType a + + vkDeviceIDByteOffset :: a -> Int + + readVkDeviceID :: Ptr a -> IO (VkDeviceIDMType a) + + writeVkDeviceID :: Ptr a -> VkDeviceIDMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'deviceID'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkDeviceID a + +class HasVkDeviceIndexCount a where + type VkDeviceIndexCountMType a :: * + + vkDeviceIndexCount :: a -> VkDeviceIndexCountMType a + + vkDeviceIndexCountByteOffset :: a -> Int + + readVkDeviceIndexCount :: Ptr a -> IO (VkDeviceIndexCountMType a) + + writeVkDeviceIndexCount :: + Ptr a -> VkDeviceIndexCountMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'deviceIndexCount'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkDeviceIndexCount a + +class HasVkDeviceLUIDArray a where + type VkDeviceLUIDArrayMType a :: * + + vkDeviceLUIDArray :: a -> Int -> VkDeviceLUIDArrayMType a + + vkDeviceLUIDArrayByteOffset :: a -> Int + + readVkDeviceLUIDArray :: + Ptr a -> Int -> IO (VkDeviceLUIDArrayMType a) + + writeVkDeviceLUIDArray :: + Ptr a -> Int -> VkDeviceLUIDArrayMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'deviceLUID'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkDeviceLUIDArray a + +class HasVkDeviceLUIDValid a where + type VkDeviceLUIDValidMType a :: * + + vkDeviceLUIDValid :: a -> VkDeviceLUIDValidMType a + + vkDeviceLUIDValidByteOffset :: a -> Int + + readVkDeviceLUIDValid :: Ptr a -> IO (VkDeviceLUIDValidMType a) + + writeVkDeviceLUIDValid :: + Ptr a -> VkDeviceLUIDValidMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'deviceLUIDValid'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkDeviceLUIDValid a + +class HasVkDeviceMask a where + type VkDeviceMaskMType a :: * + + vkDeviceMask :: a -> VkDeviceMaskMType a + + vkDeviceMaskByteOffset :: a -> Int + + readVkDeviceMask :: Ptr a -> IO (VkDeviceMaskMType a) + + writeVkDeviceMask :: Ptr a -> VkDeviceMaskMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'deviceMask'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkDeviceMask a + +class HasVkDeviceNameArray a where + type VkDeviceNameArrayMType a :: * + + vkDeviceNameArray :: a -> Int -> VkDeviceNameArrayMType a + + vkDeviceNameArrayByteOffset :: a -> Int + + readVkDeviceNameArray :: + Ptr a -> Int -> IO (VkDeviceNameArrayMType a) + + writeVkDeviceNameArray :: + Ptr a -> Int -> VkDeviceNameArrayMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'deviceName'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkDeviceNameArray a + +class HasVkDeviceNodeMask a where + type VkDeviceNodeMaskMType a :: * + + vkDeviceNodeMask :: a -> VkDeviceNodeMaskMType a + + vkDeviceNodeMaskByteOffset :: a -> Int + + readVkDeviceNodeMask :: Ptr a -> IO (VkDeviceNodeMaskMType a) + + writeVkDeviceNodeMask :: Ptr a -> VkDeviceNodeMaskMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'deviceNodeMask'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkDeviceNodeMask a + +class HasVkDeviceRenderAreaCount a where + type VkDeviceRenderAreaCountMType a :: * + + vkDeviceRenderAreaCount :: a -> VkDeviceRenderAreaCountMType a + + vkDeviceRenderAreaCountByteOffset :: a -> Int + + readVkDeviceRenderAreaCount :: + Ptr a -> IO (VkDeviceRenderAreaCountMType a) + + writeVkDeviceRenderAreaCount :: + Ptr a -> VkDeviceRenderAreaCountMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'deviceRenderAreaCount'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkDeviceRenderAreaCount a + +class HasVkDeviceType a where + type VkDeviceTypeMType a :: * + + vkDeviceType :: a -> VkDeviceTypeMType a + + vkDeviceTypeByteOffset :: a -> Int + + readVkDeviceType :: Ptr a -> IO (VkDeviceTypeMType a) + + writeVkDeviceType :: Ptr a -> VkDeviceTypeMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'deviceType'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkDeviceType a + +class HasVkDeviceUUIDArray a where + type VkDeviceUUIDArrayMType a :: * + + vkDeviceUUIDArray :: a -> Int -> VkDeviceUUIDArrayMType a + + vkDeviceUUIDArrayByteOffset :: a -> Int + + readVkDeviceUUIDArray :: + Ptr a -> Int -> IO (VkDeviceUUIDArrayMType a) + + writeVkDeviceUUIDArray :: + Ptr a -> Int -> VkDeviceUUIDArrayMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'deviceUUID'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkDeviceUUIDArray a + +class HasVkDisabledValidationCheckCount a where + type VkDisabledValidationCheckCountMType a :: * + + vkDisabledValidationCheckCount :: + a -> VkDisabledValidationCheckCountMType a + + vkDisabledValidationCheckCountByteOffset :: a -> Int + + readVkDisabledValidationCheckCount :: + Ptr a -> IO (VkDisabledValidationCheckCountMType a) + + writeVkDisabledValidationCheckCount :: + Ptr a -> VkDisabledValidationCheckCountMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text + " does not seem to have field 'disabledValidationCheckCount'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkDisabledValidationCheckCount a + +class HasVkDiscardRectangleCount a where + type VkDiscardRectangleCountMType a :: * + + vkDiscardRectangleCount :: a -> VkDiscardRectangleCountMType a + + vkDiscardRectangleCountByteOffset :: a -> Int + + readVkDiscardRectangleCount :: + Ptr a -> IO (VkDiscardRectangleCountMType a) + + writeVkDiscardRectangleCount :: + Ptr a -> VkDiscardRectangleCountMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'discardRectangleCount'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkDiscardRectangleCount a + +class HasVkDiscardRectangleMode a where + type VkDiscardRectangleModeMType a :: * + + vkDiscardRectangleMode :: a -> VkDiscardRectangleModeMType a + + vkDiscardRectangleModeByteOffset :: a -> Int + + readVkDiscardRectangleMode :: + Ptr a -> IO (VkDiscardRectangleModeMType a) + + writeVkDiscardRectangleMode :: + Ptr a -> VkDiscardRectangleModeMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'discardRectangleMode'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkDiscardRectangleMode a + +class HasVkDiscreteQueuePriorities a where + type VkDiscreteQueuePrioritiesMType a :: * + + vkDiscreteQueuePriorities :: a -> VkDiscreteQueuePrioritiesMType a + + vkDiscreteQueuePrioritiesByteOffset :: a -> Int + + readVkDiscreteQueuePriorities :: + Ptr a -> IO (VkDiscreteQueuePrioritiesMType a) + + writeVkDiscreteQueuePriorities :: + Ptr a -> VkDiscreteQueuePrioritiesMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'discreteQueuePriorities'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkDiscreteQueuePriorities a + +class HasVkDisplay a where + type VkDisplayMType a :: * + + vkDisplay :: a -> VkDisplayMType a + + vkDisplayByteOffset :: a -> Int + + readVkDisplay :: Ptr a -> IO (VkDisplayMType a) + + writeVkDisplay :: Ptr a -> VkDisplayMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'display'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkDisplay a + +class HasVkDisplayEvent a where + type VkDisplayEventMType a :: * + + vkDisplayEvent :: a -> VkDisplayEventMType a + + vkDisplayEventByteOffset :: a -> Int + + readVkDisplayEvent :: Ptr a -> IO (VkDisplayEventMType a) + + writeVkDisplayEvent :: Ptr a -> VkDisplayEventMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'displayEvent'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkDisplayEvent a + +class HasVkDisplayMode a where + type VkDisplayModeMType a :: * + + vkDisplayMode :: a -> VkDisplayModeMType a + + vkDisplayModeByteOffset :: a -> Int + + readVkDisplayMode :: Ptr a -> IO (VkDisplayModeMType a) + + writeVkDisplayMode :: Ptr a -> VkDisplayModeMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'displayMode'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkDisplayMode a + +class HasVkDisplayName a where + type VkDisplayNameMType a :: * + + vkDisplayName :: a -> VkDisplayNameMType a + + vkDisplayNameByteOffset :: a -> Int + + readVkDisplayName :: Ptr a -> IO (VkDisplayNameMType a) + + writeVkDisplayName :: Ptr a -> VkDisplayNameMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'displayName'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkDisplayName a + +class HasVkDisplayPrimaryBlue a where + type VkDisplayPrimaryBlueMType a :: * + + vkDisplayPrimaryBlue :: a -> VkDisplayPrimaryBlueMType a + + vkDisplayPrimaryBlueByteOffset :: a -> Int + + readVkDisplayPrimaryBlue :: + Ptr a -> IO (VkDisplayPrimaryBlueMType a) + + writeVkDisplayPrimaryBlue :: + Ptr a -> VkDisplayPrimaryBlueMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'displayPrimaryBlue'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkDisplayPrimaryBlue a + +class HasVkDisplayPrimaryGreen a where + type VkDisplayPrimaryGreenMType a :: * + + vkDisplayPrimaryGreen :: a -> VkDisplayPrimaryGreenMType a + + vkDisplayPrimaryGreenByteOffset :: a -> Int + + readVkDisplayPrimaryGreen :: + Ptr a -> IO (VkDisplayPrimaryGreenMType a) + + writeVkDisplayPrimaryGreen :: + Ptr a -> VkDisplayPrimaryGreenMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'displayPrimaryGreen'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkDisplayPrimaryGreen a + +class HasVkDisplayPrimaryRed a where + type VkDisplayPrimaryRedMType a :: * + + vkDisplayPrimaryRed :: a -> VkDisplayPrimaryRedMType a + + vkDisplayPrimaryRedByteOffset :: a -> Int + + readVkDisplayPrimaryRed :: Ptr a -> IO (VkDisplayPrimaryRedMType a) + + writeVkDisplayPrimaryRed :: + Ptr a -> VkDisplayPrimaryRedMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'displayPrimaryRed'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkDisplayPrimaryRed a + +class HasVkDivisor a where + type VkDivisorMType a :: * + + vkDivisor :: a -> VkDivisorMType a + + vkDivisorByteOffset :: a -> Int + + readVkDivisor :: Ptr a -> IO (VkDivisorMType a) + + writeVkDivisor :: Ptr a -> VkDivisorMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'divisor'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkDivisor a + +class HasVkDomainOrigin a where + type VkDomainOriginMType a :: * + + vkDomainOrigin :: a -> VkDomainOriginMType a + + vkDomainOriginByteOffset :: a -> Int + + readVkDomainOrigin :: Ptr a -> IO (VkDomainOriginMType a) + + writeVkDomainOrigin :: Ptr a -> VkDomainOriginMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'domainOrigin'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkDomainOrigin a + +class HasVkDpy a where + type VkDpyMType a :: * + + vkDpy :: a -> VkDpyMType a + + vkDpyByteOffset :: a -> Int + + readVkDpy :: Ptr a -> IO (VkDpyMType a) + + writeVkDpy :: Ptr a -> VkDpyMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'dpy'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkDpy a + +class HasVkDrawIndirectFirstInstance a where + type VkDrawIndirectFirstInstanceMType a :: * + + vkDrawIndirectFirstInstance :: + a -> VkDrawIndirectFirstInstanceMType a + + vkDrawIndirectFirstInstanceByteOffset :: a -> Int + + readVkDrawIndirectFirstInstance :: + Ptr a -> IO (VkDrawIndirectFirstInstanceMType a) + + writeVkDrawIndirectFirstInstance :: + Ptr a -> VkDrawIndirectFirstInstanceMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'drawIndirectFirstInstance'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkDrawIndirectFirstInstance a + +class HasVkDriverUUIDArray a where + type VkDriverUUIDArrayMType a :: * + + vkDriverUUIDArray :: a -> Int -> VkDriverUUIDArrayMType a + + vkDriverUUIDArrayByteOffset :: a -> Int + + readVkDriverUUIDArray :: + Ptr a -> Int -> IO (VkDriverUUIDArrayMType a) + + writeVkDriverUUIDArray :: + Ptr a -> Int -> VkDriverUUIDArrayMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'driverUUID'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkDriverUUIDArray a + +class HasVkDriverVersion a where + type VkDriverVersionMType a :: * + + vkDriverVersion :: a -> VkDriverVersionMType a + + vkDriverVersionByteOffset :: a -> Int + + readVkDriverVersion :: Ptr a -> IO (VkDriverVersionMType a) + + writeVkDriverVersion :: Ptr a -> VkDriverVersionMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'driverVersion'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkDriverVersion a + +class HasVkDstAccessMask a where + type VkDstAccessMaskMType a :: * + + vkDstAccessMask :: a -> VkDstAccessMaskMType a + + vkDstAccessMaskByteOffset :: a -> Int + + readVkDstAccessMask :: Ptr a -> IO (VkDstAccessMaskMType a) + + writeVkDstAccessMask :: Ptr a -> VkDstAccessMaskMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'dstAccessMask'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkDstAccessMask a + +class HasVkDstAlphaBlendFactor a where + type VkDstAlphaBlendFactorMType a :: * + + vkDstAlphaBlendFactor :: a -> VkDstAlphaBlendFactorMType a + + vkDstAlphaBlendFactorByteOffset :: a -> Int + + readVkDstAlphaBlendFactor :: + Ptr a -> IO (VkDstAlphaBlendFactorMType a) + + writeVkDstAlphaBlendFactor :: + Ptr a -> VkDstAlphaBlendFactorMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'dstAlphaBlendFactor'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkDstAlphaBlendFactor a + +class HasVkDstArrayElement a where + type VkDstArrayElementMType a :: * + + vkDstArrayElement :: a -> VkDstArrayElementMType a + + vkDstArrayElementByteOffset :: a -> Int + + readVkDstArrayElement :: Ptr a -> IO (VkDstArrayElementMType a) + + writeVkDstArrayElement :: + Ptr a -> VkDstArrayElementMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'dstArrayElement'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkDstArrayElement a + +class HasVkDstBinding a where + type VkDstBindingMType a :: * + + vkDstBinding :: a -> VkDstBindingMType a + + vkDstBindingByteOffset :: a -> Int + + readVkDstBinding :: Ptr a -> IO (VkDstBindingMType a) + + writeVkDstBinding :: Ptr a -> VkDstBindingMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'dstBinding'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkDstBinding a + +class HasVkDstColorBlendFactor a where + type VkDstColorBlendFactorMType a :: * + + vkDstColorBlendFactor :: a -> VkDstColorBlendFactorMType a + + vkDstColorBlendFactorByteOffset :: a -> Int + + readVkDstColorBlendFactor :: + Ptr a -> IO (VkDstColorBlendFactorMType a) + + writeVkDstColorBlendFactor :: + Ptr a -> VkDstColorBlendFactorMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'dstColorBlendFactor'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkDstColorBlendFactor a + +class HasVkDstOffset a where + type VkDstOffsetMType a :: * + + vkDstOffset :: a -> VkDstOffsetMType a + + vkDstOffsetByteOffset :: a -> Int + + readVkDstOffset :: Ptr a -> IO (VkDstOffsetMType a) + + writeVkDstOffset :: Ptr a -> VkDstOffsetMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'dstOffset'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkDstOffset a + +class HasVkDstOffsetsArray a where + type VkDstOffsetsArrayMType a :: * + + vkDstOffsetsArray :: a -> Int -> VkDstOffsetsArrayMType a + + vkDstOffsetsArrayByteOffset :: a -> Int + + readVkDstOffsetsArray :: + Ptr a -> Int -> IO (VkDstOffsetsArrayMType a) + + writeVkDstOffsetsArray :: + Ptr a -> Int -> VkDstOffsetsArrayMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'dstOffsets'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkDstOffsetsArray a + +class HasVkDstPremultiplied a where + type VkDstPremultipliedMType a :: * + + vkDstPremultiplied :: a -> VkDstPremultipliedMType a + + vkDstPremultipliedByteOffset :: a -> Int + + readVkDstPremultiplied :: Ptr a -> IO (VkDstPremultipliedMType a) + + writeVkDstPremultiplied :: + Ptr a -> VkDstPremultipliedMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'dstPremultiplied'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkDstPremultiplied a + +class HasVkDstQueueFamilyIndex a where + type VkDstQueueFamilyIndexMType a :: * + + vkDstQueueFamilyIndex :: a -> VkDstQueueFamilyIndexMType a + + vkDstQueueFamilyIndexByteOffset :: a -> Int + + readVkDstQueueFamilyIndex :: + Ptr a -> IO (VkDstQueueFamilyIndexMType a) + + writeVkDstQueueFamilyIndex :: + Ptr a -> VkDstQueueFamilyIndexMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'dstQueueFamilyIndex'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkDstQueueFamilyIndex a + +class HasVkDstRect a where + type VkDstRectMType a :: * + + vkDstRect :: a -> VkDstRectMType a + + vkDstRectByteOffset :: a -> Int + + readVkDstRect :: Ptr a -> IO (VkDstRectMType a) + + writeVkDstRect :: Ptr a -> VkDstRectMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'dstRect'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkDstRect a + +class HasVkDstSet a where + type VkDstSetMType a :: * + + vkDstSet :: a -> VkDstSetMType a + + vkDstSetByteOffset :: a -> Int + + readVkDstSet :: Ptr a -> IO (VkDstSetMType a) + + writeVkDstSet :: Ptr a -> VkDstSetMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'dstSet'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkDstSet a + +class HasVkDstStageMask a where + type VkDstStageMaskMType a :: * + + vkDstStageMask :: a -> VkDstStageMaskMType a + + vkDstStageMaskByteOffset :: a -> Int + + readVkDstStageMask :: Ptr a -> IO (VkDstStageMaskMType a) + + writeVkDstStageMask :: Ptr a -> VkDstStageMaskMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'dstStageMask'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkDstStageMask a + +class HasVkDstSubpass a where + type VkDstSubpassMType a :: * + + vkDstSubpass :: a -> VkDstSubpassMType a + + vkDstSubpassByteOffset :: a -> Int + + readVkDstSubpass :: Ptr a -> IO (VkDstSubpassMType a) + + writeVkDstSubpass :: Ptr a -> VkDstSubpassMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'dstSubpass'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkDstSubpass a + +class HasVkDstSubresource a where + type VkDstSubresourceMType a :: * + + vkDstSubresource :: a -> VkDstSubresourceMType a + + vkDstSubresourceByteOffset :: a -> Int + + readVkDstSubresource :: Ptr a -> IO (VkDstSubresourceMType a) + + writeVkDstSubresource :: Ptr a -> VkDstSubresourceMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'dstSubresource'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkDstSubresource a + +class HasVkDualSrcBlend a where + type VkDualSrcBlendMType a :: * + + vkDualSrcBlend :: a -> VkDualSrcBlendMType a + + vkDualSrcBlendByteOffset :: a -> Int + + readVkDualSrcBlend :: Ptr a -> IO (VkDualSrcBlendMType a) + + writeVkDualSrcBlend :: Ptr a -> VkDualSrcBlendMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'dualSrcBlend'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkDualSrcBlend a + +class HasVkDwAccess a where + type VkDwAccessMType a :: * + + vkDwAccess :: a -> VkDwAccessMType a + + vkDwAccessByteOffset :: a -> Int + + readVkDwAccess :: Ptr a -> IO (VkDwAccessMType a) + + writeVkDwAccess :: Ptr a -> VkDwAccessMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'dwAccess'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkDwAccess a + +class HasVkDynamicCount a where + type VkDynamicCountMType a :: * + + vkDynamicCount :: a -> VkDynamicCountMType a + + vkDynamicCountByteOffset :: a -> Int + + readVkDynamicCount :: Ptr a -> IO (VkDynamicCountMType a) + + writeVkDynamicCount :: Ptr a -> VkDynamicCountMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'dynamicCount'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkDynamicCount a + +class HasVkDynamicStateCount a where + type VkDynamicStateCountMType a :: * + + vkDynamicStateCount :: a -> VkDynamicStateCountMType a + + vkDynamicStateCountByteOffset :: a -> Int + + readVkDynamicStateCount :: Ptr a -> IO (VkDynamicStateCountMType a) + + writeVkDynamicStateCount :: + Ptr a -> VkDynamicStateCountMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'dynamicStateCount'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkDynamicStateCount a + +class HasVkEarliestPresentTime a where + type VkEarliestPresentTimeMType a :: * + + vkEarliestPresentTime :: a -> VkEarliestPresentTimeMType a + + vkEarliestPresentTimeByteOffset :: a -> Int + + readVkEarliestPresentTime :: + Ptr a -> IO (VkEarliestPresentTimeMType a) + + writeVkEarliestPresentTime :: + Ptr a -> VkEarliestPresentTimeMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'earliestPresentTime'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkEarliestPresentTime a + +class HasVkEnabledExtensionCount a where + type VkEnabledExtensionCountMType a :: * + + vkEnabledExtensionCount :: a -> VkEnabledExtensionCountMType a + + vkEnabledExtensionCountByteOffset :: a -> Int + + readVkEnabledExtensionCount :: + Ptr a -> IO (VkEnabledExtensionCountMType a) + + writeVkEnabledExtensionCount :: + Ptr a -> VkEnabledExtensionCountMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'enabledExtensionCount'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkEnabledExtensionCount a + +class HasVkEnabledLayerCount a where + type VkEnabledLayerCountMType a :: * + + vkEnabledLayerCount :: a -> VkEnabledLayerCountMType a + + vkEnabledLayerCountByteOffset :: a -> Int + + readVkEnabledLayerCount :: Ptr a -> IO (VkEnabledLayerCountMType a) + + writeVkEnabledLayerCount :: + Ptr a -> VkEnabledLayerCountMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'enabledLayerCount'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkEnabledLayerCount a + +class HasVkEngineVersion a where + type VkEngineVersionMType a :: * + + vkEngineVersion :: a -> VkEngineVersionMType a + + vkEngineVersionByteOffset :: a -> Int + + readVkEngineVersion :: Ptr a -> IO (VkEngineVersionMType a) + + writeVkEngineVersion :: Ptr a -> VkEngineVersionMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'engineVersion'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkEngineVersion a + +class HasVkExportFromImportedHandleTypes a where + type VkExportFromImportedHandleTypesMType a :: * + + vkExportFromImportedHandleTypes :: + a -> VkExportFromImportedHandleTypesMType a + + vkExportFromImportedHandleTypesByteOffset :: a -> Int + + readVkExportFromImportedHandleTypes :: + Ptr a -> IO (VkExportFromImportedHandleTypesMType a) + + writeVkExportFromImportedHandleTypes :: + Ptr a -> + VkExportFromImportedHandleTypesMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text + " does not seem to have field 'exportFromImportedHandleTypes'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkExportFromImportedHandleTypes a + +class HasVkExtensionNameArray a where + type VkExtensionNameArrayMType a :: * + + vkExtensionNameArray :: a -> Int -> VkExtensionNameArrayMType a + + vkExtensionNameArrayByteOffset :: a -> Int + + readVkExtensionNameArray :: + Ptr a -> Int -> IO (VkExtensionNameArrayMType a) + + writeVkExtensionNameArray :: + Ptr a -> Int -> VkExtensionNameArrayMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'extensionName'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkExtensionNameArray a + +class HasVkExtent a where + type VkExtentMType a :: * + + vkExtent :: a -> VkExtentMType a + + vkExtentByteOffset :: a -> Int + + readVkExtent :: Ptr a -> IO (VkExtentMType a) + + writeVkExtent :: Ptr a -> VkExtentMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'extent'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkExtent a + +class HasVkExternalFenceFeatures a where + type VkExternalFenceFeaturesMType a :: * + + vkExternalFenceFeatures :: a -> VkExternalFenceFeaturesMType a + + vkExternalFenceFeaturesByteOffset :: a -> Int + + readVkExternalFenceFeatures :: + Ptr a -> IO (VkExternalFenceFeaturesMType a) + + writeVkExternalFenceFeatures :: + Ptr a -> VkExternalFenceFeaturesMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'externalFenceFeatures'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkExternalFenceFeatures a + +class HasVkExternalMemoryFeatures a where + type VkExternalMemoryFeaturesMType a :: * + + vkExternalMemoryFeatures :: a -> VkExternalMemoryFeaturesMType a + + vkExternalMemoryFeaturesByteOffset :: a -> Int + + readVkExternalMemoryFeatures :: + Ptr a -> IO (VkExternalMemoryFeaturesMType a) + + writeVkExternalMemoryFeatures :: + Ptr a -> VkExternalMemoryFeaturesMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'externalMemoryFeatures'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkExternalMemoryFeatures a + +class HasVkExternalMemoryProperties a where + type VkExternalMemoryPropertiesMType a :: * + + vkExternalMemoryProperties :: + a -> VkExternalMemoryPropertiesMType a + + vkExternalMemoryPropertiesByteOffset :: a -> Int + + readVkExternalMemoryProperties :: + Ptr a -> IO (VkExternalMemoryPropertiesMType a) + + writeVkExternalMemoryProperties :: + Ptr a -> VkExternalMemoryPropertiesMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'externalMemoryProperties'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkExternalMemoryProperties a + +class HasVkExternalSemaphoreFeatures a where + type VkExternalSemaphoreFeaturesMType a :: * + + vkExternalSemaphoreFeatures :: + a -> VkExternalSemaphoreFeaturesMType a + + vkExternalSemaphoreFeaturesByteOffset :: a -> Int + + readVkExternalSemaphoreFeatures :: + Ptr a -> IO (VkExternalSemaphoreFeaturesMType a) + + writeVkExternalSemaphoreFeatures :: + Ptr a -> VkExternalSemaphoreFeaturesMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'externalSemaphoreFeatures'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkExternalSemaphoreFeatures a + +class HasVkExtraPrimitiveOverestimationSize a where + type VkExtraPrimitiveOverestimationSizeMType a :: * + + vkExtraPrimitiveOverestimationSize :: + a -> VkExtraPrimitiveOverestimationSizeMType a + + vkExtraPrimitiveOverestimationSizeByteOffset :: a -> Int + + readVkExtraPrimitiveOverestimationSize :: + Ptr a -> + IO (VkExtraPrimitiveOverestimationSizeMType a) + + writeVkExtraPrimitiveOverestimationSize :: + Ptr a -> + VkExtraPrimitiveOverestimationSizeMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text + " does not seem to have field 'extraPrimitiveOverestimationSize'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkExtraPrimitiveOverestimationSize a + +class HasVkExtraPrimitiveOverestimationSizeGranularity a where + type VkExtraPrimitiveOverestimationSizeGranularityMType a :: * + + vkExtraPrimitiveOverestimationSizeGranularity :: + a -> + VkExtraPrimitiveOverestimationSizeGranularityMType + a + + vkExtraPrimitiveOverestimationSizeGranularityByteOffset :: a -> Int + + readVkExtraPrimitiveOverestimationSizeGranularity :: + Ptr a -> + IO + (VkExtraPrimitiveOverestimationSizeGranularityMType + a) + + writeVkExtraPrimitiveOverestimationSizeGranularity :: + Ptr a -> + VkExtraPrimitiveOverestimationSizeGranularityMType + a + -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text + " does not seem to have field 'extraPrimitiveOverestimationSizeGranularity'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkExtraPrimitiveOverestimationSizeGranularity a + +class HasVkFailOp a where + type VkFailOpMType a :: * + + vkFailOp :: a -> VkFailOpMType a + + vkFailOpByteOffset :: a -> Int + + readVkFailOp :: Ptr a -> IO (VkFailOpMType a) + + writeVkFailOp :: Ptr a -> VkFailOpMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'failOp'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkFailOp a + +class HasVkFd a where + type VkFdMType a :: * + + vkFd :: a -> VkFdMType a + + vkFdByteOffset :: a -> Int + + readVkFd :: Ptr a -> IO (VkFdMType a) + + writeVkFd :: Ptr a -> VkFdMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'fd'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkFd a + +class HasVkFeatures a where + type VkFeaturesMType a :: * + + vkFeatures :: a -> VkFeaturesMType a + + vkFeaturesByteOffset :: a -> Int + + readVkFeatures :: Ptr a -> IO (VkFeaturesMType a) + + writeVkFeatures :: Ptr a -> VkFeaturesMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'features'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkFeatures a + +class HasVkFence a where + type VkFenceMType a :: * + + vkFence :: a -> VkFenceMType a + + vkFenceByteOffset :: a -> Int + + readVkFence :: Ptr a -> IO (VkFenceMType a) + + writeVkFence :: Ptr a -> VkFenceMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'fence'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkFence a + +class HasVkFillModeNonSolid a where + type VkFillModeNonSolidMType a :: * + + vkFillModeNonSolid :: a -> VkFillModeNonSolidMType a + + vkFillModeNonSolidByteOffset :: a -> Int + + readVkFillModeNonSolid :: Ptr a -> IO (VkFillModeNonSolidMType a) + + writeVkFillModeNonSolid :: + Ptr a -> VkFillModeNonSolidMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'fillModeNonSolid'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkFillModeNonSolid a + +class HasVkFilterMinmaxImageComponentMapping a where + type VkFilterMinmaxImageComponentMappingMType a :: * + + vkFilterMinmaxImageComponentMapping :: + a -> VkFilterMinmaxImageComponentMappingMType a + + vkFilterMinmaxImageComponentMappingByteOffset :: a -> Int + + readVkFilterMinmaxImageComponentMapping :: + Ptr a -> + IO (VkFilterMinmaxImageComponentMappingMType a) + + writeVkFilterMinmaxImageComponentMapping :: + Ptr a -> + VkFilterMinmaxImageComponentMappingMType a -> + IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text + " does not seem to have field 'filterMinmaxImageComponentMapping'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkFilterMinmaxImageComponentMapping a + +class HasVkFilterMinmaxSingleComponentFormats a where + type VkFilterMinmaxSingleComponentFormatsMType a :: * + + vkFilterMinmaxSingleComponentFormats :: + a -> VkFilterMinmaxSingleComponentFormatsMType a + + vkFilterMinmaxSingleComponentFormatsByteOffset :: a -> Int + + readVkFilterMinmaxSingleComponentFormats :: + Ptr a -> + IO (VkFilterMinmaxSingleComponentFormatsMType a) + + writeVkFilterMinmaxSingleComponentFormats :: + Ptr a -> + VkFilterMinmaxSingleComponentFormatsMType a -> + IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text + " does not seem to have field 'filterMinmaxSingleComponentFormats'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkFilterMinmaxSingleComponentFormats a + +class HasVkFinalLayout a where + type VkFinalLayoutMType a :: * + + vkFinalLayout :: a -> VkFinalLayoutMType a + + vkFinalLayoutByteOffset :: a -> Int + + readVkFinalLayout :: Ptr a -> IO (VkFinalLayoutMType a) + + writeVkFinalLayout :: Ptr a -> VkFinalLayoutMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'finalLayout'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkFinalLayout a + +class HasVkFirstIndex a where + type VkFirstIndexMType a :: * + + vkFirstIndex :: a -> VkFirstIndexMType a + + vkFirstIndexByteOffset :: a -> Int + + readVkFirstIndex :: Ptr a -> IO (VkFirstIndexMType a) + + writeVkFirstIndex :: Ptr a -> VkFirstIndexMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'firstIndex'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkFirstIndex a + +class HasVkFirstInstance a where + type VkFirstInstanceMType a :: * + + vkFirstInstance :: a -> VkFirstInstanceMType a + + vkFirstInstanceByteOffset :: a -> Int + + readVkFirstInstance :: Ptr a -> IO (VkFirstInstanceMType a) + + writeVkFirstInstance :: Ptr a -> VkFirstInstanceMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'firstInstance'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkFirstInstance a + +class HasVkFirstVertex a where + type VkFirstVertexMType a :: * + + vkFirstVertex :: a -> VkFirstVertexMType a + + vkFirstVertexByteOffset :: a -> Int + + readVkFirstVertex :: Ptr a -> IO (VkFirstVertexMType a) + + writeVkFirstVertex :: Ptr a -> VkFirstVertexMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'firstVertex'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkFirstVertex a + +class HasVkFlags a where + type VkFlagsMType a :: * + + vkFlags :: a -> VkFlagsMType a + + vkFlagsByteOffset :: a -> Int + + readVkFlags :: Ptr a -> IO (VkFlagsMType a) + + writeVkFlags :: Ptr a -> VkFlagsMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'flags'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkFlags a + +class HasVkFloat32Array a where + type VkFloat32ArrayMType a :: * + + vkFloat32Array :: a -> Int -> VkFloat32ArrayMType a + + vkFloat32ArrayByteOffset :: a -> Int + + readVkFloat32Array :: Ptr a -> Int -> IO (VkFloat32ArrayMType a) + + writeVkFloat32Array :: + Ptr a -> Int -> VkFloat32ArrayMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'float32'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkFloat32Array a + +class HasVkForceExplicitReconstruction a where + type VkForceExplicitReconstructionMType a :: * + + vkForceExplicitReconstruction :: + a -> VkForceExplicitReconstructionMType a + + vkForceExplicitReconstructionByteOffset :: a -> Int + + readVkForceExplicitReconstruction :: + Ptr a -> IO (VkForceExplicitReconstructionMType a) + + writeVkForceExplicitReconstruction :: + Ptr a -> VkForceExplicitReconstructionMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'forceExplicitReconstruction'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkForceExplicitReconstruction a + +class HasVkFormat a where + type VkFormatMType a :: * + + vkFormat :: a -> VkFormatMType a + + vkFormatByteOffset :: a -> Int + + readVkFormat :: Ptr a -> IO (VkFormatMType a) + + writeVkFormat :: Ptr a -> VkFormatMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'format'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkFormat a + +class HasVkFormatProperties a where + type VkFormatPropertiesMType a :: * + + vkFormatProperties :: a -> VkFormatPropertiesMType a + + vkFormatPropertiesByteOffset :: a -> Int + + readVkFormatProperties :: Ptr a -> IO (VkFormatPropertiesMType a) + + writeVkFormatProperties :: + Ptr a -> VkFormatPropertiesMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'formatProperties'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkFormatProperties a + +class HasVkFragmentStoresAndAtomics a where + type VkFragmentStoresAndAtomicsMType a :: * + + vkFragmentStoresAndAtomics :: + a -> VkFragmentStoresAndAtomicsMType a + + vkFragmentStoresAndAtomicsByteOffset :: a -> Int + + readVkFragmentStoresAndAtomics :: + Ptr a -> IO (VkFragmentStoresAndAtomicsMType a) + + writeVkFragmentStoresAndAtomics :: + Ptr a -> VkFragmentStoresAndAtomicsMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'fragmentStoresAndAtomics'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkFragmentStoresAndAtomics a + +class HasVkFramebuffer a where + type VkFramebufferMType a :: * + + vkFramebuffer :: a -> VkFramebufferMType a + + vkFramebufferByteOffset :: a -> Int + + readVkFramebuffer :: Ptr a -> IO (VkFramebufferMType a) + + writeVkFramebuffer :: Ptr a -> VkFramebufferMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'framebuffer'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkFramebuffer a + +class HasVkFramebufferColorSampleCounts a where + type VkFramebufferColorSampleCountsMType a :: * + + vkFramebufferColorSampleCounts :: + a -> VkFramebufferColorSampleCountsMType a + + vkFramebufferColorSampleCountsByteOffset :: a -> Int + + readVkFramebufferColorSampleCounts :: + Ptr a -> IO (VkFramebufferColorSampleCountsMType a) + + writeVkFramebufferColorSampleCounts :: + Ptr a -> VkFramebufferColorSampleCountsMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text + " does not seem to have field 'framebufferColorSampleCounts'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkFramebufferColorSampleCounts a + +class HasVkFramebufferDepthSampleCounts a where + type VkFramebufferDepthSampleCountsMType a :: * + + vkFramebufferDepthSampleCounts :: + a -> VkFramebufferDepthSampleCountsMType a + + vkFramebufferDepthSampleCountsByteOffset :: a -> Int + + readVkFramebufferDepthSampleCounts :: + Ptr a -> IO (VkFramebufferDepthSampleCountsMType a) + + writeVkFramebufferDepthSampleCounts :: + Ptr a -> VkFramebufferDepthSampleCountsMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text + " does not seem to have field 'framebufferDepthSampleCounts'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkFramebufferDepthSampleCounts a + +class HasVkFramebufferNoAttachmentsSampleCounts a where + type VkFramebufferNoAttachmentsSampleCountsMType a :: * + + vkFramebufferNoAttachmentsSampleCounts :: + a -> VkFramebufferNoAttachmentsSampleCountsMType a + + vkFramebufferNoAttachmentsSampleCountsByteOffset :: a -> Int + + readVkFramebufferNoAttachmentsSampleCounts :: + Ptr a -> + IO + (VkFramebufferNoAttachmentsSampleCountsMType + a) + + writeVkFramebufferNoAttachmentsSampleCounts :: + Ptr a -> + VkFramebufferNoAttachmentsSampleCountsMType a + -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text + " does not seem to have field 'framebufferNoAttachmentsSampleCounts'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkFramebufferNoAttachmentsSampleCounts a + +class HasVkFramebufferStencilSampleCounts a where + type VkFramebufferStencilSampleCountsMType a :: * + + vkFramebufferStencilSampleCounts :: + a -> VkFramebufferStencilSampleCountsMType a + + vkFramebufferStencilSampleCountsByteOffset :: a -> Int + + readVkFramebufferStencilSampleCounts :: + Ptr a -> IO (VkFramebufferStencilSampleCountsMType a) + + writeVkFramebufferStencilSampleCounts :: + Ptr a -> + VkFramebufferStencilSampleCountsMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text + " does not seem to have field 'framebufferStencilSampleCounts'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkFramebufferStencilSampleCounts a + +class HasVkFront a where + type VkFrontMType a :: * + + vkFront :: a -> VkFrontMType a + + vkFrontByteOffset :: a -> Int + + readVkFront :: Ptr a -> IO (VkFrontMType a) + + writeVkFront :: Ptr a -> VkFrontMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'front'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkFront a + +class HasVkFrontFace a where + type VkFrontFaceMType a :: * + + vkFrontFace :: a -> VkFrontFaceMType a + + vkFrontFaceByteOffset :: a -> Int + + readVkFrontFace :: Ptr a -> IO (VkFrontFaceMType a) + + writeVkFrontFace :: Ptr a -> VkFrontFaceMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'frontFace'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkFrontFace a + +class HasVkFullDrawIndexUint32 a where + type VkFullDrawIndexUint32MType a :: * + + vkFullDrawIndexUint32 :: a -> VkFullDrawIndexUint32MType a + + vkFullDrawIndexUint32ByteOffset :: a -> Int + + readVkFullDrawIndexUint32 :: + Ptr a -> IO (VkFullDrawIndexUint32MType a) + + writeVkFullDrawIndexUint32 :: + Ptr a -> VkFullDrawIndexUint32MType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'fullDrawIndexUint32'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkFullDrawIndexUint32 a + +class HasVkFullyCoveredFragmentShaderInputVariable a where + type VkFullyCoveredFragmentShaderInputVariableMType a :: * + + vkFullyCoveredFragmentShaderInputVariable :: + a -> + VkFullyCoveredFragmentShaderInputVariableMType a + + vkFullyCoveredFragmentShaderInputVariableByteOffset :: a -> Int + + readVkFullyCoveredFragmentShaderInputVariable :: + Ptr a -> + IO + (VkFullyCoveredFragmentShaderInputVariableMType + a) + + writeVkFullyCoveredFragmentShaderInputVariable :: + Ptr a -> + VkFullyCoveredFragmentShaderInputVariableMType + a + -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text + " does not seem to have field 'fullyCoveredFragmentShaderInputVariable'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkFullyCoveredFragmentShaderInputVariable a + +class HasVkG a where + type VkGMType a :: * + + vkG :: a -> VkGMType a + + vkGByteOffset :: a -> Int + + readVkG :: Ptr a -> IO (VkGMType a) + + writeVkG :: Ptr a -> VkGMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'g'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkG a + +class HasVkGeometryShader a where + type VkGeometryShaderMType a :: * + + vkGeometryShader :: a -> VkGeometryShaderMType a + + vkGeometryShaderByteOffset :: a -> Int + + readVkGeometryShader :: Ptr a -> IO (VkGeometryShaderMType a) + + writeVkGeometryShader :: Ptr a -> VkGeometryShaderMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'geometryShader'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkGeometryShader a + +class HasVkGlobalAlpha a where + type VkGlobalAlphaMType a :: * + + vkGlobalAlpha :: a -> VkGlobalAlphaMType a + + vkGlobalAlphaByteOffset :: a -> Int + + readVkGlobalAlpha :: Ptr a -> IO (VkGlobalAlphaMType a) + + writeVkGlobalAlpha :: Ptr a -> VkGlobalAlphaMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'globalAlpha'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkGlobalAlpha a + +class HasVkGlobalPriority a where + type VkGlobalPriorityMType a :: * + + vkGlobalPriority :: a -> VkGlobalPriorityMType a + + vkGlobalPriorityByteOffset :: a -> Int + + readVkGlobalPriority :: Ptr a -> IO (VkGlobalPriorityMType a) + + writeVkGlobalPriority :: Ptr a -> VkGlobalPriorityMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'globalPriority'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkGlobalPriority a + +class HasVkHandle a where + type VkHandleMType a :: * + + vkHandle :: a -> VkHandleMType a + + vkHandleByteOffset :: a -> Int + + readVkHandle :: Ptr a -> IO (VkHandleMType a) + + writeVkHandle :: Ptr a -> VkHandleMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'handle'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkHandle a + +class HasVkHandleType a where + type VkHandleTypeMType a :: * + + vkHandleType :: a -> VkHandleTypeMType a + + vkHandleTypeByteOffset :: a -> Int + + readVkHandleType :: Ptr a -> IO (VkHandleTypeMType a) + + writeVkHandleType :: Ptr a -> VkHandleTypeMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'handleType'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkHandleType a + +class HasVkHandleTypes a where + type VkHandleTypesMType a :: * + + vkHandleTypes :: a -> VkHandleTypesMType a + + vkHandleTypesByteOffset :: a -> Int + + readVkHandleTypes :: Ptr a -> IO (VkHandleTypesMType a) + + writeVkHandleTypes :: Ptr a -> VkHandleTypesMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'handleTypes'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkHandleTypes a + +class HasVkHeapIndex a where + type VkHeapIndexMType a :: * + + vkHeapIndex :: a -> VkHeapIndexMType a + + vkHeapIndexByteOffset :: a -> Int + + readVkHeapIndex :: Ptr a -> IO (VkHeapIndexMType a) + + writeVkHeapIndex :: Ptr a -> VkHeapIndexMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'heapIndex'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkHeapIndex a + +class HasVkHeight a where + type VkHeightMType a :: * + + vkHeight :: a -> VkHeightMType a + + vkHeightByteOffset :: a -> Int + + readVkHeight :: Ptr a -> IO (VkHeightMType a) + + writeVkHeight :: Ptr a -> VkHeightMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'height'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkHeight a + +class HasVkHinstance a where + type VkHinstanceMType a :: * + + vkHinstance :: a -> VkHinstanceMType a + + vkHinstanceByteOffset :: a -> Int + + readVkHinstance :: Ptr a -> IO (VkHinstanceMType a) + + writeVkHinstance :: Ptr a -> VkHinstanceMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'hinstance'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkHinstance a + +class HasVkHwnd a where + type VkHwndMType a :: * + + vkHwnd :: a -> VkHwndMType a + + vkHwndByteOffset :: a -> Int + + readVkHwnd :: Ptr a -> IO (VkHwndMType a) + + writeVkHwnd :: Ptr a -> VkHwndMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'hwnd'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkHwnd a + +class HasVkImage a where + type VkImageMType a :: * + + vkImage :: a -> VkImageMType a + + vkImageByteOffset :: a -> Int + + readVkImage :: Ptr a -> IO (VkImageMType a) + + writeVkImage :: Ptr a -> VkImageMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'image'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkImage a + +class HasVkImageArrayLayers a where + type VkImageArrayLayersMType a :: * + + vkImageArrayLayers :: a -> VkImageArrayLayersMType a + + vkImageArrayLayersByteOffset :: a -> Int + + readVkImageArrayLayers :: Ptr a -> IO (VkImageArrayLayersMType a) + + writeVkImageArrayLayers :: + Ptr a -> VkImageArrayLayersMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'imageArrayLayers'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkImageArrayLayers a + +class HasVkImageBindCount a where + type VkImageBindCountMType a :: * + + vkImageBindCount :: a -> VkImageBindCountMType a + + vkImageBindCountByteOffset :: a -> Int + + readVkImageBindCount :: Ptr a -> IO (VkImageBindCountMType a) + + writeVkImageBindCount :: Ptr a -> VkImageBindCountMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'imageBindCount'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkImageBindCount a + +class HasVkImageColorSpace a where + type VkImageColorSpaceMType a :: * + + vkImageColorSpace :: a -> VkImageColorSpaceMType a + + vkImageColorSpaceByteOffset :: a -> Int + + readVkImageColorSpace :: Ptr a -> IO (VkImageColorSpaceMType a) + + writeVkImageColorSpace :: + Ptr a -> VkImageColorSpaceMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'imageColorSpace'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkImageColorSpace a + +class HasVkImageCubeArray a where + type VkImageCubeArrayMType a :: * + + vkImageCubeArray :: a -> VkImageCubeArrayMType a + + vkImageCubeArrayByteOffset :: a -> Int + + readVkImageCubeArray :: Ptr a -> IO (VkImageCubeArrayMType a) + + writeVkImageCubeArray :: Ptr a -> VkImageCubeArrayMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'imageCubeArray'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkImageCubeArray a + +class HasVkImageExtent a where + type VkImageExtentMType a :: * + + vkImageExtent :: a -> VkImageExtentMType a + + vkImageExtentByteOffset :: a -> Int + + readVkImageExtent :: Ptr a -> IO (VkImageExtentMType a) + + writeVkImageExtent :: Ptr a -> VkImageExtentMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'imageExtent'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkImageExtent a + +class HasVkImageFormat a where + type VkImageFormatMType a :: * + + vkImageFormat :: a -> VkImageFormatMType a + + vkImageFormatByteOffset :: a -> Int + + readVkImageFormat :: Ptr a -> IO (VkImageFormatMType a) + + writeVkImageFormat :: Ptr a -> VkImageFormatMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'imageFormat'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkImageFormat a + +class HasVkImageFormatProperties a where + type VkImageFormatPropertiesMType a :: * + + vkImageFormatProperties :: a -> VkImageFormatPropertiesMType a + + vkImageFormatPropertiesByteOffset :: a -> Int + + readVkImageFormatProperties :: + Ptr a -> IO (VkImageFormatPropertiesMType a) + + writeVkImageFormatProperties :: + Ptr a -> VkImageFormatPropertiesMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'imageFormatProperties'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkImageFormatProperties a + +class HasVkImageGranularity a where + type VkImageGranularityMType a :: * + + vkImageGranularity :: a -> VkImageGranularityMType a + + vkImageGranularityByteOffset :: a -> Int + + readVkImageGranularity :: Ptr a -> IO (VkImageGranularityMType a) + + writeVkImageGranularity :: + Ptr a -> VkImageGranularityMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'imageGranularity'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkImageGranularity a + +class HasVkImageIndex a where + type VkImageIndexMType a :: * + + vkImageIndex :: a -> VkImageIndexMType a + + vkImageIndexByteOffset :: a -> Int + + readVkImageIndex :: Ptr a -> IO (VkImageIndexMType a) + + writeVkImageIndex :: Ptr a -> VkImageIndexMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'imageIndex'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkImageIndex a + +class HasVkImageLayout a where + type VkImageLayoutMType a :: * + + vkImageLayout :: a -> VkImageLayoutMType a + + vkImageLayoutByteOffset :: a -> Int + + readVkImageLayout :: Ptr a -> IO (VkImageLayoutMType a) + + writeVkImageLayout :: Ptr a -> VkImageLayoutMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'imageLayout'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkImageLayout a + +class HasVkImageMipTailFirstLod a where + type VkImageMipTailFirstLodMType a :: * + + vkImageMipTailFirstLod :: a -> VkImageMipTailFirstLodMType a + + vkImageMipTailFirstLodByteOffset :: a -> Int + + readVkImageMipTailFirstLod :: + Ptr a -> IO (VkImageMipTailFirstLodMType a) + + writeVkImageMipTailFirstLod :: + Ptr a -> VkImageMipTailFirstLodMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'imageMipTailFirstLod'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkImageMipTailFirstLod a + +class HasVkImageMipTailOffset a where + type VkImageMipTailOffsetMType a :: * + + vkImageMipTailOffset :: a -> VkImageMipTailOffsetMType a + + vkImageMipTailOffsetByteOffset :: a -> Int + + readVkImageMipTailOffset :: + Ptr a -> IO (VkImageMipTailOffsetMType a) + + writeVkImageMipTailOffset :: + Ptr a -> VkImageMipTailOffsetMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'imageMipTailOffset'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkImageMipTailOffset a + +class HasVkImageMipTailSize a where + type VkImageMipTailSizeMType a :: * + + vkImageMipTailSize :: a -> VkImageMipTailSizeMType a + + vkImageMipTailSizeByteOffset :: a -> Int + + readVkImageMipTailSize :: Ptr a -> IO (VkImageMipTailSizeMType a) + + writeVkImageMipTailSize :: + Ptr a -> VkImageMipTailSizeMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'imageMipTailSize'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkImageMipTailSize a + +class HasVkImageMipTailStride a where + type VkImageMipTailStrideMType a :: * + + vkImageMipTailStride :: a -> VkImageMipTailStrideMType a + + vkImageMipTailStrideByteOffset :: a -> Int + + readVkImageMipTailStride :: + Ptr a -> IO (VkImageMipTailStrideMType a) + + writeVkImageMipTailStride :: + Ptr a -> VkImageMipTailStrideMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'imageMipTailStride'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkImageMipTailStride a + +class HasVkImageOffset a where + type VkImageOffsetMType a :: * + + vkImageOffset :: a -> VkImageOffsetMType a + + vkImageOffsetByteOffset :: a -> Int + + readVkImageOffset :: Ptr a -> IO (VkImageOffsetMType a) + + writeVkImageOffset :: Ptr a -> VkImageOffsetMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'imageOffset'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkImageOffset a + +class HasVkImageOpaqueBindCount a where + type VkImageOpaqueBindCountMType a :: * + + vkImageOpaqueBindCount :: a -> VkImageOpaqueBindCountMType a + + vkImageOpaqueBindCountByteOffset :: a -> Int + + readVkImageOpaqueBindCount :: + Ptr a -> IO (VkImageOpaqueBindCountMType a) + + writeVkImageOpaqueBindCount :: + Ptr a -> VkImageOpaqueBindCountMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'imageOpaqueBindCount'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkImageOpaqueBindCount a + +class HasVkImageSharingMode a where + type VkImageSharingModeMType a :: * + + vkImageSharingMode :: a -> VkImageSharingModeMType a + + vkImageSharingModeByteOffset :: a -> Int + + readVkImageSharingMode :: Ptr a -> IO (VkImageSharingModeMType a) + + writeVkImageSharingMode :: + Ptr a -> VkImageSharingModeMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'imageSharingMode'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkImageSharingMode a + +class HasVkImageSubresource a where + type VkImageSubresourceMType a :: * + + vkImageSubresource :: a -> VkImageSubresourceMType a + + vkImageSubresourceByteOffset :: a -> Int + + readVkImageSubresource :: Ptr a -> IO (VkImageSubresourceMType a) + + writeVkImageSubresource :: + Ptr a -> VkImageSubresourceMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'imageSubresource'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkImageSubresource a + +class HasVkImageType a where + type VkImageTypeMType a :: * + + vkImageType :: a -> VkImageTypeMType a + + vkImageTypeByteOffset :: a -> Int + + readVkImageType :: Ptr a -> IO (VkImageTypeMType a) + + writeVkImageType :: Ptr a -> VkImageTypeMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'imageType'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkImageType a + +class HasVkImageUsage a where + type VkImageUsageMType a :: * + + vkImageUsage :: a -> VkImageUsageMType a + + vkImageUsageByteOffset :: a -> Int + + readVkImageUsage :: Ptr a -> IO (VkImageUsageMType a) + + writeVkImageUsage :: Ptr a -> VkImageUsageMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'imageUsage'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkImageUsage a + +class HasVkImageView a where + type VkImageViewMType a :: * + + vkImageView :: a -> VkImageViewMType a + + vkImageViewByteOffset :: a -> Int + + readVkImageView :: Ptr a -> IO (VkImageViewMType a) + + writeVkImageView :: Ptr a -> VkImageViewMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'imageView'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkImageView a + +class HasVkImplementationVersion a where + type VkImplementationVersionMType a :: * + + vkImplementationVersion :: a -> VkImplementationVersionMType a + + vkImplementationVersionByteOffset :: a -> Int + + readVkImplementationVersion :: + Ptr a -> IO (VkImplementationVersionMType a) + + writeVkImplementationVersion :: + Ptr a -> VkImplementationVersionMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'implementationVersion'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkImplementationVersion a + +class HasVkIndependentBlend a where + type VkIndependentBlendMType a :: * + + vkIndependentBlend :: a -> VkIndependentBlendMType a + + vkIndependentBlendByteOffset :: a -> Int + + readVkIndependentBlend :: Ptr a -> IO (VkIndependentBlendMType a) + + writeVkIndependentBlend :: + Ptr a -> VkIndependentBlendMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'independentBlend'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkIndependentBlend a + +class HasVkIndexCount a where + type VkIndexCountMType a :: * + + vkIndexCount :: a -> VkIndexCountMType a + + vkIndexCountByteOffset :: a -> Int + + readVkIndexCount :: Ptr a -> IO (VkIndexCountMType a) + + writeVkIndexCount :: Ptr a -> VkIndexCountMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'indexCount'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkIndexCount a + +class HasVkIndexType a where + type VkIndexTypeMType a :: * + + vkIndexType :: a -> VkIndexTypeMType a + + vkIndexTypeByteOffset :: a -> Int + + readVkIndexType :: Ptr a -> IO (VkIndexTypeMType a) + + writeVkIndexType :: Ptr a -> VkIndexTypeMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'indexType'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkIndexType a + +class HasVkIndirectCommandsLayout a where + type VkIndirectCommandsLayoutMType a :: * + + vkIndirectCommandsLayout :: a -> VkIndirectCommandsLayoutMType a + + vkIndirectCommandsLayoutByteOffset :: a -> Int + + readVkIndirectCommandsLayout :: + Ptr a -> IO (VkIndirectCommandsLayoutMType a) + + writeVkIndirectCommandsLayout :: + Ptr a -> VkIndirectCommandsLayoutMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'indirectCommandsLayout'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkIndirectCommandsLayout a + +class HasVkIndirectCommandsTokenCount a where + type VkIndirectCommandsTokenCountMType a :: * + + vkIndirectCommandsTokenCount :: + a -> VkIndirectCommandsTokenCountMType a + + vkIndirectCommandsTokenCountByteOffset :: a -> Int + + readVkIndirectCommandsTokenCount :: + Ptr a -> IO (VkIndirectCommandsTokenCountMType a) + + writeVkIndirectCommandsTokenCount :: + Ptr a -> VkIndirectCommandsTokenCountMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'indirectCommandsTokenCount'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkIndirectCommandsTokenCount a + +class HasVkInheritedQueries a where + type VkInheritedQueriesMType a :: * + + vkInheritedQueries :: a -> VkInheritedQueriesMType a + + vkInheritedQueriesByteOffset :: a -> Int + + readVkInheritedQueries :: Ptr a -> IO (VkInheritedQueriesMType a) + + writeVkInheritedQueries :: + Ptr a -> VkInheritedQueriesMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'inheritedQueries'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkInheritedQueries a + +class HasVkInitialDataSize a where + type VkInitialDataSizeMType a :: * + + vkInitialDataSize :: a -> VkInitialDataSizeMType a + + vkInitialDataSizeByteOffset :: a -> Int + + readVkInitialDataSize :: Ptr a -> IO (VkInitialDataSizeMType a) + + writeVkInitialDataSize :: + Ptr a -> VkInitialDataSizeMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'initialDataSize'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkInitialDataSize a + +class HasVkInitialLayout a where + type VkInitialLayoutMType a :: * + + vkInitialLayout :: a -> VkInitialLayoutMType a + + vkInitialLayoutByteOffset :: a -> Int + + readVkInitialLayout :: Ptr a -> IO (VkInitialLayoutMType a) + + writeVkInitialLayout :: Ptr a -> VkInitialLayoutMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'initialLayout'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkInitialLayout a + +class HasVkInputAttachmentCount a where + type VkInputAttachmentCountMType a :: * + + vkInputAttachmentCount :: a -> VkInputAttachmentCountMType a + + vkInputAttachmentCountByteOffset :: a -> Int + + readVkInputAttachmentCount :: + Ptr a -> IO (VkInputAttachmentCountMType a) + + writeVkInputAttachmentCount :: + Ptr a -> VkInputAttachmentCountMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'inputAttachmentCount'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkInputAttachmentCount a + +class HasVkInputAttachmentIndex a where + type VkInputAttachmentIndexMType a :: * + + vkInputAttachmentIndex :: a -> VkInputAttachmentIndexMType a + + vkInputAttachmentIndexByteOffset :: a -> Int + + readVkInputAttachmentIndex :: + Ptr a -> IO (VkInputAttachmentIndexMType a) + + writeVkInputAttachmentIndex :: + Ptr a -> VkInputAttachmentIndexMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'inputAttachmentIndex'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkInputAttachmentIndex a + +class HasVkInputRate a where + type VkInputRateMType a :: * + + vkInputRate :: a -> VkInputRateMType a + + vkInputRateByteOffset :: a -> Int + + readVkInputRate :: Ptr a -> IO (VkInputRateMType a) + + writeVkInputRate :: Ptr a -> VkInputRateMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'inputRate'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkInputRate a + +class HasVkInstanceCount a where + type VkInstanceCountMType a :: * + + vkInstanceCount :: a -> VkInstanceCountMType a + + vkInstanceCountByteOffset :: a -> Int + + readVkInstanceCount :: Ptr a -> IO (VkInstanceCountMType a) + + writeVkInstanceCount :: Ptr a -> VkInstanceCountMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'instanceCount'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkInstanceCount a + +class HasVkInt32Array a where + type VkInt32ArrayMType a :: * + + vkInt32Array :: a -> Int -> VkInt32ArrayMType a + + vkInt32ArrayByteOffset :: a -> Int + + readVkInt32Array :: Ptr a -> Int -> IO (VkInt32ArrayMType a) + + writeVkInt32Array :: Ptr a -> Int -> VkInt32ArrayMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'int32'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkInt32Array a + +class HasVkLargePoints a where + type VkLargePointsMType a :: * + + vkLargePoints :: a -> VkLargePointsMType a + + vkLargePointsByteOffset :: a -> Int + + readVkLargePoints :: Ptr a -> IO (VkLargePointsMType a) + + writeVkLargePoints :: Ptr a -> VkLargePointsMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'largePoints'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkLargePoints a + +class HasVkLayer a where + type VkLayerMType a :: * + + vkLayer :: a -> VkLayerMType a + + vkLayerByteOffset :: a -> Int + + readVkLayer :: Ptr a -> IO (VkLayerMType a) + + writeVkLayer :: Ptr a -> VkLayerMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'layer'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkLayer a + +class HasVkLayerCount a where + type VkLayerCountMType a :: * + + vkLayerCount :: a -> VkLayerCountMType a + + vkLayerCountByteOffset :: a -> Int + + readVkLayerCount :: Ptr a -> IO (VkLayerCountMType a) + + writeVkLayerCount :: Ptr a -> VkLayerCountMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'layerCount'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkLayerCount a + +class HasVkLayerNameArray a where + type VkLayerNameArrayMType a :: * + + vkLayerNameArray :: a -> Int -> VkLayerNameArrayMType a + + vkLayerNameArrayByteOffset :: a -> Int + + readVkLayerNameArray :: + Ptr a -> Int -> IO (VkLayerNameArrayMType a) + + writeVkLayerNameArray :: + Ptr a -> Int -> VkLayerNameArrayMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'layerName'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkLayerNameArray a + +class HasVkLayers a where + type VkLayersMType a :: * + + vkLayers :: a -> VkLayersMType a + + vkLayersByteOffset :: a -> Int + + readVkLayers :: Ptr a -> IO (VkLayersMType a) + + writeVkLayers :: Ptr a -> VkLayersMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'layers'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkLayers a + +class HasVkLayout a where + type VkLayoutMType a :: * + + vkLayout :: a -> VkLayoutMType a + + vkLayoutByteOffset :: a -> Int + + readVkLayout :: Ptr a -> IO (VkLayoutMType a) + + writeVkLayout :: Ptr a -> VkLayoutMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'layout'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkLayout a + +class HasVkLdsSizePerLocalWorkGroup a where + type VkLdsSizePerLocalWorkGroupMType a :: * + + vkLdsSizePerLocalWorkGroup :: + a -> VkLdsSizePerLocalWorkGroupMType a + + vkLdsSizePerLocalWorkGroupByteOffset :: a -> Int + + readVkLdsSizePerLocalWorkGroup :: + Ptr a -> IO (VkLdsSizePerLocalWorkGroupMType a) + + writeVkLdsSizePerLocalWorkGroup :: + Ptr a -> VkLdsSizePerLocalWorkGroupMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'ldsSizePerLocalWorkGroup'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkLdsSizePerLocalWorkGroup a + +class HasVkLdsUsageSizeInBytes a where + type VkLdsUsageSizeInBytesMType a :: * + + vkLdsUsageSizeInBytes :: a -> VkLdsUsageSizeInBytesMType a + + vkLdsUsageSizeInBytesByteOffset :: a -> Int + + readVkLdsUsageSizeInBytes :: + Ptr a -> IO (VkLdsUsageSizeInBytesMType a) + + writeVkLdsUsageSizeInBytes :: + Ptr a -> VkLdsUsageSizeInBytesMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'ldsUsageSizeInBytes'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkLdsUsageSizeInBytes a + +class HasVkLevel a where + type VkLevelMType a :: * + + vkLevel :: a -> VkLevelMType a + + vkLevelByteOffset :: a -> Int + + readVkLevel :: Ptr a -> IO (VkLevelMType a) + + writeVkLevel :: Ptr a -> VkLevelMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'level'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkLevel a + +class HasVkLevelCount a where + type VkLevelCountMType a :: * + + vkLevelCount :: a -> VkLevelCountMType a + + vkLevelCountByteOffset :: a -> Int + + readVkLevelCount :: Ptr a -> IO (VkLevelCountMType a) + + writeVkLevelCount :: Ptr a -> VkLevelCountMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'levelCount'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkLevelCount a + +class HasVkLimits a where + type VkLimitsMType a :: * + + vkLimits :: a -> VkLimitsMType a + + vkLimitsByteOffset :: a -> Int + + readVkLimits :: Ptr a -> IO (VkLimitsMType a) + + writeVkLimits :: Ptr a -> VkLimitsMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'limits'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkLimits a + +class HasVkLineWidth a where + type VkLineWidthMType a :: * + + vkLineWidth :: a -> VkLineWidthMType a + + vkLineWidthByteOffset :: a -> Int + + readVkLineWidth :: Ptr a -> IO (VkLineWidthMType a) + + writeVkLineWidth :: Ptr a -> VkLineWidthMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'lineWidth'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkLineWidth a + +class HasVkLineWidthGranularity a where + type VkLineWidthGranularityMType a :: * + + vkLineWidthGranularity :: a -> VkLineWidthGranularityMType a + + vkLineWidthGranularityByteOffset :: a -> Int + + readVkLineWidthGranularity :: + Ptr a -> IO (VkLineWidthGranularityMType a) + + writeVkLineWidthGranularity :: + Ptr a -> VkLineWidthGranularityMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'lineWidthGranularity'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkLineWidthGranularity a + +class HasVkLineWidthRangeArray a where + type VkLineWidthRangeArrayMType a :: * + + vkLineWidthRangeArray :: a -> Int -> VkLineWidthRangeArrayMType a + + vkLineWidthRangeArrayByteOffset :: a -> Int + + readVkLineWidthRangeArray :: + Ptr a -> Int -> IO (VkLineWidthRangeArrayMType a) + + writeVkLineWidthRangeArray :: + Ptr a -> Int -> VkLineWidthRangeArrayMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'lineWidthRange'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkLineWidthRangeArray a + +class HasVkLinearTilingFeatures a where + type VkLinearTilingFeaturesMType a :: * + + vkLinearTilingFeatures :: a -> VkLinearTilingFeaturesMType a + + vkLinearTilingFeaturesByteOffset :: a -> Int + + readVkLinearTilingFeatures :: + Ptr a -> IO (VkLinearTilingFeaturesMType a) + + writeVkLinearTilingFeatures :: + Ptr a -> VkLinearTilingFeaturesMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'linearTilingFeatures'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkLinearTilingFeatures a + +class HasVkLoadOp a where + type VkLoadOpMType a :: * + + vkLoadOp :: a -> VkLoadOpMType a + + vkLoadOpByteOffset :: a -> Int + + readVkLoadOp :: Ptr a -> IO (VkLoadOpMType a) + + writeVkLoadOp :: Ptr a -> VkLoadOpMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'loadOp'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkLoadOp a + +class HasVkLocation a where + type VkLocationMType a :: * + + vkLocation :: a -> VkLocationMType a + + vkLocationByteOffset :: a -> Int + + readVkLocation :: Ptr a -> IO (VkLocationMType a) + + writeVkLocation :: Ptr a -> VkLocationMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'location'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkLocation a + +class HasVkLogicOp a where + type VkLogicOpMType a :: * + + vkLogicOp :: a -> VkLogicOpMType a + + vkLogicOpByteOffset :: a -> Int + + readVkLogicOp :: Ptr a -> IO (VkLogicOpMType a) + + writeVkLogicOp :: Ptr a -> VkLogicOpMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'logicOp'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkLogicOp a + +class HasVkLogicOpEnable a where + type VkLogicOpEnableMType a :: * + + vkLogicOpEnable :: a -> VkLogicOpEnableMType a + + vkLogicOpEnableByteOffset :: a -> Int + + readVkLogicOpEnable :: Ptr a -> IO (VkLogicOpEnableMType a) + + writeVkLogicOpEnable :: Ptr a -> VkLogicOpEnableMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'logicOpEnable'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkLogicOpEnable a + +class HasVkMagFilter a where + type VkMagFilterMType a :: * + + vkMagFilter :: a -> VkMagFilterMType a + + vkMagFilterByteOffset :: a -> Int + + readVkMagFilter :: Ptr a -> IO (VkMagFilterMType a) + + writeVkMagFilter :: Ptr a -> VkMagFilterMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'magFilter'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMagFilter a + +class HasVkMapEntryCount a where + type VkMapEntryCountMType a :: * + + vkMapEntryCount :: a -> VkMapEntryCountMType a + + vkMapEntryCountByteOffset :: a -> Int + + readVkMapEntryCount :: Ptr a -> IO (VkMapEntryCountMType a) + + writeVkMapEntryCount :: Ptr a -> VkMapEntryCountMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'mapEntryCount'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMapEntryCount a + +class HasVkMaxAnisotropy a where + type VkMaxAnisotropyMType a :: * + + vkMaxAnisotropy :: a -> VkMaxAnisotropyMType a + + vkMaxAnisotropyByteOffset :: a -> Int + + readVkMaxAnisotropy :: Ptr a -> IO (VkMaxAnisotropyMType a) + + writeVkMaxAnisotropy :: Ptr a -> VkMaxAnisotropyMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'maxAnisotropy'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMaxAnisotropy a + +class HasVkMaxArrayLayers a where + type VkMaxArrayLayersMType a :: * + + vkMaxArrayLayers :: a -> VkMaxArrayLayersMType a + + vkMaxArrayLayersByteOffset :: a -> Int + + readVkMaxArrayLayers :: Ptr a -> IO (VkMaxArrayLayersMType a) + + writeVkMaxArrayLayers :: Ptr a -> VkMaxArrayLayersMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'maxArrayLayers'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMaxArrayLayers a + +class HasVkMaxBoundDescriptorSets a where + type VkMaxBoundDescriptorSetsMType a :: * + + vkMaxBoundDescriptorSets :: a -> VkMaxBoundDescriptorSetsMType a + + vkMaxBoundDescriptorSetsByteOffset :: a -> Int + + readVkMaxBoundDescriptorSets :: + Ptr a -> IO (VkMaxBoundDescriptorSetsMType a) + + writeVkMaxBoundDescriptorSets :: + Ptr a -> VkMaxBoundDescriptorSetsMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'maxBoundDescriptorSets'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMaxBoundDescriptorSets a + +class HasVkMaxClipDistances a where + type VkMaxClipDistancesMType a :: * + + vkMaxClipDistances :: a -> VkMaxClipDistancesMType a + + vkMaxClipDistancesByteOffset :: a -> Int + + readVkMaxClipDistances :: Ptr a -> IO (VkMaxClipDistancesMType a) + + writeVkMaxClipDistances :: + Ptr a -> VkMaxClipDistancesMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'maxClipDistances'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMaxClipDistances a + +class HasVkMaxColorAttachments a where + type VkMaxColorAttachmentsMType a :: * + + vkMaxColorAttachments :: a -> VkMaxColorAttachmentsMType a + + vkMaxColorAttachmentsByteOffset :: a -> Int + + readVkMaxColorAttachments :: + Ptr a -> IO (VkMaxColorAttachmentsMType a) + + writeVkMaxColorAttachments :: + Ptr a -> VkMaxColorAttachmentsMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'maxColorAttachments'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMaxColorAttachments a + +class HasVkMaxCombinedClipAndCullDistances a where + type VkMaxCombinedClipAndCullDistancesMType a :: * + + vkMaxCombinedClipAndCullDistances :: + a -> VkMaxCombinedClipAndCullDistancesMType a + + vkMaxCombinedClipAndCullDistancesByteOffset :: a -> Int + + readVkMaxCombinedClipAndCullDistances :: + Ptr a -> IO (VkMaxCombinedClipAndCullDistancesMType a) + + writeVkMaxCombinedClipAndCullDistances :: + Ptr a -> + VkMaxCombinedClipAndCullDistancesMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text + " does not seem to have field 'maxCombinedClipAndCullDistances'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMaxCombinedClipAndCullDistances a + +class HasVkMaxComputeSharedMemorySize a where + type VkMaxComputeSharedMemorySizeMType a :: * + + vkMaxComputeSharedMemorySize :: + a -> VkMaxComputeSharedMemorySizeMType a + + vkMaxComputeSharedMemorySizeByteOffset :: a -> Int + + readVkMaxComputeSharedMemorySize :: + Ptr a -> IO (VkMaxComputeSharedMemorySizeMType a) + + writeVkMaxComputeSharedMemorySize :: + Ptr a -> VkMaxComputeSharedMemorySizeMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'maxComputeSharedMemorySize'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMaxComputeSharedMemorySize a + +class HasVkMaxComputeWorkGroupCountArray a where + type VkMaxComputeWorkGroupCountArrayMType a :: * + + vkMaxComputeWorkGroupCountArray :: + a -> Int -> VkMaxComputeWorkGroupCountArrayMType a + + vkMaxComputeWorkGroupCountArrayByteOffset :: a -> Int + + readVkMaxComputeWorkGroupCountArray :: + Ptr a -> + Int -> IO (VkMaxComputeWorkGroupCountArrayMType a) + + writeVkMaxComputeWorkGroupCountArray :: + Ptr a -> + Int -> + VkMaxComputeWorkGroupCountArrayMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'maxComputeWorkGroupCount'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMaxComputeWorkGroupCountArray a + +class HasVkMaxComputeWorkGroupInvocations a where + type VkMaxComputeWorkGroupInvocationsMType a :: * + + vkMaxComputeWorkGroupInvocations :: + a -> VkMaxComputeWorkGroupInvocationsMType a + + vkMaxComputeWorkGroupInvocationsByteOffset :: a -> Int + + readVkMaxComputeWorkGroupInvocations :: + Ptr a -> IO (VkMaxComputeWorkGroupInvocationsMType a) + + writeVkMaxComputeWorkGroupInvocations :: + Ptr a -> + VkMaxComputeWorkGroupInvocationsMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text + " does not seem to have field 'maxComputeWorkGroupInvocations'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMaxComputeWorkGroupInvocations a + +class HasVkMaxComputeWorkGroupSizeArray a where + type VkMaxComputeWorkGroupSizeArrayMType a :: * + + vkMaxComputeWorkGroupSizeArray :: + a -> Int -> VkMaxComputeWorkGroupSizeArrayMType a + + vkMaxComputeWorkGroupSizeArrayByteOffset :: a -> Int + + readVkMaxComputeWorkGroupSizeArray :: + Ptr a -> + Int -> IO (VkMaxComputeWorkGroupSizeArrayMType a) + + writeVkMaxComputeWorkGroupSizeArray :: + Ptr a -> + Int -> VkMaxComputeWorkGroupSizeArrayMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'maxComputeWorkGroupSize'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMaxComputeWorkGroupSizeArray a + +class HasVkMaxContentLightLevel a where + type VkMaxContentLightLevelMType a :: * + + vkMaxContentLightLevel :: a -> VkMaxContentLightLevelMType a + + vkMaxContentLightLevelByteOffset :: a -> Int + + readVkMaxContentLightLevel :: + Ptr a -> IO (VkMaxContentLightLevelMType a) + + writeVkMaxContentLightLevel :: + Ptr a -> VkMaxContentLightLevelMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'maxContentLightLevel'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMaxContentLightLevel a + +class HasVkMaxCullDistances a where + type VkMaxCullDistancesMType a :: * + + vkMaxCullDistances :: a -> VkMaxCullDistancesMType a + + vkMaxCullDistancesByteOffset :: a -> Int + + readVkMaxCullDistances :: Ptr a -> IO (VkMaxCullDistancesMType a) + + writeVkMaxCullDistances :: + Ptr a -> VkMaxCullDistancesMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'maxCullDistances'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMaxCullDistances a + +class HasVkMaxDepth a where + type VkMaxDepthMType a :: * + + vkMaxDepth :: a -> VkMaxDepthMType a + + vkMaxDepthByteOffset :: a -> Int + + readVkMaxDepth :: Ptr a -> IO (VkMaxDepthMType a) + + writeVkMaxDepth :: Ptr a -> VkMaxDepthMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'maxDepth'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMaxDepth a + +class HasVkMaxDepthBounds a where + type VkMaxDepthBoundsMType a :: * + + vkMaxDepthBounds :: a -> VkMaxDepthBoundsMType a + + vkMaxDepthBoundsByteOffset :: a -> Int + + readVkMaxDepthBounds :: Ptr a -> IO (VkMaxDepthBoundsMType a) + + writeVkMaxDepthBounds :: Ptr a -> VkMaxDepthBoundsMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'maxDepthBounds'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMaxDepthBounds a + +class HasVkMaxDescriptorSetInputAttachments a where + type VkMaxDescriptorSetInputAttachmentsMType a :: * + + vkMaxDescriptorSetInputAttachments :: + a -> VkMaxDescriptorSetInputAttachmentsMType a + + vkMaxDescriptorSetInputAttachmentsByteOffset :: a -> Int + + readVkMaxDescriptorSetInputAttachments :: + Ptr a -> + IO (VkMaxDescriptorSetInputAttachmentsMType a) + + writeVkMaxDescriptorSetInputAttachments :: + Ptr a -> + VkMaxDescriptorSetInputAttachmentsMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text + " does not seem to have field 'maxDescriptorSetInputAttachments'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMaxDescriptorSetInputAttachments a + +class HasVkMaxDescriptorSetSampledImages a where + type VkMaxDescriptorSetSampledImagesMType a :: * + + vkMaxDescriptorSetSampledImages :: + a -> VkMaxDescriptorSetSampledImagesMType a + + vkMaxDescriptorSetSampledImagesByteOffset :: a -> Int + + readVkMaxDescriptorSetSampledImages :: + Ptr a -> IO (VkMaxDescriptorSetSampledImagesMType a) + + writeVkMaxDescriptorSetSampledImages :: + Ptr a -> + VkMaxDescriptorSetSampledImagesMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text + " does not seem to have field 'maxDescriptorSetSampledImages'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMaxDescriptorSetSampledImages a + +class HasVkMaxDescriptorSetSamplers a where + type VkMaxDescriptorSetSamplersMType a :: * + + vkMaxDescriptorSetSamplers :: + a -> VkMaxDescriptorSetSamplersMType a + + vkMaxDescriptorSetSamplersByteOffset :: a -> Int + + readVkMaxDescriptorSetSamplers :: + Ptr a -> IO (VkMaxDescriptorSetSamplersMType a) + + writeVkMaxDescriptorSetSamplers :: + Ptr a -> VkMaxDescriptorSetSamplersMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'maxDescriptorSetSamplers'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMaxDescriptorSetSamplers a + +class HasVkMaxDescriptorSetStorageBuffers a where + type VkMaxDescriptorSetStorageBuffersMType a :: * + + vkMaxDescriptorSetStorageBuffers :: + a -> VkMaxDescriptorSetStorageBuffersMType a + + vkMaxDescriptorSetStorageBuffersByteOffset :: a -> Int + + readVkMaxDescriptorSetStorageBuffers :: + Ptr a -> IO (VkMaxDescriptorSetStorageBuffersMType a) + + writeVkMaxDescriptorSetStorageBuffers :: + Ptr a -> + VkMaxDescriptorSetStorageBuffersMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text + " does not seem to have field 'maxDescriptorSetStorageBuffers'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMaxDescriptorSetStorageBuffers a + +class HasVkMaxDescriptorSetStorageBuffersDynamic a where + type VkMaxDescriptorSetStorageBuffersDynamicMType a :: * + + vkMaxDescriptorSetStorageBuffersDynamic :: + a -> VkMaxDescriptorSetStorageBuffersDynamicMType a + + vkMaxDescriptorSetStorageBuffersDynamicByteOffset :: a -> Int + + readVkMaxDescriptorSetStorageBuffersDynamic :: + Ptr a -> + IO + (VkMaxDescriptorSetStorageBuffersDynamicMType + a) + + writeVkMaxDescriptorSetStorageBuffersDynamic :: + Ptr a -> + VkMaxDescriptorSetStorageBuffersDynamicMType + a + -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text + " does not seem to have field 'maxDescriptorSetStorageBuffersDynamic'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMaxDescriptorSetStorageBuffersDynamic a + +class HasVkMaxDescriptorSetStorageImages a where + type VkMaxDescriptorSetStorageImagesMType a :: * + + vkMaxDescriptorSetStorageImages :: + a -> VkMaxDescriptorSetStorageImagesMType a + + vkMaxDescriptorSetStorageImagesByteOffset :: a -> Int + + readVkMaxDescriptorSetStorageImages :: + Ptr a -> IO (VkMaxDescriptorSetStorageImagesMType a) + + writeVkMaxDescriptorSetStorageImages :: + Ptr a -> + VkMaxDescriptorSetStorageImagesMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text + " does not seem to have field 'maxDescriptorSetStorageImages'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMaxDescriptorSetStorageImages a + +class HasVkMaxDescriptorSetUniformBuffers a where + type VkMaxDescriptorSetUniformBuffersMType a :: * + + vkMaxDescriptorSetUniformBuffers :: + a -> VkMaxDescriptorSetUniformBuffersMType a + + vkMaxDescriptorSetUniformBuffersByteOffset :: a -> Int + + readVkMaxDescriptorSetUniformBuffers :: + Ptr a -> IO (VkMaxDescriptorSetUniformBuffersMType a) + + writeVkMaxDescriptorSetUniformBuffers :: + Ptr a -> + VkMaxDescriptorSetUniformBuffersMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text + " does not seem to have field 'maxDescriptorSetUniformBuffers'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMaxDescriptorSetUniformBuffers a + +class HasVkMaxDescriptorSetUniformBuffersDynamic a where + type VkMaxDescriptorSetUniformBuffersDynamicMType a :: * + + vkMaxDescriptorSetUniformBuffersDynamic :: + a -> VkMaxDescriptorSetUniformBuffersDynamicMType a + + vkMaxDescriptorSetUniformBuffersDynamicByteOffset :: a -> Int + + readVkMaxDescriptorSetUniformBuffersDynamic :: + Ptr a -> + IO + (VkMaxDescriptorSetUniformBuffersDynamicMType + a) + + writeVkMaxDescriptorSetUniformBuffersDynamic :: + Ptr a -> + VkMaxDescriptorSetUniformBuffersDynamicMType + a + -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text + " does not seem to have field 'maxDescriptorSetUniformBuffersDynamic'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMaxDescriptorSetUniformBuffersDynamic a + +class HasVkMaxDiscardRectangles a where + type VkMaxDiscardRectanglesMType a :: * + + vkMaxDiscardRectangles :: a -> VkMaxDiscardRectanglesMType a + + vkMaxDiscardRectanglesByteOffset :: a -> Int + + readVkMaxDiscardRectangles :: + Ptr a -> IO (VkMaxDiscardRectanglesMType a) + + writeVkMaxDiscardRectangles :: + Ptr a -> VkMaxDiscardRectanglesMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'maxDiscardRectangles'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMaxDiscardRectangles a + +class HasVkMaxDrawIndexedIndexValue a where + type VkMaxDrawIndexedIndexValueMType a :: * + + vkMaxDrawIndexedIndexValue :: + a -> VkMaxDrawIndexedIndexValueMType a + + vkMaxDrawIndexedIndexValueByteOffset :: a -> Int + + readVkMaxDrawIndexedIndexValue :: + Ptr a -> IO (VkMaxDrawIndexedIndexValueMType a) + + writeVkMaxDrawIndexedIndexValue :: + Ptr a -> VkMaxDrawIndexedIndexValueMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'maxDrawIndexedIndexValue'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMaxDrawIndexedIndexValue a + +class HasVkMaxDrawIndirectCount a where + type VkMaxDrawIndirectCountMType a :: * + + vkMaxDrawIndirectCount :: a -> VkMaxDrawIndirectCountMType a + + vkMaxDrawIndirectCountByteOffset :: a -> Int + + readVkMaxDrawIndirectCount :: + Ptr a -> IO (VkMaxDrawIndirectCountMType a) + + writeVkMaxDrawIndirectCount :: + Ptr a -> VkMaxDrawIndirectCountMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'maxDrawIndirectCount'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMaxDrawIndirectCount a + +class HasVkMaxDstExtent a where + type VkMaxDstExtentMType a :: * + + vkMaxDstExtent :: a -> VkMaxDstExtentMType a + + vkMaxDstExtentByteOffset :: a -> Int + + readVkMaxDstExtent :: Ptr a -> IO (VkMaxDstExtentMType a) + + writeVkMaxDstExtent :: Ptr a -> VkMaxDstExtentMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'maxDstExtent'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMaxDstExtent a + +class HasVkMaxDstPosition a where + type VkMaxDstPositionMType a :: * + + vkMaxDstPosition :: a -> VkMaxDstPositionMType a + + vkMaxDstPositionByteOffset :: a -> Int + + readVkMaxDstPosition :: Ptr a -> IO (VkMaxDstPositionMType a) + + writeVkMaxDstPosition :: Ptr a -> VkMaxDstPositionMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'maxDstPosition'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMaxDstPosition a + +class HasVkMaxExtent a where + type VkMaxExtentMType a :: * + + vkMaxExtent :: a -> VkMaxExtentMType a + + vkMaxExtentByteOffset :: a -> Int + + readVkMaxExtent :: Ptr a -> IO (VkMaxExtentMType a) + + writeVkMaxExtent :: Ptr a -> VkMaxExtentMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'maxExtent'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMaxExtent a + +class HasVkMaxExtraPrimitiveOverestimationSize a where + type VkMaxExtraPrimitiveOverestimationSizeMType a :: * + + vkMaxExtraPrimitiveOverestimationSize :: + a -> VkMaxExtraPrimitiveOverestimationSizeMType a + + vkMaxExtraPrimitiveOverestimationSizeByteOffset :: a -> Int + + readVkMaxExtraPrimitiveOverestimationSize :: + Ptr a -> + IO + (VkMaxExtraPrimitiveOverestimationSizeMType a) + + writeVkMaxExtraPrimitiveOverestimationSize :: + Ptr a -> + VkMaxExtraPrimitiveOverestimationSizeMType a -> + IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text + " does not seem to have field 'maxExtraPrimitiveOverestimationSize'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMaxExtraPrimitiveOverestimationSize a + +class HasVkMaxFragmentCombinedOutputResources a where + type VkMaxFragmentCombinedOutputResourcesMType a :: * + + vkMaxFragmentCombinedOutputResources :: + a -> VkMaxFragmentCombinedOutputResourcesMType a + + vkMaxFragmentCombinedOutputResourcesByteOffset :: a -> Int + + readVkMaxFragmentCombinedOutputResources :: + Ptr a -> + IO (VkMaxFragmentCombinedOutputResourcesMType a) + + writeVkMaxFragmentCombinedOutputResources :: + Ptr a -> + VkMaxFragmentCombinedOutputResourcesMType a -> + IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text + " does not seem to have field 'maxFragmentCombinedOutputResources'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMaxFragmentCombinedOutputResources a + +class HasVkMaxFragmentDualSrcAttachments a where + type VkMaxFragmentDualSrcAttachmentsMType a :: * + + vkMaxFragmentDualSrcAttachments :: + a -> VkMaxFragmentDualSrcAttachmentsMType a + + vkMaxFragmentDualSrcAttachmentsByteOffset :: a -> Int + + readVkMaxFragmentDualSrcAttachments :: + Ptr a -> IO (VkMaxFragmentDualSrcAttachmentsMType a) + + writeVkMaxFragmentDualSrcAttachments :: + Ptr a -> + VkMaxFragmentDualSrcAttachmentsMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text + " does not seem to have field 'maxFragmentDualSrcAttachments'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMaxFragmentDualSrcAttachments a + +class HasVkMaxFragmentInputComponents a where + type VkMaxFragmentInputComponentsMType a :: * + + vkMaxFragmentInputComponents :: + a -> VkMaxFragmentInputComponentsMType a + + vkMaxFragmentInputComponentsByteOffset :: a -> Int + + readVkMaxFragmentInputComponents :: + Ptr a -> IO (VkMaxFragmentInputComponentsMType a) + + writeVkMaxFragmentInputComponents :: + Ptr a -> VkMaxFragmentInputComponentsMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'maxFragmentInputComponents'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMaxFragmentInputComponents a + +class HasVkMaxFragmentOutputAttachments a where + type VkMaxFragmentOutputAttachmentsMType a :: * + + vkMaxFragmentOutputAttachments :: + a -> VkMaxFragmentOutputAttachmentsMType a + + vkMaxFragmentOutputAttachmentsByteOffset :: a -> Int + + readVkMaxFragmentOutputAttachments :: + Ptr a -> IO (VkMaxFragmentOutputAttachmentsMType a) + + writeVkMaxFragmentOutputAttachments :: + Ptr a -> VkMaxFragmentOutputAttachmentsMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text + " does not seem to have field 'maxFragmentOutputAttachments'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMaxFragmentOutputAttachments a + +class HasVkMaxFrameAverageLightLevel a where + type VkMaxFrameAverageLightLevelMType a :: * + + vkMaxFrameAverageLightLevel :: + a -> VkMaxFrameAverageLightLevelMType a + + vkMaxFrameAverageLightLevelByteOffset :: a -> Int + + readVkMaxFrameAverageLightLevel :: + Ptr a -> IO (VkMaxFrameAverageLightLevelMType a) + + writeVkMaxFrameAverageLightLevel :: + Ptr a -> VkMaxFrameAverageLightLevelMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'maxFrameAverageLightLevel'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMaxFrameAverageLightLevel a + +class HasVkMaxFramebufferHeight a where + type VkMaxFramebufferHeightMType a :: * + + vkMaxFramebufferHeight :: a -> VkMaxFramebufferHeightMType a + + vkMaxFramebufferHeightByteOffset :: a -> Int + + readVkMaxFramebufferHeight :: + Ptr a -> IO (VkMaxFramebufferHeightMType a) + + writeVkMaxFramebufferHeight :: + Ptr a -> VkMaxFramebufferHeightMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'maxFramebufferHeight'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMaxFramebufferHeight a + +class HasVkMaxFramebufferLayers a where + type VkMaxFramebufferLayersMType a :: * + + vkMaxFramebufferLayers :: a -> VkMaxFramebufferLayersMType a + + vkMaxFramebufferLayersByteOffset :: a -> Int + + readVkMaxFramebufferLayers :: + Ptr a -> IO (VkMaxFramebufferLayersMType a) + + writeVkMaxFramebufferLayers :: + Ptr a -> VkMaxFramebufferLayersMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'maxFramebufferLayers'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMaxFramebufferLayers a + +class HasVkMaxFramebufferWidth a where + type VkMaxFramebufferWidthMType a :: * + + vkMaxFramebufferWidth :: a -> VkMaxFramebufferWidthMType a + + vkMaxFramebufferWidthByteOffset :: a -> Int + + readVkMaxFramebufferWidth :: + Ptr a -> IO (VkMaxFramebufferWidthMType a) + + writeVkMaxFramebufferWidth :: + Ptr a -> VkMaxFramebufferWidthMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'maxFramebufferWidth'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMaxFramebufferWidth a + +class HasVkMaxGeometryInputComponents a where + type VkMaxGeometryInputComponentsMType a :: * + + vkMaxGeometryInputComponents :: + a -> VkMaxGeometryInputComponentsMType a + + vkMaxGeometryInputComponentsByteOffset :: a -> Int + + readVkMaxGeometryInputComponents :: + Ptr a -> IO (VkMaxGeometryInputComponentsMType a) + + writeVkMaxGeometryInputComponents :: + Ptr a -> VkMaxGeometryInputComponentsMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'maxGeometryInputComponents'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMaxGeometryInputComponents a + +class HasVkMaxGeometryOutputComponents a where + type VkMaxGeometryOutputComponentsMType a :: * + + vkMaxGeometryOutputComponents :: + a -> VkMaxGeometryOutputComponentsMType a + + vkMaxGeometryOutputComponentsByteOffset :: a -> Int + + readVkMaxGeometryOutputComponents :: + Ptr a -> IO (VkMaxGeometryOutputComponentsMType a) + + writeVkMaxGeometryOutputComponents :: + Ptr a -> VkMaxGeometryOutputComponentsMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'maxGeometryOutputComponents'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMaxGeometryOutputComponents a + +class HasVkMaxGeometryOutputVertices a where + type VkMaxGeometryOutputVerticesMType a :: * + + vkMaxGeometryOutputVertices :: + a -> VkMaxGeometryOutputVerticesMType a + + vkMaxGeometryOutputVerticesByteOffset :: a -> Int + + readVkMaxGeometryOutputVertices :: + Ptr a -> IO (VkMaxGeometryOutputVerticesMType a) + + writeVkMaxGeometryOutputVertices :: + Ptr a -> VkMaxGeometryOutputVerticesMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'maxGeometryOutputVertices'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMaxGeometryOutputVertices a + +class HasVkMaxGeometryShaderInvocations a where + type VkMaxGeometryShaderInvocationsMType a :: * + + vkMaxGeometryShaderInvocations :: + a -> VkMaxGeometryShaderInvocationsMType a + + vkMaxGeometryShaderInvocationsByteOffset :: a -> Int + + readVkMaxGeometryShaderInvocations :: + Ptr a -> IO (VkMaxGeometryShaderInvocationsMType a) + + writeVkMaxGeometryShaderInvocations :: + Ptr a -> VkMaxGeometryShaderInvocationsMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text + " does not seem to have field 'maxGeometryShaderInvocations'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMaxGeometryShaderInvocations a + +class HasVkMaxGeometryTotalOutputComponents a where + type VkMaxGeometryTotalOutputComponentsMType a :: * + + vkMaxGeometryTotalOutputComponents :: + a -> VkMaxGeometryTotalOutputComponentsMType a + + vkMaxGeometryTotalOutputComponentsByteOffset :: a -> Int + + readVkMaxGeometryTotalOutputComponents :: + Ptr a -> + IO (VkMaxGeometryTotalOutputComponentsMType a) + + writeVkMaxGeometryTotalOutputComponents :: + Ptr a -> + VkMaxGeometryTotalOutputComponentsMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text + " does not seem to have field 'maxGeometryTotalOutputComponents'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMaxGeometryTotalOutputComponents a + +class HasVkMaxImageArrayLayers a where + type VkMaxImageArrayLayersMType a :: * + + vkMaxImageArrayLayers :: a -> VkMaxImageArrayLayersMType a + + vkMaxImageArrayLayersByteOffset :: a -> Int + + readVkMaxImageArrayLayers :: + Ptr a -> IO (VkMaxImageArrayLayersMType a) + + writeVkMaxImageArrayLayers :: + Ptr a -> VkMaxImageArrayLayersMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'maxImageArrayLayers'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMaxImageArrayLayers a + +class HasVkMaxImageCount a where + type VkMaxImageCountMType a :: * + + vkMaxImageCount :: a -> VkMaxImageCountMType a + + vkMaxImageCountByteOffset :: a -> Int + + readVkMaxImageCount :: Ptr a -> IO (VkMaxImageCountMType a) + + writeVkMaxImageCount :: Ptr a -> VkMaxImageCountMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'maxImageCount'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMaxImageCount a + +class HasVkMaxImageDimension1D a where + type VkMaxImageDimension1DMType a :: * + + vkMaxImageDimension1D :: a -> VkMaxImageDimension1DMType a + + vkMaxImageDimension1DByteOffset :: a -> Int + + readVkMaxImageDimension1D :: + Ptr a -> IO (VkMaxImageDimension1DMType a) + + writeVkMaxImageDimension1D :: + Ptr a -> VkMaxImageDimension1DMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'maxImageDimension1D'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMaxImageDimension1D a + +class HasVkMaxImageDimension2D a where + type VkMaxImageDimension2DMType a :: * + + vkMaxImageDimension2D :: a -> VkMaxImageDimension2DMType a + + vkMaxImageDimension2DByteOffset :: a -> Int + + readVkMaxImageDimension2D :: + Ptr a -> IO (VkMaxImageDimension2DMType a) + + writeVkMaxImageDimension2D :: + Ptr a -> VkMaxImageDimension2DMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'maxImageDimension2D'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMaxImageDimension2D a + +class HasVkMaxImageDimension3D a where + type VkMaxImageDimension3DMType a :: * + + vkMaxImageDimension3D :: a -> VkMaxImageDimension3DMType a + + vkMaxImageDimension3DByteOffset :: a -> Int + + readVkMaxImageDimension3D :: + Ptr a -> IO (VkMaxImageDimension3DMType a) + + writeVkMaxImageDimension3D :: + Ptr a -> VkMaxImageDimension3DMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'maxImageDimension3D'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMaxImageDimension3D a + +class HasVkMaxImageDimensionCube a where + type VkMaxImageDimensionCubeMType a :: * + + vkMaxImageDimensionCube :: a -> VkMaxImageDimensionCubeMType a + + vkMaxImageDimensionCubeByteOffset :: a -> Int + + readVkMaxImageDimensionCube :: + Ptr a -> IO (VkMaxImageDimensionCubeMType a) + + writeVkMaxImageDimensionCube :: + Ptr a -> VkMaxImageDimensionCubeMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'maxImageDimensionCube'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMaxImageDimensionCube a + +class HasVkMaxImageExtent a where + type VkMaxImageExtentMType a :: * + + vkMaxImageExtent :: a -> VkMaxImageExtentMType a + + vkMaxImageExtentByteOffset :: a -> Int + + readVkMaxImageExtent :: Ptr a -> IO (VkMaxImageExtentMType a) + + writeVkMaxImageExtent :: Ptr a -> VkMaxImageExtentMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'maxImageExtent'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMaxImageExtent a + +class HasVkMaxIndirectCommandsLayoutTokenCount a where + type VkMaxIndirectCommandsLayoutTokenCountMType a :: * + + vkMaxIndirectCommandsLayoutTokenCount :: + a -> VkMaxIndirectCommandsLayoutTokenCountMType a + + vkMaxIndirectCommandsLayoutTokenCountByteOffset :: a -> Int + + readVkMaxIndirectCommandsLayoutTokenCount :: + Ptr a -> + IO + (VkMaxIndirectCommandsLayoutTokenCountMType a) + + writeVkMaxIndirectCommandsLayoutTokenCount :: + Ptr a -> + VkMaxIndirectCommandsLayoutTokenCountMType a -> + IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text + " does not seem to have field 'maxIndirectCommandsLayoutTokenCount'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMaxIndirectCommandsLayoutTokenCount a + +class HasVkMaxInterpolationOffset a where + type VkMaxInterpolationOffsetMType a :: * + + vkMaxInterpolationOffset :: a -> VkMaxInterpolationOffsetMType a + + vkMaxInterpolationOffsetByteOffset :: a -> Int + + readVkMaxInterpolationOffset :: + Ptr a -> IO (VkMaxInterpolationOffsetMType a) + + writeVkMaxInterpolationOffset :: + Ptr a -> VkMaxInterpolationOffsetMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'maxInterpolationOffset'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMaxInterpolationOffset a + +class HasVkMaxLod a where + type VkMaxLodMType a :: * + + vkMaxLod :: a -> VkMaxLodMType a + + vkMaxLodByteOffset :: a -> Int + + readVkMaxLod :: Ptr a -> IO (VkMaxLodMType a) + + writeVkMaxLod :: Ptr a -> VkMaxLodMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'maxLod'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMaxLod a + +class HasVkMaxLuminance a where + type VkMaxLuminanceMType a :: * + + vkMaxLuminance :: a -> VkMaxLuminanceMType a + + vkMaxLuminanceByteOffset :: a -> Int + + readVkMaxLuminance :: Ptr a -> IO (VkMaxLuminanceMType a) + + writeVkMaxLuminance :: Ptr a -> VkMaxLuminanceMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'maxLuminance'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMaxLuminance a + +class HasVkMaxMemoryAllocationCount a where + type VkMaxMemoryAllocationCountMType a :: * + + vkMaxMemoryAllocationCount :: + a -> VkMaxMemoryAllocationCountMType a + + vkMaxMemoryAllocationCountByteOffset :: a -> Int + + readVkMaxMemoryAllocationCount :: + Ptr a -> IO (VkMaxMemoryAllocationCountMType a) + + writeVkMaxMemoryAllocationCount :: + Ptr a -> VkMaxMemoryAllocationCountMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'maxMemoryAllocationCount'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMaxMemoryAllocationCount a + +class HasVkMaxMipLevels a where + type VkMaxMipLevelsMType a :: * + + vkMaxMipLevels :: a -> VkMaxMipLevelsMType a + + vkMaxMipLevelsByteOffset :: a -> Int + + readVkMaxMipLevels :: Ptr a -> IO (VkMaxMipLevelsMType a) + + writeVkMaxMipLevels :: Ptr a -> VkMaxMipLevelsMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'maxMipLevels'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMaxMipLevels a + +class HasVkMaxMultiviewInstanceIndex a where + type VkMaxMultiviewInstanceIndexMType a :: * + + vkMaxMultiviewInstanceIndex :: + a -> VkMaxMultiviewInstanceIndexMType a + + vkMaxMultiviewInstanceIndexByteOffset :: a -> Int + + readVkMaxMultiviewInstanceIndex :: + Ptr a -> IO (VkMaxMultiviewInstanceIndexMType a) + + writeVkMaxMultiviewInstanceIndex :: + Ptr a -> VkMaxMultiviewInstanceIndexMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'maxMultiviewInstanceIndex'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMaxMultiviewInstanceIndex a + +class HasVkMaxMultiviewViewCount a where + type VkMaxMultiviewViewCountMType a :: * + + vkMaxMultiviewViewCount :: a -> VkMaxMultiviewViewCountMType a + + vkMaxMultiviewViewCountByteOffset :: a -> Int + + readVkMaxMultiviewViewCount :: + Ptr a -> IO (VkMaxMultiviewViewCountMType a) + + writeVkMaxMultiviewViewCount :: + Ptr a -> VkMaxMultiviewViewCountMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'maxMultiviewViewCount'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMaxMultiviewViewCount a + +class HasVkMaxObjectEntryCounts a where + type VkMaxObjectEntryCountsMType a :: * + + vkMaxObjectEntryCounts :: a -> VkMaxObjectEntryCountsMType a + + vkMaxObjectEntryCountsByteOffset :: a -> Int + + readVkMaxObjectEntryCounts :: + Ptr a -> IO (VkMaxObjectEntryCountsMType a) + + writeVkMaxObjectEntryCounts :: + Ptr a -> VkMaxObjectEntryCountsMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'maxObjectEntryCounts'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMaxObjectEntryCounts a + +class HasVkMaxPerStageDescriptorInputAttachments a where + type VkMaxPerStageDescriptorInputAttachmentsMType a :: * + + vkMaxPerStageDescriptorInputAttachments :: + a -> VkMaxPerStageDescriptorInputAttachmentsMType a + + vkMaxPerStageDescriptorInputAttachmentsByteOffset :: a -> Int + + readVkMaxPerStageDescriptorInputAttachments :: + Ptr a -> + IO + (VkMaxPerStageDescriptorInputAttachmentsMType + a) + + writeVkMaxPerStageDescriptorInputAttachments :: + Ptr a -> + VkMaxPerStageDescriptorInputAttachmentsMType + a + -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text + " does not seem to have field 'maxPerStageDescriptorInputAttachments'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMaxPerStageDescriptorInputAttachments a + +class HasVkMaxPerStageDescriptorSampledImages a where + type VkMaxPerStageDescriptorSampledImagesMType a :: * + + vkMaxPerStageDescriptorSampledImages :: + a -> VkMaxPerStageDescriptorSampledImagesMType a + + vkMaxPerStageDescriptorSampledImagesByteOffset :: a -> Int + + readVkMaxPerStageDescriptorSampledImages :: + Ptr a -> + IO (VkMaxPerStageDescriptorSampledImagesMType a) + + writeVkMaxPerStageDescriptorSampledImages :: + Ptr a -> + VkMaxPerStageDescriptorSampledImagesMType a -> + IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text + " does not seem to have field 'maxPerStageDescriptorSampledImages'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMaxPerStageDescriptorSampledImages a + +class HasVkMaxPerStageDescriptorSamplers a where + type VkMaxPerStageDescriptorSamplersMType a :: * + + vkMaxPerStageDescriptorSamplers :: + a -> VkMaxPerStageDescriptorSamplersMType a + + vkMaxPerStageDescriptorSamplersByteOffset :: a -> Int + + readVkMaxPerStageDescriptorSamplers :: + Ptr a -> IO (VkMaxPerStageDescriptorSamplersMType a) + + writeVkMaxPerStageDescriptorSamplers :: + Ptr a -> + VkMaxPerStageDescriptorSamplersMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text + " does not seem to have field 'maxPerStageDescriptorSamplers'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMaxPerStageDescriptorSamplers a + +class HasVkMaxPerStageDescriptorStorageBuffers a where + type VkMaxPerStageDescriptorStorageBuffersMType a :: * + + vkMaxPerStageDescriptorStorageBuffers :: + a -> VkMaxPerStageDescriptorStorageBuffersMType a + + vkMaxPerStageDescriptorStorageBuffersByteOffset :: a -> Int + + readVkMaxPerStageDescriptorStorageBuffers :: + Ptr a -> + IO + (VkMaxPerStageDescriptorStorageBuffersMType a) + + writeVkMaxPerStageDescriptorStorageBuffers :: + Ptr a -> + VkMaxPerStageDescriptorStorageBuffersMType a -> + IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text + " does not seem to have field 'maxPerStageDescriptorStorageBuffers'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMaxPerStageDescriptorStorageBuffers a + +class HasVkMaxPerStageDescriptorStorageImages a where + type VkMaxPerStageDescriptorStorageImagesMType a :: * + + vkMaxPerStageDescriptorStorageImages :: + a -> VkMaxPerStageDescriptorStorageImagesMType a + + vkMaxPerStageDescriptorStorageImagesByteOffset :: a -> Int + + readVkMaxPerStageDescriptorStorageImages :: + Ptr a -> + IO (VkMaxPerStageDescriptorStorageImagesMType a) + + writeVkMaxPerStageDescriptorStorageImages :: + Ptr a -> + VkMaxPerStageDescriptorStorageImagesMType a -> + IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text + " does not seem to have field 'maxPerStageDescriptorStorageImages'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMaxPerStageDescriptorStorageImages a + +class HasVkMaxPerStageDescriptorUniformBuffers a where + type VkMaxPerStageDescriptorUniformBuffersMType a :: * + + vkMaxPerStageDescriptorUniformBuffers :: + a -> VkMaxPerStageDescriptorUniformBuffersMType a + + vkMaxPerStageDescriptorUniformBuffersByteOffset :: a -> Int + + readVkMaxPerStageDescriptorUniformBuffers :: + Ptr a -> + IO + (VkMaxPerStageDescriptorUniformBuffersMType a) + + writeVkMaxPerStageDescriptorUniformBuffers :: + Ptr a -> + VkMaxPerStageDescriptorUniformBuffersMType a -> + IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text + " does not seem to have field 'maxPerStageDescriptorUniformBuffers'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMaxPerStageDescriptorUniformBuffers a + +class HasVkMaxPerStageResources a where + type VkMaxPerStageResourcesMType a :: * + + vkMaxPerStageResources :: a -> VkMaxPerStageResourcesMType a + + vkMaxPerStageResourcesByteOffset :: a -> Int + + readVkMaxPerStageResources :: + Ptr a -> IO (VkMaxPerStageResourcesMType a) + + writeVkMaxPerStageResources :: + Ptr a -> VkMaxPerStageResourcesMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'maxPerStageResources'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMaxPerStageResources a + +class HasVkMaxPipelineLayouts a where + type VkMaxPipelineLayoutsMType a :: * + + vkMaxPipelineLayouts :: a -> VkMaxPipelineLayoutsMType a + + vkMaxPipelineLayoutsByteOffset :: a -> Int + + readVkMaxPipelineLayouts :: + Ptr a -> IO (VkMaxPipelineLayoutsMType a) + + writeVkMaxPipelineLayouts :: + Ptr a -> VkMaxPipelineLayoutsMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'maxPipelineLayouts'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMaxPipelineLayouts a + +class HasVkMaxPushConstantsSize a where + type VkMaxPushConstantsSizeMType a :: * + + vkMaxPushConstantsSize :: a -> VkMaxPushConstantsSizeMType a + + vkMaxPushConstantsSizeByteOffset :: a -> Int + + readVkMaxPushConstantsSize :: + Ptr a -> IO (VkMaxPushConstantsSizeMType a) + + writeVkMaxPushConstantsSize :: + Ptr a -> VkMaxPushConstantsSizeMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'maxPushConstantsSize'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMaxPushConstantsSize a + +class HasVkMaxPushDescriptors a where + type VkMaxPushDescriptorsMType a :: * + + vkMaxPushDescriptors :: a -> VkMaxPushDescriptorsMType a + + vkMaxPushDescriptorsByteOffset :: a -> Int + + readVkMaxPushDescriptors :: + Ptr a -> IO (VkMaxPushDescriptorsMType a) + + writeVkMaxPushDescriptors :: + Ptr a -> VkMaxPushDescriptorsMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'maxPushDescriptors'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMaxPushDescriptors a + +class HasVkMaxResourceSize a where + type VkMaxResourceSizeMType a :: * + + vkMaxResourceSize :: a -> VkMaxResourceSizeMType a + + vkMaxResourceSizeByteOffset :: a -> Int + + readVkMaxResourceSize :: Ptr a -> IO (VkMaxResourceSizeMType a) + + writeVkMaxResourceSize :: + Ptr a -> VkMaxResourceSizeMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'maxResourceSize'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMaxResourceSize a + +class HasVkMaxSampleLocationGridSize a where + type VkMaxSampleLocationGridSizeMType a :: * + + vkMaxSampleLocationGridSize :: + a -> VkMaxSampleLocationGridSizeMType a + + vkMaxSampleLocationGridSizeByteOffset :: a -> Int + + readVkMaxSampleLocationGridSize :: + Ptr a -> IO (VkMaxSampleLocationGridSizeMType a) + + writeVkMaxSampleLocationGridSize :: + Ptr a -> VkMaxSampleLocationGridSizeMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'maxSampleLocationGridSize'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMaxSampleLocationGridSize a + +class HasVkMaxSampleMaskWords a where + type VkMaxSampleMaskWordsMType a :: * + + vkMaxSampleMaskWords :: a -> VkMaxSampleMaskWordsMType a + + vkMaxSampleMaskWordsByteOffset :: a -> Int + + readVkMaxSampleMaskWords :: + Ptr a -> IO (VkMaxSampleMaskWordsMType a) + + writeVkMaxSampleMaskWords :: + Ptr a -> VkMaxSampleMaskWordsMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'maxSampleMaskWords'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMaxSampleMaskWords a + +class HasVkMaxSampledImagesPerDescriptor a where + type VkMaxSampledImagesPerDescriptorMType a :: * + + vkMaxSampledImagesPerDescriptor :: + a -> VkMaxSampledImagesPerDescriptorMType a + + vkMaxSampledImagesPerDescriptorByteOffset :: a -> Int + + readVkMaxSampledImagesPerDescriptor :: + Ptr a -> IO (VkMaxSampledImagesPerDescriptorMType a) + + writeVkMaxSampledImagesPerDescriptor :: + Ptr a -> + VkMaxSampledImagesPerDescriptorMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text + " does not seem to have field 'maxSampledImagesPerDescriptor'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMaxSampledImagesPerDescriptor a + +class HasVkMaxSamplerAllocationCount a where + type VkMaxSamplerAllocationCountMType a :: * + + vkMaxSamplerAllocationCount :: + a -> VkMaxSamplerAllocationCountMType a + + vkMaxSamplerAllocationCountByteOffset :: a -> Int + + readVkMaxSamplerAllocationCount :: + Ptr a -> IO (VkMaxSamplerAllocationCountMType a) + + writeVkMaxSamplerAllocationCount :: + Ptr a -> VkMaxSamplerAllocationCountMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'maxSamplerAllocationCount'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMaxSamplerAllocationCount a + +class HasVkMaxSamplerAnisotropy a where + type VkMaxSamplerAnisotropyMType a :: * + + vkMaxSamplerAnisotropy :: a -> VkMaxSamplerAnisotropyMType a + + vkMaxSamplerAnisotropyByteOffset :: a -> Int + + readVkMaxSamplerAnisotropy :: + Ptr a -> IO (VkMaxSamplerAnisotropyMType a) + + writeVkMaxSamplerAnisotropy :: + Ptr a -> VkMaxSamplerAnisotropyMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'maxSamplerAnisotropy'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMaxSamplerAnisotropy a + +class HasVkMaxSamplerLodBias a where + type VkMaxSamplerLodBiasMType a :: * + + vkMaxSamplerLodBias :: a -> VkMaxSamplerLodBiasMType a + + vkMaxSamplerLodBiasByteOffset :: a -> Int + + readVkMaxSamplerLodBias :: Ptr a -> IO (VkMaxSamplerLodBiasMType a) + + writeVkMaxSamplerLodBias :: + Ptr a -> VkMaxSamplerLodBiasMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'maxSamplerLodBias'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMaxSamplerLodBias a + +class HasVkMaxSequencesCount a where + type VkMaxSequencesCountMType a :: * + + vkMaxSequencesCount :: a -> VkMaxSequencesCountMType a + + vkMaxSequencesCountByteOffset :: a -> Int + + readVkMaxSequencesCount :: Ptr a -> IO (VkMaxSequencesCountMType a) + + writeVkMaxSequencesCount :: + Ptr a -> VkMaxSequencesCountMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'maxSequencesCount'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMaxSequencesCount a + +class HasVkMaxSets a where + type VkMaxSetsMType a :: * + + vkMaxSets :: a -> VkMaxSetsMType a + + vkMaxSetsByteOffset :: a -> Int + + readVkMaxSets :: Ptr a -> IO (VkMaxSetsMType a) + + writeVkMaxSets :: Ptr a -> VkMaxSetsMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'maxSets'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMaxSets a + +class HasVkMaxSrcExtent a where + type VkMaxSrcExtentMType a :: * + + vkMaxSrcExtent :: a -> VkMaxSrcExtentMType a + + vkMaxSrcExtentByteOffset :: a -> Int + + readVkMaxSrcExtent :: Ptr a -> IO (VkMaxSrcExtentMType a) + + writeVkMaxSrcExtent :: Ptr a -> VkMaxSrcExtentMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'maxSrcExtent'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMaxSrcExtent a + +class HasVkMaxSrcPosition a where + type VkMaxSrcPositionMType a :: * + + vkMaxSrcPosition :: a -> VkMaxSrcPositionMType a + + vkMaxSrcPositionByteOffset :: a -> Int + + readVkMaxSrcPosition :: Ptr a -> IO (VkMaxSrcPositionMType a) + + writeVkMaxSrcPosition :: Ptr a -> VkMaxSrcPositionMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'maxSrcPosition'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMaxSrcPosition a + +class HasVkMaxStorageBufferRange a where + type VkMaxStorageBufferRangeMType a :: * + + vkMaxStorageBufferRange :: a -> VkMaxStorageBufferRangeMType a + + vkMaxStorageBufferRangeByteOffset :: a -> Int + + readVkMaxStorageBufferRange :: + Ptr a -> IO (VkMaxStorageBufferRangeMType a) + + writeVkMaxStorageBufferRange :: + Ptr a -> VkMaxStorageBufferRangeMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'maxStorageBufferRange'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMaxStorageBufferRange a + +class HasVkMaxStorageBuffersPerDescriptor a where + type VkMaxStorageBuffersPerDescriptorMType a :: * + + vkMaxStorageBuffersPerDescriptor :: + a -> VkMaxStorageBuffersPerDescriptorMType a + + vkMaxStorageBuffersPerDescriptorByteOffset :: a -> Int + + readVkMaxStorageBuffersPerDescriptor :: + Ptr a -> IO (VkMaxStorageBuffersPerDescriptorMType a) + + writeVkMaxStorageBuffersPerDescriptor :: + Ptr a -> + VkMaxStorageBuffersPerDescriptorMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text + " does not seem to have field 'maxStorageBuffersPerDescriptor'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMaxStorageBuffersPerDescriptor a + +class HasVkMaxStorageImagesPerDescriptor a where + type VkMaxStorageImagesPerDescriptorMType a :: * + + vkMaxStorageImagesPerDescriptor :: + a -> VkMaxStorageImagesPerDescriptorMType a + + vkMaxStorageImagesPerDescriptorByteOffset :: a -> Int + + readVkMaxStorageImagesPerDescriptor :: + Ptr a -> IO (VkMaxStorageImagesPerDescriptorMType a) + + writeVkMaxStorageImagesPerDescriptor :: + Ptr a -> + VkMaxStorageImagesPerDescriptorMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text + " does not seem to have field 'maxStorageImagesPerDescriptor'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMaxStorageImagesPerDescriptor a + +class HasVkMaxTessellationControlPerPatchOutputComponents a where + type VkMaxTessellationControlPerPatchOutputComponentsMType a :: * + + vkMaxTessellationControlPerPatchOutputComponents :: + a -> + VkMaxTessellationControlPerPatchOutputComponentsMType + a + + vkMaxTessellationControlPerPatchOutputComponentsByteOffset :: + a -> Int + + readVkMaxTessellationControlPerPatchOutputComponents :: + Ptr a -> + IO + (VkMaxTessellationControlPerPatchOutputComponentsMType + a) + + writeVkMaxTessellationControlPerPatchOutputComponents :: + Ptr a -> + VkMaxTessellationControlPerPatchOutputComponentsMType + a + -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text + " does not seem to have field 'maxTessellationControlPerPatchOutputComponents'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMaxTessellationControlPerPatchOutputComponents a + +class HasVkMaxTessellationControlPerVertexInputComponents a where + type VkMaxTessellationControlPerVertexInputComponentsMType a :: * + + vkMaxTessellationControlPerVertexInputComponents :: + a -> + VkMaxTessellationControlPerVertexInputComponentsMType + a + + vkMaxTessellationControlPerVertexInputComponentsByteOffset :: + a -> Int + + readVkMaxTessellationControlPerVertexInputComponents :: + Ptr a -> + IO + (VkMaxTessellationControlPerVertexInputComponentsMType + a) + + writeVkMaxTessellationControlPerVertexInputComponents :: + Ptr a -> + VkMaxTessellationControlPerVertexInputComponentsMType + a + -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text + " does not seem to have field 'maxTessellationControlPerVertexInputComponents'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMaxTessellationControlPerVertexInputComponents a + +class HasVkMaxTessellationControlPerVertexOutputComponents a where + type VkMaxTessellationControlPerVertexOutputComponentsMType a :: * + + vkMaxTessellationControlPerVertexOutputComponents :: + a -> + VkMaxTessellationControlPerVertexOutputComponentsMType + a + + vkMaxTessellationControlPerVertexOutputComponentsByteOffset :: + a -> Int + + readVkMaxTessellationControlPerVertexOutputComponents :: + Ptr a -> + IO + (VkMaxTessellationControlPerVertexOutputComponentsMType + a) + + writeVkMaxTessellationControlPerVertexOutputComponents :: + Ptr a -> + VkMaxTessellationControlPerVertexOutputComponentsMType + a + -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text + " does not seem to have field 'maxTessellationControlPerVertexOutputComponents'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMaxTessellationControlPerVertexOutputComponents a + +class HasVkMaxTessellationControlTotalOutputComponents a where + type VkMaxTessellationControlTotalOutputComponentsMType a :: * + + vkMaxTessellationControlTotalOutputComponents :: + a -> + VkMaxTessellationControlTotalOutputComponentsMType + a + + vkMaxTessellationControlTotalOutputComponentsByteOffset :: a -> Int + + readVkMaxTessellationControlTotalOutputComponents :: + Ptr a -> + IO + (VkMaxTessellationControlTotalOutputComponentsMType + a) + + writeVkMaxTessellationControlTotalOutputComponents :: + Ptr a -> + VkMaxTessellationControlTotalOutputComponentsMType + a + -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text + " does not seem to have field 'maxTessellationControlTotalOutputComponents'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMaxTessellationControlTotalOutputComponents a + +class HasVkMaxTessellationEvaluationInputComponents a where + type VkMaxTessellationEvaluationInputComponentsMType a :: * + + vkMaxTessellationEvaluationInputComponents :: + a -> + VkMaxTessellationEvaluationInputComponentsMType + a + + vkMaxTessellationEvaluationInputComponentsByteOffset :: a -> Int + + readVkMaxTessellationEvaluationInputComponents :: + Ptr a -> + IO + (VkMaxTessellationEvaluationInputComponentsMType + a) + + writeVkMaxTessellationEvaluationInputComponents :: + Ptr a -> + VkMaxTessellationEvaluationInputComponentsMType + a + -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text + " does not seem to have field 'maxTessellationEvaluationInputComponents'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMaxTessellationEvaluationInputComponents a + +class HasVkMaxTessellationEvaluationOutputComponents a where + type VkMaxTessellationEvaluationOutputComponentsMType a :: * + + vkMaxTessellationEvaluationOutputComponents :: + a -> + VkMaxTessellationEvaluationOutputComponentsMType + a + + vkMaxTessellationEvaluationOutputComponentsByteOffset :: a -> Int + + readVkMaxTessellationEvaluationOutputComponents :: + Ptr a -> + IO + (VkMaxTessellationEvaluationOutputComponentsMType + a) + + writeVkMaxTessellationEvaluationOutputComponents :: + Ptr a -> + VkMaxTessellationEvaluationOutputComponentsMType + a + -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text + " does not seem to have field 'maxTessellationEvaluationOutputComponents'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMaxTessellationEvaluationOutputComponents a + +class HasVkMaxTessellationGenerationLevel a where + type VkMaxTessellationGenerationLevelMType a :: * + + vkMaxTessellationGenerationLevel :: + a -> VkMaxTessellationGenerationLevelMType a + + vkMaxTessellationGenerationLevelByteOffset :: a -> Int + + readVkMaxTessellationGenerationLevel :: + Ptr a -> IO (VkMaxTessellationGenerationLevelMType a) + + writeVkMaxTessellationGenerationLevel :: + Ptr a -> + VkMaxTessellationGenerationLevelMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text + " does not seem to have field 'maxTessellationGenerationLevel'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMaxTessellationGenerationLevel a + +class HasVkMaxTessellationPatchSize a where + type VkMaxTessellationPatchSizeMType a :: * + + vkMaxTessellationPatchSize :: + a -> VkMaxTessellationPatchSizeMType a + + vkMaxTessellationPatchSizeByteOffset :: a -> Int + + readVkMaxTessellationPatchSize :: + Ptr a -> IO (VkMaxTessellationPatchSizeMType a) + + writeVkMaxTessellationPatchSize :: + Ptr a -> VkMaxTessellationPatchSizeMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'maxTessellationPatchSize'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMaxTessellationPatchSize a + +class HasVkMaxTexelBufferElements a where + type VkMaxTexelBufferElementsMType a :: * + + vkMaxTexelBufferElements :: a -> VkMaxTexelBufferElementsMType a + + vkMaxTexelBufferElementsByteOffset :: a -> Int + + readVkMaxTexelBufferElements :: + Ptr a -> IO (VkMaxTexelBufferElementsMType a) + + writeVkMaxTexelBufferElements :: + Ptr a -> VkMaxTexelBufferElementsMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'maxTexelBufferElements'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMaxTexelBufferElements a + +class HasVkMaxTexelGatherOffset a where + type VkMaxTexelGatherOffsetMType a :: * + + vkMaxTexelGatherOffset :: a -> VkMaxTexelGatherOffsetMType a + + vkMaxTexelGatherOffsetByteOffset :: a -> Int + + readVkMaxTexelGatherOffset :: + Ptr a -> IO (VkMaxTexelGatherOffsetMType a) + + writeVkMaxTexelGatherOffset :: + Ptr a -> VkMaxTexelGatherOffsetMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'maxTexelGatherOffset'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMaxTexelGatherOffset a + +class HasVkMaxTexelOffset a where + type VkMaxTexelOffsetMType a :: * + + vkMaxTexelOffset :: a -> VkMaxTexelOffsetMType a + + vkMaxTexelOffsetByteOffset :: a -> Int + + readVkMaxTexelOffset :: Ptr a -> IO (VkMaxTexelOffsetMType a) + + writeVkMaxTexelOffset :: Ptr a -> VkMaxTexelOffsetMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'maxTexelOffset'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMaxTexelOffset a + +class HasVkMaxUniformBufferRange a where + type VkMaxUniformBufferRangeMType a :: * + + vkMaxUniformBufferRange :: a -> VkMaxUniformBufferRangeMType a + + vkMaxUniformBufferRangeByteOffset :: a -> Int + + readVkMaxUniformBufferRange :: + Ptr a -> IO (VkMaxUniformBufferRangeMType a) + + writeVkMaxUniformBufferRange :: + Ptr a -> VkMaxUniformBufferRangeMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'maxUniformBufferRange'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMaxUniformBufferRange a + +class HasVkMaxUniformBuffersPerDescriptor a where + type VkMaxUniformBuffersPerDescriptorMType a :: * + + vkMaxUniformBuffersPerDescriptor :: + a -> VkMaxUniformBuffersPerDescriptorMType a + + vkMaxUniformBuffersPerDescriptorByteOffset :: a -> Int + + readVkMaxUniformBuffersPerDescriptor :: + Ptr a -> IO (VkMaxUniformBuffersPerDescriptorMType a) + + writeVkMaxUniformBuffersPerDescriptor :: + Ptr a -> + VkMaxUniformBuffersPerDescriptorMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text + " does not seem to have field 'maxUniformBuffersPerDescriptor'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMaxUniformBuffersPerDescriptor a + +class HasVkMaxVertexInputAttributeOffset a where + type VkMaxVertexInputAttributeOffsetMType a :: * + + vkMaxVertexInputAttributeOffset :: + a -> VkMaxVertexInputAttributeOffsetMType a + + vkMaxVertexInputAttributeOffsetByteOffset :: a -> Int + + readVkMaxVertexInputAttributeOffset :: + Ptr a -> IO (VkMaxVertexInputAttributeOffsetMType a) + + writeVkMaxVertexInputAttributeOffset :: + Ptr a -> + VkMaxVertexInputAttributeOffsetMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text + " does not seem to have field 'maxVertexInputAttributeOffset'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMaxVertexInputAttributeOffset a + +class HasVkMaxVertexInputAttributes a where + type VkMaxVertexInputAttributesMType a :: * + + vkMaxVertexInputAttributes :: + a -> VkMaxVertexInputAttributesMType a + + vkMaxVertexInputAttributesByteOffset :: a -> Int + + readVkMaxVertexInputAttributes :: + Ptr a -> IO (VkMaxVertexInputAttributesMType a) + + writeVkMaxVertexInputAttributes :: + Ptr a -> VkMaxVertexInputAttributesMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'maxVertexInputAttributes'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMaxVertexInputAttributes a + +class HasVkMaxVertexInputBindingStride a where + type VkMaxVertexInputBindingStrideMType a :: * + + vkMaxVertexInputBindingStride :: + a -> VkMaxVertexInputBindingStrideMType a + + vkMaxVertexInputBindingStrideByteOffset :: a -> Int + + readVkMaxVertexInputBindingStride :: + Ptr a -> IO (VkMaxVertexInputBindingStrideMType a) + + writeVkMaxVertexInputBindingStride :: + Ptr a -> VkMaxVertexInputBindingStrideMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'maxVertexInputBindingStride'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMaxVertexInputBindingStride a + +class HasVkMaxVertexInputBindings a where + type VkMaxVertexInputBindingsMType a :: * + + vkMaxVertexInputBindings :: a -> VkMaxVertexInputBindingsMType a + + vkMaxVertexInputBindingsByteOffset :: a -> Int + + readVkMaxVertexInputBindings :: + Ptr a -> IO (VkMaxVertexInputBindingsMType a) + + writeVkMaxVertexInputBindings :: + Ptr a -> VkMaxVertexInputBindingsMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'maxVertexInputBindings'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMaxVertexInputBindings a + +class HasVkMaxVertexOutputComponents a where + type VkMaxVertexOutputComponentsMType a :: * + + vkMaxVertexOutputComponents :: + a -> VkMaxVertexOutputComponentsMType a + + vkMaxVertexOutputComponentsByteOffset :: a -> Int + + readVkMaxVertexOutputComponents :: + Ptr a -> IO (VkMaxVertexOutputComponentsMType a) + + writeVkMaxVertexOutputComponents :: + Ptr a -> VkMaxVertexOutputComponentsMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'maxVertexOutputComponents'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMaxVertexOutputComponents a + +class HasVkMaxViewportDimensionsArray a where + type VkMaxViewportDimensionsArrayMType a :: * + + vkMaxViewportDimensionsArray :: + a -> Int -> VkMaxViewportDimensionsArrayMType a + + vkMaxViewportDimensionsArrayByteOffset :: a -> Int + + readVkMaxViewportDimensionsArray :: + Ptr a -> Int -> IO (VkMaxViewportDimensionsArrayMType a) + + writeVkMaxViewportDimensionsArray :: + Ptr a -> + Int -> VkMaxViewportDimensionsArrayMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'maxViewportDimensions'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMaxViewportDimensionsArray a + +class HasVkMaxViewports a where + type VkMaxViewportsMType a :: * + + vkMaxViewports :: a -> VkMaxViewportsMType a + + vkMaxViewportsByteOffset :: a -> Int + + readVkMaxViewports :: Ptr a -> IO (VkMaxViewportsMType a) + + writeVkMaxViewports :: Ptr a -> VkMaxViewportsMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'maxViewports'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMaxViewports a + +class HasVkMemory a where + type VkMemoryMType a :: * + + vkMemory :: a -> VkMemoryMType a + + vkMemoryByteOffset :: a -> Int + + readVkMemory :: Ptr a -> IO (VkMemoryMType a) + + writeVkMemory :: Ptr a -> VkMemoryMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'memory'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMemory a + +class HasVkMemoryDeviceIndex a where + type VkMemoryDeviceIndexMType a :: * + + vkMemoryDeviceIndex :: a -> VkMemoryDeviceIndexMType a + + vkMemoryDeviceIndexByteOffset :: a -> Int + + readVkMemoryDeviceIndex :: Ptr a -> IO (VkMemoryDeviceIndexMType a) + + writeVkMemoryDeviceIndex :: + Ptr a -> VkMemoryDeviceIndexMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'memoryDeviceIndex'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMemoryDeviceIndex a + +class HasVkMemoryHeapCount a where + type VkMemoryHeapCountMType a :: * + + vkMemoryHeapCount :: a -> VkMemoryHeapCountMType a + + vkMemoryHeapCountByteOffset :: a -> Int + + readVkMemoryHeapCount :: Ptr a -> IO (VkMemoryHeapCountMType a) + + writeVkMemoryHeapCount :: + Ptr a -> VkMemoryHeapCountMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'memoryHeapCount'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMemoryHeapCount a + +class HasVkMemoryHeapsArray a where + type VkMemoryHeapsArrayMType a :: * + + vkMemoryHeapsArray :: a -> Int -> VkMemoryHeapsArrayMType a + + vkMemoryHeapsArrayByteOffset :: a -> Int + + readVkMemoryHeapsArray :: + Ptr a -> Int -> IO (VkMemoryHeapsArrayMType a) + + writeVkMemoryHeapsArray :: + Ptr a -> Int -> VkMemoryHeapsArrayMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'memoryHeaps'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMemoryHeapsArray a + +class HasVkMemoryOffset a where + type VkMemoryOffsetMType a :: * + + vkMemoryOffset :: a -> VkMemoryOffsetMType a + + vkMemoryOffsetByteOffset :: a -> Int + + readVkMemoryOffset :: Ptr a -> IO (VkMemoryOffsetMType a) + + writeVkMemoryOffset :: Ptr a -> VkMemoryOffsetMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'memoryOffset'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMemoryOffset a + +class HasVkMemoryProperties a where + type VkMemoryPropertiesMType a :: * + + vkMemoryProperties :: a -> VkMemoryPropertiesMType a + + vkMemoryPropertiesByteOffset :: a -> Int + + readVkMemoryProperties :: Ptr a -> IO (VkMemoryPropertiesMType a) + + writeVkMemoryProperties :: + Ptr a -> VkMemoryPropertiesMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'memoryProperties'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMemoryProperties a + +class HasVkMemoryRequirements a where + type VkMemoryRequirementsMType a :: * + + vkMemoryRequirements :: a -> VkMemoryRequirementsMType a + + vkMemoryRequirementsByteOffset :: a -> Int + + readVkMemoryRequirements :: + Ptr a -> IO (VkMemoryRequirementsMType a) + + writeVkMemoryRequirements :: + Ptr a -> VkMemoryRequirementsMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'memoryRequirements'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMemoryRequirements a + +class HasVkMemoryTypeBits a where + type VkMemoryTypeBitsMType a :: * + + vkMemoryTypeBits :: a -> VkMemoryTypeBitsMType a + + vkMemoryTypeBitsByteOffset :: a -> Int + + readVkMemoryTypeBits :: Ptr a -> IO (VkMemoryTypeBitsMType a) + + writeVkMemoryTypeBits :: Ptr a -> VkMemoryTypeBitsMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'memoryTypeBits'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMemoryTypeBits a + +class HasVkMemoryTypeCount a where + type VkMemoryTypeCountMType a :: * + + vkMemoryTypeCount :: a -> VkMemoryTypeCountMType a + + vkMemoryTypeCountByteOffset :: a -> Int + + readVkMemoryTypeCount :: Ptr a -> IO (VkMemoryTypeCountMType a) + + writeVkMemoryTypeCount :: + Ptr a -> VkMemoryTypeCountMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'memoryTypeCount'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMemoryTypeCount a + +class HasVkMemoryTypeIndex a where + type VkMemoryTypeIndexMType a :: * + + vkMemoryTypeIndex :: a -> VkMemoryTypeIndexMType a + + vkMemoryTypeIndexByteOffset :: a -> Int + + readVkMemoryTypeIndex :: Ptr a -> IO (VkMemoryTypeIndexMType a) + + writeVkMemoryTypeIndex :: + Ptr a -> VkMemoryTypeIndexMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'memoryTypeIndex'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMemoryTypeIndex a + +class HasVkMemoryTypesArray a where + type VkMemoryTypesArrayMType a :: * + + vkMemoryTypesArray :: a -> Int -> VkMemoryTypesArrayMType a + + vkMemoryTypesArrayByteOffset :: a -> Int + + readVkMemoryTypesArray :: + Ptr a -> Int -> IO (VkMemoryTypesArrayMType a) + + writeVkMemoryTypesArray :: + Ptr a -> Int -> VkMemoryTypesArrayMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'memoryTypes'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMemoryTypesArray a + +class HasVkMinCommandsTokenBufferOffsetAlignment a where + type VkMinCommandsTokenBufferOffsetAlignmentMType a :: * + + vkMinCommandsTokenBufferOffsetAlignment :: + a -> VkMinCommandsTokenBufferOffsetAlignmentMType a + + vkMinCommandsTokenBufferOffsetAlignmentByteOffset :: a -> Int + + readVkMinCommandsTokenBufferOffsetAlignment :: + Ptr a -> + IO + (VkMinCommandsTokenBufferOffsetAlignmentMType + a) + + writeVkMinCommandsTokenBufferOffsetAlignment :: + Ptr a -> + VkMinCommandsTokenBufferOffsetAlignmentMType + a + -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text + " does not seem to have field 'minCommandsTokenBufferOffsetAlignment'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMinCommandsTokenBufferOffsetAlignment a + +class HasVkMinDepth a where + type VkMinDepthMType a :: * + + vkMinDepth :: a -> VkMinDepthMType a + + vkMinDepthByteOffset :: a -> Int + + readVkMinDepth :: Ptr a -> IO (VkMinDepthMType a) + + writeVkMinDepth :: Ptr a -> VkMinDepthMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'minDepth'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMinDepth a + +class HasVkMinDepthBounds a where + type VkMinDepthBoundsMType a :: * + + vkMinDepthBounds :: a -> VkMinDepthBoundsMType a + + vkMinDepthBoundsByteOffset :: a -> Int + + readVkMinDepthBounds :: Ptr a -> IO (VkMinDepthBoundsMType a) + + writeVkMinDepthBounds :: Ptr a -> VkMinDepthBoundsMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'minDepthBounds'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMinDepthBounds a + +class HasVkMinDstExtent a where + type VkMinDstExtentMType a :: * + + vkMinDstExtent :: a -> VkMinDstExtentMType a + + vkMinDstExtentByteOffset :: a -> Int + + readVkMinDstExtent :: Ptr a -> IO (VkMinDstExtentMType a) + + writeVkMinDstExtent :: Ptr a -> VkMinDstExtentMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'minDstExtent'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMinDstExtent a + +class HasVkMinDstPosition a where + type VkMinDstPositionMType a :: * + + vkMinDstPosition :: a -> VkMinDstPositionMType a + + vkMinDstPositionByteOffset :: a -> Int + + readVkMinDstPosition :: Ptr a -> IO (VkMinDstPositionMType a) + + writeVkMinDstPosition :: Ptr a -> VkMinDstPositionMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'minDstPosition'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMinDstPosition a + +class HasVkMinFilter a where + type VkMinFilterMType a :: * + + vkMinFilter :: a -> VkMinFilterMType a + + vkMinFilterByteOffset :: a -> Int + + readVkMinFilter :: Ptr a -> IO (VkMinFilterMType a) + + writeVkMinFilter :: Ptr a -> VkMinFilterMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'minFilter'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMinFilter a + +class HasVkMinImageCount a where + type VkMinImageCountMType a :: * + + vkMinImageCount :: a -> VkMinImageCountMType a + + vkMinImageCountByteOffset :: a -> Int + + readVkMinImageCount :: Ptr a -> IO (VkMinImageCountMType a) + + writeVkMinImageCount :: Ptr a -> VkMinImageCountMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'minImageCount'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMinImageCount a + +class HasVkMinImageExtent a where + type VkMinImageExtentMType a :: * + + vkMinImageExtent :: a -> VkMinImageExtentMType a + + vkMinImageExtentByteOffset :: a -> Int + + readVkMinImageExtent :: Ptr a -> IO (VkMinImageExtentMType a) + + writeVkMinImageExtent :: Ptr a -> VkMinImageExtentMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'minImageExtent'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMinImageExtent a + +class HasVkMinImageTransferGranularity a where + type VkMinImageTransferGranularityMType a :: * + + vkMinImageTransferGranularity :: + a -> VkMinImageTransferGranularityMType a + + vkMinImageTransferGranularityByteOffset :: a -> Int + + readVkMinImageTransferGranularity :: + Ptr a -> IO (VkMinImageTransferGranularityMType a) + + writeVkMinImageTransferGranularity :: + Ptr a -> VkMinImageTransferGranularityMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'minImageTransferGranularity'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMinImageTransferGranularity a + +class HasVkMinImportedHostPointerAlignment a where + type VkMinImportedHostPointerAlignmentMType a :: * + + vkMinImportedHostPointerAlignment :: + a -> VkMinImportedHostPointerAlignmentMType a + + vkMinImportedHostPointerAlignmentByteOffset :: a -> Int + + readVkMinImportedHostPointerAlignment :: + Ptr a -> IO (VkMinImportedHostPointerAlignmentMType a) + + writeVkMinImportedHostPointerAlignment :: + Ptr a -> + VkMinImportedHostPointerAlignmentMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text + " does not seem to have field 'minImportedHostPointerAlignment'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMinImportedHostPointerAlignment a + +class HasVkMinInterpolationOffset a where + type VkMinInterpolationOffsetMType a :: * + + vkMinInterpolationOffset :: a -> VkMinInterpolationOffsetMType a + + vkMinInterpolationOffsetByteOffset :: a -> Int + + readVkMinInterpolationOffset :: + Ptr a -> IO (VkMinInterpolationOffsetMType a) + + writeVkMinInterpolationOffset :: + Ptr a -> VkMinInterpolationOffsetMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'minInterpolationOffset'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMinInterpolationOffset a + +class HasVkMinLod a where + type VkMinLodMType a :: * + + vkMinLod :: a -> VkMinLodMType a + + vkMinLodByteOffset :: a -> Int + + readVkMinLod :: Ptr a -> IO (VkMinLodMType a) + + writeVkMinLod :: Ptr a -> VkMinLodMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'minLod'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMinLod a + +class HasVkMinLuminance a where + type VkMinLuminanceMType a :: * + + vkMinLuminance :: a -> VkMinLuminanceMType a + + vkMinLuminanceByteOffset :: a -> Int + + readVkMinLuminance :: Ptr a -> IO (VkMinLuminanceMType a) + + writeVkMinLuminance :: Ptr a -> VkMinLuminanceMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'minLuminance'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMinLuminance a + +class HasVkMinMemoryMapAlignment a where + type VkMinMemoryMapAlignmentMType a :: * + + vkMinMemoryMapAlignment :: a -> VkMinMemoryMapAlignmentMType a + + vkMinMemoryMapAlignmentByteOffset :: a -> Int + + readVkMinMemoryMapAlignment :: + Ptr a -> IO (VkMinMemoryMapAlignmentMType a) + + writeVkMinMemoryMapAlignment :: + Ptr a -> VkMinMemoryMapAlignmentMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'minMemoryMapAlignment'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMinMemoryMapAlignment a + +class HasVkMinSampleShading a where + type VkMinSampleShadingMType a :: * + + vkMinSampleShading :: a -> VkMinSampleShadingMType a + + vkMinSampleShadingByteOffset :: a -> Int + + readVkMinSampleShading :: Ptr a -> IO (VkMinSampleShadingMType a) + + writeVkMinSampleShading :: + Ptr a -> VkMinSampleShadingMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'minSampleShading'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMinSampleShading a + +class HasVkMinSequenceCountBufferOffsetAlignment a where + type VkMinSequenceCountBufferOffsetAlignmentMType a :: * + + vkMinSequenceCountBufferOffsetAlignment :: + a -> VkMinSequenceCountBufferOffsetAlignmentMType a + + vkMinSequenceCountBufferOffsetAlignmentByteOffset :: a -> Int + + readVkMinSequenceCountBufferOffsetAlignment :: + Ptr a -> + IO + (VkMinSequenceCountBufferOffsetAlignmentMType + a) + + writeVkMinSequenceCountBufferOffsetAlignment :: + Ptr a -> + VkMinSequenceCountBufferOffsetAlignmentMType + a + -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text + " does not seem to have field 'minSequenceCountBufferOffsetAlignment'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMinSequenceCountBufferOffsetAlignment a + +class HasVkMinSequenceIndexBufferOffsetAlignment a where + type VkMinSequenceIndexBufferOffsetAlignmentMType a :: * + + vkMinSequenceIndexBufferOffsetAlignment :: + a -> VkMinSequenceIndexBufferOffsetAlignmentMType a + + vkMinSequenceIndexBufferOffsetAlignmentByteOffset :: a -> Int + + readVkMinSequenceIndexBufferOffsetAlignment :: + Ptr a -> + IO + (VkMinSequenceIndexBufferOffsetAlignmentMType + a) + + writeVkMinSequenceIndexBufferOffsetAlignment :: + Ptr a -> + VkMinSequenceIndexBufferOffsetAlignmentMType + a + -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text + " does not seem to have field 'minSequenceIndexBufferOffsetAlignment'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMinSequenceIndexBufferOffsetAlignment a + +class HasVkMinSrcExtent a where + type VkMinSrcExtentMType a :: * + + vkMinSrcExtent :: a -> VkMinSrcExtentMType a + + vkMinSrcExtentByteOffset :: a -> Int + + readVkMinSrcExtent :: Ptr a -> IO (VkMinSrcExtentMType a) + + writeVkMinSrcExtent :: Ptr a -> VkMinSrcExtentMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'minSrcExtent'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMinSrcExtent a + +class HasVkMinSrcPosition a where + type VkMinSrcPositionMType a :: * + + vkMinSrcPosition :: a -> VkMinSrcPositionMType a + + vkMinSrcPositionByteOffset :: a -> Int + + readVkMinSrcPosition :: Ptr a -> IO (VkMinSrcPositionMType a) + + writeVkMinSrcPosition :: Ptr a -> VkMinSrcPositionMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'minSrcPosition'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMinSrcPosition a + +class HasVkMinStorageBufferOffsetAlignment a where + type VkMinStorageBufferOffsetAlignmentMType a :: * + + vkMinStorageBufferOffsetAlignment :: + a -> VkMinStorageBufferOffsetAlignmentMType a + + vkMinStorageBufferOffsetAlignmentByteOffset :: a -> Int + + readVkMinStorageBufferOffsetAlignment :: + Ptr a -> IO (VkMinStorageBufferOffsetAlignmentMType a) + + writeVkMinStorageBufferOffsetAlignment :: + Ptr a -> + VkMinStorageBufferOffsetAlignmentMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text + " does not seem to have field 'minStorageBufferOffsetAlignment'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMinStorageBufferOffsetAlignment a + +class HasVkMinTexelBufferOffsetAlignment a where + type VkMinTexelBufferOffsetAlignmentMType a :: * + + vkMinTexelBufferOffsetAlignment :: + a -> VkMinTexelBufferOffsetAlignmentMType a + + vkMinTexelBufferOffsetAlignmentByteOffset :: a -> Int + + readVkMinTexelBufferOffsetAlignment :: + Ptr a -> IO (VkMinTexelBufferOffsetAlignmentMType a) + + writeVkMinTexelBufferOffsetAlignment :: + Ptr a -> + VkMinTexelBufferOffsetAlignmentMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text + " does not seem to have field 'minTexelBufferOffsetAlignment'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMinTexelBufferOffsetAlignment a + +class HasVkMinTexelGatherOffset a where + type VkMinTexelGatherOffsetMType a :: * + + vkMinTexelGatherOffset :: a -> VkMinTexelGatherOffsetMType a + + vkMinTexelGatherOffsetByteOffset :: a -> Int + + readVkMinTexelGatherOffset :: + Ptr a -> IO (VkMinTexelGatherOffsetMType a) + + writeVkMinTexelGatherOffset :: + Ptr a -> VkMinTexelGatherOffsetMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'minTexelGatherOffset'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMinTexelGatherOffset a + +class HasVkMinTexelOffset a where + type VkMinTexelOffsetMType a :: * + + vkMinTexelOffset :: a -> VkMinTexelOffsetMType a + + vkMinTexelOffsetByteOffset :: a -> Int + + readVkMinTexelOffset :: Ptr a -> IO (VkMinTexelOffsetMType a) + + writeVkMinTexelOffset :: Ptr a -> VkMinTexelOffsetMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'minTexelOffset'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMinTexelOffset a + +class HasVkMinUniformBufferOffsetAlignment a where + type VkMinUniformBufferOffsetAlignmentMType a :: * + + vkMinUniformBufferOffsetAlignment :: + a -> VkMinUniformBufferOffsetAlignmentMType a + + vkMinUniformBufferOffsetAlignmentByteOffset :: a -> Int + + readVkMinUniformBufferOffsetAlignment :: + Ptr a -> IO (VkMinUniformBufferOffsetAlignmentMType a) + + writeVkMinUniformBufferOffsetAlignment :: + Ptr a -> + VkMinUniformBufferOffsetAlignmentMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text + " does not seem to have field 'minUniformBufferOffsetAlignment'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMinUniformBufferOffsetAlignment a + +class HasVkMipLevel a where + type VkMipLevelMType a :: * + + vkMipLevel :: a -> VkMipLevelMType a + + vkMipLevelByteOffset :: a -> Int + + readVkMipLevel :: Ptr a -> IO (VkMipLevelMType a) + + writeVkMipLevel :: Ptr a -> VkMipLevelMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'mipLevel'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMipLevel a + +class HasVkMipLevels a where + type VkMipLevelsMType a :: * + + vkMipLevels :: a -> VkMipLevelsMType a + + vkMipLevelsByteOffset :: a -> Int + + readVkMipLevels :: Ptr a -> IO (VkMipLevelsMType a) + + writeVkMipLevels :: Ptr a -> VkMipLevelsMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'mipLevels'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMipLevels a + +class HasVkMipLodBias a where + type VkMipLodBiasMType a :: * + + vkMipLodBias :: a -> VkMipLodBiasMType a + + vkMipLodBiasByteOffset :: a -> Int + + readVkMipLodBias :: Ptr a -> IO (VkMipLodBiasMType a) + + writeVkMipLodBias :: Ptr a -> VkMipLodBiasMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'mipLodBias'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMipLodBias a + +class HasVkMipmapMode a where + type VkMipmapModeMType a :: * + + vkMipmapMode :: a -> VkMipmapModeMType a + + vkMipmapModeByteOffset :: a -> Int + + readVkMipmapMode :: Ptr a -> IO (VkMipmapModeMType a) + + writeVkMipmapMode :: Ptr a -> VkMipmapModeMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'mipmapMode'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMipmapMode a + +class HasVkMipmapPrecisionBits a where + type VkMipmapPrecisionBitsMType a :: * + + vkMipmapPrecisionBits :: a -> VkMipmapPrecisionBitsMType a + + vkMipmapPrecisionBitsByteOffset :: a -> Int + + readVkMipmapPrecisionBits :: + Ptr a -> IO (VkMipmapPrecisionBitsMType a) + + writeVkMipmapPrecisionBits :: + Ptr a -> VkMipmapPrecisionBitsMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'mipmapPrecisionBits'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMipmapPrecisionBits a + +class HasVkMirSurface a where + type VkMirSurfaceMType a :: * + + vkMirSurface :: a -> VkMirSurfaceMType a + + vkMirSurfaceByteOffset :: a -> Int + + readVkMirSurface :: Ptr a -> IO (VkMirSurfaceMType a) + + writeVkMirSurface :: Ptr a -> VkMirSurfaceMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'mirSurface'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMirSurface a + +class HasVkMode a where + type VkModeMType a :: * + + vkMode :: a -> VkModeMType a + + vkModeByteOffset :: a -> Int + + readVkMode :: Ptr a -> IO (VkModeMType a) + + writeVkMode :: Ptr a -> VkModeMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'mode'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMode a + +class HasVkModes a where + type VkModesMType a :: * + + vkModes :: a -> VkModesMType a + + vkModesByteOffset :: a -> Int + + readVkModes :: Ptr a -> IO (VkModesMType a) + + writeVkModes :: Ptr a -> VkModesMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'modes'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkModes a + +class HasVkModule a where + type VkModuleMType a :: * + + vkModule :: a -> VkModuleMType a + + vkModuleByteOffset :: a -> Int + + readVkModule :: Ptr a -> IO (VkModuleMType a) + + writeVkModule :: Ptr a -> VkModuleMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'module'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkModule a + +class HasVkMultiDrawIndirect a where + type VkMultiDrawIndirectMType a :: * + + vkMultiDrawIndirect :: a -> VkMultiDrawIndirectMType a + + vkMultiDrawIndirectByteOffset :: a -> Int + + readVkMultiDrawIndirect :: Ptr a -> IO (VkMultiDrawIndirectMType a) + + writeVkMultiDrawIndirect :: + Ptr a -> VkMultiDrawIndirectMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'multiDrawIndirect'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMultiDrawIndirect a + +class HasVkMultiViewport a where + type VkMultiViewportMType a :: * + + vkMultiViewport :: a -> VkMultiViewportMType a + + vkMultiViewportByteOffset :: a -> Int + + readVkMultiViewport :: Ptr a -> IO (VkMultiViewportMType a) + + writeVkMultiViewport :: Ptr a -> VkMultiViewportMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'multiViewport'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMultiViewport a + +class HasVkMultiview a where + type VkMultiviewMType a :: * + + vkMultiview :: a -> VkMultiviewMType a + + vkMultiviewByteOffset :: a -> Int + + readVkMultiview :: Ptr a -> IO (VkMultiviewMType a) + + writeVkMultiview :: Ptr a -> VkMultiviewMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'multiview'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMultiview a + +class HasVkMultiviewGeometryShader a where + type VkMultiviewGeometryShaderMType a :: * + + vkMultiviewGeometryShader :: a -> VkMultiviewGeometryShaderMType a + + vkMultiviewGeometryShaderByteOffset :: a -> Int + + readVkMultiviewGeometryShader :: + Ptr a -> IO (VkMultiviewGeometryShaderMType a) + + writeVkMultiviewGeometryShader :: + Ptr a -> VkMultiviewGeometryShaderMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'multiviewGeometryShader'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMultiviewGeometryShader a + +class HasVkMultiviewTessellationShader a where + type VkMultiviewTessellationShaderMType a :: * + + vkMultiviewTessellationShader :: + a -> VkMultiviewTessellationShaderMType a + + vkMultiviewTessellationShaderByteOffset :: a -> Int + + readVkMultiviewTessellationShader :: + Ptr a -> IO (VkMultiviewTessellationShaderMType a) + + writeVkMultiviewTessellationShader :: + Ptr a -> VkMultiviewTessellationShaderMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'multiviewTessellationShader'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkMultiviewTessellationShader a + +class HasVkName a where + type VkNameMType a :: * + + vkName :: a -> VkNameMType a + + vkNameByteOffset :: a -> Int + + readVkName :: Ptr a -> IO (VkNameMType a) + + writeVkName :: Ptr a -> VkNameMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'name'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkName a + +class HasVkNewLayout a where + type VkNewLayoutMType a :: * + + vkNewLayout :: a -> VkNewLayoutMType a + + vkNewLayoutByteOffset :: a -> Int + + readVkNewLayout :: Ptr a -> IO (VkNewLayoutMType a) + + writeVkNewLayout :: Ptr a -> VkNewLayoutMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'newLayout'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkNewLayout a + +class HasVkNonCoherentAtomSize a where + type VkNonCoherentAtomSizeMType a :: * + + vkNonCoherentAtomSize :: a -> VkNonCoherentAtomSizeMType a + + vkNonCoherentAtomSizeByteOffset :: a -> Int + + readVkNonCoherentAtomSize :: + Ptr a -> IO (VkNonCoherentAtomSizeMType a) + + writeVkNonCoherentAtomSize :: + Ptr a -> VkNonCoherentAtomSizeMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'nonCoherentAtomSize'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkNonCoherentAtomSize a + +class HasVkNumAvailableSgprs a where + type VkNumAvailableSgprsMType a :: * + + vkNumAvailableSgprs :: a -> VkNumAvailableSgprsMType a + + vkNumAvailableSgprsByteOffset :: a -> Int + + readVkNumAvailableSgprs :: Ptr a -> IO (VkNumAvailableSgprsMType a) + + writeVkNumAvailableSgprs :: + Ptr a -> VkNumAvailableSgprsMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'numAvailableSgprs'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkNumAvailableSgprs a + +class HasVkNumAvailableVgprs a where + type VkNumAvailableVgprsMType a :: * + + vkNumAvailableVgprs :: a -> VkNumAvailableVgprsMType a + + vkNumAvailableVgprsByteOffset :: a -> Int + + readVkNumAvailableVgprs :: Ptr a -> IO (VkNumAvailableVgprsMType a) + + writeVkNumAvailableVgprs :: + Ptr a -> VkNumAvailableVgprsMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'numAvailableVgprs'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkNumAvailableVgprs a + +class HasVkNumPhysicalSgprs a where + type VkNumPhysicalSgprsMType a :: * + + vkNumPhysicalSgprs :: a -> VkNumPhysicalSgprsMType a + + vkNumPhysicalSgprsByteOffset :: a -> Int + + readVkNumPhysicalSgprs :: Ptr a -> IO (VkNumPhysicalSgprsMType a) + + writeVkNumPhysicalSgprs :: + Ptr a -> VkNumPhysicalSgprsMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'numPhysicalSgprs'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkNumPhysicalSgprs a + +class HasVkNumPhysicalVgprs a where + type VkNumPhysicalVgprsMType a :: * + + vkNumPhysicalVgprs :: a -> VkNumPhysicalVgprsMType a + + vkNumPhysicalVgprsByteOffset :: a -> Int + + readVkNumPhysicalVgprs :: Ptr a -> IO (VkNumPhysicalVgprsMType a) + + writeVkNumPhysicalVgprs :: + Ptr a -> VkNumPhysicalVgprsMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'numPhysicalVgprs'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkNumPhysicalVgprs a + +class HasVkNumUsedSgprs a where + type VkNumUsedSgprsMType a :: * + + vkNumUsedSgprs :: a -> VkNumUsedSgprsMType a + + vkNumUsedSgprsByteOffset :: a -> Int + + readVkNumUsedSgprs :: Ptr a -> IO (VkNumUsedSgprsMType a) + + writeVkNumUsedSgprs :: Ptr a -> VkNumUsedSgprsMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'numUsedSgprs'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkNumUsedSgprs a + +class HasVkNumUsedVgprs a where + type VkNumUsedVgprsMType a :: * + + vkNumUsedVgprs :: a -> VkNumUsedVgprsMType a + + vkNumUsedVgprsByteOffset :: a -> Int + + readVkNumUsedVgprs :: Ptr a -> IO (VkNumUsedVgprsMType a) + + writeVkNumUsedVgprs :: Ptr a -> VkNumUsedVgprsMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'numUsedVgprs'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkNumUsedVgprs a + +class HasVkObject a where + type VkObjectMType a :: * + + vkObject :: a -> VkObjectMType a + + vkObjectByteOffset :: a -> Int + + readVkObject :: Ptr a -> IO (VkObjectMType a) + + writeVkObject :: Ptr a -> VkObjectMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'object'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkObject a + +class HasVkObjectCount a where + type VkObjectCountMType a :: * + + vkObjectCount :: a -> VkObjectCountMType a + + vkObjectCountByteOffset :: a -> Int + + readVkObjectCount :: Ptr a -> IO (VkObjectCountMType a) + + writeVkObjectCount :: Ptr a -> VkObjectCountMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'objectCount'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkObjectCount a + +class HasVkObjectTable a where + type VkObjectTableMType a :: * + + vkObjectTable :: a -> VkObjectTableMType a + + vkObjectTableByteOffset :: a -> Int + + readVkObjectTable :: Ptr a -> IO (VkObjectTableMType a) + + writeVkObjectTable :: Ptr a -> VkObjectTableMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'objectTable'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkObjectTable a + +class HasVkObjectType a where + type VkObjectTypeMType a :: * + + vkObjectType :: a -> VkObjectTypeMType a + + vkObjectTypeByteOffset :: a -> Int + + readVkObjectType :: Ptr a -> IO (VkObjectTypeMType a) + + writeVkObjectType :: Ptr a -> VkObjectTypeMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'objectType'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkObjectType a + +class HasVkOcclusionQueryEnable a where + type VkOcclusionQueryEnableMType a :: * + + vkOcclusionQueryEnable :: a -> VkOcclusionQueryEnableMType a + + vkOcclusionQueryEnableByteOffset :: a -> Int + + readVkOcclusionQueryEnable :: + Ptr a -> IO (VkOcclusionQueryEnableMType a) + + writeVkOcclusionQueryEnable :: + Ptr a -> VkOcclusionQueryEnableMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'occlusionQueryEnable'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkOcclusionQueryEnable a + +class HasVkOcclusionQueryPrecise a where + type VkOcclusionQueryPreciseMType a :: * + + vkOcclusionQueryPrecise :: a -> VkOcclusionQueryPreciseMType a + + vkOcclusionQueryPreciseByteOffset :: a -> Int + + readVkOcclusionQueryPrecise :: + Ptr a -> IO (VkOcclusionQueryPreciseMType a) + + writeVkOcclusionQueryPrecise :: + Ptr a -> VkOcclusionQueryPreciseMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'occlusionQueryPrecise'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkOcclusionQueryPrecise a + +class HasVkOffset a where + type VkOffsetMType a :: * + + vkOffset :: a -> VkOffsetMType a + + vkOffsetByteOffset :: a -> Int + + readVkOffset :: Ptr a -> IO (VkOffsetMType a) + + writeVkOffset :: Ptr a -> VkOffsetMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'offset'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkOffset a + +class HasVkOldLayout a where + type VkOldLayoutMType a :: * + + vkOldLayout :: a -> VkOldLayoutMType a + + vkOldLayoutByteOffset :: a -> Int + + readVkOldLayout :: Ptr a -> IO (VkOldLayoutMType a) + + writeVkOldLayout :: Ptr a -> VkOldLayoutMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'oldLayout'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkOldLayout a + +class HasVkOldSwapchain a where + type VkOldSwapchainMType a :: * + + vkOldSwapchain :: a -> VkOldSwapchainMType a + + vkOldSwapchainByteOffset :: a -> Int + + readVkOldSwapchain :: Ptr a -> IO (VkOldSwapchainMType a) + + writeVkOldSwapchain :: Ptr a -> VkOldSwapchainMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'oldSwapchain'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkOldSwapchain a + +class HasVkOptimalBufferCopyOffsetAlignment a where + type VkOptimalBufferCopyOffsetAlignmentMType a :: * + + vkOptimalBufferCopyOffsetAlignment :: + a -> VkOptimalBufferCopyOffsetAlignmentMType a + + vkOptimalBufferCopyOffsetAlignmentByteOffset :: a -> Int + + readVkOptimalBufferCopyOffsetAlignment :: + Ptr a -> + IO (VkOptimalBufferCopyOffsetAlignmentMType a) + + writeVkOptimalBufferCopyOffsetAlignment :: + Ptr a -> + VkOptimalBufferCopyOffsetAlignmentMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text + " does not seem to have field 'optimalBufferCopyOffsetAlignment'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkOptimalBufferCopyOffsetAlignment a + +class HasVkOptimalBufferCopyRowPitchAlignment a where + type VkOptimalBufferCopyRowPitchAlignmentMType a :: * + + vkOptimalBufferCopyRowPitchAlignment :: + a -> VkOptimalBufferCopyRowPitchAlignmentMType a + + vkOptimalBufferCopyRowPitchAlignmentByteOffset :: a -> Int + + readVkOptimalBufferCopyRowPitchAlignment :: + Ptr a -> + IO (VkOptimalBufferCopyRowPitchAlignmentMType a) + + writeVkOptimalBufferCopyRowPitchAlignment :: + Ptr a -> + VkOptimalBufferCopyRowPitchAlignmentMType a -> + IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text + " does not seem to have field 'optimalBufferCopyRowPitchAlignment'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkOptimalBufferCopyRowPitchAlignment a + +class HasVkOptimalTilingFeatures a where + type VkOptimalTilingFeaturesMType a :: * + + vkOptimalTilingFeatures :: a -> VkOptimalTilingFeaturesMType a + + vkOptimalTilingFeaturesByteOffset :: a -> Int + + readVkOptimalTilingFeatures :: + Ptr a -> IO (VkOptimalTilingFeaturesMType a) + + writeVkOptimalTilingFeatures :: + Ptr a -> VkOptimalTilingFeaturesMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'optimalTilingFeatures'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkOptimalTilingFeatures a + +class HasVkPAcquireKeys a where + type VkPAcquireKeysMType a :: * + + vkPAcquireKeys :: a -> VkPAcquireKeysMType a + + vkPAcquireKeysByteOffset :: a -> Int + + readVkPAcquireKeys :: Ptr a -> IO (VkPAcquireKeysMType a) + + writeVkPAcquireKeys :: Ptr a -> VkPAcquireKeysMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pAcquireKeys'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPAcquireKeys a + +class HasVkPAcquireSyncs a where + type VkPAcquireSyncsMType a :: * + + vkPAcquireSyncs :: a -> VkPAcquireSyncsMType a + + vkPAcquireSyncsByteOffset :: a -> Int + + readVkPAcquireSyncs :: Ptr a -> IO (VkPAcquireSyncsMType a) + + writeVkPAcquireSyncs :: Ptr a -> VkPAcquireSyncsMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pAcquireSyncs'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPAcquireSyncs a + +class HasVkPAcquireTimeoutMilliseconds a where + type VkPAcquireTimeoutMillisecondsMType a :: * + + vkPAcquireTimeoutMilliseconds :: + a -> VkPAcquireTimeoutMillisecondsMType a + + vkPAcquireTimeoutMillisecondsByteOffset :: a -> Int + + readVkPAcquireTimeoutMilliseconds :: + Ptr a -> IO (VkPAcquireTimeoutMillisecondsMType a) + + writeVkPAcquireTimeoutMilliseconds :: + Ptr a -> VkPAcquireTimeoutMillisecondsMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pAcquireTimeoutMilliseconds'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPAcquireTimeoutMilliseconds a + +class HasVkPAcquireTimeouts a where + type VkPAcquireTimeoutsMType a :: * + + vkPAcquireTimeouts :: a -> VkPAcquireTimeoutsMType a + + vkPAcquireTimeoutsByteOffset :: a -> Int + + readVkPAcquireTimeouts :: Ptr a -> IO (VkPAcquireTimeoutsMType a) + + writeVkPAcquireTimeouts :: + Ptr a -> VkPAcquireTimeoutsMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pAcquireTimeouts'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPAcquireTimeouts a + +class HasVkPApplicationInfo a where + type VkPApplicationInfoMType a :: * + + vkPApplicationInfo :: a -> VkPApplicationInfoMType a + + vkPApplicationInfoByteOffset :: a -> Int + + readVkPApplicationInfo :: Ptr a -> IO (VkPApplicationInfoMType a) + + writeVkPApplicationInfo :: + Ptr a -> VkPApplicationInfoMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pApplicationInfo'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPApplicationInfo a + +class HasVkPApplicationName a where + type VkPApplicationNameMType a :: * + + vkPApplicationName :: a -> VkPApplicationNameMType a + + vkPApplicationNameByteOffset :: a -> Int + + readVkPApplicationName :: Ptr a -> IO (VkPApplicationNameMType a) + + writeVkPApplicationName :: + Ptr a -> VkPApplicationNameMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pApplicationName'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPApplicationName a + +class HasVkPAspectReferences a where + type VkPAspectReferencesMType a :: * + + vkPAspectReferences :: a -> VkPAspectReferencesMType a + + vkPAspectReferencesByteOffset :: a -> Int + + readVkPAspectReferences :: Ptr a -> IO (VkPAspectReferencesMType a) + + writeVkPAspectReferences :: + Ptr a -> VkPAspectReferencesMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pAspectReferences'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPAspectReferences a + +class HasVkPAttachmentInitialSampleLocations a where + type VkPAttachmentInitialSampleLocationsMType a :: * + + vkPAttachmentInitialSampleLocations :: + a -> VkPAttachmentInitialSampleLocationsMType a + + vkPAttachmentInitialSampleLocationsByteOffset :: a -> Int + + readVkPAttachmentInitialSampleLocations :: + Ptr a -> + IO (VkPAttachmentInitialSampleLocationsMType a) + + writeVkPAttachmentInitialSampleLocations :: + Ptr a -> + VkPAttachmentInitialSampleLocationsMType a -> + IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text + " does not seem to have field 'pAttachmentInitialSampleLocations'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPAttachmentInitialSampleLocations a + +class HasVkPAttachments a where + type VkPAttachmentsMType a :: * + + vkPAttachments :: a -> VkPAttachmentsMType a + + vkPAttachmentsByteOffset :: a -> Int + + readVkPAttachments :: Ptr a -> IO (VkPAttachmentsMType a) + + writeVkPAttachments :: Ptr a -> VkPAttachmentsMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pAttachments'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPAttachments a + +class HasVkPAttributes a where + type VkPAttributesMType a :: * + + vkPAttributes :: a -> VkPAttributesMType a + + vkPAttributesByteOffset :: a -> Int + + readVkPAttributes :: Ptr a -> IO (VkPAttributesMType a) + + writeVkPAttributes :: Ptr a -> VkPAttributesMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pAttributes'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPAttributes a + +class HasVkPBindings a where + type VkPBindingsMType a :: * + + vkPBindings :: a -> VkPBindingsMType a + + vkPBindingsByteOffset :: a -> Int + + readVkPBindings :: Ptr a -> IO (VkPBindingsMType a) + + writeVkPBindings :: Ptr a -> VkPBindingsMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pBindings'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPBindings a + +class HasVkPBinds a where + type VkPBindsMType a :: * + + vkPBinds :: a -> VkPBindsMType a + + vkPBindsByteOffset :: a -> Int + + readVkPBinds :: Ptr a -> IO (VkPBindsMType a) + + writeVkPBinds :: Ptr a -> VkPBindsMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pBinds'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPBinds a + +class HasVkPBufferBinds a where + type VkPBufferBindsMType a :: * + + vkPBufferBinds :: a -> VkPBufferBindsMType a + + vkPBufferBindsByteOffset :: a -> Int + + readVkPBufferBinds :: Ptr a -> IO (VkPBufferBindsMType a) + + writeVkPBufferBinds :: Ptr a -> VkPBufferBindsMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pBufferBinds'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPBufferBinds a + +class HasVkPBufferInfo a where + type VkPBufferInfoMType a :: * + + vkPBufferInfo :: a -> VkPBufferInfoMType a + + vkPBufferInfoByteOffset :: a -> Int + + readVkPBufferInfo :: Ptr a -> IO (VkPBufferInfoMType a) + + writeVkPBufferInfo :: Ptr a -> VkPBufferInfoMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pBufferInfo'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPBufferInfo a + +class HasVkPClearValues a where + type VkPClearValuesMType a :: * + + vkPClearValues :: a -> VkPClearValuesMType a + + vkPClearValuesByteOffset :: a -> Int + + readVkPClearValues :: Ptr a -> IO (VkPClearValuesMType a) + + writeVkPClearValues :: Ptr a -> VkPClearValuesMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pClearValues'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPClearValues a + +class HasVkPCode a where + type VkPCodeMType a :: * + + vkPCode :: a -> VkPCodeMType a + + vkPCodeByteOffset :: a -> Int + + readVkPCode :: Ptr a -> IO (VkPCodeMType a) + + writeVkPCode :: Ptr a -> VkPCodeMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pCode'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPCode a + +class HasVkPColorAttachments a where + type VkPColorAttachmentsMType a :: * + + vkPColorAttachments :: a -> VkPColorAttachmentsMType a + + vkPColorAttachmentsByteOffset :: a -> Int + + readVkPColorAttachments :: Ptr a -> IO (VkPColorAttachmentsMType a) + + writeVkPColorAttachments :: + Ptr a -> VkPColorAttachmentsMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pColorAttachments'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPColorAttachments a + +class HasVkPColorBlendState a where + type VkPColorBlendStateMType a :: * + + vkPColorBlendState :: a -> VkPColorBlendStateMType a + + vkPColorBlendStateByteOffset :: a -> Int + + readVkPColorBlendState :: Ptr a -> IO (VkPColorBlendStateMType a) + + writeVkPColorBlendState :: + Ptr a -> VkPColorBlendStateMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pColorBlendState'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPColorBlendState a + +class HasVkPCommandBufferDeviceMasks a where + type VkPCommandBufferDeviceMasksMType a :: * + + vkPCommandBufferDeviceMasks :: + a -> VkPCommandBufferDeviceMasksMType a + + vkPCommandBufferDeviceMasksByteOffset :: a -> Int + + readVkPCommandBufferDeviceMasks :: + Ptr a -> IO (VkPCommandBufferDeviceMasksMType a) + + writeVkPCommandBufferDeviceMasks :: + Ptr a -> VkPCommandBufferDeviceMasksMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pCommandBufferDeviceMasks'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPCommandBufferDeviceMasks a + +class HasVkPCommandBuffers a where + type VkPCommandBuffersMType a :: * + + vkPCommandBuffers :: a -> VkPCommandBuffersMType a + + vkPCommandBuffersByteOffset :: a -> Int + + readVkPCommandBuffers :: Ptr a -> IO (VkPCommandBuffersMType a) + + writeVkPCommandBuffers :: + Ptr a -> VkPCommandBuffersMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pCommandBuffers'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPCommandBuffers a + +class HasVkPCorrelationMasks a where + type VkPCorrelationMasksMType a :: * + + vkPCorrelationMasks :: a -> VkPCorrelationMasksMType a + + vkPCorrelationMasksByteOffset :: a -> Int + + readVkPCorrelationMasks :: Ptr a -> IO (VkPCorrelationMasksMType a) + + writeVkPCorrelationMasks :: + Ptr a -> VkPCorrelationMasksMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pCorrelationMasks'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPCorrelationMasks a + +class HasVkPCoverageModulationTable a where + type VkPCoverageModulationTableMType a :: * + + vkPCoverageModulationTable :: + a -> VkPCoverageModulationTableMType a + + vkPCoverageModulationTableByteOffset :: a -> Int + + readVkPCoverageModulationTable :: + Ptr a -> IO (VkPCoverageModulationTableMType a) + + writeVkPCoverageModulationTable :: + Ptr a -> VkPCoverageModulationTableMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pCoverageModulationTable'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPCoverageModulationTable a + +class HasVkPData a where + type VkPDataMType a :: * + + vkPData :: a -> VkPDataMType a + + vkPDataByteOffset :: a -> Int + + readVkPData :: Ptr a -> IO (VkPDataMType a) + + writeVkPData :: Ptr a -> VkPDataMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pData'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPData a + +class HasVkPDependencies a where + type VkPDependenciesMType a :: * + + vkPDependencies :: a -> VkPDependenciesMType a + + vkPDependenciesByteOffset :: a -> Int + + readVkPDependencies :: Ptr a -> IO (VkPDependenciesMType a) + + writeVkPDependencies :: Ptr a -> VkPDependenciesMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pDependencies'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPDependencies a + +class HasVkPDepthStencilAttachment a where + type VkPDepthStencilAttachmentMType a :: * + + vkPDepthStencilAttachment :: a -> VkPDepthStencilAttachmentMType a + + vkPDepthStencilAttachmentByteOffset :: a -> Int + + readVkPDepthStencilAttachment :: + Ptr a -> IO (VkPDepthStencilAttachmentMType a) + + writeVkPDepthStencilAttachment :: + Ptr a -> VkPDepthStencilAttachmentMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pDepthStencilAttachment'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPDepthStencilAttachment a + +class HasVkPDepthStencilState a where + type VkPDepthStencilStateMType a :: * + + vkPDepthStencilState :: a -> VkPDepthStencilStateMType a + + vkPDepthStencilStateByteOffset :: a -> Int + + readVkPDepthStencilState :: + Ptr a -> IO (VkPDepthStencilStateMType a) + + writeVkPDepthStencilState :: + Ptr a -> VkPDepthStencilStateMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pDepthStencilState'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPDepthStencilState a + +class HasVkPDescriptorUpdateEntries a where + type VkPDescriptorUpdateEntriesMType a :: * + + vkPDescriptorUpdateEntries :: + a -> VkPDescriptorUpdateEntriesMType a + + vkPDescriptorUpdateEntriesByteOffset :: a -> Int + + readVkPDescriptorUpdateEntries :: + Ptr a -> IO (VkPDescriptorUpdateEntriesMType a) + + writeVkPDescriptorUpdateEntries :: + Ptr a -> VkPDescriptorUpdateEntriesMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pDescriptorUpdateEntries'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPDescriptorUpdateEntries a + +class HasVkPDeviceIndices a where + type VkPDeviceIndicesMType a :: * + + vkPDeviceIndices :: a -> VkPDeviceIndicesMType a + + vkPDeviceIndicesByteOffset :: a -> Int + + readVkPDeviceIndices :: Ptr a -> IO (VkPDeviceIndicesMType a) + + writeVkPDeviceIndices :: Ptr a -> VkPDeviceIndicesMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pDeviceIndices'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPDeviceIndices a + +class HasVkPDeviceMasks a where + type VkPDeviceMasksMType a :: * + + vkPDeviceMasks :: a -> VkPDeviceMasksMType a + + vkPDeviceMasksByteOffset :: a -> Int + + readVkPDeviceMasks :: Ptr a -> IO (VkPDeviceMasksMType a) + + writeVkPDeviceMasks :: Ptr a -> VkPDeviceMasksMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pDeviceMasks'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPDeviceMasks a + +class HasVkPDeviceRenderAreas a where + type VkPDeviceRenderAreasMType a :: * + + vkPDeviceRenderAreas :: a -> VkPDeviceRenderAreasMType a + + vkPDeviceRenderAreasByteOffset :: a -> Int + + readVkPDeviceRenderAreas :: + Ptr a -> IO (VkPDeviceRenderAreasMType a) + + writeVkPDeviceRenderAreas :: + Ptr a -> VkPDeviceRenderAreasMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pDeviceRenderAreas'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPDeviceRenderAreas a + +class HasVkPDisabledValidationChecks a where + type VkPDisabledValidationChecksMType a :: * + + vkPDisabledValidationChecks :: + a -> VkPDisabledValidationChecksMType a + + vkPDisabledValidationChecksByteOffset :: a -> Int + + readVkPDisabledValidationChecks :: + Ptr a -> IO (VkPDisabledValidationChecksMType a) + + writeVkPDisabledValidationChecks :: + Ptr a -> VkPDisabledValidationChecksMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pDisabledValidationChecks'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPDisabledValidationChecks a + +class HasVkPDiscardRectangles a where + type VkPDiscardRectanglesMType a :: * + + vkPDiscardRectangles :: a -> VkPDiscardRectanglesMType a + + vkPDiscardRectanglesByteOffset :: a -> Int + + readVkPDiscardRectangles :: + Ptr a -> IO (VkPDiscardRectanglesMType a) + + writeVkPDiscardRectangles :: + Ptr a -> VkPDiscardRectanglesMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pDiscardRectangles'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPDiscardRectangles a + +class HasVkPDynamicState a where + type VkPDynamicStateMType a :: * + + vkPDynamicState :: a -> VkPDynamicStateMType a + + vkPDynamicStateByteOffset :: a -> Int + + readVkPDynamicState :: Ptr a -> IO (VkPDynamicStateMType a) + + writeVkPDynamicState :: Ptr a -> VkPDynamicStateMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pDynamicState'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPDynamicState a + +class HasVkPDynamicStates a where + type VkPDynamicStatesMType a :: * + + vkPDynamicStates :: a -> VkPDynamicStatesMType a + + vkPDynamicStatesByteOffset :: a -> Int + + readVkPDynamicStates :: Ptr a -> IO (VkPDynamicStatesMType a) + + writeVkPDynamicStates :: Ptr a -> VkPDynamicStatesMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pDynamicStates'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPDynamicStates a + +class HasVkPEnabledFeatures a where + type VkPEnabledFeaturesMType a :: * + + vkPEnabledFeatures :: a -> VkPEnabledFeaturesMType a + + vkPEnabledFeaturesByteOffset :: a -> Int + + readVkPEnabledFeatures :: Ptr a -> IO (VkPEnabledFeaturesMType a) + + writeVkPEnabledFeatures :: + Ptr a -> VkPEnabledFeaturesMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pEnabledFeatures'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPEnabledFeatures a + +class HasVkPEngineName a where + type VkPEngineNameMType a :: * + + vkPEngineName :: a -> VkPEngineNameMType a + + vkPEngineNameByteOffset :: a -> Int + + readVkPEngineName :: Ptr a -> IO (VkPEngineNameMType a) + + writeVkPEngineName :: Ptr a -> VkPEngineNameMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pEngineName'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPEngineName a + +class HasVkPHostPointer a where + type VkPHostPointerMType a :: * + + vkPHostPointer :: a -> VkPHostPointerMType a + + vkPHostPointerByteOffset :: a -> Int + + readVkPHostPointer :: Ptr a -> IO (VkPHostPointerMType a) + + writeVkPHostPointer :: Ptr a -> VkPHostPointerMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pHostPointer'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPHostPointer a + +class HasVkPImageBinds a where + type VkPImageBindsMType a :: * + + vkPImageBinds :: a -> VkPImageBindsMType a + + vkPImageBindsByteOffset :: a -> Int + + readVkPImageBinds :: Ptr a -> IO (VkPImageBindsMType a) + + writeVkPImageBinds :: Ptr a -> VkPImageBindsMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pImageBinds'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPImageBinds a + +class HasVkPImageIndices a where + type VkPImageIndicesMType a :: * + + vkPImageIndices :: a -> VkPImageIndicesMType a + + vkPImageIndicesByteOffset :: a -> Int + + readVkPImageIndices :: Ptr a -> IO (VkPImageIndicesMType a) + + writeVkPImageIndices :: Ptr a -> VkPImageIndicesMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pImageIndices'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPImageIndices a + +class HasVkPImageInfo a where + type VkPImageInfoMType a :: * + + vkPImageInfo :: a -> VkPImageInfoMType a + + vkPImageInfoByteOffset :: a -> Int + + readVkPImageInfo :: Ptr a -> IO (VkPImageInfoMType a) + + writeVkPImageInfo :: Ptr a -> VkPImageInfoMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pImageInfo'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPImageInfo a + +class HasVkPImageOpaqueBinds a where + type VkPImageOpaqueBindsMType a :: * + + vkPImageOpaqueBinds :: a -> VkPImageOpaqueBindsMType a + + vkPImageOpaqueBindsByteOffset :: a -> Int + + readVkPImageOpaqueBinds :: Ptr a -> IO (VkPImageOpaqueBindsMType a) + + writeVkPImageOpaqueBinds :: + Ptr a -> VkPImageOpaqueBindsMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pImageOpaqueBinds'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPImageOpaqueBinds a + +class HasVkPImmutableSamplers a where + type VkPImmutableSamplersMType a :: * + + vkPImmutableSamplers :: a -> VkPImmutableSamplersMType a + + vkPImmutableSamplersByteOffset :: a -> Int + + readVkPImmutableSamplers :: + Ptr a -> IO (VkPImmutableSamplersMType a) + + writeVkPImmutableSamplers :: + Ptr a -> VkPImmutableSamplersMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pImmutableSamplers'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPImmutableSamplers a + +class HasVkPIndirectCommandsTokens a where + type VkPIndirectCommandsTokensMType a :: * + + vkPIndirectCommandsTokens :: a -> VkPIndirectCommandsTokensMType a + + vkPIndirectCommandsTokensByteOffset :: a -> Int + + readVkPIndirectCommandsTokens :: + Ptr a -> IO (VkPIndirectCommandsTokensMType a) + + writeVkPIndirectCommandsTokens :: + Ptr a -> VkPIndirectCommandsTokensMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pIndirectCommandsTokens'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPIndirectCommandsTokens a + +class HasVkPInheritanceInfo a where + type VkPInheritanceInfoMType a :: * + + vkPInheritanceInfo :: a -> VkPInheritanceInfoMType a + + vkPInheritanceInfoByteOffset :: a -> Int + + readVkPInheritanceInfo :: Ptr a -> IO (VkPInheritanceInfoMType a) + + writeVkPInheritanceInfo :: + Ptr a -> VkPInheritanceInfoMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pInheritanceInfo'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPInheritanceInfo a + +class HasVkPInitialData a where + type VkPInitialDataMType a :: * + + vkPInitialData :: a -> VkPInitialDataMType a + + vkPInitialDataByteOffset :: a -> Int + + readVkPInitialData :: Ptr a -> IO (VkPInitialDataMType a) + + writeVkPInitialData :: Ptr a -> VkPInitialDataMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pInitialData'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPInitialData a + +class HasVkPInputAssemblyState a where + type VkPInputAssemblyStateMType a :: * + + vkPInputAssemblyState :: a -> VkPInputAssemblyStateMType a + + vkPInputAssemblyStateByteOffset :: a -> Int + + readVkPInputAssemblyState :: + Ptr a -> IO (VkPInputAssemblyStateMType a) + + writeVkPInputAssemblyState :: + Ptr a -> VkPInputAssemblyStateMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pInputAssemblyState'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPInputAssemblyState a + +class HasVkPInputAttachments a where + type VkPInputAttachmentsMType a :: * + + vkPInputAttachments :: a -> VkPInputAttachmentsMType a + + vkPInputAttachmentsByteOffset :: a -> Int + + readVkPInputAttachments :: Ptr a -> IO (VkPInputAttachmentsMType a) + + writeVkPInputAttachments :: + Ptr a -> VkPInputAttachmentsMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pInputAttachments'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPInputAttachments a + +class HasVkPMapEntries a where + type VkPMapEntriesMType a :: * + + vkPMapEntries :: a -> VkPMapEntriesMType a + + vkPMapEntriesByteOffset :: a -> Int + + readVkPMapEntries :: Ptr a -> IO (VkPMapEntriesMType a) + + writeVkPMapEntries :: Ptr a -> VkPMapEntriesMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pMapEntries'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPMapEntries a + +class HasVkPMarkerName a where + type VkPMarkerNameMType a :: * + + vkPMarkerName :: a -> VkPMarkerNameMType a + + vkPMarkerNameByteOffset :: a -> Int + + readVkPMarkerName :: Ptr a -> IO (VkPMarkerNameMType a) + + writeVkPMarkerName :: Ptr a -> VkPMarkerNameMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pMarkerName'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPMarkerName a + +class HasVkPMultisampleState a where + type VkPMultisampleStateMType a :: * + + vkPMultisampleState :: a -> VkPMultisampleStateMType a + + vkPMultisampleStateByteOffset :: a -> Int + + readVkPMultisampleState :: Ptr a -> IO (VkPMultisampleStateMType a) + + writeVkPMultisampleState :: + Ptr a -> VkPMultisampleStateMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pMultisampleState'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPMultisampleState a + +class HasVkPName a where + type VkPNameMType a :: * + + vkPName :: a -> VkPNameMType a + + vkPNameByteOffset :: a -> Int + + readVkPName :: Ptr a -> IO (VkPNameMType a) + + writeVkPName :: Ptr a -> VkPNameMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pName'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPName a + +class HasVkPNext a where + type VkPNextMType a :: * + + vkPNext :: a -> VkPNextMType a + + vkPNextByteOffset :: a -> Int + + readVkPNext :: Ptr a -> IO (VkPNextMType a) + + writeVkPNext :: Ptr a -> VkPNextMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pNext'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPNext a + +class HasVkPObjectEntryCounts a where + type VkPObjectEntryCountsMType a :: * + + vkPObjectEntryCounts :: a -> VkPObjectEntryCountsMType a + + vkPObjectEntryCountsByteOffset :: a -> Int + + readVkPObjectEntryCounts :: + Ptr a -> IO (VkPObjectEntryCountsMType a) + + writeVkPObjectEntryCounts :: + Ptr a -> VkPObjectEntryCountsMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pObjectEntryCounts'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPObjectEntryCounts a + +class HasVkPObjectEntryTypes a where + type VkPObjectEntryTypesMType a :: * + + vkPObjectEntryTypes :: a -> VkPObjectEntryTypesMType a + + vkPObjectEntryTypesByteOffset :: a -> Int + + readVkPObjectEntryTypes :: Ptr a -> IO (VkPObjectEntryTypesMType a) + + writeVkPObjectEntryTypes :: + Ptr a -> VkPObjectEntryTypesMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pObjectEntryTypes'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPObjectEntryTypes a + +class HasVkPObjectEntryUsageFlags a where + type VkPObjectEntryUsageFlagsMType a :: * + + vkPObjectEntryUsageFlags :: a -> VkPObjectEntryUsageFlagsMType a + + vkPObjectEntryUsageFlagsByteOffset :: a -> Int + + readVkPObjectEntryUsageFlags :: + Ptr a -> IO (VkPObjectEntryUsageFlagsMType a) + + writeVkPObjectEntryUsageFlags :: + Ptr a -> VkPObjectEntryUsageFlagsMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pObjectEntryUsageFlags'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPObjectEntryUsageFlags a + +class HasVkPObjectName a where + type VkPObjectNameMType a :: * + + vkPObjectName :: a -> VkPObjectNameMType a + + vkPObjectNameByteOffset :: a -> Int + + readVkPObjectName :: Ptr a -> IO (VkPObjectNameMType a) + + writeVkPObjectName :: Ptr a -> VkPObjectNameMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pObjectName'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPObjectName a + +class HasVkPPhysicalDevices a where + type VkPPhysicalDevicesMType a :: * + + vkPPhysicalDevices :: a -> VkPPhysicalDevicesMType a + + vkPPhysicalDevicesByteOffset :: a -> Int + + readVkPPhysicalDevices :: Ptr a -> IO (VkPPhysicalDevicesMType a) + + writeVkPPhysicalDevices :: + Ptr a -> VkPPhysicalDevicesMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pPhysicalDevices'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPPhysicalDevices a + +class HasVkPPoolSizes a where + type VkPPoolSizesMType a :: * + + vkPPoolSizes :: a -> VkPPoolSizesMType a + + vkPPoolSizesByteOffset :: a -> Int + + readVkPPoolSizes :: Ptr a -> IO (VkPPoolSizesMType a) + + writeVkPPoolSizes :: Ptr a -> VkPPoolSizesMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pPoolSizes'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPPoolSizes a + +class HasVkPPostSubpassSampleLocations a where + type VkPPostSubpassSampleLocationsMType a :: * + + vkPPostSubpassSampleLocations :: + a -> VkPPostSubpassSampleLocationsMType a + + vkPPostSubpassSampleLocationsByteOffset :: a -> Int + + readVkPPostSubpassSampleLocations :: + Ptr a -> IO (VkPPostSubpassSampleLocationsMType a) + + writeVkPPostSubpassSampleLocations :: + Ptr a -> VkPPostSubpassSampleLocationsMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pPostSubpassSampleLocations'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPPostSubpassSampleLocations a + +class HasVkPPreserveAttachments a where + type VkPPreserveAttachmentsMType a :: * + + vkPPreserveAttachments :: a -> VkPPreserveAttachmentsMType a + + vkPPreserveAttachmentsByteOffset :: a -> Int + + readVkPPreserveAttachments :: + Ptr a -> IO (VkPPreserveAttachmentsMType a) + + writeVkPPreserveAttachments :: + Ptr a -> VkPPreserveAttachmentsMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pPreserveAttachments'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPPreserveAttachments a + +class HasVkPPushConstantRanges a where + type VkPPushConstantRangesMType a :: * + + vkPPushConstantRanges :: a -> VkPPushConstantRangesMType a + + vkPPushConstantRangesByteOffset :: a -> Int + + readVkPPushConstantRanges :: + Ptr a -> IO (VkPPushConstantRangesMType a) + + writeVkPPushConstantRanges :: + Ptr a -> VkPPushConstantRangesMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pPushConstantRanges'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPPushConstantRanges a + +class HasVkPQueueCreateInfos a where + type VkPQueueCreateInfosMType a :: * + + vkPQueueCreateInfos :: a -> VkPQueueCreateInfosMType a + + vkPQueueCreateInfosByteOffset :: a -> Int + + readVkPQueueCreateInfos :: Ptr a -> IO (VkPQueueCreateInfosMType a) + + writeVkPQueueCreateInfos :: + Ptr a -> VkPQueueCreateInfosMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pQueueCreateInfos'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPQueueCreateInfos a + +class HasVkPQueueFamilyIndices a where + type VkPQueueFamilyIndicesMType a :: * + + vkPQueueFamilyIndices :: a -> VkPQueueFamilyIndicesMType a + + vkPQueueFamilyIndicesByteOffset :: a -> Int + + readVkPQueueFamilyIndices :: + Ptr a -> IO (VkPQueueFamilyIndicesMType a) + + writeVkPQueueFamilyIndices :: + Ptr a -> VkPQueueFamilyIndicesMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pQueueFamilyIndices'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPQueueFamilyIndices a + +class HasVkPQueuePriorities a where + type VkPQueuePrioritiesMType a :: * + + vkPQueuePriorities :: a -> VkPQueuePrioritiesMType a + + vkPQueuePrioritiesByteOffset :: a -> Int + + readVkPQueuePriorities :: Ptr a -> IO (VkPQueuePrioritiesMType a) + + writeVkPQueuePriorities :: + Ptr a -> VkPQueuePrioritiesMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pQueuePriorities'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPQueuePriorities a + +class HasVkPRasterizationState a where + type VkPRasterizationStateMType a :: * + + vkPRasterizationState :: a -> VkPRasterizationStateMType a + + vkPRasterizationStateByteOffset :: a -> Int + + readVkPRasterizationState :: + Ptr a -> IO (VkPRasterizationStateMType a) + + writeVkPRasterizationState :: + Ptr a -> VkPRasterizationStateMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pRasterizationState'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPRasterizationState a + +class HasVkPRectangles a where + type VkPRectanglesMType a :: * + + vkPRectangles :: a -> VkPRectanglesMType a + + vkPRectanglesByteOffset :: a -> Int + + readVkPRectangles :: Ptr a -> IO (VkPRectanglesMType a) + + writeVkPRectangles :: Ptr a -> VkPRectanglesMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pRectangles'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPRectangles a + +class HasVkPRegions a where + type VkPRegionsMType a :: * + + vkPRegions :: a -> VkPRegionsMType a + + vkPRegionsByteOffset :: a -> Int + + readVkPRegions :: Ptr a -> IO (VkPRegionsMType a) + + writeVkPRegions :: Ptr a -> VkPRegionsMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pRegions'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPRegions a + +class HasVkPReleaseKeys a where + type VkPReleaseKeysMType a :: * + + vkPReleaseKeys :: a -> VkPReleaseKeysMType a + + vkPReleaseKeysByteOffset :: a -> Int + + readVkPReleaseKeys :: Ptr a -> IO (VkPReleaseKeysMType a) + + writeVkPReleaseKeys :: Ptr a -> VkPReleaseKeysMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pReleaseKeys'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPReleaseKeys a + +class HasVkPReleaseSyncs a where + type VkPReleaseSyncsMType a :: * + + vkPReleaseSyncs :: a -> VkPReleaseSyncsMType a + + vkPReleaseSyncsByteOffset :: a -> Int + + readVkPReleaseSyncs :: Ptr a -> IO (VkPReleaseSyncsMType a) + + writeVkPReleaseSyncs :: Ptr a -> VkPReleaseSyncsMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pReleaseSyncs'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPReleaseSyncs a + +class HasVkPResolveAttachments a where + type VkPResolveAttachmentsMType a :: * + + vkPResolveAttachments :: a -> VkPResolveAttachmentsMType a + + vkPResolveAttachmentsByteOffset :: a -> Int + + readVkPResolveAttachments :: + Ptr a -> IO (VkPResolveAttachmentsMType a) + + writeVkPResolveAttachments :: + Ptr a -> VkPResolveAttachmentsMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pResolveAttachments'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPResolveAttachments a + +class HasVkPResults a where + type VkPResultsMType a :: * + + vkPResults :: a -> VkPResultsMType a + + vkPResultsByteOffset :: a -> Int + + readVkPResults :: Ptr a -> IO (VkPResultsMType a) + + writeVkPResults :: Ptr a -> VkPResultsMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pResults'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPResults a + +class HasVkPSFRRects a where + type VkPSFRRectsMType a :: * + + vkPSFRRects :: a -> VkPSFRRectsMType a + + vkPSFRRectsByteOffset :: a -> Int + + readVkPSFRRects :: Ptr a -> IO (VkPSFRRectsMType a) + + writeVkPSFRRects :: Ptr a -> VkPSFRRectsMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pSFRRects'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPSFRRects a + +class HasVkPSampleLocations a where + type VkPSampleLocationsMType a :: * + + vkPSampleLocations :: a -> VkPSampleLocationsMType a + + vkPSampleLocationsByteOffset :: a -> Int + + readVkPSampleLocations :: Ptr a -> IO (VkPSampleLocationsMType a) + + writeVkPSampleLocations :: + Ptr a -> VkPSampleLocationsMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pSampleLocations'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPSampleLocations a + +class HasVkPSampleMask a where + type VkPSampleMaskMType a :: * + + vkPSampleMask :: a -> VkPSampleMaskMType a + + vkPSampleMaskByteOffset :: a -> Int + + readVkPSampleMask :: Ptr a -> IO (VkPSampleMaskMType a) + + writeVkPSampleMask :: Ptr a -> VkPSampleMaskMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pSampleMask'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPSampleMask a + +class HasVkPScissors a where + type VkPScissorsMType a :: * + + vkPScissors :: a -> VkPScissorsMType a + + vkPScissorsByteOffset :: a -> Int + + readVkPScissors :: Ptr a -> IO (VkPScissorsMType a) + + writeVkPScissors :: Ptr a -> VkPScissorsMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pScissors'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPScissors a + +class HasVkPSetLayouts a where + type VkPSetLayoutsMType a :: * + + vkPSetLayouts :: a -> VkPSetLayoutsMType a + + vkPSetLayoutsByteOffset :: a -> Int + + readVkPSetLayouts :: Ptr a -> IO (VkPSetLayoutsMType a) + + writeVkPSetLayouts :: Ptr a -> VkPSetLayoutsMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pSetLayouts'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPSetLayouts a + +class HasVkPSignalSemaphoreDeviceIndices a where + type VkPSignalSemaphoreDeviceIndicesMType a :: * + + vkPSignalSemaphoreDeviceIndices :: + a -> VkPSignalSemaphoreDeviceIndicesMType a + + vkPSignalSemaphoreDeviceIndicesByteOffset :: a -> Int + + readVkPSignalSemaphoreDeviceIndices :: + Ptr a -> IO (VkPSignalSemaphoreDeviceIndicesMType a) + + writeVkPSignalSemaphoreDeviceIndices :: + Ptr a -> + VkPSignalSemaphoreDeviceIndicesMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text + " does not seem to have field 'pSignalSemaphoreDeviceIndices'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPSignalSemaphoreDeviceIndices a + +class HasVkPSignalSemaphoreValues a where + type VkPSignalSemaphoreValuesMType a :: * + + vkPSignalSemaphoreValues :: a -> VkPSignalSemaphoreValuesMType a + + vkPSignalSemaphoreValuesByteOffset :: a -> Int + + readVkPSignalSemaphoreValues :: + Ptr a -> IO (VkPSignalSemaphoreValuesMType a) + + writeVkPSignalSemaphoreValues :: + Ptr a -> VkPSignalSemaphoreValuesMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pSignalSemaphoreValues'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPSignalSemaphoreValues a + +class HasVkPSignalSemaphores a where + type VkPSignalSemaphoresMType a :: * + + vkPSignalSemaphores :: a -> VkPSignalSemaphoresMType a + + vkPSignalSemaphoresByteOffset :: a -> Int + + readVkPSignalSemaphores :: Ptr a -> IO (VkPSignalSemaphoresMType a) + + writeVkPSignalSemaphores :: + Ptr a -> VkPSignalSemaphoresMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pSignalSemaphores'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPSignalSemaphores a + +class HasVkPSpecializationInfo a where + type VkPSpecializationInfoMType a :: * + + vkPSpecializationInfo :: a -> VkPSpecializationInfoMType a + + vkPSpecializationInfoByteOffset :: a -> Int + + readVkPSpecializationInfo :: + Ptr a -> IO (VkPSpecializationInfoMType a) + + writeVkPSpecializationInfo :: + Ptr a -> VkPSpecializationInfoMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pSpecializationInfo'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPSpecializationInfo a + +class HasVkPStages a where + type VkPStagesMType a :: * + + vkPStages :: a -> VkPStagesMType a + + vkPStagesByteOffset :: a -> Int + + readVkPStages :: Ptr a -> IO (VkPStagesMType a) + + writeVkPStages :: Ptr a -> VkPStagesMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pStages'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPStages a + +class HasVkPSubpasses a where + type VkPSubpassesMType a :: * + + vkPSubpasses :: a -> VkPSubpassesMType a + + vkPSubpassesByteOffset :: a -> Int + + readVkPSubpasses :: Ptr a -> IO (VkPSubpassesMType a) + + writeVkPSubpasses :: Ptr a -> VkPSubpassesMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pSubpasses'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPSubpasses a + +class HasVkPSwapchains a where + type VkPSwapchainsMType a :: * + + vkPSwapchains :: a -> VkPSwapchainsMType a + + vkPSwapchainsByteOffset :: a -> Int + + readVkPSwapchains :: Ptr a -> IO (VkPSwapchainsMType a) + + writeVkPSwapchains :: Ptr a -> VkPSwapchainsMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pSwapchains'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPSwapchains a + +class HasVkPTag a where + type VkPTagMType a :: * + + vkPTag :: a -> VkPTagMType a + + vkPTagByteOffset :: a -> Int + + readVkPTag :: Ptr a -> IO (VkPTagMType a) + + writeVkPTag :: Ptr a -> VkPTagMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pTag'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPTag a + +class HasVkPTessellationState a where + type VkPTessellationStateMType a :: * + + vkPTessellationState :: a -> VkPTessellationStateMType a + + vkPTessellationStateByteOffset :: a -> Int + + readVkPTessellationState :: + Ptr a -> IO (VkPTessellationStateMType a) + + writeVkPTessellationState :: + Ptr a -> VkPTessellationStateMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pTessellationState'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPTessellationState a + +class HasVkPTexelBufferView a where + type VkPTexelBufferViewMType a :: * + + vkPTexelBufferView :: a -> VkPTexelBufferViewMType a + + vkPTexelBufferViewByteOffset :: a -> Int + + readVkPTexelBufferView :: Ptr a -> IO (VkPTexelBufferViewMType a) + + writeVkPTexelBufferView :: + Ptr a -> VkPTexelBufferViewMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pTexelBufferView'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPTexelBufferView a + +class HasVkPTimes a where + type VkPTimesMType a :: * + + vkPTimes :: a -> VkPTimesMType a + + vkPTimesByteOffset :: a -> Int + + readVkPTimes :: Ptr a -> IO (VkPTimesMType a) + + writeVkPTimes :: Ptr a -> VkPTimesMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pTimes'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPTimes a + +class HasVkPTokens a where + type VkPTokensMType a :: * + + vkPTokens :: a -> VkPTokensMType a + + vkPTokensByteOffset :: a -> Int + + readVkPTokens :: Ptr a -> IO (VkPTokensMType a) + + writeVkPTokens :: Ptr a -> VkPTokensMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pTokens'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPTokens a + +class HasVkPUserData a where + type VkPUserDataMType a :: * + + vkPUserData :: a -> VkPUserDataMType a + + vkPUserDataByteOffset :: a -> Int + + readVkPUserData :: Ptr a -> IO (VkPUserDataMType a) + + writeVkPUserData :: Ptr a -> VkPUserDataMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pUserData'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPUserData a + +class HasVkPVertexAttributeDescriptions a where + type VkPVertexAttributeDescriptionsMType a :: * + + vkPVertexAttributeDescriptions :: + a -> VkPVertexAttributeDescriptionsMType a + + vkPVertexAttributeDescriptionsByteOffset :: a -> Int + + readVkPVertexAttributeDescriptions :: + Ptr a -> IO (VkPVertexAttributeDescriptionsMType a) + + writeVkPVertexAttributeDescriptions :: + Ptr a -> VkPVertexAttributeDescriptionsMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text + " does not seem to have field 'pVertexAttributeDescriptions'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPVertexAttributeDescriptions a + +class HasVkPVertexBindingDescriptions a where + type VkPVertexBindingDescriptionsMType a :: * + + vkPVertexBindingDescriptions :: + a -> VkPVertexBindingDescriptionsMType a + + vkPVertexBindingDescriptionsByteOffset :: a -> Int + + readVkPVertexBindingDescriptions :: + Ptr a -> IO (VkPVertexBindingDescriptionsMType a) + + writeVkPVertexBindingDescriptions :: + Ptr a -> VkPVertexBindingDescriptionsMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pVertexBindingDescriptions'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPVertexBindingDescriptions a + +class HasVkPVertexInputState a where + type VkPVertexInputStateMType a :: * + + vkPVertexInputState :: a -> VkPVertexInputStateMType a + + vkPVertexInputStateByteOffset :: a -> Int + + readVkPVertexInputState :: Ptr a -> IO (VkPVertexInputStateMType a) + + writeVkPVertexInputState :: + Ptr a -> VkPVertexInputStateMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pVertexInputState'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPVertexInputState a + +class HasVkPView a where + type VkPViewMType a :: * + + vkPView :: a -> VkPViewMType a + + vkPViewByteOffset :: a -> Int + + readVkPView :: Ptr a -> IO (VkPViewMType a) + + writeVkPView :: Ptr a -> VkPViewMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pView'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPView a + +class HasVkPViewFormats a where + type VkPViewFormatsMType a :: * + + vkPViewFormats :: a -> VkPViewFormatsMType a + + vkPViewFormatsByteOffset :: a -> Int + + readVkPViewFormats :: Ptr a -> IO (VkPViewFormatsMType a) + + writeVkPViewFormats :: Ptr a -> VkPViewFormatsMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pViewFormats'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPViewFormats a + +class HasVkPViewMasks a where + type VkPViewMasksMType a :: * + + vkPViewMasks :: a -> VkPViewMasksMType a + + vkPViewMasksByteOffset :: a -> Int + + readVkPViewMasks :: Ptr a -> IO (VkPViewMasksMType a) + + writeVkPViewMasks :: Ptr a -> VkPViewMasksMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pViewMasks'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPViewMasks a + +class HasVkPViewOffsets a where + type VkPViewOffsetsMType a :: * + + vkPViewOffsets :: a -> VkPViewOffsetsMType a + + vkPViewOffsetsByteOffset :: a -> Int + + readVkPViewOffsets :: Ptr a -> IO (VkPViewOffsetsMType a) + + writeVkPViewOffsets :: Ptr a -> VkPViewOffsetsMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pViewOffsets'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPViewOffsets a + +class HasVkPViewportState a where + type VkPViewportStateMType a :: * + + vkPViewportState :: a -> VkPViewportStateMType a + + vkPViewportStateByteOffset :: a -> Int + + readVkPViewportState :: Ptr a -> IO (VkPViewportStateMType a) + + writeVkPViewportState :: Ptr a -> VkPViewportStateMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pViewportState'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPViewportState a + +class HasVkPViewportSwizzles a where + type VkPViewportSwizzlesMType a :: * + + vkPViewportSwizzles :: a -> VkPViewportSwizzlesMType a + + vkPViewportSwizzlesByteOffset :: a -> Int + + readVkPViewportSwizzles :: Ptr a -> IO (VkPViewportSwizzlesMType a) + + writeVkPViewportSwizzles :: + Ptr a -> VkPViewportSwizzlesMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pViewportSwizzles'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPViewportSwizzles a + +class HasVkPViewportWScalings a where + type VkPViewportWScalingsMType a :: * + + vkPViewportWScalings :: a -> VkPViewportWScalingsMType a + + vkPViewportWScalingsByteOffset :: a -> Int + + readVkPViewportWScalings :: + Ptr a -> IO (VkPViewportWScalingsMType a) + + writeVkPViewportWScalings :: + Ptr a -> VkPViewportWScalingsMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pViewportWScalings'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPViewportWScalings a + +class HasVkPViewports a where + type VkPViewportsMType a :: * + + vkPViewports :: a -> VkPViewportsMType a + + vkPViewportsByteOffset :: a -> Int + + readVkPViewports :: Ptr a -> IO (VkPViewportsMType a) + + writeVkPViewports :: Ptr a -> VkPViewportsMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pViewports'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPViewports a + +class HasVkPWaitDstStageMask a where + type VkPWaitDstStageMaskMType a :: * + + vkPWaitDstStageMask :: a -> VkPWaitDstStageMaskMType a + + vkPWaitDstStageMaskByteOffset :: a -> Int + + readVkPWaitDstStageMask :: Ptr a -> IO (VkPWaitDstStageMaskMType a) + + writeVkPWaitDstStageMask :: + Ptr a -> VkPWaitDstStageMaskMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pWaitDstStageMask'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPWaitDstStageMask a + +class HasVkPWaitSemaphoreDeviceIndices a where + type VkPWaitSemaphoreDeviceIndicesMType a :: * + + vkPWaitSemaphoreDeviceIndices :: + a -> VkPWaitSemaphoreDeviceIndicesMType a + + vkPWaitSemaphoreDeviceIndicesByteOffset :: a -> Int + + readVkPWaitSemaphoreDeviceIndices :: + Ptr a -> IO (VkPWaitSemaphoreDeviceIndicesMType a) + + writeVkPWaitSemaphoreDeviceIndices :: + Ptr a -> VkPWaitSemaphoreDeviceIndicesMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pWaitSemaphoreDeviceIndices'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPWaitSemaphoreDeviceIndices a + +class HasVkPWaitSemaphoreValues a where + type VkPWaitSemaphoreValuesMType a :: * + + vkPWaitSemaphoreValues :: a -> VkPWaitSemaphoreValuesMType a + + vkPWaitSemaphoreValuesByteOffset :: a -> Int + + readVkPWaitSemaphoreValues :: + Ptr a -> IO (VkPWaitSemaphoreValuesMType a) + + writeVkPWaitSemaphoreValues :: + Ptr a -> VkPWaitSemaphoreValuesMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pWaitSemaphoreValues'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPWaitSemaphoreValues a + +class HasVkPWaitSemaphores a where + type VkPWaitSemaphoresMType a :: * + + vkPWaitSemaphores :: a -> VkPWaitSemaphoresMType a + + vkPWaitSemaphoresByteOffset :: a -> Int + + readVkPWaitSemaphores :: Ptr a -> IO (VkPWaitSemaphoresMType a) + + writeVkPWaitSemaphores :: + Ptr a -> VkPWaitSemaphoresMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pWaitSemaphores'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPWaitSemaphores a + +class HasVkParameters a where + type VkParametersMType a :: * + + vkParameters :: a -> VkParametersMType a + + vkParametersByteOffset :: a -> Int + + readVkParameters :: Ptr a -> IO (VkParametersMType a) + + writeVkParameters :: Ptr a -> VkParametersMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'parameters'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkParameters a + +class HasVkPassOp a where + type VkPassOpMType a :: * + + vkPassOp :: a -> VkPassOpMType a + + vkPassOpByteOffset :: a -> Int + + readVkPassOp :: Ptr a -> IO (VkPassOpMType a) + + writeVkPassOp :: Ptr a -> VkPassOpMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'passOp'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPassOp a + +class HasVkPatchControlPoints a where + type VkPatchControlPointsMType a :: * + + vkPatchControlPoints :: a -> VkPatchControlPointsMType a + + vkPatchControlPointsByteOffset :: a -> Int + + readVkPatchControlPoints :: + Ptr a -> IO (VkPatchControlPointsMType a) + + writeVkPatchControlPoints :: + Ptr a -> VkPatchControlPointsMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'patchControlPoints'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPatchControlPoints a + +class HasVkPerViewPositionAllComponents a where + type VkPerViewPositionAllComponentsMType a :: * + + vkPerViewPositionAllComponents :: + a -> VkPerViewPositionAllComponentsMType a + + vkPerViewPositionAllComponentsByteOffset :: a -> Int + + readVkPerViewPositionAllComponents :: + Ptr a -> IO (VkPerViewPositionAllComponentsMType a) + + writeVkPerViewPositionAllComponents :: + Ptr a -> VkPerViewPositionAllComponentsMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text + " does not seem to have field 'perViewPositionAllComponents'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPerViewPositionAllComponents a + +class HasVkPersistent a where + type VkPersistentMType a :: * + + vkPersistent :: a -> VkPersistentMType a + + vkPersistentByteOffset :: a -> Int + + readVkPersistent :: Ptr a -> IO (VkPersistentMType a) + + writeVkPersistent :: Ptr a -> VkPersistentMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'persistent'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPersistent a + +class HasVkPersistentContent a where + type VkPersistentContentMType a :: * + + vkPersistentContent :: a -> VkPersistentContentMType a + + vkPersistentContentByteOffset :: a -> Int + + readVkPersistentContent :: Ptr a -> IO (VkPersistentContentMType a) + + writeVkPersistentContent :: + Ptr a -> VkPersistentContentMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'persistentContent'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPersistentContent a + +class HasVkPfnAllocation a where + type VkPfnAllocationMType a :: * + + vkPfnAllocation :: a -> VkPfnAllocationMType a + + vkPfnAllocationByteOffset :: a -> Int + + readVkPfnAllocation :: Ptr a -> IO (VkPfnAllocationMType a) + + writeVkPfnAllocation :: Ptr a -> VkPfnAllocationMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pfnAllocation'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPfnAllocation a + +class HasVkPfnCallback a where + type VkPfnCallbackMType a :: * + + vkPfnCallback :: a -> VkPfnCallbackMType a + + vkPfnCallbackByteOffset :: a -> Int + + readVkPfnCallback :: Ptr a -> IO (VkPfnCallbackMType a) + + writeVkPfnCallback :: Ptr a -> VkPfnCallbackMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pfnCallback'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPfnCallback a + +class HasVkPfnFree a where + type VkPfnFreeMType a :: * + + vkPfnFree :: a -> VkPfnFreeMType a + + vkPfnFreeByteOffset :: a -> Int + + readVkPfnFree :: Ptr a -> IO (VkPfnFreeMType a) + + writeVkPfnFree :: Ptr a -> VkPfnFreeMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pfnFree'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPfnFree a + +class HasVkPfnInternalAllocation a where + type VkPfnInternalAllocationMType a :: * + + vkPfnInternalAllocation :: a -> VkPfnInternalAllocationMType a + + vkPfnInternalAllocationByteOffset :: a -> Int + + readVkPfnInternalAllocation :: + Ptr a -> IO (VkPfnInternalAllocationMType a) + + writeVkPfnInternalAllocation :: + Ptr a -> VkPfnInternalAllocationMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pfnInternalAllocation'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPfnInternalAllocation a + +class HasVkPfnInternalFree a where + type VkPfnInternalFreeMType a :: * + + vkPfnInternalFree :: a -> VkPfnInternalFreeMType a + + vkPfnInternalFreeByteOffset :: a -> Int + + readVkPfnInternalFree :: Ptr a -> IO (VkPfnInternalFreeMType a) + + writeVkPfnInternalFree :: + Ptr a -> VkPfnInternalFreeMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pfnInternalFree'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPfnInternalFree a + +class HasVkPfnReallocation a where + type VkPfnReallocationMType a :: * + + vkPfnReallocation :: a -> VkPfnReallocationMType a + + vkPfnReallocationByteOffset :: a -> Int + + readVkPfnReallocation :: Ptr a -> IO (VkPfnReallocationMType a) + + writeVkPfnReallocation :: + Ptr a -> VkPfnReallocationMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pfnReallocation'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPfnReallocation a + +class HasVkPhysicalDeviceCount a where + type VkPhysicalDeviceCountMType a :: * + + vkPhysicalDeviceCount :: a -> VkPhysicalDeviceCountMType a + + vkPhysicalDeviceCountByteOffset :: a -> Int + + readVkPhysicalDeviceCount :: + Ptr a -> IO (VkPhysicalDeviceCountMType a) + + writeVkPhysicalDeviceCount :: + Ptr a -> VkPhysicalDeviceCountMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'physicalDeviceCount'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPhysicalDeviceCount a + +class HasVkPhysicalDevicesArray a where + type VkPhysicalDevicesArrayMType a :: * + + vkPhysicalDevicesArray :: a -> Int -> VkPhysicalDevicesArrayMType a + + vkPhysicalDevicesArrayByteOffset :: a -> Int + + readVkPhysicalDevicesArray :: + Ptr a -> Int -> IO (VkPhysicalDevicesArrayMType a) + + writeVkPhysicalDevicesArray :: + Ptr a -> Int -> VkPhysicalDevicesArrayMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'physicalDevices'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPhysicalDevicesArray a + +class HasVkPhysicalDimensions a where + type VkPhysicalDimensionsMType a :: * + + vkPhysicalDimensions :: a -> VkPhysicalDimensionsMType a + + vkPhysicalDimensionsByteOffset :: a -> Int + + readVkPhysicalDimensions :: + Ptr a -> IO (VkPhysicalDimensionsMType a) + + writeVkPhysicalDimensions :: + Ptr a -> VkPhysicalDimensionsMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'physicalDimensions'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPhysicalDimensions a + +class HasVkPhysicalResolution a where + type VkPhysicalResolutionMType a :: * + + vkPhysicalResolution :: a -> VkPhysicalResolutionMType a + + vkPhysicalResolutionByteOffset :: a -> Int + + readVkPhysicalResolution :: + Ptr a -> IO (VkPhysicalResolutionMType a) + + writeVkPhysicalResolution :: + Ptr a -> VkPhysicalResolutionMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'physicalResolution'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPhysicalResolution a + +class HasVkPipeline a where + type VkPipelineMType a :: * + + vkPipeline :: a -> VkPipelineMType a + + vkPipelineByteOffset :: a -> Int + + readVkPipeline :: Ptr a -> IO (VkPipelineMType a) + + writeVkPipeline :: Ptr a -> VkPipelineMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pipeline'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPipeline a + +class HasVkPipelineBindPoint a where + type VkPipelineBindPointMType a :: * + + vkPipelineBindPoint :: a -> VkPipelineBindPointMType a + + vkPipelineBindPointByteOffset :: a -> Int + + readVkPipelineBindPoint :: Ptr a -> IO (VkPipelineBindPointMType a) + + writeVkPipelineBindPoint :: + Ptr a -> VkPipelineBindPointMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pipelineBindPoint'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPipelineBindPoint a + +class HasVkPipelineCacheUUIDArray a where + type VkPipelineCacheUUIDArrayMType a :: * + + vkPipelineCacheUUIDArray :: + a -> Int -> VkPipelineCacheUUIDArrayMType a + + vkPipelineCacheUUIDArrayByteOffset :: a -> Int + + readVkPipelineCacheUUIDArray :: + Ptr a -> Int -> IO (VkPipelineCacheUUIDArrayMType a) + + writeVkPipelineCacheUUIDArray :: + Ptr a -> Int -> VkPipelineCacheUUIDArrayMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pipelineCacheUUID'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPipelineCacheUUIDArray a + +class HasVkPipelineLayout a where + type VkPipelineLayoutMType a :: * + + vkPipelineLayout :: a -> VkPipelineLayoutMType a + + vkPipelineLayoutByteOffset :: a -> Int + + readVkPipelineLayout :: Ptr a -> IO (VkPipelineLayoutMType a) + + writeVkPipelineLayout :: Ptr a -> VkPipelineLayoutMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pipelineLayout'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPipelineLayout a + +class HasVkPipelineStatistics a where + type VkPipelineStatisticsMType a :: * + + vkPipelineStatistics :: a -> VkPipelineStatisticsMType a + + vkPipelineStatisticsByteOffset :: a -> Int + + readVkPipelineStatistics :: + Ptr a -> IO (VkPipelineStatisticsMType a) + + writeVkPipelineStatistics :: + Ptr a -> VkPipelineStatisticsMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pipelineStatistics'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPipelineStatistics a + +class HasVkPipelineStatisticsQuery a where + type VkPipelineStatisticsQueryMType a :: * + + vkPipelineStatisticsQuery :: a -> VkPipelineStatisticsQueryMType a + + vkPipelineStatisticsQueryByteOffset :: a -> Int + + readVkPipelineStatisticsQuery :: + Ptr a -> IO (VkPipelineStatisticsQueryMType a) + + writeVkPipelineStatisticsQuery :: + Ptr a -> VkPipelineStatisticsQueryMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pipelineStatisticsQuery'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPipelineStatisticsQuery a + +class HasVkPlaneAspect a where + type VkPlaneAspectMType a :: * + + vkPlaneAspect :: a -> VkPlaneAspectMType a + + vkPlaneAspectByteOffset :: a -> Int + + readVkPlaneAspect :: Ptr a -> IO (VkPlaneAspectMType a) + + writeVkPlaneAspect :: Ptr a -> VkPlaneAspectMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'planeAspect'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPlaneAspect a + +class HasVkPlaneIndex a where + type VkPlaneIndexMType a :: * + + vkPlaneIndex :: a -> VkPlaneIndexMType a + + vkPlaneIndexByteOffset :: a -> Int + + readVkPlaneIndex :: Ptr a -> IO (VkPlaneIndexMType a) + + writeVkPlaneIndex :: Ptr a -> VkPlaneIndexMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'planeIndex'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPlaneIndex a + +class HasVkPlaneReorderPossible a where + type VkPlaneReorderPossibleMType a :: * + + vkPlaneReorderPossible :: a -> VkPlaneReorderPossibleMType a + + vkPlaneReorderPossibleByteOffset :: a -> Int + + readVkPlaneReorderPossible :: + Ptr a -> IO (VkPlaneReorderPossibleMType a) + + writeVkPlaneReorderPossible :: + Ptr a -> VkPlaneReorderPossibleMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'planeReorderPossible'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPlaneReorderPossible a + +class HasVkPlaneStackIndex a where + type VkPlaneStackIndexMType a :: * + + vkPlaneStackIndex :: a -> VkPlaneStackIndexMType a + + vkPlaneStackIndexByteOffset :: a -> Int + + readVkPlaneStackIndex :: Ptr a -> IO (VkPlaneStackIndexMType a) + + writeVkPlaneStackIndex :: + Ptr a -> VkPlaneStackIndexMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'planeStackIndex'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPlaneStackIndex a + +class HasVkPointClippingBehavior a where + type VkPointClippingBehaviorMType a :: * + + vkPointClippingBehavior :: a -> VkPointClippingBehaviorMType a + + vkPointClippingBehaviorByteOffset :: a -> Int + + readVkPointClippingBehavior :: + Ptr a -> IO (VkPointClippingBehaviorMType a) + + writeVkPointClippingBehavior :: + Ptr a -> VkPointClippingBehaviorMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pointClippingBehavior'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPointClippingBehavior a + +class HasVkPointSizeGranularity a where + type VkPointSizeGranularityMType a :: * + + vkPointSizeGranularity :: a -> VkPointSizeGranularityMType a + + vkPointSizeGranularityByteOffset :: a -> Int + + readVkPointSizeGranularity :: + Ptr a -> IO (VkPointSizeGranularityMType a) + + writeVkPointSizeGranularity :: + Ptr a -> VkPointSizeGranularityMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pointSizeGranularity'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPointSizeGranularity a + +class HasVkPointSizeRangeArray a where + type VkPointSizeRangeArrayMType a :: * + + vkPointSizeRangeArray :: a -> Int -> VkPointSizeRangeArrayMType a + + vkPointSizeRangeArrayByteOffset :: a -> Int + + readVkPointSizeRangeArray :: + Ptr a -> Int -> IO (VkPointSizeRangeArrayMType a) + + writeVkPointSizeRangeArray :: + Ptr a -> Int -> VkPointSizeRangeArrayMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pointSizeRange'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPointSizeRangeArray a + +class HasVkPolygonMode a where + type VkPolygonModeMType a :: * + + vkPolygonMode :: a -> VkPolygonModeMType a + + vkPolygonModeByteOffset :: a -> Int + + readVkPolygonMode :: Ptr a -> IO (VkPolygonModeMType a) + + writeVkPolygonMode :: Ptr a -> VkPolygonModeMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'polygonMode'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPolygonMode a + +class HasVkPoolSizeCount a where + type VkPoolSizeCountMType a :: * + + vkPoolSizeCount :: a -> VkPoolSizeCountMType a + + vkPoolSizeCountByteOffset :: a -> Int + + readVkPoolSizeCount :: Ptr a -> IO (VkPoolSizeCountMType a) + + writeVkPoolSizeCount :: Ptr a -> VkPoolSizeCountMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'poolSizeCount'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPoolSizeCount a + +class HasVkPostSubpassSampleLocationsCount a where + type VkPostSubpassSampleLocationsCountMType a :: * + + vkPostSubpassSampleLocationsCount :: + a -> VkPostSubpassSampleLocationsCountMType a + + vkPostSubpassSampleLocationsCountByteOffset :: a -> Int + + readVkPostSubpassSampleLocationsCount :: + Ptr a -> IO (VkPostSubpassSampleLocationsCountMType a) + + writeVkPostSubpassSampleLocationsCount :: + Ptr a -> + VkPostSubpassSampleLocationsCountMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text + " does not seem to have field 'postSubpassSampleLocationsCount'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPostSubpassSampleLocationsCount a + +class HasVkPowerState a where + type VkPowerStateMType a :: * + + vkPowerState :: a -> VkPowerStateMType a + + vkPowerStateByteOffset :: a -> Int + + readVkPowerState :: Ptr a -> IO (VkPowerStateMType a) + + writeVkPowerState :: Ptr a -> VkPowerStateMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'powerState'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPowerState a + +class HasVkPpEnabledExtensionNames a where + type VkPpEnabledExtensionNamesMType a :: * + + vkPpEnabledExtensionNames :: a -> VkPpEnabledExtensionNamesMType a + + vkPpEnabledExtensionNamesByteOffset :: a -> Int + + readVkPpEnabledExtensionNames :: + Ptr a -> IO (VkPpEnabledExtensionNamesMType a) + + writeVkPpEnabledExtensionNames :: + Ptr a -> VkPpEnabledExtensionNamesMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'ppEnabledExtensionNames'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPpEnabledExtensionNames a + +class HasVkPpEnabledLayerNames a where + type VkPpEnabledLayerNamesMType a :: * + + vkPpEnabledLayerNames :: a -> VkPpEnabledLayerNamesMType a + + vkPpEnabledLayerNamesByteOffset :: a -> Int + + readVkPpEnabledLayerNames :: + Ptr a -> IO (VkPpEnabledLayerNamesMType a) + + writeVkPpEnabledLayerNames :: + Ptr a -> VkPpEnabledLayerNamesMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'ppEnabledLayerNames'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPpEnabledLayerNames a + +class HasVkPreTransform a where + type VkPreTransformMType a :: * + + vkPreTransform :: a -> VkPreTransformMType a + + vkPreTransformByteOffset :: a -> Int + + readVkPreTransform :: Ptr a -> IO (VkPreTransformMType a) + + writeVkPreTransform :: Ptr a -> VkPreTransformMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'preTransform'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPreTransform a + +class HasVkPrefersDedicatedAllocation a where + type VkPrefersDedicatedAllocationMType a :: * + + vkPrefersDedicatedAllocation :: + a -> VkPrefersDedicatedAllocationMType a + + vkPrefersDedicatedAllocationByteOffset :: a -> Int + + readVkPrefersDedicatedAllocation :: + Ptr a -> IO (VkPrefersDedicatedAllocationMType a) + + writeVkPrefersDedicatedAllocation :: + Ptr a -> VkPrefersDedicatedAllocationMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'prefersDedicatedAllocation'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPrefersDedicatedAllocation a + +class HasVkPresentID a where + type VkPresentIDMType a :: * + + vkPresentID :: a -> VkPresentIDMType a + + vkPresentIDByteOffset :: a -> Int + + readVkPresentID :: Ptr a -> IO (VkPresentIDMType a) + + writeVkPresentID :: Ptr a -> VkPresentIDMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'presentID'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPresentID a + +class HasVkPresentMargin a where + type VkPresentMarginMType a :: * + + vkPresentMargin :: a -> VkPresentMarginMType a + + vkPresentMarginByteOffset :: a -> Int + + readVkPresentMargin :: Ptr a -> IO (VkPresentMarginMType a) + + writeVkPresentMargin :: Ptr a -> VkPresentMarginMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'presentMargin'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPresentMargin a + +class HasVkPresentMaskArray a where + type VkPresentMaskArrayMType a :: * + + vkPresentMaskArray :: a -> Int -> VkPresentMaskArrayMType a + + vkPresentMaskArrayByteOffset :: a -> Int + + readVkPresentMaskArray :: + Ptr a -> Int -> IO (VkPresentMaskArrayMType a) + + writeVkPresentMaskArray :: + Ptr a -> Int -> VkPresentMaskArrayMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'presentMask'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPresentMaskArray a + +class HasVkPresentMode a where + type VkPresentModeMType a :: * + + vkPresentMode :: a -> VkPresentModeMType a + + vkPresentModeByteOffset :: a -> Int + + readVkPresentMode :: Ptr a -> IO (VkPresentModeMType a) + + writeVkPresentMode :: Ptr a -> VkPresentModeMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'presentMode'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPresentMode a + +class HasVkPreserveAttachmentCount a where + type VkPreserveAttachmentCountMType a :: * + + vkPreserveAttachmentCount :: a -> VkPreserveAttachmentCountMType a + + vkPreserveAttachmentCountByteOffset :: a -> Int + + readVkPreserveAttachmentCount :: + Ptr a -> IO (VkPreserveAttachmentCountMType a) + + writeVkPreserveAttachmentCount :: + Ptr a -> VkPreserveAttachmentCountMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'preserveAttachmentCount'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPreserveAttachmentCount a + +class HasVkPrimitiveOverestimationSize a where + type VkPrimitiveOverestimationSizeMType a :: * + + vkPrimitiveOverestimationSize :: + a -> VkPrimitiveOverestimationSizeMType a + + vkPrimitiveOverestimationSizeByteOffset :: a -> Int + + readVkPrimitiveOverestimationSize :: + Ptr a -> IO (VkPrimitiveOverestimationSizeMType a) + + writeVkPrimitiveOverestimationSize :: + Ptr a -> VkPrimitiveOverestimationSizeMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'primitiveOverestimationSize'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPrimitiveOverestimationSize a + +class HasVkPrimitiveRestartEnable a where + type VkPrimitiveRestartEnableMType a :: * + + vkPrimitiveRestartEnable :: a -> VkPrimitiveRestartEnableMType a + + vkPrimitiveRestartEnableByteOffset :: a -> Int + + readVkPrimitiveRestartEnable :: + Ptr a -> IO (VkPrimitiveRestartEnableMType a) + + writeVkPrimitiveRestartEnable :: + Ptr a -> VkPrimitiveRestartEnableMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'primitiveRestartEnable'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPrimitiveRestartEnable a + +class HasVkPrimitiveUnderestimation a where + type VkPrimitiveUnderestimationMType a :: * + + vkPrimitiveUnderestimation :: + a -> VkPrimitiveUnderestimationMType a + + vkPrimitiveUnderestimationByteOffset :: a -> Int + + readVkPrimitiveUnderestimation :: + Ptr a -> IO (VkPrimitiveUnderestimationMType a) + + writeVkPrimitiveUnderestimation :: + Ptr a -> VkPrimitiveUnderestimationMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'primitiveUnderestimation'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPrimitiveUnderestimation a + +class HasVkProperties a where + type VkPropertiesMType a :: * + + vkProperties :: a -> VkPropertiesMType a + + vkPropertiesByteOffset :: a -> Int + + readVkProperties :: Ptr a -> IO (VkPropertiesMType a) + + writeVkProperties :: Ptr a -> VkPropertiesMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'properties'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkProperties a + +class HasVkPropertyFlags a where + type VkPropertyFlagsMType a :: * + + vkPropertyFlags :: a -> VkPropertyFlagsMType a + + vkPropertyFlagsByteOffset :: a -> Int + + readVkPropertyFlags :: Ptr a -> IO (VkPropertyFlagsMType a) + + writeVkPropertyFlags :: Ptr a -> VkPropertyFlagsMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'propertyFlags'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPropertyFlags a + +class HasVkPushConstantRangeCount a where + type VkPushConstantRangeCountMType a :: * + + vkPushConstantRangeCount :: a -> VkPushConstantRangeCountMType a + + vkPushConstantRangeCountByteOffset :: a -> Int + + readVkPushConstantRangeCount :: + Ptr a -> IO (VkPushConstantRangeCountMType a) + + writeVkPushConstantRangeCount :: + Ptr a -> VkPushConstantRangeCountMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'pushConstantRangeCount'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkPushConstantRangeCount a + +class HasVkQueryCount a where + type VkQueryCountMType a :: * + + vkQueryCount :: a -> VkQueryCountMType a + + vkQueryCountByteOffset :: a -> Int + + readVkQueryCount :: Ptr a -> IO (VkQueryCountMType a) + + writeVkQueryCount :: Ptr a -> VkQueryCountMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'queryCount'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkQueryCount a + +class HasVkQueryFlags a where + type VkQueryFlagsMType a :: * + + vkQueryFlags :: a -> VkQueryFlagsMType a + + vkQueryFlagsByteOffset :: a -> Int + + readVkQueryFlags :: Ptr a -> IO (VkQueryFlagsMType a) + + writeVkQueryFlags :: Ptr a -> VkQueryFlagsMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'queryFlags'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkQueryFlags a + +class HasVkQueryType a where + type VkQueryTypeMType a :: * + + vkQueryType :: a -> VkQueryTypeMType a + + vkQueryTypeByteOffset :: a -> Int + + readVkQueryType :: Ptr a -> IO (VkQueryTypeMType a) + + writeVkQueryType :: Ptr a -> VkQueryTypeMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'queryType'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkQueryType a + +class HasVkQueueCount a where + type VkQueueCountMType a :: * + + vkQueueCount :: a -> VkQueueCountMType a + + vkQueueCountByteOffset :: a -> Int + + readVkQueueCount :: Ptr a -> IO (VkQueueCountMType a) + + writeVkQueueCount :: Ptr a -> VkQueueCountMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'queueCount'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkQueueCount a + +class HasVkQueueCreateInfoCount a where + type VkQueueCreateInfoCountMType a :: * + + vkQueueCreateInfoCount :: a -> VkQueueCreateInfoCountMType a + + vkQueueCreateInfoCountByteOffset :: a -> Int + + readVkQueueCreateInfoCount :: + Ptr a -> IO (VkQueueCreateInfoCountMType a) + + writeVkQueueCreateInfoCount :: + Ptr a -> VkQueueCreateInfoCountMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'queueCreateInfoCount'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkQueueCreateInfoCount a + +class HasVkQueueFamilyIndex a where + type VkQueueFamilyIndexMType a :: * + + vkQueueFamilyIndex :: a -> VkQueueFamilyIndexMType a + + vkQueueFamilyIndexByteOffset :: a -> Int + + readVkQueueFamilyIndex :: Ptr a -> IO (VkQueueFamilyIndexMType a) + + writeVkQueueFamilyIndex :: + Ptr a -> VkQueueFamilyIndexMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'queueFamilyIndex'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkQueueFamilyIndex a + +class HasVkQueueFamilyIndexCount a where + type VkQueueFamilyIndexCountMType a :: * + + vkQueueFamilyIndexCount :: a -> VkQueueFamilyIndexCountMType a + + vkQueueFamilyIndexCountByteOffset :: a -> Int + + readVkQueueFamilyIndexCount :: + Ptr a -> IO (VkQueueFamilyIndexCountMType a) + + writeVkQueueFamilyIndexCount :: + Ptr a -> VkQueueFamilyIndexCountMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'queueFamilyIndexCount'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkQueueFamilyIndexCount a + +class HasVkQueueFamilyProperties a where + type VkQueueFamilyPropertiesMType a :: * + + vkQueueFamilyProperties :: a -> VkQueueFamilyPropertiesMType a + + vkQueueFamilyPropertiesByteOffset :: a -> Int + + readVkQueueFamilyProperties :: + Ptr a -> IO (VkQueueFamilyPropertiesMType a) + + writeVkQueueFamilyProperties :: + Ptr a -> VkQueueFamilyPropertiesMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'queueFamilyProperties'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkQueueFamilyProperties a + +class HasVkQueueFlags a where + type VkQueueFlagsMType a :: * + + vkQueueFlags :: a -> VkQueueFlagsMType a + + vkQueueFlagsByteOffset :: a -> Int + + readVkQueueFlags :: Ptr a -> IO (VkQueueFlagsMType a) + + writeVkQueueFlags :: Ptr a -> VkQueueFlagsMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'queueFlags'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkQueueFlags a + +class HasVkR a where + type VkRMType a :: * + + vkR :: a -> VkRMType a + + vkRByteOffset :: a -> Int + + readVkR :: Ptr a -> IO (VkRMType a) + + writeVkR :: Ptr a -> VkRMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'r'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkR a + +class HasVkRange a where + type VkRangeMType a :: * + + vkRange :: a -> VkRangeMType a + + vkRangeByteOffset :: a -> Int + + readVkRange :: Ptr a -> IO (VkRangeMType a) + + writeVkRange :: Ptr a -> VkRangeMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'range'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkRange a + +class HasVkRasterizationOrder a where + type VkRasterizationOrderMType a :: * + + vkRasterizationOrder :: a -> VkRasterizationOrderMType a + + vkRasterizationOrderByteOffset :: a -> Int + + readVkRasterizationOrder :: + Ptr a -> IO (VkRasterizationOrderMType a) + + writeVkRasterizationOrder :: + Ptr a -> VkRasterizationOrderMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'rasterizationOrder'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkRasterizationOrder a + +class HasVkRasterizationSamples a where + type VkRasterizationSamplesMType a :: * + + vkRasterizationSamples :: a -> VkRasterizationSamplesMType a + + vkRasterizationSamplesByteOffset :: a -> Int + + readVkRasterizationSamples :: + Ptr a -> IO (VkRasterizationSamplesMType a) + + writeVkRasterizationSamples :: + Ptr a -> VkRasterizationSamplesMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'rasterizationSamples'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkRasterizationSamples a + +class HasVkRasterizerDiscardEnable a where + type VkRasterizerDiscardEnableMType a :: * + + vkRasterizerDiscardEnable :: a -> VkRasterizerDiscardEnableMType a + + vkRasterizerDiscardEnableByteOffset :: a -> Int + + readVkRasterizerDiscardEnable :: + Ptr a -> IO (VkRasterizerDiscardEnableMType a) + + writeVkRasterizerDiscardEnable :: + Ptr a -> VkRasterizerDiscardEnableMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'rasterizerDiscardEnable'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkRasterizerDiscardEnable a + +class HasVkRect a where + type VkRectMType a :: * + + vkRect :: a -> VkRectMType a + + vkRectByteOffset :: a -> Int + + readVkRect :: Ptr a -> IO (VkRectMType a) + + writeVkRect :: Ptr a -> VkRectMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'rect'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkRect a + +class HasVkRectangleCount a where + type VkRectangleCountMType a :: * + + vkRectangleCount :: a -> VkRectangleCountMType a + + vkRectangleCountByteOffset :: a -> Int + + readVkRectangleCount :: Ptr a -> IO (VkRectangleCountMType a) + + writeVkRectangleCount :: Ptr a -> VkRectangleCountMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'rectangleCount'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkRectangleCount a + +class HasVkReductionMode a where + type VkReductionModeMType a :: * + + vkReductionMode :: a -> VkReductionModeMType a + + vkReductionModeByteOffset :: a -> Int + + readVkReductionMode :: Ptr a -> IO (VkReductionModeMType a) + + writeVkReductionMode :: Ptr a -> VkReductionModeMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'reductionMode'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkReductionMode a + +class HasVkReference a where + type VkReferenceMType a :: * + + vkReference :: a -> VkReferenceMType a + + vkReferenceByteOffset :: a -> Int + + readVkReference :: Ptr a -> IO (VkReferenceMType a) + + writeVkReference :: Ptr a -> VkReferenceMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'reference'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkReference a + +class HasVkRefreshDuration a where + type VkRefreshDurationMType a :: * + + vkRefreshDuration :: a -> VkRefreshDurationMType a + + vkRefreshDurationByteOffset :: a -> Int + + readVkRefreshDuration :: Ptr a -> IO (VkRefreshDurationMType a) + + writeVkRefreshDuration :: + Ptr a -> VkRefreshDurationMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'refreshDuration'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkRefreshDuration a + +class HasVkRefreshRate a where + type VkRefreshRateMType a :: * + + vkRefreshRate :: a -> VkRefreshRateMType a + + vkRefreshRateByteOffset :: a -> Int + + readVkRefreshRate :: Ptr a -> IO (VkRefreshRateMType a) + + writeVkRefreshRate :: Ptr a -> VkRefreshRateMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'refreshRate'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkRefreshRate a + +class HasVkReleaseCount a where + type VkReleaseCountMType a :: * + + vkReleaseCount :: a -> VkReleaseCountMType a + + vkReleaseCountByteOffset :: a -> Int + + readVkReleaseCount :: Ptr a -> IO (VkReleaseCountMType a) + + writeVkReleaseCount :: Ptr a -> VkReleaseCountMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'releaseCount'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkReleaseCount a + +class HasVkRenderArea a where + type VkRenderAreaMType a :: * + + vkRenderArea :: a -> VkRenderAreaMType a + + vkRenderAreaByteOffset :: a -> Int + + readVkRenderArea :: Ptr a -> IO (VkRenderAreaMType a) + + writeVkRenderArea :: Ptr a -> VkRenderAreaMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'renderArea'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkRenderArea a + +class HasVkRenderPass a where + type VkRenderPassMType a :: * + + vkRenderPass :: a -> VkRenderPassMType a + + vkRenderPassByteOffset :: a -> Int + + readVkRenderPass :: Ptr a -> IO (VkRenderPassMType a) + + writeVkRenderPass :: Ptr a -> VkRenderPassMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'renderPass'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkRenderPass a + +class HasVkRequiresDedicatedAllocation a where + type VkRequiresDedicatedAllocationMType a :: * + + vkRequiresDedicatedAllocation :: + a -> VkRequiresDedicatedAllocationMType a + + vkRequiresDedicatedAllocationByteOffset :: a -> Int + + readVkRequiresDedicatedAllocation :: + Ptr a -> IO (VkRequiresDedicatedAllocationMType a) + + writeVkRequiresDedicatedAllocation :: + Ptr a -> VkRequiresDedicatedAllocationMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'requiresDedicatedAllocation'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkRequiresDedicatedAllocation a + +class HasVkResidencyAlignedMipSize a where + type VkResidencyAlignedMipSizeMType a :: * + + vkResidencyAlignedMipSize :: a -> VkResidencyAlignedMipSizeMType a + + vkResidencyAlignedMipSizeByteOffset :: a -> Int + + readVkResidencyAlignedMipSize :: + Ptr a -> IO (VkResidencyAlignedMipSizeMType a) + + writeVkResidencyAlignedMipSize :: + Ptr a -> VkResidencyAlignedMipSizeMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'residencyAlignedMipSize'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkResidencyAlignedMipSize a + +class HasVkResidencyNonResidentStrict a where + type VkResidencyNonResidentStrictMType a :: * + + vkResidencyNonResidentStrict :: + a -> VkResidencyNonResidentStrictMType a + + vkResidencyNonResidentStrictByteOffset :: a -> Int + + readVkResidencyNonResidentStrict :: + Ptr a -> IO (VkResidencyNonResidentStrictMType a) + + writeVkResidencyNonResidentStrict :: + Ptr a -> VkResidencyNonResidentStrictMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'residencyNonResidentStrict'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkResidencyNonResidentStrict a + +class HasVkResidencyStandard2DBlockShape a where + type VkResidencyStandard2DBlockShapeMType a :: * + + vkResidencyStandard2DBlockShape :: + a -> VkResidencyStandard2DBlockShapeMType a + + vkResidencyStandard2DBlockShapeByteOffset :: a -> Int + + readVkResidencyStandard2DBlockShape :: + Ptr a -> IO (VkResidencyStandard2DBlockShapeMType a) + + writeVkResidencyStandard2DBlockShape :: + Ptr a -> + VkResidencyStandard2DBlockShapeMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text + " does not seem to have field 'residencyStandard2DBlockShape'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkResidencyStandard2DBlockShape a + +class HasVkResidencyStandard2DMultisampleBlockShape a where + type VkResidencyStandard2DMultisampleBlockShapeMType a :: * + + vkResidencyStandard2DMultisampleBlockShape :: + a -> + VkResidencyStandard2DMultisampleBlockShapeMType + a + + vkResidencyStandard2DMultisampleBlockShapeByteOffset :: a -> Int + + readVkResidencyStandard2DMultisampleBlockShape :: + Ptr a -> + IO + (VkResidencyStandard2DMultisampleBlockShapeMType + a) + + writeVkResidencyStandard2DMultisampleBlockShape :: + Ptr a -> + VkResidencyStandard2DMultisampleBlockShapeMType + a + -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text + " does not seem to have field 'residencyStandard2DMultisampleBlockShape'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkResidencyStandard2DMultisampleBlockShape a + +class HasVkResidencyStandard3DBlockShape a where + type VkResidencyStandard3DBlockShapeMType a :: * + + vkResidencyStandard3DBlockShape :: + a -> VkResidencyStandard3DBlockShapeMType a + + vkResidencyStandard3DBlockShapeByteOffset :: a -> Int + + readVkResidencyStandard3DBlockShape :: + Ptr a -> IO (VkResidencyStandard3DBlockShapeMType a) + + writeVkResidencyStandard3DBlockShape :: + Ptr a -> + VkResidencyStandard3DBlockShapeMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text + " does not seem to have field 'residencyStandard3DBlockShape'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkResidencyStandard3DBlockShape a + +class HasVkResourceDeviceIndex a where + type VkResourceDeviceIndexMType a :: * + + vkResourceDeviceIndex :: a -> VkResourceDeviceIndexMType a + + vkResourceDeviceIndexByteOffset :: a -> Int + + readVkResourceDeviceIndex :: + Ptr a -> IO (VkResourceDeviceIndexMType a) + + writeVkResourceDeviceIndex :: + Ptr a -> VkResourceDeviceIndexMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'resourceDeviceIndex'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkResourceDeviceIndex a + +class HasVkResourceOffset a where + type VkResourceOffsetMType a :: * + + vkResourceOffset :: a -> VkResourceOffsetMType a + + vkResourceOffsetByteOffset :: a -> Int + + readVkResourceOffset :: Ptr a -> IO (VkResourceOffsetMType a) + + writeVkResourceOffset :: Ptr a -> VkResourceOffsetMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'resourceOffset'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkResourceOffset a + +class HasVkResourceUsage a where + type VkResourceUsageMType a :: * + + vkResourceUsage :: a -> VkResourceUsageMType a + + vkResourceUsageByteOffset :: a -> Int + + readVkResourceUsage :: Ptr a -> IO (VkResourceUsageMType a) + + writeVkResourceUsage :: Ptr a -> VkResourceUsageMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'resourceUsage'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkResourceUsage a + +class HasVkRobustBufferAccess a where + type VkRobustBufferAccessMType a :: * + + vkRobustBufferAccess :: a -> VkRobustBufferAccessMType a + + vkRobustBufferAccessByteOffset :: a -> Int + + readVkRobustBufferAccess :: + Ptr a -> IO (VkRobustBufferAccessMType a) + + writeVkRobustBufferAccess :: + Ptr a -> VkRobustBufferAccessMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'robustBufferAccess'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkRobustBufferAccess a + +class HasVkRowPitch a where + type VkRowPitchMType a :: * + + vkRowPitch :: a -> VkRowPitchMType a + + vkRowPitchByteOffset :: a -> Int + + readVkRowPitch :: Ptr a -> IO (VkRowPitchMType a) + + writeVkRowPitch :: Ptr a -> VkRowPitchMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'rowPitch'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkRowPitch a + +class HasVkSFRRectCount a where + type VkSFRRectCountMType a :: * + + vkSFRRectCount :: a -> VkSFRRectCountMType a + + vkSFRRectCountByteOffset :: a -> Int + + readVkSFRRectCount :: Ptr a -> IO (VkSFRRectCountMType a) + + writeVkSFRRectCount :: Ptr a -> VkSFRRectCountMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'SFRRectCount'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkSFRRectCount a + +class HasVkSType a where + type VkSTypeMType a :: * + + vkSType :: a -> VkSTypeMType a + + vkSTypeByteOffset :: a -> Int + + readVkSType :: Ptr a -> IO (VkSTypeMType a) + + writeVkSType :: Ptr a -> VkSTypeMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'sType'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkSType a + +class HasVkSampleCounts a where + type VkSampleCountsMType a :: * + + vkSampleCounts :: a -> VkSampleCountsMType a + + vkSampleCountsByteOffset :: a -> Int + + readVkSampleCounts :: Ptr a -> IO (VkSampleCountsMType a) + + writeVkSampleCounts :: Ptr a -> VkSampleCountsMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'sampleCounts'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkSampleCounts a + +class HasVkSampleLocationCoordinateRangeArray a where + type VkSampleLocationCoordinateRangeArrayMType a :: * + + vkSampleLocationCoordinateRangeArray :: + a -> Int -> VkSampleLocationCoordinateRangeArrayMType a + + vkSampleLocationCoordinateRangeArrayByteOffset :: a -> Int + + readVkSampleLocationCoordinateRangeArray :: + Ptr a -> + Int -> + IO + (VkSampleLocationCoordinateRangeArrayMType a) + + writeVkSampleLocationCoordinateRangeArray :: + Ptr a -> + Int -> + VkSampleLocationCoordinateRangeArrayMType a -> + IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text + " does not seem to have field 'sampleLocationCoordinateRange'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkSampleLocationCoordinateRangeArray a + +class HasVkSampleLocationGridSize a where + type VkSampleLocationGridSizeMType a :: * + + vkSampleLocationGridSize :: a -> VkSampleLocationGridSizeMType a + + vkSampleLocationGridSizeByteOffset :: a -> Int + + readVkSampleLocationGridSize :: + Ptr a -> IO (VkSampleLocationGridSizeMType a) + + writeVkSampleLocationGridSize :: + Ptr a -> VkSampleLocationGridSizeMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'sampleLocationGridSize'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkSampleLocationGridSize a + +class HasVkSampleLocationSampleCounts a where + type VkSampleLocationSampleCountsMType a :: * + + vkSampleLocationSampleCounts :: + a -> VkSampleLocationSampleCountsMType a + + vkSampleLocationSampleCountsByteOffset :: a -> Int + + readVkSampleLocationSampleCounts :: + Ptr a -> IO (VkSampleLocationSampleCountsMType a) + + writeVkSampleLocationSampleCounts :: + Ptr a -> VkSampleLocationSampleCountsMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'sampleLocationSampleCounts'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkSampleLocationSampleCounts a + +class HasVkSampleLocationSubPixelBits a where + type VkSampleLocationSubPixelBitsMType a :: * + + vkSampleLocationSubPixelBits :: + a -> VkSampleLocationSubPixelBitsMType a + + vkSampleLocationSubPixelBitsByteOffset :: a -> Int + + readVkSampleLocationSubPixelBits :: + Ptr a -> IO (VkSampleLocationSubPixelBitsMType a) + + writeVkSampleLocationSubPixelBits :: + Ptr a -> VkSampleLocationSubPixelBitsMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'sampleLocationSubPixelBits'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkSampleLocationSubPixelBits a + +class HasVkSampleLocationsCount a where + type VkSampleLocationsCountMType a :: * + + vkSampleLocationsCount :: a -> VkSampleLocationsCountMType a + + vkSampleLocationsCountByteOffset :: a -> Int + + readVkSampleLocationsCount :: + Ptr a -> IO (VkSampleLocationsCountMType a) + + writeVkSampleLocationsCount :: + Ptr a -> VkSampleLocationsCountMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'sampleLocationsCount'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkSampleLocationsCount a + +class HasVkSampleLocationsEnable a where + type VkSampleLocationsEnableMType a :: * + + vkSampleLocationsEnable :: a -> VkSampleLocationsEnableMType a + + vkSampleLocationsEnableByteOffset :: a -> Int + + readVkSampleLocationsEnable :: + Ptr a -> IO (VkSampleLocationsEnableMType a) + + writeVkSampleLocationsEnable :: + Ptr a -> VkSampleLocationsEnableMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'sampleLocationsEnable'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkSampleLocationsEnable a + +class HasVkSampleLocationsInfo a where + type VkSampleLocationsInfoMType a :: * + + vkSampleLocationsInfo :: a -> VkSampleLocationsInfoMType a + + vkSampleLocationsInfoByteOffset :: a -> Int + + readVkSampleLocationsInfo :: + Ptr a -> IO (VkSampleLocationsInfoMType a) + + writeVkSampleLocationsInfo :: + Ptr a -> VkSampleLocationsInfoMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'sampleLocationsInfo'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkSampleLocationsInfo a + +class HasVkSampleLocationsPerPixel a where + type VkSampleLocationsPerPixelMType a :: * + + vkSampleLocationsPerPixel :: a -> VkSampleLocationsPerPixelMType a + + vkSampleLocationsPerPixelByteOffset :: a -> Int + + readVkSampleLocationsPerPixel :: + Ptr a -> IO (VkSampleLocationsPerPixelMType a) + + writeVkSampleLocationsPerPixel :: + Ptr a -> VkSampleLocationsPerPixelMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'sampleLocationsPerPixel'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkSampleLocationsPerPixel a + +class HasVkSampleRateShading a where + type VkSampleRateShadingMType a :: * + + vkSampleRateShading :: a -> VkSampleRateShadingMType a + + vkSampleRateShadingByteOffset :: a -> Int + + readVkSampleRateShading :: Ptr a -> IO (VkSampleRateShadingMType a) + + writeVkSampleRateShading :: + Ptr a -> VkSampleRateShadingMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'sampleRateShading'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkSampleRateShading a + +class HasVkSampleShadingEnable a where + type VkSampleShadingEnableMType a :: * + + vkSampleShadingEnable :: a -> VkSampleShadingEnableMType a + + vkSampleShadingEnableByteOffset :: a -> Int + + readVkSampleShadingEnable :: + Ptr a -> IO (VkSampleShadingEnableMType a) + + writeVkSampleShadingEnable :: + Ptr a -> VkSampleShadingEnableMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'sampleShadingEnable'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkSampleShadingEnable a + +class HasVkSampledImageColorSampleCounts a where + type VkSampledImageColorSampleCountsMType a :: * + + vkSampledImageColorSampleCounts :: + a -> VkSampledImageColorSampleCountsMType a + + vkSampledImageColorSampleCountsByteOffset :: a -> Int + + readVkSampledImageColorSampleCounts :: + Ptr a -> IO (VkSampledImageColorSampleCountsMType a) + + writeVkSampledImageColorSampleCounts :: + Ptr a -> + VkSampledImageColorSampleCountsMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text + " does not seem to have field 'sampledImageColorSampleCounts'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkSampledImageColorSampleCounts a + +class HasVkSampledImageDepthSampleCounts a where + type VkSampledImageDepthSampleCountsMType a :: * + + vkSampledImageDepthSampleCounts :: + a -> VkSampledImageDepthSampleCountsMType a + + vkSampledImageDepthSampleCountsByteOffset :: a -> Int + + readVkSampledImageDepthSampleCounts :: + Ptr a -> IO (VkSampledImageDepthSampleCountsMType a) + + writeVkSampledImageDepthSampleCounts :: + Ptr a -> + VkSampledImageDepthSampleCountsMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text + " does not seem to have field 'sampledImageDepthSampleCounts'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkSampledImageDepthSampleCounts a + +class HasVkSampledImageIntegerSampleCounts a where + type VkSampledImageIntegerSampleCountsMType a :: * + + vkSampledImageIntegerSampleCounts :: + a -> VkSampledImageIntegerSampleCountsMType a + + vkSampledImageIntegerSampleCountsByteOffset :: a -> Int + + readVkSampledImageIntegerSampleCounts :: + Ptr a -> IO (VkSampledImageIntegerSampleCountsMType a) + + writeVkSampledImageIntegerSampleCounts :: + Ptr a -> + VkSampledImageIntegerSampleCountsMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text + " does not seem to have field 'sampledImageIntegerSampleCounts'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkSampledImageIntegerSampleCounts a + +class HasVkSampledImageStencilSampleCounts a where + type VkSampledImageStencilSampleCountsMType a :: * + + vkSampledImageStencilSampleCounts :: + a -> VkSampledImageStencilSampleCountsMType a + + vkSampledImageStencilSampleCountsByteOffset :: a -> Int + + readVkSampledImageStencilSampleCounts :: + Ptr a -> IO (VkSampledImageStencilSampleCountsMType a) + + writeVkSampledImageStencilSampleCounts :: + Ptr a -> + VkSampledImageStencilSampleCountsMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text + " does not seem to have field 'sampledImageStencilSampleCounts'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkSampledImageStencilSampleCounts a + +class HasVkSampler a where + type VkSamplerMType a :: * + + vkSampler :: a -> VkSamplerMType a + + vkSamplerByteOffset :: a -> Int + + readVkSampler :: Ptr a -> IO (VkSamplerMType a) + + writeVkSampler :: Ptr a -> VkSamplerMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'sampler'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkSampler a + +class HasVkSamplerAnisotropy a where + type VkSamplerAnisotropyMType a :: * + + vkSamplerAnisotropy :: a -> VkSamplerAnisotropyMType a + + vkSamplerAnisotropyByteOffset :: a -> Int + + readVkSamplerAnisotropy :: Ptr a -> IO (VkSamplerAnisotropyMType a) + + writeVkSamplerAnisotropy :: + Ptr a -> VkSamplerAnisotropyMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'samplerAnisotropy'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkSamplerAnisotropy a + +class HasVkSamplerYcbcrConversion a where + type VkSamplerYcbcrConversionMType a :: * + + vkSamplerYcbcrConversion :: a -> VkSamplerYcbcrConversionMType a + + vkSamplerYcbcrConversionByteOffset :: a -> Int + + readVkSamplerYcbcrConversion :: + Ptr a -> IO (VkSamplerYcbcrConversionMType a) + + writeVkSamplerYcbcrConversion :: + Ptr a -> VkSamplerYcbcrConversionMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'samplerYcbcrConversion'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkSamplerYcbcrConversion a + +class HasVkSamples a where + type VkSamplesMType a :: * + + vkSamples :: a -> VkSamplesMType a + + vkSamplesByteOffset :: a -> Int + + readVkSamples :: Ptr a -> IO (VkSamplesMType a) + + writeVkSamples :: Ptr a -> VkSamplesMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'samples'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkSamples a + +class HasVkScissorCount a where + type VkScissorCountMType a :: * + + vkScissorCount :: a -> VkScissorCountMType a + + vkScissorCountByteOffset :: a -> Int + + readVkScissorCount :: Ptr a -> IO (VkScissorCountMType a) + + writeVkScissorCount :: Ptr a -> VkScissorCountMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'scissorCount'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkScissorCount a + +class HasVkScratchMemUsageInBytes a where + type VkScratchMemUsageInBytesMType a :: * + + vkScratchMemUsageInBytes :: a -> VkScratchMemUsageInBytesMType a + + vkScratchMemUsageInBytesByteOffset :: a -> Int + + readVkScratchMemUsageInBytes :: + Ptr a -> IO (VkScratchMemUsageInBytesMType a) + + writeVkScratchMemUsageInBytes :: + Ptr a -> VkScratchMemUsageInBytesMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'scratchMemUsageInBytes'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkScratchMemUsageInBytes a + +class HasVkSemaphore a where + type VkSemaphoreMType a :: * + + vkSemaphore :: a -> VkSemaphoreMType a + + vkSemaphoreByteOffset :: a -> Int + + readVkSemaphore :: Ptr a -> IO (VkSemaphoreMType a) + + writeVkSemaphore :: Ptr a -> VkSemaphoreMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'semaphore'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkSemaphore a + +class HasVkSequencesCountBuffer a where + type VkSequencesCountBufferMType a :: * + + vkSequencesCountBuffer :: a -> VkSequencesCountBufferMType a + + vkSequencesCountBufferByteOffset :: a -> Int + + readVkSequencesCountBuffer :: + Ptr a -> IO (VkSequencesCountBufferMType a) + + writeVkSequencesCountBuffer :: + Ptr a -> VkSequencesCountBufferMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'sequencesCountBuffer'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkSequencesCountBuffer a + +class HasVkSequencesCountOffset a where + type VkSequencesCountOffsetMType a :: * + + vkSequencesCountOffset :: a -> VkSequencesCountOffsetMType a + + vkSequencesCountOffsetByteOffset :: a -> Int + + readVkSequencesCountOffset :: + Ptr a -> IO (VkSequencesCountOffsetMType a) + + writeVkSequencesCountOffset :: + Ptr a -> VkSequencesCountOffsetMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'sequencesCountOffset'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkSequencesCountOffset a + +class HasVkSequencesIndexBuffer a where + type VkSequencesIndexBufferMType a :: * + + vkSequencesIndexBuffer :: a -> VkSequencesIndexBufferMType a + + vkSequencesIndexBufferByteOffset :: a -> Int + + readVkSequencesIndexBuffer :: + Ptr a -> IO (VkSequencesIndexBufferMType a) + + writeVkSequencesIndexBuffer :: + Ptr a -> VkSequencesIndexBufferMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'sequencesIndexBuffer'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkSequencesIndexBuffer a + +class HasVkSequencesIndexOffset a where + type VkSequencesIndexOffsetMType a :: * + + vkSequencesIndexOffset :: a -> VkSequencesIndexOffsetMType a + + vkSequencesIndexOffsetByteOffset :: a -> Int + + readVkSequencesIndexOffset :: + Ptr a -> IO (VkSequencesIndexOffsetMType a) + + writeVkSequencesIndexOffset :: + Ptr a -> VkSequencesIndexOffsetMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'sequencesIndexOffset'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkSequencesIndexOffset a + +class HasVkSet a where + type VkSetMType a :: * + + vkSet :: a -> VkSetMType a + + vkSetByteOffset :: a -> Int + + readVkSet :: Ptr a -> IO (VkSetMType a) + + writeVkSet :: Ptr a -> VkSetMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'set'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkSet a + +class HasVkSetLayoutCount a where + type VkSetLayoutCountMType a :: * + + vkSetLayoutCount :: a -> VkSetLayoutCountMType a + + vkSetLayoutCountByteOffset :: a -> Int + + readVkSetLayoutCount :: Ptr a -> IO (VkSetLayoutCountMType a) + + writeVkSetLayoutCount :: Ptr a -> VkSetLayoutCountMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'setLayoutCount'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkSetLayoutCount a + +class HasVkShaderClipDistance a where + type VkShaderClipDistanceMType a :: * + + vkShaderClipDistance :: a -> VkShaderClipDistanceMType a + + vkShaderClipDistanceByteOffset :: a -> Int + + readVkShaderClipDistance :: + Ptr a -> IO (VkShaderClipDistanceMType a) + + writeVkShaderClipDistance :: + Ptr a -> VkShaderClipDistanceMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'shaderClipDistance'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkShaderClipDistance a + +class HasVkShaderCullDistance a where + type VkShaderCullDistanceMType a :: * + + vkShaderCullDistance :: a -> VkShaderCullDistanceMType a + + vkShaderCullDistanceByteOffset :: a -> Int + + readVkShaderCullDistance :: + Ptr a -> IO (VkShaderCullDistanceMType a) + + writeVkShaderCullDistance :: + Ptr a -> VkShaderCullDistanceMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'shaderCullDistance'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkShaderCullDistance a + +class HasVkShaderFloat64 a where + type VkShaderFloat64MType a :: * + + vkShaderFloat64 :: a -> VkShaderFloat64MType a + + vkShaderFloat64ByteOffset :: a -> Int + + readVkShaderFloat64 :: Ptr a -> IO (VkShaderFloat64MType a) + + writeVkShaderFloat64 :: Ptr a -> VkShaderFloat64MType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'shaderFloat64'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkShaderFloat64 a + +class HasVkShaderImageGatherExtended a where + type VkShaderImageGatherExtendedMType a :: * + + vkShaderImageGatherExtended :: + a -> VkShaderImageGatherExtendedMType a + + vkShaderImageGatherExtendedByteOffset :: a -> Int + + readVkShaderImageGatherExtended :: + Ptr a -> IO (VkShaderImageGatherExtendedMType a) + + writeVkShaderImageGatherExtended :: + Ptr a -> VkShaderImageGatherExtendedMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'shaderImageGatherExtended'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkShaderImageGatherExtended a + +class HasVkShaderInt16 a where + type VkShaderInt16MType a :: * + + vkShaderInt16 :: a -> VkShaderInt16MType a + + vkShaderInt16ByteOffset :: a -> Int + + readVkShaderInt16 :: Ptr a -> IO (VkShaderInt16MType a) + + writeVkShaderInt16 :: Ptr a -> VkShaderInt16MType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'shaderInt16'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkShaderInt16 a + +class HasVkShaderInt64 a where + type VkShaderInt64MType a :: * + + vkShaderInt64 :: a -> VkShaderInt64MType a + + vkShaderInt64ByteOffset :: a -> Int + + readVkShaderInt64 :: Ptr a -> IO (VkShaderInt64MType a) + + writeVkShaderInt64 :: Ptr a -> VkShaderInt64MType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'shaderInt64'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkShaderInt64 a + +class HasVkShaderResourceMinLod a where + type VkShaderResourceMinLodMType a :: * + + vkShaderResourceMinLod :: a -> VkShaderResourceMinLodMType a + + vkShaderResourceMinLodByteOffset :: a -> Int + + readVkShaderResourceMinLod :: + Ptr a -> IO (VkShaderResourceMinLodMType a) + + writeVkShaderResourceMinLod :: + Ptr a -> VkShaderResourceMinLodMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'shaderResourceMinLod'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkShaderResourceMinLod a + +class HasVkShaderResourceResidency a where + type VkShaderResourceResidencyMType a :: * + + vkShaderResourceResidency :: a -> VkShaderResourceResidencyMType a + + vkShaderResourceResidencyByteOffset :: a -> Int + + readVkShaderResourceResidency :: + Ptr a -> IO (VkShaderResourceResidencyMType a) + + writeVkShaderResourceResidency :: + Ptr a -> VkShaderResourceResidencyMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'shaderResourceResidency'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkShaderResourceResidency a + +class HasVkShaderSampledImageArrayDynamicIndexing a where + type VkShaderSampledImageArrayDynamicIndexingMType a :: * + + vkShaderSampledImageArrayDynamicIndexing :: + a -> + VkShaderSampledImageArrayDynamicIndexingMType a + + vkShaderSampledImageArrayDynamicIndexingByteOffset :: a -> Int + + readVkShaderSampledImageArrayDynamicIndexing :: + Ptr a -> + IO + (VkShaderSampledImageArrayDynamicIndexingMType + a) + + writeVkShaderSampledImageArrayDynamicIndexing :: + Ptr a -> + VkShaderSampledImageArrayDynamicIndexingMType + a + -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text + " does not seem to have field 'shaderSampledImageArrayDynamicIndexing'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkShaderSampledImageArrayDynamicIndexing a + +class HasVkShaderStageMask a where + type VkShaderStageMaskMType a :: * + + vkShaderStageMask :: a -> VkShaderStageMaskMType a + + vkShaderStageMaskByteOffset :: a -> Int + + readVkShaderStageMask :: Ptr a -> IO (VkShaderStageMaskMType a) + + writeVkShaderStageMask :: + Ptr a -> VkShaderStageMaskMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'shaderStageMask'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkShaderStageMask a + +class HasVkShaderStorageBufferArrayDynamicIndexing a where + type VkShaderStorageBufferArrayDynamicIndexingMType a :: * + + vkShaderStorageBufferArrayDynamicIndexing :: + a -> + VkShaderStorageBufferArrayDynamicIndexingMType a + + vkShaderStorageBufferArrayDynamicIndexingByteOffset :: a -> Int + + readVkShaderStorageBufferArrayDynamicIndexing :: + Ptr a -> + IO + (VkShaderStorageBufferArrayDynamicIndexingMType + a) + + writeVkShaderStorageBufferArrayDynamicIndexing :: + Ptr a -> + VkShaderStorageBufferArrayDynamicIndexingMType + a + -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text + " does not seem to have field 'shaderStorageBufferArrayDynamicIndexing'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkShaderStorageBufferArrayDynamicIndexing a + +class HasVkShaderStorageImageArrayDynamicIndexing a where + type VkShaderStorageImageArrayDynamicIndexingMType a :: * + + vkShaderStorageImageArrayDynamicIndexing :: + a -> + VkShaderStorageImageArrayDynamicIndexingMType a + + vkShaderStorageImageArrayDynamicIndexingByteOffset :: a -> Int + + readVkShaderStorageImageArrayDynamicIndexing :: + Ptr a -> + IO + (VkShaderStorageImageArrayDynamicIndexingMType + a) + + writeVkShaderStorageImageArrayDynamicIndexing :: + Ptr a -> + VkShaderStorageImageArrayDynamicIndexingMType + a + -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text + " does not seem to have field 'shaderStorageImageArrayDynamicIndexing'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkShaderStorageImageArrayDynamicIndexing a + +class HasVkShaderStorageImageExtendedFormats a where + type VkShaderStorageImageExtendedFormatsMType a :: * + + vkShaderStorageImageExtendedFormats :: + a -> VkShaderStorageImageExtendedFormatsMType a + + vkShaderStorageImageExtendedFormatsByteOffset :: a -> Int + + readVkShaderStorageImageExtendedFormats :: + Ptr a -> + IO (VkShaderStorageImageExtendedFormatsMType a) + + writeVkShaderStorageImageExtendedFormats :: + Ptr a -> + VkShaderStorageImageExtendedFormatsMType a -> + IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text + " does not seem to have field 'shaderStorageImageExtendedFormats'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkShaderStorageImageExtendedFormats a + +class HasVkShaderStorageImageMultisample a where + type VkShaderStorageImageMultisampleMType a :: * + + vkShaderStorageImageMultisample :: + a -> VkShaderStorageImageMultisampleMType a + + vkShaderStorageImageMultisampleByteOffset :: a -> Int + + readVkShaderStorageImageMultisample :: + Ptr a -> IO (VkShaderStorageImageMultisampleMType a) + + writeVkShaderStorageImageMultisample :: + Ptr a -> + VkShaderStorageImageMultisampleMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text + " does not seem to have field 'shaderStorageImageMultisample'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkShaderStorageImageMultisample a + +class HasVkShaderStorageImageReadWithoutFormat a where + type VkShaderStorageImageReadWithoutFormatMType a :: * + + vkShaderStorageImageReadWithoutFormat :: + a -> VkShaderStorageImageReadWithoutFormatMType a + + vkShaderStorageImageReadWithoutFormatByteOffset :: a -> Int + + readVkShaderStorageImageReadWithoutFormat :: + Ptr a -> + IO + (VkShaderStorageImageReadWithoutFormatMType a) + + writeVkShaderStorageImageReadWithoutFormat :: + Ptr a -> + VkShaderStorageImageReadWithoutFormatMType a -> + IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text + " does not seem to have field 'shaderStorageImageReadWithoutFormat'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkShaderStorageImageReadWithoutFormat a + +class HasVkShaderStorageImageWriteWithoutFormat a where + type VkShaderStorageImageWriteWithoutFormatMType a :: * + + vkShaderStorageImageWriteWithoutFormat :: + a -> VkShaderStorageImageWriteWithoutFormatMType a + + vkShaderStorageImageWriteWithoutFormatByteOffset :: a -> Int + + readVkShaderStorageImageWriteWithoutFormat :: + Ptr a -> + IO + (VkShaderStorageImageWriteWithoutFormatMType + a) + + writeVkShaderStorageImageWriteWithoutFormat :: + Ptr a -> + VkShaderStorageImageWriteWithoutFormatMType a + -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text + " does not seem to have field 'shaderStorageImageWriteWithoutFormat'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkShaderStorageImageWriteWithoutFormat a + +class HasVkShaderTessellationAndGeometryPointSize a where + type VkShaderTessellationAndGeometryPointSizeMType a :: * + + vkShaderTessellationAndGeometryPointSize :: + a -> + VkShaderTessellationAndGeometryPointSizeMType a + + vkShaderTessellationAndGeometryPointSizeByteOffset :: a -> Int + + readVkShaderTessellationAndGeometryPointSize :: + Ptr a -> + IO + (VkShaderTessellationAndGeometryPointSizeMType + a) + + writeVkShaderTessellationAndGeometryPointSize :: + Ptr a -> + VkShaderTessellationAndGeometryPointSizeMType + a + -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text + " does not seem to have field 'shaderTessellationAndGeometryPointSize'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkShaderTessellationAndGeometryPointSize a + +class HasVkShaderUniformBufferArrayDynamicIndexing a where + type VkShaderUniformBufferArrayDynamicIndexingMType a :: * + + vkShaderUniformBufferArrayDynamicIndexing :: + a -> + VkShaderUniformBufferArrayDynamicIndexingMType a + + vkShaderUniformBufferArrayDynamicIndexingByteOffset :: a -> Int + + readVkShaderUniformBufferArrayDynamicIndexing :: + Ptr a -> + IO + (VkShaderUniformBufferArrayDynamicIndexingMType + a) + + writeVkShaderUniformBufferArrayDynamicIndexing :: + Ptr a -> + VkShaderUniformBufferArrayDynamicIndexingMType + a + -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text + " does not seem to have field 'shaderUniformBufferArrayDynamicIndexing'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkShaderUniformBufferArrayDynamicIndexing a + +class HasVkSharedPresentSupportedUsageFlags a where + type VkSharedPresentSupportedUsageFlagsMType a :: * + + vkSharedPresentSupportedUsageFlags :: + a -> VkSharedPresentSupportedUsageFlagsMType a + + vkSharedPresentSupportedUsageFlagsByteOffset :: a -> Int + + readVkSharedPresentSupportedUsageFlags :: + Ptr a -> + IO (VkSharedPresentSupportedUsageFlagsMType a) + + writeVkSharedPresentSupportedUsageFlags :: + Ptr a -> + VkSharedPresentSupportedUsageFlagsMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text + " does not seem to have field 'sharedPresentSupportedUsageFlags'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkSharedPresentSupportedUsageFlags a + +class HasVkSharingMode a where + type VkSharingModeMType a :: * + + vkSharingMode :: a -> VkSharingModeMType a + + vkSharingModeByteOffset :: a -> Int + + readVkSharingMode :: Ptr a -> IO (VkSharingModeMType a) + + writeVkSharingMode :: Ptr a -> VkSharingModeMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'sharingMode'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkSharingMode a + +class HasVkSignalSemaphoreCount a where + type VkSignalSemaphoreCountMType a :: * + + vkSignalSemaphoreCount :: a -> VkSignalSemaphoreCountMType a + + vkSignalSemaphoreCountByteOffset :: a -> Int + + readVkSignalSemaphoreCount :: + Ptr a -> IO (VkSignalSemaphoreCountMType a) + + writeVkSignalSemaphoreCount :: + Ptr a -> VkSignalSemaphoreCountMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'signalSemaphoreCount'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkSignalSemaphoreCount a + +class HasVkSignalSemaphoreValuesCount a where + type VkSignalSemaphoreValuesCountMType a :: * + + vkSignalSemaphoreValuesCount :: + a -> VkSignalSemaphoreValuesCountMType a + + vkSignalSemaphoreValuesCountByteOffset :: a -> Int + + readVkSignalSemaphoreValuesCount :: + Ptr a -> IO (VkSignalSemaphoreValuesCountMType a) + + writeVkSignalSemaphoreValuesCount :: + Ptr a -> VkSignalSemaphoreValuesCountMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'signalSemaphoreValuesCount'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkSignalSemaphoreValuesCount a + +class HasVkSize a where + type VkSizeMType a :: * + + vkSize :: a -> VkSizeMType a + + vkSizeByteOffset :: a -> Int + + readVkSize :: Ptr a -> IO (VkSizeMType a) + + writeVkSize :: Ptr a -> VkSizeMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'size'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkSize a + +class HasVkSparseAddressSpaceSize a where + type VkSparseAddressSpaceSizeMType a :: * + + vkSparseAddressSpaceSize :: a -> VkSparseAddressSpaceSizeMType a + + vkSparseAddressSpaceSizeByteOffset :: a -> Int + + readVkSparseAddressSpaceSize :: + Ptr a -> IO (VkSparseAddressSpaceSizeMType a) + + writeVkSparseAddressSpaceSize :: + Ptr a -> VkSparseAddressSpaceSizeMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'sparseAddressSpaceSize'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkSparseAddressSpaceSize a + +class HasVkSparseBinding a where + type VkSparseBindingMType a :: * + + vkSparseBinding :: a -> VkSparseBindingMType a + + vkSparseBindingByteOffset :: a -> Int + + readVkSparseBinding :: Ptr a -> IO (VkSparseBindingMType a) + + writeVkSparseBinding :: Ptr a -> VkSparseBindingMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'sparseBinding'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkSparseBinding a + +class HasVkSparseProperties a where + type VkSparsePropertiesMType a :: * + + vkSparseProperties :: a -> VkSparsePropertiesMType a + + vkSparsePropertiesByteOffset :: a -> Int + + readVkSparseProperties :: Ptr a -> IO (VkSparsePropertiesMType a) + + writeVkSparseProperties :: + Ptr a -> VkSparsePropertiesMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'sparseProperties'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkSparseProperties a + +class HasVkSparseResidency16Samples a where + type VkSparseResidency16SamplesMType a :: * + + vkSparseResidency16Samples :: + a -> VkSparseResidency16SamplesMType a + + vkSparseResidency16SamplesByteOffset :: a -> Int + + readVkSparseResidency16Samples :: + Ptr a -> IO (VkSparseResidency16SamplesMType a) + + writeVkSparseResidency16Samples :: + Ptr a -> VkSparseResidency16SamplesMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'sparseResidency16Samples'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkSparseResidency16Samples a + +class HasVkSparseResidency2Samples a where + type VkSparseResidency2SamplesMType a :: * + + vkSparseResidency2Samples :: a -> VkSparseResidency2SamplesMType a + + vkSparseResidency2SamplesByteOffset :: a -> Int + + readVkSparseResidency2Samples :: + Ptr a -> IO (VkSparseResidency2SamplesMType a) + + writeVkSparseResidency2Samples :: + Ptr a -> VkSparseResidency2SamplesMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'sparseResidency2Samples'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkSparseResidency2Samples a + +class HasVkSparseResidency4Samples a where + type VkSparseResidency4SamplesMType a :: * + + vkSparseResidency4Samples :: a -> VkSparseResidency4SamplesMType a + + vkSparseResidency4SamplesByteOffset :: a -> Int + + readVkSparseResidency4Samples :: + Ptr a -> IO (VkSparseResidency4SamplesMType a) + + writeVkSparseResidency4Samples :: + Ptr a -> VkSparseResidency4SamplesMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'sparseResidency4Samples'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkSparseResidency4Samples a + +class HasVkSparseResidency8Samples a where + type VkSparseResidency8SamplesMType a :: * + + vkSparseResidency8Samples :: a -> VkSparseResidency8SamplesMType a + + vkSparseResidency8SamplesByteOffset :: a -> Int + + readVkSparseResidency8Samples :: + Ptr a -> IO (VkSparseResidency8SamplesMType a) + + writeVkSparseResidency8Samples :: + Ptr a -> VkSparseResidency8SamplesMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'sparseResidency8Samples'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkSparseResidency8Samples a + +class HasVkSparseResidencyAliased a where + type VkSparseResidencyAliasedMType a :: * + + vkSparseResidencyAliased :: a -> VkSparseResidencyAliasedMType a + + vkSparseResidencyAliasedByteOffset :: a -> Int + + readVkSparseResidencyAliased :: + Ptr a -> IO (VkSparseResidencyAliasedMType a) + + writeVkSparseResidencyAliased :: + Ptr a -> VkSparseResidencyAliasedMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'sparseResidencyAliased'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkSparseResidencyAliased a + +class HasVkSparseResidencyBuffer a where + type VkSparseResidencyBufferMType a :: * + + vkSparseResidencyBuffer :: a -> VkSparseResidencyBufferMType a + + vkSparseResidencyBufferByteOffset :: a -> Int + + readVkSparseResidencyBuffer :: + Ptr a -> IO (VkSparseResidencyBufferMType a) + + writeVkSparseResidencyBuffer :: + Ptr a -> VkSparseResidencyBufferMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'sparseResidencyBuffer'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkSparseResidencyBuffer a + +class HasVkSparseResidencyImage2D a where + type VkSparseResidencyImage2DMType a :: * + + vkSparseResidencyImage2D :: a -> VkSparseResidencyImage2DMType a + + vkSparseResidencyImage2DByteOffset :: a -> Int + + readVkSparseResidencyImage2D :: + Ptr a -> IO (VkSparseResidencyImage2DMType a) + + writeVkSparseResidencyImage2D :: + Ptr a -> VkSparseResidencyImage2DMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'sparseResidencyImage2D'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkSparseResidencyImage2D a + +class HasVkSparseResidencyImage3D a where + type VkSparseResidencyImage3DMType a :: * + + vkSparseResidencyImage3D :: a -> VkSparseResidencyImage3DMType a + + vkSparseResidencyImage3DByteOffset :: a -> Int + + readVkSparseResidencyImage3D :: + Ptr a -> IO (VkSparseResidencyImage3DMType a) + + writeVkSparseResidencyImage3D :: + Ptr a -> VkSparseResidencyImage3DMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'sparseResidencyImage3D'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkSparseResidencyImage3D a + +class HasVkSpecVersion a where + type VkSpecVersionMType a :: * + + vkSpecVersion :: a -> VkSpecVersionMType a + + vkSpecVersionByteOffset :: a -> Int + + readVkSpecVersion :: Ptr a -> IO (VkSpecVersionMType a) + + writeVkSpecVersion :: Ptr a -> VkSpecVersionMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'specVersion'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkSpecVersion a + +class HasVkSrcAccessMask a where + type VkSrcAccessMaskMType a :: * + + vkSrcAccessMask :: a -> VkSrcAccessMaskMType a + + vkSrcAccessMaskByteOffset :: a -> Int + + readVkSrcAccessMask :: Ptr a -> IO (VkSrcAccessMaskMType a) + + writeVkSrcAccessMask :: Ptr a -> VkSrcAccessMaskMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'srcAccessMask'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkSrcAccessMask a + +class HasVkSrcAlphaBlendFactor a where + type VkSrcAlphaBlendFactorMType a :: * + + vkSrcAlphaBlendFactor :: a -> VkSrcAlphaBlendFactorMType a + + vkSrcAlphaBlendFactorByteOffset :: a -> Int + + readVkSrcAlphaBlendFactor :: + Ptr a -> IO (VkSrcAlphaBlendFactorMType a) + + writeVkSrcAlphaBlendFactor :: + Ptr a -> VkSrcAlphaBlendFactorMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'srcAlphaBlendFactor'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkSrcAlphaBlendFactor a + +class HasVkSrcArrayElement a where + type VkSrcArrayElementMType a :: * + + vkSrcArrayElement :: a -> VkSrcArrayElementMType a + + vkSrcArrayElementByteOffset :: a -> Int + + readVkSrcArrayElement :: Ptr a -> IO (VkSrcArrayElementMType a) + + writeVkSrcArrayElement :: + Ptr a -> VkSrcArrayElementMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'srcArrayElement'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkSrcArrayElement a + +class HasVkSrcBinding a where + type VkSrcBindingMType a :: * + + vkSrcBinding :: a -> VkSrcBindingMType a + + vkSrcBindingByteOffset :: a -> Int + + readVkSrcBinding :: Ptr a -> IO (VkSrcBindingMType a) + + writeVkSrcBinding :: Ptr a -> VkSrcBindingMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'srcBinding'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkSrcBinding a + +class HasVkSrcColorBlendFactor a where + type VkSrcColorBlendFactorMType a :: * + + vkSrcColorBlendFactor :: a -> VkSrcColorBlendFactorMType a + + vkSrcColorBlendFactorByteOffset :: a -> Int + + readVkSrcColorBlendFactor :: + Ptr a -> IO (VkSrcColorBlendFactorMType a) + + writeVkSrcColorBlendFactor :: + Ptr a -> VkSrcColorBlendFactorMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'srcColorBlendFactor'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkSrcColorBlendFactor a + +class HasVkSrcOffset a where + type VkSrcOffsetMType a :: * + + vkSrcOffset :: a -> VkSrcOffsetMType a + + vkSrcOffsetByteOffset :: a -> Int + + readVkSrcOffset :: Ptr a -> IO (VkSrcOffsetMType a) + + writeVkSrcOffset :: Ptr a -> VkSrcOffsetMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'srcOffset'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkSrcOffset a + +class HasVkSrcOffsetsArray a where + type VkSrcOffsetsArrayMType a :: * + + vkSrcOffsetsArray :: a -> Int -> VkSrcOffsetsArrayMType a + + vkSrcOffsetsArrayByteOffset :: a -> Int + + readVkSrcOffsetsArray :: + Ptr a -> Int -> IO (VkSrcOffsetsArrayMType a) + + writeVkSrcOffsetsArray :: + Ptr a -> Int -> VkSrcOffsetsArrayMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'srcOffsets'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkSrcOffsetsArray a + +class HasVkSrcPremultiplied a where + type VkSrcPremultipliedMType a :: * + + vkSrcPremultiplied :: a -> VkSrcPremultipliedMType a + + vkSrcPremultipliedByteOffset :: a -> Int + + readVkSrcPremultiplied :: Ptr a -> IO (VkSrcPremultipliedMType a) + + writeVkSrcPremultiplied :: + Ptr a -> VkSrcPremultipliedMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'srcPremultiplied'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkSrcPremultiplied a + +class HasVkSrcQueueFamilyIndex a where + type VkSrcQueueFamilyIndexMType a :: * + + vkSrcQueueFamilyIndex :: a -> VkSrcQueueFamilyIndexMType a + + vkSrcQueueFamilyIndexByteOffset :: a -> Int + + readVkSrcQueueFamilyIndex :: + Ptr a -> IO (VkSrcQueueFamilyIndexMType a) + + writeVkSrcQueueFamilyIndex :: + Ptr a -> VkSrcQueueFamilyIndexMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'srcQueueFamilyIndex'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkSrcQueueFamilyIndex a + +class HasVkSrcRect a where + type VkSrcRectMType a :: * + + vkSrcRect :: a -> VkSrcRectMType a + + vkSrcRectByteOffset :: a -> Int + + readVkSrcRect :: Ptr a -> IO (VkSrcRectMType a) + + writeVkSrcRect :: Ptr a -> VkSrcRectMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'srcRect'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkSrcRect a + +class HasVkSrcSet a where + type VkSrcSetMType a :: * + + vkSrcSet :: a -> VkSrcSetMType a + + vkSrcSetByteOffset :: a -> Int + + readVkSrcSet :: Ptr a -> IO (VkSrcSetMType a) + + writeVkSrcSet :: Ptr a -> VkSrcSetMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'srcSet'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkSrcSet a + +class HasVkSrcStageMask a where + type VkSrcStageMaskMType a :: * + + vkSrcStageMask :: a -> VkSrcStageMaskMType a + + vkSrcStageMaskByteOffset :: a -> Int + + readVkSrcStageMask :: Ptr a -> IO (VkSrcStageMaskMType a) + + writeVkSrcStageMask :: Ptr a -> VkSrcStageMaskMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'srcStageMask'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkSrcStageMask a + +class HasVkSrcSubpass a where + type VkSrcSubpassMType a :: * + + vkSrcSubpass :: a -> VkSrcSubpassMType a + + vkSrcSubpassByteOffset :: a -> Int + + readVkSrcSubpass :: Ptr a -> IO (VkSrcSubpassMType a) + + writeVkSrcSubpass :: Ptr a -> VkSrcSubpassMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'srcSubpass'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkSrcSubpass a + +class HasVkSrcSubresource a where + type VkSrcSubresourceMType a :: * + + vkSrcSubresource :: a -> VkSrcSubresourceMType a + + vkSrcSubresourceByteOffset :: a -> Int + + readVkSrcSubresource :: Ptr a -> IO (VkSrcSubresourceMType a) + + writeVkSrcSubresource :: Ptr a -> VkSrcSubresourceMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'srcSubresource'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkSrcSubresource a + +class HasVkStage a where + type VkStageMType a :: * + + vkStage :: a -> VkStageMType a + + vkStageByteOffset :: a -> Int + + readVkStage :: Ptr a -> IO (VkStageMType a) + + writeVkStage :: Ptr a -> VkStageMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'stage'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkStage a + +class HasVkStageCount a where + type VkStageCountMType a :: * + + vkStageCount :: a -> VkStageCountMType a + + vkStageCountByteOffset :: a -> Int + + readVkStageCount :: Ptr a -> IO (VkStageCountMType a) + + writeVkStageCount :: Ptr a -> VkStageCountMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'stageCount'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkStageCount a + +class HasVkStageFlags a where + type VkStageFlagsMType a :: * + + vkStageFlags :: a -> VkStageFlagsMType a + + vkStageFlagsByteOffset :: a -> Int + + readVkStageFlags :: Ptr a -> IO (VkStageFlagsMType a) + + writeVkStageFlags :: Ptr a -> VkStageFlagsMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'stageFlags'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkStageFlags a + +class HasVkStandardSampleLocations a where + type VkStandardSampleLocationsMType a :: * + + vkStandardSampleLocations :: a -> VkStandardSampleLocationsMType a + + vkStandardSampleLocationsByteOffset :: a -> Int + + readVkStandardSampleLocations :: + Ptr a -> IO (VkStandardSampleLocationsMType a) + + writeVkStandardSampleLocations :: + Ptr a -> VkStandardSampleLocationsMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'standardSampleLocations'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkStandardSampleLocations a + +class HasVkStencil a where + type VkStencilMType a :: * + + vkStencil :: a -> VkStencilMType a + + vkStencilByteOffset :: a -> Int + + readVkStencil :: Ptr a -> IO (VkStencilMType a) + + writeVkStencil :: Ptr a -> VkStencilMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'stencil'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkStencil a + +class HasVkStencilLoadOp a where + type VkStencilLoadOpMType a :: * + + vkStencilLoadOp :: a -> VkStencilLoadOpMType a + + vkStencilLoadOpByteOffset :: a -> Int + + readVkStencilLoadOp :: Ptr a -> IO (VkStencilLoadOpMType a) + + writeVkStencilLoadOp :: Ptr a -> VkStencilLoadOpMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'stencilLoadOp'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkStencilLoadOp a + +class HasVkStencilStoreOp a where + type VkStencilStoreOpMType a :: * + + vkStencilStoreOp :: a -> VkStencilStoreOpMType a + + vkStencilStoreOpByteOffset :: a -> Int + + readVkStencilStoreOp :: Ptr a -> IO (VkStencilStoreOpMType a) + + writeVkStencilStoreOp :: Ptr a -> VkStencilStoreOpMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'stencilStoreOp'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkStencilStoreOp a + +class HasVkStencilTestEnable a where + type VkStencilTestEnableMType a :: * + + vkStencilTestEnable :: a -> VkStencilTestEnableMType a + + vkStencilTestEnableByteOffset :: a -> Int + + readVkStencilTestEnable :: Ptr a -> IO (VkStencilTestEnableMType a) + + writeVkStencilTestEnable :: + Ptr a -> VkStencilTestEnableMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'stencilTestEnable'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkStencilTestEnable a + +class HasVkStorageBuffer16BitAccess a where + type VkStorageBuffer16BitAccessMType a :: * + + vkStorageBuffer16BitAccess :: + a -> VkStorageBuffer16BitAccessMType a + + vkStorageBuffer16BitAccessByteOffset :: a -> Int + + readVkStorageBuffer16BitAccess :: + Ptr a -> IO (VkStorageBuffer16BitAccessMType a) + + writeVkStorageBuffer16BitAccess :: + Ptr a -> VkStorageBuffer16BitAccessMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'storageBuffer16BitAccess'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkStorageBuffer16BitAccess a + +class HasVkStorageImageSampleCounts a where + type VkStorageImageSampleCountsMType a :: * + + vkStorageImageSampleCounts :: + a -> VkStorageImageSampleCountsMType a + + vkStorageImageSampleCountsByteOffset :: a -> Int + + readVkStorageImageSampleCounts :: + Ptr a -> IO (VkStorageImageSampleCountsMType a) + + writeVkStorageImageSampleCounts :: + Ptr a -> VkStorageImageSampleCountsMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'storageImageSampleCounts'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkStorageImageSampleCounts a + +class HasVkStorageInputOutput16 a where + type VkStorageInputOutput16MType a :: * + + vkStorageInputOutput16 :: a -> VkStorageInputOutput16MType a + + vkStorageInputOutput16ByteOffset :: a -> Int + + readVkStorageInputOutput16 :: + Ptr a -> IO (VkStorageInputOutput16MType a) + + writeVkStorageInputOutput16 :: + Ptr a -> VkStorageInputOutput16MType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'storageInputOutput16'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkStorageInputOutput16 a + +class HasVkStoragePushConstant16 a where + type VkStoragePushConstant16MType a :: * + + vkStoragePushConstant16 :: a -> VkStoragePushConstant16MType a + + vkStoragePushConstant16ByteOffset :: a -> Int + + readVkStoragePushConstant16 :: + Ptr a -> IO (VkStoragePushConstant16MType a) + + writeVkStoragePushConstant16 :: + Ptr a -> VkStoragePushConstant16MType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'storagePushConstant16'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkStoragePushConstant16 a + +class HasVkStoreOp a where + type VkStoreOpMType a :: * + + vkStoreOp :: a -> VkStoreOpMType a + + vkStoreOpByteOffset :: a -> Int + + readVkStoreOp :: Ptr a -> IO (VkStoreOpMType a) + + writeVkStoreOp :: Ptr a -> VkStoreOpMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'storeOp'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkStoreOp a + +class HasVkStrictLines a where + type VkStrictLinesMType a :: * + + vkStrictLines :: a -> VkStrictLinesMType a + + vkStrictLinesByteOffset :: a -> Int + + readVkStrictLines :: Ptr a -> IO (VkStrictLinesMType a) + + writeVkStrictLines :: Ptr a -> VkStrictLinesMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'strictLines'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkStrictLines a + +class HasVkStride a where + type VkStrideMType a :: * + + vkStride :: a -> VkStrideMType a + + vkStrideByteOffset :: a -> Int + + readVkStride :: Ptr a -> IO (VkStrideMType a) + + writeVkStride :: Ptr a -> VkStrideMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'stride'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkStride a + +class HasVkSubPixelInterpolationOffsetBits a where + type VkSubPixelInterpolationOffsetBitsMType a :: * + + vkSubPixelInterpolationOffsetBits :: + a -> VkSubPixelInterpolationOffsetBitsMType a + + vkSubPixelInterpolationOffsetBitsByteOffset :: a -> Int + + readVkSubPixelInterpolationOffsetBits :: + Ptr a -> IO (VkSubPixelInterpolationOffsetBitsMType a) + + writeVkSubPixelInterpolationOffsetBits :: + Ptr a -> + VkSubPixelInterpolationOffsetBitsMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text + " does not seem to have field 'subPixelInterpolationOffsetBits'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkSubPixelInterpolationOffsetBits a + +class HasVkSubPixelPrecisionBits a where + type VkSubPixelPrecisionBitsMType a :: * + + vkSubPixelPrecisionBits :: a -> VkSubPixelPrecisionBitsMType a + + vkSubPixelPrecisionBitsByteOffset :: a -> Int + + readVkSubPixelPrecisionBits :: + Ptr a -> IO (VkSubPixelPrecisionBitsMType a) + + writeVkSubPixelPrecisionBits :: + Ptr a -> VkSubPixelPrecisionBitsMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'subPixelPrecisionBits'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkSubPixelPrecisionBits a + +class HasVkSubTexelPrecisionBits a where + type VkSubTexelPrecisionBitsMType a :: * + + vkSubTexelPrecisionBits :: a -> VkSubTexelPrecisionBitsMType a + + vkSubTexelPrecisionBitsByteOffset :: a -> Int + + readVkSubTexelPrecisionBits :: + Ptr a -> IO (VkSubTexelPrecisionBitsMType a) + + writeVkSubTexelPrecisionBits :: + Ptr a -> VkSubTexelPrecisionBitsMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'subTexelPrecisionBits'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkSubTexelPrecisionBits a + +class HasVkSubpass a where + type VkSubpassMType a :: * + + vkSubpass :: a -> VkSubpassMType a + + vkSubpassByteOffset :: a -> Int + + readVkSubpass :: Ptr a -> IO (VkSubpassMType a) + + writeVkSubpass :: Ptr a -> VkSubpassMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'subpass'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkSubpass a + +class HasVkSubpassCount a where + type VkSubpassCountMType a :: * + + vkSubpassCount :: a -> VkSubpassCountMType a + + vkSubpassCountByteOffset :: a -> Int + + readVkSubpassCount :: Ptr a -> IO (VkSubpassCountMType a) + + writeVkSubpassCount :: Ptr a -> VkSubpassCountMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'subpassCount'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkSubpassCount a + +class HasVkSubpassIndex a where + type VkSubpassIndexMType a :: * + + vkSubpassIndex :: a -> VkSubpassIndexMType a + + vkSubpassIndexByteOffset :: a -> Int + + readVkSubpassIndex :: Ptr a -> IO (VkSubpassIndexMType a) + + writeVkSubpassIndex :: Ptr a -> VkSubpassIndexMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'subpassIndex'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkSubpassIndex a + +class HasVkSubresource a where + type VkSubresourceMType a :: * + + vkSubresource :: a -> VkSubresourceMType a + + vkSubresourceByteOffset :: a -> Int + + readVkSubresource :: Ptr a -> IO (VkSubresourceMType a) + + writeVkSubresource :: Ptr a -> VkSubresourceMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'subresource'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkSubresource a + +class HasVkSubresourceRange a where + type VkSubresourceRangeMType a :: * + + vkSubresourceRange :: a -> VkSubresourceRangeMType a + + vkSubresourceRangeByteOffset :: a -> Int + + readVkSubresourceRange :: Ptr a -> IO (VkSubresourceRangeMType a) + + writeVkSubresourceRange :: + Ptr a -> VkSubresourceRangeMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'subresourceRange'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkSubresourceRange a + +class HasVkSubsetAllocation a where + type VkSubsetAllocationMType a :: * + + vkSubsetAllocation :: a -> VkSubsetAllocationMType a + + vkSubsetAllocationByteOffset :: a -> Int + + readVkSubsetAllocation :: Ptr a -> IO (VkSubsetAllocationMType a) + + writeVkSubsetAllocation :: + Ptr a -> VkSubsetAllocationMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'subsetAllocation'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkSubsetAllocation a + +class HasVkSupportedAlpha a where + type VkSupportedAlphaMType a :: * + + vkSupportedAlpha :: a -> VkSupportedAlphaMType a + + vkSupportedAlphaByteOffset :: a -> Int + + readVkSupportedAlpha :: Ptr a -> IO (VkSupportedAlphaMType a) + + writeVkSupportedAlpha :: Ptr a -> VkSupportedAlphaMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'supportedAlpha'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkSupportedAlpha a + +class HasVkSupportedCompositeAlpha a where + type VkSupportedCompositeAlphaMType a :: * + + vkSupportedCompositeAlpha :: a -> VkSupportedCompositeAlphaMType a + + vkSupportedCompositeAlphaByteOffset :: a -> Int + + readVkSupportedCompositeAlpha :: + Ptr a -> IO (VkSupportedCompositeAlphaMType a) + + writeVkSupportedCompositeAlpha :: + Ptr a -> VkSupportedCompositeAlphaMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'supportedCompositeAlpha'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkSupportedCompositeAlpha a + +class HasVkSupportedSurfaceCounters a where + type VkSupportedSurfaceCountersMType a :: * + + vkSupportedSurfaceCounters :: + a -> VkSupportedSurfaceCountersMType a + + vkSupportedSurfaceCountersByteOffset :: a -> Int + + readVkSupportedSurfaceCounters :: + Ptr a -> IO (VkSupportedSurfaceCountersMType a) + + writeVkSupportedSurfaceCounters :: + Ptr a -> VkSupportedSurfaceCountersMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'supportedSurfaceCounters'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkSupportedSurfaceCounters a + +class HasVkSupportedTransforms a where + type VkSupportedTransformsMType a :: * + + vkSupportedTransforms :: a -> VkSupportedTransformsMType a + + vkSupportedTransformsByteOffset :: a -> Int + + readVkSupportedTransforms :: + Ptr a -> IO (VkSupportedTransformsMType a) + + writeVkSupportedTransforms :: + Ptr a -> VkSupportedTransformsMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'supportedTransforms'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkSupportedTransforms a + +class HasVkSupportedUsageFlags a where + type VkSupportedUsageFlagsMType a :: * + + vkSupportedUsageFlags :: a -> VkSupportedUsageFlagsMType a + + vkSupportedUsageFlagsByteOffset :: a -> Int + + readVkSupportedUsageFlags :: + Ptr a -> IO (VkSupportedUsageFlagsMType a) + + writeVkSupportedUsageFlags :: + Ptr a -> VkSupportedUsageFlagsMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'supportedUsageFlags'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkSupportedUsageFlags a + +class HasVkSupportsTextureGatherLODBiasAMD a where + type VkSupportsTextureGatherLODBiasAMDMType a :: * + + vkSupportsTextureGatherLODBiasAMD :: + a -> VkSupportsTextureGatherLODBiasAMDMType a + + vkSupportsTextureGatherLODBiasAMDByteOffset :: a -> Int + + readVkSupportsTextureGatherLODBiasAMD :: + Ptr a -> IO (VkSupportsTextureGatherLODBiasAMDMType a) + + writeVkSupportsTextureGatherLODBiasAMD :: + Ptr a -> + VkSupportsTextureGatherLODBiasAMDMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text + " does not seem to have field 'supportsTextureGatherLODBiasAMD'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkSupportsTextureGatherLODBiasAMD a + +class HasVkSurface a where + type VkSurfaceMType a :: * + + vkSurface :: a -> VkSurfaceMType a + + vkSurfaceByteOffset :: a -> Int + + readVkSurface :: Ptr a -> IO (VkSurfaceMType a) + + writeVkSurface :: Ptr a -> VkSurfaceMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'surface'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkSurface a + +class HasVkSurfaceCapabilities a where + type VkSurfaceCapabilitiesMType a :: * + + vkSurfaceCapabilities :: a -> VkSurfaceCapabilitiesMType a + + vkSurfaceCapabilitiesByteOffset :: a -> Int + + readVkSurfaceCapabilities :: + Ptr a -> IO (VkSurfaceCapabilitiesMType a) + + writeVkSurfaceCapabilities :: + Ptr a -> VkSurfaceCapabilitiesMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'surfaceCapabilities'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkSurfaceCapabilities a + +class HasVkSurfaceCounters a where + type VkSurfaceCountersMType a :: * + + vkSurfaceCounters :: a -> VkSurfaceCountersMType a + + vkSurfaceCountersByteOffset :: a -> Int + + readVkSurfaceCounters :: Ptr a -> IO (VkSurfaceCountersMType a) + + writeVkSurfaceCounters :: + Ptr a -> VkSurfaceCountersMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'surfaceCounters'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkSurfaceCounters a + +class HasVkSurfaceFormat a where + type VkSurfaceFormatMType a :: * + + vkSurfaceFormat :: a -> VkSurfaceFormatMType a + + vkSurfaceFormatByteOffset :: a -> Int + + readVkSurfaceFormat :: Ptr a -> IO (VkSurfaceFormatMType a) + + writeVkSurfaceFormat :: Ptr a -> VkSurfaceFormatMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'surfaceFormat'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkSurfaceFormat a + +class HasVkSwapchain a where + type VkSwapchainMType a :: * + + vkSwapchain :: a -> VkSwapchainMType a + + vkSwapchainByteOffset :: a -> Int + + readVkSwapchain :: Ptr a -> IO (VkSwapchainMType a) + + writeVkSwapchain :: Ptr a -> VkSwapchainMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'swapchain'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkSwapchain a + +class HasVkSwapchainCount a where + type VkSwapchainCountMType a :: * + + vkSwapchainCount :: a -> VkSwapchainCountMType a + + vkSwapchainCountByteOffset :: a -> Int + + readVkSwapchainCount :: Ptr a -> IO (VkSwapchainCountMType a) + + writeVkSwapchainCount :: Ptr a -> VkSwapchainCountMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'swapchainCount'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkSwapchainCount a + +class HasVkTagName a where + type VkTagNameMType a :: * + + vkTagName :: a -> VkTagNameMType a + + vkTagNameByteOffset :: a -> Int + + readVkTagName :: Ptr a -> IO (VkTagNameMType a) + + writeVkTagName :: Ptr a -> VkTagNameMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'tagName'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkTagName a + +class HasVkTagSize a where + type VkTagSizeMType a :: * + + vkTagSize :: a -> VkTagSizeMType a + + vkTagSizeByteOffset :: a -> Int + + readVkTagSize :: Ptr a -> IO (VkTagSizeMType a) + + writeVkTagSize :: Ptr a -> VkTagSizeMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'tagSize'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkTagSize a + +class HasVkTargetCommandBuffer a where + type VkTargetCommandBufferMType a :: * + + vkTargetCommandBuffer :: a -> VkTargetCommandBufferMType a + + vkTargetCommandBufferByteOffset :: a -> Int + + readVkTargetCommandBuffer :: + Ptr a -> IO (VkTargetCommandBufferMType a) + + writeVkTargetCommandBuffer :: + Ptr a -> VkTargetCommandBufferMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'targetCommandBuffer'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkTargetCommandBuffer a + +class HasVkTemplateType a where + type VkTemplateTypeMType a :: * + + vkTemplateType :: a -> VkTemplateTypeMType a + + vkTemplateTypeByteOffset :: a -> Int + + readVkTemplateType :: Ptr a -> IO (VkTemplateTypeMType a) + + writeVkTemplateType :: Ptr a -> VkTemplateTypeMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'templateType'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkTemplateType a + +class HasVkTessellationShader a where + type VkTessellationShaderMType a :: * + + vkTessellationShader :: a -> VkTessellationShaderMType a + + vkTessellationShaderByteOffset :: a -> Int + + readVkTessellationShader :: + Ptr a -> IO (VkTessellationShaderMType a) + + writeVkTessellationShader :: + Ptr a -> VkTessellationShaderMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'tessellationShader'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkTessellationShader a + +class HasVkTextureCompressionASTC_LDR a where + type VkTextureCompressionASTC_LDRMType a :: * + + vkTextureCompressionASTC_LDR :: + a -> VkTextureCompressionASTC_LDRMType a + + vkTextureCompressionASTC_LDRByteOffset :: a -> Int + + readVkTextureCompressionASTC_LDR :: + Ptr a -> IO (VkTextureCompressionASTC_LDRMType a) + + writeVkTextureCompressionASTC_LDR :: + Ptr a -> VkTextureCompressionASTC_LDRMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'textureCompressionASTC_LDR'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkTextureCompressionASTC_LDR a + +class HasVkTextureCompressionBC a where + type VkTextureCompressionBCMType a :: * + + vkTextureCompressionBC :: a -> VkTextureCompressionBCMType a + + vkTextureCompressionBCByteOffset :: a -> Int + + readVkTextureCompressionBC :: + Ptr a -> IO (VkTextureCompressionBCMType a) + + writeVkTextureCompressionBC :: + Ptr a -> VkTextureCompressionBCMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'textureCompressionBC'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkTextureCompressionBC a + +class HasVkTextureCompressionETC2 a where + type VkTextureCompressionETC2MType a :: * + + vkTextureCompressionETC2 :: a -> VkTextureCompressionETC2MType a + + vkTextureCompressionETC2ByteOffset :: a -> Int + + readVkTextureCompressionETC2 :: + Ptr a -> IO (VkTextureCompressionETC2MType a) + + writeVkTextureCompressionETC2 :: + Ptr a -> VkTextureCompressionETC2MType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'textureCompressionETC2'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkTextureCompressionETC2 a + +class HasVkTiling a where + type VkTilingMType a :: * + + vkTiling :: a -> VkTilingMType a + + vkTilingByteOffset :: a -> Int + + readVkTiling :: Ptr a -> IO (VkTilingMType a) + + writeVkTiling :: Ptr a -> VkTilingMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'tiling'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkTiling a + +class HasVkTimeout a where + type VkTimeoutMType a :: * + + vkTimeout :: a -> VkTimeoutMType a + + vkTimeoutByteOffset :: a -> Int + + readVkTimeout :: Ptr a -> IO (VkTimeoutMType a) + + writeVkTimeout :: Ptr a -> VkTimeoutMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'timeout'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkTimeout a + +class HasVkTimestampComputeAndGraphics a where + type VkTimestampComputeAndGraphicsMType a :: * + + vkTimestampComputeAndGraphics :: + a -> VkTimestampComputeAndGraphicsMType a + + vkTimestampComputeAndGraphicsByteOffset :: a -> Int + + readVkTimestampComputeAndGraphics :: + Ptr a -> IO (VkTimestampComputeAndGraphicsMType a) + + writeVkTimestampComputeAndGraphics :: + Ptr a -> VkTimestampComputeAndGraphicsMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'timestampComputeAndGraphics'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkTimestampComputeAndGraphics a + +class HasVkTimestampPeriod a where + type VkTimestampPeriodMType a :: * + + vkTimestampPeriod :: a -> VkTimestampPeriodMType a + + vkTimestampPeriodByteOffset :: a -> Int + + readVkTimestampPeriod :: Ptr a -> IO (VkTimestampPeriodMType a) + + writeVkTimestampPeriod :: + Ptr a -> VkTimestampPeriodMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'timestampPeriod'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkTimestampPeriod a + +class HasVkTimestampValidBits a where + type VkTimestampValidBitsMType a :: * + + vkTimestampValidBits :: a -> VkTimestampValidBitsMType a + + vkTimestampValidBitsByteOffset :: a -> Int + + readVkTimestampValidBits :: + Ptr a -> IO (VkTimestampValidBitsMType a) + + writeVkTimestampValidBits :: + Ptr a -> VkTimestampValidBitsMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'timestampValidBits'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkTimestampValidBits a + +class HasVkTokenCount a where + type VkTokenCountMType a :: * + + vkTokenCount :: a -> VkTokenCountMType a + + vkTokenCountByteOffset :: a -> Int + + readVkTokenCount :: Ptr a -> IO (VkTokenCountMType a) + + writeVkTokenCount :: Ptr a -> VkTokenCountMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'tokenCount'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkTokenCount a + +class HasVkTokenType a where + type VkTokenTypeMType a :: * + + vkTokenType :: a -> VkTokenTypeMType a + + vkTokenTypeByteOffset :: a -> Int + + readVkTokenType :: Ptr a -> IO (VkTokenTypeMType a) + + writeVkTokenType :: Ptr a -> VkTokenTypeMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'tokenType'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkTokenType a + +class HasVkTopology a where + type VkTopologyMType a :: * + + vkTopology :: a -> VkTopologyMType a + + vkTopologyByteOffset :: a -> Int + + readVkTopology :: Ptr a -> IO (VkTopologyMType a) + + writeVkTopology :: Ptr a -> VkTopologyMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'topology'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkTopology a + +class HasVkTransform a where + type VkTransformMType a :: * + + vkTransform :: a -> VkTransformMType a + + vkTransformByteOffset :: a -> Int + + readVkTransform :: Ptr a -> IO (VkTransformMType a) + + writeVkTransform :: Ptr a -> VkTransformMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'transform'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkTransform a + +class HasVkType a where + type VkTypeMType a :: * + + vkType :: a -> VkTypeMType a + + vkTypeByteOffset :: a -> Int + + readVkType :: Ptr a -> IO (VkTypeMType a) + + writeVkType :: Ptr a -> VkTypeMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'type'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkType a + +class HasVkUint32Array a where + type VkUint32ArrayMType a :: * + + vkUint32Array :: a -> Int -> VkUint32ArrayMType a + + vkUint32ArrayByteOffset :: a -> Int + + readVkUint32Array :: Ptr a -> Int -> IO (VkUint32ArrayMType a) + + writeVkUint32Array :: Ptr a -> Int -> VkUint32ArrayMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'uint32'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkUint32Array a + +class HasVkUniformAndStorageBuffer16BitAccess a where + type VkUniformAndStorageBuffer16BitAccessMType a :: * + + vkUniformAndStorageBuffer16BitAccess :: + a -> VkUniformAndStorageBuffer16BitAccessMType a + + vkUniformAndStorageBuffer16BitAccessByteOffset :: a -> Int + + readVkUniformAndStorageBuffer16BitAccess :: + Ptr a -> + IO (VkUniformAndStorageBuffer16BitAccessMType a) + + writeVkUniformAndStorageBuffer16BitAccess :: + Ptr a -> + VkUniformAndStorageBuffer16BitAccessMType a -> + IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text + " does not seem to have field 'uniformAndStorageBuffer16BitAccess'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkUniformAndStorageBuffer16BitAccess a + +class HasVkUnnormalizedCoordinates a where + type VkUnnormalizedCoordinatesMType a :: * + + vkUnnormalizedCoordinates :: a -> VkUnnormalizedCoordinatesMType a + + vkUnnormalizedCoordinatesByteOffset :: a -> Int + + readVkUnnormalizedCoordinates :: + Ptr a -> IO (VkUnnormalizedCoordinatesMType a) + + writeVkUnnormalizedCoordinates :: + Ptr a -> VkUnnormalizedCoordinatesMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'unnormalizedCoordinates'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkUnnormalizedCoordinates a + +class HasVkUsage a where + type VkUsageMType a :: * + + vkUsage :: a -> VkUsageMType a + + vkUsageByteOffset :: a -> Int + + readVkUsage :: Ptr a -> IO (VkUsageMType a) + + writeVkUsage :: Ptr a -> VkUsageMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'usage'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkUsage a + +class HasVkValidationCache a where + type VkValidationCacheMType a :: * + + vkValidationCache :: a -> VkValidationCacheMType a + + vkValidationCacheByteOffset :: a -> Int + + readVkValidationCache :: Ptr a -> IO (VkValidationCacheMType a) + + writeVkValidationCache :: + Ptr a -> VkValidationCacheMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'validationCache'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkValidationCache a + +class HasVkVariableMultisampleRate a where + type VkVariableMultisampleRateMType a :: * + + vkVariableMultisampleRate :: a -> VkVariableMultisampleRateMType a + + vkVariableMultisampleRateByteOffset :: a -> Int + + readVkVariableMultisampleRate :: + Ptr a -> IO (VkVariableMultisampleRateMType a) + + writeVkVariableMultisampleRate :: + Ptr a -> VkVariableMultisampleRateMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'variableMultisampleRate'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkVariableMultisampleRate a + +class HasVkVariablePointers a where + type VkVariablePointersMType a :: * + + vkVariablePointers :: a -> VkVariablePointersMType a + + vkVariablePointersByteOffset :: a -> Int + + readVkVariablePointers :: Ptr a -> IO (VkVariablePointersMType a) + + writeVkVariablePointers :: + Ptr a -> VkVariablePointersMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'variablePointers'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkVariablePointers a + +class HasVkVariablePointersStorageBuffer a where + type VkVariablePointersStorageBufferMType a :: * + + vkVariablePointersStorageBuffer :: + a -> VkVariablePointersStorageBufferMType a + + vkVariablePointersStorageBufferByteOffset :: a -> Int + + readVkVariablePointersStorageBuffer :: + Ptr a -> IO (VkVariablePointersStorageBufferMType a) + + writeVkVariablePointersStorageBuffer :: + Ptr a -> + VkVariablePointersStorageBufferMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text + " does not seem to have field 'variablePointersStorageBuffer'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkVariablePointersStorageBuffer a + +class HasVkVariableSampleLocations a where + type VkVariableSampleLocationsMType a :: * + + vkVariableSampleLocations :: a -> VkVariableSampleLocationsMType a + + vkVariableSampleLocationsByteOffset :: a -> Int + + readVkVariableSampleLocations :: + Ptr a -> IO (VkVariableSampleLocationsMType a) + + writeVkVariableSampleLocations :: + Ptr a -> VkVariableSampleLocationsMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'variableSampleLocations'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkVariableSampleLocations a + +class HasVkVendorID a where + type VkVendorIDMType a :: * + + vkVendorID :: a -> VkVendorIDMType a + + vkVendorIDByteOffset :: a -> Int + + readVkVendorID :: Ptr a -> IO (VkVendorIDMType a) + + writeVkVendorID :: Ptr a -> VkVendorIDMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'vendorID'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkVendorID a + +class HasVkVertexAttributeDescriptionCount a where + type VkVertexAttributeDescriptionCountMType a :: * + + vkVertexAttributeDescriptionCount :: + a -> VkVertexAttributeDescriptionCountMType a + + vkVertexAttributeDescriptionCountByteOffset :: a -> Int + + readVkVertexAttributeDescriptionCount :: + Ptr a -> IO (VkVertexAttributeDescriptionCountMType a) + + writeVkVertexAttributeDescriptionCount :: + Ptr a -> + VkVertexAttributeDescriptionCountMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text + " does not seem to have field 'vertexAttributeDescriptionCount'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkVertexAttributeDescriptionCount a + +class HasVkVertexBindingDescriptionCount a where + type VkVertexBindingDescriptionCountMType a :: * + + vkVertexBindingDescriptionCount :: + a -> VkVertexBindingDescriptionCountMType a + + vkVertexBindingDescriptionCountByteOffset :: a -> Int + + readVkVertexBindingDescriptionCount :: + Ptr a -> IO (VkVertexBindingDescriptionCountMType a) + + writeVkVertexBindingDescriptionCount :: + Ptr a -> + VkVertexBindingDescriptionCountMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text + " does not seem to have field 'vertexBindingDescriptionCount'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkVertexBindingDescriptionCount a + +class HasVkVertexCount a where + type VkVertexCountMType a :: * + + vkVertexCount :: a -> VkVertexCountMType a + + vkVertexCountByteOffset :: a -> Int + + readVkVertexCount :: Ptr a -> IO (VkVertexCountMType a) + + writeVkVertexCount :: Ptr a -> VkVertexCountMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'vertexCount'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkVertexCount a + +class HasVkVertexOffset a where + type VkVertexOffsetMType a :: * + + vkVertexOffset :: a -> VkVertexOffsetMType a + + vkVertexOffsetByteOffset :: a -> Int + + readVkVertexOffset :: Ptr a -> IO (VkVertexOffsetMType a) + + writeVkVertexOffset :: Ptr a -> VkVertexOffsetMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'vertexOffset'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkVertexOffset a + +class HasVkVertexPipelineStoresAndAtomics a where + type VkVertexPipelineStoresAndAtomicsMType a :: * + + vkVertexPipelineStoresAndAtomics :: + a -> VkVertexPipelineStoresAndAtomicsMType a + + vkVertexPipelineStoresAndAtomicsByteOffset :: a -> Int + + readVkVertexPipelineStoresAndAtomics :: + Ptr a -> IO (VkVertexPipelineStoresAndAtomicsMType a) + + writeVkVertexPipelineStoresAndAtomics :: + Ptr a -> + VkVertexPipelineStoresAndAtomicsMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text + " does not seem to have field 'vertexPipelineStoresAndAtomics'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkVertexPipelineStoresAndAtomics a + +class HasVkViewFormatCount a where + type VkViewFormatCountMType a :: * + + vkViewFormatCount :: a -> VkViewFormatCountMType a + + vkViewFormatCountByteOffset :: a -> Int + + readVkViewFormatCount :: Ptr a -> IO (VkViewFormatCountMType a) + + writeVkViewFormatCount :: + Ptr a -> VkViewFormatCountMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'viewFormatCount'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkViewFormatCount a + +class HasVkViewType a where + type VkViewTypeMType a :: * + + vkViewType :: a -> VkViewTypeMType a + + vkViewTypeByteOffset :: a -> Int + + readVkViewType :: Ptr a -> IO (VkViewTypeMType a) + + writeVkViewType :: Ptr a -> VkViewTypeMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'viewType'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkViewType a + +class HasVkViewportBoundsRangeArray a where + type VkViewportBoundsRangeArrayMType a :: * + + vkViewportBoundsRangeArray :: + a -> Int -> VkViewportBoundsRangeArrayMType a + + vkViewportBoundsRangeArrayByteOffset :: a -> Int + + readVkViewportBoundsRangeArray :: + Ptr a -> Int -> IO (VkViewportBoundsRangeArrayMType a) + + writeVkViewportBoundsRangeArray :: + Ptr a -> Int -> VkViewportBoundsRangeArrayMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'viewportBoundsRange'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkViewportBoundsRangeArray a + +class HasVkViewportCount a where + type VkViewportCountMType a :: * + + vkViewportCount :: a -> VkViewportCountMType a + + vkViewportCountByteOffset :: a -> Int + + readVkViewportCount :: Ptr a -> IO (VkViewportCountMType a) + + writeVkViewportCount :: Ptr a -> VkViewportCountMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'viewportCount'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkViewportCount a + +class HasVkViewportSubPixelBits a where + type VkViewportSubPixelBitsMType a :: * + + vkViewportSubPixelBits :: a -> VkViewportSubPixelBitsMType a + + vkViewportSubPixelBitsByteOffset :: a -> Int + + readVkViewportSubPixelBits :: + Ptr a -> IO (VkViewportSubPixelBitsMType a) + + writeVkViewportSubPixelBits :: + Ptr a -> VkViewportSubPixelBitsMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'viewportSubPixelBits'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkViewportSubPixelBits a + +class HasVkViewportWScalingEnable a where + type VkViewportWScalingEnableMType a :: * + + vkViewportWScalingEnable :: a -> VkViewportWScalingEnableMType a + + vkViewportWScalingEnableByteOffset :: a -> Int + + readVkViewportWScalingEnable :: + Ptr a -> IO (VkViewportWScalingEnableMType a) + + writeVkViewportWScalingEnable :: + Ptr a -> VkViewportWScalingEnableMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'viewportWScalingEnable'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkViewportWScalingEnable a + +class HasVkVisibleRegion a where + type VkVisibleRegionMType a :: * + + vkVisibleRegion :: a -> VkVisibleRegionMType a + + vkVisibleRegionByteOffset :: a -> Int + + readVkVisibleRegion :: Ptr a -> IO (VkVisibleRegionMType a) + + writeVkVisibleRegion :: Ptr a -> VkVisibleRegionMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'visibleRegion'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkVisibleRegion a + +class HasVkW a where + type VkWMType a :: * + + vkW :: a -> VkWMType a + + vkWByteOffset :: a -> Int + + readVkW :: Ptr a -> IO (VkWMType a) + + writeVkW :: Ptr a -> VkWMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'w'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkW a + +class HasVkWaitSemaphoreCount a where + type VkWaitSemaphoreCountMType a :: * + + vkWaitSemaphoreCount :: a -> VkWaitSemaphoreCountMType a + + vkWaitSemaphoreCountByteOffset :: a -> Int + + readVkWaitSemaphoreCount :: + Ptr a -> IO (VkWaitSemaphoreCountMType a) + + writeVkWaitSemaphoreCount :: + Ptr a -> VkWaitSemaphoreCountMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'waitSemaphoreCount'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkWaitSemaphoreCount a + +class HasVkWaitSemaphoreValuesCount a where + type VkWaitSemaphoreValuesCountMType a :: * + + vkWaitSemaphoreValuesCount :: + a -> VkWaitSemaphoreValuesCountMType a + + vkWaitSemaphoreValuesCountByteOffset :: a -> Int + + readVkWaitSemaphoreValuesCount :: + Ptr a -> IO (VkWaitSemaphoreValuesCountMType a) + + writeVkWaitSemaphoreValuesCount :: + Ptr a -> VkWaitSemaphoreValuesCountMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'waitSemaphoreValuesCount'." + ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkWaitSemaphoreValuesCount a + +class HasVkWhitePoint a where + type VkWhitePointMType a :: * + + vkWhitePoint :: a -> VkWhitePointMType a + + vkWhitePointByteOffset :: a -> Int + + readVkWhitePoint :: Ptr a -> IO (VkWhitePointMType a) + + writeVkWhitePoint :: Ptr a -> VkWhitePointMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'whitePoint'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkWhitePoint a + +class HasVkWideLines a where + type VkWideLinesMType a :: * + + vkWideLines :: a -> VkWideLinesMType a + + vkWideLinesByteOffset :: a -> Int + + readVkWideLines :: Ptr a -> IO (VkWideLinesMType a) + + writeVkWideLines :: Ptr a -> VkWideLinesMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'wideLines'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkWideLines a + +class HasVkWidth a where + type VkWidthMType a :: * + + vkWidth :: a -> VkWidthMType a + + vkWidthByteOffset :: a -> Int + + readVkWidth :: Ptr a -> IO (VkWidthMType a) + + writeVkWidth :: Ptr a -> VkWidthMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'width'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkWidth a + +class HasVkWindow a where + type VkWindowMType a :: * + + vkWindow :: a -> VkWindowMType a + + vkWindowByteOffset :: a -> Int + + readVkWindow :: Ptr a -> IO (VkWindowMType a) + + writeVkWindow :: Ptr a -> VkWindowMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'window'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkWindow a + +class HasVkWriteMask a where + type VkWriteMaskMType a :: * + + vkWriteMask :: a -> VkWriteMaskMType a + + vkWriteMaskByteOffset :: a -> Int + + readVkWriteMask :: Ptr a -> IO (VkWriteMaskMType a) + + writeVkWriteMask :: Ptr a -> VkWriteMaskMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'writeMask'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkWriteMask a + +class HasVkX a where + type VkXMType a :: * + + vkX :: a -> VkXMType a + + vkXByteOffset :: a -> Int + + readVkX :: Ptr a -> IO (VkXMType a) + + writeVkX :: Ptr a -> VkXMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'x'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkX a + +class HasVkXChromaOffset a where + type VkXChromaOffsetMType a :: * + + vkXChromaOffset :: a -> VkXChromaOffsetMType a + + vkXChromaOffsetByteOffset :: a -> Int + + readVkXChromaOffset :: Ptr a -> IO (VkXChromaOffsetMType a) + + writeVkXChromaOffset :: Ptr a -> VkXChromaOffsetMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'xChromaOffset'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkXChromaOffset a + +class HasVkXcoeff a where + type VkXcoeffMType a :: * + + vkXcoeff :: a -> VkXcoeffMType a + + vkXcoeffByteOffset :: a -> Int + + readVkXcoeff :: Ptr a -> IO (VkXcoeffMType a) + + writeVkXcoeff :: Ptr a -> VkXcoeffMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'xcoeff'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkXcoeff a + +class HasVkY a where + type VkYMType a :: * + + vkY :: a -> VkYMType a + + vkYByteOffset :: a -> Int + + readVkY :: Ptr a -> IO (VkYMType a) + + writeVkY :: Ptr a -> VkYMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'y'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkY a + +class HasVkYChromaOffset a where + type VkYChromaOffsetMType a :: * + + vkYChromaOffset :: a -> VkYChromaOffsetMType a + + vkYChromaOffsetByteOffset :: a -> Int + + readVkYChromaOffset :: Ptr a -> IO (VkYChromaOffsetMType a) + + writeVkYChromaOffset :: Ptr a -> VkYChromaOffsetMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'yChromaOffset'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkYChromaOffset a + +class HasVkYcbcrModel a where + type VkYcbcrModelMType a :: * + + vkYcbcrModel :: a -> VkYcbcrModelMType a + + vkYcbcrModelByteOffset :: a -> Int + + readVkYcbcrModel :: Ptr a -> IO (VkYcbcrModelMType a) + + writeVkYcbcrModel :: Ptr a -> VkYcbcrModelMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'ycbcrModel'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkYcbcrModel a + +class HasVkYcbcrRange a where + type VkYcbcrRangeMType a :: * + + vkYcbcrRange :: a -> VkYcbcrRangeMType a + + vkYcbcrRangeByteOffset :: a -> Int + + readVkYcbcrRange :: Ptr a -> IO (VkYcbcrRangeMType a) + + writeVkYcbcrRange :: Ptr a -> VkYcbcrRangeMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'ycbcrRange'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkYcbcrRange a + +class HasVkYcoeff a where + type VkYcoeffMType a :: * + + vkYcoeff :: a -> VkYcoeffMType a + + vkYcoeffByteOffset :: a -> Int + + readVkYcoeff :: Ptr a -> IO (VkYcoeffMType a) + + writeVkYcoeff :: Ptr a -> VkYcoeffMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'ycoeff'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkYcoeff a + +class HasVkZ a where + type VkZMType a :: * + + vkZ :: a -> VkZMType a + + vkZByteOffset :: a -> Int + + readVkZ :: Ptr a -> IO (VkZMType a) + + writeVkZ :: Ptr a -> VkZMType a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError + ('ShowType a ':<>: + 'Text " does not seem to have field 'z'." ':$$: + 'Text + "Check Vulkan documentation for available fields of this type.") => + HasVkZ a diff --git a/src/Graphics/Vulkan.hs b/src/Graphics/Vulkan.hs new file mode 100644 --- /dev/null +++ b/src/Graphics/Vulkan.hs @@ -0,0 +1,22 @@ +{-# LANGUAGE Strict #-} +-- | This module is not part of auto-generated code based on vk.xml. +-- Instead, it is hand-written to aggregate all generated code. +module Graphics.Vulkan + ( module Graphics.Vulkan.Marshal + , module Graphics.Vulkan.Constants + , module Graphics.Vulkan.Core + , module Graphics.Vulkan.Types.Defines + , module Graphics.Vulkan.Types.Funcpointers + , module Graphics.Vulkan.Types.Handles + , module Graphics.Vulkan.Types.Include + , module Graphics.Vulkan.Types.StructMembers + ) where + +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Constants +import Graphics.Vulkan.Core +import Graphics.Vulkan.Types.Defines +import Graphics.Vulkan.Types.Funcpointers +import Graphics.Vulkan.Types.Handles +import Graphics.Vulkan.Types.Include +import Graphics.Vulkan.Types.StructMembers diff --git a/src/Graphics/Vulkan/Marshal.hs b/src/Graphics/Vulkan/Marshal.hs new file mode 100644 --- /dev/null +++ b/src/Graphics/Vulkan/Marshal.hs @@ -0,0 +1,422 @@ +{-# OPTIONS_GHC -fno-warn-missing-methods #-} +{-# LANGUAGE AllowAmbiguousTypes #-} +{-# LANGUAGE ConstraintKinds #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DefaultSignatures #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleContexts #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE KindSignatures #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE RoleAnnotations #-} +{-# LANGUAGE ScopedTypeVariables #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeApplications #-} +{-# LANGUAGE TypeFamilies #-} +{-# LANGUAGE TypeOperators #-} +{-# LANGUAGE UndecidableInstances #-} +{-# LANGUAGE UndecidableSuperClasses #-} +{-# LANGUAGE ViewPatterns #-} +-- | This module is not part of auto-generated code based on vk.xml. +-- Instead, it is hand-written to provide common types and classes. +module Graphics.Vulkan.Marshal + ( FlagType (..), FlagMask, FlagBit + , VulkanMarshal (..), VulkanMarshalPrim () + , VulkanPtr (..) + , VkPtr (..) + , pattern VK_NULL_HANDLE, pattern VK_NULL + , clearStorable, withPtr + -- * Type-indexed access to struct members + , HasField (..), CanReadField (..), CanWriteField (..) + , CanReadFieldArray (..), CanWriteFieldArray (..), IndexInBounds + -- * Re-exported functions from 'Foreign.ForeignPtr' + , mallocForeignPtr, withForeignPtr, addForeignPtrFinalizer + -- * Re-exported common types + , Int8, Int16, Int32, Int64 + , Word8, Word16, Word32, Word64 + , Ptr, FunPtr, Void, CString + , CInt (..), CSize (..), CChar (..), CWchar (..), CULong (..) + -- * Utilities for string types + , withCStringField, unsafeCStringField + , getStringField, readStringField, writeStringField + , eqCStrings, eqCStringsN + ) where + +import Data.Data (Data) +import Data.Int (Int16, Int32, Int64, Int8) +import Data.Kind (Constraint, Type) +import Data.Void (Void) +import Data.Word (Word16, Word32, Word64, + Word8) +import Foreign.C.String (CString, peekCString) +import Foreign.C.Types (CChar (..), CWchar (..), CInt (..), CSize (..), CULong (..)) +import Foreign.ForeignPtr (ForeignPtr, + addForeignPtrFinalizer, + mallocForeignPtr, + withForeignPtr) +import Foreign.Marshal.Array (pokeArray0) +import Foreign.Marshal.Utils (fillBytes) +import Foreign.Ptr (FunPtr, nullPtr, plusPtr) +import Foreign.Storable (Storable (sizeOf)) +import GHC.Generics (Generic) +import GHC.Ptr (Ptr (..)) +import GHC.TypeLits +import System.IO.Unsafe (unsafeDupablePerformIO) + +import Graphics.Vulkan.Marshal.Internal + +-- | Distinguish single bits and bitmasks in vulkan flags +data FlagType = FlagMask | FlagBit + +-- | Vulkan flags type that can have multiple bits set. +type FlagMask = 'FlagMask +-- | Vulkan single bit flag value. +type FlagBit = 'FlagBit + + +-- | All Vulkan structures are stored as-is in byte arrays to avoid any overheads +-- for wrapping and unwrapping haskell values. +-- VulkanMarshal provides an interfaces to write and read these structures +-- in an imperative way. +class VulkanMarshal a where + -- | Names of fields in vulkan structure or union, + -- in the same order as they appear in C typedef. + type StructFields a :: [Symbol] + -- | Whether this type is a C union. + -- Otherwise this is a C structure. + type CUnionType a :: Bool + -- | Notes that this struct or union is going to be filled in by the API, + -- rather than an application filling it out and passing it to the API. + type ReturnedOnly a :: Bool + -- | Comma-separated list of structures whose "pNext" can include this type. + type StructExtends a :: [Type] + -- | Allocate a pinned aligned byte array to keep vulkan data structure + -- and fill it using a foreign function. + -- + -- Note, the function is supposed to use `newAlignedPinnedByteArray#` + -- and does not guarantee to fill memory with zeroes. + -- Use `clearStorable` to make sure all bytes are set to zero. + -- + -- Note, the memory is managed by GHC, thus no need for freeing it manually. + newVkData :: (Ptr a -> IO ()) -> IO a + default newVkData :: (Storable a, VulkanMarshalPrim a) + => (Ptr a -> IO ()) -> IO a + newVkData = newVkData# + {-# INLINE newVkData #-} + -- | Allocate a pinned aligned byte array to keep vulkan data structure. + -- + -- Note, the function is supposed to use `newAlignedPinnedByteArray#` + -- and does not guarantee to fill memory with zeroes. + -- Use `clearStorable` to make sure all bytes are set to zero. + -- + -- Note, the memory is managed by GHC, thus no need for freeing it manually. + mallocVkData :: IO a + default mallocVkData :: (Storable a, VulkanMarshalPrim a) => IO a + mallocVkData = mallocVkData# + {-# INLINE mallocVkData #-} + -- | Allocate a pinned aligned byte array to keep vulkan data structures. + -- Returned `Ptr a` points to the first element in the contiguous array of + -- returned structures. Returned list elements point to the same memory area. + -- This function is unsafe in two ways: + -- + -- * Several structures are stored next to each other, with no gaps; + -- it would break its alignment if the size is not multiple of alignment. + -- * Returned pointer is not tracked by GHC as a reference to the managed + -- memory. Thus, the array can be GCed if all references to the returned + -- list are lost. + -- + -- Note, the function is supposed to use `newAlignedPinnedByteArray#` + -- and does not guarantee to fill memory with zeroes. + -- Use `clearStorable` to make sure all bytes are set to zero. + -- + -- Note, the memory is managed by GHC, thus no need for freeing it manually. + mallocVkDataArray :: Int -> IO (Ptr a, [a]) + default mallocVkDataArray :: (Storable a, VulkanMarshalPrim a) + => Int -> IO (Ptr a, [a]) + mallocVkDataArray = mallocVkDataArray# + {-# INLINE mallocVkDataArray #-} + -- | Get pointer to vulkan structure. + -- Note, the address is only valid as long as a given vulkan structure exists. + -- Structures created with newVkData are stored in pinned byte arrays, + -- so their memory is maintained by Haskell GC. + unsafePtr :: a -> Ptr a + default unsafePtr :: VulkanMarshalPrim a => a -> Ptr a + unsafePtr a = Ptr (unsafeAddr a) + {-# INLINE unsafePtr #-} + -- | Get vulkan structure referenced by a 'ForeignPtr' trying to avoid copying data. + -- + -- This function does copy data if called on an unmanaged `ForeignPtr` + -- (i.e. one created from ordinary `Ptr` using something like `newForeignPtr`.). + -- + -- This function does not copy data if called on a managed `ForeignPtr` + -- (i.e. one created using `mallocForeignPtr`, or `toForeignPtr`, or `toPlainForeignPtr`). + -- + -- Note, `fromForeignPtr` does not copy finalizers of `ForeignPtr`. + -- Thus, if all references to original `ForeignPtr` are lost, + -- its attached finalizers may run even if the created structure is alive. + fromForeignPtr :: ForeignPtr a -> IO a + default fromForeignPtr :: (Storable a, VulkanMarshalPrim a) + => ForeignPtr a -> IO a + fromForeignPtr = fromForeignPtr# + {-# INLINE fromForeignPtr #-} + -- | Create a `ForeignPtr` referencing the structure without copying data. + toForeignPtr :: a -> IO (ForeignPtr a) + default toForeignPtr :: VulkanMarshalPrim a => a -> IO (ForeignPtr a) + toForeignPtr = toForeignPtr# + {-# INLINE toForeignPtr #-} + -- | Create a `ForeignPtr` referencing the structure without copying data. + -- This version of a pointer carries no finalizers. + -- + -- It is not possible to add a finalizer to a ForeignPtr created with + -- @toPlainForeignPtr@. + -- Attempts to add a finalizer to a ForeignPtr created this way, or to + -- finalize such a pointer, will throw an exception. + toPlainForeignPtr :: a -> IO (ForeignPtr a) + default toPlainForeignPtr :: VulkanMarshalPrim a => a -> IO (ForeignPtr a) + toPlainForeignPtr = toPlainForeignPtr# + {-# INLINE toPlainForeignPtr #-} + -- | Make sure this data is alive at a given point in a sequence of IO actions. + touchVkData :: a -> IO () + default touchVkData :: VulkanMarshalPrim a => a -> IO () + touchVkData = touchVkData# + {-# INLINE touchVkData #-} + +-- | Run some operation with a pointer to vulkan structure. +-- +-- Should be used with care: +-- the structure pretends to be immutable, so it is better to only read +-- from the pointed memory area, not to write. +-- If an action needs to write something to the pointer, use `newVkData`. +withPtr :: VulkanMarshal a => a -> (Ptr a -> IO b) -> IO b +withPtr x k = do + b <- k (unsafePtr x) + touchVkData x + return b + +-- | Fill all bytes to zero getting data size from `Storable` instance. +clearStorable :: Storable a => Ptr a -> IO () +clearStorable p = fillBytes p 0 (sizeOf $ unptr p) + where + unptr :: Ptr b -> b + unptr ~_ = undefined + +-- | ===== @VK_DEFINE_NON_DISPATCHABLE_HANDLE@ +-- Non-dispatchable handles are represented as `VkPtr` +-- +-- Represented as `Word64` +-- +-- > +-- > #if !defined(VK_DEFINE_NON_DISPATCHABLE_HANDLE) +-- > #if defined(__LP64__) || defined(_WIN64) || (defined(__x86_64__) && !defined(__ILP32__) ) || defined(_M_X64) || defined(__ia64) || defined (_M_IA64) || defined(__aarch64__) || defined(__powerpc64__) +-- > #define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef struct object##_T *object; +-- > #else +-- > #define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef uint64_t object; +-- > #endif +-- > #endif +-- > +-- +newtype VkPtr a = VkPtr Word64 + deriving (Eq, Ord, Show, Storable, Generic, Data) +type role VkPtr phantom + + +-- | Unify dispatchable and non-dispatchable vulkan pointer types. +-- +-- Dispatchable handles are represented as `Ptr`. +-- +-- Non-dispatchable handles are represented as `VkPtr`. +-- +class VulkanPtr ptr where + vkNullPtr :: ptr a + +instance VulkanPtr Ptr where + vkNullPtr = nullPtr + {-# INLINE vkNullPtr #-} + +instance VulkanPtr VkPtr where + vkNullPtr = VkPtr 0 + {-# INLINE vkNullPtr #-} + +isNullPtr :: (Eq (ptr a), VulkanPtr ptr) => ptr a -> Bool +isNullPtr = (vkNullPtr ==) +{-# INLINE isNullPtr #-} + +-- | Null pointer (either dispatchable or non-dispatchable) +pattern VK_NULL :: (Eq (ptr a), VulkanPtr ptr) => ptr a +pattern VK_NULL <- (isNullPtr -> True) + where VK_NULL = vkNullPtr + +-- | > +-- > #define VK_NULL_HANDLE 0 +-- > +pattern VK_NULL_HANDLE :: (Eq (ptr a), VulkanPtr ptr) => ptr a +pattern VK_NULL_HANDLE = VK_NULL + +-- | Describe fields of a vulkan structure or union. +class HasField (fname :: Symbol) (a :: Type) where + -- | Type of a field in a vulkan structure or union. + type FieldType fname a :: Type + -- | Whether this field marked optional in vulkan specification. + -- Usually, this means that `VK_NULL` can be written in place + -- of this field. + type FieldOptional fname a :: Bool + -- | Offset of a field in bytes. + type FieldOffset fname a :: Nat + -- | Whether this field is a fixed-length array stored directly in a struct. + type FieldIsArray fname a :: Bool + -- | Whether this field marked optional in vulkan specification. + -- Usually, this means that `VK_NULL` can be written in place + -- of this field. + fieldOptional :: Bool + -- | Offset of a field in bytes. + fieldOffset :: Int + +class HasField fname a => CanReadField (fname :: Symbol) (a :: Type) where + getField :: a -> FieldType fname a + readField :: Ptr a -> IO (FieldType fname a) + +class CanReadField fname a => CanWriteField (fname :: Symbol) (a :: Type) where + writeField :: Ptr a -> FieldType fname a -> IO () + +class ( HasField fname a + , IndexInBounds fname idx a + , FieldIsArray fname a ~ 'True + ) => CanReadFieldArray (fname :: Symbol) (idx :: Nat) (a :: Type) where + -- | Length of an array that is a field of a structure or union + type FieldArrayLength fname a :: Nat + -- | Length of an array that is a field of a structure or union + fieldArrayLength :: Int + getFieldArray :: a -> FieldType fname a + readFieldArray :: Ptr a -> IO (FieldType fname a) + +class CanReadFieldArray fname idx a + => CanWriteFieldArray (fname :: Symbol) (idx :: Nat) (a :: Type) where + writeFieldArray :: Ptr a -> FieldType fname a -> IO () + +instance {-# OVERLAPPABLE #-} + TypeError (NoField fname a) => HasField fname a where +instance {-# OVERLAPPABLE #-} + TypeError (NoField fname a) => CanReadField fname a where +instance {-# OVERLAPPABLE #-} + TypeError (NoField fname a) => CanWriteField fname a where +instance {-# OVERLAPPABLE #-} + ( TypeError (NoField fname a) + , IndexInBounds fname idx a + , FieldIsArray fname a ~ 'True + ) => CanReadFieldArray fname idx a where +instance {-# OVERLAPPABLE #-} + ( TypeError (NoField fname a) + , IndexInBounds fname idx a + , FieldIsArray fname a ~ 'True + ) => CanWriteFieldArray fname idx a where + +type NoField (s :: Symbol) (a :: Type) = 'Text "Structure " ':<>: 'ShowType a + ':<>: 'Text " does not have field " ':<>: 'ShowType s ':<>: 'Text "." + ':$$: 'Text "Note, this structure has following fields: " + ':<>: 'ShowType (StructFields a) + +type IndexInBounds (s :: Symbol) (i :: Nat) (a :: Type) + = IndexInBounds' s i a (CmpNat i (FieldArrayLength s a)) + +type family IndexInBounds' (s :: Symbol) + (i :: Nat) + (a :: Type) (r :: Ordering) :: Constraint where + IndexInBounds' _ _ _ 'LT = () + IndexInBounds' s i a _ = TypeError + ( 'Text "Array index " ':<>: 'ShowType i + ':<>: 'Text " is out of bounds for '" + ':<>: 'Text s ':<>: 'Text "', member of type " + ':<>: 'ShowType a ':<>: 'Text "." + ':$$: 'Text "Note: the array size is " + ':<>: 'ShowType (FieldArrayLength s a) ':<>: 'Text "." + ) + +-- | Perform an action on a C string field. +-- The string pointers should not be used outside the callback. +-- It will point to a correct location only as long as the struct is alive. +withCStringField :: forall fname a b + . ( CanReadFieldArray fname 0 a + , FieldType fname a ~ CChar + , VulkanMarshal a + ) + => a -> (CString -> IO b) -> IO b +withCStringField x f = do + r <- f (unsafeCStringField @fname @a x) + touchVkData x + pure r + +-- | Get pointer to a memory location of the C string field in a structure. +unsafeCStringField :: forall fname a + . ( CanReadFieldArray fname 0 a + , FieldType fname a ~ CChar + , VulkanMarshal a + ) + => a -> CString +unsafeCStringField x = unsafePtr x `plusPtr` fieldOffset @fname @a + + +getStringField :: forall fname a + . ( CanReadFieldArray fname 0 a + , FieldType fname a ~ CChar + , VulkanMarshal a + ) + => a -> String +getStringField x + = case takeForce (fieldArrayLength @fname @0 @a) + . unsafeDupablePerformIO + $ withCStringField @fname @a x peekCString of + ((), s) -> s + +readStringField :: forall fname a + . ( CanReadFieldArray fname 0 a + , FieldType fname a ~ CChar + , VulkanMarshal a + ) + => Ptr a -> IO String +readStringField px = do + ((), s) <- takeForce (fieldArrayLength @fname @0 @a) + <$> peekCString (px `plusPtr` fieldOffset @fname @a) + return s + +writeStringField :: forall fname a + . ( CanWriteFieldArray fname 0 a + , FieldType fname a ~ CChar + , VulkanMarshal a + ) + => Ptr a -> String -> IO () +writeStringField px = + pokeArray0 '\0' (px `plusPtr` fieldOffset @fname @a) + +takeForce :: Int -> String -> ((), String) +takeForce 0 _ = ((), []) +takeForce _ [] = ((), []) +takeForce n (x:xs) = seq x $ (x:) <$> takeForce (n-1) xs + + +-- | Check first if two CString point to the same memory location. +-- Otherwise, compare them using C @strcmp@ function. +eqCStrings :: CString -> CString -> Bool +eqCStrings a b + | a == b = True + | c_strcmp a b == 0 = True + | otherwise = False + +-- | Check first if two CString point to the same memory location. +-- Otherwise, compare them using C @strncmp@ function. +-- It may be useful to provide maximum number of characters to compare. +eqCStringsN :: CString -> CString -> Int -> Bool +eqCStringsN a b n + | a == b = True + | c_strncmp a b (fromIntegral n) == 0 = True + | otherwise = False + + +foreign import ccall unsafe "strncmp" + c_strncmp :: CString -> CString -> CSize -> CInt + +foreign import ccall unsafe "strcmp" + c_strcmp :: CString -> CString -> CInt diff --git a/src/Graphics/Vulkan/Marshal/Create.hs b/src/Graphics/Vulkan/Marshal/Create.hs new file mode 100644 --- /dev/null +++ b/src/Graphics/Vulkan/Marshal/Create.hs @@ -0,0 +1,324 @@ +{-# LANGUAGE AllowAmbiguousTypes #-} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE ConstraintKinds #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleContexts #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE KindSignatures #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE PatternSynonyms #-} +{-# LANGUAGE RoleAnnotations #-} +{-# LANGUAGE ScopedTypeVariables #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE TypeApplications #-} +{-# LANGUAGE TypeFamilies #-} +{-# LANGUAGE TypeOperators #-} +{-# LANGUAGE UnboxedTuples #-} +{-# LANGUAGE UndecidableInstances #-} +-- | This module is not part of auto-generated code based on vk.xml. +-- It is also not included into `Graphics.Vulkan`. +-- It just provides convenient helpers for creation of vulkan structures. +module Graphics.Vulkan.Marshal.Create + ( CreateVkStruct () + , createVk, (&*) + , set, setAt, setVk, setVkRef, setStr, setStrRef, setStrListRef, setListRef + , SetOptionalFields (..), HandleRemainingFields (..), HandleRemFields + ) where + +import Data.Coerce +import Data.Kind (Constraint, Type) +import Data.Type.Bool (If) +import Foreign.C.String (newCString) +import Foreign.C.Types (CChar) +import Foreign.Marshal.Alloc (finalizerFree, free) +import Foreign.Marshal.Array (newArray, pokeArray0) +import Foreign.Ptr (plusPtr, nullPtr) +import Foreign.Storable (Storable) +import GHC.Base (IO (..)) +import GHC.Prim +import GHC.Ptr (FunPtr (..), Ptr (..)) +import GHC.TypeLits +import System.IO.Unsafe (unsafeDupablePerformIO) + +import Graphics.Vulkan.Marshal +import Graphics.Vulkan.Marshal.Internal + + +-- | Safely fill-in a new vulkan structure +newtype CreateVkStruct x (fs :: [Symbol]) a + = CreateVkStruct + { unCreateVkStruct + :: Ptr x -- Reference to memory containing the struct + -> IO ( ( [Ptr ()] + -- Pointers to data that was allocated with malloc or alike. + -- The memory is guaranteed to be freed by means of finalizerFree + -- at some point. + , [IO ()] + -- A list of functions that have a chance to run on finalization. + -- GHC sometimes does not run them, but they are still suitable + -- for touching GHC-managed memory to ensure an object exists + -- at least as long as the created structure. + ) + + , a) + } + +instance Functor (CreateVkStruct x fs) where + fmap f = CreateVkStruct . fmap (fmap $ fmap f) . unCreateVkStruct + +instance Applicative (CreateVkStruct x fs) where + pure = CreateVkStruct . const . pure . (,) ([],[]) + csf <*> csx = CreateVkStruct $ \ptr -> + g <$> unCreateVkStruct csf ptr <*> unCreateVkStruct csx ptr + where + g ((as1, as2), f) ((bs1, bs2), x) = ((as1 ++ bs1, as2 ++ bs2), f x) + +instance Monad (CreateVkStruct x fs) where + return = pure + csx >>= k = CreateVkStruct $ \ptr -> do + ((as1, as2), x) <- unCreateVkStruct csx ptr + ((bs1, bs2), y) <- unCreateVkStruct (k x) ptr + return ((as1 ++ bs1, as2 ++ bs2), y) + + +-- | Create a vulkan structure. +-- +-- Use smart creation functions like `setVk`, `setStrRef`, `setListRef`, etc +-- to keep GC aware of references between dependent structures. +-- +-- `createVk` produces at most one weak reference to a created structure +-- with a set of haskell and C finalizers. +-- These finalizers make sure all `malloc`ed memory is released and +-- no managed memory gets purged too early. +createVk :: ( VulkanMarshal x, VulkanMarshalPrim x + , HandleRemFields x fs + ) => CreateVkStruct x fs () -> x +createVk a = unsafeDupablePerformIO $ do + x <- mallocVkData + withPtr x $ \xptr -> do + ((cDeps, hFins), ()) <- unCreateVkStruct (a >> handleRemFields) xptr + IO $ \s0 -> case (# cDeps, hFins #) of + (# [], [] #) -> (# s0, () #) + (# _ , _ #) -> case mkW (unsafeByteArray x) hFins s0 of + (# s1, w #) -> let go [] s = (# s, () #) + go xxs@(Ptr c : xs) s = + case addCFinalizerToWeak# fp c 0# nullAddr# w s of + (# s' , 0# #) -> case mapM_ free xxs of + IO k -> k s' + (# s' , _ #) -> go xs s' + in go cDeps s1 + return x + where + !(FunPtr fp) = finalizerFree @() + mkW :: ByteArray# -> [IO ()] + -> State# RealWorld -> (# State# RealWorld, Weak# () #) + mkW ba [] = mkWeakNoFinalizer# ba () + mkW ba xs = case sequence_ xs of + IO k -> mkWeak# ba () k +{-# NOINLINE createVk #-} + +-- | `writeField` wrapped into `CreateVkStruct` monad. +set :: forall fname x + . ( CanWriteField fname x + ) + => FieldType fname x -> CreateVkStruct x '[fname] () +set v = CreateVkStruct $ \p -> (,) ([],[]) <$> writeField @fname @x p v + + +-- | `writeFieldArray` wrapped into `CreateVkStruct` monad. +setAt :: forall fname i x + . CanWriteFieldArray fname i x + => FieldType fname x -> CreateVkStruct x '[fname] () +setAt v = CreateVkStruct $ \p -> (,) ([],[]) <$> writeFieldArray @fname @i @x p v + +-- | Write fields of a member struct. +setVk :: forall fname x afs a + . ( CanWriteField fname x + , a ~ FieldType fname x + , VulkanMarshal a + , HandleRemFields a afs + ) + => CreateVkStruct a afs () + -> CreateVkStruct x '[fname] () +setVk ma = CreateVkStruct $ \p -> + unCreateVkStruct (ma >> handleRemFields) (plusPtr p (fieldOffset @fname @x)) + +-- | Write a String into a vulkan struct in-place. +setStr :: forall fname x + . ( CanWriteFieldArray fname 0 x + , FieldType fname x ~ CChar + ) + => String -> CreateVkStruct x '[fname] () +setStr v = CreateVkStruct $ \p -> + (,) ([],[]) <$> pokeArray0 '\0' (p `plusPtr` fieldOffset @fname @x) v + +-- | Allocate memory for a CString, store it, +-- and write a pointer to it into vulkan structure. +-- +-- This function also attaches a reliable finalizer to the vulkan struct, +-- so that the allocated memory is freed when the structure is GCed. +setStrRef :: forall fname x + . ( CanWriteField fname x + , FieldType fname x ~ CString + ) + => String -> CreateVkStruct x '[fname] () +setStrRef v = CreateVkStruct $ \p -> do + sPtr <- newCString v + (,) ([coerce sPtr],[]) <$> writeField @fname @x p sPtr + +-- | Allocate memory for an array of elements, store them, +-- and write a pointer to the array into vulkan structure. +-- +-- This function also attaches a reliable finalizer to the vulkan struct, +-- so that the array memory is freed when the structure is GCed. +-- +-- This function writes null pointer if used with an empty list. +setListRef :: forall fname x a + . ( CanWriteField fname x + , FieldType fname x ~ Ptr a + , Storable a + ) + => [a] -> CreateVkStruct x '[fname] () +setListRef [] = CreateVkStruct $ \p -> + (,) ([],[]) <$> writeField @fname @x p nullPtr +setListRef v = CreateVkStruct $ \p -> do + aPtr <- newArray v + (,) ([coerce aPtr],[]) <$> writeField @fname @x p aPtr + +-- | Allocate memory for an array of elements, store them, +-- and write a pointer to the array into vulkan structure. +-- +-- This function also attaches a reliable finalizer to the vulkan struct, +-- so that the array memory is freed when the structure is GCed. +-- +-- This function writes null pointer if used with an empty list. +setStrListRef :: forall fname x + . ( CanWriteField fname x + , FieldType fname x ~ Ptr CString + ) + => [String] -> CreateVkStruct x '[fname] () +setStrListRef [] = CreateVkStruct $ \p -> + (,) ([],[]) <$> writeField @fname @x p nullPtr +setStrListRef v = CreateVkStruct $ \p -> do + strptrs <- mapM newCString v + aPtr <- newArray strptrs + (,) (coerce aPtr : coerce strptrs,[]) <$> writeField @fname @x p aPtr + +-- | Write a pointer to a vulkan structure - member of current structure +-- and make sure the member exists as long as this structure exists. +-- +-- Prefer this function to using @unsafePtr a@, because the latter +-- does not keep the dependency information in GC, which results in +-- member structure being garbage-collected and the reference being invalid. +setVkRef :: forall fname x a + . ( CanWriteField fname x + , FieldType fname x ~ Ptr a + , VulkanMarshal a + ) + => a -> CreateVkStruct x '[fname] () +setVkRef v = CreateVkStruct $ \p -> + (,) ([],[touchVkData v]) <$> writeField @fname @x p (unsafePtr v) + +-- | Combine multiple field writes. +infixl 1 &* +(&*) :: CreateVkStruct x as () -> CreateVkStruct x bs () + -> CreateVkStruct x (Union x as bs) () +CreateVkStruct a &* CreateVkStruct b = CreateVkStruct a >> CreateVkStruct b + + + +type family Union (x :: Type) (as :: [Symbol]) (bs :: [Symbol]) :: [Symbol] where + Union _ as '[] = as + Union x '[] (b ': bs) = Union x '[b] bs + Union x (a ': as) (a ': bs) = If (FieldIsArray a x) + ( Union x as (a ': bs) ) + ( TypeError + ( 'Text "The same field " ':<>: 'ShowType x + ':<>: 'Text " should not be set twice." + ) + ) + Union x (a ': as) (b ': bs) = a ': Union x as (b ': bs) + +type family Difference (as :: [Symbol]) (bs :: [Symbol]) :: [Symbol] where + Difference '[] _ = '[] + Difference as '[] = as + Difference as (b ': bs) = Difference (Delete b as) bs + + +type family Delete (a :: Symbol) (as :: [Symbol]) :: [Symbol] where + Delete _ '[] = '[] + Delete a (a ': as) = as + Delete a (b ': bs) = b ': Delete a bs + + + +-- | Notify user if some required fields are missing. +type HandleRemFields x fs = HandleRemainingFields x fs (CUnionType x) + + +-- | Notify user if some required fields are missing and fill in optional fields. +class CUnionType x ~ isUnion + => HandleRemainingFields (x :: Type) (fs :: [Symbol]) (isUnion :: Bool) where + handleRemFields :: CreateVkStruct x fs () + + + +type SetUnionMsg x = + 'Text "You have to set exactly one field for a union type " ':<>: 'ShowType x + ':$$: 'Text "Note, this type has following fields: " + ':<>: 'ShowType (StructFields x) + +instance ( TypeError ( SetUnionMsg x ) + , CUnionType x ~ 'True + ) => HandleRemainingFields x '[] 'True where + handleRemFields = pure () + +instance CUnionType x ~ 'True => HandleRemainingFields x '[f] 'True where + handleRemFields = pure () + +instance ( TypeError ( SetUnionMsg x ) + , CUnionType x ~ 'True + ) => HandleRemainingFields x (a ': b ': fs) 'True where + handleRemFields = pure () + + +instance ( SetOptionalFields x (Difference (StructFields x) fs) + , CUnionType x ~ 'False + ) => HandleRemainingFields x fs 'False where + handleRemFields + = ( coerce :: CreateVkStruct x (Difference (StructFields x) fs) () + -> CreateVkStruct x fs () + ) setOptionalFields + + + + +class SetOptionalFields (x :: Type) (fs :: [Symbol]) where + setOptionalFields :: CreateVkStruct x fs () + +instance SetOptionalFields x '[] where + setOptionalFields = pure () + +instance ( SetOptionalFields x fs + , FieldMustBeOptional f x + , Storable (FieldType f x) + , HasField f x + ) => SetOptionalFields x (f ': fs) where + setOptionalFields = coerce $ x >> setOptionalFields + where + x :: CreateVkStruct x fs () + x = CreateVkStruct $ + \ptr -> (,) ([],[]) <$> + clearStorable ( plusPtr ptr (fieldOffset @f @x) + :: Ptr (FieldType f x) + ) + +type family FieldMustBeOptional (f :: Symbol) (x :: Type) :: Constraint where + FieldMustBeOptional f x = If (FieldOptional f x) (() :: Constraint) + ( TypeError + ( 'Text "Non-optional field " ':<>: 'ShowType f + ':<>: 'Text " of structure " ':<>: 'ShowType x + ':<>: 'Text " is not set." + ) + ) diff --git a/src/Graphics/Vulkan/Marshal/Internal.hs b/src/Graphics/Vulkan/Marshal/Internal.hs new file mode 100644 --- /dev/null +++ b/src/Graphics/Vulkan/Marshal/Internal.hs @@ -0,0 +1,204 @@ +{-# LANGUAGE ExistentialQuantification #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE ScopedTypeVariables #-} +{-# LANGUAGE Strict #-} +{-# LANGUAGE UnboxedTuples #-} +{-# LANGUAGE UnliftedFFITypes #-} +-- | This module is not part of auto-generated code based on vk.xml. +-- Instead, it is hand-written to provide common types and classes. +-- +-- DANGER! +-- This is an internal module; it can change a lot between package versions; +-- it provides low-level functions, most of which have user-friendly analogues. +module Graphics.Vulkan.Marshal.Internal + ( VulkanMarshalPrim (..) + , fromForeignPtr# + , toForeignPtr#, toPlainForeignPtr# + , touchVkData# + , cmpBytes# + , newVkData# + , mallocVkData#, mallocVkDataArray# + , peekVkData#, pokeVkData# + ) where + +import Foreign.C.Types (CInt (..), CSize (..)) +import Foreign.ForeignPtr (ForeignPtr, newForeignPtr_) +import Foreign.Storable (Storable (..)) +import GHC.Base (isTrue#) +import GHC.Prim +import GHC.Ptr (Ptr (..)) +import GHC.Types (IO (..), Int (..)) + +import GHC.ForeignPtr (ForeignPtr (..), ForeignPtrContents (..)) + + +-- | This class gives low-level access to memory location occupied by Vulkan data. +-- +-- Meant for internal use only. +class VulkanMarshalPrim a where + -- | Get address of vulkan structure. + -- Note, the address is only valid as long as a given vulkan structure exists. + -- Structures created with newVkData are stored in pinned byte arrays, + -- so their memory is maintained by Haskell GC. + unsafeAddr :: a -> Addr# + -- | Get a @ByteArray#@ that keeps the data. + -- + -- Note, the data structure does not necessarily starts at zero offset. + unsafeByteArray :: a -> ByteArray# + -- | Combine a vulkan structure from ByteArray and an offset in this array. + unsafeFromByteArrayOffset :: Int# -> ByteArray# -> a + + + + +-- | Create a `ByteArray#`-based type from `ForeignPtr`. +-- Try to not copy data, but do it if necessary. +fromForeignPtr# :: forall a . (Storable a, VulkanMarshalPrim a) + => ForeignPtr a -> IO a +fromForeignPtr# (ForeignPtr addr PlainForeignPtr{}) + | I# n <- sizeOf (undefined :: a) + , I# a <- alignment (undefined :: a) + = IO + (\s0 -> case newAlignedPinnedByteArray# n a s0 of + (# s1, mba #) -> case copyAddrToByteArray# addr mba 0# n s1 of + s2 -> case unsafeFreezeByteArray# mba s2 of + (# s3, ba #) -> (# s3, unsafeFromByteArrayOffset 0# ba #) + ) +fromForeignPtr# (ForeignPtr addr (MallocPtr mba _)) + = IO + (\s0 -> case unsafeFreezeByteArray# mba s0 of + (# s1, ba #) -> (# s1, unsafeFromByteArrayOffset + (minusAddr# addr (byteArrayContents# ba)) ba #) + ) +fromForeignPtr# (ForeignPtr addr (PlainPtr mba)) + = IO + (\s0 -> case unsafeFreezeByteArray# mba s0 of + (# s1, ba #) -> (# s1, unsafeFromByteArrayOffset + (minusAddr# addr (byteArrayContents# ba)) ba #) + ) +{-# INLINE fromForeignPtr# #-} + + +-- | Create a `ForeignPtr` referencing the structure without copying data. +toForeignPtr# :: VulkanMarshalPrim a => a -> IO (ForeignPtr a) +toForeignPtr# x + | a <- unsafeAddr x + , b <- unsafeByteArray x = do + ForeignPtr _ (PlainForeignPtr r) + <- newForeignPtr_ (Ptr a) + IO (\s -> (# s, ForeignPtr a (MallocPtr (unsafeCoerce# b) r) #)) +{-# INLINE toForeignPtr# #-} + +-- | Create a `ForeignPtr` referencing the structure without copying data. +-- This version of a pointer carries no finalizers. +-- +-- It is not possible to add a finalizer to a ForeignPtr created with +-- @toPlainForeignPtr@. +-- Attempts to add a finalizer to a ForeignPtr created this way, or to +-- finalize such a pointer, will throw an exception. +toPlainForeignPtr# :: VulkanMarshalPrim a => a -> IO (ForeignPtr a) +toPlainForeignPtr# x + | a <- unsafeAddr x + , b <- unsafeByteArray x = IO + (\s -> (# s, ForeignPtr a (PlainPtr (unsafeCoerce# b)) #)) +{-# INLINE toPlainForeignPtr# #-} + +-- | Make sure the region of memory is not collected at this moment in time. +touchVkData# :: VulkanMarshalPrim a => a -> IO () +touchVkData# a = IO (\s -> (# touch# (unsafeByteArray a) s, () #)) +{-# INLINE touchVkData# #-} + + +newVkData# :: forall a + . (Storable a, VulkanMarshalPrim a) + => (Ptr a -> IO ()) -> IO a +newVkData# f + | I# n <- sizeOf (undefined :: a) + , I# a <- alignment (undefined :: a) + = IO + (\s0 -> case newAlignedPinnedByteArray# n a s0 of + (# s1, mba #) -> case unsafeFreezeByteArray# mba s1 of + (# s2, ba #) -> case f (Ptr (byteArrayContents# ba)) of + IO k -> case k s2 of + (# s3, () #) -> (# s3, unsafeFromByteArrayOffset 0# ba #) + ) +{-# INLINE newVkData# #-} + +mallocVkData# :: forall a + . (Storable a, VulkanMarshalPrim a) + => IO a +mallocVkData# + | I# n <- sizeOf (undefined :: a) + , I# a <- alignment (undefined :: a) + = IO + (\s0 -> case newAlignedPinnedByteArray# n a s0 of + (# s1, mba #) -> case unsafeFreezeByteArray# mba s1 of + (# s2, ba #) -> (# s2, unsafeFromByteArrayOffset 0# ba #) + ) +{-# INLINE mallocVkData# #-} + +mallocVkDataArray# :: forall a + . (Storable a, VulkanMarshalPrim a) + => Int -> IO (Ptr a, [a]) +mallocVkDataArray# (I# m) + | I# n <- sizeOf (undefined :: a) + , I# a <- alignment (undefined :: a) + , nm <- n *# m + = IO + (\s0 -> case newAlignedPinnedByteArray# nm a s0 of + (# s1, mba #) -> case unsafeFreezeByteArray# mba s1 of + (# s2, ba #) -> + (# s2 + , ( Ptr (byteArrayContents# ba) + , let go k | isTrue# (k >=# nm) = [] + | otherwise = unsafeFromByteArrayOffset k ba + : go (k +# n) + in go 0# + ) + #) + ) +{-# INLINE mallocVkDataArray# #-} + + +peekVkData# :: forall a + . (Storable a, VulkanMarshalPrim a) + => Ptr a -> IO a +peekVkData# (Ptr addr) + | I# n <- sizeOf (undefined :: a) + , I# a <- alignment (undefined :: a) + = IO + (\s -> case newAlignedPinnedByteArray# n a s of + (# s1, mba #) -> case copyAddrToByteArray# addr mba 0# n s1 of + s2 -> case unsafeFreezeByteArray# mba s2 of + (# s3, ba #) -> (# s3, unsafeFromByteArrayOffset 0# ba #) + ) +{-# INLINE peekVkData# #-} + +pokeVkData# :: forall a + . (Storable a, VulkanMarshalPrim a) + => Ptr a -> a -> IO () +pokeVkData# (Ptr addr) x + = c_memcpy addr (unsafeAddr x) (fromIntegral $ sizeOf x) +{-# INLINE pokeVkData# #-} + + +-- | Internal function used to implement Eq and Ord instances for Vulkan structs. +-- Compares first n bytes of two memory areas. +-- +-- Uses lexicographic ordering (c memcmp inside). +-- +-- This is a helper that should be used in VulkanMarshal instances only. +cmpBytes# :: Int -> Addr# -> Addr# -> Ordering +cmpBytes# n a b + | isTrue# (eqAddr# a b) = EQ + | otherwise = case c_memcmp a b (fromIntegral n) of + r | r > 0 -> GT + | r < 0 -> LT + | otherwise -> EQ + +foreign import ccall unsafe "memcmp" + c_memcmp :: Addr# -> Addr# -> CSize -> CInt + + +foreign import ccall unsafe "memcpy" + c_memcpy :: Addr# -> Addr# -> CSize -> IO () diff --git a/vulkan-api.cabal b/vulkan-api.cabal new file mode 100644 --- /dev/null +++ b/vulkan-api.cabal @@ -0,0 +1,674 @@ +-- +-- Do not modify this file directly +-- it is autogenerated at genvulkan/src/Write/Cabal.hs +-- +name: vulkan-api +version: 0.1.0.0 +synopsis: Low-level low-overhead vulkan api bindings +description: Haskell bindings for vulkan api as described in vk.xml. +homepage: https://github.com/achirkin/genvulkan#readme +license: BSD3 +license-file: LICENSE +author: Artem Chirkin +maintainer: chirkin@arch.ethz.ch +copyright: Copyright: (c) 2018 Artem Chirkin +category: vulkan, bsd3, graphics, library, opengl +build-type: Simple +cabal-version: >=1.22 +extra-source-files: include/vulkan/vulkan.h + +flag usePlatformAndroidKhr + description: + Enable platform-specific extensions protected by CPP macros VK_USE_PLATFORM_ANDROID_KHR + default: False + +flag usePlatformIosMvk + description: + Enable platform-specific extensions protected by CPP macros VK_USE_PLATFORM_IOS_MVK + default: False + +flag usePlatformMacosMvk + description: + Enable platform-specific extensions protected by CPP macros VK_USE_PLATFORM_MACOS_MVK + default: False + +flag usePlatformMirKhr + description: + Enable platform-specific extensions protected by CPP macros VK_USE_PLATFORM_MIR_KHR + default: False + +flag usePlatformViNn + description: + Enable platform-specific extensions protected by CPP macros VK_USE_PLATFORM_VI_NN + default: False + +flag usePlatformWaylandKhr + description: + Enable platform-specific extensions protected by CPP macros VK_USE_PLATFORM_WAYLAND_KHR + default: False + +flag usePlatformWin32Khr + description: + Enable platform-specific extensions protected by CPP macros VK_USE_PLATFORM_WIN32_KHR + default: False + +flag usePlatformXcbKhr + description: + Enable platform-specific extensions protected by CPP macros VK_USE_PLATFORM_XCB_KHR + default: False + +flag usePlatformXlibKhr + description: + Enable platform-specific extensions protected by CPP macros VK_USE_PLATFORM_XLIB_KHR + default: False + +flag usePlatformXlibXrandrExt + description: + Enable platform-specific extensions protected by CPP macros VK_USE_PLATFORM_XLIB_XRANDR_EXT + default: False + +library + hs-source-dirs: src, src-gen + exposed-modules: + + Graphics.Vulkan + Graphics.Vulkan.Constants + Graphics.Vulkan.Core + Graphics.Vulkan.Ext + Graphics.Vulkan.Ext.VK_AMD_buffer_marker + Graphics.Vulkan.Ext.VK_AMD_draw_indirect_count + Graphics.Vulkan.Ext.VK_AMD_gcn_shader + Graphics.Vulkan.Ext.VK_AMD_gpu_shader_half_float + Graphics.Vulkan.Ext.VK_AMD_gpu_shader_int16 + Graphics.Vulkan.Ext.VK_AMD_mixed_attachment_samples + Graphics.Vulkan.Ext.VK_AMD_negative_viewport_height + Graphics.Vulkan.Ext.VK_AMD_rasterization_order + Graphics.Vulkan.Ext.VK_AMD_shader_ballot + Graphics.Vulkan.Ext.VK_AMD_shader_explicit_vertex_parameter + Graphics.Vulkan.Ext.VK_AMD_shader_fragment_mask + Graphics.Vulkan.Ext.VK_AMD_shader_image_load_store_lod + Graphics.Vulkan.Ext.VK_AMD_shader_info + Graphics.Vulkan.Ext.VK_AMD_shader_trinary_minmax + Graphics.Vulkan.Ext.VK_AMD_texture_gather_bias_lod + Graphics.Vulkan.Ext.VK_EXT_blend_operation_advanced + Graphics.Vulkan.Ext.VK_EXT_conservative_rasterization + Graphics.Vulkan.Ext.VK_EXT_debug_marker + Graphics.Vulkan.Ext.VK_EXT_debug_report + Graphics.Vulkan.Ext.VK_EXT_depth_range_unrestricted + Graphics.Vulkan.Ext.VK_EXT_direct_mode_display + Graphics.Vulkan.Ext.VK_EXT_discard_rectangles + Graphics.Vulkan.Ext.VK_EXT_display_control + Graphics.Vulkan.Ext.VK_EXT_display_surface_counter + Graphics.Vulkan.Ext.VK_EXT_external_memory_dma_buf + Graphics.Vulkan.Ext.VK_EXT_external_memory_host + Graphics.Vulkan.Ext.VK_EXT_global_priority + Graphics.Vulkan.Ext.VK_EXT_hdr_metadata + Graphics.Vulkan.Ext.VK_EXT_post_depth_coverage + Graphics.Vulkan.Ext.VK_EXT_queue_family_foreign + Graphics.Vulkan.Ext.VK_EXT_sample_locations + Graphics.Vulkan.Ext.VK_EXT_sampler_filter_minmax + Graphics.Vulkan.Ext.VK_EXT_shader_stencil_export + Graphics.Vulkan.Ext.VK_EXT_shader_subgroup_ballot + Graphics.Vulkan.Ext.VK_EXT_shader_subgroup_vote + Graphics.Vulkan.Ext.VK_EXT_shader_viewport_index_layer + Graphics.Vulkan.Ext.VK_EXT_swapchain_colorspace + Graphics.Vulkan.Ext.VK_EXT_validation_cache + Graphics.Vulkan.Ext.VK_EXT_validation_flags + Graphics.Vulkan.Ext.VK_GOOGLE_display_timing + Graphics.Vulkan.Ext.VK_IMG_filter_cubic + Graphics.Vulkan.Ext.VK_IMG_format_pvrtc + Graphics.Vulkan.Ext.VK_KHR_16bit_storage + Graphics.Vulkan.Ext.VK_KHR_bind_memory2 + Graphics.Vulkan.Ext.VK_KHR_dedicated_allocation + Graphics.Vulkan.Ext.VK_KHR_descriptor_update_template + Graphics.Vulkan.Ext.VK_KHR_display + Graphics.Vulkan.Ext.VK_KHR_display_swapchain + Graphics.Vulkan.Ext.VK_KHR_external_fence + Graphics.Vulkan.Ext.VK_KHR_external_fence_capabilities + Graphics.Vulkan.Ext.VK_KHR_external_fence_fd + Graphics.Vulkan.Ext.VK_KHR_external_memory + Graphics.Vulkan.Ext.VK_KHR_external_memory_capabilities + Graphics.Vulkan.Ext.VK_KHR_external_memory_fd + Graphics.Vulkan.Ext.VK_KHR_external_semaphore + Graphics.Vulkan.Ext.VK_KHR_external_semaphore_capabilities + Graphics.Vulkan.Ext.VK_KHR_external_semaphore_fd + Graphics.Vulkan.Ext.VK_KHR_get_memory_requirements2 + Graphics.Vulkan.Ext.VK_KHR_get_physical_device_properties2 + Graphics.Vulkan.Ext.VK_KHR_get_surface_capabilities2 + Graphics.Vulkan.Ext.VK_KHR_image_format_list + Graphics.Vulkan.Ext.VK_KHR_incremental_present + Graphics.Vulkan.Ext.VK_KHR_maintenance1 + Graphics.Vulkan.Ext.VK_KHR_maintenance2 + Graphics.Vulkan.Ext.VK_KHR_push_descriptor + Graphics.Vulkan.Ext.VK_KHR_relaxed_block_layout + Graphics.Vulkan.Ext.VK_KHR_sampler_mirror_clamp_to_edge + Graphics.Vulkan.Ext.VK_KHR_sampler_ycbcr_conversion + Graphics.Vulkan.Ext.VK_KHR_shader_draw_parameters + Graphics.Vulkan.Ext.VK_KHR_shared_presentable_image + Graphics.Vulkan.Ext.VK_KHR_storage_buffer_storage_class + Graphics.Vulkan.Ext.VK_KHR_surface + Graphics.Vulkan.Ext.VK_KHR_swapchain + Graphics.Vulkan.Ext.VK_KHR_variable_pointers + Graphics.Vulkan.Ext.VK_KHX_device_group + Graphics.Vulkan.Ext.VK_KHX_device_group_creation + Graphics.Vulkan.Ext.VK_KHX_multiview + Graphics.Vulkan.Ext.VK_NVX_device_generated_commands + Graphics.Vulkan.Ext.VK_NVX_multiview_per_view_attributes + Graphics.Vulkan.Ext.VK_NV_clip_space_w_scaling + Graphics.Vulkan.Ext.VK_NV_dedicated_allocation + Graphics.Vulkan.Ext.VK_NV_external_memory + Graphics.Vulkan.Ext.VK_NV_external_memory_capabilities + Graphics.Vulkan.Ext.VK_NV_fill_rectangle + Graphics.Vulkan.Ext.VK_NV_fragment_coverage_to_color + Graphics.Vulkan.Ext.VK_NV_framebuffer_mixed_samples + Graphics.Vulkan.Ext.VK_NV_geometry_shader_passthrough + Graphics.Vulkan.Ext.VK_NV_glsl_shader + Graphics.Vulkan.Ext.VK_NV_sample_mask_override_coverage + Graphics.Vulkan.Ext.VK_NV_viewport_array2 + Graphics.Vulkan.Ext.VK_NV_viewport_swizzle + Graphics.Vulkan.Marshal + Graphics.Vulkan.Marshal.Create + Graphics.Vulkan.Marshal.Internal + Graphics.Vulkan.Types.BaseTypes + Graphics.Vulkan.Types.Bitmasks + Graphics.Vulkan.Types.Defines + Graphics.Vulkan.Types.Enum.VkAccessFlags + Graphics.Vulkan.Types.Enum.VkAttachmentDescriptionFlags + Graphics.Vulkan.Types.Enum.VkAttachmentLoadOp + Graphics.Vulkan.Types.Enum.VkAttachmentStoreOp + Graphics.Vulkan.Types.Enum.VkBlendFactor + Graphics.Vulkan.Types.Enum.VkBlendOp + Graphics.Vulkan.Types.Enum.VkBlendOverlapEXT + Graphics.Vulkan.Types.Enum.VkBorderColor + Graphics.Vulkan.Types.Enum.VkBufferCreateFlags + Graphics.Vulkan.Types.Enum.VkBufferUsageFlags + Graphics.Vulkan.Types.Enum.VkBufferViewCreateFlagBits + Graphics.Vulkan.Types.Enum.VkChromaLocationKHR + Graphics.Vulkan.Types.Enum.VkColorComponentFlags + Graphics.Vulkan.Types.Enum.VkColorSpaceKHR + Graphics.Vulkan.Types.Enum.VkCommandBufferLevel + Graphics.Vulkan.Types.Enum.VkCommandBufferResetFlags + Graphics.Vulkan.Types.Enum.VkCommandBufferUsageFlags + Graphics.Vulkan.Types.Enum.VkCommandPoolCreateFlags + Graphics.Vulkan.Types.Enum.VkCommandPoolResetFlags + Graphics.Vulkan.Types.Enum.VkCompareOp + Graphics.Vulkan.Types.Enum.VkComponentSwizzle + Graphics.Vulkan.Types.Enum.VkCompositeAlphaFlagsKHR + Graphics.Vulkan.Types.Enum.VkConservativeRasterizationModeEXT + Graphics.Vulkan.Types.Enum.VkCoverageModulationModeNV + Graphics.Vulkan.Types.Enum.VkCullModeFlags + Graphics.Vulkan.Types.Enum.VkDebugReportFlagsEXT + Graphics.Vulkan.Types.Enum.VkDebugReportObjectTypeEXT + Graphics.Vulkan.Types.Enum.VkDependencyFlags + Graphics.Vulkan.Types.Enum.VkDescriptorPoolCreateFlags + Graphics.Vulkan.Types.Enum.VkDescriptorSetLayoutCreateFlags + Graphics.Vulkan.Types.Enum.VkDescriptorType + Graphics.Vulkan.Types.Enum.VkDescriptorUpdateTemplateTypeKHR + Graphics.Vulkan.Types.Enum.VkDeviceCreateFlagBits + Graphics.Vulkan.Types.Enum.VkDeviceEventTypeEXT + Graphics.Vulkan.Types.Enum.VkDeviceGroupPresentModeFlagsKHX + Graphics.Vulkan.Types.Enum.VkDeviceQueueCreateFlagBits + Graphics.Vulkan.Types.Enum.VkDiscardRectangleModeEXT + Graphics.Vulkan.Types.Enum.VkDisplayEventTypeEXT + Graphics.Vulkan.Types.Enum.VkDisplayPlaneAlphaFlagsKHR + Graphics.Vulkan.Types.Enum.VkDisplayPowerStateEXT + Graphics.Vulkan.Types.Enum.VkDynamicState + Graphics.Vulkan.Types.Enum.VkExternalFenceFeatureFlagsKHR + Graphics.Vulkan.Types.Enum.VkExternalFenceHandleTypeFlagsKHR + Graphics.Vulkan.Types.Enum.VkExternalMemoryFeatureFlagsKHR + Graphics.Vulkan.Types.Enum.VkExternalMemoryFeatureFlagsNV + Graphics.Vulkan.Types.Enum.VkExternalMemoryHandleTypeFlagsKHR + Graphics.Vulkan.Types.Enum.VkExternalMemoryHandleTypeFlagsNV + Graphics.Vulkan.Types.Enum.VkExternalSemaphoreFeatureFlagsKHR + Graphics.Vulkan.Types.Enum.VkExternalSemaphoreHandleTypeFlagsKHR + Graphics.Vulkan.Types.Enum.VkFenceCreateFlags + Graphics.Vulkan.Types.Enum.VkFenceImportFlagsKHR + Graphics.Vulkan.Types.Enum.VkFilter + Graphics.Vulkan.Types.Enum.VkFormat + Graphics.Vulkan.Types.Enum.VkFormatFeatureFlags + Graphics.Vulkan.Types.Enum.VkFramebufferCreateFlagBits + Graphics.Vulkan.Types.Enum.VkFrontFace + Graphics.Vulkan.Types.Enum.VkImageAspectFlags + Graphics.Vulkan.Types.Enum.VkImageCreateFlags + Graphics.Vulkan.Types.Enum.VkImageLayout + Graphics.Vulkan.Types.Enum.VkImageTiling + Graphics.Vulkan.Types.Enum.VkImageType + Graphics.Vulkan.Types.Enum.VkImageUsageFlags + Graphics.Vulkan.Types.Enum.VkImageViewType + Graphics.Vulkan.Types.Enum.VkIndexType + Graphics.Vulkan.Types.Enum.VkIndirectCommandsLayoutUsageFlagsNVX + Graphics.Vulkan.Types.Enum.VkIndirectCommandsTokenTypeNVX + Graphics.Vulkan.Types.Enum.VkInstanceCreateFlagBits + Graphics.Vulkan.Types.Enum.VkInternalAllocationType + Graphics.Vulkan.Types.Enum.VkLogicOp + Graphics.Vulkan.Types.Enum.VkMemoryAllocateFlagsKHX + Graphics.Vulkan.Types.Enum.VkMemoryHeapFlags + Graphics.Vulkan.Types.Enum.VkMemoryPropertyFlags + Graphics.Vulkan.Types.Enum.VkObjectEntryTypeNVX + Graphics.Vulkan.Types.Enum.VkObjectEntryUsageFlagsNVX + Graphics.Vulkan.Types.Enum.VkObjectType + Graphics.Vulkan.Types.Enum.VkPeerMemoryFeatureFlagsKHX + Graphics.Vulkan.Types.Enum.VkPhysicalDeviceType + Graphics.Vulkan.Types.Enum.VkPipelineBindPoint + Graphics.Vulkan.Types.Enum.VkPipelineCacheCreateFlagBits + Graphics.Vulkan.Types.Enum.VkPipelineCacheHeaderVersion + Graphics.Vulkan.Types.Enum.VkPipelineColorBlendStateCreateFlagBits + Graphics.Vulkan.Types.Enum.VkPipelineCreateFlags + Graphics.Vulkan.Types.Enum.VkPipelineDepthStencilStateCreateFlagBits + Graphics.Vulkan.Types.Enum.VkPipelineDynamicStateCreateFlagBits + Graphics.Vulkan.Types.Enum.VkPipelineInputAssemblyStateCreateFlagBits + Graphics.Vulkan.Types.Enum.VkPipelineLayoutCreateFlagBits + Graphics.Vulkan.Types.Enum.VkPipelineMultisampleStateCreateFlagBits + Graphics.Vulkan.Types.Enum.VkPipelineRasterizationStateCreateFlagBits + Graphics.Vulkan.Types.Enum.VkPipelineShaderStageCreateFlagBits + Graphics.Vulkan.Types.Enum.VkPipelineStageFlags + Graphics.Vulkan.Types.Enum.VkPipelineTessellationStateCreateFlagBits + Graphics.Vulkan.Types.Enum.VkPipelineVertexInputStateCreateFlagBits + Graphics.Vulkan.Types.Enum.VkPipelineViewportStateCreateFlagBits + Graphics.Vulkan.Types.Enum.VkPointClippingBehaviorKHR + Graphics.Vulkan.Types.Enum.VkPolygonMode + Graphics.Vulkan.Types.Enum.VkPresentModeKHR + Graphics.Vulkan.Types.Enum.VkPrimitiveTopology + Graphics.Vulkan.Types.Enum.VkQueryControlFlags + Graphics.Vulkan.Types.Enum.VkQueryPipelineStatisticFlags + Graphics.Vulkan.Types.Enum.VkQueryPoolCreateFlagBits + Graphics.Vulkan.Types.Enum.VkQueryResultFlags + Graphics.Vulkan.Types.Enum.VkQueryType + Graphics.Vulkan.Types.Enum.VkQueueFlags + Graphics.Vulkan.Types.Enum.VkQueueGlobalPriorityEXT + Graphics.Vulkan.Types.Enum.VkRasterizationOrderAMD + Graphics.Vulkan.Types.Enum.VkRenderPassCreateFlagBits + Graphics.Vulkan.Types.Enum.VkResult + Graphics.Vulkan.Types.Enum.VkSampleCountFlags + Graphics.Vulkan.Types.Enum.VkSamplerAddressMode + Graphics.Vulkan.Types.Enum.VkSamplerCreateFlagBits + Graphics.Vulkan.Types.Enum.VkSamplerMipmapMode + Graphics.Vulkan.Types.Enum.VkSamplerReductionModeEXT + Graphics.Vulkan.Types.Enum.VkSamplerYcbcrModelConversionKHR + Graphics.Vulkan.Types.Enum.VkSamplerYcbcrRangeKHR + Graphics.Vulkan.Types.Enum.VkSemaphoreImportFlagsKHR + Graphics.Vulkan.Types.Enum.VkShaderInfoTypeAMD + Graphics.Vulkan.Types.Enum.VkShaderStageFlags + Graphics.Vulkan.Types.Enum.VkSharingMode + Graphics.Vulkan.Types.Enum.VkSparseImageFormatFlags + Graphics.Vulkan.Types.Enum.VkSparseMemoryBindFlags + Graphics.Vulkan.Types.Enum.VkStencilFaceFlags + Graphics.Vulkan.Types.Enum.VkStencilOp + Graphics.Vulkan.Types.Enum.VkStructureType + Graphics.Vulkan.Types.Enum.VkSubpassContents + Graphics.Vulkan.Types.Enum.VkSubpassDescriptionFlags + Graphics.Vulkan.Types.Enum.VkSurfaceCounterFlagsEXT + Graphics.Vulkan.Types.Enum.VkSurfaceTransformFlagsKHR + Graphics.Vulkan.Types.Enum.VkSwapchainCreateFlagsKHR + Graphics.Vulkan.Types.Enum.VkSystemAllocationScope + Graphics.Vulkan.Types.Enum.VkTessellationDomainOriginKHR + Graphics.Vulkan.Types.Enum.VkValidationCacheHeaderVersionEXT + Graphics.Vulkan.Types.Enum.VkValidationCheckEXT + Graphics.Vulkan.Types.Enum.VkVertexInputRate + Graphics.Vulkan.Types.Enum.VkViewportCoordinateSwizzleNV + Graphics.Vulkan.Types.Funcpointers + Graphics.Vulkan.Types.Handles + Graphics.Vulkan.Types.Include + Graphics.Vulkan.Types.Struct.VkAcquireNextImageInfoKHX + Graphics.Vulkan.Types.Struct.VkAllocationCallbacks + Graphics.Vulkan.Types.Struct.VkApplicationInfo + Graphics.Vulkan.Types.Struct.VkAttachmentDescription + Graphics.Vulkan.Types.Struct.VkAttachmentReference + Graphics.Vulkan.Types.Struct.VkAttachmentSampleLocationsEXT + Graphics.Vulkan.Types.Struct.VkBindBufferMemoryDeviceGroupInfoKHX + Graphics.Vulkan.Types.Struct.VkBindBufferMemoryInfoKHR + Graphics.Vulkan.Types.Struct.VkBindImageMemoryDeviceGroupInfoKHX + Graphics.Vulkan.Types.Struct.VkBindImageMemoryInfoKHR + Graphics.Vulkan.Types.Struct.VkBindImageMemorySwapchainInfoKHX + Graphics.Vulkan.Types.Struct.VkBindImagePlaneMemoryInfoKHR + Graphics.Vulkan.Types.Struct.VkBindSparseInfo + Graphics.Vulkan.Types.Struct.VkBufferCopy + Graphics.Vulkan.Types.Struct.VkBufferCreateInfo + Graphics.Vulkan.Types.Struct.VkBufferImageCopy + Graphics.Vulkan.Types.Struct.VkBufferMemoryBarrier + Graphics.Vulkan.Types.Struct.VkBufferMemoryRequirementsInfo2KHR + Graphics.Vulkan.Types.Struct.VkBufferViewCreateInfo + Graphics.Vulkan.Types.Struct.VkClearAttachment + Graphics.Vulkan.Types.Struct.VkClearColorValue + Graphics.Vulkan.Types.Struct.VkClearDepthStencilValue + Graphics.Vulkan.Types.Struct.VkClearRect + Graphics.Vulkan.Types.Struct.VkClearValue + Graphics.Vulkan.Types.Struct.VkCmdProcessCommandsInfoNVX + Graphics.Vulkan.Types.Struct.VkCmdReserveSpaceForCommandsInfoNVX + Graphics.Vulkan.Types.Struct.VkCommandBufferAllocateInfo + Graphics.Vulkan.Types.Struct.VkCommandBufferBeginInfo + Graphics.Vulkan.Types.Struct.VkCommandBufferInheritanceInfo + Graphics.Vulkan.Types.Struct.VkCommandPoolCreateInfo + Graphics.Vulkan.Types.Struct.VkComponentMapping + Graphics.Vulkan.Types.Struct.VkComputePipelineCreateInfo + Graphics.Vulkan.Types.Struct.VkCopyDescriptorSet + Graphics.Vulkan.Types.Struct.VkDebugMarkerMarkerInfoEXT + Graphics.Vulkan.Types.Struct.VkDebugMarkerObjectNameInfoEXT + Graphics.Vulkan.Types.Struct.VkDebugMarkerObjectTagInfoEXT + Graphics.Vulkan.Types.Struct.VkDebugReportCallbackCreateInfoEXT + Graphics.Vulkan.Types.Struct.VkDedicatedAllocationBufferCreateInfoNV + Graphics.Vulkan.Types.Struct.VkDedicatedAllocationImageCreateInfoNV + Graphics.Vulkan.Types.Struct.VkDedicatedAllocationMemoryAllocateInfoNV + Graphics.Vulkan.Types.Struct.VkDescriptorBufferInfo + Graphics.Vulkan.Types.Struct.VkDescriptorImageInfo + Graphics.Vulkan.Types.Struct.VkDescriptorPoolCreateInfo + Graphics.Vulkan.Types.Struct.VkDescriptorPoolSize + Graphics.Vulkan.Types.Struct.VkDescriptorSetAllocateInfo + Graphics.Vulkan.Types.Struct.VkDescriptorSetLayoutBinding + Graphics.Vulkan.Types.Struct.VkDescriptorSetLayoutCreateInfo + Graphics.Vulkan.Types.Struct.VkDescriptorUpdateTemplateCreateInfoKHR + Graphics.Vulkan.Types.Struct.VkDescriptorUpdateTemplateEntryKHR + Graphics.Vulkan.Types.Struct.VkDeviceCreateInfo + Graphics.Vulkan.Types.Struct.VkDeviceEventInfoEXT + Graphics.Vulkan.Types.Struct.VkDeviceGeneratedCommandsFeaturesNVX + Graphics.Vulkan.Types.Struct.VkDeviceGeneratedCommandsLimitsNVX + Graphics.Vulkan.Types.Struct.VkDeviceGroupBindSparseInfoKHX + Graphics.Vulkan.Types.Struct.VkDeviceGroupCommandBufferBeginInfoKHX + Graphics.Vulkan.Types.Struct.VkDeviceGroupDeviceCreateInfoKHX + Graphics.Vulkan.Types.Struct.VkDeviceGroupPresentCapabilitiesKHX + Graphics.Vulkan.Types.Struct.VkDeviceGroupPresentInfoKHX + Graphics.Vulkan.Types.Struct.VkDeviceGroupRenderPassBeginInfoKHX + Graphics.Vulkan.Types.Struct.VkDeviceGroupSubmitInfoKHX + Graphics.Vulkan.Types.Struct.VkDeviceGroupSwapchainCreateInfoKHX + Graphics.Vulkan.Types.Struct.VkDeviceQueueCreateInfo + Graphics.Vulkan.Types.Struct.VkDeviceQueueGlobalPriorityCreateInfoEXT + Graphics.Vulkan.Types.Struct.VkDispatchIndirectCommand + Graphics.Vulkan.Types.Struct.VkDisplayEventInfoEXT + Graphics.Vulkan.Types.Struct.VkDisplayModeCreateInfoKHR + Graphics.Vulkan.Types.Struct.VkDisplayModeParametersKHR + Graphics.Vulkan.Types.Struct.VkDisplayModePropertiesKHR + Graphics.Vulkan.Types.Struct.VkDisplayPlaneCapabilitiesKHR + Graphics.Vulkan.Types.Struct.VkDisplayPlanePropertiesKHR + Graphics.Vulkan.Types.Struct.VkDisplayPowerInfoEXT + Graphics.Vulkan.Types.Struct.VkDisplayPresentInfoKHR + Graphics.Vulkan.Types.Struct.VkDisplayPropertiesKHR + Graphics.Vulkan.Types.Struct.VkDisplaySurfaceCreateInfoKHR + Graphics.Vulkan.Types.Struct.VkDrawIndexedIndirectCommand + Graphics.Vulkan.Types.Struct.VkDrawIndirectCommand + Graphics.Vulkan.Types.Struct.VkEventCreateInfo + Graphics.Vulkan.Types.Struct.VkExportFenceCreateInfoKHR + Graphics.Vulkan.Types.Struct.VkExportMemoryAllocateInfoKHR + Graphics.Vulkan.Types.Struct.VkExportMemoryAllocateInfoNV + Graphics.Vulkan.Types.Struct.VkExportSemaphoreCreateInfoKHR + Graphics.Vulkan.Types.Struct.VkExtensionProperties + Graphics.Vulkan.Types.Struct.VkExtent2D + Graphics.Vulkan.Types.Struct.VkExtent3D + Graphics.Vulkan.Types.Struct.VkExternalBufferPropertiesKHR + Graphics.Vulkan.Types.Struct.VkExternalFencePropertiesKHR + Graphics.Vulkan.Types.Struct.VkExternalImageFormatPropertiesKHR + Graphics.Vulkan.Types.Struct.VkExternalImageFormatPropertiesNV + Graphics.Vulkan.Types.Struct.VkExternalMemoryBufferCreateInfoKHR + Graphics.Vulkan.Types.Struct.VkExternalMemoryImageCreateInfoKHR + Graphics.Vulkan.Types.Struct.VkExternalMemoryImageCreateInfoNV + Graphics.Vulkan.Types.Struct.VkExternalMemoryPropertiesKHR + Graphics.Vulkan.Types.Struct.VkExternalSemaphorePropertiesKHR + Graphics.Vulkan.Types.Struct.VkFenceCreateInfo + Graphics.Vulkan.Types.Struct.VkFenceGetFdInfoKHR + Graphics.Vulkan.Types.Struct.VkFormatProperties + Graphics.Vulkan.Types.Struct.VkFormatProperties2KHR + Graphics.Vulkan.Types.Struct.VkFramebufferCreateInfo + Graphics.Vulkan.Types.Struct.VkGraphicsPipelineCreateInfo + Graphics.Vulkan.Types.Struct.VkHdrMetadataEXT + Graphics.Vulkan.Types.Struct.VkImageBlit + Graphics.Vulkan.Types.Struct.VkImageCopy + Graphics.Vulkan.Types.Struct.VkImageCreateInfo + Graphics.Vulkan.Types.Struct.VkImageFormatListCreateInfoKHR + Graphics.Vulkan.Types.Struct.VkImageFormatProperties + Graphics.Vulkan.Types.Struct.VkImageFormatProperties2KHR + Graphics.Vulkan.Types.Struct.VkImageMemoryBarrier + Graphics.Vulkan.Types.Struct.VkImageMemoryRequirementsInfo2KHR + Graphics.Vulkan.Types.Struct.VkImagePlaneMemoryRequirementsInfoKHR + Graphics.Vulkan.Types.Struct.VkImageResolve + Graphics.Vulkan.Types.Struct.VkImageSparseMemoryRequirementsInfo2KHR + Graphics.Vulkan.Types.Struct.VkImageSubresource + Graphics.Vulkan.Types.Struct.VkImageSubresourceLayers + Graphics.Vulkan.Types.Struct.VkImageSubresourceRange + Graphics.Vulkan.Types.Struct.VkImageSwapchainCreateInfoKHX + Graphics.Vulkan.Types.Struct.VkImageViewCreateInfo + Graphics.Vulkan.Types.Struct.VkImageViewUsageCreateInfoKHR + Graphics.Vulkan.Types.Struct.VkImportFenceFdInfoKHR + Graphics.Vulkan.Types.Struct.VkImportMemoryFdInfoKHR + Graphics.Vulkan.Types.Struct.VkImportMemoryHostPointerInfoEXT + Graphics.Vulkan.Types.Struct.VkImportSemaphoreFdInfoKHR + Graphics.Vulkan.Types.Struct.VkIndirectCommandsLayoutCreateInfoNVX + Graphics.Vulkan.Types.Struct.VkIndirectCommandsLayoutTokenNVX + Graphics.Vulkan.Types.Struct.VkIndirectCommandsTokenNVX + Graphics.Vulkan.Types.Struct.VkInputAttachmentAspectReferenceKHR + Graphics.Vulkan.Types.Struct.VkInstanceCreateInfo + Graphics.Vulkan.Types.Struct.VkLayerProperties + Graphics.Vulkan.Types.Struct.VkMappedMemoryRange + Graphics.Vulkan.Types.Struct.VkMemoryAllocateFlagsInfoKHX + Graphics.Vulkan.Types.Struct.VkMemoryAllocateInfo + Graphics.Vulkan.Types.Struct.VkMemoryBarrier + Graphics.Vulkan.Types.Struct.VkMemoryDedicatedAllocateInfoKHR + Graphics.Vulkan.Types.Struct.VkMemoryDedicatedRequirementsKHR + Graphics.Vulkan.Types.Struct.VkMemoryFdPropertiesKHR + Graphics.Vulkan.Types.Struct.VkMemoryGetFdInfoKHR + Graphics.Vulkan.Types.Struct.VkMemoryHeap + Graphics.Vulkan.Types.Struct.VkMemoryHostPointerPropertiesEXT + Graphics.Vulkan.Types.Struct.VkMemoryRequirements + Graphics.Vulkan.Types.Struct.VkMemoryRequirements2KHR + Graphics.Vulkan.Types.Struct.VkMemoryType + Graphics.Vulkan.Types.Struct.VkMultisamplePropertiesEXT + Graphics.Vulkan.Types.Struct.VkObjectTableCreateInfoNVX + Graphics.Vulkan.Types.Struct.VkObjectTableDescriptorSetEntryNVX + Graphics.Vulkan.Types.Struct.VkObjectTableEntryNVX + Graphics.Vulkan.Types.Struct.VkObjectTableIndexBufferEntryNVX + Graphics.Vulkan.Types.Struct.VkObjectTablePipelineEntryNVX + Graphics.Vulkan.Types.Struct.VkObjectTablePushConstantEntryNVX + Graphics.Vulkan.Types.Struct.VkObjectTableVertexBufferEntryNVX + Graphics.Vulkan.Types.Struct.VkOffset2D + Graphics.Vulkan.Types.Struct.VkOffset3D + Graphics.Vulkan.Types.Struct.VkPastPresentationTimingGOOGLE + Graphics.Vulkan.Types.Struct.VkPhysicalDevice16BitStorageFeaturesKHR + Graphics.Vulkan.Types.Struct.VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT + Graphics.Vulkan.Types.Struct.VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT + Graphics.Vulkan.Types.Struct.VkPhysicalDeviceConservativeRasterizationPropertiesEXT + Graphics.Vulkan.Types.Struct.VkPhysicalDeviceDiscardRectanglePropertiesEXT + Graphics.Vulkan.Types.Struct.VkPhysicalDeviceExternalBufferInfoKHR + Graphics.Vulkan.Types.Struct.VkPhysicalDeviceExternalFenceInfoKHR + Graphics.Vulkan.Types.Struct.VkPhysicalDeviceExternalImageFormatInfoKHR + Graphics.Vulkan.Types.Struct.VkPhysicalDeviceExternalMemoryHostPropertiesEXT + Graphics.Vulkan.Types.Struct.VkPhysicalDeviceExternalSemaphoreInfoKHR + Graphics.Vulkan.Types.Struct.VkPhysicalDeviceFeatures + Graphics.Vulkan.Types.Struct.VkPhysicalDeviceFeatures2KHR + Graphics.Vulkan.Types.Struct.VkPhysicalDeviceGroupPropertiesKHX + Graphics.Vulkan.Types.Struct.VkPhysicalDeviceIDPropertiesKHR + Graphics.Vulkan.Types.Struct.VkPhysicalDeviceImageFormatInfo2KHR + Graphics.Vulkan.Types.Struct.VkPhysicalDeviceLimits + Graphics.Vulkan.Types.Struct.VkPhysicalDeviceMemoryProperties + Graphics.Vulkan.Types.Struct.VkPhysicalDeviceMemoryProperties2KHR + Graphics.Vulkan.Types.Struct.VkPhysicalDeviceMultiviewFeaturesKHX + Graphics.Vulkan.Types.Struct.VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX + Graphics.Vulkan.Types.Struct.VkPhysicalDeviceMultiviewPropertiesKHX + Graphics.Vulkan.Types.Struct.VkPhysicalDevicePointClippingPropertiesKHR + Graphics.Vulkan.Types.Struct.VkPhysicalDeviceProperties + Graphics.Vulkan.Types.Struct.VkPhysicalDeviceProperties2KHR + Graphics.Vulkan.Types.Struct.VkPhysicalDevicePushDescriptorPropertiesKHR + Graphics.Vulkan.Types.Struct.VkPhysicalDeviceSampleLocationsPropertiesEXT + Graphics.Vulkan.Types.Struct.VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT + Graphics.Vulkan.Types.Struct.VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR + Graphics.Vulkan.Types.Struct.VkPhysicalDeviceSparseImageFormatInfo2KHR + Graphics.Vulkan.Types.Struct.VkPhysicalDeviceSparseProperties + Graphics.Vulkan.Types.Struct.VkPhysicalDeviceSurfaceInfo2KHR + Graphics.Vulkan.Types.Struct.VkPhysicalDeviceVariablePointerFeaturesKHR + Graphics.Vulkan.Types.Struct.VkPipelineCacheCreateInfo + Graphics.Vulkan.Types.Struct.VkPipelineColorBlendAdvancedStateCreateInfoEXT + Graphics.Vulkan.Types.Struct.VkPipelineColorBlendAttachmentState + Graphics.Vulkan.Types.Struct.VkPipelineColorBlendStateCreateInfo + Graphics.Vulkan.Types.Struct.VkPipelineCoverageModulationStateCreateInfoNV + Graphics.Vulkan.Types.Struct.VkPipelineCoverageToColorStateCreateInfoNV + Graphics.Vulkan.Types.Struct.VkPipelineDepthStencilStateCreateInfo + Graphics.Vulkan.Types.Struct.VkPipelineDiscardRectangleStateCreateInfoEXT + Graphics.Vulkan.Types.Struct.VkPipelineDynamicStateCreateInfo + Graphics.Vulkan.Types.Struct.VkPipelineInputAssemblyStateCreateInfo + Graphics.Vulkan.Types.Struct.VkPipelineLayoutCreateInfo + Graphics.Vulkan.Types.Struct.VkPipelineMultisampleStateCreateInfo + Graphics.Vulkan.Types.Struct.VkPipelineRasterizationConservativeStateCreateInfoEXT + Graphics.Vulkan.Types.Struct.VkPipelineRasterizationStateCreateInfo + Graphics.Vulkan.Types.Struct.VkPipelineRasterizationStateRasterizationOrderAMD + Graphics.Vulkan.Types.Struct.VkPipelineSampleLocationsStateCreateInfoEXT + Graphics.Vulkan.Types.Struct.VkPipelineShaderStageCreateInfo + Graphics.Vulkan.Types.Struct.VkPipelineTessellationDomainOriginStateCreateInfoKHR + Graphics.Vulkan.Types.Struct.VkPipelineTessellationStateCreateInfo + Graphics.Vulkan.Types.Struct.VkPipelineVertexInputStateCreateInfo + Graphics.Vulkan.Types.Struct.VkPipelineViewportStateCreateInfo + Graphics.Vulkan.Types.Struct.VkPipelineViewportSwizzleStateCreateInfoNV + Graphics.Vulkan.Types.Struct.VkPipelineViewportWScalingStateCreateInfoNV + Graphics.Vulkan.Types.Struct.VkPresentInfoKHR + Graphics.Vulkan.Types.Struct.VkPresentRegionKHR + Graphics.Vulkan.Types.Struct.VkPresentRegionsKHR + Graphics.Vulkan.Types.Struct.VkPresentTimeGOOGLE + Graphics.Vulkan.Types.Struct.VkPresentTimesInfoGOOGLE + Graphics.Vulkan.Types.Struct.VkPushConstantRange + Graphics.Vulkan.Types.Struct.VkQueryPoolCreateInfo + Graphics.Vulkan.Types.Struct.VkQueueFamilyProperties + Graphics.Vulkan.Types.Struct.VkQueueFamilyProperties2KHR + Graphics.Vulkan.Types.Struct.VkRect2D + Graphics.Vulkan.Types.Struct.VkRectLayerKHR + Graphics.Vulkan.Types.Struct.VkRefreshCycleDurationGOOGLE + Graphics.Vulkan.Types.Struct.VkRenderPassBeginInfo + Graphics.Vulkan.Types.Struct.VkRenderPassCreateInfo + Graphics.Vulkan.Types.Struct.VkRenderPassInputAttachmentAspectCreateInfoKHR + Graphics.Vulkan.Types.Struct.VkRenderPassMultiviewCreateInfoKHX + Graphics.Vulkan.Types.Struct.VkRenderPassSampleLocationsBeginInfoEXT + Graphics.Vulkan.Types.Struct.VkSampleLocationEXT + Graphics.Vulkan.Types.Struct.VkSampleLocationsInfoEXT + Graphics.Vulkan.Types.Struct.VkSamplerCreateInfo + Graphics.Vulkan.Types.Struct.VkSamplerReductionModeCreateInfoEXT + Graphics.Vulkan.Types.Struct.VkSamplerYcbcrConversionCreateInfoKHR + Graphics.Vulkan.Types.Struct.VkSamplerYcbcrConversionImageFormatPropertiesKHR + Graphics.Vulkan.Types.Struct.VkSamplerYcbcrConversionInfoKHR + Graphics.Vulkan.Types.Struct.VkSemaphoreCreateInfo + Graphics.Vulkan.Types.Struct.VkSemaphoreGetFdInfoKHR + Graphics.Vulkan.Types.Struct.VkShaderModuleCreateInfo + Graphics.Vulkan.Types.Struct.VkShaderModuleValidationCacheCreateInfoEXT + Graphics.Vulkan.Types.Struct.VkShaderResourceUsageAMD + Graphics.Vulkan.Types.Struct.VkShaderStatisticsInfoAMD + Graphics.Vulkan.Types.Struct.VkSharedPresentSurfaceCapabilitiesKHR + Graphics.Vulkan.Types.Struct.VkSparseBufferMemoryBindInfo + Graphics.Vulkan.Types.Struct.VkSparseImageFormatProperties + Graphics.Vulkan.Types.Struct.VkSparseImageFormatProperties2KHR + Graphics.Vulkan.Types.Struct.VkSparseImageMemoryBind + Graphics.Vulkan.Types.Struct.VkSparseImageMemoryBindInfo + Graphics.Vulkan.Types.Struct.VkSparseImageMemoryRequirements + Graphics.Vulkan.Types.Struct.VkSparseImageMemoryRequirements2KHR + Graphics.Vulkan.Types.Struct.VkSparseImageOpaqueMemoryBindInfo + Graphics.Vulkan.Types.Struct.VkSparseMemoryBind + Graphics.Vulkan.Types.Struct.VkSpecializationInfo + Graphics.Vulkan.Types.Struct.VkSpecializationMapEntry + Graphics.Vulkan.Types.Struct.VkStencilOpState + Graphics.Vulkan.Types.Struct.VkSubmitInfo + Graphics.Vulkan.Types.Struct.VkSubpassDependency + Graphics.Vulkan.Types.Struct.VkSubpassDescription + Graphics.Vulkan.Types.Struct.VkSubpassSampleLocationsEXT + Graphics.Vulkan.Types.Struct.VkSubresourceLayout + Graphics.Vulkan.Types.Struct.VkSurfaceCapabilities2EXT + Graphics.Vulkan.Types.Struct.VkSurfaceCapabilities2KHR + Graphics.Vulkan.Types.Struct.VkSurfaceCapabilitiesKHR + Graphics.Vulkan.Types.Struct.VkSurfaceFormat2KHR + Graphics.Vulkan.Types.Struct.VkSurfaceFormatKHR + Graphics.Vulkan.Types.Struct.VkSwapchainCounterCreateInfoEXT + Graphics.Vulkan.Types.Struct.VkSwapchainCreateInfoKHR + Graphics.Vulkan.Types.Struct.VkTextureLODGatherFormatPropertiesAMD + Graphics.Vulkan.Types.Struct.VkValidationCacheCreateInfoEXT + Graphics.Vulkan.Types.Struct.VkValidationFlagsEXT + Graphics.Vulkan.Types.Struct.VkVertexInputAttributeDescription + Graphics.Vulkan.Types.Struct.VkVertexInputBindingDescription + Graphics.Vulkan.Types.Struct.VkViewport + Graphics.Vulkan.Types.Struct.VkViewportSwizzleNV + Graphics.Vulkan.Types.Struct.VkViewportWScalingNV + Graphics.Vulkan.Types.Struct.VkWriteDescriptorSet + Graphics.Vulkan.Types.Struct.VkXYColorEXT + Graphics.Vulkan.Types.StructMembers + if flag(usePlatformAndroidKhr) + cpp-options: -DVK_USE_PLATFORM_ANDROID_KHR + exposed-modules: + Graphics.Vulkan.Ext.VK_KHR_android_surface + Graphics.Vulkan.Types.Struct.VkAndroidSurfaceCreateInfoKHR + + if flag(usePlatformIosMvk) + cpp-options: -DVK_USE_PLATFORM_IOS_MVK + exposed-modules: + Graphics.Vulkan.Ext.VK_MVK_ios_surface + Graphics.Vulkan.Types.Struct.VkIOSSurfaceCreateInfoMVK + + if flag(usePlatformMacosMvk) + cpp-options: -DVK_USE_PLATFORM_MACOS_MVK + exposed-modules: + Graphics.Vulkan.Ext.VK_MVK_macos_surface + Graphics.Vulkan.Types.Struct.VkMacOSSurfaceCreateInfoMVK + + if flag(usePlatformMirKhr) + cpp-options: -DVK_USE_PLATFORM_MIR_KHR + exposed-modules: + Graphics.Vulkan.Ext.VK_KHR_mir_surface + Graphics.Vulkan.Types.Struct.VkMirSurfaceCreateInfoKHR + + if flag(usePlatformViNn) + cpp-options: -DVK_USE_PLATFORM_VI_NN + exposed-modules: + Graphics.Vulkan.Ext.VK_NN_vi_surface + Graphics.Vulkan.Types.Struct.VkViSurfaceCreateInfoNN + + if flag(usePlatformWaylandKhr) + cpp-options: -DVK_USE_PLATFORM_WAYLAND_KHR + exposed-modules: + Graphics.Vulkan.Ext.VK_KHR_wayland_surface + Graphics.Vulkan.Types.Struct.VkWaylandSurfaceCreateInfoKHR + + if flag(usePlatformWin32Khr) + cpp-options: -DVK_USE_PLATFORM_WIN32_KHR + exposed-modules: + Graphics.Vulkan.Ext.VK_KHR_external_fence_win32 + Graphics.Vulkan.Ext.VK_KHR_external_memory_win32 + Graphics.Vulkan.Ext.VK_KHR_external_semaphore_win32 + Graphics.Vulkan.Ext.VK_KHR_win32_keyed_mutex + Graphics.Vulkan.Ext.VK_KHR_win32_surface + Graphics.Vulkan.Ext.VK_NV_external_memory_win32 + Graphics.Vulkan.Ext.VK_NV_win32_keyed_mutex + Graphics.Vulkan.Types.Struct.VkD3D12FenceSubmitInfoKHR + Graphics.Vulkan.Types.Struct.VkExportFenceWin32HandleInfoKHR + Graphics.Vulkan.Types.Struct.VkExportMemoryWin32HandleInfoKHR + Graphics.Vulkan.Types.Struct.VkExportMemoryWin32HandleInfoNV + Graphics.Vulkan.Types.Struct.VkExportSemaphoreWin32HandleInfoKHR + Graphics.Vulkan.Types.Struct.VkFenceGetWin32HandleInfoKHR + Graphics.Vulkan.Types.Struct.VkImportFenceWin32HandleInfoKHR + Graphics.Vulkan.Types.Struct.VkImportMemoryWin32HandleInfoKHR + Graphics.Vulkan.Types.Struct.VkImportMemoryWin32HandleInfoNV + Graphics.Vulkan.Types.Struct.VkImportSemaphoreWin32HandleInfoKHR + Graphics.Vulkan.Types.Struct.VkMemoryGetWin32HandleInfoKHR + Graphics.Vulkan.Types.Struct.VkMemoryWin32HandlePropertiesKHR + Graphics.Vulkan.Types.Struct.VkSemaphoreGetWin32HandleInfoKHR + Graphics.Vulkan.Types.Struct.VkWin32KeyedMutexAcquireReleaseInfoKHR + Graphics.Vulkan.Types.Struct.VkWin32KeyedMutexAcquireReleaseInfoNV + Graphics.Vulkan.Types.Struct.VkWin32SurfaceCreateInfoKHR + + if flag(usePlatformXcbKhr) + cpp-options: -DVK_USE_PLATFORM_XCB_KHR + exposed-modules: + Graphics.Vulkan.Ext.VK_KHR_xcb_surface + Graphics.Vulkan.Types.Struct.VkXcbSurfaceCreateInfoKHR + + if flag(usePlatformXlibKhr) + cpp-options: -DVK_USE_PLATFORM_XLIB_KHR + exposed-modules: + Graphics.Vulkan.Ext.VK_KHR_xlib_surface + Graphics.Vulkan.Types.Struct.VkXlibSurfaceCreateInfoKHR + + if flag(usePlatformXlibXrandrExt) + cpp-options: -DVK_USE_PLATFORM_XLIB_XRANDR_EXT + exposed-modules: + Graphics.Vulkan.Ext.VK_EXT_acquire_xlib_display + + build-depends: + base >= 4.7 && < 5 + , ghc-prim >= 0.4 && < 0.6 + default-language: Haskell2010 + ghc-options: -Wall + extra-libraries: vulkan + include-dirs: include + +source-repository head + type: git + location: https://github.com/achirkin/vulkan