{-# language CPP #-}
-- | = Name
--
-- VK_KHR_deferred_host_operations - device extension
--
-- == VK_KHR_deferred_host_operations
--
-- [__Name String__]
--     @VK_KHR_deferred_host_operations@
--
-- [__Extension Type__]
--     Device extension
--
-- [__Registered Extension Number__]
--     269
--
-- [__Revision__]
--     4
--
-- [__Extension and Version Dependencies__]
--
--     -   Requires Vulkan 1.0
--
-- [__Contact__]
--
--     -   Josh Barczak
--         <https://github.com/KhronosGroup/Vulkan-Docs/issues/new?body=[VK_KHR_deferred_host_operations] @jbarczak%0A<<Here describe the issue or question you have about the VK_KHR_deferred_host_operations extension>> >
--
-- == Other Extension Metadata
--
-- [__Last Modified Date__]
--     2020-11-12
--
-- [__IP Status__]
--     No known IP claims.
--
-- [__Contributors__]
--
--     -   Joshua Barczak, Intel
--
--     -   Jeff Bolz, NVIDIA
--
--     -   Daniel Koch, NVIDIA
--
--     -   Slawek Grajewski, Intel
--
--     -   Tobias Hector, AMD
--
--     -   Yuriy O’Donnell, Epic
--
--     -   Eric Werness, NVIDIA
--
--     -   Baldur Karlsson, Valve
--
--     -   Jesse Barker, Unity
--
--     -   Contributors to VK_KHR_acceleration_structure,
--         VK_KHR_ray_tracing_pipeline
--
-- == Description
--
-- The @VK_KHR_deferred_host_operations@ extension defines the
-- infrastructure and usage patterns for deferrable commands, but does not
-- specify any commands as deferrable. This is left to additional dependent
-- extensions. Commands /must/ not be deferred unless the deferral is
-- specifically allowed by another extension which depends on
-- @VK_KHR_deferred_host_operations@.
--
-- == New Object Types
--
-- -   'Vulkan.Extensions.Handles.DeferredOperationKHR'
--
-- == New Commands
--
-- -   'createDeferredOperationKHR'
--
-- -   'deferredOperationJoinKHR'
--
-- -   'destroyDeferredOperationKHR'
--
-- -   'getDeferredOperationMaxConcurrencyKHR'
--
-- -   'getDeferredOperationResultKHR'
--
-- == New Enum Constants
--
-- -   'KHR_DEFERRED_HOST_OPERATIONS_EXTENSION_NAME'
--
-- -   'KHR_DEFERRED_HOST_OPERATIONS_SPEC_VERSION'
--
-- -   Extending 'Vulkan.Core10.Enums.ObjectType.ObjectType':
--
--     -   'Vulkan.Core10.Enums.ObjectType.OBJECT_TYPE_DEFERRED_OPERATION_KHR'
--
-- -   Extending 'Vulkan.Core10.Enums.Result.Result':
--
--     -   'Vulkan.Core10.Enums.Result.OPERATION_DEFERRED_KHR'
--
--     -   'Vulkan.Core10.Enums.Result.OPERATION_NOT_DEFERRED_KHR'
--
--     -   'Vulkan.Core10.Enums.Result.THREAD_DONE_KHR'
--
--     -   'Vulkan.Core10.Enums.Result.THREAD_IDLE_KHR'
--
-- == Code Examples
--
-- The following examples will illustrate the concept of deferrable
-- operations using a hypothetical example. The command
-- @vkDoSomethingExpensiveEXT@ denotes a deferrable command. The structure
-- @VkExpensiveOperationArgsEXT@ represents the arguments which it would
-- normally accept.
--
-- The following example illustrates how a vulkan application might request
-- deferral of an expensive operation:
--
-- > // create a deferred operation
-- > VkDeferredOperationKHR hOp;
-- > VkResult result = vkCreateDeferredOperationKHR(device, pCallbacks, &hOp);
-- > assert(result == VK_SUCCESS);
-- >
-- > result = vkDoSomethingExpensive(device, hOp, ...);
-- > assert( result == VK_OPERATION_DEFERRED_KHR );
-- >
-- > // operation was deferred.  Execute it asynchronously
-- > std::async::launch(
-- >     [ hOp ] ( )
-- >     {
-- >         vkDeferredOperationJoinKHR(device, hOp);
-- >
-- >         result = vkGetDeferredOperationResultKHR(device, hOp);
-- >
-- >         // deferred operation is now complete.  'result' indicates success or failure
-- >
-- >         vkDestroyDeferredOperationKHR(device, hOp, pCallbacks);
-- >     }
-- > );
--
-- The following example illustrates extracting concurrency from a single
-- deferred operation:
--
-- > // create a deferred operation
-- > VkDeferredOperationKHR hOp;
-- > VkResult result = vkCreateDeferredOperationKHR(device, pCallbacks, &hOp);
-- > assert(result == VK_SUCCESS);
-- >
-- > result = vkDoSomethingExpensive(device, hOp, ...);
-- > assert( result == VK_OPERATION_DEFERRED_KHR );
-- >
-- > // Query the maximum amount of concurrency and clamp to the desired maximum
-- > uint32_t numLaunches = std::min(vkGetDeferredOperationMaxConcurrencyKHR(device, hOp), maxThreads);
-- >
-- > std::vector<std::future<void> > joins;
-- >
-- > for (uint32_t i = 0; i < numLaunches; i++) {
-- >   joins.emplace_back(std::async::launch(
-- >     [ hOp ] ( )
-- >     {
-- >         vkDeferredOperationJoinKHR(device, hOp);
-- >                 // in a job system, a return of VK_THREAD_IDLE_KHR should queue another
-- >                 // job, but it is not functionally required
-- >     }
-- >   );
-- > }
-- >
-- > for (auto &f : joins) {
-- >   f.get();
-- > }
-- >
-- > result = vkGetDeferredOperationResultKHR(device, hOp);
-- >
-- > // deferred operation is now complete.  'result' indicates success or failure
-- >
-- > vkDestroyDeferredOperationKHR(device, hOp, pCallbacks);
--
-- The following example shows a subroutine which guarantees completion of
-- a deferred operation, in the presence of multiple worker threads, and
-- returns the result of the operation.
--
-- > VkResult FinishDeferredOperation(VkDeferredOperationKHR hOp)
-- > {
-- >     // Attempt to join the operation until the implementation indicates that we should stop
-- >
-- >     VkResult result = vkDeferredOperationJoinKHR(device, hOp);
-- >     while( result == VK_THREAD_IDLE_KHR )
-- >     {
-- >         std::this_thread::yield();
-- >         result = vkDeferredOperationJoinKHR(device, hOp);
-- >     }
-- >
-- >     switch( result )
-- >     {
-- >     case VK_SUCCESS:
-- >         {
-- >             // deferred operation has finished.  Query its result
-- >             result = vkGetDeferredOperationResultKHR(device, hOp);
-- >         }
-- >         break;
-- >
-- >     case VK_THREAD_DONE_KHR:
-- >         {
-- >             // deferred operation is being wrapped up by another thread
-- >             //  wait for that thread to finish
-- >             do
-- >             {
-- >                 std::this_thread::yield();
-- >                 result = vkGetDeferredOperationResultKHR(device, hOp);
-- >             } while( result == VK_NOT_READY );
-- >         }
-- >         break;
-- >
-- >     default:
-- >         assert(false); // other conditions are illegal.
-- >         break;
-- >     }
-- >
-- >     return result;
-- > }
--
-- == Issues
--
-- 1.  Should this extension have a VkPhysicalDevice*FeaturesKHR structure?
--
-- __RESOLVED__: No. This extension does not add any functionality on its
-- own and requires a dependent extension to actually enable functionality
-- and thus there is no value in adding a feature structure. If necessary,
-- any dependent extension could add a feature boolean if it wanted to
-- indicate that it is adding optional deferral support.
--
-- == Version History
--
-- -   Revision 1, 2019-12-05 (Josh Barczak, Daniel Koch)
--
--     -   Initial draft.
--
-- -   Revision 2, 2020-03-06 (Daniel Koch, Tobias Hector)
--
--     -   Add missing VK_OBJECT_TYPE_DEFERRED_OPERATION_KHR enum
--
--     -   fix sample code
--
--     -   Clarified deferred operation parameter lifetimes (#2018,!3647)
--
-- -   Revision 3, 2020-05-15 (Josh Barczak)
--
--     -   Clarify behavior of vkGetDeferredOperationMaxConcurrencyKHR,
--         allowing it to return 0 if the operation is complete
--         (#2036,!3850)
--
-- -   Revision 4, 2020-11-12 (Tobias Hector, Daniel Koch)
--
--     -   Remove VkDeferredOperationInfoKHR and change return value
--         semantics when deferred host operations are in use (#2067,3813)
--
--     -   clarify return value of vkGetDeferredOperationResultKHR
--         (#2339,!4110)
--
-- == See Also
--
-- 'Vulkan.Extensions.Handles.DeferredOperationKHR',
-- 'createDeferredOperationKHR', 'deferredOperationJoinKHR',
-- 'destroyDeferredOperationKHR', 'getDeferredOperationMaxConcurrencyKHR',
-- 'getDeferredOperationResultKHR'
--
-- == Document Notes
--
-- For more information, see the
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#VK_KHR_deferred_host_operations Vulkan Specification>
--
-- This page is a generated document. Fixes and changes should be made to
-- the generator scripts, not directly.
module Vulkan.Extensions.VK_KHR_deferred_host_operations  ( createDeferredOperationKHR
                                                          , withDeferredOperationKHR
                                                          , destroyDeferredOperationKHR
                                                          , getDeferredOperationMaxConcurrencyKHR
                                                          , getDeferredOperationResultKHR
                                                          , deferredOperationJoinKHR
                                                          , KHR_DEFERRED_HOST_OPERATIONS_SPEC_VERSION
                                                          , pattern KHR_DEFERRED_HOST_OPERATIONS_SPEC_VERSION
                                                          , KHR_DEFERRED_HOST_OPERATIONS_EXTENSION_NAME
                                                          , pattern KHR_DEFERRED_HOST_OPERATIONS_EXTENSION_NAME
                                                          , DeferredOperationKHR(..)
                                                          ) where

import Vulkan.Internal.Utils (traceAroundEvent)
import Control.Exception.Base (bracket)
import Control.Monad (unless)
import Control.Monad.IO.Class (liftIO)
import Foreign.Marshal.Alloc (callocBytes)
import Foreign.Marshal.Alloc (free)
import GHC.Base (when)
import GHC.IO (throwIO)
import GHC.Ptr (nullFunPtr)
import Foreign.Ptr (nullPtr)
import Control.Monad.Trans.Class (lift)
import Control.Monad.Trans.Cont (evalContT)
import Vulkan.CStruct (ToCStruct(..))
import Control.Monad.IO.Class (MonadIO)
import Data.String (IsString)
import Foreign.Storable (Storable(peek))
import GHC.IO.Exception (IOErrorType(..))
import GHC.IO.Exception (IOException(..))
import Foreign.Ptr (FunPtr)
import Foreign.Ptr (Ptr)
import Data.Word (Word32)
import Control.Monad.Trans.Cont (ContT(..))
import Vulkan.NamedType ((:::))
import Vulkan.Core10.AllocationCallbacks (AllocationCallbacks)
import Vulkan.Extensions.Handles (DeferredOperationKHR)
import Vulkan.Extensions.Handles (DeferredOperationKHR(..))
import Vulkan.Core10.Handles (Device)
import Vulkan.Core10.Handles (Device(..))
import Vulkan.Core10.Handles (Device(Device))
import Vulkan.Dynamic (DeviceCmds(pVkCreateDeferredOperationKHR))
import Vulkan.Dynamic (DeviceCmds(pVkDeferredOperationJoinKHR))
import Vulkan.Dynamic (DeviceCmds(pVkDestroyDeferredOperationKHR))
import Vulkan.Dynamic (DeviceCmds(pVkGetDeferredOperationMaxConcurrencyKHR))
import Vulkan.Dynamic (DeviceCmds(pVkGetDeferredOperationResultKHR))
import Vulkan.Core10.Handles (Device_T)
import Vulkan.Core10.Enums.Result (Result)
import Vulkan.Core10.Enums.Result (Result(..))
import Vulkan.Exception (VulkanException(..))
import Vulkan.Core10.Enums.Result (Result(SUCCESS))
import Vulkan.Extensions.Handles (DeferredOperationKHR(..))
foreign import ccall
#if !defined(SAFE_FOREIGN_CALLS)
  unsafe
#endif
  "dynamic" mkVkCreateDeferredOperationKHR
  :: FunPtr (Ptr Device_T -> Ptr AllocationCallbacks -> Ptr DeferredOperationKHR -> IO Result) -> Ptr Device_T -> Ptr AllocationCallbacks -> Ptr DeferredOperationKHR -> IO Result

-- | vkCreateDeferredOperationKHR - Create a deferred operation handle
--
-- == Valid Usage (Implicit)
--
-- -   #VUID-vkCreateDeferredOperationKHR-device-parameter# @device@ /must/
--     be a valid 'Vulkan.Core10.Handles.Device' handle
--
-- -   #VUID-vkCreateDeferredOperationKHR-pAllocator-parameter# If
--     @pAllocator@ is not @NULL@, @pAllocator@ /must/ be a valid pointer
--     to a valid 'Vulkan.Core10.AllocationCallbacks.AllocationCallbacks'
--     structure
--
-- -   #VUID-vkCreateDeferredOperationKHR-pDeferredOperation-parameter#
--     @pDeferredOperation@ /must/ be a valid pointer to a
--     'Vulkan.Extensions.Handles.DeferredOperationKHR' handle
--
-- == Return Codes
--
-- [<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#fundamentals-successcodes Success>]
--
--     -   'Vulkan.Core10.Enums.Result.SUCCESS'
--
-- [<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#fundamentals-errorcodes Failure>]
--
--     -   'Vulkan.Core10.Enums.Result.ERROR_OUT_OF_HOST_MEMORY'
--
-- = See Also
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#VK_KHR_deferred_host_operations VK_KHR_deferred_host_operations>,
-- 'Vulkan.Core10.AllocationCallbacks.AllocationCallbacks',
-- 'Vulkan.Extensions.Handles.DeferredOperationKHR',
-- 'Vulkan.Core10.Handles.Device'
createDeferredOperationKHR :: forall io
                            . (MonadIO io)
                           => -- | @device@ is the device which owns @operation@.
                              Device
                           -> -- | @pAllocator@ controls host memory allocation as described in the
                              -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#memory-allocation Memory Allocation>
                              -- chapter.
                              ("allocator" ::: Maybe AllocationCallbacks)
                           -> io (DeferredOperationKHR)
createDeferredOperationKHR :: Device
-> ("allocator" ::: Maybe AllocationCallbacks)
-> io DeferredOperationKHR
createDeferredOperationKHR Device
device "allocator" ::: Maybe AllocationCallbacks
allocator = IO DeferredOperationKHR -> io DeferredOperationKHR
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO DeferredOperationKHR -> io DeferredOperationKHR)
-> (ContT DeferredOperationKHR IO DeferredOperationKHR
    -> IO DeferredOperationKHR)
-> ContT DeferredOperationKHR IO DeferredOperationKHR
-> io DeferredOperationKHR
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ContT DeferredOperationKHR IO DeferredOperationKHR
-> IO DeferredOperationKHR
forall (m :: * -> *) r. Monad m => ContT r m r -> m r
evalContT (ContT DeferredOperationKHR IO DeferredOperationKHR
 -> io DeferredOperationKHR)
-> ContT DeferredOperationKHR IO DeferredOperationKHR
-> io DeferredOperationKHR
forall a b. (a -> b) -> a -> b
$ do
  let vkCreateDeferredOperationKHRPtr :: FunPtr
  (Ptr Device_T
   -> ("pAllocator" ::: Ptr AllocationCallbacks)
   -> ("pDeferredOperation" ::: Ptr DeferredOperationKHR)
   -> IO Result)
vkCreateDeferredOperationKHRPtr = DeviceCmds
-> FunPtr
     (Ptr Device_T
      -> ("pAllocator" ::: Ptr AllocationCallbacks)
      -> ("pDeferredOperation" ::: Ptr DeferredOperationKHR)
      -> IO Result)
pVkCreateDeferredOperationKHR (case Device
device of Device{DeviceCmds
$sel:deviceCmds:Device :: Device -> DeviceCmds
deviceCmds :: DeviceCmds
deviceCmds} -> DeviceCmds
deviceCmds)
  IO () -> ContT DeferredOperationKHR IO ()
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (IO () -> ContT DeferredOperationKHR IO ())
-> IO () -> ContT DeferredOperationKHR IO ()
forall a b. (a -> b) -> a -> b
$ Bool -> IO () -> IO ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless (FunPtr
  (Ptr Device_T
   -> ("pAllocator" ::: Ptr AllocationCallbacks)
   -> ("pDeferredOperation" ::: Ptr DeferredOperationKHR)
   -> IO Result)
vkCreateDeferredOperationKHRPtr FunPtr
  (Ptr Device_T
   -> ("pAllocator" ::: Ptr AllocationCallbacks)
   -> ("pDeferredOperation" ::: Ptr DeferredOperationKHR)
   -> IO Result)
-> FunPtr
     (Ptr Device_T
      -> ("pAllocator" ::: Ptr AllocationCallbacks)
      -> ("pDeferredOperation" ::: Ptr DeferredOperationKHR)
      -> IO Result)
-> Bool
forall a. Eq a => a -> a -> Bool
/= FunPtr
  (Ptr Device_T
   -> ("pAllocator" ::: Ptr AllocationCallbacks)
   -> ("pDeferredOperation" ::: Ptr DeferredOperationKHR)
   -> IO Result)
forall a. FunPtr a
nullFunPtr) (IO () -> IO ()) -> IO () -> IO ()
forall a b. (a -> b) -> a -> b
$
    IOException -> IO ()
forall e a. Exception e => e -> IO a
throwIO (IOException -> IO ()) -> IOException -> IO ()
forall a b. (a -> b) -> a -> b
$ Maybe Handle
-> IOErrorType
-> String
-> String
-> Maybe CInt
-> Maybe String
-> IOException
IOError Maybe Handle
forall a. Maybe a
Nothing IOErrorType
InvalidArgument String
"" String
"The function pointer for vkCreateDeferredOperationKHR is null" Maybe CInt
forall a. Maybe a
Nothing Maybe String
forall a. Maybe a
Nothing
  let vkCreateDeferredOperationKHR' :: Ptr Device_T
-> ("pAllocator" ::: Ptr AllocationCallbacks)
-> ("pDeferredOperation" ::: Ptr DeferredOperationKHR)
-> IO Result
vkCreateDeferredOperationKHR' = FunPtr
  (Ptr Device_T
   -> ("pAllocator" ::: Ptr AllocationCallbacks)
   -> ("pDeferredOperation" ::: Ptr DeferredOperationKHR)
   -> IO Result)
-> Ptr Device_T
-> ("pAllocator" ::: Ptr AllocationCallbacks)
-> ("pDeferredOperation" ::: Ptr DeferredOperationKHR)
-> IO Result
mkVkCreateDeferredOperationKHR FunPtr
  (Ptr Device_T
   -> ("pAllocator" ::: Ptr AllocationCallbacks)
   -> ("pDeferredOperation" ::: Ptr DeferredOperationKHR)
   -> IO Result)
vkCreateDeferredOperationKHRPtr
  "pAllocator" ::: Ptr AllocationCallbacks
pAllocator <- case ("allocator" ::: Maybe AllocationCallbacks
allocator) of
    "allocator" ::: Maybe AllocationCallbacks
Nothing -> ("pAllocator" ::: Ptr AllocationCallbacks)
-> ContT
     DeferredOperationKHR IO ("pAllocator" ::: Ptr AllocationCallbacks)
forall (f :: * -> *) a. Applicative f => a -> f a
pure "pAllocator" ::: Ptr AllocationCallbacks
forall a. Ptr a
nullPtr
    Just AllocationCallbacks
j -> ((("pAllocator" ::: Ptr AllocationCallbacks)
  -> IO DeferredOperationKHR)
 -> IO DeferredOperationKHR)
-> ContT
     DeferredOperationKHR IO ("pAllocator" ::: Ptr AllocationCallbacks)
forall k (r :: k) (m :: k -> *) a.
((a -> m r) -> m r) -> ContT r m a
ContT (((("pAllocator" ::: Ptr AllocationCallbacks)
   -> IO DeferredOperationKHR)
  -> IO DeferredOperationKHR)
 -> ContT
      DeferredOperationKHR IO ("pAllocator" ::: Ptr AllocationCallbacks))
-> ((("pAllocator" ::: Ptr AllocationCallbacks)
     -> IO DeferredOperationKHR)
    -> IO DeferredOperationKHR)
-> ContT
     DeferredOperationKHR IO ("pAllocator" ::: Ptr AllocationCallbacks)
forall a b. (a -> b) -> a -> b
$ AllocationCallbacks
-> (("pAllocator" ::: Ptr AllocationCallbacks)
    -> IO DeferredOperationKHR)
-> IO DeferredOperationKHR
forall a b. ToCStruct a => a -> (Ptr a -> IO b) -> IO b
withCStruct (AllocationCallbacks
j)
  "pDeferredOperation" ::: Ptr DeferredOperationKHR
pPDeferredOperation <- ((("pDeferredOperation" ::: Ptr DeferredOperationKHR)
  -> IO DeferredOperationKHR)
 -> IO DeferredOperationKHR)
-> ContT
     DeferredOperationKHR
     IO
     ("pDeferredOperation" ::: Ptr DeferredOperationKHR)
forall k (r :: k) (m :: k -> *) a.
((a -> m r) -> m r) -> ContT r m a
ContT (((("pDeferredOperation" ::: Ptr DeferredOperationKHR)
   -> IO DeferredOperationKHR)
  -> IO DeferredOperationKHR)
 -> ContT
      DeferredOperationKHR
      IO
      ("pDeferredOperation" ::: Ptr DeferredOperationKHR))
-> ((("pDeferredOperation" ::: Ptr DeferredOperationKHR)
     -> IO DeferredOperationKHR)
    -> IO DeferredOperationKHR)
-> ContT
     DeferredOperationKHR
     IO
     ("pDeferredOperation" ::: Ptr DeferredOperationKHR)
forall a b. (a -> b) -> a -> b
$ IO ("pDeferredOperation" ::: Ptr DeferredOperationKHR)
-> (("pDeferredOperation" ::: Ptr DeferredOperationKHR) -> IO ())
-> (("pDeferredOperation" ::: Ptr DeferredOperationKHR)
    -> IO DeferredOperationKHR)
-> IO DeferredOperationKHR
forall a b c. IO a -> (a -> IO b) -> (a -> IO c) -> IO c
bracket (Int -> IO ("pDeferredOperation" ::: Ptr DeferredOperationKHR)
forall a. Int -> IO (Ptr a)
callocBytes @DeferredOperationKHR Int
8) ("pDeferredOperation" ::: Ptr DeferredOperationKHR) -> IO ()
forall a. Ptr a -> IO ()
free
  Result
r <- IO Result -> ContT DeferredOperationKHR IO Result
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (IO Result -> ContT DeferredOperationKHR IO Result)
-> IO Result -> ContT DeferredOperationKHR IO Result
forall a b. (a -> b) -> a -> b
$ String -> IO Result -> IO Result
forall a. String -> IO a -> IO a
traceAroundEvent String
"vkCreateDeferredOperationKHR" (Ptr Device_T
-> ("pAllocator" ::: Ptr AllocationCallbacks)
-> ("pDeferredOperation" ::: Ptr DeferredOperationKHR)
-> IO Result
vkCreateDeferredOperationKHR' (Device -> Ptr Device_T
deviceHandle (Device
device)) "pAllocator" ::: Ptr AllocationCallbacks
pAllocator ("pDeferredOperation" ::: Ptr DeferredOperationKHR
pPDeferredOperation))
  IO () -> ContT DeferredOperationKHR IO ()
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (IO () -> ContT DeferredOperationKHR IO ())
-> IO () -> ContT DeferredOperationKHR IO ()
forall a b. (a -> b) -> a -> b
$ Bool -> IO () -> IO ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Result
r Result -> Result -> Bool
forall a. Ord a => a -> a -> Bool
< Result
SUCCESS) (VulkanException -> IO ()
forall e a. Exception e => e -> IO a
throwIO (Result -> VulkanException
VulkanException Result
r))
  DeferredOperationKHR
pDeferredOperation <- IO DeferredOperationKHR
-> ContT DeferredOperationKHR IO DeferredOperationKHR
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (IO DeferredOperationKHR
 -> ContT DeferredOperationKHR IO DeferredOperationKHR)
-> IO DeferredOperationKHR
-> ContT DeferredOperationKHR IO DeferredOperationKHR
forall a b. (a -> b) -> a -> b
$ ("pDeferredOperation" ::: Ptr DeferredOperationKHR)
-> IO DeferredOperationKHR
forall a. Storable a => Ptr a -> IO a
peek @DeferredOperationKHR "pDeferredOperation" ::: Ptr DeferredOperationKHR
pPDeferredOperation
  DeferredOperationKHR
-> ContT DeferredOperationKHR IO DeferredOperationKHR
forall (f :: * -> *) a. Applicative f => a -> f a
pure (DeferredOperationKHR
 -> ContT DeferredOperationKHR IO DeferredOperationKHR)
-> DeferredOperationKHR
-> ContT DeferredOperationKHR IO DeferredOperationKHR
forall a b. (a -> b) -> a -> b
$ (DeferredOperationKHR
pDeferredOperation)

-- | A convenience wrapper to make a compatible pair of calls to
-- 'createDeferredOperationKHR' and 'destroyDeferredOperationKHR'
--
-- To ensure that 'destroyDeferredOperationKHR' is always called: pass
-- 'Control.Exception.bracket' (or the allocate function from your
-- favourite resource management library) as the last argument.
-- To just extract the pair pass '(,)' as the last argument.
--
withDeferredOperationKHR :: forall io r . MonadIO io => Device -> Maybe AllocationCallbacks -> (io DeferredOperationKHR -> (DeferredOperationKHR -> io ()) -> r) -> r
withDeferredOperationKHR :: Device
-> ("allocator" ::: Maybe AllocationCallbacks)
-> (io DeferredOperationKHR
    -> (DeferredOperationKHR -> io ()) -> r)
-> r
withDeferredOperationKHR Device
device "allocator" ::: Maybe AllocationCallbacks
pAllocator io DeferredOperationKHR -> (DeferredOperationKHR -> io ()) -> r
b =
  io DeferredOperationKHR -> (DeferredOperationKHR -> io ()) -> r
b (Device
-> ("allocator" ::: Maybe AllocationCallbacks)
-> io DeferredOperationKHR
forall (io :: * -> *).
MonadIO io =>
Device
-> ("allocator" ::: Maybe AllocationCallbacks)
-> io DeferredOperationKHR
createDeferredOperationKHR Device
device "allocator" ::: Maybe AllocationCallbacks
pAllocator)
    (\(DeferredOperationKHR
o0) -> Device
-> DeferredOperationKHR
-> ("allocator" ::: Maybe AllocationCallbacks)
-> io ()
forall (io :: * -> *).
MonadIO io =>
Device
-> DeferredOperationKHR
-> ("allocator" ::: Maybe AllocationCallbacks)
-> io ()
destroyDeferredOperationKHR Device
device DeferredOperationKHR
o0 "allocator" ::: Maybe AllocationCallbacks
pAllocator)


foreign import ccall
#if !defined(SAFE_FOREIGN_CALLS)
  unsafe
#endif
  "dynamic" mkVkDestroyDeferredOperationKHR
  :: FunPtr (Ptr Device_T -> DeferredOperationKHR -> Ptr AllocationCallbacks -> IO ()) -> Ptr Device_T -> DeferredOperationKHR -> Ptr AllocationCallbacks -> IO ()

-- | vkDestroyDeferredOperationKHR - Destroy a deferred operation handle
--
-- == Valid Usage
--
-- -   #VUID-vkDestroyDeferredOperationKHR-operation-03434# If
--     'Vulkan.Core10.AllocationCallbacks.AllocationCallbacks' were
--     provided when @operation@ was created, a compatible set of callbacks
--     /must/ be provided here
--
-- -   #VUID-vkDestroyDeferredOperationKHR-operation-03435# If no
--     'Vulkan.Core10.AllocationCallbacks.AllocationCallbacks' were
--     provided when @operation@ was created, @pAllocator@ /must/ be @NULL@
--
-- -   #VUID-vkDestroyDeferredOperationKHR-operation-03436# @operation@
--     /must/ be completed
--
-- == Valid Usage (Implicit)
--
-- -   #VUID-vkDestroyDeferredOperationKHR-device-parameter# @device@
--     /must/ be a valid 'Vulkan.Core10.Handles.Device' handle
--
-- -   #VUID-vkDestroyDeferredOperationKHR-operation-parameter# If
--     @operation@ is not 'Vulkan.Core10.APIConstants.NULL_HANDLE',
--     @operation@ /must/ be a valid
--     'Vulkan.Extensions.Handles.DeferredOperationKHR' handle
--
-- -   #VUID-vkDestroyDeferredOperationKHR-pAllocator-parameter# If
--     @pAllocator@ is not @NULL@, @pAllocator@ /must/ be a valid pointer
--     to a valid 'Vulkan.Core10.AllocationCallbacks.AllocationCallbacks'
--     structure
--
-- -   #VUID-vkDestroyDeferredOperationKHR-operation-parent# If @operation@
--     is a valid handle, it /must/ have been created, allocated, or
--     retrieved from @device@
--
-- == Host Synchronization
--
-- -   Host access to @operation@ /must/ be externally synchronized
--
-- = See Also
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#VK_KHR_deferred_host_operations VK_KHR_deferred_host_operations>,
-- 'Vulkan.Core10.AllocationCallbacks.AllocationCallbacks',
-- 'Vulkan.Extensions.Handles.DeferredOperationKHR',
-- 'Vulkan.Core10.Handles.Device'
destroyDeferredOperationKHR :: forall io
                             . (MonadIO io)
                            => -- | @device@ is the device which owns @operation@.
                               Device
                            -> -- | @operation@ is the completed operation to be destroyed.
                               DeferredOperationKHR
                            -> -- | @pAllocator@ controls host memory allocation as described in the
                               -- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#memory-allocation Memory Allocation>
                               -- chapter.
                               ("allocator" ::: Maybe AllocationCallbacks)
                            -> io ()
destroyDeferredOperationKHR :: Device
-> DeferredOperationKHR
-> ("allocator" ::: Maybe AllocationCallbacks)
-> io ()
destroyDeferredOperationKHR Device
device DeferredOperationKHR
operation "allocator" ::: Maybe AllocationCallbacks
allocator = IO () -> io ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> io ())
-> (ContT () IO () -> IO ()) -> ContT () IO () -> io ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ContT () IO () -> IO ()
forall (m :: * -> *) r. Monad m => ContT r m r -> m r
evalContT (ContT () IO () -> io ()) -> ContT () IO () -> io ()
forall a b. (a -> b) -> a -> b
$ do
  let vkDestroyDeferredOperationKHRPtr :: FunPtr
  (Ptr Device_T
   -> DeferredOperationKHR
   -> ("pAllocator" ::: Ptr AllocationCallbacks)
   -> IO ())
vkDestroyDeferredOperationKHRPtr = DeviceCmds
-> FunPtr
     (Ptr Device_T
      -> DeferredOperationKHR
      -> ("pAllocator" ::: Ptr AllocationCallbacks)
      -> IO ())
pVkDestroyDeferredOperationKHR (case Device
device of Device{DeviceCmds
deviceCmds :: DeviceCmds
$sel:deviceCmds:Device :: Device -> DeviceCmds
deviceCmds} -> DeviceCmds
deviceCmds)
  IO () -> ContT () IO ()
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (IO () -> ContT () IO ()) -> IO () -> ContT () IO ()
forall a b. (a -> b) -> a -> b
$ Bool -> IO () -> IO ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless (FunPtr
  (Ptr Device_T
   -> DeferredOperationKHR
   -> ("pAllocator" ::: Ptr AllocationCallbacks)
   -> IO ())
vkDestroyDeferredOperationKHRPtr FunPtr
  (Ptr Device_T
   -> DeferredOperationKHR
   -> ("pAllocator" ::: Ptr AllocationCallbacks)
   -> IO ())
-> FunPtr
     (Ptr Device_T
      -> DeferredOperationKHR
      -> ("pAllocator" ::: Ptr AllocationCallbacks)
      -> IO ())
-> Bool
forall a. Eq a => a -> a -> Bool
/= FunPtr
  (Ptr Device_T
   -> DeferredOperationKHR
   -> ("pAllocator" ::: Ptr AllocationCallbacks)
   -> IO ())
forall a. FunPtr a
nullFunPtr) (IO () -> IO ()) -> IO () -> IO ()
forall a b. (a -> b) -> a -> b
$
    IOException -> IO ()
forall e a. Exception e => e -> IO a
throwIO (IOException -> IO ()) -> IOException -> IO ()
forall a b. (a -> b) -> a -> b
$ Maybe Handle
-> IOErrorType
-> String
-> String
-> Maybe CInt
-> Maybe String
-> IOException
IOError Maybe Handle
forall a. Maybe a
Nothing IOErrorType
InvalidArgument String
"" String
"The function pointer for vkDestroyDeferredOperationKHR is null" Maybe CInt
forall a. Maybe a
Nothing Maybe String
forall a. Maybe a
Nothing
  let vkDestroyDeferredOperationKHR' :: Ptr Device_T
-> DeferredOperationKHR
-> ("pAllocator" ::: Ptr AllocationCallbacks)
-> IO ()
vkDestroyDeferredOperationKHR' = FunPtr
  (Ptr Device_T
   -> DeferredOperationKHR
   -> ("pAllocator" ::: Ptr AllocationCallbacks)
   -> IO ())
-> Ptr Device_T
-> DeferredOperationKHR
-> ("pAllocator" ::: Ptr AllocationCallbacks)
-> IO ()
mkVkDestroyDeferredOperationKHR FunPtr
  (Ptr Device_T
   -> DeferredOperationKHR
   -> ("pAllocator" ::: Ptr AllocationCallbacks)
   -> IO ())
vkDestroyDeferredOperationKHRPtr
  "pAllocator" ::: Ptr AllocationCallbacks
pAllocator <- case ("allocator" ::: Maybe AllocationCallbacks
allocator) of
    "allocator" ::: Maybe AllocationCallbacks
Nothing -> ("pAllocator" ::: Ptr AllocationCallbacks)
-> ContT () IO ("pAllocator" ::: Ptr AllocationCallbacks)
forall (f :: * -> *) a. Applicative f => a -> f a
pure "pAllocator" ::: Ptr AllocationCallbacks
forall a. Ptr a
nullPtr
    Just AllocationCallbacks
j -> ((("pAllocator" ::: Ptr AllocationCallbacks) -> IO ()) -> IO ())
-> ContT () IO ("pAllocator" ::: Ptr AllocationCallbacks)
forall k (r :: k) (m :: k -> *) a.
((a -> m r) -> m r) -> ContT r m a
ContT (((("pAllocator" ::: Ptr AllocationCallbacks) -> IO ()) -> IO ())
 -> ContT () IO ("pAllocator" ::: Ptr AllocationCallbacks))
-> ((("pAllocator" ::: Ptr AllocationCallbacks) -> IO ()) -> IO ())
-> ContT () IO ("pAllocator" ::: Ptr AllocationCallbacks)
forall a b. (a -> b) -> a -> b
$ AllocationCallbacks
-> (("pAllocator" ::: Ptr AllocationCallbacks) -> IO ()) -> IO ()
forall a b. ToCStruct a => a -> (Ptr a -> IO b) -> IO b
withCStruct (AllocationCallbacks
j)
  IO () -> ContT () IO ()
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (IO () -> ContT () IO ()) -> IO () -> ContT () IO ()
forall a b. (a -> b) -> a -> b
$ String -> IO () -> IO ()
forall a. String -> IO a -> IO a
traceAroundEvent String
"vkDestroyDeferredOperationKHR" (Ptr Device_T
-> DeferredOperationKHR
-> ("pAllocator" ::: Ptr AllocationCallbacks)
-> IO ()
vkDestroyDeferredOperationKHR' (Device -> Ptr Device_T
deviceHandle (Device
device)) (DeferredOperationKHR
operation) "pAllocator" ::: Ptr AllocationCallbacks
pAllocator)
  () -> ContT () IO ()
forall (f :: * -> *) a. Applicative f => a -> f a
pure (() -> ContT () IO ()) -> () -> ContT () IO ()
forall a b. (a -> b) -> a -> b
$ ()


foreign import ccall
#if !defined(SAFE_FOREIGN_CALLS)
  unsafe
#endif
  "dynamic" mkVkGetDeferredOperationMaxConcurrencyKHR
  :: FunPtr (Ptr Device_T -> DeferredOperationKHR -> IO Word32) -> Ptr Device_T -> DeferredOperationKHR -> IO Word32

-- | vkGetDeferredOperationMaxConcurrencyKHR - Query the maximum concurrency
-- on a deferred operation
--
-- = Description
--
-- The returned value is the maximum number of threads that can usefully
-- execute a deferred operation concurrently, reported for the state of the
-- deferred operation at the point this command is called. This value is
-- intended to be used to better schedule work onto available threads.
-- Applications /can/ join any number of threads to the deferred operation
-- and expect it to eventually complete, though excessive joins /may/
-- return 'Vulkan.Core10.Enums.Result.THREAD_DONE_KHR' immediately,
-- performing no useful work.
--
-- If @operation@ is complete, 'getDeferredOperationMaxConcurrencyKHR'
-- returns zero.
--
-- If @operation@ is currently joined to any threads, the value returned by
-- this command /may/ immediately be out of date.
--
-- If @operation@ is pending, implementations /must/ not return zero unless
-- at least one thread is currently executing 'deferredOperationJoinKHR' on
-- @operation@. If there are such threads, the implementation /should/
-- return an estimate of the number of additional threads which it could
-- profitably use.
--
-- Implementations /may/ return 232-1 to indicate that the maximum
-- concurrency is unknown and cannot be easily derived. Implementations
-- /may/ return values larger than the maximum concurrency available on the
-- host CPU. In these situations, an application /should/ clamp the return
-- value rather than oversubscribing the machine.
--
-- Note
--
-- The recommended usage pattern for applications is to query this value
-- once, after deferral, and schedule no more than the specified number of
-- threads to join the operation. Each time a joined thread receives
-- 'Vulkan.Core10.Enums.Result.THREAD_IDLE_KHR', the application should
-- schedule an additional join at some point in the future, but is not
-- required to do so.
--
-- == Valid Usage (Implicit)
--
-- = See Also
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#VK_KHR_deferred_host_operations VK_KHR_deferred_host_operations>,
-- 'Vulkan.Extensions.Handles.DeferredOperationKHR',
-- 'Vulkan.Core10.Handles.Device'
getDeferredOperationMaxConcurrencyKHR :: forall io
                                       . (MonadIO io)
                                      => -- | @device@ is the device which owns @operation@.
                                         --
                                         -- #VUID-vkGetDeferredOperationMaxConcurrencyKHR-device-parameter# @device@
                                         -- /must/ be a valid 'Vulkan.Core10.Handles.Device' handle
                                         Device
                                      -> -- | @operation@ is the deferred operation to be queried.
                                         --
                                         -- #VUID-vkGetDeferredOperationMaxConcurrencyKHR-operation-parameter#
                                         -- @operation@ /must/ be a valid
                                         -- 'Vulkan.Extensions.Handles.DeferredOperationKHR' handle
                                         --
                                         -- #VUID-vkGetDeferredOperationMaxConcurrencyKHR-operation-parent#
                                         -- @operation@ /must/ have been created, allocated, or retrieved from
                                         -- @device@
                                         DeferredOperationKHR
                                      -> io (Word32)
getDeferredOperationMaxConcurrencyKHR :: Device -> DeferredOperationKHR -> io Word32
getDeferredOperationMaxConcurrencyKHR Device
device DeferredOperationKHR
operation = IO Word32 -> io Word32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> io Word32) -> IO Word32 -> io Word32
forall a b. (a -> b) -> a -> b
$ do
  let vkGetDeferredOperationMaxConcurrencyKHRPtr :: FunPtr (Ptr Device_T -> DeferredOperationKHR -> IO Word32)
vkGetDeferredOperationMaxConcurrencyKHRPtr = DeviceCmds
-> FunPtr (Ptr Device_T -> DeferredOperationKHR -> IO Word32)
pVkGetDeferredOperationMaxConcurrencyKHR (case Device
device of Device{DeviceCmds
deviceCmds :: DeviceCmds
$sel:deviceCmds:Device :: Device -> DeviceCmds
deviceCmds} -> DeviceCmds
deviceCmds)
  Bool -> IO () -> IO ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless (FunPtr (Ptr Device_T -> DeferredOperationKHR -> IO Word32)
vkGetDeferredOperationMaxConcurrencyKHRPtr FunPtr (Ptr Device_T -> DeferredOperationKHR -> IO Word32)
-> FunPtr (Ptr Device_T -> DeferredOperationKHR -> IO Word32)
-> Bool
forall a. Eq a => a -> a -> Bool
/= FunPtr (Ptr Device_T -> DeferredOperationKHR -> IO Word32)
forall a. FunPtr a
nullFunPtr) (IO () -> IO ()) -> IO () -> IO ()
forall a b. (a -> b) -> a -> b
$
    IOException -> IO ()
forall e a. Exception e => e -> IO a
throwIO (IOException -> IO ()) -> IOException -> IO ()
forall a b. (a -> b) -> a -> b
$ Maybe Handle
-> IOErrorType
-> String
-> String
-> Maybe CInt
-> Maybe String
-> IOException
IOError Maybe Handle
forall a. Maybe a
Nothing IOErrorType
InvalidArgument String
"" String
"The function pointer for vkGetDeferredOperationMaxConcurrencyKHR is null" Maybe CInt
forall a. Maybe a
Nothing Maybe String
forall a. Maybe a
Nothing
  let vkGetDeferredOperationMaxConcurrencyKHR' :: Ptr Device_T -> DeferredOperationKHR -> IO Word32
vkGetDeferredOperationMaxConcurrencyKHR' = FunPtr (Ptr Device_T -> DeferredOperationKHR -> IO Word32)
-> Ptr Device_T -> DeferredOperationKHR -> IO Word32
mkVkGetDeferredOperationMaxConcurrencyKHR FunPtr (Ptr Device_T -> DeferredOperationKHR -> IO Word32)
vkGetDeferredOperationMaxConcurrencyKHRPtr
  Word32
r <- String -> IO Word32 -> IO Word32
forall a. String -> IO a -> IO a
traceAroundEvent String
"vkGetDeferredOperationMaxConcurrencyKHR" (Ptr Device_T -> DeferredOperationKHR -> IO Word32
vkGetDeferredOperationMaxConcurrencyKHR' (Device -> Ptr Device_T
deviceHandle (Device
device)) (DeferredOperationKHR
operation))
  Word32 -> IO Word32
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Word32 -> IO Word32) -> Word32 -> IO Word32
forall a b. (a -> b) -> a -> b
$ (Word32
r)


foreign import ccall
#if !defined(SAFE_FOREIGN_CALLS)
  unsafe
#endif
  "dynamic" mkVkGetDeferredOperationResultKHR
  :: FunPtr (Ptr Device_T -> DeferredOperationKHR -> IO Result) -> Ptr Device_T -> DeferredOperationKHR -> IO Result

-- | vkGetDeferredOperationResultKHR - Query the result of a deferred
-- operation
--
-- = Description
--
-- If no command has been deferred on @operation@,
-- 'getDeferredOperationResultKHR' returns
-- 'Vulkan.Core10.Enums.Result.SUCCESS'.
--
-- If the deferred operation is pending, 'getDeferredOperationResultKHR'
-- returns 'Vulkan.Core10.Enums.Result.NOT_READY'.
--
-- If the deferred operation is complete, it returns the appropriate return
-- value from the original command. This value /must/ be one of the
-- 'Vulkan.Core10.Enums.Result.Result' values which could have been
-- returned by the original command if the operation had not been deferred.
--
-- == Return Codes
--
-- [<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#fundamentals-successcodes Success>]
--
--     -   'Vulkan.Core10.Enums.Result.SUCCESS'
--
--     -   'Vulkan.Core10.Enums.Result.NOT_READY'
--
-- = See Also
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#VK_KHR_deferred_host_operations VK_KHR_deferred_host_operations>,
-- 'Vulkan.Extensions.Handles.DeferredOperationKHR',
-- 'Vulkan.Core10.Handles.Device'
getDeferredOperationResultKHR :: forall io
                               . (MonadIO io)
                              => -- | @device@ is the device which owns @operation@.
                                 --
                                 -- #VUID-vkGetDeferredOperationResultKHR-device-parameter# @device@ /must/
                                 -- be a valid 'Vulkan.Core10.Handles.Device' handle
                                 Device
                              -> -- | @operation@ is the operation whose deferred result is being queried.
                                 --
                                 -- #VUID-vkGetDeferredOperationResultKHR-operation-parameter# @operation@
                                 -- /must/ be a valid 'Vulkan.Extensions.Handles.DeferredOperationKHR'
                                 -- handle
                                 --
                                 -- #VUID-vkGetDeferredOperationResultKHR-operation-parent# @operation@
                                 -- /must/ have been created, allocated, or retrieved from @device@
                                 DeferredOperationKHR
                              -> io (Result)
getDeferredOperationResultKHR :: Device -> DeferredOperationKHR -> io Result
getDeferredOperationResultKHR Device
device DeferredOperationKHR
operation = IO Result -> io Result
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Result -> io Result) -> IO Result -> io Result
forall a b. (a -> b) -> a -> b
$ do
  let vkGetDeferredOperationResultKHRPtr :: FunPtr (Ptr Device_T -> DeferredOperationKHR -> IO Result)
vkGetDeferredOperationResultKHRPtr = DeviceCmds
-> FunPtr (Ptr Device_T -> DeferredOperationKHR -> IO Result)
pVkGetDeferredOperationResultKHR (case Device
device of Device{DeviceCmds
deviceCmds :: DeviceCmds
$sel:deviceCmds:Device :: Device -> DeviceCmds
deviceCmds} -> DeviceCmds
deviceCmds)
  Bool -> IO () -> IO ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless (FunPtr (Ptr Device_T -> DeferredOperationKHR -> IO Result)
vkGetDeferredOperationResultKHRPtr FunPtr (Ptr Device_T -> DeferredOperationKHR -> IO Result)
-> FunPtr (Ptr Device_T -> DeferredOperationKHR -> IO Result)
-> Bool
forall a. Eq a => a -> a -> Bool
/= FunPtr (Ptr Device_T -> DeferredOperationKHR -> IO Result)
forall a. FunPtr a
nullFunPtr) (IO () -> IO ()) -> IO () -> IO ()
forall a b. (a -> b) -> a -> b
$
    IOException -> IO ()
forall e a. Exception e => e -> IO a
throwIO (IOException -> IO ()) -> IOException -> IO ()
forall a b. (a -> b) -> a -> b
$ Maybe Handle
-> IOErrorType
-> String
-> String
-> Maybe CInt
-> Maybe String
-> IOException
IOError Maybe Handle
forall a. Maybe a
Nothing IOErrorType
InvalidArgument String
"" String
"The function pointer for vkGetDeferredOperationResultKHR is null" Maybe CInt
forall a. Maybe a
Nothing Maybe String
forall a. Maybe a
Nothing
  let vkGetDeferredOperationResultKHR' :: Ptr Device_T -> DeferredOperationKHR -> IO Result
vkGetDeferredOperationResultKHR' = FunPtr (Ptr Device_T -> DeferredOperationKHR -> IO Result)
-> Ptr Device_T -> DeferredOperationKHR -> IO Result
mkVkGetDeferredOperationResultKHR FunPtr (Ptr Device_T -> DeferredOperationKHR -> IO Result)
vkGetDeferredOperationResultKHRPtr
  Result
r <- String -> IO Result -> IO Result
forall a. String -> IO a -> IO a
traceAroundEvent String
"vkGetDeferredOperationResultKHR" (Ptr Device_T -> DeferredOperationKHR -> IO Result
vkGetDeferredOperationResultKHR' (Device -> Ptr Device_T
deviceHandle (Device
device)) (DeferredOperationKHR
operation))
  Result -> IO Result
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Result -> IO Result) -> Result -> IO Result
forall a b. (a -> b) -> a -> b
$ (Result
r)


foreign import ccall
#if !defined(SAFE_FOREIGN_CALLS)
  unsafe
#endif
  "dynamic" mkVkDeferredOperationJoinKHR
  :: FunPtr (Ptr Device_T -> DeferredOperationKHR -> IO Result) -> Ptr Device_T -> DeferredOperationKHR -> IO Result

-- | vkDeferredOperationJoinKHR - Assign a thread to a deferred operation
--
-- = Description
--
-- The 'deferredOperationJoinKHR' command will execute a portion of the
-- deferred operation on the calling thread.
--
-- The return value will be one of the following:
--
-- -   A return value of 'Vulkan.Core10.Enums.Result.SUCCESS' indicates
--     that @operation@ is complete. The application /should/ use
--     'getDeferredOperationResultKHR' to retrieve the result of
--     @operation@.
--
-- -   A return value of 'Vulkan.Core10.Enums.Result.THREAD_DONE_KHR'
--     indicates that the deferred operation is not complete, but there is
--     no work remaining to assign to threads. Future calls to
--     'deferredOperationJoinKHR' are not necessary and will simply harm
--     performance. This situation /may/ occur when other threads executing
--     'deferredOperationJoinKHR' are about to complete @operation@, and
--     the implementation is unable to partition the workload any further.
--
-- -   A return value of 'Vulkan.Core10.Enums.Result.THREAD_IDLE_KHR'
--     indicates that the deferred operation is not complete, and there is
--     no work for the thread to do at the time of the call. This situation
--     /may/ occur if the operation encounters a temporary reduction in
--     parallelism. By returning
--     'Vulkan.Core10.Enums.Result.THREAD_IDLE_KHR', the implementation is
--     signaling that it expects that more opportunities for parallelism
--     will emerge as execution progresses, and that future calls to
--     'deferredOperationJoinKHR' /can/ be beneficial. In the meantime, the
--     application /can/ perform other work on the calling thread.
--
-- Implementations /must/ guarantee forward progress by enforcing the
-- following invariants:
--
-- 1.  If only one thread has invoked 'deferredOperationJoinKHR' on a given
--     operation, that thread /must/ execute the operation to completion
--     and return 'Vulkan.Core10.Enums.Result.SUCCESS'.
--
-- 2.  If multiple threads have concurrently invoked
--     'deferredOperationJoinKHR' on the same operation, then at least one
--     of them /must/ complete the operation and return
--     'Vulkan.Core10.Enums.Result.SUCCESS'.
--
-- == Valid Usage (Implicit)
--
-- -   #VUID-vkDeferredOperationJoinKHR-device-parameter# @device@ /must/
--     be a valid 'Vulkan.Core10.Handles.Device' handle
--
-- -   #VUID-vkDeferredOperationJoinKHR-operation-parameter# @operation@
--     /must/ be a valid 'Vulkan.Extensions.Handles.DeferredOperationKHR'
--     handle
--
-- -   #VUID-vkDeferredOperationJoinKHR-operation-parent# @operation@
--     /must/ have been created, allocated, or retrieved from @device@
--
-- == Return Codes
--
-- [<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#fundamentals-successcodes Success>]
--
--     -   'Vulkan.Core10.Enums.Result.SUCCESS'
--
--     -   'Vulkan.Core10.Enums.Result.THREAD_DONE_KHR'
--
--     -   'Vulkan.Core10.Enums.Result.THREAD_IDLE_KHR'
--
-- [<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#fundamentals-errorcodes Failure>]
--
--     -   'Vulkan.Core10.Enums.Result.ERROR_OUT_OF_HOST_MEMORY'
--
--     -   'Vulkan.Core10.Enums.Result.ERROR_OUT_OF_DEVICE_MEMORY'
--
-- = See Also
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#VK_KHR_deferred_host_operations VK_KHR_deferred_host_operations>,
-- 'Vulkan.Extensions.Handles.DeferredOperationKHR',
-- 'Vulkan.Core10.Handles.Device'
deferredOperationJoinKHR :: forall io
                          . (MonadIO io)
                         => -- | @device@ is the device which owns @operation@.
                            Device
                         -> -- | @operation@ is the deferred operation that the calling thread should
                            -- work on.
                            DeferredOperationKHR
                         -> io (Result)
deferredOperationJoinKHR :: Device -> DeferredOperationKHR -> io Result
deferredOperationJoinKHR Device
device DeferredOperationKHR
operation = IO Result -> io Result
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Result -> io Result) -> IO Result -> io Result
forall a b. (a -> b) -> a -> b
$ do
  let vkDeferredOperationJoinKHRPtr :: FunPtr (Ptr Device_T -> DeferredOperationKHR -> IO Result)
vkDeferredOperationJoinKHRPtr = DeviceCmds
-> FunPtr (Ptr Device_T -> DeferredOperationKHR -> IO Result)
pVkDeferredOperationJoinKHR (case Device
device of Device{DeviceCmds
deviceCmds :: DeviceCmds
$sel:deviceCmds:Device :: Device -> DeviceCmds
deviceCmds} -> DeviceCmds
deviceCmds)
  Bool -> IO () -> IO ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless (FunPtr (Ptr Device_T -> DeferredOperationKHR -> IO Result)
vkDeferredOperationJoinKHRPtr FunPtr (Ptr Device_T -> DeferredOperationKHR -> IO Result)
-> FunPtr (Ptr Device_T -> DeferredOperationKHR -> IO Result)
-> Bool
forall a. Eq a => a -> a -> Bool
/= FunPtr (Ptr Device_T -> DeferredOperationKHR -> IO Result)
forall a. FunPtr a
nullFunPtr) (IO () -> IO ()) -> IO () -> IO ()
forall a b. (a -> b) -> a -> b
$
    IOException -> IO ()
forall e a. Exception e => e -> IO a
throwIO (IOException -> IO ()) -> IOException -> IO ()
forall a b. (a -> b) -> a -> b
$ Maybe Handle
-> IOErrorType
-> String
-> String
-> Maybe CInt
-> Maybe String
-> IOException
IOError Maybe Handle
forall a. Maybe a
Nothing IOErrorType
InvalidArgument String
"" String
"The function pointer for vkDeferredOperationJoinKHR is null" Maybe CInt
forall a. Maybe a
Nothing Maybe String
forall a. Maybe a
Nothing
  let vkDeferredOperationJoinKHR' :: Ptr Device_T -> DeferredOperationKHR -> IO Result
vkDeferredOperationJoinKHR' = FunPtr (Ptr Device_T -> DeferredOperationKHR -> IO Result)
-> Ptr Device_T -> DeferredOperationKHR -> IO Result
mkVkDeferredOperationJoinKHR FunPtr (Ptr Device_T -> DeferredOperationKHR -> IO Result)
vkDeferredOperationJoinKHRPtr
  Result
r <- String -> IO Result -> IO Result
forall a. String -> IO a -> IO a
traceAroundEvent String
"vkDeferredOperationJoinKHR" (Ptr Device_T -> DeferredOperationKHR -> IO Result
vkDeferredOperationJoinKHR' (Device -> Ptr Device_T
deviceHandle (Device
device)) (DeferredOperationKHR
operation))
  Bool -> IO () -> IO ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Result
r Result -> Result -> Bool
forall a. Ord a => a -> a -> Bool
< Result
SUCCESS) (VulkanException -> IO ()
forall e a. Exception e => e -> IO a
throwIO (Result -> VulkanException
VulkanException Result
r))
  Result -> IO Result
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Result -> IO Result) -> Result -> IO Result
forall a b. (a -> b) -> a -> b
$ (Result
r)


type KHR_DEFERRED_HOST_OPERATIONS_SPEC_VERSION = 4

-- No documentation found for TopLevel "VK_KHR_DEFERRED_HOST_OPERATIONS_SPEC_VERSION"
pattern KHR_DEFERRED_HOST_OPERATIONS_SPEC_VERSION :: forall a . Integral a => a
pattern $bKHR_DEFERRED_HOST_OPERATIONS_SPEC_VERSION :: a
$mKHR_DEFERRED_HOST_OPERATIONS_SPEC_VERSION :: forall r a. Integral a => a -> (Void# -> r) -> (Void# -> r) -> r
KHR_DEFERRED_HOST_OPERATIONS_SPEC_VERSION = 4


type KHR_DEFERRED_HOST_OPERATIONS_EXTENSION_NAME = "VK_KHR_deferred_host_operations"

-- No documentation found for TopLevel "VK_KHR_DEFERRED_HOST_OPERATIONS_EXTENSION_NAME"
pattern KHR_DEFERRED_HOST_OPERATIONS_EXTENSION_NAME :: forall a . (Eq a, IsString a) => a
pattern $bKHR_DEFERRED_HOST_OPERATIONS_EXTENSION_NAME :: a
$mKHR_DEFERRED_HOST_OPERATIONS_EXTENSION_NAME :: forall r a.
(Eq a, IsString a) =>
a -> (Void# -> r) -> (Void# -> r) -> r
KHR_DEFERRED_HOST_OPERATIONS_EXTENSION_NAME = "VK_KHR_deferred_host_operations"