content: {-# language CPP #-}
  -- | = Name
  --
  -- XR_KHR_visibility_mask - instance extension
  --
  -- = Specification
  --
  -- See
  -- <https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_KHR_visibility_mask  XR_KHR_visibility_mask>
  -- in the main specification for complete information.
  --
  -- = Registered Extension Number
  --
  -- 32
  --
  -- = Revision
  --
  -- 2
  --
  -- = Extension and Version Dependencies
  --
  -- -   Requires OpenXR 1.0
  --
  -- = See Also
  --
  -- 'EventDataVisibilityMaskChangedKHR', 'VisibilityMaskKHR',
  -- 'VisibilityMaskTypeKHR', 'getVisibilityMaskKHR'
  --
  -- = Document Notes
  --
  -- For more information, see the
  -- <https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_KHR_visibility_mask OpenXR Specification>
  --
  -- This page is a generated document. Fixes and changes should be made to
  -- the generator scripts, not directly.
  module OpenXR.Extensions.XR_KHR_visibility_mask  ( getVisibilityMaskKHR
                                                   , EventDataVisibilityMaskChangedKHR(..)
                                                   , VisibilityMaskKHR(..)
                                                   , VisibilityMaskTypeKHR( VISIBILITY_MASK_TYPE_HIDDEN_TRIANGLE_MESH_KHR
                                                                          , VISIBILITY_MASK_TYPE_VISIBLE_TRIANGLE_MESH_KHR
                                                                          , VISIBILITY_MASK_TYPE_LINE_LOOP_KHR
                                                                          , ..
                                                                          )
                                                   , KHR_visibility_mask_SPEC_VERSION
                                                   , pattern KHR_visibility_mask_SPEC_VERSION
                                                   , KHR_VISIBILITY_MASK_EXTENSION_NAME
                                                   , pattern KHR_VISIBILITY_MASK_EXTENSION_NAME
                                                   ) where
  
  import OpenXR.Internal.Utils (enumReadPrec)
  import OpenXR.Internal.Utils (enumShowsPrec)
  import OpenXR.Internal.Utils (traceAroundEvent)
  import Control.Monad (unless)
  import Control.Monad.IO.Class (liftIO)
  import Foreign.Marshal.Alloc (allocaBytes)
  import GHC.Base (when)
  import GHC.IO (throwIO)
  import GHC.Ptr (nullFunPtr)
  import Foreign.Ptr (nullPtr)
  import Foreign.Ptr (plusPtr)
  import GHC.Show (showsPrec)
  import Control.Monad.Trans.Class (lift)
  import Control.Monad.Trans.Cont (evalContT)
  import OpenXR.CStruct (FromCStruct)
  import OpenXR.CStruct (FromCStruct(..))
  import OpenXR.CStruct (ToCStruct)
  import OpenXR.CStruct (ToCStruct(..))
  import OpenXR.Zero (Zero)
  import OpenXR.Zero (Zero(..))
  import Control.Monad.IO.Class (MonadIO)
  import Data.String (IsString)
  import Data.Typeable (Typeable)
  import Foreign.Storable (Storable)
  import Foreign.Storable (Storable(peek))
  import Foreign.Storable (Storable(poke))
  import qualified Foreign.Storable (Storable(..))
  import GHC.Generics (Generic)
  import GHC.IO.Exception (IOErrorType(..))
  import GHC.IO.Exception (IOException(..))
  import Data.Int (Int32)
  import Foreign.Ptr (FunPtr)
  import Foreign.Ptr (Ptr)
  import GHC.Read (Read(readPrec))
  import GHC.Show (Show(showsPrec))
  import Data.Word (Word32)
  import Data.Kind (Type)
  import Control.Monad.Trans.Cont (ContT(..))
  import OpenXR.NamedType ((:::))
  import OpenXR.Core10.OtherTypes (EventDataBaseHeader(..))
  import OpenXR.Dynamic (InstanceCmds(pXrGetVisibilityMaskKHR))
  import OpenXR.Core10.OtherTypes (IsEventData(..))
  import OpenXR.Exception (OpenXrException(..))
  import OpenXR.Core10.Enums.Result (Result)
  import OpenXR.Core10.Enums.Result (Result(..))
  import OpenXR.Core10.Handles (Session)
  import OpenXR.Core10.Handles (Session(..))
  import OpenXR.Core10.Handles (Session(Session))
  import OpenXR.Core10.Handles (Session_T)
  import OpenXR.Core10.Enums.StructureType (StructureType)
  import OpenXR.Core10.Input (Vector2f)
  import OpenXR.Core10.Enums.ViewConfigurationType (ViewConfigurationType)
  import OpenXR.Core10.Enums.ViewConfigurationType (ViewConfigurationType(..))
  import OpenXR.Core10.Enums.Result (Result(SUCCESS))
  import OpenXR.Core10.Enums.StructureType (StructureType(TYPE_EVENT_DATA_VISIBILITY_MASK_CHANGED_KHR))
  import OpenXR.Core10.Enums.StructureType (StructureType(TYPE_VISIBILITY_MASK_KHR))
  foreign import ccall
  #if !defined(SAFE_FOREIGN_CALLS)
    unsafe
  #endif
    "dynamic" mkXrGetVisibilityMaskKHR
    :: FunPtr (Ptr Session_T -> ViewConfigurationType -> Word32 -> VisibilityMaskTypeKHR -> Ptr VisibilityMaskKHR -> IO Result) -> Ptr Session_T -> ViewConfigurationType -> Word32 -> VisibilityMaskTypeKHR -> Ptr VisibilityMaskKHR -> IO Result
  
  -- | xrGetVisibilityMaskKHR - Gets visibility mask
  --
  -- == Parameter Descriptions
  --
  -- = Description
  --
  -- 'getVisibilityMaskKHR' retrieves the view mask for a given view. This
  -- function follows the
  -- <https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#buffer-size-parameters two-call idiom>
  -- for filling multiple buffers in a struct. Specifically, if either
  -- @vertexCapacityInput@ or @indexCapacityInput@ is @0@, the runtime /must/
  -- respond as if both fields were set to @0@, returning the vertex count
  -- and index count through @vertexCountOutput@ or @indexCountOutput@
  -- respectively. If a view mask for the specified view isn’t available, the
  -- returned vertex and index counts /must/ be @0@.
  --
  -- == Valid Usage (Implicit)
  --
  -- -   #VUID-xrGetVisibilityMaskKHR-extension-notenabled# The
  --     @XR_KHR_visibility_mask@ extension /must/ be enabled prior to
  --     calling 'getVisibilityMaskKHR'
  --
  -- -   #VUID-xrGetVisibilityMaskKHR-session-parameter# @session@ /must/ be
  --     a valid 'OpenXR.Core10.Handles.Session' handle
  --
  -- -   #VUID-xrGetVisibilityMaskKHR-viewConfigurationType-parameter#
  --     @viewConfigurationType@ /must/ be a valid
  --     'OpenXR.Core10.Enums.ViewConfigurationType.ViewConfigurationType'
  --     value
  --
  -- -   #VUID-xrGetVisibilityMaskKHR-visibilityMaskType-parameter#
  --     @visibilityMaskType@ /must/ be a valid 'VisibilityMaskTypeKHR' value
  --
  -- -   #VUID-xrGetVisibilityMaskKHR-visibilityMask-parameter#
  --     @visibilityMask@ /must/ be a pointer to an 'VisibilityMaskKHR'
  --     structure
  --
  -- == Return Codes
  --
  -- [<https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#fundamentals-successcodes Success>]
  --
  --     -   'OpenXR.Core10.Enums.Result.SUCCESS'
  --
  --     -   'OpenXR.Core10.Enums.Result.SESSION_LOSS_PENDING'
  --
  -- [<https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#fundamentals-errorcodes Failure>]
  --
  --     -   'OpenXR.Core10.Enums.Result.ERROR_HANDLE_INVALID'
  --
  --     -   'OpenXR.Core10.Enums.Result.ERROR_INSTANCE_LOST'
  --
  --     -   'OpenXR.Core10.Enums.Result.ERROR_RUNTIME_FAILURE'
  --
  --     -   'OpenXR.Core10.Enums.Result.ERROR_VALIDATION_FAILURE'
  --
  --     -   'OpenXR.Core10.Enums.Result.ERROR_VIEW_CONFIGURATION_TYPE_UNSUPPORTED'
  --
  --     -   'OpenXR.Core10.Enums.Result.ERROR_SIZE_INSUFFICIENT'
  --
  --     -   'OpenXR.Core10.Enums.Result.ERROR_SESSION_LOST'
  --
  --     -   'OpenXR.Core10.Enums.Result.ERROR_FUNCTION_UNSUPPORTED'
  --
  -- = See Also
  --
  -- 'OpenXR.Core10.Handles.Session',
  -- 'OpenXR.Core10.Enums.ViewConfigurationType.ViewConfigurationType',
  -- 'VisibilityMaskKHR', 'VisibilityMaskTypeKHR'
  getVisibilityMaskKHR :: forall io
                        . (MonadIO io)
                       => -- | @session@ is an 'OpenXR.Core10.Handles.Session' handle previously
                          -- created with 'OpenXR.Core10.Device.createSession'.
                          Session
                       -> -- | @viewConfigurationType@ is the view configuration from which to retrieve
                          -- mask information.
                          ViewConfigurationType
                       -> -- | @viewIndex@ is the individual view within the view configuration from
                          -- which to retrieve mask information.
                          ("viewIndex" ::: Word32)
                       -> -- | @visibilityMaskType@ is the type of visibility mask requested.
                          VisibilityMaskTypeKHR
                       -> io (Result, VisibilityMaskKHR)
  getVisibilityMaskKHR session
                         viewConfigurationType
                         viewIndex
                         visibilityMaskType = liftIO . evalContT $ do
    let xrGetVisibilityMaskKHRPtr = pXrGetVisibilityMaskKHR (case session of Session{instanceCmds} -> instanceCmds)
    lift $ unless (xrGetVisibilityMaskKHRPtr /= nullFunPtr) $
      throwIO $ IOError Nothing InvalidArgument "" "The function pointer for xrGetVisibilityMaskKHR is null" Nothing Nothing
    let xrGetVisibilityMaskKHR' = mkXrGetVisibilityMaskKHR xrGetVisibilityMaskKHRPtr
    pVisibilityMask <- ContT (withZeroCStruct @VisibilityMaskKHR)
    r <- lift $ traceAroundEvent "xrGetVisibilityMaskKHR" (xrGetVisibilityMaskKHR'
                                                             (sessionHandle (session))
                                                             (viewConfigurationType)
                                                             (viewIndex)
                                                             (visibilityMaskType)
                                                             (pVisibilityMask))
    lift $ when (r < SUCCESS) (throwIO (OpenXrException r))
    visibilityMask <- lift $ peekCStruct @VisibilityMaskKHR pVisibilityMask
    pure $ (r, visibilityMask)
  
  
  -- | XrEventDataVisibilityMaskChangedKHR - Visibility Mask
  --
  -- == Valid Usage (Implicit)
  --
  -- -   #VUID-XrEventDataVisibilityMaskChangedKHR-extension-notenabled# The
  --     @XR_KHR_visibility_mask@ extension /must/ be enabled prior to using
  --     'EventDataVisibilityMaskChangedKHR'
  --
  -- -   #VUID-XrEventDataVisibilityMaskChangedKHR-type-type# @type@ /must/
  --     be
  --     'OpenXR.Core10.Enums.StructureType.TYPE_EVENT_DATA_VISIBILITY_MASK_CHANGED_KHR'
  --
  -- -   #VUID-XrEventDataVisibilityMaskChangedKHR-next-next# @next@ /must/
  --     be @NULL@ or a valid pointer to the
  --     <https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#valid-usage-for-structure-pointer-chains next structure in a structure chain>
  --
  -- -   #VUID-XrEventDataVisibilityMaskChangedKHR-session-parameter#
  --     @session@ /must/ be a valid 'OpenXR.Core10.Handles.Session' handle
  --
  -- -   #VUID-XrEventDataVisibilityMaskChangedKHR-viewConfigurationType-parameter#
  --     @viewConfigurationType@ /must/ be a valid
  --     'OpenXR.Core10.Enums.ViewConfigurationType.ViewConfigurationType'
  --     value
  --
  -- = See Also
  --
  -- 'OpenXR.Core10.Handles.Session',
  -- 'OpenXR.Core10.Enums.StructureType.StructureType',
  -- 'OpenXR.Core10.Enums.ViewConfigurationType.ViewConfigurationType'
  data EventDataVisibilityMaskChangedKHR = EventDataVisibilityMaskChangedKHR
    { -- | @session@ is the 'OpenXR.Core10.Handles.Session' for which the view mask
      -- has changed.
      session :: Ptr Session_T
    , -- | @viewConfigurationType@ is the view configuration whose mask has
      -- changed.
      viewConfigurationType :: ViewConfigurationType
    , -- | @viewIndex@ is the individual view within the view configuration to
      -- which the change refers.
      viewIndex :: Word32
    }
    deriving (Typeable, Eq)
  #if defined(GENERIC_INSTANCES)
  deriving instance Generic (EventDataVisibilityMaskChangedKHR)
  #endif
  deriving instance Show EventDataVisibilityMaskChangedKHR
  
  instance IsEventData EventDataVisibilityMaskChangedKHR where
    toEventDataBaseHeader EventDataVisibilityMaskChangedKHR{} = EventDataBaseHeader{type' = TYPE_EVENT_DATA_VISIBILITY_MASK_CHANGED_KHR}
  
  instance ToCStruct EventDataVisibilityMaskChangedKHR where
    withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
    pokeCStruct p EventDataVisibilityMaskChangedKHR{..} f = do
      poke ((p `plusPtr` 0 :: Ptr StructureType)) (TYPE_EVENT_DATA_VISIBILITY_MASK_CHANGED_KHR)
      poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
      poke ((p `plusPtr` 16 :: Ptr (Ptr Session_T))) (session)
      poke ((p `plusPtr` 24 :: Ptr ViewConfigurationType)) (viewConfigurationType)
      poke ((p `plusPtr` 28 :: Ptr Word32)) (viewIndex)
      f
    cStructSize = 32
    cStructAlignment = 8
    pokeZeroCStruct p f = do
      poke ((p `plusPtr` 0 :: Ptr StructureType)) (TYPE_EVENT_DATA_VISIBILITY_MASK_CHANGED_KHR)
      poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
      poke ((p `plusPtr` 16 :: Ptr (Ptr Session_T))) (zero)
      poke ((p `plusPtr` 24 :: Ptr ViewConfigurationType)) (zero)
      poke ((p `plusPtr` 28 :: Ptr Word32)) (zero)
      f
  
  instance FromCStruct EventDataVisibilityMaskChangedKHR where
    peekCStruct p = do
      session <- peek @(Ptr Session_T) ((p `plusPtr` 16 :: Ptr (Ptr Session_T)))
      viewConfigurationType <- peek @ViewConfigurationType ((p `plusPtr` 24 :: Ptr ViewConfigurationType))
      viewIndex <- peek @Word32 ((p `plusPtr` 28 :: Ptr Word32))
      pure $ EventDataVisibilityMaskChangedKHR
               session viewConfigurationType viewIndex
  
  instance Storable EventDataVisibilityMaskChangedKHR where
    sizeOf ~_ = 32
    alignment ~_ = 8
    peek = peekCStruct
    poke ptr poked = pokeCStruct ptr poked (pure ())
  
  instance Zero EventDataVisibilityMaskChangedKHR where
    zero = EventDataVisibilityMaskChangedKHR
             zero
             zero
             zero
  
  
  -- | XrVisibilityMaskKHR - Visibility Mask
  --
  -- == Member Descriptions
  --
  -- -   @type@ is the 'OpenXR.Core10.Enums.StructureType.StructureType' of
  --     this structure.
  --
  -- -   @next@ is @NULL@ or a pointer to the next structure in a structure
  --     chain. No such structures are defined in core OpenXR or this
  --     extension.
  --
  -- -   @vertexCapacityInput@ is the capacity of the @vertices@ array, or
  --     @0@ to indicate a request to retrieve the required capacity.
  --
  -- -   @vertexCountOutput@ is filled in by the runtime with the count of
  --     vertices written or the required capacity in the case that
  --     @vertexCapacityInput@ or @indexCapacityInput@ is @0@.
  --
  -- -   @vertices@ is an array of vertices filled in by the runtime that
  --     specifies mask coordinates in the z=-1 plane of the rendered
  --     view—​i.e., one meter in front of the view. When rendering the mask
  --     for use in a projection layer, these vertices must be transformed by
  --     the application’s projection matrix used for the respective
  --     'OpenXR.Core10.OtherTypes.CompositionLayerProjectionView'.
  --
  -- == Description
  --
  -- -   @indexCapacityInput@ is the capacity of the @indices@ array, or @0@
  --     to indicate a request to retrieve the required capacity.
  --
  -- -   @indexCountOutput@ is filled in by the runtime with the count of
  --     indices written or the required capacity in the case that
  --     @vertexCapacityInput@ or @indexCapacityInput@ is @0@.
  --
  -- -   @indices@ is an array of indices filled in by the runtime,
  --     specifying the indices of the mask geometry in the @vertices@ array.
  --
  -- == Valid Usage (Implicit)
  --
  -- -   #VUID-XrVisibilityMaskKHR-extension-notenabled# The
  --     @XR_KHR_visibility_mask@ extension /must/ be enabled prior to using
  --     'VisibilityMaskKHR'
  --
  -- -   #VUID-XrVisibilityMaskKHR-type-type# @type@ /must/ be
  --     'OpenXR.Core10.Enums.StructureType.TYPE_VISIBILITY_MASK_KHR'
  --
  -- -   #VUID-XrVisibilityMaskKHR-next-next# @next@ /must/ be @NULL@ or a
  --     valid pointer to the
  --     <https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#valid-usage-for-structure-pointer-chains next structure in a structure chain>
  --
  -- -   #VUID-XrVisibilityMaskKHR-vertices-parameter# If
  --     @vertexCapacityInput@ is not @0@, @vertices@ /must/ be a pointer to
  --     an array of @vertexCapacityInput@ 'OpenXR.Core10.Input.Vector2f'
  --     structures
  --
  -- -   #VUID-XrVisibilityMaskKHR-indices-parameter# If @indexCapacityInput@
  --     is not @0@, @indices@ /must/ be a pointer to an array of
  --     @indexCapacityInput@ @uint32_t@ values
  --
  -- = See Also
  --
  -- 'OpenXR.Core10.Enums.StructureType.StructureType',
  -- 'OpenXR.Core10.Input.Vector2f', 'getVisibilityMaskKHR'
  data VisibilityMaskKHR = VisibilityMaskKHR
    { -- No documentation found for Nested "XrVisibilityMaskKHR" "vertexCapacityInput"
      vertexCapacityInput :: Word32
    , -- No documentation found for Nested "XrVisibilityMaskKHR" "vertexCountOutput"
      vertexCountOutput :: Word32
    , -- No documentation found for Nested "XrVisibilityMaskKHR" "vertices"
      vertices :: Ptr Vector2f
    , -- No documentation found for Nested "XrVisibilityMaskKHR" "indexCapacityInput"
      indexCapacityInput :: Word32
    , -- No documentation found for Nested "XrVisibilityMaskKHR" "indexCountOutput"
      indexCountOutput :: Word32
    , -- No documentation found for Nested "XrVisibilityMaskKHR" "indices"
      indices :: Ptr Word32
    }
    deriving (Typeable, Eq)
  #if defined(GENERIC_INSTANCES)
  deriving instance Generic (VisibilityMaskKHR)
  #endif
  deriving instance Show VisibilityMaskKHR
  
  instance ToCStruct VisibilityMaskKHR where
    withCStruct x f = allocaBytes 48 $ \p -> pokeCStruct p x (f p)
    pokeCStruct p VisibilityMaskKHR{..} f = do
      poke ((p `plusPtr` 0 :: Ptr StructureType)) (TYPE_VISIBILITY_MASK_KHR)
      poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
      poke ((p `plusPtr` 16 :: Ptr Word32)) (vertexCapacityInput)
      poke ((p `plusPtr` 20 :: Ptr Word32)) (vertexCountOutput)
      poke ((p `plusPtr` 24 :: Ptr (Ptr Vector2f))) (vertices)
      poke ((p `plusPtr` 32 :: Ptr Word32)) (indexCapacityInput)
      poke ((p `plusPtr` 36 :: Ptr Word32)) (indexCountOutput)
      poke ((p `plusPtr` 40 :: Ptr (Ptr Word32))) (indices)
      f
    cStructSize = 48
    cStructAlignment = 8
    pokeZeroCStruct p f = do
      poke ((p `plusPtr` 0 :: Ptr StructureType)) (TYPE_VISIBILITY_MASK_KHR)
      poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
      f
  
  instance FromCStruct VisibilityMaskKHR where
    peekCStruct p = do
      vertexCapacityInput <- peek @Word32 ((p `plusPtr` 16 :: Ptr Word32))
      vertexCountOutput <- peek @Word32 ((p `plusPtr` 20 :: Ptr Word32))
      vertices <- peek @(Ptr Vector2f) ((p `plusPtr` 24 :: Ptr (Ptr Vector2f)))
      indexCapacityInput <- peek @Word32 ((p `plusPtr` 32 :: Ptr Word32))
      indexCountOutput <- peek @Word32 ((p `plusPtr` 36 :: Ptr Word32))
      indices <- peek @(Ptr Word32) ((p `plusPtr` 40 :: Ptr (Ptr Word32)))
      pure $ VisibilityMaskKHR
               vertexCapacityInput
               vertexCountOutput
               vertices
               indexCapacityInput
               indexCountOutput
               indices
  
  instance Storable VisibilityMaskKHR where
    sizeOf ~_ = 48
    alignment ~_ = 8
    peek = peekCStruct
    poke ptr poked = pokeCStruct ptr poked (pure ())
  
  instance Zero VisibilityMaskKHR where
    zero = VisibilityMaskKHR
             zero
             zero
             zero
             zero
             zero
             zero
  
  
  -- | XrVisibilityMaskTypeKHR - Visibility Mask Type
  --
  -- == Enumerant Descriptions
  --
  -- = See Also
  --
  -- 'getVisibilityMaskKHR'
  newtype VisibilityMaskTypeKHR = VisibilityMaskTypeKHR Int32
    deriving newtype (Eq, Ord, Storable, Zero)
  
  -- Note that the zero instance does not produce a valid value, passing 'zero' to Vulkan will result in an error
  
  -- | 'VISIBILITY_MASK_TYPE_HIDDEN_TRIANGLE_MESH_KHR' refers to a two
  -- dimensional triangle mesh on the view surface which /should/ not be
  -- drawn to by the application. 'VisibilityMaskKHR' refers to a set of
  -- triangles identified by vertices and vertex indices. The index count
  -- will thus be a multiple of three. The triangle vertices will be returned
  -- in counter-clockwise order as viewed from the user perspective.
  pattern VISIBILITY_MASK_TYPE_HIDDEN_TRIANGLE_MESH_KHR = VisibilityMaskTypeKHR 1
  
  -- | 'VISIBILITY_MASK_TYPE_VISIBLE_TRIANGLE_MESH_KHR' refers to a two
  -- dimensional triangle mesh on the view surface which /should/ be drawn to
  -- by the application. 'VisibilityMaskKHR' refers to a set of triangles
  -- identified by vertices and vertex indices. The index count will thus be
  -- a multiple of three. The triangle vertices will be returned in
  -- counter-clockwise order as viewed from the user perspective.
  pattern VISIBILITY_MASK_TYPE_VISIBLE_TRIANGLE_MESH_KHR = VisibilityMaskTypeKHR 2
  
  -- | 'VISIBILITY_MASK_TYPE_LINE_LOOP_KHR' refers to a single multi-segmented
  -- line loop on the view surface which encompasses the view area which
  -- /should/ be drawn by the application. It is the border that exists
  -- between the visible and hidden meshes identified by
  -- 'VISIBILITY_MASK_TYPE_HIDDEN_TRIANGLE_MESH_KHR' and
  -- 'VISIBILITY_MASK_TYPE_VISIBLE_TRIANGLE_MESH_KHR'. The line is
  -- counter-clockwise, contiguous, and non-self crossing, with the last
  -- point implicitly connecting to the first point. There is one vertex per
  -- point, the index count will equal the vertex count, and the indices will
  -- refer to the vertices.
  pattern VISIBILITY_MASK_TYPE_LINE_LOOP_KHR = VisibilityMaskTypeKHR 3
  
  {-# COMPLETE
    VISIBILITY_MASK_TYPE_HIDDEN_TRIANGLE_MESH_KHR
    , VISIBILITY_MASK_TYPE_VISIBLE_TRIANGLE_MESH_KHR
    , VISIBILITY_MASK_TYPE_LINE_LOOP_KHR ::
      VisibilityMaskTypeKHR
    #-}
  
  conNameVisibilityMaskTypeKHR :: String
  conNameVisibilityMaskTypeKHR = "VisibilityMaskTypeKHR"
  
  enumPrefixVisibilityMaskTypeKHR :: String
  enumPrefixVisibilityMaskTypeKHR = "VISIBILITY_MASK_TYPE_"
  
  showTableVisibilityMaskTypeKHR :: [(VisibilityMaskTypeKHR, String)]
  showTableVisibilityMaskTypeKHR =
    [
      ( VISIBILITY_MASK_TYPE_HIDDEN_TRIANGLE_MESH_KHR
      , "HIDDEN_TRIANGLE_MESH_KHR"
      )
    ,
      ( VISIBILITY_MASK_TYPE_VISIBLE_TRIANGLE_MESH_KHR
      , "VISIBLE_TRIANGLE_MESH_KHR"
      )
    ,
      ( VISIBILITY_MASK_TYPE_LINE_LOOP_KHR
      , "LINE_LOOP_KHR"
      )
    ]
  
  instance Show VisibilityMaskTypeKHR where
    showsPrec =
      enumShowsPrec
        enumPrefixVisibilityMaskTypeKHR
        showTableVisibilityMaskTypeKHR
        conNameVisibilityMaskTypeKHR
        (\(VisibilityMaskTypeKHR x) -> x)
        (showsPrec 11)
  
  instance Read VisibilityMaskTypeKHR where
    readPrec =
      enumReadPrec
        enumPrefixVisibilityMaskTypeKHR
        showTableVisibilityMaskTypeKHR
        conNameVisibilityMaskTypeKHR
        VisibilityMaskTypeKHR
  
  type KHR_visibility_mask_SPEC_VERSION = 2
  
  -- No documentation found for TopLevel "XR_KHR_visibility_mask_SPEC_VERSION"
  pattern KHR_visibility_mask_SPEC_VERSION :: forall a . Integral a => a
  pattern KHR_visibility_mask_SPEC_VERSION = 2
  
  
  type KHR_VISIBILITY_MASK_EXTENSION_NAME = "XR_KHR_visibility_mask"
  
  -- No documentation found for TopLevel "XR_KHR_VISIBILITY_MASK_EXTENSION_NAME"
  pattern KHR_VISIBILITY_MASK_EXTENSION_NAME :: forall a . (Eq a, IsString a) => a
  pattern KHR_VISIBILITY_MASK_EXTENSION_NAME = "XR_KHR_visibility_mask"
  
  