{-# LANGUAGE ImportQualifiedPost #-}
{-# LANGUAGE BlockArguments #-}
{-# LANGUAGE MonoLocalBinds #-}
{-# OPTIONS_GHC -Wall -fno-warn-tabs #-}

module Gpu.Vulkan.Khr.Surface.Middle.Internal (

	-- * DESTROY

	destroy, S(..),

	-- * CAPABILITIES AND FORMAT

	Capabilities(..), capabilitiesFromCore,
	Format(..), formatFromCore ) where

import Data.Word
import Data.TypeLevel.ParMaybe qualified as TPMaybe

import Gpu.Vulkan.Khr.Surface.Enum

import qualified Gpu.Vulkan.Enum as Vk
import qualified Gpu.Vulkan.Core as C
import Gpu.Vulkan.AllocationCallbacks.Middle.Internal
	qualified as AllocationCallbacks
import qualified Gpu.Vulkan.Khr.Surface.Core as Sfc.C
import qualified Gpu.Vulkan.Image.Enum as Image
import qualified Gpu.Vulkan.Instance.Middle.Internal as Instance

newtype S = S Sfc.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

destroy :: Instance.I -> S -> TPMaybe.M AllocationCallbacks.A mn -> IO ()
destroy :: forall (mn :: Maybe (*)). I -> S -> M A mn -> IO ()
destroy (Instance.I I
ist) (S S
sfc) M A mn
mac =
	M A mn -> (Ptr A -> IO ()) -> IO ()
forall (ma :: Maybe (*)) b. M A ma -> (Ptr A -> IO b) -> IO ()
AllocationCallbacks.mToCore M A mn
mac ((Ptr A -> IO ()) -> IO ()) -> (Ptr A -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ I -> S -> Ptr A -> IO ()
Sfc.C.destroy I
ist S
sfc

data Capabilities = Capabilities {
	Capabilities -> Word32
capabilitiesMinImageCount :: Word32,
	Capabilities -> Word32
capabilitiesMaxImageCount :: Word32,
	Capabilities -> Extent2d
capabilitiesCurrentExtent :: C.Extent2d,
	Capabilities -> Extent2d
capabilitiesMinImageExtent :: C.Extent2d,
	Capabilities -> Extent2d
capabilitiesMaxImageExtent :: C.Extent2d,
	Capabilities -> Word32
capabilitiesMaxImageArrayLayers :: Word32,
	Capabilities -> TransformFlags
capabilitiesSupportedTransforms :: TransformFlags,
	Capabilities -> TransformFlags
capabilitiesCurrentTransform :: TransformFlagBits,
	Capabilities -> CompositeAlphaFlags
capabilitiesSupportedCompositeAlpha :: CompositeAlphaFlags,
	Capabilities -> UsageFlags
capabilitiesSupportedUsageFlags :: Image.UsageFlags }
	deriving Int -> Capabilities -> ShowS
[Capabilities] -> ShowS
Capabilities -> String
(Int -> Capabilities -> ShowS)
-> (Capabilities -> String)
-> ([Capabilities] -> ShowS)
-> Show Capabilities
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Capabilities -> ShowS
showsPrec :: Int -> Capabilities -> ShowS
$cshow :: Capabilities -> String
show :: Capabilities -> String
$cshowList :: [Capabilities] -> ShowS
showList :: [Capabilities] -> ShowS
Show

capabilitiesFromCore :: Sfc.C.Capabilities -> Capabilities
capabilitiesFromCore :: Capabilities -> Capabilities
capabilitiesFromCore Sfc.C.Capabilities {
	capabilitiesMinImageCount :: Capabilities -> Word32
Sfc.C.capabilitiesMinImageCount = Word32
mnic,
	capabilitiesMaxImageCount :: Capabilities -> Word32
Sfc.C.capabilitiesMaxImageCount = Word32
mxic,
	capabilitiesCurrentExtent :: Capabilities -> Extent2d
Sfc.C.capabilitiesCurrentExtent = Extent2d
ce,
	capabilitiesMinImageExtent :: Capabilities -> Extent2d
Sfc.C.capabilitiesMinImageExtent = Extent2d
mnie,
	capabilitiesMaxImageExtent :: Capabilities -> Extent2d
Sfc.C.capabilitiesMaxImageExtent = Extent2d
mxie,
	capabilitiesMaxImageArrayLayers :: Capabilities -> Word32
Sfc.C.capabilitiesMaxImageArrayLayers = Word32
mials,
	capabilitiesSupportedTransforms :: Capabilities -> Word32
Sfc.C.capabilitiesSupportedTransforms = Word32
st,
	capabilitiesCurrentTransform :: Capabilities -> Word32
Sfc.C.capabilitiesCurrentTransform = Word32
ct,
	capabilitiesSupportedCompositeAlpha :: Capabilities -> Word32
Sfc.C.capabilitiesSupportedCompositeAlpha = Word32
sca,
	capabilitiesSupportedUsageFlags :: Capabilities -> Word32
Sfc.C.capabilitiesSupportedUsageFlags = Word32
suf
	} = Capabilities {
		capabilitiesMinImageCount :: Word32
capabilitiesMinImageCount = Word32
mnic,
		capabilitiesMaxImageCount :: Word32
capabilitiesMaxImageCount = Word32
mxic,
		capabilitiesCurrentExtent :: Extent2d
capabilitiesCurrentExtent = Extent2d
ce,
		capabilitiesMinImageExtent :: Extent2d
capabilitiesMinImageExtent = Extent2d
mnie,
		capabilitiesMaxImageExtent :: Extent2d
capabilitiesMaxImageExtent = Extent2d
mxie,
		capabilitiesMaxImageArrayLayers :: Word32
capabilitiesMaxImageArrayLayers = Word32
mials,
		capabilitiesSupportedTransforms :: TransformFlags
capabilitiesSupportedTransforms = Word32 -> TransformFlags
TransformFlagBits Word32
st,
		capabilitiesCurrentTransform :: TransformFlags
capabilitiesCurrentTransform = Word32 -> TransformFlags
TransformFlagBits Word32
ct,
		capabilitiesSupportedCompositeAlpha :: CompositeAlphaFlags
capabilitiesSupportedCompositeAlpha =
			Word32 -> CompositeAlphaFlags
CompositeAlphaFlagBits Word32
sca,
		capabilitiesSupportedUsageFlags :: UsageFlags
capabilitiesSupportedUsageFlags = Word32 -> UsageFlags
Image.UsageFlagBits Word32
suf }

data Format = Format {
	Format -> Format
formatFormat :: Vk.Format,
	Format -> ColorSpace
formatColorSpace :: ColorSpace }
	deriving Int -> Format -> ShowS
[Format] -> ShowS
Format -> String
(Int -> Format -> ShowS)
-> (Format -> String) -> ([Format] -> ShowS) -> Show Format
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Format -> ShowS
showsPrec :: Int -> Format -> ShowS
$cshow :: Format -> String
show :: Format -> String
$cshowList :: [Format] -> ShowS
showList :: [Format] -> ShowS
Show

formatFromCore :: Sfc.C.Format -> Format
formatFromCore :: Format -> Format
formatFromCore Sfc.C.Format {
	formatFormat :: Format -> Word32
Sfc.C.formatFormat = Word32
fmt,
	formatColorSpace :: Format -> Word32
Sfc.C.formatColorSpace = Word32
cs
	} = Format {
		formatFormat :: Format
formatFormat = Word32 -> Format
Vk.Format Word32
fmt,
		formatColorSpace :: ColorSpace
formatColorSpace = Word32 -> ColorSpace
ColorSpace Word32
cs }

{-
formatToCore :: Format -> Sfc.C.Format
formatToCore Format {
	formatFormat = Vk.Format fmt,
	formatColorSpace = ColorSpace cs } = Sfc.C.Format {
		Sfc.C.formatFormat = fmt,
		Sfc.C.formatColorSpace = cs }
-}