Graphics.Vulkan

This module is not part of auto-generated code based on vk.xml. Instead, it is hand-written to aggregate all generated code.

Documentation

module Graphics.Vulkan.Marshal

module Graphics.Vulkan.Marshal.Proc

module Graphics.Vulkan.Constants

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

type VK_API_VERSION_1_0 = 4194304

pattern VK_API_VERSION_1_0 :: (Num a, Eq a) => a

// 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

type VK_API_VERSION_1_1 = 4198400

pattern VK_API_VERSION_1_1 :: (Num a, Eq a) => a

// Vulkan 1.1 version number
#define VK_API_VERSION_1_1 VK_MAKE_VERSION(1, 1, 0)// Patch version should always be set to 0

type VK_API_VERSION_1_2 = 4202496

pattern VK_API_VERSION_1_2 :: (Num a, Eq a) => a

// Vulkan 1.2 version number
#define VK_API_VERSION_1_2 VK_MAKE_VERSION(1, 2, 0)// Patch version should always be set to 0

data Ptr a

A value of type Ptr a represents a pointer to an object, or an array of objects, which may be marshalled to or from Haskell values of type a.

The type a will often be an instance of class Storable which provides the marshalling operations. However this is not essential, and you can provide your own operations to access the pointer. For example you might write small foreign functions to get or set the fields of a C struct.

Instances

VulkanPtr Ptr

Defined in Graphics.Vulkan.Marshal

Methods

vkNullPtr :: Ptr a

Generic1 (URec (Ptr ()) :: k -> Type)

Since: base-4.9.0.0

Defined in GHC.Generics

Associated Types

type Rep1 (URec (Ptr ())) :: k -> Type

Methods

from1 :: forall (a :: k0). URec (Ptr ()) a -> Rep1 (URec (Ptr ())) a

to1 :: forall (a :: k0). Rep1 (URec (Ptr ())) a -> URec (Ptr ()) a

Eq (Ptr a)

Since: base-2.1

Defined in GHC.Ptr

Methods

(==) :: Ptr a -> Ptr a -> Bool

(/=) :: Ptr a -> Ptr a -> Bool

Ord (Ptr a)

Since: base-2.1

Defined in GHC.Ptr

Methods

compare :: Ptr a -> Ptr a -> Ordering

(<) :: Ptr a -> Ptr a -> Bool

(<=) :: Ptr a -> Ptr a -> Bool

(>) :: Ptr a -> Ptr a -> Bool

(>=) :: Ptr a -> Ptr a -> Bool

max :: Ptr a -> Ptr a -> Ptr a

min :: Ptr a -> Ptr a -> Ptr a

Show (Ptr a)

Since: base-2.1

Defined in GHC.Ptr

Methods

showsPrec :: Int -> Ptr a -> ShowS

show :: Ptr a -> String

showList :: [Ptr a] -> ShowS

Foldable (UAddr :: Type -> Type)

Since: base-4.9.0.0

Defined in Data.Foldable

Methods

fold :: Monoid m => UAddr m -> m

foldMap :: Monoid m => (a -> m) -> UAddr a -> m

foldMap' :: Monoid m => (a -> m) -> UAddr a -> m

foldr :: (a -> b -> b) -> b -> UAddr a -> b

foldr' :: (a -> b -> b) -> b -> UAddr a -> b

foldl :: (b -> a -> b) -> b -> UAddr a -> b

foldl' :: (b -> a -> b) -> b -> UAddr a -> b

foldr1 :: (a -> a -> a) -> UAddr a -> a

foldl1 :: (a -> a -> a) -> UAddr a -> a

toList :: UAddr a -> [a]

null :: UAddr a -> Bool

length :: UAddr a -> Int

elem :: Eq a => a -> UAddr a -> Bool

maximum :: Ord a => UAddr a -> a

minimum :: Ord a => UAddr a -> a

sum :: Num a => UAddr a -> a

product :: Num a => UAddr a -> a

Traversable (UAddr :: Type -> Type)

Since: base-4.9.0.0

Defined in Data.Traversable

Methods

traverse :: Applicative f => (a -> f b) -> UAddr a -> f (UAddr b)

sequenceA :: Applicative f => UAddr (f a) -> f (UAddr a)

mapM :: Monad m => (a -> m b) -> UAddr a -> m (UAddr b)

sequence :: Monad m => UAddr (m a) -> m (UAddr a)

Storable (Ptr a)

Since: base-2.1

Defined in Foreign.Storable

Methods

sizeOf :: Ptr a -> Int

alignment :: Ptr a -> Int

peekElemOff :: Ptr (Ptr a) -> Int -> IO (Ptr a)

pokeElemOff :: Ptr (Ptr a) -> Int -> Ptr a -> IO ()

peekByteOff :: Ptr b -> Int -> IO (Ptr a)

pokeByteOff :: Ptr b -> Int -> Ptr a -> IO ()

peek :: Ptr (Ptr a) -> IO (Ptr a)

poke :: Ptr (Ptr a) -> Ptr a -> IO ()

Functor (URec (Ptr ()) :: Type -> Type)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

fmap :: (a -> b) -> URec (Ptr ()) a -> URec (Ptr ()) b

(<$) :: a -> URec (Ptr ()) b -> URec (Ptr ()) a

Eq (URec (Ptr ()) p)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

(==) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool

(/=) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool

Ord (URec (Ptr ()) p)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

compare :: URec (Ptr ()) p -> URec (Ptr ()) p -> Ordering

(<) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool

(<=) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool

(>) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool

(>=) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool

max :: URec (Ptr ()) p -> URec (Ptr ()) p -> URec (Ptr ()) p

min :: URec (Ptr ()) p -> URec (Ptr ()) p -> URec (Ptr ()) p

Generic (URec (Ptr ()) p)

Since: base-4.9.0.0

Defined in GHC.Generics

Associated Types

type Rep (URec (Ptr ()) p) :: Type -> Type

Methods

from :: URec (Ptr ()) p -> Rep (URec (Ptr ()) p) x

to :: Rep (URec (Ptr ()) p) x -> URec (Ptr ()) p

data URec (Ptr ()) (p :: k)

Used for marking occurrences of Addr#

Since: base-4.9.0.0

Defined in GHC.Generics

data URec (Ptr ()) (p :: k) = UAddr {

• uAddr# :: Addr#

}

type Rep1 (URec (Ptr ()) :: k -> Type)

Defined in GHC.Generics

type Rep1 (URec (Ptr ()) :: k -> Type) = D1 ('MetaData "URec" "GHC.Generics" "base" 'False) (C1 ('MetaCons "UAddr" 'PrefixI 'True) (S1 ('MetaSel ('Just "uAddr#") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (UAddr :: k -> Type)))

type Rep (URec (Ptr ()) p)

Defined in GHC.Generics

type Rep (URec (Ptr ()) p) = D1 ('MetaData "URec" "GHC.Generics" "base" 'False) (C1 ('MetaCons "UAddr" 'PrefixI 'True) (S1 ('MetaSel ('Just "uAddr#") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (UAddr :: Type -> Type)))

VK_DEFINE_HANDLE

Dispatchable handles are represented as Ptr

#define VK_DEFINE_HANDLE(object) typedef struct object##_T* object;

newtype VkPtr a

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

Constructors

VkPtr Word64

Instances

VulkanPtr VkPtr

Defined in Graphics.Vulkan.Marshal

Methods

vkNullPtr :: VkPtr a

Eq (VkPtr a)

Defined in Graphics.Vulkan.Marshal

Methods

(==) :: VkPtr a -> VkPtr a -> Bool

(/=) :: VkPtr a -> VkPtr a -> Bool

Ord (VkPtr a)

Defined in Graphics.Vulkan.Marshal

Methods

compare :: VkPtr a -> VkPtr a -> Ordering

(<) :: VkPtr a -> VkPtr a -> Bool

(<=) :: VkPtr a -> VkPtr a -> Bool

(>) :: VkPtr a -> VkPtr a -> Bool

(>=) :: VkPtr a -> VkPtr a -> Bool

max :: VkPtr a -> VkPtr a -> VkPtr a

min :: VkPtr a -> VkPtr a -> VkPtr a

Show (VkPtr a)

Defined in Graphics.Vulkan.Marshal

Methods

showsPrec :: Int -> VkPtr a -> ShowS

show :: VkPtr a -> String

showList :: [VkPtr a] -> ShowS

Storable (VkPtr a)

Defined in Graphics.Vulkan.Marshal

Methods

sizeOf :: VkPtr a -> Int

alignment :: VkPtr a -> Int

peekElemOff :: Ptr (VkPtr a) -> Int -> IO (VkPtr a)

pokeElemOff :: Ptr (VkPtr a) -> Int -> VkPtr a -> IO ()

peekByteOff :: Ptr b -> Int -> IO (VkPtr a)

pokeByteOff :: Ptr b -> Int -> VkPtr a -> IO ()

peek :: Ptr (VkPtr a) -> IO (VkPtr a)

poke :: Ptr (VkPtr a) -> VkPtr a -> IO ()

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

type VK_HEADER_VERSION = 152

pattern VK_HEADER_VERSION :: (Num a, Eq a) => a

// Version of this file
#define VK_HEADER_VERSION 152

_VK_HEADER_VERSION_COMPLETE :: (Bits a, Num a) => a

// Complete version of this file
#define VK_HEADER_VERSION_COMPLETE VK_MAKE_VERSION(1, 2, VK_HEADER_VERSION)

_VK_MAKE_VERSION :: Bits a => a -> a -> a -> a

#define VK_MAKE_VERSION(major, minor, patch) --   >     ((((uint32_t)(major)) << 22) | (((uint32_t)(minor)) << 12) | ((uint32_t)(patch)))

class VulkanPtr ptr where

Unify dispatchable and non-dispatchable vulkan pointer types.

Dispatchable handles are represented as Ptr.

Non-dispatchable handles are represented as VkPtr.

Methods

vkNullPtr :: ptr a

Instances

VulkanPtr Ptr

Defined in Graphics.Vulkan.Marshal

Methods

vkNullPtr :: Ptr a

VulkanPtr VkPtr

Defined in Graphics.Vulkan.Marshal

Methods

vkNullPtr :: VkPtr a

pattern VK_NULL_HANDLE :: (Eq (ptr a), VulkanPtr ptr) => ptr a

#define VK_NULL_HANDLE 0

_VK_VERSION_MAJOR :: Bits a => a -> a

#define VK_VERSION_MAJOR(version) ((uint32_t)(version) >> 22)

_VK_VERSION_MINOR :: (Bits a, Num a) => a -> a

#define VK_VERSION_MINOR(version) (((uint32_t)(version) >> 12) & 0x3ff)

_VK_VERSION_PATCH :: (Bits a, Num a) => a -> a

#define VK_VERSION_PATCH(version) ((uint32_t)(version) & 0xfff)

type PFN_vkAllocationFunction = FunPtr HS_vkAllocationFunction

typedef void* (VKAPI_PTR *PFN_vkAllocationFunction)(
    void*                                       pUserData,
    size_t                                      size,
    size_t                                      alignment,
    VkSystemAllocationScope                     allocationScope);

type HS_vkAllocationFunction = Ptr Void -> CSize -> CSize -> VkSystemAllocationScope -> IO (Ptr Void)

newVkAllocationFunction :: HS_vkAllocationFunction -> IO PFN_vkAllocationFunction

Wrap haskell function into C-callable FunPtr. Note, you need to free resources after using it.

unwrapVkAllocationFunction :: PFN_vkAllocationFunction -> HS_vkAllocationFunction

type PFN_vkDebugReportCallbackEXT = FunPtr HS_vkDebugReportCallbackEXT

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 HS_vkDebugReportCallbackEXT = VkDebugReportFlagsEXT -> VkDebugReportObjectTypeEXT -> Word64 -> CSize -> Int32 -> CString -> CString -> Ptr Void -> IO VkBool32

newVkDebugReportCallbackEXT :: HS_vkDebugReportCallbackEXT -> IO PFN_vkDebugReportCallbackEXT

Wrap haskell function into C-callable FunPtr. Note, you need to free resources after using it.

unwrapVkDebugReportCallbackEXT :: PFN_vkDebugReportCallbackEXT -> HS_vkDebugReportCallbackEXT

type PFN_vkDebugUtilsMessengerCallbackEXT = FunPtr HS_vkDebugUtilsMessengerCallbackEXT

typedef VkBool32 (VKAPI_PTR *PFN_vkDebugUtilsMessengerCallbackEXT)(
    VkDebugUtilsMessageSeverityFlagBitsEXT           messageSeverity,
    VkDebugUtilsMessageTypeFlagsEXT                  messageTypes,
    const VkDebugUtilsMessengerCallbackDataEXT*      pCallbackData,
    void*                                            pUserData);

type HS_vkDebugUtilsMessengerCallbackEXT = VkDebugUtilsMessageSeverityFlagBitsEXT -> VkDebugUtilsMessageTypeFlagsEXT -> Ptr VkDebugUtilsMessengerCallbackDataEXT -> Ptr Void -> IO VkBool32

newVkDebugUtilsMessengerCallbackEXT :: HS_vkDebugUtilsMessengerCallbackEXT -> IO PFN_vkDebugUtilsMessengerCallbackEXT

Wrap haskell function into C-callable FunPtr. Note, you need to free resources after using it.

unwrapVkDebugUtilsMessengerCallbackEXT :: PFN_vkDebugUtilsMessengerCallbackEXT -> HS_vkDebugUtilsMessengerCallbackEXT

type PFN_vkFreeFunction = FunPtr HS_vkFreeFunction

typedef void (VKAPI_PTR *PFN_vkFreeFunction)(
    void*                                       pUserData,
    void*                                       pMemory);

type HS_vkFreeFunction = Ptr Void -> Ptr Void -> IO ()

newVkFreeFunction :: HS_vkFreeFunction -> IO PFN_vkFreeFunction

Wrap haskell function into C-callable FunPtr. Note, you need to free resources after using it.

unwrapVkFreeFunction :: PFN_vkFreeFunction -> HS_vkFreeFunction

type PFN_vkInternalAllocationNotification = FunPtr HS_vkInternalAllocationNotification

typedef void (VKAPI_PTR *PFN_vkInternalAllocationNotification)(
    void*                                       pUserData,
    size_t                                      size,
    VkInternalAllocationType                    allocationType,
    VkSystemAllocationScope                     allocationScope);

type HS_vkInternalAllocationNotification = Ptr Void -> CSize -> VkInternalAllocationType -> VkSystemAllocationScope -> IO ()

newVkInternalAllocationNotification :: HS_vkInternalAllocationNotification -> IO PFN_vkInternalAllocationNotification

Wrap haskell function into C-callable FunPtr. Note, you need to free resources after using it.

unwrapVkInternalAllocationNotification :: PFN_vkInternalAllocationNotification -> HS_vkInternalAllocationNotification

type PFN_vkInternalFreeNotification = FunPtr HS_vkInternalFreeNotification

typedef void (VKAPI_PTR *PFN_vkInternalFreeNotification)(
    void*                                       pUserData,
    size_t                                      size,
    VkInternalAllocationType                    allocationType,
    VkSystemAllocationScope                     allocationScope);

type HS_vkInternalFreeNotification = Ptr Void -> CSize -> VkInternalAllocationType -> VkSystemAllocationScope -> IO ()

newVkInternalFreeNotification :: HS_vkInternalFreeNotification -> IO PFN_vkInternalFreeNotification

Wrap haskell function into C-callable FunPtr. Note, you need to free resources after using it.

unwrapVkInternalFreeNotification :: PFN_vkInternalFreeNotification -> HS_vkInternalFreeNotification

type PFN_vkReallocationFunction = FunPtr HS_vkReallocationFunction

typedef void* (VKAPI_PTR *PFN_vkReallocationFunction)(
    void*                                       pUserData,
    void*                                       pOriginal,
    size_t                                      size,
    size_t                                      alignment,
    VkSystemAllocationScope                     allocationScope);

type HS_vkReallocationFunction = Ptr Void -> Ptr Void -> CSize -> CSize -> VkSystemAllocationScope -> IO (Ptr Void)

newVkReallocationFunction :: HS_vkReallocationFunction -> IO PFN_vkReallocationFunction

Wrap haskell function into C-callable FunPtr. Note, you need to free resources after using it.

unwrapVkReallocationFunction :: PFN_vkReallocationFunction -> HS_vkReallocationFunction

type PFN_vkVoidFunction = FunPtr HS_vkVoidFunction

typedef void (VKAPI_PTR *PFN_vkVoidFunction)(void);

type HS_vkVoidFunction = IO ()

newVkVoidFunction :: HS_vkVoidFunction -> IO PFN_vkVoidFunction

Wrap haskell function into C-callable FunPtr. Note, you need to free resources after using it.

unwrapVkVoidFunction :: PFN_vkVoidFunction -> HS_vkVoidFunction

type VkAccelerationStructureKHR = VkPtr VkAccelerationStructureKHR_T

data VkAccelerationStructureKHR_T

Opaque data type referenced by VkAccelerationStructureKHR

type VkAccelerationStructureNV = VkPtr VkAccelerationStructureNV_T

data VkAccelerationStructureNV_T

Opaque data type referenced by VkAccelerationStructureNV

type VkBuffer = VkPtr VkBuffer_T

data VkBuffer_T

Opaque data type referenced by VkBuffer

type VkBufferView = VkPtr VkBufferView_T

data VkBufferView_T

Opaque data type referenced by VkBufferView

type VkCommandBuffer = Ptr VkCommandBuffer_T

data VkCommandBuffer_T

Opaque data type referenced by VkCommandBuffer

type VkCommandPool = VkPtr VkCommandPool_T

data VkCommandPool_T

Opaque data type referenced by VkCommandPool

type VkDebugReportCallbackEXT = VkPtr VkDebugReportCallbackEXT_T

data VkDebugReportCallbackEXT_T

Opaque data type referenced by VkDebugReportCallbackEXT

type VkDebugUtilsMessengerEXT = VkPtr VkDebugUtilsMessengerEXT_T

data VkDebugUtilsMessengerEXT_T

Opaque data type referenced by VkDebugUtilsMessengerEXT

type VkDeferredOperationKHR = VkPtr VkDeferredOperationKHR_T

data VkDeferredOperationKHR_T

Opaque data type referenced by VkDeferredOperationKHR

type VkDescriptorPool = VkPtr VkDescriptorPool_T

data VkDescriptorPool_T

Opaque data type referenced by VkDescriptorPool

type VkDescriptorSet = VkPtr VkDescriptorSet_T

data VkDescriptorSet_T

Opaque data type referenced by VkDescriptorSet

type VkDescriptorSetLayout = VkPtr VkDescriptorSetLayout_T

data VkDescriptorSetLayout_T

Opaque data type referenced by VkDescriptorSetLayout

type VkDescriptorUpdateTemplate = VkPtr VkDescriptorUpdateTemplate_T

data VkDescriptorUpdateTemplate_T

Opaque data type referenced by VkDescriptorUpdateTemplate

type VkDescriptorUpdateTemplateKHR = VkPtr VkDescriptorUpdateTemplateKHR_T

data VkDescriptorUpdateTemplateKHR_T

Opaque data type referenced by VkDescriptorUpdateTemplateKHR

type VkDevice = Ptr VkDevice_T

data VkDevice_T

Opaque data type referenced by VkDevice

type VkDeviceMemory = VkPtr VkDeviceMemory_T

data VkDeviceMemory_T

Opaque data type referenced by VkDeviceMemory

type VkDisplayKHR = VkPtr VkDisplayKHR_T

data VkDisplayKHR_T

Opaque data type referenced by VkDisplayKHR

type VkDisplayModeKHR = VkPtr VkDisplayModeKHR_T

data VkDisplayModeKHR_T

Opaque data type referenced by VkDisplayModeKHR

type VkEvent = VkPtr VkEvent_T

data VkEvent_T

Opaque data type referenced by VkEvent

type VkFence = VkPtr VkFence_T

data VkFence_T

Opaque data type referenced by VkFence

type VkFramebuffer = VkPtr VkFramebuffer_T

data VkFramebuffer_T

Opaque data type referenced by VkFramebuffer

type VkImage = VkPtr VkImage_T

data VkImage_T

Opaque data type referenced by VkImage

type VkImageView = VkPtr VkImageView_T

data VkImageView_T

Opaque data type referenced by VkImageView

type VkIndirectCommandsLayoutNV = VkPtr VkIndirectCommandsLayoutNV_T

data VkIndirectCommandsLayoutNV_T

Opaque data type referenced by VkIndirectCommandsLayoutNV

type VkInstance = Ptr VkInstance_T

data VkInstance_T

Opaque data type referenced by VkInstance

type VkPerformanceConfigurationINTEL = VkPtr VkPerformanceConfigurationINTEL_T

data VkPerformanceConfigurationINTEL_T

Opaque data type referenced by VkPerformanceConfigurationINTEL

type VkPhysicalDevice = Ptr VkPhysicalDevice_T

data VkPhysicalDevice_T

Opaque data type referenced by VkPhysicalDevice

type VkPipeline = VkPtr VkPipeline_T

data VkPipeline_T

Opaque data type referenced by VkPipeline

type VkPipelineCache = VkPtr VkPipelineCache_T

data VkPipelineCache_T

Opaque data type referenced by VkPipelineCache

type VkPipelineLayout = VkPtr VkPipelineLayout_T

data VkPipelineLayout_T

Opaque data type referenced by VkPipelineLayout

type VkPrivateDataSlotEXT = VkPtr VkPrivateDataSlotEXT_T

data VkPrivateDataSlotEXT_T

Opaque data type referenced by VkPrivateDataSlotEXT

type VkQueryPool = VkPtr VkQueryPool_T

data VkQueryPool_T

Opaque data type referenced by VkQueryPool

type VkQueue = Ptr VkQueue_T

data VkQueue_T

Opaque data type referenced by VkQueue

type VkRenderPass = VkPtr VkRenderPass_T

data VkRenderPass_T

Opaque data type referenced by VkRenderPass

type VkSampler = VkPtr VkSampler_T

data VkSampler_T

Opaque data type referenced by VkSampler

type VkSamplerYcbcrConversion = VkPtr VkSamplerYcbcrConversion_T

data VkSamplerYcbcrConversion_T

Opaque data type referenced by VkSamplerYcbcrConversion

type VkSamplerYcbcrConversionKHR = VkPtr VkSamplerYcbcrConversionKHR_T

data VkSamplerYcbcrConversionKHR_T

Opaque data type referenced by VkSamplerYcbcrConversionKHR

type VkSemaphore = VkPtr VkSemaphore_T

data VkSemaphore_T

Opaque data type referenced by VkSemaphore

type VkShaderModule = VkPtr VkShaderModule_T

data VkShaderModule_T

Opaque data type referenced by VkShaderModule

type VkSurfaceKHR = VkPtr VkSurfaceKHR_T

data VkSurfaceKHR_T

Opaque data type referenced by VkSurfaceKHR

type VkSwapchainKHR = VkPtr VkSwapchainKHR_T

data VkSwapchainKHR_T

Opaque data type referenced by VkSwapchainKHR

type VkValidationCacheEXT = VkPtr VkValidationCacheEXT_T

data VkValidationCacheEXT_T

Opaque data type referenced by VkValidationCacheEXT

type DWORD = Word32

Requires windows.h

data Display

Requires X11/Xlib.h

data GgpFrameToken

Requires ggp_c/vulkan_types.h

data GgpStreamDescriptor

Requires ggp_c/vulkan_types.h

type HANDLE = Ptr ()

Requires windows.h

type HINSTANCE = Ptr ()

Requires windows.h

data HMONITOR

Requires windows.h

type HWND = Ptr ()

Requires windows.h

data IDirectFB

Requires directfb.h

data IDirectFBSurface

Requires directfb.h

type LPCWSTR = Ptr CWchar

Requires windows.h

type RROutput = CULong

Requires X11extensionsXrandr.h

data SECURITY_ATTRIBUTES

Requires windows.h

type VisualID = CULong

Requires X11/Xlib.h

type Window = CULong

Requires X11/Xlib.h

data WlDisplay

Requires wayland-client.h

data WlSurface

Requires wayland-client.h

data XcbConnectionT

Requires xcb/xcb.h

type XcbVisualidT = CULong

Requires xcb/xcb.h

type XcbWindowT = CULong

Requires xcb/xcb.h

data Zx_handle_t

Requires zircon/types.h