content: {-# OPTIONS_HADDOCK ignore-exports#-}
  {-# LANGUAGE DataKinds                  #-}
  {-# LANGUAGE FlexibleInstances          #-}
  {-# LANGUAGE GeneralizedNewtypeDeriving #-}
  {-# LANGUAGE KindSignatures             #-}
  {-# LANGUAGE PatternSynonyms            #-}
  {-# LANGUAGE StandaloneDeriving         #-}
  {-# LANGUAGE Strict                     #-}
  {-# LANGUAGE TypeSynonymInstances       #-}
  module Graphics.Vulkan.Types.Enum.Memory
         (VkMemoryAllocateFlagBitsKHR(..),
          VkMemoryAllocateBitmask(VkMemoryAllocateBitmask,
                                  VkMemoryAllocateFlags, VkMemoryAllocateFlagBits,
                                  VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT),
          VkMemoryAllocateFlags, VkMemoryAllocateFlagBits,
          VkMemoryHeapBitmask(VkMemoryHeapBitmask, VkMemoryHeapFlags,
                              VkMemoryHeapFlagBits, VK_MEMORY_HEAP_DEVICE_LOCAL_BIT),
          VkMemoryHeapFlags, VkMemoryHeapFlagBits,
          VkMemoryOverallocationBehaviorAMD(VkMemoryOverallocationBehaviorAMD,
                                            VK_MEMORY_OVERALLOCATION_BEHAVIOR_DEFAULT_AMD,
                                            VK_MEMORY_OVERALLOCATION_BEHAVIOR_ALLOWED_AMD,
                                            VK_MEMORY_OVERALLOCATION_BEHAVIOR_DISALLOWED_AMD),
          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.Coerce                     (coerce)
  import Foreign.Storable                (Storable)
  import GHC.Read                        (choose, expectP)
  import Graphics.Vulkan.Marshal         (FlagBit, FlagMask, FlagType, Int32)
  import Graphics.Vulkan.Types.BaseTypes (VkFlags (..))
  import Text.ParserCombinators.ReadPrec (prec, step, (+++))
  import Text.Read                       (Read (..), parens)
  import Text.Read.Lex                   (Lexeme (..))
  
  newtype VkMemoryAllocateFlagBitsKHR = VkMemoryAllocateFlagBitsKHR VkFlags
                                        deriving (Eq, Ord, Enum, Bits, FiniteBits, Storable)
  
  instance Show VkMemoryAllocateFlagBitsKHR where
      {-# INLINE showsPrec #-}
      showsPrec = coerce (showsPrec :: Int -> VkFlags -> ShowS)
  
  instance Read VkMemoryAllocateFlagBitsKHR where
      {-# INLINE readsPrec #-}
      readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags)
  
  newtype VkMemoryAllocateBitmask (a ::
                                     FlagType) = VkMemoryAllocateBitmask VkFlags
                                                 deriving (Eq, Ord, Storable)
  
  type VkMemoryAllocateFlags = VkMemoryAllocateBitmask FlagMask
  
  type VkMemoryAllocateFlagBits = VkMemoryAllocateBitmask FlagBit
  
  pattern VkMemoryAllocateFlagBits ::
          VkFlags -> VkMemoryAllocateBitmask FlagBit
  
  pattern VkMemoryAllocateFlagBits n = VkMemoryAllocateBitmask n
  
  pattern VkMemoryAllocateFlags ::
          VkFlags -> VkMemoryAllocateBitmask FlagMask
  
  pattern VkMemoryAllocateFlags n = VkMemoryAllocateBitmask n
  
  deriving instance Bits (VkMemoryAllocateBitmask FlagMask)
  
  deriving instance FiniteBits (VkMemoryAllocateBitmask FlagMask)
  
  instance Show (VkMemoryAllocateBitmask a) where
      showsPrec _ VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT
        = showString "VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT"
      showsPrec p (VkMemoryAllocateBitmask x)
        = showParen (p >= 11)
            (showString "VkMemoryAllocateBitmask " . showsPrec 11 x)
  
  instance Read (VkMemoryAllocateBitmask a) where
      readPrec
        = parens
            (choose
               [("VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT",
                 pure VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT)]
               +++
               prec 10
                 (expectP (Ident "VkMemoryAllocateBitmask") >>
                    (VkMemoryAllocateBitmask <$> step readPrec)))
  
  -- | Force allocation on specific devices
  --
  --   bitpos = @0@
  pattern VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT ::
          VkMemoryAllocateBitmask a
  
  pattern VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT =
          VkMemoryAllocateBitmask 1
  
  newtype VkMemoryHeapBitmask (a ::
                                 FlagType) = VkMemoryHeapBitmask VkFlags
                                             deriving (Eq, Ord, Storable)
  
  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)
  
  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
  
  -- | type = @enum@
  --
  --   <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#VkMemoryOverallocationBehaviorAMD VkMemoryOverallocationBehaviorAMD registry at www.khronos.org>
  newtype VkMemoryOverallocationBehaviorAMD = VkMemoryOverallocationBehaviorAMD Int32
                                              deriving (Eq, Ord, Enum, Storable)
  
  instance Show VkMemoryOverallocationBehaviorAMD where
      showsPrec _ VK_MEMORY_OVERALLOCATION_BEHAVIOR_DEFAULT_AMD
        = showString "VK_MEMORY_OVERALLOCATION_BEHAVIOR_DEFAULT_AMD"
      showsPrec _ VK_MEMORY_OVERALLOCATION_BEHAVIOR_ALLOWED_AMD
        = showString "VK_MEMORY_OVERALLOCATION_BEHAVIOR_ALLOWED_AMD"
      showsPrec _ VK_MEMORY_OVERALLOCATION_BEHAVIOR_DISALLOWED_AMD
        = showString "VK_MEMORY_OVERALLOCATION_BEHAVIOR_DISALLOWED_AMD"
      showsPrec p (VkMemoryOverallocationBehaviorAMD x)
        = showParen (p >= 11)
            (showString "VkMemoryOverallocationBehaviorAMD " . showsPrec 11 x)
  
  instance Read VkMemoryOverallocationBehaviorAMD where
      readPrec
        = parens
            (choose
               [("VK_MEMORY_OVERALLOCATION_BEHAVIOR_DEFAULT_AMD",
                 pure VK_MEMORY_OVERALLOCATION_BEHAVIOR_DEFAULT_AMD),
                ("VK_MEMORY_OVERALLOCATION_BEHAVIOR_ALLOWED_AMD",
                 pure VK_MEMORY_OVERALLOCATION_BEHAVIOR_ALLOWED_AMD),
                ("VK_MEMORY_OVERALLOCATION_BEHAVIOR_DISALLOWED_AMD",
                 pure VK_MEMORY_OVERALLOCATION_BEHAVIOR_DISALLOWED_AMD)]
               +++
               prec 10
                 (expectP (Ident "VkMemoryOverallocationBehaviorAMD") >>
                    (VkMemoryOverallocationBehaviorAMD <$> step readPrec)))
  
  pattern VK_MEMORY_OVERALLOCATION_BEHAVIOR_DEFAULT_AMD ::
          VkMemoryOverallocationBehaviorAMD
  
  pattern VK_MEMORY_OVERALLOCATION_BEHAVIOR_DEFAULT_AMD =
          VkMemoryOverallocationBehaviorAMD 0
  
  pattern VK_MEMORY_OVERALLOCATION_BEHAVIOR_ALLOWED_AMD ::
          VkMemoryOverallocationBehaviorAMD
  
  pattern VK_MEMORY_OVERALLOCATION_BEHAVIOR_ALLOWED_AMD =
          VkMemoryOverallocationBehaviorAMD 1
  
  pattern VK_MEMORY_OVERALLOCATION_BEHAVIOR_DISALLOWED_AMD ::
          VkMemoryOverallocationBehaviorAMD
  
  pattern VK_MEMORY_OVERALLOCATION_BEHAVIOR_DISALLOWED_AMD =
          VkMemoryOverallocationBehaviorAMD 2
  
  newtype VkMemoryPropertyBitmask (a ::
                                     FlagType) = VkMemoryPropertyBitmask VkFlags
                                                 deriving (Eq, Ord, Storable)
  
  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)
  
  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
  