{-# LANGUAGE DataKinds #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DerivingStrategies #-}
{-# LANGUAGE DuplicateRecordFields #-}
{-# LANGUAGE EmptyDataDecls #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE MagicHash #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE TypeApplications #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE TypeOperators #-}
{-# LANGUAGE UndecidableInstances #-}
{-# LANGUAGE NoFieldSelectors #-}
{-# LANGUAGE NoImplicitPrelude #-}

module SDL3.Sys.Bindgen.Vulkan (
  SDL3.Sys.Bindgen.Vulkan.VkInstance (..),
  SDL3.Sys.Bindgen.Vulkan.VkInstance_T,
  SDL3.Sys.Bindgen.Vulkan.VkPhysicalDevice (..),
  SDL3.Sys.Bindgen.Vulkan.VkPhysicalDevice_T,
  SDL3.Sys.Bindgen.Vulkan.VkSurfaceKHR (..),
  SDL3.Sys.Bindgen.Vulkan.VkSurfaceKHR_T,
  SDL3.Sys.Bindgen.Vulkan.VkAllocationCallbacks,
)
where

import Prelude (Eq, Ord, Show, type (~))

import HsBindgen.Runtime.HasCField qualified as HasCField
import HsBindgen.Runtime.Marshal qualified as Marshal
import HsBindgen.Runtime.Support qualified as BG
import HsBindgen.Runtime.Support.CompatHasField qualified as BG.CompatHasField

-- | [C declaration]: @VkInstance@, defined at @SDL3\/SDL_vulkan.h 67:1@
newtype VkInstance = VkInstance
  { VkInstance -> Ptr VkInstance_T
unwrap :: BG.Ptr VkInstance_T
  }
  deriving stock ((forall x. VkInstance -> Rep VkInstance x)
-> (forall x. Rep VkInstance x -> VkInstance) -> Generic VkInstance
forall x. Rep VkInstance x -> VkInstance
forall x. VkInstance -> Rep VkInstance x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. VkInstance -> Rep VkInstance x
from :: forall x. VkInstance -> Rep VkInstance x
$cto :: forall x. Rep VkInstance x -> VkInstance
to :: forall x. Rep VkInstance x -> VkInstance
BG.Generic, VkInstance -> VkInstance -> Bool
(VkInstance -> VkInstance -> Bool)
-> (VkInstance -> VkInstance -> Bool) -> Eq VkInstance
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: VkInstance -> VkInstance -> Bool
== :: VkInstance -> VkInstance -> Bool
$c/= :: VkInstance -> VkInstance -> Bool
/= :: VkInstance -> VkInstance -> Bool
Eq, Eq VkInstance
Eq VkInstance =>
(VkInstance -> VkInstance -> Ordering)
-> (VkInstance -> VkInstance -> Bool)
-> (VkInstance -> VkInstance -> Bool)
-> (VkInstance -> VkInstance -> Bool)
-> (VkInstance -> VkInstance -> Bool)
-> (VkInstance -> VkInstance -> VkInstance)
-> (VkInstance -> VkInstance -> VkInstance)
-> Ord VkInstance
VkInstance -> VkInstance -> Bool
VkInstance -> VkInstance -> Ordering
VkInstance -> VkInstance -> VkInstance
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: VkInstance -> VkInstance -> Ordering
compare :: VkInstance -> VkInstance -> Ordering
$c< :: VkInstance -> VkInstance -> Bool
< :: VkInstance -> VkInstance -> Bool
$c<= :: VkInstance -> VkInstance -> Bool
<= :: VkInstance -> VkInstance -> Bool
$c> :: VkInstance -> VkInstance -> Bool
> :: VkInstance -> VkInstance -> Bool
$c>= :: VkInstance -> VkInstance -> Bool
>= :: VkInstance -> VkInstance -> Bool
$cmax :: VkInstance -> VkInstance -> VkInstance
max :: VkInstance -> VkInstance -> VkInstance
$cmin :: VkInstance -> VkInstance -> VkInstance
min :: VkInstance -> VkInstance -> VkInstance
Ord, Int -> VkInstance -> ShowS
[VkInstance] -> ShowS
VkInstance -> String
(Int -> VkInstance -> ShowS)
-> (VkInstance -> String)
-> ([VkInstance] -> ShowS)
-> Show VkInstance
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> VkInstance -> ShowS
showsPrec :: Int -> VkInstance -> ShowS
$cshow :: VkInstance -> String
show :: VkInstance -> String
$cshowList :: [VkInstance] -> ShowS
showList :: [VkInstance] -> ShowS
Show)
  deriving newtype
    ( FFIType VkInstance -> VkInstance
VkInstance -> FFIType VkInstance
(VkInstance -> FFIType VkInstance)
-> (FFIType VkInstance -> VkInstance) -> HasFFIType VkInstance
forall a. (a -> FFIType a) -> (FFIType a -> a) -> HasFFIType a
$ctoFFIType :: VkInstance -> FFIType VkInstance
toFFIType :: VkInstance -> FFIType VkInstance
$cfromFFIType :: FFIType VkInstance -> VkInstance
fromFFIType :: FFIType VkInstance -> VkInstance
BG.HasFFIType
    , Ptr VkInstance -> IO VkInstance
Ptr VkInstance -> Int -> IO VkInstance
Ptr VkInstance -> Int -> VkInstance -> IO ()
Ptr VkInstance -> VkInstance -> IO ()
VkInstance -> Int
(VkInstance -> Int)
-> (VkInstance -> Int)
-> (Ptr VkInstance -> Int -> IO VkInstance)
-> (Ptr VkInstance -> Int -> VkInstance -> IO ())
-> (forall b. Ptr b -> Int -> IO VkInstance)
-> (forall b. Ptr b -> Int -> VkInstance -> IO ())
-> (Ptr VkInstance -> IO VkInstance)
-> (Ptr VkInstance -> VkInstance -> IO ())
-> Storable VkInstance
forall b. Ptr b -> Int -> IO VkInstance
forall b. Ptr b -> Int -> VkInstance -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
$csizeOf :: VkInstance -> Int
sizeOf :: VkInstance -> Int
$calignment :: VkInstance -> Int
alignment :: VkInstance -> Int
$cpeekElemOff :: Ptr VkInstance -> Int -> IO VkInstance
peekElemOff :: Ptr VkInstance -> Int -> IO VkInstance
$cpokeElemOff :: Ptr VkInstance -> Int -> VkInstance -> IO ()
pokeElemOff :: Ptr VkInstance -> Int -> VkInstance -> IO ()
$cpeekByteOff :: forall b. Ptr b -> Int -> IO VkInstance
peekByteOff :: forall b. Ptr b -> Int -> IO VkInstance
$cpokeByteOff :: forall b. Ptr b -> Int -> VkInstance -> IO ()
pokeByteOff :: forall b. Ptr b -> Int -> VkInstance -> IO ()
$cpeek :: Ptr VkInstance -> IO VkInstance
peek :: Ptr VkInstance -> IO VkInstance
$cpoke :: Ptr VkInstance -> VkInstance -> IO ()
poke :: Ptr VkInstance -> VkInstance -> IO ()
BG.Storable
    , Ptr VkInstance -> IO VkInstance
(Ptr VkInstance -> IO VkInstance) -> ReadRaw VkInstance
forall a. (Ptr a -> IO a) -> ReadRaw a
$creadRaw :: Ptr VkInstance -> IO VkInstance
readRaw :: Ptr VkInstance -> IO VkInstance
Marshal.ReadRaw
    , Proxy VkInstance -> Int
(Proxy VkInstance -> Int)
-> (Proxy VkInstance -> Int) -> StaticSize VkInstance
forall a. (Proxy a -> Int) -> (Proxy a -> Int) -> StaticSize a
$cstaticSizeOf :: Proxy VkInstance -> Int
staticSizeOf :: Proxy VkInstance -> Int
$cstaticAlignment :: Proxy VkInstance -> Int
staticAlignment :: Proxy VkInstance -> Int
Marshal.StaticSize
    , Ptr VkInstance -> VkInstance -> IO ()
(Ptr VkInstance -> VkInstance -> IO ()) -> WriteRaw VkInstance
forall a. (Ptr a -> a -> IO ()) -> WriteRaw a
$cwriteRaw :: Ptr VkInstance -> VkInstance -> IO ()
writeRaw :: Ptr VkInstance -> VkInstance -> IO ()
Marshal.WriteRaw
    )

instance
  (ty ~ BG.Ptr VkInstance_T)
  => BG.CompatHasField.HasField "unwrap" VkInstance ty
  where
  hasField :: VkInstance -> (ty -> VkInstance, ty)
hasField =
    \VkInstance
x0 ->
      ( \ty
y1 ->
          VkInstance{unwrap :: Ptr VkInstance_T
unwrap = ty
Ptr VkInstance_T
y1}
      , forall {k} (x :: k) r a. HasField x r a => r -> a
forall (x :: Symbol) r a. HasField x r a => r -> a
BG.getField @"unwrap" VkInstance
x0
      )

instance
  (ty ~ BG.Ptr VkInstance_T)
  => BG.HasField "unwrap" (BG.Ptr VkInstance) (BG.Ptr ty)
  where
  getField :: Ptr VkInstance -> Ptr ty
getField = Proxy "unwrap"
-> Ptr VkInstance -> Ptr (CFieldType VkInstance "unwrap")
forall a (field :: Symbol).
HasCField a field =>
Proxy field -> Ptr a -> Ptr (CFieldType a field)
HasCField.fromPtr (forall {k} (t :: k). Proxy t
forall (t :: Symbol). Proxy t
BG.Proxy @"unwrap")

instance HasCField.HasCField VkInstance "unwrap" where
  type
    CFieldType VkInstance "unwrap" =
      BG.Ptr VkInstance_T

  offset# :: Proxy# VkInstance -> Proxy# "unwrap" -> Int
offset# = \Proxy# VkInstance
_ -> \Proxy# "unwrap"
_ -> Int
0

-- | [C declaration]: @struct VkInstance_T@, defined at @SDL3\/SDL_vulkan.h 67:1@
data VkInstance_T

-- | [C declaration]: @VkPhysicalDevice@, defined at @SDL3\/SDL_vulkan.h 68:1@
newtype VkPhysicalDevice = VkPhysicalDevice
  { VkPhysicalDevice -> Ptr VkPhysicalDevice_T
unwrap :: BG.Ptr VkPhysicalDevice_T
  }
  deriving stock ((forall x. VkPhysicalDevice -> Rep VkPhysicalDevice x)
-> (forall x. Rep VkPhysicalDevice x -> VkPhysicalDevice)
-> Generic VkPhysicalDevice
forall x. Rep VkPhysicalDevice x -> VkPhysicalDevice
forall x. VkPhysicalDevice -> Rep VkPhysicalDevice x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. VkPhysicalDevice -> Rep VkPhysicalDevice x
from :: forall x. VkPhysicalDevice -> Rep VkPhysicalDevice x
$cto :: forall x. Rep VkPhysicalDevice x -> VkPhysicalDevice
to :: forall x. Rep VkPhysicalDevice x -> VkPhysicalDevice
BG.Generic, VkPhysicalDevice -> VkPhysicalDevice -> Bool
(VkPhysicalDevice -> VkPhysicalDevice -> Bool)
-> (VkPhysicalDevice -> VkPhysicalDevice -> Bool)
-> Eq VkPhysicalDevice
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: VkPhysicalDevice -> VkPhysicalDevice -> Bool
== :: VkPhysicalDevice -> VkPhysicalDevice -> Bool
$c/= :: VkPhysicalDevice -> VkPhysicalDevice -> Bool
/= :: VkPhysicalDevice -> VkPhysicalDevice -> Bool
Eq, Eq VkPhysicalDevice
Eq VkPhysicalDevice =>
(VkPhysicalDevice -> VkPhysicalDevice -> Ordering)
-> (VkPhysicalDevice -> VkPhysicalDevice -> Bool)
-> (VkPhysicalDevice -> VkPhysicalDevice -> Bool)
-> (VkPhysicalDevice -> VkPhysicalDevice -> Bool)
-> (VkPhysicalDevice -> VkPhysicalDevice -> Bool)
-> (VkPhysicalDevice -> VkPhysicalDevice -> VkPhysicalDevice)
-> (VkPhysicalDevice -> VkPhysicalDevice -> VkPhysicalDevice)
-> Ord VkPhysicalDevice
VkPhysicalDevice -> VkPhysicalDevice -> Bool
VkPhysicalDevice -> VkPhysicalDevice -> Ordering
VkPhysicalDevice -> VkPhysicalDevice -> VkPhysicalDevice
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: VkPhysicalDevice -> VkPhysicalDevice -> Ordering
compare :: VkPhysicalDevice -> VkPhysicalDevice -> Ordering
$c< :: VkPhysicalDevice -> VkPhysicalDevice -> Bool
< :: VkPhysicalDevice -> VkPhysicalDevice -> Bool
$c<= :: VkPhysicalDevice -> VkPhysicalDevice -> Bool
<= :: VkPhysicalDevice -> VkPhysicalDevice -> Bool
$c> :: VkPhysicalDevice -> VkPhysicalDevice -> Bool
> :: VkPhysicalDevice -> VkPhysicalDevice -> Bool
$c>= :: VkPhysicalDevice -> VkPhysicalDevice -> Bool
>= :: VkPhysicalDevice -> VkPhysicalDevice -> Bool
$cmax :: VkPhysicalDevice -> VkPhysicalDevice -> VkPhysicalDevice
max :: VkPhysicalDevice -> VkPhysicalDevice -> VkPhysicalDevice
$cmin :: VkPhysicalDevice -> VkPhysicalDevice -> VkPhysicalDevice
min :: VkPhysicalDevice -> VkPhysicalDevice -> VkPhysicalDevice
Ord, Int -> VkPhysicalDevice -> ShowS
[VkPhysicalDevice] -> ShowS
VkPhysicalDevice -> String
(Int -> VkPhysicalDevice -> ShowS)
-> (VkPhysicalDevice -> String)
-> ([VkPhysicalDevice] -> ShowS)
-> Show VkPhysicalDevice
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> VkPhysicalDevice -> ShowS
showsPrec :: Int -> VkPhysicalDevice -> ShowS
$cshow :: VkPhysicalDevice -> String
show :: VkPhysicalDevice -> String
$cshowList :: [VkPhysicalDevice] -> ShowS
showList :: [VkPhysicalDevice] -> ShowS
Show)
  deriving newtype
    ( FFIType VkPhysicalDevice -> VkPhysicalDevice
VkPhysicalDevice -> FFIType VkPhysicalDevice
(VkPhysicalDevice -> FFIType VkPhysicalDevice)
-> (FFIType VkPhysicalDevice -> VkPhysicalDevice)
-> HasFFIType VkPhysicalDevice
forall a. (a -> FFIType a) -> (FFIType a -> a) -> HasFFIType a
$ctoFFIType :: VkPhysicalDevice -> FFIType VkPhysicalDevice
toFFIType :: VkPhysicalDevice -> FFIType VkPhysicalDevice
$cfromFFIType :: FFIType VkPhysicalDevice -> VkPhysicalDevice
fromFFIType :: FFIType VkPhysicalDevice -> VkPhysicalDevice
BG.HasFFIType
    , Ptr VkPhysicalDevice -> IO VkPhysicalDevice
Ptr VkPhysicalDevice -> Int -> IO VkPhysicalDevice
Ptr VkPhysicalDevice -> Int -> VkPhysicalDevice -> IO ()
Ptr VkPhysicalDevice -> VkPhysicalDevice -> IO ()
VkPhysicalDevice -> Int
(VkPhysicalDevice -> Int)
-> (VkPhysicalDevice -> Int)
-> (Ptr VkPhysicalDevice -> Int -> IO VkPhysicalDevice)
-> (Ptr VkPhysicalDevice -> Int -> VkPhysicalDevice -> IO ())
-> (forall b. Ptr b -> Int -> IO VkPhysicalDevice)
-> (forall b. Ptr b -> Int -> VkPhysicalDevice -> IO ())
-> (Ptr VkPhysicalDevice -> IO VkPhysicalDevice)
-> (Ptr VkPhysicalDevice -> VkPhysicalDevice -> IO ())
-> Storable VkPhysicalDevice
forall b. Ptr b -> Int -> IO VkPhysicalDevice
forall b. Ptr b -> Int -> VkPhysicalDevice -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
$csizeOf :: VkPhysicalDevice -> Int
sizeOf :: VkPhysicalDevice -> Int
$calignment :: VkPhysicalDevice -> Int
alignment :: VkPhysicalDevice -> Int
$cpeekElemOff :: Ptr VkPhysicalDevice -> Int -> IO VkPhysicalDevice
peekElemOff :: Ptr VkPhysicalDevice -> Int -> IO VkPhysicalDevice
$cpokeElemOff :: Ptr VkPhysicalDevice -> Int -> VkPhysicalDevice -> IO ()
pokeElemOff :: Ptr VkPhysicalDevice -> Int -> VkPhysicalDevice -> IO ()
$cpeekByteOff :: forall b. Ptr b -> Int -> IO VkPhysicalDevice
peekByteOff :: forall b. Ptr b -> Int -> IO VkPhysicalDevice
$cpokeByteOff :: forall b. Ptr b -> Int -> VkPhysicalDevice -> IO ()
pokeByteOff :: forall b. Ptr b -> Int -> VkPhysicalDevice -> IO ()
$cpeek :: Ptr VkPhysicalDevice -> IO VkPhysicalDevice
peek :: Ptr VkPhysicalDevice -> IO VkPhysicalDevice
$cpoke :: Ptr VkPhysicalDevice -> VkPhysicalDevice -> IO ()
poke :: Ptr VkPhysicalDevice -> VkPhysicalDevice -> IO ()
BG.Storable
    , Ptr VkPhysicalDevice -> IO VkPhysicalDevice
(Ptr VkPhysicalDevice -> IO VkPhysicalDevice)
-> ReadRaw VkPhysicalDevice
forall a. (Ptr a -> IO a) -> ReadRaw a
$creadRaw :: Ptr VkPhysicalDevice -> IO VkPhysicalDevice
readRaw :: Ptr VkPhysicalDevice -> IO VkPhysicalDevice
Marshal.ReadRaw
    , Proxy VkPhysicalDevice -> Int
(Proxy VkPhysicalDevice -> Int)
-> (Proxy VkPhysicalDevice -> Int) -> StaticSize VkPhysicalDevice
forall a. (Proxy a -> Int) -> (Proxy a -> Int) -> StaticSize a
$cstaticSizeOf :: Proxy VkPhysicalDevice -> Int
staticSizeOf :: Proxy VkPhysicalDevice -> Int
$cstaticAlignment :: Proxy VkPhysicalDevice -> Int
staticAlignment :: Proxy VkPhysicalDevice -> Int
Marshal.StaticSize
    , Ptr VkPhysicalDevice -> VkPhysicalDevice -> IO ()
(Ptr VkPhysicalDevice -> VkPhysicalDevice -> IO ())
-> WriteRaw VkPhysicalDevice
forall a. (Ptr a -> a -> IO ()) -> WriteRaw a
$cwriteRaw :: Ptr VkPhysicalDevice -> VkPhysicalDevice -> IO ()
writeRaw :: Ptr VkPhysicalDevice -> VkPhysicalDevice -> IO ()
Marshal.WriteRaw
    )

instance
  (ty ~ BG.Ptr VkPhysicalDevice_T)
  => BG.CompatHasField.HasField "unwrap" VkPhysicalDevice ty
  where
  hasField :: VkPhysicalDevice -> (ty -> VkPhysicalDevice, ty)
hasField =
    \VkPhysicalDevice
x0 ->
      ( \ty
y1 ->
          VkPhysicalDevice{unwrap :: Ptr VkPhysicalDevice_T
unwrap = ty
Ptr VkPhysicalDevice_T
y1}
      , forall {k} (x :: k) r a. HasField x r a => r -> a
forall (x :: Symbol) r a. HasField x r a => r -> a
BG.getField @"unwrap" VkPhysicalDevice
x0
      )

instance
  (ty ~ BG.Ptr VkPhysicalDevice_T)
  => BG.HasField "unwrap" (BG.Ptr VkPhysicalDevice) (BG.Ptr ty)
  where
  getField :: Ptr VkPhysicalDevice -> Ptr ty
getField = Proxy "unwrap"
-> Ptr VkPhysicalDevice
-> Ptr (CFieldType VkPhysicalDevice "unwrap")
forall a (field :: Symbol).
HasCField a field =>
Proxy field -> Ptr a -> Ptr (CFieldType a field)
HasCField.fromPtr (forall {k} (t :: k). Proxy t
forall (t :: Symbol). Proxy t
BG.Proxy @"unwrap")

instance HasCField.HasCField VkPhysicalDevice "unwrap" where
  type
    CFieldType VkPhysicalDevice "unwrap" =
      BG.Ptr VkPhysicalDevice_T

  offset# :: Proxy# VkPhysicalDevice -> Proxy# "unwrap" -> Int
offset# = \Proxy# VkPhysicalDevice
_ -> \Proxy# "unwrap"
_ -> Int
0

-- | [C declaration]: @struct VkPhysicalDevice_T@, defined at @SDL3\/SDL_vulkan.h 68:1@
data VkPhysicalDevice_T

-- | [C declaration]: @VkSurfaceKHR@, defined at @SDL3\/SDL_vulkan.h 69:1@
newtype VkSurfaceKHR = VkSurfaceKHR
  { VkSurfaceKHR -> Ptr VkSurfaceKHR_T
unwrap :: BG.Ptr VkSurfaceKHR_T
  }
  deriving stock ((forall x. VkSurfaceKHR -> Rep VkSurfaceKHR x)
-> (forall x. Rep VkSurfaceKHR x -> VkSurfaceKHR)
-> Generic VkSurfaceKHR
forall x. Rep VkSurfaceKHR x -> VkSurfaceKHR
forall x. VkSurfaceKHR -> Rep VkSurfaceKHR x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. VkSurfaceKHR -> Rep VkSurfaceKHR x
from :: forall x. VkSurfaceKHR -> Rep VkSurfaceKHR x
$cto :: forall x. Rep VkSurfaceKHR x -> VkSurfaceKHR
to :: forall x. Rep VkSurfaceKHR x -> VkSurfaceKHR
BG.Generic, VkSurfaceKHR -> VkSurfaceKHR -> Bool
(VkSurfaceKHR -> VkSurfaceKHR -> Bool)
-> (VkSurfaceKHR -> VkSurfaceKHR -> Bool) -> Eq VkSurfaceKHR
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: VkSurfaceKHR -> VkSurfaceKHR -> Bool
== :: VkSurfaceKHR -> VkSurfaceKHR -> Bool
$c/= :: VkSurfaceKHR -> VkSurfaceKHR -> Bool
/= :: VkSurfaceKHR -> VkSurfaceKHR -> Bool
Eq, Eq VkSurfaceKHR
Eq VkSurfaceKHR =>
(VkSurfaceKHR -> VkSurfaceKHR -> Ordering)
-> (VkSurfaceKHR -> VkSurfaceKHR -> Bool)
-> (VkSurfaceKHR -> VkSurfaceKHR -> Bool)
-> (VkSurfaceKHR -> VkSurfaceKHR -> Bool)
-> (VkSurfaceKHR -> VkSurfaceKHR -> Bool)
-> (VkSurfaceKHR -> VkSurfaceKHR -> VkSurfaceKHR)
-> (VkSurfaceKHR -> VkSurfaceKHR -> VkSurfaceKHR)
-> Ord VkSurfaceKHR
VkSurfaceKHR -> VkSurfaceKHR -> Bool
VkSurfaceKHR -> VkSurfaceKHR -> Ordering
VkSurfaceKHR -> VkSurfaceKHR -> VkSurfaceKHR
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: VkSurfaceKHR -> VkSurfaceKHR -> Ordering
compare :: VkSurfaceKHR -> VkSurfaceKHR -> Ordering
$c< :: VkSurfaceKHR -> VkSurfaceKHR -> Bool
< :: VkSurfaceKHR -> VkSurfaceKHR -> Bool
$c<= :: VkSurfaceKHR -> VkSurfaceKHR -> Bool
<= :: VkSurfaceKHR -> VkSurfaceKHR -> Bool
$c> :: VkSurfaceKHR -> VkSurfaceKHR -> Bool
> :: VkSurfaceKHR -> VkSurfaceKHR -> Bool
$c>= :: VkSurfaceKHR -> VkSurfaceKHR -> Bool
>= :: VkSurfaceKHR -> VkSurfaceKHR -> Bool
$cmax :: VkSurfaceKHR -> VkSurfaceKHR -> VkSurfaceKHR
max :: VkSurfaceKHR -> VkSurfaceKHR -> VkSurfaceKHR
$cmin :: VkSurfaceKHR -> VkSurfaceKHR -> VkSurfaceKHR
min :: VkSurfaceKHR -> VkSurfaceKHR -> VkSurfaceKHR
Ord, Int -> VkSurfaceKHR -> ShowS
[VkSurfaceKHR] -> ShowS
VkSurfaceKHR -> String
(Int -> VkSurfaceKHR -> ShowS)
-> (VkSurfaceKHR -> String)
-> ([VkSurfaceKHR] -> ShowS)
-> Show VkSurfaceKHR
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> VkSurfaceKHR -> ShowS
showsPrec :: Int -> VkSurfaceKHR -> ShowS
$cshow :: VkSurfaceKHR -> String
show :: VkSurfaceKHR -> String
$cshowList :: [VkSurfaceKHR] -> ShowS
showList :: [VkSurfaceKHR] -> ShowS
Show)
  deriving newtype
    ( FFIType VkSurfaceKHR -> VkSurfaceKHR
VkSurfaceKHR -> FFIType VkSurfaceKHR
(VkSurfaceKHR -> FFIType VkSurfaceKHR)
-> (FFIType VkSurfaceKHR -> VkSurfaceKHR)
-> HasFFIType VkSurfaceKHR
forall a. (a -> FFIType a) -> (FFIType a -> a) -> HasFFIType a
$ctoFFIType :: VkSurfaceKHR -> FFIType VkSurfaceKHR
toFFIType :: VkSurfaceKHR -> FFIType VkSurfaceKHR
$cfromFFIType :: FFIType VkSurfaceKHR -> VkSurfaceKHR
fromFFIType :: FFIType VkSurfaceKHR -> VkSurfaceKHR
BG.HasFFIType
    , Ptr VkSurfaceKHR -> IO VkSurfaceKHR
Ptr VkSurfaceKHR -> Int -> IO VkSurfaceKHR
Ptr VkSurfaceKHR -> Int -> VkSurfaceKHR -> IO ()
Ptr VkSurfaceKHR -> VkSurfaceKHR -> IO ()
VkSurfaceKHR -> Int
(VkSurfaceKHR -> Int)
-> (VkSurfaceKHR -> Int)
-> (Ptr VkSurfaceKHR -> Int -> IO VkSurfaceKHR)
-> (Ptr VkSurfaceKHR -> Int -> VkSurfaceKHR -> IO ())
-> (forall b. Ptr b -> Int -> IO VkSurfaceKHR)
-> (forall b. Ptr b -> Int -> VkSurfaceKHR -> IO ())
-> (Ptr VkSurfaceKHR -> IO VkSurfaceKHR)
-> (Ptr VkSurfaceKHR -> VkSurfaceKHR -> IO ())
-> Storable VkSurfaceKHR
forall b. Ptr b -> Int -> IO VkSurfaceKHR
forall b. Ptr b -> Int -> VkSurfaceKHR -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
$csizeOf :: VkSurfaceKHR -> Int
sizeOf :: VkSurfaceKHR -> Int
$calignment :: VkSurfaceKHR -> Int
alignment :: VkSurfaceKHR -> Int
$cpeekElemOff :: Ptr VkSurfaceKHR -> Int -> IO VkSurfaceKHR
peekElemOff :: Ptr VkSurfaceKHR -> Int -> IO VkSurfaceKHR
$cpokeElemOff :: Ptr VkSurfaceKHR -> Int -> VkSurfaceKHR -> IO ()
pokeElemOff :: Ptr VkSurfaceKHR -> Int -> VkSurfaceKHR -> IO ()
$cpeekByteOff :: forall b. Ptr b -> Int -> IO VkSurfaceKHR
peekByteOff :: forall b. Ptr b -> Int -> IO VkSurfaceKHR
$cpokeByteOff :: forall b. Ptr b -> Int -> VkSurfaceKHR -> IO ()
pokeByteOff :: forall b. Ptr b -> Int -> VkSurfaceKHR -> IO ()
$cpeek :: Ptr VkSurfaceKHR -> IO VkSurfaceKHR
peek :: Ptr VkSurfaceKHR -> IO VkSurfaceKHR
$cpoke :: Ptr VkSurfaceKHR -> VkSurfaceKHR -> IO ()
poke :: Ptr VkSurfaceKHR -> VkSurfaceKHR -> IO ()
BG.Storable
    , Ptr VkSurfaceKHR -> IO VkSurfaceKHR
(Ptr VkSurfaceKHR -> IO VkSurfaceKHR) -> ReadRaw VkSurfaceKHR
forall a. (Ptr a -> IO a) -> ReadRaw a
$creadRaw :: Ptr VkSurfaceKHR -> IO VkSurfaceKHR
readRaw :: Ptr VkSurfaceKHR -> IO VkSurfaceKHR
Marshal.ReadRaw
    , Proxy VkSurfaceKHR -> Int
(Proxy VkSurfaceKHR -> Int)
-> (Proxy VkSurfaceKHR -> Int) -> StaticSize VkSurfaceKHR
forall a. (Proxy a -> Int) -> (Proxy a -> Int) -> StaticSize a
$cstaticSizeOf :: Proxy VkSurfaceKHR -> Int
staticSizeOf :: Proxy VkSurfaceKHR -> Int
$cstaticAlignment :: Proxy VkSurfaceKHR -> Int
staticAlignment :: Proxy VkSurfaceKHR -> Int
Marshal.StaticSize
    , Ptr VkSurfaceKHR -> VkSurfaceKHR -> IO ()
(Ptr VkSurfaceKHR -> VkSurfaceKHR -> IO ())
-> WriteRaw VkSurfaceKHR
forall a. (Ptr a -> a -> IO ()) -> WriteRaw a
$cwriteRaw :: Ptr VkSurfaceKHR -> VkSurfaceKHR -> IO ()
writeRaw :: Ptr VkSurfaceKHR -> VkSurfaceKHR -> IO ()
Marshal.WriteRaw
    )

instance
  (ty ~ BG.Ptr VkSurfaceKHR_T)
  => BG.CompatHasField.HasField "unwrap" VkSurfaceKHR ty
  where
  hasField :: VkSurfaceKHR -> (ty -> VkSurfaceKHR, ty)
hasField =
    \VkSurfaceKHR
x0 ->
      ( \ty
y1 ->
          VkSurfaceKHR{unwrap :: Ptr VkSurfaceKHR_T
unwrap = ty
Ptr VkSurfaceKHR_T
y1}
      , forall {k} (x :: k) r a. HasField x r a => r -> a
forall (x :: Symbol) r a. HasField x r a => r -> a
BG.getField @"unwrap" VkSurfaceKHR
x0
      )

instance
  (ty ~ BG.Ptr VkSurfaceKHR_T)
  => BG.HasField "unwrap" (BG.Ptr VkSurfaceKHR) (BG.Ptr ty)
  where
  getField :: Ptr VkSurfaceKHR -> Ptr ty
getField = Proxy "unwrap"
-> Ptr VkSurfaceKHR -> Ptr (CFieldType VkSurfaceKHR "unwrap")
forall a (field :: Symbol).
HasCField a field =>
Proxy field -> Ptr a -> Ptr (CFieldType a field)
HasCField.fromPtr (forall {k} (t :: k). Proxy t
forall (t :: Symbol). Proxy t
BG.Proxy @"unwrap")

instance HasCField.HasCField VkSurfaceKHR "unwrap" where
  type
    CFieldType VkSurfaceKHR "unwrap" =
      BG.Ptr VkSurfaceKHR_T

  offset# :: Proxy# VkSurfaceKHR -> Proxy# "unwrap" -> Int
offset# = \Proxy# VkSurfaceKHR
_ -> \Proxy# "unwrap"
_ -> Int
0

-- | [C declaration]: @struct VkSurfaceKHR_T@, defined at @SDL3\/SDL_vulkan.h 69:1@
data VkSurfaceKHR_T

-- | [C declaration]: @struct VkAllocationCallbacks@, defined at @SDL3\/SDL_vulkan.h 70:8@
data VkAllocationCallbacks