{-# language CPP #-}
-- | = Name
--
-- XR_KHR_opengl_es_enable - instance extension
--
-- = Specification
--
-- See
-- <https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_KHR_opengl_es_enable  XR_KHR_opengl_es_enable>
-- in the main specification for complete information.
--
-- = Registered Extension Number
--
-- 25
--
-- = Revision
--
-- 7
--
-- = Extension and Version Dependencies
--
-- -   Requires OpenXR 1.0
--
-- = See Also
--
-- 'GraphicsBindingOpenGLESAndroidKHR', 'GraphicsRequirementsOpenGLESKHR',
-- 'SwapchainImageOpenGLESKHR', 'getOpenGLESGraphicsRequirementsKHR'
--
-- = Document Notes
--
-- For more information, see the
-- <https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_KHR_opengl_es_enable 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_opengl_es_enable  ( getOpenGLESGraphicsRequirementsKHR
                                                  , GraphicsBindingOpenGLESAndroidKHR(..)
                                                  , SwapchainImageOpenGLESKHR(..)
                                                  , GraphicsRequirementsOpenGLESKHR(..)
                                                  , KHR_opengl_es_enable_SPEC_VERSION
                                                  , pattern KHR_opengl_es_enable_SPEC_VERSION
                                                  , KHR_OPENGL_ES_ENABLE_EXTENSION_NAME
                                                  , pattern KHR_OPENGL_ES_ENABLE_EXTENSION_NAME
                                                  , EGLDisplay
                                                  , EGLConfig
                                                  , EGLContext
                                                  ) where

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 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 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 Foreign.Ptr (FunPtr)
import Foreign.Ptr (Ptr)
import Data.Word (Word32)
import Data.Kind (Type)
import Control.Monad.Trans.Cont (ContT(..))
import OpenXR.Core10.Handles (Instance)
import OpenXR.Core10.Handles (Instance(..))
import OpenXR.Core10.Handles (Instance(Instance))
import OpenXR.Dynamic (InstanceCmds(pXrGetOpenGLESGraphicsRequirementsKHR))
import OpenXR.Core10.Handles (Instance_T)
import OpenXR.Core10.Image (IsSwapchainImage(..))
import OpenXR.Exception (OpenXrException(..))
import OpenXR.Core10.Enums.Result (Result)
import OpenXR.Core10.Enums.Result (Result(..))
import OpenXR.Core10.Enums.StructureType (StructureType)
import OpenXR.Core10.Image (SwapchainImageBaseHeader(..))
import OpenXR.Core10.Device (SystemId)
import OpenXR.Core10.Device (SystemId(..))
import OpenXR.Version (Version)
import OpenXR.Core10.Enums.Result (Result(SUCCESS))
import OpenXR.Core10.Enums.StructureType (StructureType(TYPE_GRAPHICS_BINDING_OPENGL_ES_ANDROID_KHR))
import OpenXR.Core10.Enums.StructureType (StructureType(TYPE_GRAPHICS_REQUIREMENTS_OPENGL_ES_KHR))
import OpenXR.Core10.Enums.StructureType (StructureType(TYPE_SWAPCHAIN_IMAGE_OPENGL_ES_KHR))
foreign import ccall
#if !defined(SAFE_FOREIGN_CALLS)
  unsafe
#endif
  "dynamic" mkXrGetOpenGLESGraphicsRequirementsKHR
  :: FunPtr (Ptr Instance_T -> SystemId -> Ptr GraphicsRequirementsOpenGLESKHR -> IO Result) -> Ptr Instance_T -> SystemId -> Ptr GraphicsRequirementsOpenGLESKHR -> IO Result

-- | xrGetOpenGLESGraphicsRequirementsKHR - Retrieve the OpenGL ES version
-- requirements for an instance and system
--
-- == Parameter Descriptions
--
-- = Description
--
-- The 'getOpenGLESGraphicsRequirementsKHR' function identifies to the
-- application the minimum OpenGL ES version requirement and the highest
-- known tested OpenGL ES version. The runtime /must/ return
-- 'OpenXR.Core10.Enums.Result.ERROR_GRAPHICS_REQUIREMENTS_CALL_MISSING'
-- ('OpenXR.Core10.Enums.Result.ERROR_VALIDATION_FAILURE' /may/ be returned
-- due to legacy behavior) on calls to 'OpenXR.Core10.Device.createSession'
-- if 'getOpenGLESGraphicsRequirementsKHR' has not been called for the same
-- @instance@ and @systemId@.
--
-- == Valid Usage (Implicit)
--
-- -   #VUID-xrGetOpenGLESGraphicsRequirementsKHR-extension-notenabled# The
--     @XR_KHR_opengl_es_enable@ extension /must/ be enabled prior to
--     calling 'getOpenGLESGraphicsRequirementsKHR'
--
-- -   #VUID-xrGetOpenGLESGraphicsRequirementsKHR-instance-parameter#
--     @instance@ /must/ be a valid 'OpenXR.Core10.Handles.Instance' handle
--
-- -   #VUID-xrGetOpenGLESGraphicsRequirementsKHR-graphicsRequirements-parameter#
--     @graphicsRequirements@ /must/ be a pointer to an
--     'GraphicsRequirementsOpenGLESKHR' structure
--
-- == Return Codes
--
-- [<https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#fundamentals-successcodes Success>]
--
--     -   'OpenXR.Core10.Enums.Result.SUCCESS'
--
-- [<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_SYSTEM_INVALID'
--
--     -   'OpenXR.Core10.Enums.Result.ERROR_VALIDATION_FAILURE'
--
--     -   'OpenXR.Core10.Enums.Result.ERROR_FUNCTION_UNSUPPORTED'
--
-- = See Also
--
-- 'GraphicsRequirementsOpenGLESKHR', 'OpenXR.Core10.Handles.Instance',
-- <https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSystemId >
getOpenGLESGraphicsRequirementsKHR :: forall io
                                    . (MonadIO io)
                                   => -- | @instance@ is an 'OpenXR.Core10.Handles.Instance' handle previously
                                      -- created with 'OpenXR.Core10.Instance.createInstance'.
                                      Instance
                                   -> -- | @systemId@ is an
                                      -- <https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrSystemId >
                                      -- handle for the system which will be used to create a session.
                                      SystemId
                                   -> io (GraphicsRequirementsOpenGLESKHR)
getOpenGLESGraphicsRequirementsKHR instance' systemId = liftIO . evalContT $ do
  let xrGetOpenGLESGraphicsRequirementsKHRPtr = pXrGetOpenGLESGraphicsRequirementsKHR (case instance' of Instance{instanceCmds} -> instanceCmds)
  lift $ unless (xrGetOpenGLESGraphicsRequirementsKHRPtr /= nullFunPtr) $
    throwIO $ IOError Nothing InvalidArgument "" "The function pointer for xrGetOpenGLESGraphicsRequirementsKHR is null" Nothing Nothing
  let xrGetOpenGLESGraphicsRequirementsKHR' = mkXrGetOpenGLESGraphicsRequirementsKHR xrGetOpenGLESGraphicsRequirementsKHRPtr
  pGraphicsRequirements <- ContT (withZeroCStruct @GraphicsRequirementsOpenGLESKHR)
  r <- lift $ traceAroundEvent "xrGetOpenGLESGraphicsRequirementsKHR" (xrGetOpenGLESGraphicsRequirementsKHR' (instanceHandle (instance')) (systemId) (pGraphicsRequirements))
  lift $ when (r < SUCCESS) (throwIO (OpenXrException r))
  graphicsRequirements <- lift $ peekCStruct @GraphicsRequirementsOpenGLESKHR pGraphicsRequirements
  pure $ (graphicsRequirements)


-- | XrGraphicsBindingOpenGLESAndroidKHR - The graphics binding structure to
-- be passed at session creation to use OpenGL ES on Android
--
-- == Member Descriptions
--
-- = Description
--
-- When creating an OpenGL ES-backed 'OpenXR.Core10.Handles.Session' on
-- Android, the application will provide a pointer to an
-- 'GraphicsBindingOpenGLESAndroidKHR' structure in the @next@ chain of the
-- 'OpenXR.Core10.Device.SessionCreateInfo'.
--
-- The required window system configuration define to expose this structure
-- type is
-- <https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XR_USE_PLATFORM_ANDROID XR_USE_PLATFORM_ANDROID>.
--
-- == Valid Usage (Implicit)
--
-- -   #VUID-XrGraphicsBindingOpenGLESAndroidKHR-extension-notenabled# The
--     @XR_KHR_opengl_es_enable@ extension /must/ be enabled prior to using
--     'GraphicsBindingOpenGLESAndroidKHR'
--
-- -   #VUID-XrGraphicsBindingOpenGLESAndroidKHR-type-type# @type@ /must/
--     be
--     'OpenXR.Core10.Enums.StructureType.TYPE_GRAPHICS_BINDING_OPENGL_ES_ANDROID_KHR'
--
-- -   #VUID-XrGraphicsBindingOpenGLESAndroidKHR-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-XrGraphicsBindingOpenGLESAndroidKHR-display-parameter#
--     @display@ /must/ be a valid 'EGLDisplay' value
--
-- -   #VUID-XrGraphicsBindingOpenGLESAndroidKHR-config-parameter# @config@
--     /must/ be a valid 'EGLConfig' value
--
-- -   #VUID-XrGraphicsBindingOpenGLESAndroidKHR-context-parameter#
--     @context@ /must/ be a valid 'EGLContext' value
--
-- = See Also
--
-- 'OpenXR.Core10.Enums.StructureType.StructureType',
-- 'OpenXR.Core10.Device.createSession'
data GraphicsBindingOpenGLESAndroidKHR = GraphicsBindingOpenGLESAndroidKHR
  { -- | @display@ is a valid Android OpenGL ES 'EGLDisplay'.
    display :: EGLDisplay
  , -- | @config@ is a valid Android OpenGL ES 'EGLConfig'.
    config :: EGLConfig
  , -- | @context@ is a valid Android OpenGL ES 'EGLContext'.
    context :: EGLContext
  }
  deriving (Typeable, Eq)
#if defined(GENERIC_INSTANCES)
deriving instance Generic (GraphicsBindingOpenGLESAndroidKHR)
#endif
deriving instance Show GraphicsBindingOpenGLESAndroidKHR

instance ToCStruct GraphicsBindingOpenGLESAndroidKHR where
  withCStruct x f = allocaBytes 40 $ \p -> pokeCStruct p x (f p)
  pokeCStruct p GraphicsBindingOpenGLESAndroidKHR{..} f = do
    poke ((p `plusPtr` 0 :: Ptr StructureType)) (TYPE_GRAPHICS_BINDING_OPENGL_ES_ANDROID_KHR)
    poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
    poke ((p `plusPtr` 16 :: Ptr EGLDisplay)) (display)
    poke ((p `plusPtr` 24 :: Ptr EGLConfig)) (config)
    poke ((p `plusPtr` 32 :: Ptr EGLContext)) (context)
    f
  cStructSize = 40
  cStructAlignment = 8
  pokeZeroCStruct p f = do
    poke ((p `plusPtr` 0 :: Ptr StructureType)) (TYPE_GRAPHICS_BINDING_OPENGL_ES_ANDROID_KHR)
    poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
    poke ((p `plusPtr` 16 :: Ptr EGLDisplay)) (zero)
    poke ((p `plusPtr` 24 :: Ptr EGLConfig)) (zero)
    poke ((p `plusPtr` 32 :: Ptr EGLContext)) (zero)
    f

instance FromCStruct GraphicsBindingOpenGLESAndroidKHR where
  peekCStruct p = do
    display <- peek @EGLDisplay ((p `plusPtr` 16 :: Ptr EGLDisplay))
    config <- peek @EGLConfig ((p `plusPtr` 24 :: Ptr EGLConfig))
    context <- peek @EGLContext ((p `plusPtr` 32 :: Ptr EGLContext))
    pure $ GraphicsBindingOpenGLESAndroidKHR
             display config context

instance Storable GraphicsBindingOpenGLESAndroidKHR where
  sizeOf ~_ = 40
  alignment ~_ = 8
  peek = peekCStruct
  poke ptr poked = pokeCStruct ptr poked (pure ())

instance Zero GraphicsBindingOpenGLESAndroidKHR where
  zero = GraphicsBindingOpenGLESAndroidKHR
           zero
           zero
           zero


-- | XrSwapchainImageOpenGLESKHR - OpenGL ES-specific swapchain image
-- structure
--
-- == Member Descriptions
--
-- = Description
--
-- If a given session was created with a @XrGraphicsBindingOpenGLES*KHR@,
-- the following conditions /must/ apply.
--
-- -   Calls to 'OpenXR.Core10.Image.enumerateSwapchainImages' on an
--     'OpenXR.Core10.Handles.Swapchain' in that session /must/ return an
--     array of 'SwapchainImageOpenGLESKHR' structures.
--
-- -   Whenever an OpenXR function accepts an
--     'OpenXR.Core10.Image.SwapchainImageBaseHeader' pointer as a
--     parameter in that session, the runtime /must/ also accept a pointer
--     to an 'SwapchainImageOpenGLESKHR' structure.
--
-- The OpenXR runtime /must/ interpret the bottom-left corner of the
-- swapchain image as the coordinate origin unless specified otherwise by
-- extension functionality.
--
-- The OpenXR runtime /must/ interpret the swapchain images in a clip space
-- of positive Y pointing up, near Z plane at -1, and far Z plane at 1.
--
-- == Valid Usage (Implicit)
--
-- -   #VUID-XrSwapchainImageOpenGLESKHR-extension-notenabled# The
--     @XR_KHR_opengl_es_enable@ extension /must/ be enabled prior to using
--     'SwapchainImageOpenGLESKHR'
--
-- -   #VUID-XrSwapchainImageOpenGLESKHR-type-type# @type@ /must/ be
--     'OpenXR.Core10.Enums.StructureType.TYPE_SWAPCHAIN_IMAGE_OPENGL_ES_KHR'
--
-- -   #VUID-XrSwapchainImageOpenGLESKHR-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>
--
-- = See Also
--
-- 'OpenXR.Core10.Enums.StructureType.StructureType',
-- 'OpenXR.Core10.Image.SwapchainImageBaseHeader'
data SwapchainImageOpenGLESKHR = SwapchainImageOpenGLESKHR
  { -- | @image@ is an index indicating the current OpenGL ES swapchain image to
    -- use.
    image :: Word32 }
  deriving (Typeable, Eq)
#if defined(GENERIC_INSTANCES)
deriving instance Generic (SwapchainImageOpenGLESKHR)
#endif
deriving instance Show SwapchainImageOpenGLESKHR

instance IsSwapchainImage SwapchainImageOpenGLESKHR where
  toSwapchainImageBaseHeader SwapchainImageOpenGLESKHR{} = SwapchainImageBaseHeader{type' = TYPE_SWAPCHAIN_IMAGE_OPENGL_ES_KHR}

instance ToCStruct SwapchainImageOpenGLESKHR where
  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
  pokeCStruct p SwapchainImageOpenGLESKHR{..} f = do
    poke ((p `plusPtr` 0 :: Ptr StructureType)) (TYPE_SWAPCHAIN_IMAGE_OPENGL_ES_KHR)
    poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
    poke ((p `plusPtr` 16 :: Ptr Word32)) (image)
    f
  cStructSize = 24
  cStructAlignment = 8
  pokeZeroCStruct p f = do
    poke ((p `plusPtr` 0 :: Ptr StructureType)) (TYPE_SWAPCHAIN_IMAGE_OPENGL_ES_KHR)
    poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
    poke ((p `plusPtr` 16 :: Ptr Word32)) (zero)
    f

instance FromCStruct SwapchainImageOpenGLESKHR where
  peekCStruct p = do
    image <- peek @Word32 ((p `plusPtr` 16 :: Ptr Word32))
    pure $ SwapchainImageOpenGLESKHR
             image

instance Storable SwapchainImageOpenGLESKHR where
  sizeOf ~_ = 24
  alignment ~_ = 8
  peek = peekCStruct
  poke ptr poked = pokeCStruct ptr poked (pure ())

instance Zero SwapchainImageOpenGLESKHR where
  zero = SwapchainImageOpenGLESKHR
           zero


-- | XrGraphicsRequirementsOpenGLESKHR - OpenGL ES API version requirements
--
-- == Member Descriptions
--
-- = Description
--
-- 'GraphicsRequirementsOpenGLESKHR' is populated by
-- 'getOpenGLESGraphicsRequirementsKHR' with the runtime’s OpenGL ES API
-- version requirements.
--
-- == Valid Usage (Implicit)
--
-- -   #VUID-XrGraphicsRequirementsOpenGLESKHR-extension-notenabled# The
--     @XR_KHR_opengl_es_enable@ extension /must/ be enabled prior to using
--     'GraphicsRequirementsOpenGLESKHR'
--
-- -   #VUID-XrGraphicsRequirementsOpenGLESKHR-type-type# @type@ /must/ be
--     'OpenXR.Core10.Enums.StructureType.TYPE_GRAPHICS_REQUIREMENTS_OPENGL_ES_KHR'
--
-- -   #VUID-XrGraphicsRequirementsOpenGLESKHR-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>
--
-- = See Also
--
-- 'OpenXR.Core10.Enums.StructureType.StructureType',
-- <https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#XrVersion >,
-- 'getOpenGLESGraphicsRequirementsKHR'
data GraphicsRequirementsOpenGLESKHR = GraphicsRequirementsOpenGLESKHR
  { -- | @minApiVersionSupported@ is the minimum version of OpenGL ES that the
    -- runtime supports. Uses 'OpenXR.Version.MAKE_VERSION' on major and minor
    -- API version, ignoring any patch version component.
    minApiVersionSupported :: Version
  , -- | @maxApiVersionSupported@ is the maximum version of OpenGL ES that the
    -- runtime has been tested on and is known to support. Newer OpenGL ES
    -- versions might work if they are compatible. Uses
    -- 'OpenXR.Version.MAKE_VERSION' on major and minor API version, ignoring
    -- any patch version component.
    maxApiVersionSupported :: Version
  }
  deriving (Typeable, Eq)
#if defined(GENERIC_INSTANCES)
deriving instance Generic (GraphicsRequirementsOpenGLESKHR)
#endif
deriving instance Show GraphicsRequirementsOpenGLESKHR

instance ToCStruct GraphicsRequirementsOpenGLESKHR where
  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
  pokeCStruct p GraphicsRequirementsOpenGLESKHR{..} f = do
    poke ((p `plusPtr` 0 :: Ptr StructureType)) (TYPE_GRAPHICS_REQUIREMENTS_OPENGL_ES_KHR)
    poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
    poke ((p `plusPtr` 16 :: Ptr Version)) (minApiVersionSupported)
    poke ((p `plusPtr` 24 :: Ptr Version)) (maxApiVersionSupported)
    f
  cStructSize = 32
  cStructAlignment = 8
  pokeZeroCStruct p f = do
    poke ((p `plusPtr` 0 :: Ptr StructureType)) (TYPE_GRAPHICS_REQUIREMENTS_OPENGL_ES_KHR)
    poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
    poke ((p `plusPtr` 16 :: Ptr Version)) (zero)
    poke ((p `plusPtr` 24 :: Ptr Version)) (zero)
    f

instance FromCStruct GraphicsRequirementsOpenGLESKHR where
  peekCStruct p = do
    minApiVersionSupported <- peek @Version ((p `plusPtr` 16 :: Ptr Version))
    maxApiVersionSupported <- peek @Version ((p `plusPtr` 24 :: Ptr Version))
    pure $ GraphicsRequirementsOpenGLESKHR
             minApiVersionSupported maxApiVersionSupported

instance Storable GraphicsRequirementsOpenGLESKHR where
  sizeOf ~_ = 32
  alignment ~_ = 8
  peek = peekCStruct
  poke ptr poked = pokeCStruct ptr poked (pure ())

instance Zero GraphicsRequirementsOpenGLESKHR where
  zero = GraphicsRequirementsOpenGLESKHR
           zero
           zero


type KHR_opengl_es_enable_SPEC_VERSION = 7

-- No documentation found for TopLevel "XR_KHR_opengl_es_enable_SPEC_VERSION"
pattern KHR_opengl_es_enable_SPEC_VERSION :: forall a . Integral a => a
pattern KHR_opengl_es_enable_SPEC_VERSION = 7


type KHR_OPENGL_ES_ENABLE_EXTENSION_NAME = "XR_KHR_opengl_es_enable"

-- No documentation found for TopLevel "XR_KHR_OPENGL_ES_ENABLE_EXTENSION_NAME"
pattern KHR_OPENGL_ES_ENABLE_EXTENSION_NAME :: forall a . (Eq a, IsString a) => a
pattern KHR_OPENGL_ES_ENABLE_EXTENSION_NAME = "XR_KHR_opengl_es_enable"


type EGLDisplay = Ptr ()


type EGLConfig = Ptr ()


type EGLContext = Ptr ()

