{-# LANGUAGE LambdaCase, ViewPatterns #-}
{-# LANGUAGE PatternSynonyms #-}
{-# OPTIONS_GHC -Wall -fno-warn-tabs #-}

module Data.Color.Internal (
	-- * Alpha
	Alpha(..), pattern AlphaWord8, pattern AlphaWord16, pattern AlphaWord32,
	pattern AlphaInt32, alphaInt32,
	pattern AlphaDouble, alphaDouble, alphaRealToFrac,
	-- * RGB
	Rgb(..), pattern RgbWord8, pattern RgbWord16, pattern RgbWord32,
	pattern RgbInt32, rgbInt32,
	pattern RgbDouble, rgbDouble, rgbRealToFrac,
	-- * RGBA
	-- ** Straight
	Rgba(..), pattern RgbaWord8, pattern RgbaWord16, pattern RgbaWord32,
	pattern RgbaInt32, rgbaInt32,
	pattern RgbaDouble, rgbaDouble,
	-- ** Premultiplied
	pattern RgbaPremultipliedWord8, rgbaPremultipliedWord8,
	pattern RgbaPremultipliedWord16, rgbaPremultipliedWord16,
	pattern RgbaPremultipliedDouble, rgbaPremultipliedDouble,
	-- ** From and To Rgb and Alpha
	toRgba, fromRgba,
	-- ** Convert Fractional
	rgbaRealToFrac ) where

import Data.Bits
import Data.Bool
import Data.Word
import Data.Int

data Alpha d
	= AlphaWord8_ Word8 | AlphaWord16_ Word16 | AlphaWord32_ Word32
	| AlphaInt32_ Int32 | AlphaDouble_ d
	deriving Int -> Alpha d -> ShowS
forall d. Show d => Int -> Alpha d -> ShowS
forall d. Show d => [Alpha d] -> ShowS
forall d. Show d => Alpha d -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Alpha d] -> ShowS
$cshowList :: forall d. Show d => [Alpha d] -> ShowS
show :: Alpha d -> String
$cshow :: forall d. Show d => Alpha d -> String
showsPrec :: Int -> Alpha d -> ShowS
$cshowsPrec :: forall d. Show d => Int -> Alpha d -> ShowS
Show

{-# COMPLETE AlphaWord8 #-}

pattern AlphaWord8 :: RealFrac d => Word8 -> Alpha d
pattern $bAlphaWord8 :: forall d. RealFrac d => Word8 -> Alpha d
$mAlphaWord8 :: forall {r} {d}.
RealFrac d =>
Alpha d -> (Word8 -> r) -> ((# #) -> r) -> r
AlphaWord8 a <- (fromAlphaWord8 -> a)
	where AlphaWord8 = forall d. Word8 -> Alpha d
AlphaWord8_

fromAlphaWord8 :: RealFrac d => Alpha d -> Word8
fromAlphaWord8 :: forall d. RealFrac d => Alpha d -> Word8
fromAlphaWord8 = \case
	AlphaWord8_ Word8
a -> Word8
a
	AlphaWord16_ Word16
a -> forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ Word16
a forall a. Bits a => a -> Int -> a
`shiftR` Int
8
	AlphaWord32_ Word32
a -> forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ Word32
a forall a. Bits a => a -> Int -> a
`shiftR` Int
24
	AlphaInt32_ Int32
a -> forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ Int32
a forall a. Bits a => a -> Int -> a
`shiftR` Int
23
	AlphaDouble_ d
a -> forall d. RealFrac d => d -> Word8
cDoubleToWord8 d
a

{-# COMPLETE AlphaWord16 #-}

pattern AlphaWord16 :: RealFrac d => Word16 -> Alpha d
pattern $bAlphaWord16 :: forall d. RealFrac d => Word16 -> Alpha d
$mAlphaWord16 :: forall {r} {d}.
RealFrac d =>
Alpha d -> (Word16 -> r) -> ((# #) -> r) -> r
AlphaWord16 a <- (fromAlphaWord16 -> a)
	where AlphaWord16 = forall d. Word16 -> Alpha d
AlphaWord16_

fromAlphaWord16 :: RealFrac d => Alpha d -> Word16
fromAlphaWord16 :: forall d. RealFrac d => Alpha d -> Word16
fromAlphaWord16 = \case
	AlphaWord8_ (forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Word16
a) -> Word16
a forall a. Bits a => a -> Int -> a
`shiftL` Int
8 forall a. Bits a => a -> a -> a
.|. Word16
a
	AlphaWord16_ Word16
a -> Word16
a
	AlphaWord32_ Word32
a -> forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ Word32
a forall a. Bits a => a -> Int -> a
`shiftR` Int
16
	AlphaInt32_ Int32
a -> forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ Int32
a forall a. Bits a => a -> Int -> a
`shiftR` Int
15
	AlphaDouble_ d
a -> forall d. RealFrac d => d -> Word16
cDoubleToWord16 d
a

{-# COMPLETE AlphaWord32 #-}

pattern AlphaWord32 :: RealFrac d => Word32 -> Alpha d
pattern $bAlphaWord32 :: forall d. RealFrac d => Word32 -> Alpha d
$mAlphaWord32 :: forall {r} {d}.
RealFrac d =>
Alpha d -> (Word32 -> r) -> ((# #) -> r) -> r
AlphaWord32 a <- (fromAlphaWord32 -> a)
	where AlphaWord32 = forall d. Word32 -> Alpha d
AlphaWord32_

fromAlphaWord32 :: RealFrac d => Alpha d -> Word32
fromAlphaWord32 :: forall d. RealFrac d => Alpha d -> Word32
fromAlphaWord32 = \case
	AlphaWord8_ (forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Word32
a) ->
		Word32
a forall a. Bits a => a -> Int -> a
`shiftL` Int
24 forall a. Bits a => a -> a -> a
.|. Word32
a forall a. Bits a => a -> Int -> a
`shiftL` Int
16 forall a. Bits a => a -> a -> a
.|. Word32
a forall a. Bits a => a -> Int -> a
`shiftL` Int
8 forall a. Bits a => a -> a -> a
.|. Word32
a
	AlphaWord16_ (forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Word32
a) -> Word32
a forall a. Bits a => a -> Int -> a
`shiftL` Int
16 forall a. Bits a => a -> a -> a
.|. Word32
a
	AlphaWord32_ Word32
a -> Word32
a
	AlphaInt32_ (forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Word32
a) -> Word32
a forall a. Bits a => a -> Int -> a
`shiftL` Int
1 forall a. Bits a => a -> a -> a
.|. Word32
a forall a. Bits a => a -> Int -> a
`shiftR` Int
30
	AlphaDouble_ d
a -> forall d. RealFrac d => d -> Word32
cDoubleToWord32 d
a

{-# COMPLETE AlphaInt32 #-}

pattern AlphaInt32 :: RealFrac d => Int32 -> Alpha d
pattern $mAlphaInt32 :: forall {r} {d}.
RealFrac d =>
Alpha d -> (Int32 -> r) -> ((# #) -> r) -> r
AlphaInt32 a <- (fromAlphaInt32 -> a)

alphaInt32 :: Int32 -> Maybe (Alpha d)
alphaInt32 :: forall d. Int32 -> Maybe (Alpha d)
alphaInt32 Int32
a = forall a. a -> a -> Bool -> a
bool forall a. Maybe a
Nothing (forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ forall d. Int32 -> Alpha d
AlphaInt32_ Int32
a) (Int32
a forall a. Ord a => a -> a -> Bool
>= Int32
0)

fromAlphaInt32 :: RealFrac d => Alpha d -> Int32
fromAlphaInt32 :: forall d. RealFrac d => Alpha d -> Int32
fromAlphaInt32 = \case
	AlphaWord8_ (forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Int32
a) ->
		Int32
a forall a. Bits a => a -> Int -> a
`shiftL` Int
23 forall a. Bits a => a -> a -> a
.|. Int32
a forall a. Bits a => a -> Int -> a
`shiftL` Int
15 forall a. Bits a => a -> a -> a
.|.
		Int32
a forall a. Bits a => a -> Int -> a
`shiftL` Int
7 forall a. Bits a => a -> a -> a
.|. Int32
a forall a. Bits a => a -> Int -> a
`shiftR` Int
1
	AlphaWord16_ (forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Int32
a) ->
		Int32
a forall a. Bits a => a -> Int -> a
`shiftL` Int
15 forall a. Bits a => a -> a -> a
.|. Int32
a forall a. Bits a => a -> Int -> a
`shiftR` Int
1
	AlphaWord32_ Word32
a -> forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ Word32
a forall a. Bits a => a -> Int -> a
`shiftR` Int
1
	AlphaInt32_ Int32
a -> Int32
a
	AlphaDouble_ d
a -> forall d. RealFrac d => d -> Int32
cDoubleToInt32 d
a

{-# COMPLETE AlphaDouble #-}

pattern AlphaDouble :: Fractional d => d -> (Alpha d)
pattern $mAlphaDouble :: forall {r} {d}.
Fractional d =>
Alpha d -> (d -> r) -> ((# #) -> r) -> r
AlphaDouble a <- (fromAlphaDouble -> a)

fromAlphaDouble :: Fractional d => Alpha d -> d
fromAlphaDouble :: forall d. Fractional d => Alpha d -> d
fromAlphaDouble = \case
	AlphaWord8_ Word8
a -> forall d. Fractional d => Word8 -> d
word8ToCDouble Word8
a
	AlphaWord16_ Word16
a -> forall d. Fractional d => Word16 -> d
word16ToCDouble Word16
a
	AlphaWord32_ Word32
a -> forall d. Fractional d => Word32 -> d
word32ToCDouble Word32
a
	AlphaInt32_ Int32
a -> forall d. Fractional d => Int32 -> d
int32ToCDouble Int32
a
	AlphaDouble_ d
a -> d
a

alphaDouble :: (Ord d, Num d) => d -> Maybe (Alpha d)
alphaDouble :: forall d. (Ord d, Num d) => d -> Maybe (Alpha d)
alphaDouble d
a
	| forall d. (Ord d, Num d) => d -> Bool
from0to1 d
a = forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ forall d. d -> Alpha d
AlphaDouble_ d
a
	| Bool
otherwise = forall a. Maybe a
Nothing

alphaRealToFrac :: (Real d, Fractional d') => Alpha d -> Alpha d'
alphaRealToFrac :: forall d d'. (Real d, Fractional d') => Alpha d -> Alpha d'
alphaRealToFrac = \case
	AlphaWord8_ Word8
a -> forall d. Word8 -> Alpha d
AlphaWord8_ Word8
a
	AlphaWord16_ Word16
a -> forall d. Word16 -> Alpha d
AlphaWord16_ Word16
a
	AlphaWord32_ Word32
a -> forall d. Word32 -> Alpha d
AlphaWord32_ Word32
a
	AlphaInt32_ Int32
a -> forall d. Int32 -> Alpha d
AlphaInt32_ Int32
a
	AlphaDouble_ d
a -> forall d. d -> Alpha d
AlphaDouble_ forall a b. (a -> b) -> a -> b
$ forall a b. (Real a, Fractional b) => a -> b
realToFrac d
a

data Rgb d
	= RgbWord8_ Word8 Word8 Word8
	| RgbWord16_ Word16 Word16 Word16
	| RgbWord32_ Word32 Word32 Word32
	| RgbInt32_ Int32 Int32 Int32
	| RgbDouble_ d d d
	deriving Int -> Rgb d -> ShowS
forall d. Show d => Int -> Rgb d -> ShowS
forall d. Show d => [Rgb d] -> ShowS
forall d. Show d => Rgb d -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Rgb d] -> ShowS
$cshowList :: forall d. Show d => [Rgb d] -> ShowS
show :: Rgb d -> String
$cshow :: forall d. Show d => Rgb d -> String
showsPrec :: Int -> Rgb d -> ShowS
$cshowsPrec :: forall d. Show d => Int -> Rgb d -> ShowS
Show

{-# COMPLETE RgbWord8 #-}

pattern RgbWord8 :: RealFrac d => Word8 -> Word8 -> Word8 -> Rgb d
pattern $bRgbWord8 :: forall d. RealFrac d => Word8 -> Word8 -> Word8 -> Rgb d
$mRgbWord8 :: forall {r} {d}.
RealFrac d =>
Rgb d -> (Word8 -> Word8 -> Word8 -> r) -> ((# #) -> r) -> r
RgbWord8 r g b <- (fromRgbWord8 -> (r, g, b))
	where RgbWord8 = forall d. Word8 -> Word8 -> Word8 -> Rgb d
RgbWord8_

fromRgbWord8 :: RealFrac d => Rgb d -> (Word8, Word8, Word8)
fromRgbWord8 :: forall d. RealFrac d => Rgb d -> (Word8, Word8, Word8)
fromRgbWord8 = \case
	RgbWord8_ Word8
r Word8
g Word8
b -> (Word8
r, Word8
g, Word8
b)
	RgbWord16_ Word16
r Word16
g Word16
b -> (
		forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ Word16
r forall a. Bits a => a -> Int -> a
`shiftR` Int
8,
		forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ Word16
g forall a. Bits a => a -> Int -> a
`shiftR` Int
8,
		forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ Word16
b forall a. Bits a => a -> Int -> a
`shiftR` Int
8 )
	RgbWord32_ Word32
r Word32
g Word32
b -> (
		forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ Word32
r forall a. Bits a => a -> Int -> a
`shiftR` Int
24,
		forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ Word32
g forall a. Bits a => a -> Int -> a
`shiftR` Int
24,
		forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ Word32
b forall a. Bits a => a -> Int -> a
`shiftR` Int
24 )
	RgbInt32_ Int32
r Int32
g Int32
b -> (
		forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ Int32
r forall a. Bits a => a -> Int -> a
`shiftR` Int
23,
		forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ Int32
g forall a. Bits a => a -> Int -> a
`shiftR` Int
23,
		forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ Int32
b forall a. Bits a => a -> Int -> a
`shiftR` Int
23 )
	RgbDouble_ d
r d
g d
b -> case forall d. RealFrac d => d -> Word8
cDoubleToWord8 forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [d
r, d
g, d
b] of
		[Word8
r', Word8
g', Word8
b'] -> (Word8
r', Word8
g', Word8
b')
		[Word8]
_ -> forall a. HasCallStack => String -> a
error String
"never occur"

{-# COMPLETE RgbWord16 #-}

pattern RgbWord16 :: RealFrac d => Word16 -> Word16 -> Word16 -> Rgb d
pattern $bRgbWord16 :: forall d. RealFrac d => Word16 -> Word16 -> Word16 -> Rgb d
$mRgbWord16 :: forall {r} {d}.
RealFrac d =>
Rgb d -> (Word16 -> Word16 -> Word16 -> r) -> ((# #) -> r) -> r
RgbWord16 r g b <- (fromRgbWord16 -> (r, g, b))
	where RgbWord16 = forall d. Word16 -> Word16 -> Word16 -> Rgb d
RgbWord16_

fromRgbWord16 :: RealFrac d => Rgb d -> (Word16, Word16, Word16)
fromRgbWord16 :: forall d. RealFrac d => Rgb d -> (Word16, Word16, Word16)
fromRgbWord16 = \case
	RgbWord8_ (forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Word16
r) (forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Word16
g) (forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Word16
b) ->
		(Word16
r forall a. Bits a => a -> Int -> a
`shiftL` Int
8 forall a. Bits a => a -> a -> a
.|. Word16
r, Word16
g forall a. Bits a => a -> Int -> a
`shiftL` Int
8 forall a. Bits a => a -> a -> a
.|. Word16
g, Word16
b forall a. Bits a => a -> Int -> a
`shiftL` Int
8 forall a. Bits a => a -> a -> a
.|. Word16
b)
	RgbWord16_ Word16
r Word16
g Word16
b -> (Word16
r, Word16
g, Word16
b)
	RgbWord32_ Word32
r Word32
g Word32
b -> (
		forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ Word32
r forall a. Bits a => a -> Int -> a
`shiftR` Int
16,
		forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ Word32
g forall a. Bits a => a -> Int -> a
`shiftR` Int
16,
		forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ Word32
b forall a. Bits a => a -> Int -> a
`shiftR` Int
16 )
	RgbInt32_ Int32
r Int32
g Int32
b -> (
		forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ Int32
r forall a. Bits a => a -> Int -> a
`shiftR` Int
15,
		forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ Int32
g forall a. Bits a => a -> Int -> a
`shiftR` Int
15,
		forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ Int32
b forall a. Bits a => a -> Int -> a
`shiftR` Int
15 )
	RgbDouble_ d
r d
g d
b ->
		let [Word16
r', Word16
g', Word16
b'] = forall d. RealFrac d => d -> Word16
cDoubleToWord16 forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [d
r, d
g, d
b] in (Word16
r', Word16
g', Word16
b')

{-# COMPLETE RgbWord32 #-}

pattern RgbWord32 :: RealFrac d => Word32 -> Word32 -> Word32 -> Rgb d
pattern $bRgbWord32 :: forall d. RealFrac d => Word32 -> Word32 -> Word32 -> Rgb d
$mRgbWord32 :: forall {r} {d}.
RealFrac d =>
Rgb d -> (Word32 -> Word32 -> Word32 -> r) -> ((# #) -> r) -> r
RgbWord32 r g b <- (fromRgbWord32 -> (r, g, b))
	where RgbWord32 = forall d. Word32 -> Word32 -> Word32 -> Rgb d
RgbWord32_

fromRgbWord32 :: RealFrac d => Rgb d -> (Word32, Word32, Word32)
fromRgbWord32 :: forall d. RealFrac d => Rgb d -> (Word32, Word32, Word32)
fromRgbWord32 = \case
	RgbWord8_ (forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Word32
r) (forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Word32
g) (forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Word32
b) ->
		(	Word32
r forall a. Bits a => a -> Int -> a
`shiftL` Int
24 forall a. Bits a => a -> a -> a
.|. Word32
r forall a. Bits a => a -> Int -> a
`shiftL` Int
16 forall a. Bits a => a -> a -> a
.|. Word32
r forall a. Bits a => a -> Int -> a
`shiftL` Int
8 forall a. Bits a => a -> a -> a
.|. Word32
r,
			Word32
g forall a. Bits a => a -> Int -> a
`shiftL` Int
24 forall a. Bits a => a -> a -> a
.|. Word32
g forall a. Bits a => a -> Int -> a
`shiftL` Int
16 forall a. Bits a => a -> a -> a
.|. Word32
g forall a. Bits a => a -> Int -> a
`shiftL` Int
8 forall a. Bits a => a -> a -> a
.|. Word32
g,
			Word32
b forall a. Bits a => a -> Int -> a
`shiftL` Int
24 forall a. Bits a => a -> a -> a
.|. Word32
b forall a. Bits a => a -> Int -> a
`shiftL` Int
16 forall a. Bits a => a -> a -> a
.|. Word32
b forall a. Bits a => a -> Int -> a
`shiftL` Int
8 forall a. Bits a => a -> a -> a
.|. Word32
b )
	RgbWord16_ (forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Word32
r) (forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Word32
g) (forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Word32
b)
		-> (	Word32
r forall a. Bits a => a -> Int -> a
`shiftL` Int
16 forall a. Bits a => a -> a -> a
.|. Word32
r, Word32
g forall a. Bits a => a -> Int -> a
`shiftL` Int
16 forall a. Bits a => a -> a -> a
.|. Word32
g,
			Word32
b forall a. Bits a => a -> Int -> a
`shiftL` Int
16 forall a. Bits a => a -> a -> a
.|. Word32
b )
	RgbWord32_ Word32
r Word32
g Word32
b -> (Word32
r, Word32
g, Word32
b)
	RgbInt32_ (forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Word32
r) (forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Word32
g) (forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Word32
b) ->
		(	Word32
r forall a. Bits a => a -> Int -> a
`shiftL` Int
1 forall a. Bits a => a -> a -> a
.|. Word32
r forall a. Bits a => a -> Int -> a
`shiftR` Int
30,
			Word32
g forall a. Bits a => a -> Int -> a
`shiftL` Int
1 forall a. Bits a => a -> a -> a
.|. Word32
g forall a. Bits a => a -> Int -> a
`shiftR` Int
30,
			Word32
b forall a. Bits a => a -> Int -> a
`shiftL` Int
1 forall a. Bits a => a -> a -> a
.|. Word32
b forall a. Bits a => a -> Int -> a
`shiftR` Int
30 )
	RgbDouble_ d
r d
g d
b ->
		let [Word32
r', Word32
g', Word32
b'] = forall d. RealFrac d => d -> Word32
cDoubleToWord32 forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [d
r, d
g, d
b] in (Word32
r', Word32
g', Word32
b')

{-# COMPLETE RgbInt32 #-}

pattern RgbInt32 :: RealFrac d => Int32 -> Int32 -> Int32 -> Rgb d
pattern $mRgbInt32 :: forall {r} {d}.
RealFrac d =>
Rgb d -> (Int32 -> Int32 -> Int32 -> r) -> ((# #) -> r) -> r
RgbInt32 r g b <- (fromRgbInt32 -> (r, g, b))

rgbInt32 :: Int32 -> Int32 -> Int32 -> Maybe (Rgb d)
rgbInt32 :: forall d. Int32 -> Int32 -> Int32 -> Maybe (Rgb d)
rgbInt32 Int32
r Int32
g Int32
b
	| Int32
r forall a. Ord a => a -> a -> Bool
< Int32
0 Bool -> Bool -> Bool
|| Int32
g forall a. Ord a => a -> a -> Bool
< Int32
0 Bool -> Bool -> Bool
|| Int32
b forall a. Ord a => a -> a -> Bool
< Int32
0 = forall a. Maybe a
Nothing
	| Bool
otherwise = forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ forall d. Int32 -> Int32 -> Int32 -> Rgb d
RgbInt32_ Int32
r Int32
g Int32
b

fromRgbInt32 :: RealFrac d => Rgb d -> (Int32, Int32, Int32)
fromRgbInt32 :: forall d. RealFrac d => Rgb d -> (Int32, Int32, Int32)
fromRgbInt32 = \case
	RgbWord8_ (forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Int32
r) (forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Int32
g) (forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Int32
b) ->
		(	Int32
r forall a. Bits a => a -> Int -> a
`shiftL` Int
23 forall a. Bits a => a -> a -> a
.|. Int32
r forall a. Bits a => a -> Int -> a
`shiftL` Int
15 forall a. Bits a => a -> a -> a
.|.
			Int32
r forall a. Bits a => a -> Int -> a
`shiftL` Int
7 forall a. Bits a => a -> a -> a
.|. Int32
r forall a. Bits a => a -> Int -> a
`shiftR` Int
1,
			Int32
g forall a. Bits a => a -> Int -> a
`shiftL` Int
23 forall a. Bits a => a -> a -> a
.|. Int32
g forall a. Bits a => a -> Int -> a
`shiftL` Int
15 forall a. Bits a => a -> a -> a
.|.
			Int32
g forall a. Bits a => a -> Int -> a
`shiftL` Int
7 forall a. Bits a => a -> a -> a
.|. Int32
g forall a. Bits a => a -> Int -> a
`shiftR` Int
1,
			Int32
b forall a. Bits a => a -> Int -> a
`shiftL` Int
23 forall a. Bits a => a -> a -> a
.|. Int32
b forall a. Bits a => a -> Int -> a
`shiftL` Int
15 forall a. Bits a => a -> a -> a
.|.
			Int32
b forall a. Bits a => a -> Int -> a
`shiftL` Int
7 forall a. Bits a => a -> a -> a
.|. Int32
b forall a. Bits a => a -> Int -> a
`shiftR` Int
1 )
	RgbWord16_ (forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Int32
r) (forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Int32
g) (forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Int32
b) ->
		(	Int32
r forall a. Bits a => a -> Int -> a
`shiftL` Int
15 forall a. Bits a => a -> a -> a
.|. Int32
r forall a. Bits a => a -> Int -> a
`shiftR` Int
1,
			Int32
g forall a. Bits a => a -> Int -> a
`shiftL` Int
15 forall a. Bits a => a -> a -> a
.|. Int32
g forall a. Bits a => a -> Int -> a
`shiftR` Int
1,
			Int32
b forall a. Bits a => a -> Int -> a
`shiftL` Int
15 forall a. Bits a => a -> a -> a
.|. Int32
b forall a. Bits a => a -> Int -> a
`shiftR` Int
1 )
	RgbWord32_ Word32
r Word32
g Word32
b -> (
		forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ Word32
r forall a. Bits a => a -> Int -> a
`shiftR` Int
1, forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ Word32
g forall a. Bits a => a -> Int -> a
`shiftR` Int
1,
		forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ Word32
b forall a. Bits a => a -> Int -> a
`shiftR` Int
1 )
	RgbInt32_ Int32
r Int32
g Int32
b -> (Int32
r, Int32
g, Int32
b)
	RgbDouble_ d
r d
g d
b ->
		let [Int32
r', Int32
g', Int32
b'] = forall d. RealFrac d => d -> Int32
cDoubleToInt32 forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [d
r, d
g, d
b] in (Int32
r', Int32
g', Int32
b')

{-# COMPLETE RgbDouble #-}

pattern RgbDouble :: Fractional d => d -> d -> d -> (Rgb d)
pattern $mRgbDouble :: forall {r} {d}.
Fractional d =>
Rgb d -> (d -> d -> d -> r) -> ((# #) -> r) -> r
RgbDouble r g b <- (fromRgbDouble -> (r, g, b))

fromRgbDouble :: Fractional d => Rgb d -> (d, d, d)
fromRgbDouble :: forall d. Fractional d => Rgb d -> (d, d, d)
fromRgbDouble = \case
	RgbWord8_ Word8
r Word8
g Word8
b ->
		let [d
r', d
g', d
b'] = forall d. Fractional d => Word8 -> d
word8ToCDouble forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Word8
r, Word8
g, Word8
b] in (d
r', d
g', d
b')
	RgbWord16_ Word16
r Word16
g Word16
b ->
		let [d
r', d
g', d
b'] = forall d. Fractional d => Word16 -> d
word16ToCDouble forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Word16
r, Word16
g, Word16
b] in (d
r', d
g', d
b')
	RgbWord32_ Word32
r Word32
g Word32
b ->
		let [d
r', d
g', d
b'] = forall d. Fractional d => Word32 -> d
word32ToCDouble forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Word32
r, Word32
g, Word32
b] in (d
r', d
g', d
b')
	RgbInt32_ Int32
r Int32
g Int32
b ->
		let [d
r', d
g', d
b'] = forall d. Fractional d => Int32 -> d
int32ToCDouble forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Int32
r, Int32
g, Int32
b] in (d
r', d
g', d
b')
	RgbDouble_ d
r d
g d
b -> (d
r, d
g, d
b)

rgbDouble :: (Ord d, Num d) => d -> d -> d -> Maybe (Rgb d)
rgbDouble :: forall d. (Ord d, Num d) => d -> d -> d -> Maybe (Rgb d)
rgbDouble d
r d
g d
b
	| forall d. (Ord d, Num d) => d -> Bool
from0to1 d
r Bool -> Bool -> Bool
&& forall d. (Ord d, Num d) => d -> Bool
from0to1 d
g Bool -> Bool -> Bool
&& forall d. (Ord d, Num d) => d -> Bool
from0to1 d
b = forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ forall d. d -> d -> d -> Rgb d
RgbDouble_ d
r d
g d
b
	| Bool
otherwise = forall a. Maybe a
Nothing

rgbRealToFrac :: (Real d, Fractional d') => Rgb d -> Rgb d'
rgbRealToFrac :: forall d d'. (Real d, Fractional d') => Rgb d -> Rgb d'
rgbRealToFrac = \case
	RgbWord8_ Word8
r Word8
g Word8
b -> forall d. Word8 -> Word8 -> Word8 -> Rgb d
RgbWord8_ Word8
r Word8
g Word8
b
	RgbWord16_ Word16
r Word16
g Word16
b -> forall d. Word16 -> Word16 -> Word16 -> Rgb d
RgbWord16_ Word16
r Word16
g Word16
b
	RgbWord32_ Word32
r Word32
g Word32
b -> forall d. Word32 -> Word32 -> Word32 -> Rgb d
RgbWord32_ Word32
r Word32
g Word32
b
	RgbInt32_ Int32
r Int32
g Int32
b -> forall d. Int32 -> Int32 -> Int32 -> Rgb d
RgbInt32_ Int32
r Int32
g Int32
b
	RgbDouble_ d
r d
g d
b -> forall d. d -> d -> d -> Rgb d
RgbDouble_ d'
r' d'
g' d'
b'
		where [d'
r', d'
g', d'
b'] = forall a b. (Real a, Fractional b) => a -> b
realToFrac forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [d
r, d
g, d
b]

data Rgba d
	= RgbaWord8_ Word8 Word8 Word8 Word8
	| RgbaWord16_ Word16 Word16 Word16 Word16
	| RgbaWord32_ Word32 Word32 Word32 Word32
	| RgbaInt32_ Int32 Int32 Int32 Int32
	| RgbaDouble_ d d d d
	| RgbaPremultipliedWord8_ Word8 Word8 Word8 Word8
	| RgbaPremultipliedWord16_ Word16 Word16 Word16 Word16
	| RgbaPremultipliedDouble_ d d d d
	deriving Int -> Rgba d -> ShowS
forall d. Show d => Int -> Rgba d -> ShowS
forall d. Show d => [Rgba d] -> ShowS
forall d. Show d => Rgba d -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Rgba d] -> ShowS
$cshowList :: forall d. Show d => [Rgba d] -> ShowS
show :: Rgba d -> String
$cshow :: forall d. Show d => Rgba d -> String
showsPrec :: Int -> Rgba d -> ShowS
$cshowsPrec :: forall d. Show d => Int -> Rgba d -> ShowS
Show

{-# COMPLETE RgbaWord8 #-}

pattern RgbaWord8 :: RealFrac d => Word8 -> Word8 -> Word8 -> Word8 -> Rgba d
pattern $bRgbaWord8 :: forall d. RealFrac d => Word8 -> Word8 -> Word8 -> Word8 -> Rgba d
$mRgbaWord8 :: forall {r} {d}.
RealFrac d =>
Rgba d
-> (Word8 -> Word8 -> Word8 -> Word8 -> r) -> ((# #) -> r) -> r
RgbaWord8 r g b a <- (fromRgbaWord8 -> (r, g, b, a))
	where RgbaWord8 = forall d. Word8 -> Word8 -> Word8 -> Word8 -> Rgba d
RgbaWord8_

fromRgbaWord8 :: RealFrac d => Rgba d -> (Word8, Word8, Word8, Word8)
fromRgbaWord8 :: forall d. RealFrac d => Rgba d -> (Word8, Word8, Word8, Word8)
fromRgbaWord8 = \case
	RgbaWord8_ Word8
r Word8
g Word8
b Word8
a -> (Word8
r, Word8
g, Word8
b, Word8
a)
	RgbaWord16_ Word16
r Word16
g Word16
b Word16
a -> (
		forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ Word16
r forall a. Bits a => a -> Int -> a
`shiftR` Int
8, forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ Word16
g forall a. Bits a => a -> Int -> a
`shiftR` Int
8,
		forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ Word16
b forall a. Bits a => a -> Int -> a
`shiftR` Int
8, forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ Word16
a forall a. Bits a => a -> Int -> a
`shiftR` Int
8 )
	RgbaWord32_ Word32
r Word32
g Word32
b Word32
a -> (
		forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ Word32
r forall a. Bits a => a -> Int -> a
`shiftR` Int
24, forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ Word32
g forall a. Bits a => a -> Int -> a
`shiftR` Int
24,
		forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ Word32
b forall a. Bits a => a -> Int -> a
`shiftR` Int
24, forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ Word32
a forall a. Bits a => a -> Int -> a
`shiftR` Int
24 )
	RgbaInt32_ Int32
r Int32
g Int32
b Int32
a -> (
		forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ Int32
r forall a. Bits a => a -> Int -> a
`shiftR` Int
23, forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ Int32
g forall a. Bits a => a -> Int -> a
`shiftR` Int
23,
		forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ Int32
b forall a. Bits a => a -> Int -> a
`shiftR` Int
23, forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ Int32
a forall a. Bits a => a -> Int -> a
`shiftR` Int
23 )
	RgbaDouble_ d
r d
g d
b d
a -> (Word8
r', Word8
g', Word8
b', Word8
a')
		where [Word8
r', Word8
g', Word8
b', Word8
a'] = forall d. RealFrac d => d -> Word8
cDoubleToWord8 forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [d
r, d
g, d
b, d
a]
	RgbaPremultipliedWord8_ Word8
r Word8
g Word8
b Word8
a -> (Word8
r', Word8
g', Word8
b', Word8
a')
		where [Word8
r', Word8
g', Word8
b', Word8
a'] = (Word8, Word8, Word8, Word8) -> [Word8]
unPremultipliedWord8 (Word8
r, Word8
g, Word8
b, Word8
a)
	RgbaPremultipliedWord16_ Word16
r Word16
g Word16
b Word16
a -> (
		forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ Word16
r' forall a. Bits a => a -> Int -> a
`shiftR` Int
8,
		forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ Word16
g' forall a. Bits a => a -> Int -> a
`shiftR` Int
8,
		forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ Word16
b' forall a. Bits a => a -> Int -> a
`shiftR` Int
8,
		forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ Word16
a' forall a. Bits a => a -> Int -> a
`shiftR` Int
8 )
		where [Word16
r', Word16
g', Word16
b', Word16
a'] = (Word16, Word16, Word16, Word16) -> [Word16]
unPremultipliedWord16 (Word16
r, Word16
g, Word16
b, Word16
a)
	RgbaPremultipliedDouble_ d
r d
g d
b d
a -> (Word8
r', Word8
g', Word8
b', Word8
a')
		where [Word8
r', Word8
g', Word8
b', Word8
a'] =
			forall d. RealFrac d => d -> Word8
cDoubleToWord8 forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall d. (Eq d, Fractional d) => (d, d, d, d) -> [d]
unPremultipliedDouble (d
r, d
g, d
b, d
a)

{-# COMPLETE RgbaWord16 #-}

pattern RgbaWord16 :: RealFrac d => Word16 -> Word16 -> Word16 -> Word16 -> Rgba d
pattern $bRgbaWord16 :: forall d.
RealFrac d =>
Word16 -> Word16 -> Word16 -> Word16 -> Rgba d
$mRgbaWord16 :: forall {r} {d}.
RealFrac d =>
Rgba d
-> (Word16 -> Word16 -> Word16 -> Word16 -> r) -> ((# #) -> r) -> r
RgbaWord16 r g b a <- (fromRgbaWord16 -> (r, g, b, a))
	where RgbaWord16 = forall d. Word16 -> Word16 -> Word16 -> Word16 -> Rgba d
RgbaWord16_

fromRgbaWord16 :: RealFrac d => Rgba d -> (Word16, Word16, Word16, Word16)
fromRgbaWord16 :: forall d. RealFrac d => Rgba d -> (Word16, Word16, Word16, Word16)
fromRgbaWord16 = \case
	RgbaWord8_
		(forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Word16
r) (forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Word16
g)
		(forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Word16
b) (forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Word16
a) -> (
		Word16
r forall a. Bits a => a -> Int -> a
`shiftL` Int
8 forall a. Bits a => a -> a -> a
.|. Word16
r, Word16
g forall a. Bits a => a -> Int -> a
`shiftL` Int
8 forall a. Bits a => a -> a -> a
.|. Word16
g,
		Word16
b forall a. Bits a => a -> Int -> a
`shiftL` Int
8 forall a. Bits a => a -> a -> a
.|. Word16
b, Word16
a forall a. Bits a => a -> Int -> a
`shiftL` Int
8 forall a. Bits a => a -> a -> a
.|. Word16
a)
	RgbaWord16_ Word16
r Word16
g Word16
b Word16
a -> (Word16
r, Word16
g, Word16
b, Word16
a)
	RgbaWord32_ Word32
r Word32
g Word32
b Word32
a -> (
		forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ Word32
r forall a. Bits a => a -> Int -> a
`shiftR` Int
16, forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ Word32
g forall a. Bits a => a -> Int -> a
`shiftR` Int
16,
		forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ Word32
b forall a. Bits a => a -> Int -> a
`shiftR` Int
16, forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ Word32
a forall a. Bits a => a -> Int -> a
`shiftR` Int
16 )
	RgbaInt32_ Int32
r Int32
g Int32
b Int32
a -> (
		forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ Int32
r forall a. Bits a => a -> Int -> a
`shiftR` Int
15, forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ Int32
g forall a. Bits a => a -> Int -> a
`shiftR` Int
15,
		forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ Int32
b forall a. Bits a => a -> Int -> a
`shiftR` Int
15, forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ Int32
a forall a. Bits a => a -> Int -> a
`shiftR` Int
15 )
	RgbaDouble_ d
r d
g d
b d
a ->
		let [Word16
r', Word16
g', Word16
b', Word16
a'] = forall d. RealFrac d => d -> Word16
cDoubleToWord16 forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [d
r, d
g, d
b, d
a] in (Word16
r', Word16
g', Word16
b', Word16
a')
	RgbaPremultipliedWord8_ Word8
r Word8
g Word8
b Word8
a -> (
		Word16
r' forall a. Bits a => a -> Int -> a
`shiftL` Int
8 forall a. Bits a => a -> a -> a
.|. Word16
r', Word16
g' forall a. Bits a => a -> Int -> a
`shiftL` Int
8 forall a. Bits a => a -> a -> a
.|. Word16
g',
		Word16
b' forall a. Bits a => a -> Int -> a
`shiftL` Int
8 forall a. Bits a => a -> a -> a
.|. Word16
b', Word16
a' forall a. Bits a => a -> Int -> a
`shiftL` Int
8 forall a. Bits a => a -> a -> a
.|. Word16
a')
		where [Word16
r', Word16
g', Word16
b', Word16
a'] =
			forall a b. (Integral a, Num b) => a -> b
fromIntegral forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Word8, Word8, Word8, Word8) -> [Word8]
unPremultipliedWord8 (Word8
r, Word8
g, Word8
b, Word8
a)
	RgbaPremultipliedWord16_ Word16
r Word16
g Word16
b Word16
a -> (Word16
r', Word16
g', Word16
b', Word16
a')
		where [Word16
r', Word16
g', Word16
b', Word16
a'] = (Word16, Word16, Word16, Word16) -> [Word16]
unPremultipliedWord16 (Word16
r, Word16
g, Word16
b, Word16
a)
	RgbaPremultipliedDouble_ d
r d
g d
b d
a -> (Word16
r', Word16
g', Word16
b', Word16
a')
		where [Word16
r', Word16
g', Word16
b', Word16
a'] =
			forall d. RealFrac d => d -> Word16
cDoubleToWord16 forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall d. (Eq d, Fractional d) => (d, d, d, d) -> [d]
unPremultipliedDouble (d
r, d
g, d
b, d
a)

{-# COMPLETE RgbaWord32 #-}

pattern RgbaWord32 :: RealFrac d =>
	Word32 -> Word32 -> Word32 -> Word32 -> Rgba d
pattern $bRgbaWord32 :: forall d.
RealFrac d =>
Word32 -> Word32 -> Word32 -> Word32 -> Rgba d
$mRgbaWord32 :: forall {r} {d}.
RealFrac d =>
Rgba d
-> (Word32 -> Word32 -> Word32 -> Word32 -> r) -> ((# #) -> r) -> r
RgbaWord32 r g b a <- (fromRgbaWord32 -> (r, g, b, a))
	where RgbaWord32 = forall d. Word32 -> Word32 -> Word32 -> Word32 -> Rgba d
RgbaWord32_

fromRgbaWord32 :: RealFrac d => Rgba d -> (Word32, Word32, Word32, Word32)
fromRgbaWord32 :: forall d. RealFrac d => Rgba d -> (Word32, Word32, Word32, Word32)
fromRgbaWord32 = \case
	RgbaWord8_
		(forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Word32
r) (forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Word32
g)
		(forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Word32
b) (forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Word32
a) -> (
		Word32
r forall a. Bits a => a -> Int -> a
`shiftL` Int
24 forall a. Bits a => a -> a -> a
.|. Word32
r forall a. Bits a => a -> Int -> a
`shiftL` Int
16 forall a. Bits a => a -> a -> a
.|. Word32
r forall a. Bits a => a -> Int -> a
`shiftL` Int
8 forall a. Bits a => a -> a -> a
.|. Word32
r,
		Word32
g forall a. Bits a => a -> Int -> a
`shiftL` Int
24 forall a. Bits a => a -> a -> a
.|. Word32
g forall a. Bits a => a -> Int -> a
`shiftL` Int
16 forall a. Bits a => a -> a -> a
.|. Word32
g forall a. Bits a => a -> Int -> a
`shiftL` Int
8 forall a. Bits a => a -> a -> a
.|. Word32
g,
		Word32
b forall a. Bits a => a -> Int -> a
`shiftL` Int
24 forall a. Bits a => a -> a -> a
.|. Word32
b forall a. Bits a => a -> Int -> a
`shiftL` Int
16 forall a. Bits a => a -> a -> a
.|. Word32
b forall a. Bits a => a -> Int -> a
`shiftL` Int
8 forall a. Bits a => a -> a -> a
.|. Word32
b,
		Word32
a forall a. Bits a => a -> Int -> a
`shiftL` Int
24 forall a. Bits a => a -> a -> a
.|. Word32
a forall a. Bits a => a -> Int -> a
`shiftL` Int
16 forall a. Bits a => a -> a -> a
.|. Word32
a forall a. Bits a => a -> Int -> a
`shiftL` Int
8 forall a. Bits a => a -> a -> a
.|. Word32
a )
	RgbaWord16_
		(forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Word32
r) (forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Word32
g)
		(forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Word32
b) (forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Word32
a) -> (
		Word32
r forall a. Bits a => a -> Int -> a
`shiftL` Int
16 forall a. Bits a => a -> a -> a
.|. Word32
r, Word32
g forall a. Bits a => a -> Int -> a
`shiftL` Int
16 forall a. Bits a => a -> a -> a
.|. Word32
g,
		Word32
b forall a. Bits a => a -> Int -> a
`shiftL` Int
16 forall a. Bits a => a -> a -> a
.|. Word32
b, Word32
a forall a. Bits a => a -> Int -> a
`shiftL` Int
16 forall a. Bits a => a -> a -> a
.|. Word32
a )
	RgbaWord32_ Word32
r Word32
g Word32
b Word32
a -> (Word32
r, Word32
g, Word32
b, Word32
a)
	RgbaInt32_
		(forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Word32
r) (forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Word32
g)
		(forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Word32
b) (forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Word32
a) -> (
		Word32
r forall a. Bits a => a -> Int -> a
`shiftL` Int
1 forall a. Bits a => a -> a -> a
.|. Word32
r forall a. Bits a => a -> Int -> a
`shiftR` Int
30, Word32
g forall a. Bits a => a -> Int -> a
`shiftL` Int
1 forall a. Bits a => a -> a -> a
.|. Word32
g forall a. Bits a => a -> Int -> a
`shiftR` Int
30,
		Word32
b forall a. Bits a => a -> Int -> a
`shiftL` Int
1 forall a. Bits a => a -> a -> a
.|. Word32
b forall a. Bits a => a -> Int -> a
`shiftR` Int
30, Word32
a forall a. Bits a => a -> Int -> a
`shiftL` Int
1 forall a. Bits a => a -> a -> a
.|. Word32
a forall a. Bits a => a -> Int -> a
`shiftR` Int
30 )
	RgbaDouble_ d
r d
g d
b d
a -> let
		[Word32
r', Word32
g', Word32
b', Word32
a'] = forall d. RealFrac d => d -> Word32
cDoubleToWord32 forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [d
r, d
g, d
b, d
a] in
		(Word32
r', Word32
g', Word32
b', Word32
a')
	RgbaPremultipliedWord8_ Word8
r Word8
g Word8
b Word8
a -> (
		Word32
r' forall a. Bits a => a -> Int -> a
`shiftL`  Int
24 forall a. Bits a => a -> a -> a
.|. Word32
r' forall a. Bits a => a -> Int -> a
`shiftL` Int
16 forall a. Bits a => a -> a -> a
.|. Word32
r' forall a. Bits a => a -> Int -> a
`shiftL` Int
8 forall a. Bits a => a -> a -> a
.|. Word32
r',
		Word32
g' forall a. Bits a => a -> Int -> a
`shiftL`  Int
24 forall a. Bits a => a -> a -> a
.|. Word32
g' forall a. Bits a => a -> Int -> a
`shiftL` Int
16 forall a. Bits a => a -> a -> a
.|. Word32
g' forall a. Bits a => a -> Int -> a
`shiftL` Int
8 forall a. Bits a => a -> a -> a
.|. Word32
g',
		Word32
b' forall a. Bits a => a -> Int -> a
`shiftL`  Int
24 forall a. Bits a => a -> a -> a
.|. Word32
b' forall a. Bits a => a -> Int -> a
`shiftL` Int
16 forall a. Bits a => a -> a -> a
.|. Word32
b' forall a. Bits a => a -> Int -> a
`shiftL` Int
8 forall a. Bits a => a -> a -> a
.|. Word32
b',
		Word32
a' forall a. Bits a => a -> Int -> a
`shiftL`  Int
24 forall a. Bits a => a -> a -> a
.|. Word32
a' forall a. Bits a => a -> Int -> a
`shiftL` Int
16 forall a. Bits a => a -> a -> a
.|. Word32
a' forall a. Bits a => a -> Int -> a
`shiftL` Int
8 forall a. Bits a => a -> a -> a
.|. Word32
a' )
		where [Word32
r', Word32
g', Word32
b', Word32
a'] =
			forall a b. (Integral a, Num b) => a -> b
fromIntegral forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Word8, Word8, Word8, Word8) -> [Word8]
unPremultipliedWord8 (Word8
r, Word8
g, Word8
b, Word8
a)
	RgbaPremultipliedWord16_ Word16
r Word16
g Word16
b Word16
a -> (
		Word32
r' forall a. Bits a => a -> Int -> a
`shiftL` Int
16 forall a. Bits a => a -> a -> a
.|. Word32
r', Word32
g' forall a. Bits a => a -> Int -> a
`shiftL` Int
16 forall a. Bits a => a -> a -> a
.|. Word32
g',
		Word32
b' forall a. Bits a => a -> Int -> a
`shiftL` Int
16 forall a. Bits a => a -> a -> a
.|. Word32
b', Word32
a' forall a. Bits a => a -> Int -> a
`shiftL` Int
16 forall a. Bits a => a -> a -> a
.|. Word32
a' )
		where [Word32
r', Word32
g', Word32
b', Word32
a'] =
			forall a b. (Integral a, Num b) => a -> b
fromIntegral forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Word16, Word16, Word16, Word16) -> [Word16]
unPremultipliedWord16 (Word16
r, Word16
g, Word16
b, Word16
a)
	RgbaPremultipliedDouble_ d
r d
g d
b d
a -> (Word32
r', Word32
g', Word32
b', Word32
a')
		where [Word32
r', Word32
g', Word32
b', Word32
a'] =
			forall d. RealFrac d => d -> Word32
cDoubleToWord32 forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall d. (Eq d, Fractional d) => (d, d, d, d) -> [d]
unPremultipliedDouble (d
r, d
g, d
b, d
a)

{-# COMPLETE RgbaInt32 #-}

pattern RgbaInt32 :: RealFrac d => Int32 -> Int32 -> Int32 -> Int32 -> Rgba d
pattern $mRgbaInt32 :: forall {r} {d}.
RealFrac d =>
Rgba d
-> (Int32 -> Int32 -> Int32 -> Int32 -> r) -> ((# #) -> r) -> r
RgbaInt32 r g b a <- (fromRgbaInt32 -> (r, g, b, a))

rgbaInt32 :: Int32 -> Int32 -> Int32 -> Int32 -> Maybe (Rgba d)
rgbaInt32 :: forall d. Int32 -> Int32 -> Int32 -> Int32 -> Maybe (Rgba d)
rgbaInt32 Int32
r Int32
g Int32
b Int32
a
	| Int32
r forall a. Ord a => a -> a -> Bool
< Int32
0 Bool -> Bool -> Bool
|| Int32
g forall a. Ord a => a -> a -> Bool
< Int32
0 Bool -> Bool -> Bool
|| Int32
b forall a. Ord a => a -> a -> Bool
< Int32
0 Bool -> Bool -> Bool
|| Int32
a forall a. Ord a => a -> a -> Bool
< Int32
0 = forall a. Maybe a
Nothing
	| Bool
otherwise = forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ forall d. Int32 -> Int32 -> Int32 -> Int32 -> Rgba d
RgbaInt32_ Int32
r Int32
g Int32
b Int32
a

fromRgbaInt32 :: RealFrac d => Rgba d -> (Int32, Int32, Int32, Int32)
fromRgbaInt32 :: forall d. RealFrac d => Rgba d -> (Int32, Int32, Int32, Int32)
fromRgbaInt32 = \case
	RgbaWord8_
		(forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Int32
r) (forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Int32
g)
		(forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Int32
b) (forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Int32
a) -> (
		Int32
r forall a. Bits a => a -> Int -> a
`shiftL` Int
23 forall a. Bits a => a -> a -> a
.|. Int32
r forall a. Bits a => a -> Int -> a
`shiftL` Int
15 forall a. Bits a => a -> a -> a
.|.
		Int32
r forall a. Bits a => a -> Int -> a
`shiftL` Int
7 forall a. Bits a => a -> a -> a
.|. Int32
r forall a. Bits a => a -> Int -> a
`shiftR` Int
1,
		Int32
g forall a. Bits a => a -> Int -> a
`shiftL` Int
23 forall a. Bits a => a -> a -> a
.|. Int32
g forall a. Bits a => a -> Int -> a
`shiftL` Int
15 forall a. Bits a => a -> a -> a
.|.
		Int32
g forall a. Bits a => a -> Int -> a
`shiftL` Int
7 forall a. Bits a => a -> a -> a
.|. Int32
g forall a. Bits a => a -> Int -> a
`shiftR` Int
1,
		Int32
b forall a. Bits a => a -> Int -> a
`shiftL` Int
23 forall a. Bits a => a -> a -> a
.|. Int32
b forall a. Bits a => a -> Int -> a
`shiftL` Int
15 forall a. Bits a => a -> a -> a
.|.
		Int32
b forall a. Bits a => a -> Int -> a
`shiftL` Int
7 forall a. Bits a => a -> a -> a
.|. Int32
b forall a. Bits a => a -> Int -> a
`shiftR` Int
1,
		Int32
a forall a. Bits a => a -> Int -> a
`shiftL` Int
23 forall a. Bits a => a -> a -> a
.|. Int32
a forall a. Bits a => a -> Int -> a
`shiftL` Int
15 forall a. Bits a => a -> a -> a
.|.
		Int32
a forall a. Bits a => a -> Int -> a
`shiftL` Int
7 forall a. Bits a => a -> a -> a
.|. Int32
a forall a. Bits a => a -> Int -> a
`shiftR` Int
1 )
	RgbaWord16_
		(forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Int32
r) (forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Int32
g)
		(forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Int32
b) (forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Int32
a) -> (
		Int32
r forall a. Bits a => a -> Int -> a
`shiftL` Int
15 forall a. Bits a => a -> a -> a
.|. Int32
r forall a. Bits a => a -> Int -> a
`shiftR` Int
1, Int32
g forall a. Bits a => a -> Int -> a
`shiftL` Int
15 forall a. Bits a => a -> a -> a
.|. Int32
g forall a. Bits a => a -> Int -> a
`shiftR` Int
1,
		Int32
b forall a. Bits a => a -> Int -> a
`shiftL` Int
15 forall a. Bits a => a -> a -> a
.|. Int32
b forall a. Bits a => a -> Int -> a
`shiftR` Int
1, Int32
a forall a. Bits a => a -> Int -> a
`shiftL` Int
15 forall a. Bits a => a -> a -> a
.|. Int32
a forall a. Bits a => a -> Int -> a
`shiftR` Int
1 )
	RgbaWord32_ Word32
r Word32
g Word32
b Word32
a -> (
		forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ Word32
r forall a. Bits a => a -> Int -> a
`shiftR` Int
1, forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ Word32
g forall a. Bits a => a -> Int -> a
`shiftR` Int
1,
		forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ Word32
b forall a. Bits a => a -> Int -> a
`shiftR` Int
1, forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ Word32
a forall a. Bits a => a -> Int -> a
`shiftR` Int
1 )
	RgbaInt32_ Int32
r Int32
g Int32
b Int32
a -> (Int32
r, Int32
g, Int32
b, Int32
a)
	RgbaDouble_ d
r d
g d
b d
a -> let
		[Int32
r', Int32
g', Int32
b', Int32
a'] = forall d. RealFrac d => d -> Int32
cDoubleToInt32 forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [d
r, d
g, d
b, d
a] in
		(Int32
r', Int32
g', Int32
b', Int32
a')
	RgbaPremultipliedWord8_ Word8
r Word8
g Word8
b Word8
a -> (
		Int32
r' forall a. Bits a => a -> Int -> a
`shiftL` Int
23 forall a. Bits a => a -> a -> a
.|. Int32
r' forall a. Bits a => a -> Int -> a
`shiftL` Int
15 forall a. Bits a => a -> a -> a
.|.
		Int32
r' forall a. Bits a => a -> Int -> a
`shiftL` Int
7 forall a. Bits a => a -> a -> a
.|. Int32
r' forall a. Bits a => a -> Int -> a
`shiftR` Int
1,
		Int32
g' forall a. Bits a => a -> Int -> a
`shiftL` Int
23 forall a. Bits a => a -> a -> a
.|. Int32
g' forall a. Bits a => a -> Int -> a
`shiftL` Int
15 forall a. Bits a => a -> a -> a
.|.
		Int32
g' forall a. Bits a => a -> Int -> a
`shiftL` Int
7 forall a. Bits a => a -> a -> a
.|. Int32
g' forall a. Bits a => a -> Int -> a
`shiftR` Int
1,
		Int32
b' forall a. Bits a => a -> Int -> a
`shiftL` Int
23 forall a. Bits a => a -> a -> a
.|. Int32
b' forall a. Bits a => a -> Int -> a
`shiftL` Int
15 forall a. Bits a => a -> a -> a
.|.
		Int32
b' forall a. Bits a => a -> Int -> a
`shiftL` Int
7 forall a. Bits a => a -> a -> a
.|. Int32
b' forall a. Bits a => a -> Int -> a
`shiftR` Int
1,
		Int32
a' forall a. Bits a => a -> Int -> a
`shiftL` Int
23 forall a. Bits a => a -> a -> a
.|. Int32
a' forall a. Bits a => a -> Int -> a
`shiftL` Int
15 forall a. Bits a => a -> a -> a
.|.
		Int32
a' forall a. Bits a => a -> Int -> a
`shiftL` Int
7 forall a. Bits a => a -> a -> a
.|. Int32
a' forall a. Bits a => a -> Int -> a
`shiftR` Int
1 )
		where [Int32
r', Int32
g', Int32
b', Int32
a'] =
			forall a b. (Integral a, Num b) => a -> b
fromIntegral forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Word8, Word8, Word8, Word8) -> [Word8]
unPremultipliedWord8 (Word8
r, Word8
g, Word8
b, Word8
a)
	RgbaPremultipliedWord16_ Word16
r Word16
g Word16
b Word16
a -> (
		Int32
r' forall a. Bits a => a -> Int -> a
`shiftL` Int
15 forall a. Bits a => a -> a -> a
.|. Int32
r' forall a. Bits a => a -> Int -> a
`shiftR` Int
1,
		Int32
g' forall a. Bits a => a -> Int -> a
`shiftL` Int
15 forall a. Bits a => a -> a -> a
.|. Int32
g' forall a. Bits a => a -> Int -> a
`shiftR` Int
1,
		Int32
b' forall a. Bits a => a -> Int -> a
`shiftL` Int
15 forall a. Bits a => a -> a -> a
.|. Int32
b' forall a. Bits a => a -> Int -> a
`shiftR` Int
1,
		Int32
a' forall a. Bits a => a -> Int -> a
`shiftL` Int
15 forall a. Bits a => a -> a -> a
.|. Int32
a' forall a. Bits a => a -> Int -> a
`shiftR` Int
1 )
		where [Int32
r', Int32
g', Int32
b', Int32
a'] =
			forall a b. (Integral a, Num b) => a -> b
fromIntegral forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Word16, Word16, Word16, Word16) -> [Word16]
unPremultipliedWord16 (Word16
r, Word16
g, Word16
b, Word16
a)
	RgbaPremultipliedDouble_ d
r d
g d
b d
a -> (Int32
r', Int32
g', Int32
b', Int32
a')
		where [Int32
r', Int32
g', Int32
b', Int32
a'] =
			forall d. RealFrac d => d -> Int32
cDoubleToInt32 forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall d. (Eq d, Fractional d) => (d, d, d, d) -> [d]
unPremultipliedDouble (d
r, d
g, d
b, d
a)

{-# COMPLETE RgbaDouble #-}

pattern RgbaDouble :: (Eq d, Fractional d) => d -> d -> d -> d -> Rgba d
pattern $mRgbaDouble :: forall {r} {d}.
(Eq d, Fractional d) =>
Rgba d -> (d -> d -> d -> d -> r) -> ((# #) -> r) -> r
RgbaDouble r g b a <- (fromRgbaDouble -> (r, g, b, a))

fromRgbaDouble :: (Eq d, Fractional d) => Rgba d -> (d, d, d, d)
fromRgbaDouble :: forall d. (Eq d, Fractional d) => Rgba d -> (d, d, d, d)
fromRgbaDouble = \case
	RgbaWord8_ Word8
r Word8
g Word8
b Word8
a -> (d
r', d
g', d
b', d
a')
		where [d
r', d
g', d
b', d
a'] = forall d. Fractional d => Word8 -> d
word8ToCDouble forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Word8
r, Word8
g, Word8
b, Word8
a]
	RgbaWord16_ Word16
r Word16
g Word16
b Word16
a -> (d
r', d
g', d
b', d
a')
		where [d
r', d
g', d
b', d
a'] = forall d. Fractional d => Word16 -> d
word16ToCDouble forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Word16
r, Word16
g, Word16
b, Word16
a]
	RgbaWord32_ Word32
r Word32
g Word32
b Word32
a -> (d
r', d
g', d
b', d
a')
		where [d
r', d
g', d
b', d
a'] = forall d. Fractional d => Word32 -> d
word32ToCDouble forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Word32
r, Word32
g, Word32
b, Word32
a]
	RgbaInt32_ Int32
r Int32
g Int32
b Int32
a -> (d
r', d
g', d
b', d
a')
		where [d
r', d
g', d
b', d
a'] = forall d. Fractional d => Int32 -> d
int32ToCDouble forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Int32
r, Int32
g, Int32
b, Int32
a]
	RgbaDouble_ d
r d
g d
b d
a -> (d
r, d
g, d
b, d
a)
	RgbaPremultipliedWord8_ Word8
r Word8
g Word8
b Word8
a -> (d
r', d
g', d
b', d
a')
		where [d
r', d
g', d
b', d
a'] =
			forall d. Fractional d => Word8 -> d
word8ToCDouble forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Word8, Word8, Word8, Word8) -> [Word8]
unPremultipliedWord8 (Word8
r, Word8
g, Word8
b, Word8
a)
	RgbaPremultipliedWord16_ Word16
r Word16
g Word16
b Word16
a -> (d
r', d
g', d
b', d
a')
		where [d
r', d
g', d
b', d
a'] =
			forall d. Fractional d => Word16 -> d
word16ToCDouble forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Word16, Word16, Word16, Word16) -> [Word16]
unPremultipliedWord16 (Word16
r, Word16
g, Word16
b, Word16
a)
	RgbaPremultipliedDouble_ d
r d
g d
b d
a -> (d
r', d
g', d
b', d
a')
		where [d
r', d
g', d
b', d
a'] = forall d. (Eq d, Fractional d) => (d, d, d, d) -> [d]
unPremultipliedDouble (d
r, d
g, d
b, d
a)

rgbaDouble :: (Ord d, Num d) => d -> d -> d -> d -> Maybe (Rgba d)
rgbaDouble :: forall d. (Ord d, Num d) => d -> d -> d -> d -> Maybe (Rgba d)
rgbaDouble d
r d
g d
b d
a
	| forall d. (Ord d, Num d) => d -> Bool
from0to1 d
r Bool -> Bool -> Bool
&& forall d. (Ord d, Num d) => d -> Bool
from0to1 d
g Bool -> Bool -> Bool
&& forall d. (Ord d, Num d) => d -> Bool
from0to1 d
b Bool -> Bool -> Bool
&& forall d. (Ord d, Num d) => d -> Bool
from0to1 d
a =
		forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ forall d. d -> d -> d -> d -> Rgba d
RgbaDouble_ d
r d
g d
b d
a
	| Bool
otherwise = forall a. Maybe a
Nothing

fromRgba :: (Eq d, Fractional d) => Rgba d -> (Rgb d, Alpha d)
fromRgba :: forall d. (Eq d, Fractional d) => Rgba d -> (Rgb d, Alpha d)
fromRgba = \case
	RgbaWord8_ Word8
r Word8
g Word8
b Word8
a -> (forall d. Word8 -> Word8 -> Word8 -> Rgb d
RgbWord8_ Word8
r Word8
g Word8
b, forall d. Word8 -> Alpha d
AlphaWord8_ Word8
a)
	RgbaWord16_ Word16
r Word16
g Word16
b Word16
a -> (forall d. Word16 -> Word16 -> Word16 -> Rgb d
RgbWord16_ Word16
r Word16
g Word16
b, forall d. Word16 -> Alpha d
AlphaWord16_ Word16
a)
	RgbaWord32_ Word32
r Word32
g Word32
b Word32
a -> (forall d. Word32 -> Word32 -> Word32 -> Rgb d
RgbWord32_ Word32
r Word32
g Word32
b, forall d. Word32 -> Alpha d
AlphaWord32_ Word32
a)
	RgbaInt32_ Int32
r Int32
g Int32
b Int32
a -> (forall d. Int32 -> Int32 -> Int32 -> Rgb d
RgbInt32_ Int32
r Int32
g Int32
b, forall d. Int32 -> Alpha d
AlphaInt32_ Int32
a)
	RgbaDouble_ d
r d
g d
b d
a -> (forall d. d -> d -> d -> Rgb d
RgbDouble_ d
r d
g d
b, forall d. d -> Alpha d
AlphaDouble_ d
a)
	RgbaPremultipliedWord8_ Word8
r Word8
g Word8
b Word8
a -> (forall d. Word8 -> Word8 -> Word8 -> Rgb d
RgbWord8_ Word8
r' Word8
g' Word8
b', forall d. Word8 -> Alpha d
AlphaWord8_ Word8
a')
		where [Word8
r', Word8
g', Word8
b', Word8
a'] = (Word8, Word8, Word8, Word8) -> [Word8]
unPremultipliedWord8 (Word8
r, Word8
g, Word8
b, Word8
a)
	RgbaPremultipliedWord16_ Word16
r Word16
g Word16
b Word16
a -> (forall d. Word16 -> Word16 -> Word16 -> Rgb d
RgbWord16_ Word16
r' Word16
g' Word16
b', forall d. Word16 -> Alpha d
AlphaWord16_ Word16
a')
		where [Word16
r', Word16
g', Word16
b', Word16
a'] = (Word16, Word16, Word16, Word16) -> [Word16]
unPremultipliedWord16 (Word16
r, Word16
g, Word16
b, Word16
a)
	RgbaPremultipliedDouble_ d
r d
g d
b d
a -> (forall d. d -> d -> d -> Rgb d
RgbDouble_ d
r' d
g' d
b', forall d. d -> Alpha d
AlphaDouble_ d
a')
		where [d
r', d
g', d
b', d
a'] = forall d. (Eq d, Fractional d) => (d, d, d, d) -> [d]
unPremultipliedDouble (d
r, d
g, d
b, d
a)

toRgba :: RealFrac d => Rgb d -> Alpha d -> Rgba d
toRgba :: forall d. RealFrac d => Rgb d -> Alpha d -> Rgba d
toRgba (RgbWord8_ Word8
r Word8
g Word8
b) (AlphaWord8 Word8
a) = forall d. RealFrac d => Word8 -> Word8 -> Word8 -> Word8 -> Rgba d
RgbaWord8 Word8
r Word8
g Word8
b Word8
a
toRgba (RgbWord16_ Word16
r Word16
g Word16
b) (AlphaWord16 Word16
a) = forall d.
RealFrac d =>
Word16 -> Word16 -> Word16 -> Word16 -> Rgba d
RgbaWord16 Word16
r Word16
g Word16
b Word16
a
toRgba (RgbWord32_ Word32
r Word32
g Word32
b) (AlphaWord32 Word32
a) = forall d.
RealFrac d =>
Word32 -> Word32 -> Word32 -> Word32 -> Rgba d
RgbaWord32 Word32
r Word32
g Word32
b Word32
a
toRgba (RgbInt32_ Int32
r Int32
g Int32
b) (AlphaInt32 Int32
a) = forall d. Int32 -> Int32 -> Int32 -> Int32 -> Rgba d
RgbaInt32_ Int32
r Int32
g Int32
b Int32
a
toRgba (RgbDouble_ d
r d
g d
b) (AlphaDouble d
a) = forall d. d -> d -> d -> d -> Rgba d
RgbaDouble_ d
r d
g d
b d
a

rgbaRealToFrac :: (Real d, Fractional d') => Rgba d -> Rgba d'
rgbaRealToFrac :: forall d d'. (Real d, Fractional d') => Rgba d -> Rgba d'
rgbaRealToFrac = \case
	RgbaWord8_ Word8
r Word8
g Word8
b Word8
a -> forall d. Word8 -> Word8 -> Word8 -> Word8 -> Rgba d
RgbaWord8_ Word8
r Word8
g Word8
b Word8
a
	RgbaWord16_ Word16
r Word16
g Word16
b Word16
a -> forall d. Word16 -> Word16 -> Word16 -> Word16 -> Rgba d
RgbaWord16_ Word16
r Word16
g Word16
b Word16
a
	RgbaWord32_ Word32
r Word32
g Word32
b Word32
a -> forall d. Word32 -> Word32 -> Word32 -> Word32 -> Rgba d
RgbaWord32_ Word32
r Word32
g Word32
b Word32
a
	RgbaInt32_ Int32
r Int32
g Int32
b Int32
a -> forall d. Int32 -> Int32 -> Int32 -> Int32 -> Rgba d
RgbaInt32_ Int32
r Int32
g Int32
b Int32
a
	RgbaDouble_ d
r d
g d
b d
a -> forall d. d -> d -> d -> d -> Rgba d
RgbaDouble_ d'
r' d'
g' d'
b' d'
a'
		where [d'
r', d'
g', d'
b', d'
a'] = forall a b. (Real a, Fractional b) => a -> b
realToFrac forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [d
r, d
g, d
b, d
a]
	RgbaPremultipliedWord8_ Word8
r Word8
g Word8
b Word8
a -> forall d. Word8 -> Word8 -> Word8 -> Word8 -> Rgba d
RgbaPremultipliedWord8_ Word8
r Word8
g Word8
b Word8
a
	RgbaPremultipliedWord16_ Word16
r Word16
g Word16
b Word16
a -> forall d. Word16 -> Word16 -> Word16 -> Word16 -> Rgba d
RgbaPremultipliedWord16_ Word16
r Word16
g Word16
b Word16
a
	RgbaPremultipliedDouble_ d
r d
g d
b d
a -> forall d. d -> d -> d -> d -> Rgba d
RgbaPremultipliedDouble_ d'
r' d'
g' d'
b' d'
a'
		where [d'
r', d'
g', d'
b', d'
a'] = forall a b. (Real a, Fractional b) => a -> b
realToFrac forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [d
r, d
g, d
b, d
a]

cDoubleToWord8 :: RealFrac d => d -> Word8
cDoubleToWord8 :: forall d. RealFrac d => d -> Word8
cDoubleToWord8 = forall a b. (RealFrac a, Integral b) => a -> b
round forall b c a. (b -> c) -> (a -> b) -> a -> c
. (forall a. Num a => a -> a -> a
* d
0xff)

cDoubleToWord16 :: RealFrac d => d -> Word16
cDoubleToWord16 :: forall d. RealFrac d => d -> Word16
cDoubleToWord16 = forall a b. (RealFrac a, Integral b) => a -> b
round forall b c a. (b -> c) -> (a -> b) -> a -> c
. (forall a. Num a => a -> a -> a
* d
0xffff)

cDoubleToWord32 :: RealFrac d => d -> Word32
cDoubleToWord32 :: forall d. RealFrac d => d -> Word32
cDoubleToWord32 = forall a b. (RealFrac a, Integral b) => a -> b
round forall b c a. (b -> c) -> (a -> b) -> a -> c
. (forall a. Num a => a -> a -> a
* d
0xffffffff)

cDoubleToInt32 :: RealFrac d => d -> Int32
cDoubleToInt32 :: forall d. RealFrac d => d -> Int32
cDoubleToInt32 = forall a b. (RealFrac a, Integral b) => a -> b
round forall b c a. (b -> c) -> (a -> b) -> a -> c
. (forall a. Num a => a -> a -> a
* d
0x7fffffff)

word8ToCDouble :: Fractional d => Word8 -> d
word8ToCDouble :: forall d. Fractional d => Word8 -> d
word8ToCDouble = (forall a. Fractional a => a -> a -> a
/ d
0xff) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (Integral a, Num b) => a -> b
fromIntegral

word16ToCDouble :: Fractional d => Word16 -> d
word16ToCDouble :: forall d. Fractional d => Word16 -> d
word16ToCDouble = (forall a. Fractional a => a -> a -> a
/ d
0xffff) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (Integral a, Num b) => a -> b
fromIntegral

word32ToCDouble :: Fractional d => Word32 -> d
word32ToCDouble :: forall d. Fractional d => Word32 -> d
word32ToCDouble = (forall a. Fractional a => a -> a -> a
/ d
0xffffffff) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (Integral a, Num b) => a -> b
fromIntegral

int32ToCDouble :: Fractional d => Int32 -> d
int32ToCDouble :: forall d. Fractional d => Int32 -> d
int32ToCDouble = (forall a. Fractional a => a -> a -> a
/ d
0x7fffffff) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (Integral a, Num b) => a -> b
fromIntegral

from0to1 :: (Ord d, Num d) => d -> Bool
from0to1 :: forall d. (Ord d, Num d) => d -> Bool
from0to1 d
n = d
0 forall a. Ord a => a -> a -> Bool
<= d
n Bool -> Bool -> Bool
&& d
n forall a. Ord a => a -> a -> Bool
<= d
1

{-# COMPLETE RgbaPremultipliedWord8 #-}

pattern RgbaPremultipliedWord8 ::
	RealFrac d => Word8 -> Word8 -> Word8 -> Word8 -> Rgba d
pattern $mRgbaPremultipliedWord8 :: forall {r} {d}.
RealFrac d =>
Rgba d
-> (Word8 -> Word8 -> Word8 -> Word8 -> r) -> ((# #) -> r) -> r
RgbaPremultipliedWord8 r g b a <-
	(fromRgbaPremultipliedWord8 -> (r, g, b, a))

rgbaPremultipliedWord8 :: Word8 -> Word8 -> Word8 -> Word8 -> Maybe (Rgba d)
rgbaPremultipliedWord8 :: forall d. Word8 -> Word8 -> Word8 -> Word8 -> Maybe (Rgba d)
rgbaPremultipliedWord8 Word8
r Word8
g Word8
b Word8
a
	| Word8
r forall a. Ord a => a -> a -> Bool
<= Word8
a Bool -> Bool -> Bool
&& Word8
g forall a. Ord a => a -> a -> Bool
<= Word8
a Bool -> Bool -> Bool
&& Word8
b forall a. Ord a => a -> a -> Bool
<= Word8
a = forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ forall d. Word8 -> Word8 -> Word8 -> Word8 -> Rgba d
RgbaPremultipliedWord8_ Word8
r Word8
g Word8
b Word8
a
	| Bool
otherwise = forall a. Maybe a
Nothing

fromRgbaPremultipliedWord8 :: RealFrac d => Rgba d -> (Word8, Word8, Word8, Word8)
fromRgbaPremultipliedWord8 :: forall d. RealFrac d => Rgba d -> (Word8, Word8, Word8, Word8)
fromRgbaPremultipliedWord8 = (Word8, Word8, Word8, Word8) -> (Word8, Word8, Word8, Word8)
toPremultipliedWord8 forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall d. RealFrac d => Rgba d -> (Word8, Word8, Word8, Word8)
fromRgbaWord8

toPremultipliedWord8 ::
	(Word8, Word8, Word8, Word8) -> (Word8, Word8, Word8, Word8)
toPremultipliedWord8 :: (Word8, Word8, Word8, Word8) -> (Word8, Word8, Word8, Word8)
toPremultipliedWord8 (
	forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Word16
r, forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Word16
g,
	forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Word16
b, forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Word16
a) = (Word8
r', Word8
g', Word8
b', Word8
a')
	where
	[Word8
r', Word8
g', Word8
b', Word8
a'] = forall a b. (Integral a, Num b) => a -> b
fromIntegral forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [
		Word16
r forall a. Num a => a -> a -> a
* Word16
a forall a. Integral a => a -> a -> a
`div` Word16
0xff, Word16
g forall a. Num a => a -> a -> a
* Word16
a forall a. Integral a => a -> a -> a
`div` Word16
0xff, Word16
b forall a. Num a => a -> a -> a
* Word16
a forall a. Integral a => a -> a -> a
`div` Word16
0xff,
		Word16
a :: Word16 ]

unPremultipliedWord8 :: (Word8, Word8, Word8, Word8) -> [Word8]
unPremultipliedWord8 :: (Word8, Word8, Word8, Word8) -> [Word8]
unPremultipliedWord8 (
	forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Word16
r, forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Word16
g,
	forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Word16
b, forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Word16
a ) = forall a b. (Integral a, Num b) => a -> b
fromIntegral forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [
		Word16
r forall a. Num a => a -> a -> a
* Word16
0xff forall n. (Integral n, Bounded n) => n -> n -> n
`div'` Word16
a, Word16
g forall a. Num a => a -> a -> a
* Word16
0xff forall n. (Integral n, Bounded n) => n -> n -> n
`div'` Word16
a, Word16
b forall a. Num a => a -> a -> a
* Word16
0xff forall n. (Integral n, Bounded n) => n -> n -> n
`div'` Word16
a,
		Word16
a :: Word16 ]

{-# COMPLETE RgbaPremultipliedWord16 #-}

pattern RgbaPremultipliedWord16 ::
	RealFrac d => Word16 -> Word16 -> Word16 -> Word16 -> Rgba d
pattern $mRgbaPremultipliedWord16 :: forall {r} {d}.
RealFrac d =>
Rgba d
-> (Word16 -> Word16 -> Word16 -> Word16 -> r) -> ((# #) -> r) -> r
RgbaPremultipliedWord16 r g b a <-
	(fromRgbaPremultipliedWord16 -> (r, g, b, a))

rgbaPremultipliedWord16 :: Word16 -> Word16 -> Word16 -> Word16 -> Maybe (Rgba d)
rgbaPremultipliedWord16 :: forall d. Word16 -> Word16 -> Word16 -> Word16 -> Maybe (Rgba d)
rgbaPremultipliedWord16 Word16
r Word16
g Word16
b Word16
a
	| Word16
r forall a. Ord a => a -> a -> Bool
<= Word16
a Bool -> Bool -> Bool
&& Word16
g forall a. Ord a => a -> a -> Bool
<= Word16
a Bool -> Bool -> Bool
&& Word16
b forall a. Ord a => a -> a -> Bool
<= Word16
a = forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ forall d. Word16 -> Word16 -> Word16 -> Word16 -> Rgba d
RgbaPremultipliedWord16_ Word16
r Word16
g Word16
b Word16
a
	| Bool
otherwise = forall a. Maybe a
Nothing

fromRgbaPremultipliedWord16 ::
	RealFrac d => Rgba d -> (Word16, Word16, Word16, Word16)
fromRgbaPremultipliedWord16 :: forall d. RealFrac d => Rgba d -> (Word16, Word16, Word16, Word16)
fromRgbaPremultipliedWord16 = (Word16, Word16, Word16, Word16)
-> (Word16, Word16, Word16, Word16)
toPremultipliedWord16 forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall d. RealFrac d => Rgba d -> (Word16, Word16, Word16, Word16)
fromRgbaWord16

toPremultipliedWord16 ::
	(Word16, Word16, Word16, Word16) -> (Word16, Word16, Word16, Word16)
toPremultipliedWord16 :: (Word16, Word16, Word16, Word16)
-> (Word16, Word16, Word16, Word16)
toPremultipliedWord16 (
	forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Word32
r, forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Word32
g,
	forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Word32
b, forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Word32
a ) = (Word16
r', Word16
g', Word16
b', Word16
a')
	where
	[Word16
r', Word16
g', Word16
b', Word16
a'] = forall a b. (Integral a, Num b) => a -> b
fromIntegral forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [
		Word32
r forall a. Num a => a -> a -> a
* Word32
a forall a. Integral a => a -> a -> a
`div` Word32
0xffff, Word32
g forall a. Num a => a -> a -> a
* Word32
a forall a. Integral a => a -> a -> a
`div` Word32
0xffff, Word32
b forall a. Num a => a -> a -> a
* Word32
a forall a. Integral a => a -> a -> a
`div` Word32
0xffff,
		Word32
a :: Word32 ]

unPremultipliedWord16 :: (Word16, Word16, Word16, Word16) -> [Word16]
unPremultipliedWord16 :: (Word16, Word16, Word16, Word16) -> [Word16]
unPremultipliedWord16 (
	forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Word32
r, forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Word32
g,
	forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Word32
b, forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Word32
a ) = forall a b. (Integral a, Num b) => a -> b
fromIntegral forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [
		Word32
r forall a. Num a => a -> a -> a
* Word32
0xffff forall n. (Integral n, Bounded n) => n -> n -> n
`div'` Word32
a, Word32
g forall a. Num a => a -> a -> a
* Word32
0xffff forall n. (Integral n, Bounded n) => n -> n -> n
`div'` Word32
a, Word32
b forall a. Num a => a -> a -> a
* Word32
0xff forall n. (Integral n, Bounded n) => n -> n -> n
`div'` Word32
a,
		Word32
a :: Word32 ]

pattern RgbaPremultipliedDouble :: (Eq d, Fractional d) => d -> d -> d -> d -> Rgba d
pattern $mRgbaPremultipliedDouble :: forall {r} {d}.
(Eq d, Fractional d) =>
Rgba d -> (d -> d -> d -> d -> r) -> ((# #) -> r) -> r
RgbaPremultipliedDouble r g b a <-
	(fromRgbaPremultipliedDouble -> (r, g, b, a))

rgbaPremultipliedDouble :: (Ord d, Num d) => d -> d -> d -> d -> Maybe (Rgba d)
rgbaPremultipliedDouble :: forall d. (Ord d, Num d) => d -> d -> d -> d -> Maybe (Rgba d)
rgbaPremultipliedDouble d
r d
g d
b d
a
	| d
0 forall a. Ord a => a -> a -> Bool
<= d
r Bool -> Bool -> Bool
&& d
r forall a. Ord a => a -> a -> Bool
<= d
a, d
0 forall a. Ord a => a -> a -> Bool
<= d
g Bool -> Bool -> Bool
&& d
g forall a. Ord a => a -> a -> Bool
<= d
a, d
0 forall a. Ord a => a -> a -> Bool
<= d
b Bool -> Bool -> Bool
&& d
b forall a. Ord a => a -> a -> Bool
<= d
a,
		d
0 forall a. Ord a => a -> a -> Bool
<= d
a Bool -> Bool -> Bool
&& d
a forall a. Ord a => a -> a -> Bool
<= d
1 = forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ forall d. d -> d -> d -> d -> Rgba d
RgbaPremultipliedDouble_ d
r d
g d
b d
a
	| Bool
otherwise = forall a. Maybe a
Nothing

fromRgbaPremultipliedDouble :: (Eq d, Fractional d) => Rgba d -> (d, d, d, d)
fromRgbaPremultipliedDouble :: forall d. (Eq d, Fractional d) => Rgba d -> (d, d, d, d)
fromRgbaPremultipliedDouble = forall d. Fractional d => (d, d, d, d) -> (d, d, d, d)
toPremultipliedDouble forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall d. (Eq d, Fractional d) => Rgba d -> (d, d, d, d)
fromRgbaDouble

toPremultipliedDouble :: Fractional d => (d, d, d, d) -> (d, d, d, d)
toPremultipliedDouble :: forall d. Fractional d => (d, d, d, d) -> (d, d, d, d)
toPremultipliedDouble (d
r, d
g, d
b, d
a) = (d
r forall a. Num a => a -> a -> a
* d
a, d
g forall a. Num a => a -> a -> a
* d
a, d
b forall a. Num a => a -> a -> a
* d
a, d
a)

unPremultipliedDouble :: (Eq d, Fractional d) => (d, d, d, d) -> [d]
unPremultipliedDouble :: forall d. (Eq d, Fractional d) => (d, d, d, d) -> [d]
unPremultipliedDouble (d
r, d
g, d
b, d
a) = [d
r forall a. (Eq a, Fractional a) => a -> a -> a
./. d
a, d
g forall a. (Eq a, Fractional a) => a -> a -> a
./. d
a, d
b forall a. (Eq a, Fractional a) => a -> a -> a
./. d
a, d
a]

div' :: (Integral n, Bounded n) => n -> n -> n
n
0 div' :: forall n. (Integral n, Bounded n) => n -> n -> n
`div'` n
0 = n
0
n
_ `div'` n
0 = forall a. Bounded a => a
maxBound
n
a `div'` n
b = n
a forall a. Integral a => a -> a -> a
`div` n
b

(./.) :: (Eq a, Fractional a) => a -> a -> a
a
0 ./. :: forall a. (Eq a, Fractional a) => a -> a -> a
./. a
0 = a
0
a
a ./. a
b = a
a forall a. Fractional a => a -> a -> a
/ a
b