{-# LANGUAGE MultiParamTypeClasses #-}

-- |
-- Module      : WGPU.Internal.Multipurpose
-- Description : Multipurpose
--
-- This is a bit like a "Types" module. It exists to collect things which are
-- somewhat generic and are used in more than one part of the API.
module WGPU.Internal.Multipurpose
  ( -- * Types
    CompareFunction (..),
  )
where

import WGPU.Internal.Memory (ToRaw, raw)
import WGPU.Raw.Generated.Enum.WGPUCompareFunction (WGPUCompareFunction)
import qualified WGPU.Raw.Generated.Enum.WGPUCompareFunction as WGPUCompareFunction

-------------------------------------------------------------------------------

-- | Comparison function used for depth and stencil operations.
data CompareFunction
  = CompareFunctionNever
  | CompareFunctionLess
  | CompareFunctionEqual
  | CompareFunctionLessEqual
  | CompareFunctionGreater
  | CompareFunctionNotEqual
  | CompareFunctionGreaterEqual
  | CompareFunctionAlways
  deriving (CompareFunction -> CompareFunction -> Bool
(CompareFunction -> CompareFunction -> Bool)
-> (CompareFunction -> CompareFunction -> Bool)
-> Eq CompareFunction
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CompareFunction -> CompareFunction -> Bool
$c/= :: CompareFunction -> CompareFunction -> Bool
== :: CompareFunction -> CompareFunction -> Bool
$c== :: CompareFunction -> CompareFunction -> Bool
Eq, Int -> CompareFunction -> ShowS
[CompareFunction] -> ShowS
CompareFunction -> String
(Int -> CompareFunction -> ShowS)
-> (CompareFunction -> String)
-> ([CompareFunction] -> ShowS)
-> Show CompareFunction
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CompareFunction] -> ShowS
$cshowList :: [CompareFunction] -> ShowS
show :: CompareFunction -> String
$cshow :: CompareFunction -> String
showsPrec :: Int -> CompareFunction -> ShowS
$cshowsPrec :: Int -> CompareFunction -> ShowS
Show)

-- | Convert a 'CompareFunction' to its raw value.
instance ToRaw CompareFunction WGPUCompareFunction where
  raw :: CompareFunction -> ContT c IO WGPUCompareFunction
raw CompareFunction
cf =
    WGPUCompareFunction -> ContT c IO WGPUCompareFunction
forall (f :: * -> *) a. Applicative f => a -> f a
pure (WGPUCompareFunction -> ContT c IO WGPUCompareFunction)
-> WGPUCompareFunction -> ContT c IO WGPUCompareFunction
forall a b. (a -> b) -> a -> b
$
      case CompareFunction
cf of
        CompareFunction
CompareFunctionNever -> WGPUCompareFunction
forall a. (Eq a, Num a) => a
WGPUCompareFunction.Never
        CompareFunction
CompareFunctionLess -> WGPUCompareFunction
forall a. (Eq a, Num a) => a
WGPUCompareFunction.Less
        CompareFunction
CompareFunctionEqual -> WGPUCompareFunction
forall a. (Eq a, Num a) => a
WGPUCompareFunction.Equal
        CompareFunction
CompareFunctionLessEqual -> WGPUCompareFunction
forall a. (Eq a, Num a) => a
WGPUCompareFunction.LessEqual
        CompareFunction
CompareFunctionGreater -> WGPUCompareFunction
forall a. (Eq a, Num a) => a
WGPUCompareFunction.Greater
        CompareFunction
CompareFunctionNotEqual -> WGPUCompareFunction
forall a. (Eq a, Num a) => a
WGPUCompareFunction.NotEqual
        CompareFunction
CompareFunctionGreaterEqual -> WGPUCompareFunction
forall a. (Eq a, Num a) => a
WGPUCompareFunction.GreaterEqual
        CompareFunction
CompareFunctionAlways -> WGPUCompareFunction
forall a. (Eq a, Num a) => a
WGPUCompareFunction.Always