{-# LANGUAGE ImportQualifiedPost #-}
{-# LANGUAGE BlockArguments #-}
{-# LANGUAGE MonoLocalBinds #-}
{-# LANGUAGE FlexibleContexts, UndecidableInstances #-}
{-# LANGUAGE PatternSynonyms, ViewPatterns #-}
{-# LANGUAGE StandaloneDeriving #-}
{-# OPTIONS_GHC -Wall -fno-warn-tabs #-}

module Gpu.Vulkan.Sampler.Middle.Internal where

import Foreign.Ptr
import Foreign.Marshal.Alloc
import Foreign.Storable	
import Foreign.Storable.PeekPoke
import Data.TypeLevel.Maybe qualified as TMaybe
import Data.TypeLevel.ParMaybe qualified as TPMaybe

import Gpu.Vulkan.Base.Middle.Internal
import Gpu.Vulkan.Enum
import Gpu.Vulkan.Exception.Middle.Internal
import Gpu.Vulkan.Exception.Enum
import Gpu.Vulkan.Sampler.Enum

import Gpu.Vulkan.AllocationCallbacks.Middle.Internal
	qualified as AllocationCallbacks
import qualified Gpu.Vulkan.Device.Middle.Internal as Device
import qualified Gpu.Vulkan.Sampler.Core as C

newtype S = S C.S deriving Int -> S -> ShowS
[S] -> ShowS
S -> String
(Int -> S -> ShowS) -> (S -> String) -> ([S] -> ShowS) -> Show S
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> S -> ShowS
showsPrec :: Int -> S -> ShowS
$cshow :: S -> String
show :: S -> String
$cshowList :: [S] -> ShowS
showList :: [S] -> ShowS
Show

pattern Null :: S
pattern $mNull :: forall {r}. S -> ((# #) -> r) -> ((# #) -> r) -> r
$bNull :: S
Null <- S NullHandle where
	Null = S -> S
S S
forall a. Ptr a
NullHandle

data CreateInfo mn = CreateInfo {
	forall (mn :: Maybe (*)). CreateInfo mn -> M mn
createInfoNext :: TMaybe.M mn,
	forall (mn :: Maybe (*)). CreateInfo mn -> CreateFlags
createInfoFlags :: CreateFlags,
	forall (mn :: Maybe (*)). CreateInfo mn -> Filter
createInfoMagFilter :: Filter,
	forall (mn :: Maybe (*)). CreateInfo mn -> Filter
createInfoMinFilter :: Filter,
	forall (mn :: Maybe (*)). CreateInfo mn -> MipmapMode
createInfoMipmapMode :: MipmapMode,
	forall (mn :: Maybe (*)). CreateInfo mn -> AddressMode
createInfoAddressModeU :: AddressMode,
	forall (mn :: Maybe (*)). CreateInfo mn -> AddressMode
createInfoAddressModeV :: AddressMode,
	forall (mn :: Maybe (*)). CreateInfo mn -> AddressMode
createInfoAddressModeW :: AddressMode,
	forall (mn :: Maybe (*)). CreateInfo mn -> Float
createInfoMipLodBias :: Float,
	forall (mn :: Maybe (*)). CreateInfo mn -> Bool
createInfoAnisotropyEnable :: Bool,
	forall (mn :: Maybe (*)). CreateInfo mn -> Float
createInfoMaxAnisotropy :: Float,
	forall (mn :: Maybe (*)). CreateInfo mn -> Bool
createInfoCompareEnable :: Bool,
	forall (mn :: Maybe (*)). CreateInfo mn -> CompareOp
createInfoCompareOp :: CompareOp,
	forall (mn :: Maybe (*)). CreateInfo mn -> Float
createInfoMinLod :: Float,
	forall (mn :: Maybe (*)). CreateInfo mn -> Float
createInfoMaxLod :: Float,
	forall (mn :: Maybe (*)). CreateInfo mn -> BorderColor
createInfoBorderColor :: BorderColor,
	forall (mn :: Maybe (*)). CreateInfo mn -> Bool
createInfoUnnormalizedCoordinates :: Bool }

deriving instance Show (TMaybe.M mn) => Show (CreateInfo mn)

createInfoToCore :: WithPoked (TMaybe.M mn) =>
	CreateInfo mn -> (Ptr C.CreateInfo -> IO r) -> IO ()
createInfoToCore :: forall (mn :: Maybe (*)) r.
WithPoked (M mn) =>
CreateInfo mn -> (Ptr CreateInfo -> IO r) -> IO ()
createInfoToCore CreateInfo {
	createInfoNext :: forall (mn :: Maybe (*)). CreateInfo mn -> M mn
createInfoNext = M mn
mnxt,
	createInfoFlags :: forall (mn :: Maybe (*)). CreateInfo mn -> CreateFlags
createInfoFlags = CreateFlagBits Word32
flgs,
	createInfoMagFilter :: forall (mn :: Maybe (*)). CreateInfo mn -> Filter
createInfoMagFilter = Filter Word32
mgf,
	createInfoMinFilter :: forall (mn :: Maybe (*)). CreateInfo mn -> Filter
createInfoMinFilter = Filter Word32
mnf,
	createInfoMipmapMode :: forall (mn :: Maybe (*)). CreateInfo mn -> MipmapMode
createInfoMipmapMode = MipmapMode Word32
mmm,
	createInfoAddressModeU :: forall (mn :: Maybe (*)). CreateInfo mn -> AddressMode
createInfoAddressModeU = AddressMode Word32
amu,
	createInfoAddressModeV :: forall (mn :: Maybe (*)). CreateInfo mn -> AddressMode
createInfoAddressModeV = AddressMode Word32
amv,
	createInfoAddressModeW :: forall (mn :: Maybe (*)). CreateInfo mn -> AddressMode
createInfoAddressModeW = AddressMode Word32
amw,
	createInfoMipLodBias :: forall (mn :: Maybe (*)). CreateInfo mn -> Float
createInfoMipLodBias = Float
mlb,
	createInfoAnisotropyEnable :: forall (mn :: Maybe (*)). CreateInfo mn -> Bool
createInfoAnisotropyEnable = Bool -> Word32
boolToBool32 -> Word32
aie,
	createInfoMaxAnisotropy :: forall (mn :: Maybe (*)). CreateInfo mn -> Float
createInfoMaxAnisotropy = Float
mai,
	createInfoCompareEnable :: forall (mn :: Maybe (*)). CreateInfo mn -> Bool
createInfoCompareEnable = Bool -> Word32
boolToBool32 -> Word32
ce,
	createInfoCompareOp :: forall (mn :: Maybe (*)). CreateInfo mn -> CompareOp
createInfoCompareOp = CompareOp Word32
cop,
	createInfoMinLod :: forall (mn :: Maybe (*)). CreateInfo mn -> Float
createInfoMinLod = Float
mnl,
	createInfoMaxLod :: forall (mn :: Maybe (*)). CreateInfo mn -> Float
createInfoMaxLod = Float
mxl,
	createInfoBorderColor :: forall (mn :: Maybe (*)). CreateInfo mn -> BorderColor
createInfoBorderColor = BorderColor Word32
bc,
	createInfoUnnormalizedCoordinates :: forall (mn :: Maybe (*)). CreateInfo mn -> Bool
createInfoUnnormalizedCoordinates = Bool -> Word32
boolToBool32 -> Word32
unc } Ptr CreateInfo -> IO r
f =
	M mn -> (forall s. PtrS s (M mn) -> IO ()) -> IO ()
forall a b.
WithPoked a =>
a -> (forall s. PtrS s a -> IO b) -> IO b
forall b. M mn -> (forall s. PtrS s (M mn) -> IO b) -> IO b
withPoked' M mn
mnxt \PtrS s (M mn)
pnxt -> PtrS s (M mn) -> (Ptr (M mn) -> IO r) -> IO ()
forall s a b. PtrS s a -> (Ptr a -> IO b) -> IO ()
withPtrS PtrS s (M mn)
pnxt \(Ptr (M mn) -> Ptr ()
forall a b. Ptr a -> Ptr b
castPtr -> Ptr ()
pnxt') ->
	let	ci :: CreateInfo
ci = C.CreateInfo {
			createInfoSType :: ()
C.createInfoSType = (),
			createInfoPNext :: Ptr ()
C.createInfoPNext = Ptr ()
pnxt',
			createInfoFlags :: Word32
C.createInfoFlags = Word32
flgs,
			createInfoMagFilter :: Word32
C.createInfoMagFilter = Word32
mgf,
			createInfoMinFilter :: Word32
C.createInfoMinFilter = Word32
mnf,
			createInfoMipmapMode :: Word32
C.createInfoMipmapMode = Word32
mmm,
			createInfoAddressModeU :: Word32
C.createInfoAddressModeU = Word32
amu,
			createInfoAddressModeV :: Word32
C.createInfoAddressModeV = Word32
amv,
			createInfoAddressModeW :: Word32
C.createInfoAddressModeW = Word32
amw,
			createInfoMipLodBias :: Float
C.createInfoMipLodBias = Float
mlb,
			createInfoAnisotropyEnable :: Word32
C.createInfoAnisotropyEnable = Word32
aie,
			createInfoMaxAnisotropy :: Float
C.createInfoMaxAnisotropy = Float
mai,
			createInfoCompareEnable :: Word32
C.createInfoCompareEnable = Word32
ce,
			createInfoCompareOp :: Word32
C.createInfoCompareOp = Word32
cop,
			createInfoMinLod :: Float
C.createInfoMinLod = Float
mnl,
			createInfoMaxLod :: Float
C.createInfoMaxLod = Float
mxl,
			createInfoBorderColor :: Word32
C.createInfoBorderColor = Word32
bc,
			createInfoUnnormalizedCoordinates :: Word32
C.createInfoUnnormalizedCoordinates = Word32
unc } in
	CreateInfo -> (Ptr CreateInfo -> IO r) -> IO r
forall a b. Pokable a => a -> (Ptr a -> IO b) -> IO b
withPoked CreateInfo
ci Ptr CreateInfo -> IO r
f

create :: WithPoked (TMaybe.M mn) =>
	Device.D -> CreateInfo mn -> TPMaybe.M AllocationCallbacks.A mc -> IO S
create :: forall (mn :: Maybe (*)) (mc :: Maybe (*)).
WithPoked (M mn) =>
D -> CreateInfo mn -> M A mc -> IO S
create (Device.D D
dvc) CreateInfo mn
ci M A mc
mac = S -> S
S (S -> S) -> IO S -> IO S
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Ptr S -> IO S) -> IO S
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca \Ptr S
ps -> do
	CreateInfo mn -> (Ptr CreateInfo -> IO ()) -> IO ()
forall (mn :: Maybe (*)) r.
WithPoked (M mn) =>
CreateInfo mn -> (Ptr CreateInfo -> IO r) -> IO ()
createInfoToCore CreateInfo mn
ci \Ptr CreateInfo
pci ->
		M A mc -> (Ptr A -> IO ()) -> IO ()
forall (ma :: Maybe (*)) b. M A ma -> (Ptr A -> IO b) -> IO ()
AllocationCallbacks.mToCore M A mc
mac \Ptr A
pac ->
			Result -> IO ()
throwUnlessSuccess (Result -> IO ()) -> (Int32 -> Result) -> Int32 -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int32 -> Result
Result
				(Int32 -> IO ()) -> IO Int32 -> IO ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< D -> Ptr CreateInfo -> Ptr A -> Ptr S -> IO Int32
C.create D
dvc Ptr CreateInfo
pci Ptr A
pac Ptr S
ps
	Ptr S -> IO S
forall a. Storable a => Ptr a -> IO a
peek Ptr S
ps

destroy :: Device.D -> S -> TPMaybe.M AllocationCallbacks.A md -> IO ()
destroy :: forall (md :: Maybe (*)). D -> S -> M A md -> IO ()
destroy (Device.D D
dvc) (S S
s) M A md
mac =
	M A md -> (Ptr A -> IO ()) -> IO ()
forall (ma :: Maybe (*)) b. M A ma -> (Ptr A -> IO b) -> IO ()
AllocationCallbacks.mToCore M A md
mac ((Ptr A -> IO ()) -> IO ()) -> (Ptr A -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ D -> S -> Ptr A -> IO ()
C.destroy D
dvc S
s