{-# 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
[Alpha d] -> ShowS
Alpha d -> String
(Int -> Alpha d -> ShowS)
-> (Alpha d -> String) -> ([Alpha d] -> ShowS) -> Show (Alpha d)
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 :: Word8 -> Alpha d
$mAlphaWord8 :: forall r d.
RealFrac d =>
Alpha d -> (Word8 -> r) -> (Void# -> r) -> r
AlphaWord8 a <- (fromAlphaWord8 -> a)
	where AlphaWord8 = Word8 -> Alpha d
forall d. Word8 -> Alpha d
AlphaWord8_

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

{-# COMPLETE AlphaWord16 #-}

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

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

{-# COMPLETE AlphaWord32 #-}

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

fromAlphaWord32 :: RealFrac d => Alpha d -> Word32
fromAlphaWord32 :: Alpha d -> Word32
fromAlphaWord32 = \case
	AlphaWord8_ (Word8 -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Word32
a) ->
		Word32
a Word32 -> Int -> Word32
forall a. Bits a => a -> Int -> a
`shiftL` Int
24 Word32 -> Word32 -> Word32
forall a. Bits a => a -> a -> a
.|. Word32
a Word32 -> Int -> Word32
forall a. Bits a => a -> Int -> a
`shiftL` Int
16 Word32 -> Word32 -> Word32
forall a. Bits a => a -> a -> a
.|. Word32
a Word32 -> Int -> Word32
forall a. Bits a => a -> Int -> a
`shiftL` Int
8 Word32 -> Word32 -> Word32
forall a. Bits a => a -> a -> a
.|. Word32
a
	AlphaWord16_ (Word16 -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Word32
a) -> Word32
a Word32 -> Int -> Word32
forall a. Bits a => a -> Int -> a
`shiftL` Int
16 Word32 -> Word32 -> Word32
forall a. Bits a => a -> a -> a
.|. Word32
a
	AlphaWord32_ Word32
a -> Word32
a
	AlphaInt32_ (Int32 -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Word32
a) -> Word32
a Word32 -> Int -> Word32
forall a. Bits a => a -> Int -> a
`shiftL` Int
1 Word32 -> Word32 -> Word32
forall a. Bits a => a -> a -> a
.|. Word32
a Word32 -> Int -> Word32
forall a. Bits a => a -> Int -> a
`shiftR` Int
30
	AlphaDouble_ d
a -> d -> Word32
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) -> (Void# -> r) -> r
AlphaInt32 a <- (fromAlphaInt32 -> a)

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

fromAlphaInt32 :: RealFrac d => Alpha d -> Int32
fromAlphaInt32 :: Alpha d -> Int32
fromAlphaInt32 = \case
	AlphaWord8_ (Word8 -> Int32
forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Int32
a) ->
		Int32
a Int32 -> Int -> Int32
forall a. Bits a => a -> Int -> a
`shiftL` Int
23 Int32 -> Int32 -> Int32
forall a. Bits a => a -> a -> a
.|. Int32
a Int32 -> Int -> Int32
forall a. Bits a => a -> Int -> a
`shiftL` Int
15 Int32 -> Int32 -> Int32
forall a. Bits a => a -> a -> a
.|.
		Int32
a Int32 -> Int -> Int32
forall a. Bits a => a -> Int -> a
`shiftL` Int
7 Int32 -> Int32 -> Int32
forall a. Bits a => a -> a -> a
.|. Int32
a Int32 -> Int -> Int32
forall a. Bits a => a -> Int -> a
`shiftR` Int
1
	AlphaWord16_ (Word16 -> Int32
forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Int32
a) ->
		Int32
a Int32 -> Int -> Int32
forall a. Bits a => a -> Int -> a
`shiftL` Int
15 Int32 -> Int32 -> Int32
forall a. Bits a => a -> a -> a
.|. Int32
a Int32 -> Int -> Int32
forall a. Bits a => a -> Int -> a
`shiftR` Int
1
	AlphaWord32_ Word32
a -> Word32 -> Int32
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word32 -> Int32) -> Word32 -> Int32
forall a b. (a -> b) -> a -> b
$ Word32
a Word32 -> Int -> Word32
forall a. Bits a => a -> Int -> a
`shiftR` Int
1
	AlphaInt32_ Int32
a -> Int32
a
	AlphaDouble_ d
a -> d -> Int32
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) -> (Void# -> r) -> r
AlphaDouble a <- (fromAlphaDouble -> a)

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

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

alphaRealToFrac :: (Real d, Fractional d') => Alpha d -> Alpha d'
alphaRealToFrac :: Alpha d -> Alpha d'
alphaRealToFrac = \case
	AlphaWord8_ Word8
a -> Word8 -> Alpha d'
forall d. Word8 -> Alpha d
AlphaWord8_ Word8
a
	AlphaWord16_ Word16
a -> Word16 -> Alpha d'
forall d. Word16 -> Alpha d
AlphaWord16_ Word16
a
	AlphaWord32_ Word32
a -> Word32 -> Alpha d'
forall d. Word32 -> Alpha d
AlphaWord32_ Word32
a
	AlphaInt32_ Int32
a -> Int32 -> Alpha d'
forall d. Int32 -> Alpha d
AlphaInt32_ Int32
a
	AlphaDouble_ d
a -> d' -> Alpha d'
forall d. d -> Alpha d
AlphaDouble_ (d' -> Alpha d') -> d' -> Alpha d'
forall a b. (a -> b) -> a -> b
$ d -> d'
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
[Rgb d] -> ShowS
Rgb d -> String
(Int -> Rgb d -> ShowS)
-> (Rgb d -> String) -> ([Rgb d] -> ShowS) -> Show (Rgb d)
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 :: Word8 -> Word8 -> Word8 -> Rgb d
$mRgbWord8 :: forall r d.
RealFrac d =>
Rgb d -> (Word8 -> Word8 -> Word8 -> r) -> (Void# -> r) -> r
RgbWord8 r g b <- (fromRgbWord8 -> (r, g, b))
	where RgbWord8 = Word8 -> Word8 -> Word8 -> Rgb d
forall d. Word8 -> Word8 -> Word8 -> Rgb d
RgbWord8_

fromRgbWord8 :: RealFrac d => Rgb d -> (Word8, Word8, Word8)
fromRgbWord8 :: 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 -> (
		Word16 -> Word8
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word16 -> Word8) -> Word16 -> Word8
forall a b. (a -> b) -> a -> b
$ Word16
r Word16 -> Int -> Word16
forall a. Bits a => a -> Int -> a
`shiftR` Int
8,
		Word16 -> Word8
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word16 -> Word8) -> Word16 -> Word8
forall a b. (a -> b) -> a -> b
$ Word16
g Word16 -> Int -> Word16
forall a. Bits a => a -> Int -> a
`shiftR` Int
8,
		Word16 -> Word8
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word16 -> Word8) -> Word16 -> Word8
forall a b. (a -> b) -> a -> b
$ Word16
b Word16 -> Int -> Word16
forall a. Bits a => a -> Int -> a
`shiftR` Int
8 )
	RgbWord32_ Word32
r Word32
g Word32
b -> (
		Word32 -> Word8
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word32 -> Word8) -> Word32 -> Word8
forall a b. (a -> b) -> a -> b
$ Word32
r Word32 -> Int -> Word32
forall a. Bits a => a -> Int -> a
`shiftR` Int
24,
		Word32 -> Word8
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word32 -> Word8) -> Word32 -> Word8
forall a b. (a -> b) -> a -> b
$ Word32
g Word32 -> Int -> Word32
forall a. Bits a => a -> Int -> a
`shiftR` Int
24,
		Word32 -> Word8
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word32 -> Word8) -> Word32 -> Word8
forall a b. (a -> b) -> a -> b
$ Word32
b Word32 -> Int -> Word32
forall a. Bits a => a -> Int -> a
`shiftR` Int
24 )
	RgbInt32_ Int32
r Int32
g Int32
b -> (
		Int32 -> Word8
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int32 -> Word8) -> Int32 -> Word8
forall a b. (a -> b) -> a -> b
$ Int32
r Int32 -> Int -> Int32
forall a. Bits a => a -> Int -> a
`shiftR` Int
23,
		Int32 -> Word8
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int32 -> Word8) -> Int32 -> Word8
forall a b. (a -> b) -> a -> b
$ Int32
g Int32 -> Int -> Int32
forall a. Bits a => a -> Int -> a
`shiftR` Int
23,
		Int32 -> Word8
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int32 -> Word8) -> Int32 -> Word8
forall a b. (a -> b) -> a -> b
$ Int32
b Int32 -> Int -> Int32
forall a. Bits a => a -> Int -> a
`shiftR` Int
23 )
	RgbDouble_ d
r d
g d
b ->
		let [Word8
r', Word8
g', Word8
b'] = d -> Word8
forall d. RealFrac d => d -> Word8
cDoubleToWord8 (d -> Word8) -> [d] -> [Word8]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [d
r, d
g, d
b] in (Word8
r', Word8
g', Word8
b')

{-# COMPLETE RgbWord16 #-}

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

fromRgbWord16 :: RealFrac d => Rgb d -> (Word16, Word16, Word16)
fromRgbWord16 :: Rgb d -> (Word16, Word16, Word16)
fromRgbWord16 = \case
	RgbWord8_ (Word8 -> Word16
forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Word16
r) (Word8 -> Word16
forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Word16
g) (Word8 -> Word16
forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Word16
b) ->
		(Word16
r Word16 -> Int -> Word16
forall a. Bits a => a -> Int -> a
`shiftL` Int
8 Word16 -> Word16 -> Word16
forall a. Bits a => a -> a -> a
.|. Word16
r, Word16
g Word16 -> Int -> Word16
forall a. Bits a => a -> Int -> a
`shiftL` Int
8 Word16 -> Word16 -> Word16
forall a. Bits a => a -> a -> a
.|. Word16
g, Word16
b Word16 -> Int -> Word16
forall a. Bits a => a -> Int -> a
`shiftL` Int
8 Word16 -> Word16 -> Word16
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 -> (
		Word32 -> Word16
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word32 -> Word16) -> Word32 -> Word16
forall a b. (a -> b) -> a -> b
$ Word32
r Word32 -> Int -> Word32
forall a. Bits a => a -> Int -> a
`shiftR` Int
16,
		Word32 -> Word16
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word32 -> Word16) -> Word32 -> Word16
forall a b. (a -> b) -> a -> b
$ Word32
g Word32 -> Int -> Word32
forall a. Bits a => a -> Int -> a
`shiftR` Int
16,
		Word32 -> Word16
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word32 -> Word16) -> Word32 -> Word16
forall a b. (a -> b) -> a -> b
$ Word32
b Word32 -> Int -> Word32
forall a. Bits a => a -> Int -> a
`shiftR` Int
16 )
	RgbInt32_ Int32
r Int32
g Int32
b -> (
		Int32 -> Word16
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int32 -> Word16) -> Int32 -> Word16
forall a b. (a -> b) -> a -> b
$ Int32
r Int32 -> Int -> Int32
forall a. Bits a => a -> Int -> a
`shiftR` Int
15,
		Int32 -> Word16
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int32 -> Word16) -> Int32 -> Word16
forall a b. (a -> b) -> a -> b
$ Int32
g Int32 -> Int -> Int32
forall a. Bits a => a -> Int -> a
`shiftR` Int
15,
		Int32 -> Word16
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int32 -> Word16) -> Int32 -> Word16
forall a b. (a -> b) -> a -> b
$ Int32
b Int32 -> Int -> Int32
forall a. Bits a => a -> Int -> a
`shiftR` Int
15 )
	RgbDouble_ d
r d
g d
b ->
		let [Word16
r', Word16
g', Word16
b'] = d -> Word16
forall d. RealFrac d => d -> Word16
cDoubleToWord16 (d -> Word16) -> [d] -> [Word16]
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 :: Word32 -> Word32 -> Word32 -> Rgb d
$mRgbWord32 :: forall r d.
RealFrac d =>
Rgb d -> (Word32 -> Word32 -> Word32 -> r) -> (Void# -> r) -> r
RgbWord32 r g b <- (fromRgbWord32 -> (r, g, b))
	where RgbWord32 = Word32 -> Word32 -> Word32 -> Rgb d
forall d. Word32 -> Word32 -> Word32 -> Rgb d
RgbWord32_

fromRgbWord32 :: RealFrac d => Rgb d -> (Word32, Word32, Word32)
fromRgbWord32 :: Rgb d -> (Word32, Word32, Word32)
fromRgbWord32 = \case
	RgbWord8_ (Word8 -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Word32
r) (Word8 -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Word32
g) (Word8 -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Word32
b) ->
		(	Word32
r Word32 -> Int -> Word32
forall a. Bits a => a -> Int -> a
`shiftL` Int
24 Word32 -> Word32 -> Word32
forall a. Bits a => a -> a -> a
.|. Word32
r Word32 -> Int -> Word32
forall a. Bits a => a -> Int -> a
`shiftL` Int
16 Word32 -> Word32 -> Word32
forall a. Bits a => a -> a -> a
.|. Word32
r Word32 -> Int -> Word32
forall a. Bits a => a -> Int -> a
`shiftL` Int
8 Word32 -> Word32 -> Word32
forall a. Bits a => a -> a -> a
.|. Word32
r,
			Word32
g Word32 -> Int -> Word32
forall a. Bits a => a -> Int -> a
`shiftL` Int
24 Word32 -> Word32 -> Word32
forall a. Bits a => a -> a -> a
.|. Word32
g Word32 -> Int -> Word32
forall a. Bits a => a -> Int -> a
`shiftL` Int
16 Word32 -> Word32 -> Word32
forall a. Bits a => a -> a -> a
.|. Word32
g Word32 -> Int -> Word32
forall a. Bits a => a -> Int -> a
`shiftL` Int
8 Word32 -> Word32 -> Word32
forall a. Bits a => a -> a -> a
.|. Word32
g,
			Word32
b Word32 -> Int -> Word32
forall a. Bits a => a -> Int -> a
`shiftL` Int
24 Word32 -> Word32 -> Word32
forall a. Bits a => a -> a -> a
.|. Word32
b Word32 -> Int -> Word32
forall a. Bits a => a -> Int -> a
`shiftL` Int
16 Word32 -> Word32 -> Word32
forall a. Bits a => a -> a -> a
.|. Word32
b Word32 -> Int -> Word32
forall a. Bits a => a -> Int -> a
`shiftL` Int
8 Word32 -> Word32 -> Word32
forall a. Bits a => a -> a -> a
.|. Word32
b )
	RgbWord16_ (Word16 -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Word32
r) (Word16 -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Word32
g) (Word16 -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Word32
b)
		-> (	Word32
r Word32 -> Int -> Word32
forall a. Bits a => a -> Int -> a
`shiftL` Int
16 Word32 -> Word32 -> Word32
forall a. Bits a => a -> a -> a
.|. Word32
r, Word32
g Word32 -> Int -> Word32
forall a. Bits a => a -> Int -> a
`shiftL` Int
16 Word32 -> Word32 -> Word32
forall a. Bits a => a -> a -> a
.|. Word32
g,
			Word32
b Word32 -> Int -> Word32
forall a. Bits a => a -> Int -> a
`shiftL` Int
16 Word32 -> Word32 -> Word32
forall a. Bits a => a -> a -> a
.|. Word32
b )
	RgbWord32_ Word32
r Word32
g Word32
b -> (Word32
r, Word32
g, Word32
b)
	RgbInt32_ (Int32 -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Word32
r) (Int32 -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Word32
g) (Int32 -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Word32
b) ->
		(	Word32
r Word32 -> Int -> Word32
forall a. Bits a => a -> Int -> a
`shiftL` Int
1 Word32 -> Word32 -> Word32
forall a. Bits a => a -> a -> a
.|. Word32
r Word32 -> Int -> Word32
forall a. Bits a => a -> Int -> a
`shiftR` Int
30,
			Word32
g Word32 -> Int -> Word32
forall a. Bits a => a -> Int -> a
`shiftL` Int
1 Word32 -> Word32 -> Word32
forall a. Bits a => a -> a -> a
.|. Word32
g Word32 -> Int -> Word32
forall a. Bits a => a -> Int -> a
`shiftR` Int
30,
			Word32
b Word32 -> Int -> Word32
forall a. Bits a => a -> Int -> a
`shiftL` Int
1 Word32 -> Word32 -> Word32
forall a. Bits a => a -> a -> a
.|. Word32
b Word32 -> Int -> Word32
forall a. Bits a => a -> Int -> a
`shiftR` Int
30 )
	RgbDouble_ d
r d
g d
b ->
		let [Word32
r', Word32
g', Word32
b'] = d -> Word32
forall d. RealFrac d => d -> Word32
cDoubleToWord32 (d -> Word32) -> [d] -> [Word32]
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) -> (Void# -> r) -> r
RgbInt32 r g b <- (fromRgbInt32 -> (r, g, b))

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

fromRgbInt32 :: RealFrac d => Rgb d -> (Int32, Int32, Int32)
fromRgbInt32 :: Rgb d -> (Int32, Int32, Int32)
fromRgbInt32 = \case
	RgbWord8_ (Word8 -> Int32
forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Int32
r) (Word8 -> Int32
forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Int32
g) (Word8 -> Int32
forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Int32
b) ->
		(	Int32
r Int32 -> Int -> Int32
forall a. Bits a => a -> Int -> a
`shiftL` Int
23 Int32 -> Int32 -> Int32
forall a. Bits a => a -> a -> a
.|. Int32
r Int32 -> Int -> Int32
forall a. Bits a => a -> Int -> a
`shiftL` Int
15 Int32 -> Int32 -> Int32
forall a. Bits a => a -> a -> a
.|.
			Int32
r Int32 -> Int -> Int32
forall a. Bits a => a -> Int -> a
`shiftL` Int
7 Int32 -> Int32 -> Int32
forall a. Bits a => a -> a -> a
.|. Int32
r Int32 -> Int -> Int32
forall a. Bits a => a -> Int -> a
`shiftR` Int
1,
			Int32
g Int32 -> Int -> Int32
forall a. Bits a => a -> Int -> a
`shiftL` Int
23 Int32 -> Int32 -> Int32
forall a. Bits a => a -> a -> a
.|. Int32
g Int32 -> Int -> Int32
forall a. Bits a => a -> Int -> a
`shiftL` Int
15 Int32 -> Int32 -> Int32
forall a. Bits a => a -> a -> a
.|.
			Int32
g Int32 -> Int -> Int32
forall a. Bits a => a -> Int -> a
`shiftL` Int
7 Int32 -> Int32 -> Int32
forall a. Bits a => a -> a -> a
.|. Int32
g Int32 -> Int -> Int32
forall a. Bits a => a -> Int -> a
`shiftR` Int
1,
			Int32
b Int32 -> Int -> Int32
forall a. Bits a => a -> Int -> a
`shiftL` Int
23 Int32 -> Int32 -> Int32
forall a. Bits a => a -> a -> a
.|. Int32
b Int32 -> Int -> Int32
forall a. Bits a => a -> Int -> a
`shiftL` Int
15 Int32 -> Int32 -> Int32
forall a. Bits a => a -> a -> a
.|.
			Int32
b Int32 -> Int -> Int32
forall a. Bits a => a -> Int -> a
`shiftL` Int
7 Int32 -> Int32 -> Int32
forall a. Bits a => a -> a -> a
.|. Int32
b Int32 -> Int -> Int32
forall a. Bits a => a -> Int -> a
`shiftR` Int
1 )
	RgbWord16_ (Word16 -> Int32
forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Int32
r) (Word16 -> Int32
forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Int32
g) (Word16 -> Int32
forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Int32
b) ->
		(	Int32
r Int32 -> Int -> Int32
forall a. Bits a => a -> Int -> a
`shiftL` Int
15 Int32 -> Int32 -> Int32
forall a. Bits a => a -> a -> a
.|. Int32
r Int32 -> Int -> Int32
forall a. Bits a => a -> Int -> a
`shiftR` Int
1,
			Int32
g Int32 -> Int -> Int32
forall a. Bits a => a -> Int -> a
`shiftL` Int
15 Int32 -> Int32 -> Int32
forall a. Bits a => a -> a -> a
.|. Int32
g Int32 -> Int -> Int32
forall a. Bits a => a -> Int -> a
`shiftR` Int
1,
			Int32
b Int32 -> Int -> Int32
forall a. Bits a => a -> Int -> a
`shiftL` Int
15 Int32 -> Int32 -> Int32
forall a. Bits a => a -> a -> a
.|. Int32
b Int32 -> Int -> Int32
forall a. Bits a => a -> Int -> a
`shiftR` Int
1 )
	RgbWord32_ Word32
r Word32
g Word32
b -> (
		Word32 -> Int32
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word32 -> Int32) -> Word32 -> Int32
forall a b. (a -> b) -> a -> b
$ Word32
r Word32 -> Int -> Word32
forall a. Bits a => a -> Int -> a
`shiftR` Int
1, Word32 -> Int32
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word32 -> Int32) -> Word32 -> Int32
forall a b. (a -> b) -> a -> b
$ Word32
g Word32 -> Int -> Word32
forall a. Bits a => a -> Int -> a
`shiftR` Int
1,
		Word32 -> Int32
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word32 -> Int32) -> Word32 -> Int32
forall a b. (a -> b) -> a -> b
$ Word32
b Word32 -> Int -> Word32
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'] = d -> Int32
forall d. RealFrac d => d -> Int32
cDoubleToInt32 (d -> Int32) -> [d] -> [Int32]
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) -> (Void# -> r) -> r
RgbDouble r g b <- (fromRgbDouble -> (r, g, b))

fromRgbDouble :: Fractional d => Rgb d -> (d, d, d)
fromRgbDouble :: Rgb d -> (d, d, d)
fromRgbDouble = \case
	RgbWord8_ Word8
r Word8
g Word8
b ->
		let [d
r', d
g', d
b'] = Word8 -> d
forall d. Fractional d => Word8 -> d
word8ToCDouble (Word8 -> d) -> [Word8] -> [d]
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'] = Word16 -> d
forall d. Fractional d => Word16 -> d
word16ToCDouble (Word16 -> d) -> [Word16] -> [d]
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'] = Word32 -> d
forall d. Fractional d => Word32 -> d
word32ToCDouble (Word32 -> d) -> [Word32] -> [d]
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'] = Int32 -> d
forall d. Fractional d => Int32 -> d
int32ToCDouble (Int32 -> d) -> [Int32] -> [d]
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 :: d -> d -> d -> Maybe (Rgb d)
rgbDouble d
r d
g d
b
	| d -> Bool
forall d. (Ord d, Num d) => d -> Bool
from0to1 d
r Bool -> Bool -> Bool
&& d -> Bool
forall d. (Ord d, Num d) => d -> Bool
from0to1 d
g Bool -> Bool -> Bool
&& d -> Bool
forall d. (Ord d, Num d) => d -> Bool
from0to1 d
b = Rgb d -> Maybe (Rgb d)
forall a. a -> Maybe a
Just (Rgb d -> Maybe (Rgb d)) -> Rgb d -> Maybe (Rgb d)
forall a b. (a -> b) -> a -> b
$ d -> d -> d -> Rgb d
forall d. d -> d -> d -> Rgb d
RgbDouble_ d
r d
g d
b
	| Bool
otherwise = Maybe (Rgb d)
forall a. Maybe a
Nothing

rgbRealToFrac :: (Real d, Fractional d') => Rgb d -> Rgb d'
rgbRealToFrac :: Rgb d -> Rgb d'
rgbRealToFrac = \case
	RgbWord8_ Word8
r Word8
g Word8
b -> Word8 -> Word8 -> Word8 -> Rgb d'
forall d. Word8 -> Word8 -> Word8 -> Rgb d
RgbWord8_ Word8
r Word8
g Word8
b
	RgbWord16_ Word16
r Word16
g Word16
b -> Word16 -> Word16 -> Word16 -> Rgb d'
forall d. Word16 -> Word16 -> Word16 -> Rgb d
RgbWord16_ Word16
r Word16
g Word16
b
	RgbWord32_ Word32
r Word32
g Word32
b -> Word32 -> Word32 -> Word32 -> Rgb d'
forall d. Word32 -> Word32 -> Word32 -> Rgb d
RgbWord32_ Word32
r Word32
g Word32
b
	RgbInt32_ Int32
r Int32
g Int32
b -> Int32 -> Int32 -> Int32 -> Rgb d'
forall d. Int32 -> Int32 -> Int32 -> Rgb d
RgbInt32_ Int32
r Int32
g Int32
b
	RgbDouble_ d
r d
g d
b -> d' -> d' -> d' -> Rgb d'
forall d. d -> d -> d -> Rgb d
RgbDouble_ d'
r' d'
g' d'
b'
		where [d'
r', d'
g', d'
b'] = d -> d'
forall a b. (Real a, Fractional b) => a -> b
realToFrac (d -> d') -> [d] -> [d']
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
[Rgba d] -> ShowS
Rgba d -> String
(Int -> Rgba d -> ShowS)
-> (Rgba d -> String) -> ([Rgba d] -> ShowS) -> Show (Rgba d)
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 :: Word8 -> Word8 -> Word8 -> Word8 -> Rgba d
$mRgbaWord8 :: forall r d.
RealFrac d =>
Rgba d
-> (Word8 -> Word8 -> Word8 -> Word8 -> r) -> (Void# -> r) -> r
RgbaWord8 r g b a <- (fromRgbaWord8 -> (r, g, b, a))
	where RgbaWord8 = Word8 -> Word8 -> Word8 -> Word8 -> Rgba d
forall d. Word8 -> Word8 -> Word8 -> Word8 -> Rgba d
RgbaWord8_

fromRgbaWord8 :: RealFrac d => Rgba d -> (Word8, Word8, Word8, Word8)
fromRgbaWord8 :: 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 -> (
		Word16 -> Word8
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word16 -> Word8) -> Word16 -> Word8
forall a b. (a -> b) -> a -> b
$ Word16
r Word16 -> Int -> Word16
forall a. Bits a => a -> Int -> a
`shiftR` Int
8, Word16 -> Word8
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word16 -> Word8) -> Word16 -> Word8
forall a b. (a -> b) -> a -> b
$ Word16
g Word16 -> Int -> Word16
forall a. Bits a => a -> Int -> a
`shiftR` Int
8,
		Word16 -> Word8
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word16 -> Word8) -> Word16 -> Word8
forall a b. (a -> b) -> a -> b
$ Word16
b Word16 -> Int -> Word16
forall a. Bits a => a -> Int -> a
`shiftR` Int
8, Word16 -> Word8
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word16 -> Word8) -> Word16 -> Word8
forall a b. (a -> b) -> a -> b
$ Word16
a Word16 -> Int -> Word16
forall a. Bits a => a -> Int -> a
`shiftR` Int
8 )
	RgbaWord32_ Word32
r Word32
g Word32
b Word32
a -> (
		Word32 -> Word8
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word32 -> Word8) -> Word32 -> Word8
forall a b. (a -> b) -> a -> b
$ Word32
r Word32 -> Int -> Word32
forall a. Bits a => a -> Int -> a
`shiftR` Int
24, Word32 -> Word8
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word32 -> Word8) -> Word32 -> Word8
forall a b. (a -> b) -> a -> b
$ Word32
g Word32 -> Int -> Word32
forall a. Bits a => a -> Int -> a
`shiftR` Int
24,
		Word32 -> Word8
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word32 -> Word8) -> Word32 -> Word8
forall a b. (a -> b) -> a -> b
$ Word32
b Word32 -> Int -> Word32
forall a. Bits a => a -> Int -> a
`shiftR` Int
24, Word32 -> Word8
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word32 -> Word8) -> Word32 -> Word8
forall a b. (a -> b) -> a -> b
$ Word32
a Word32 -> Int -> Word32
forall a. Bits a => a -> Int -> a
`shiftR` Int
24 )
	RgbaInt32_ Int32
r Int32
g Int32
b Int32
a -> (
		Int32 -> Word8
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int32 -> Word8) -> Int32 -> Word8
forall a b. (a -> b) -> a -> b
$ Int32
r Int32 -> Int -> Int32
forall a. Bits a => a -> Int -> a
`shiftR` Int
23, Int32 -> Word8
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int32 -> Word8) -> Int32 -> Word8
forall a b. (a -> b) -> a -> b
$ Int32
g Int32 -> Int -> Int32
forall a. Bits a => a -> Int -> a
`shiftR` Int
23,
		Int32 -> Word8
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int32 -> Word8) -> Int32 -> Word8
forall a b. (a -> b) -> a -> b
$ Int32
b Int32 -> Int -> Int32
forall a. Bits a => a -> Int -> a
`shiftR` Int
23, Int32 -> Word8
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int32 -> Word8) -> Int32 -> Word8
forall a b. (a -> b) -> a -> b
$ Int32
a Int32 -> Int -> Int32
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'] = d -> Word8
forall d. RealFrac d => d -> Word8
cDoubleToWord8 (d -> Word8) -> [d] -> [Word8]
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 -> (
		Word16 -> Word8
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word16 -> Word8) -> Word16 -> Word8
forall a b. (a -> b) -> a -> b
$ Word16
r' Word16 -> Int -> Word16
forall a. Bits a => a -> Int -> a
`shiftR` Int
8,
		Word16 -> Word8
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word16 -> Word8) -> Word16 -> Word8
forall a b. (a -> b) -> a -> b
$ Word16
g' Word16 -> Int -> Word16
forall a. Bits a => a -> Int -> a
`shiftR` Int
8,
		Word16 -> Word8
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word16 -> Word8) -> Word16 -> Word8
forall a b. (a -> b) -> a -> b
$ Word16
b' Word16 -> Int -> Word16
forall a. Bits a => a -> Int -> a
`shiftR` Int
8,
		Word16 -> Word8
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word16 -> Word8) -> Word16 -> Word8
forall a b. (a -> b) -> a -> b
$ Word16
a' Word16 -> Int -> Word16
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'] =
			d -> Word8
forall d. RealFrac d => d -> Word8
cDoubleToWord8 (d -> Word8) -> [d] -> [Word8]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (d, d, d, d) -> [d]
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 :: Word16 -> Word16 -> Word16 -> Word16 -> Rgba d
$mRgbaWord16 :: forall r d.
RealFrac d =>
Rgba d
-> (Word16 -> Word16 -> Word16 -> Word16 -> r) -> (Void# -> r) -> r
RgbaWord16 r g b a <- (fromRgbaWord16 -> (r, g, b, a))
	where RgbaWord16 = Word16 -> Word16 -> Word16 -> Word16 -> Rgba d
forall d. Word16 -> Word16 -> Word16 -> Word16 -> Rgba d
RgbaWord16_

fromRgbaWord16 :: RealFrac d => Rgba d -> (Word16, Word16, Word16, Word16)
fromRgbaWord16 :: Rgba d -> (Word16, Word16, Word16, Word16)
fromRgbaWord16 = \case
	RgbaWord8_
		(Word8 -> Word16
forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Word16
r) (Word8 -> Word16
forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Word16
g)
		(Word8 -> Word16
forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Word16
b) (Word8 -> Word16
forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Word16
a) -> (
		Word16
r Word16 -> Int -> Word16
forall a. Bits a => a -> Int -> a
`shiftL` Int
8 Word16 -> Word16 -> Word16
forall a. Bits a => a -> a -> a
.|. Word16
r, Word16
g Word16 -> Int -> Word16
forall a. Bits a => a -> Int -> a
`shiftL` Int
8 Word16 -> Word16 -> Word16
forall a. Bits a => a -> a -> a
.|. Word16
g,
		Word16
b Word16 -> Int -> Word16
forall a. Bits a => a -> Int -> a
`shiftL` Int
8 Word16 -> Word16 -> Word16
forall a. Bits a => a -> a -> a
.|. Word16
b, Word16
a Word16 -> Int -> Word16
forall a. Bits a => a -> Int -> a
`shiftL` Int
8 Word16 -> Word16 -> Word16
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 -> (
		Word32 -> Word16
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word32 -> Word16) -> Word32 -> Word16
forall a b. (a -> b) -> a -> b
$ Word32
r Word32 -> Int -> Word32
forall a. Bits a => a -> Int -> a
`shiftR` Int
16, Word32 -> Word16
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word32 -> Word16) -> Word32 -> Word16
forall a b. (a -> b) -> a -> b
$ Word32
g Word32 -> Int -> Word32
forall a. Bits a => a -> Int -> a
`shiftR` Int
16,
		Word32 -> Word16
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word32 -> Word16) -> Word32 -> Word16
forall a b. (a -> b) -> a -> b
$ Word32
b Word32 -> Int -> Word32
forall a. Bits a => a -> Int -> a
`shiftR` Int
16, Word32 -> Word16
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word32 -> Word16) -> Word32 -> Word16
forall a b. (a -> b) -> a -> b
$ Word32
a Word32 -> Int -> Word32
forall a. Bits a => a -> Int -> a
`shiftR` Int
16 )
	RgbaInt32_ Int32
r Int32
g Int32
b Int32
a -> (
		Int32 -> Word16
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int32 -> Word16) -> Int32 -> Word16
forall a b. (a -> b) -> a -> b
$ Int32
r Int32 -> Int -> Int32
forall a. Bits a => a -> Int -> a
`shiftR` Int
15, Int32 -> Word16
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int32 -> Word16) -> Int32 -> Word16
forall a b. (a -> b) -> a -> b
$ Int32
g Int32 -> Int -> Int32
forall a. Bits a => a -> Int -> a
`shiftR` Int
15,
		Int32 -> Word16
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int32 -> Word16) -> Int32 -> Word16
forall a b. (a -> b) -> a -> b
$ Int32
b Int32 -> Int -> Int32
forall a. Bits a => a -> Int -> a
`shiftR` Int
15, Int32 -> Word16
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int32 -> Word16) -> Int32 -> Word16
forall a b. (a -> b) -> a -> b
$ Int32
a Int32 -> Int -> Int32
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'] = d -> Word16
forall d. RealFrac d => d -> Word16
cDoubleToWord16 (d -> Word16) -> [d] -> [Word16]
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' Word16 -> Int -> Word16
forall a. Bits a => a -> Int -> a
`shiftL` Int
8 Word16 -> Word16 -> Word16
forall a. Bits a => a -> a -> a
.|. Word16
r', Word16
g' Word16 -> Int -> Word16
forall a. Bits a => a -> Int -> a
`shiftL` Int
8 Word16 -> Word16 -> Word16
forall a. Bits a => a -> a -> a
.|. Word16
g',
		Word16
b' Word16 -> Int -> Word16
forall a. Bits a => a -> Int -> a
`shiftL` Int
8 Word16 -> Word16 -> Word16
forall a. Bits a => a -> a -> a
.|. Word16
b', Word16
a' Word16 -> Int -> Word16
forall a. Bits a => a -> Int -> a
`shiftL` Int
8 Word16 -> Word16 -> Word16
forall a. Bits a => a -> a -> a
.|. Word16
a')
		where [Word16
r', Word16
g', Word16
b', Word16
a'] =
			Word8 -> Word16
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word8 -> Word16) -> [Word8] -> [Word16]
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'] =
			d -> Word16
forall d. RealFrac d => d -> Word16
cDoubleToWord16 (d -> Word16) -> [d] -> [Word16]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (d, d, d, d) -> [d]
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 :: Word32 -> Word32 -> Word32 -> Word32 -> Rgba d
$mRgbaWord32 :: forall r d.
RealFrac d =>
Rgba d
-> (Word32 -> Word32 -> Word32 -> Word32 -> r) -> (Void# -> r) -> r
RgbaWord32 r g b a <- (fromRgbaWord32 -> (r, g, b, a))
	where RgbaWord32 = Word32 -> Word32 -> Word32 -> Word32 -> Rgba d
forall d. Word32 -> Word32 -> Word32 -> Word32 -> Rgba d
RgbaWord32_

fromRgbaWord32 :: RealFrac d => Rgba d -> (Word32, Word32, Word32, Word32)
fromRgbaWord32 :: Rgba d -> (Word32, Word32, Word32, Word32)
fromRgbaWord32 = \case
	RgbaWord8_
		(Word8 -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Word32
r) (Word8 -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Word32
g)
		(Word8 -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Word32
b) (Word8 -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Word32
a) -> (
		Word32
r Word32 -> Int -> Word32
forall a. Bits a => a -> Int -> a
`shiftL` Int
24 Word32 -> Word32 -> Word32
forall a. Bits a => a -> a -> a
.|. Word32
r Word32 -> Int -> Word32
forall a. Bits a => a -> Int -> a
`shiftL` Int
16 Word32 -> Word32 -> Word32
forall a. Bits a => a -> a -> a
.|. Word32
r Word32 -> Int -> Word32
forall a. Bits a => a -> Int -> a
`shiftL` Int
8 Word32 -> Word32 -> Word32
forall a. Bits a => a -> a -> a
.|. Word32
r,
		Word32
g Word32 -> Int -> Word32
forall a. Bits a => a -> Int -> a
`shiftL` Int
24 Word32 -> Word32 -> Word32
forall a. Bits a => a -> a -> a
.|. Word32
g Word32 -> Int -> Word32
forall a. Bits a => a -> Int -> a
`shiftL` Int
16 Word32 -> Word32 -> Word32
forall a. Bits a => a -> a -> a
.|. Word32
g Word32 -> Int -> Word32
forall a. Bits a => a -> Int -> a
`shiftL` Int
8 Word32 -> Word32 -> Word32
forall a. Bits a => a -> a -> a
.|. Word32
g,
		Word32
b Word32 -> Int -> Word32
forall a. Bits a => a -> Int -> a
`shiftL` Int
24 Word32 -> Word32 -> Word32
forall a. Bits a => a -> a -> a
.|. Word32
b Word32 -> Int -> Word32
forall a. Bits a => a -> Int -> a
`shiftL` Int
16 Word32 -> Word32 -> Word32
forall a. Bits a => a -> a -> a
.|. Word32
b Word32 -> Int -> Word32
forall a. Bits a => a -> Int -> a
`shiftL` Int
8 Word32 -> Word32 -> Word32
forall a. Bits a => a -> a -> a
.|. Word32
b,
		Word32
a Word32 -> Int -> Word32
forall a. Bits a => a -> Int -> a
`shiftL` Int
24 Word32 -> Word32 -> Word32
forall a. Bits a => a -> a -> a
.|. Word32
a Word32 -> Int -> Word32
forall a. Bits a => a -> Int -> a
`shiftL` Int
16 Word32 -> Word32 -> Word32
forall a. Bits a => a -> a -> a
.|. Word32
a Word32 -> Int -> Word32
forall a. Bits a => a -> Int -> a
`shiftL` Int
8 Word32 -> Word32 -> Word32
forall a. Bits a => a -> a -> a
.|. Word32
a )
	RgbaWord16_
		(Word16 -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Word32
r) (Word16 -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Word32
g)
		(Word16 -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Word32
b) (Word16 -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Word32
a) -> (
		Word32
r Word32 -> Int -> Word32
forall a. Bits a => a -> Int -> a
`shiftL` Int
16 Word32 -> Word32 -> Word32
forall a. Bits a => a -> a -> a
.|. Word32
r, Word32
g Word32 -> Int -> Word32
forall a. Bits a => a -> Int -> a
`shiftL` Int
16 Word32 -> Word32 -> Word32
forall a. Bits a => a -> a -> a
.|. Word32
g,
		Word32
b Word32 -> Int -> Word32
forall a. Bits a => a -> Int -> a
`shiftL` Int
16 Word32 -> Word32 -> Word32
forall a. Bits a => a -> a -> a
.|. Word32
b, Word32
a Word32 -> Int -> Word32
forall a. Bits a => a -> Int -> a
`shiftL` Int
16 Word32 -> Word32 -> Word32
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_
		(Int32 -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Word32
r) (Int32 -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Word32
g)
		(Int32 -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Word32
b) (Int32 -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Word32
a) -> (
		Word32
r Word32 -> Int -> Word32
forall a. Bits a => a -> Int -> a
`shiftL` Int
1 Word32 -> Word32 -> Word32
forall a. Bits a => a -> a -> a
.|. Word32
r Word32 -> Int -> Word32
forall a. Bits a => a -> Int -> a
`shiftR` Int
30, Word32
g Word32 -> Int -> Word32
forall a. Bits a => a -> Int -> a
`shiftL` Int
1 Word32 -> Word32 -> Word32
forall a. Bits a => a -> a -> a
.|. Word32
g Word32 -> Int -> Word32
forall a. Bits a => a -> Int -> a
`shiftR` Int
30,
		Word32
b Word32 -> Int -> Word32
forall a. Bits a => a -> Int -> a
`shiftL` Int
1 Word32 -> Word32 -> Word32
forall a. Bits a => a -> a -> a
.|. Word32
b Word32 -> Int -> Word32
forall a. Bits a => a -> Int -> a
`shiftR` Int
30, Word32
a Word32 -> Int -> Word32
forall a. Bits a => a -> Int -> a
`shiftL` Int
1 Word32 -> Word32 -> Word32
forall a. Bits a => a -> a -> a
.|. Word32
a Word32 -> Int -> Word32
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'] = d -> Word32
forall d. RealFrac d => d -> Word32
cDoubleToWord32 (d -> Word32) -> [d] -> [Word32]
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' Word32 -> Int -> Word32
forall a. Bits a => a -> Int -> a
`shiftL`  Int
24 Word32 -> Word32 -> Word32
forall a. Bits a => a -> a -> a
.|. Word32
r' Word32 -> Int -> Word32
forall a. Bits a => a -> Int -> a
`shiftL` Int
16 Word32 -> Word32 -> Word32
forall a. Bits a => a -> a -> a
.|. Word32
r' Word32 -> Int -> Word32
forall a. Bits a => a -> Int -> a
`shiftL` Int
8 Word32 -> Word32 -> Word32
forall a. Bits a => a -> a -> a
.|. Word32
r',
		Word32
g' Word32 -> Int -> Word32
forall a. Bits a => a -> Int -> a
`shiftL`  Int
24 Word32 -> Word32 -> Word32
forall a. Bits a => a -> a -> a
.|. Word32
g' Word32 -> Int -> Word32
forall a. Bits a => a -> Int -> a
`shiftL` Int
16 Word32 -> Word32 -> Word32
forall a. Bits a => a -> a -> a
.|. Word32
g' Word32 -> Int -> Word32
forall a. Bits a => a -> Int -> a
`shiftL` Int
8 Word32 -> Word32 -> Word32
forall a. Bits a => a -> a -> a
.|. Word32
g',
		Word32
b' Word32 -> Int -> Word32
forall a. Bits a => a -> Int -> a
`shiftL`  Int
24 Word32 -> Word32 -> Word32
forall a. Bits a => a -> a -> a
.|. Word32
b' Word32 -> Int -> Word32
forall a. Bits a => a -> Int -> a
`shiftL` Int
16 Word32 -> Word32 -> Word32
forall a. Bits a => a -> a -> a
.|. Word32
b' Word32 -> Int -> Word32
forall a. Bits a => a -> Int -> a
`shiftL` Int
8 Word32 -> Word32 -> Word32
forall a. Bits a => a -> a -> a
.|. Word32
b',
		Word32
a' Word32 -> Int -> Word32
forall a. Bits a => a -> Int -> a
`shiftL`  Int
24 Word32 -> Word32 -> Word32
forall a. Bits a => a -> a -> a
.|. Word32
a' Word32 -> Int -> Word32
forall a. Bits a => a -> Int -> a
`shiftL` Int
16 Word32 -> Word32 -> Word32
forall a. Bits a => a -> a -> a
.|. Word32
a' Word32 -> Int -> Word32
forall a. Bits a => a -> Int -> a
`shiftL` Int
8 Word32 -> Word32 -> Word32
forall a. Bits a => a -> a -> a
.|. Word32
a' )
		where [Word32
r', Word32
g', Word32
b', Word32
a'] =
			Word8 -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word8 -> Word32) -> [Word8] -> [Word32]
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' Word32 -> Int -> Word32
forall a. Bits a => a -> Int -> a
`shiftL` Int
16 Word32 -> Word32 -> Word32
forall a. Bits a => a -> a -> a
.|. Word32
r', Word32
g' Word32 -> Int -> Word32
forall a. Bits a => a -> Int -> a
`shiftL` Int
16 Word32 -> Word32 -> Word32
forall a. Bits a => a -> a -> a
.|. Word32
g',
		Word32
b' Word32 -> Int -> Word32
forall a. Bits a => a -> Int -> a
`shiftL` Int
16 Word32 -> Word32 -> Word32
forall a. Bits a => a -> a -> a
.|. Word32
b', Word32
a' Word32 -> Int -> Word32
forall a. Bits a => a -> Int -> a
`shiftL` Int
16 Word32 -> Word32 -> Word32
forall a. Bits a => a -> a -> a
.|. Word32
a' )
		where [Word32
r', Word32
g', Word32
b', Word32
a'] =
			Word16 -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word16 -> Word32) -> [Word16] -> [Word32]
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'] =
			d -> Word32
forall d. RealFrac d => d -> Word32
cDoubleToWord32 (d -> Word32) -> [d] -> [Word32]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (d, d, d, d) -> [d]
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) -> (Void# -> r) -> r
RgbaInt32 r g b a <- (fromRgbaInt32 -> (r, g, b, a))

rgbaInt32 :: Int32 -> Int32 -> Int32 -> Int32 -> Maybe (Rgba d)
rgbaInt32 :: Int32 -> Int32 -> Int32 -> Int32 -> Maybe (Rgba d)
rgbaInt32 Int32
r Int32
g Int32
b Int32
a
	| Int32
r Int32 -> Int32 -> Bool
forall a. Ord a => a -> a -> Bool
< Int32
0 Bool -> Bool -> Bool
|| Int32
g Int32 -> Int32 -> Bool
forall a. Ord a => a -> a -> Bool
< Int32
0 Bool -> Bool -> Bool
|| Int32
b Int32 -> Int32 -> Bool
forall a. Ord a => a -> a -> Bool
< Int32
0 Bool -> Bool -> Bool
|| Int32
a Int32 -> Int32 -> Bool
forall a. Ord a => a -> a -> Bool
< Int32
0 = Maybe (Rgba d)
forall a. Maybe a
Nothing
	| Bool
otherwise = Rgba d -> Maybe (Rgba d)
forall a. a -> Maybe a
Just (Rgba d -> Maybe (Rgba d)) -> Rgba d -> Maybe (Rgba d)
forall a b. (a -> b) -> a -> b
$ Int32 -> Int32 -> Int32 -> Int32 -> Rgba d
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 :: Rgba d -> (Int32, Int32, Int32, Int32)
fromRgbaInt32 = \case
	RgbaWord8_
		(Word8 -> Int32
forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Int32
r) (Word8 -> Int32
forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Int32
g)
		(Word8 -> Int32
forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Int32
b) (Word8 -> Int32
forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Int32
a) -> (
		Int32
r Int32 -> Int -> Int32
forall a. Bits a => a -> Int -> a
`shiftL` Int
23 Int32 -> Int32 -> Int32
forall a. Bits a => a -> a -> a
.|. Int32
r Int32 -> Int -> Int32
forall a. Bits a => a -> Int -> a
`shiftL` Int
15 Int32 -> Int32 -> Int32
forall a. Bits a => a -> a -> a
.|.
		Int32
r Int32 -> Int -> Int32
forall a. Bits a => a -> Int -> a
`shiftL` Int
7 Int32 -> Int32 -> Int32
forall a. Bits a => a -> a -> a
.|. Int32
r Int32 -> Int -> Int32
forall a. Bits a => a -> Int -> a
`shiftR` Int
1,
		Int32
g Int32 -> Int -> Int32
forall a. Bits a => a -> Int -> a
`shiftL` Int
23 Int32 -> Int32 -> Int32
forall a. Bits a => a -> a -> a
.|. Int32
g Int32 -> Int -> Int32
forall a. Bits a => a -> Int -> a
`shiftL` Int
15 Int32 -> Int32 -> Int32
forall a. Bits a => a -> a -> a
.|.
		Int32
g Int32 -> Int -> Int32
forall a. Bits a => a -> Int -> a
`shiftL` Int
7 Int32 -> Int32 -> Int32
forall a. Bits a => a -> a -> a
.|. Int32
g Int32 -> Int -> Int32
forall a. Bits a => a -> Int -> a
`shiftR` Int
1,
		Int32
b Int32 -> Int -> Int32
forall a. Bits a => a -> Int -> a
`shiftL` Int
23 Int32 -> Int32 -> Int32
forall a. Bits a => a -> a -> a
.|. Int32
b Int32 -> Int -> Int32
forall a. Bits a => a -> Int -> a
`shiftL` Int
15 Int32 -> Int32 -> Int32
forall a. Bits a => a -> a -> a
.|.
		Int32
b Int32 -> Int -> Int32
forall a. Bits a => a -> Int -> a
`shiftL` Int
7 Int32 -> Int32 -> Int32
forall a. Bits a => a -> a -> a
.|. Int32
b Int32 -> Int -> Int32
forall a. Bits a => a -> Int -> a
`shiftR` Int
1,
		Int32
a Int32 -> Int -> Int32
forall a. Bits a => a -> Int -> a
`shiftL` Int
23 Int32 -> Int32 -> Int32
forall a. Bits a => a -> a -> a
.|. Int32
a Int32 -> Int -> Int32
forall a. Bits a => a -> Int -> a
`shiftL` Int
15 Int32 -> Int32 -> Int32
forall a. Bits a => a -> a -> a
.|.
		Int32
a Int32 -> Int -> Int32
forall a. Bits a => a -> Int -> a
`shiftL` Int
7 Int32 -> Int32 -> Int32
forall a. Bits a => a -> a -> a
.|. Int32
a Int32 -> Int -> Int32
forall a. Bits a => a -> Int -> a
`shiftR` Int
1 )
	RgbaWord16_
		(Word16 -> Int32
forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Int32
r) (Word16 -> Int32
forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Int32
g)
		(Word16 -> Int32
forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Int32
b) (Word16 -> Int32
forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Int32
a) -> (
		Int32
r Int32 -> Int -> Int32
forall a. Bits a => a -> Int -> a
`shiftL` Int
15 Int32 -> Int32 -> Int32
forall a. Bits a => a -> a -> a
.|. Int32
r Int32 -> Int -> Int32
forall a. Bits a => a -> Int -> a
`shiftR` Int
1, Int32
g Int32 -> Int -> Int32
forall a. Bits a => a -> Int -> a
`shiftL` Int
15 Int32 -> Int32 -> Int32
forall a. Bits a => a -> a -> a
.|. Int32
g Int32 -> Int -> Int32
forall a. Bits a => a -> Int -> a
`shiftR` Int
1,
		Int32
b Int32 -> Int -> Int32
forall a. Bits a => a -> Int -> a
`shiftL` Int
15 Int32 -> Int32 -> Int32
forall a. Bits a => a -> a -> a
.|. Int32
b Int32 -> Int -> Int32
forall a. Bits a => a -> Int -> a
`shiftR` Int
1, Int32
a Int32 -> Int -> Int32
forall a. Bits a => a -> Int -> a
`shiftL` Int
15 Int32 -> Int32 -> Int32
forall a. Bits a => a -> a -> a
.|. Int32
a Int32 -> Int -> Int32
forall a. Bits a => a -> Int -> a
`shiftR` Int
1 )
	RgbaWord32_ Word32
r Word32
g Word32
b Word32
a -> (
		Word32 -> Int32
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word32 -> Int32) -> Word32 -> Int32
forall a b. (a -> b) -> a -> b
$ Word32
r Word32 -> Int -> Word32
forall a. Bits a => a -> Int -> a
`shiftR` Int
1, Word32 -> Int32
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word32 -> Int32) -> Word32 -> Int32
forall a b. (a -> b) -> a -> b
$ Word32
g Word32 -> Int -> Word32
forall a. Bits a => a -> Int -> a
`shiftR` Int
1,
		Word32 -> Int32
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word32 -> Int32) -> Word32 -> Int32
forall a b. (a -> b) -> a -> b
$ Word32
b Word32 -> Int -> Word32
forall a. Bits a => a -> Int -> a
`shiftR` Int
1, Word32 -> Int32
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word32 -> Int32) -> Word32 -> Int32
forall a b. (a -> b) -> a -> b
$ Word32
a Word32 -> Int -> Word32
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'] = d -> Int32
forall d. RealFrac d => d -> Int32
cDoubleToInt32 (d -> Int32) -> [d] -> [Int32]
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' Int32 -> Int -> Int32
forall a. Bits a => a -> Int -> a
`shiftL` Int
23 Int32 -> Int32 -> Int32
forall a. Bits a => a -> a -> a
.|. Int32
r' Int32 -> Int -> Int32
forall a. Bits a => a -> Int -> a
`shiftL` Int
15 Int32 -> Int32 -> Int32
forall a. Bits a => a -> a -> a
.|.
		Int32
r' Int32 -> Int -> Int32
forall a. Bits a => a -> Int -> a
`shiftL` Int
7 Int32 -> Int32 -> Int32
forall a. Bits a => a -> a -> a
.|. Int32
r' Int32 -> Int -> Int32
forall a. Bits a => a -> Int -> a
`shiftR` Int
1,
		Int32
g' Int32 -> Int -> Int32
forall a. Bits a => a -> Int -> a
`shiftL` Int
23 Int32 -> Int32 -> Int32
forall a. Bits a => a -> a -> a
.|. Int32
g' Int32 -> Int -> Int32
forall a. Bits a => a -> Int -> a
`shiftL` Int
15 Int32 -> Int32 -> Int32
forall a. Bits a => a -> a -> a
.|.
		Int32
g' Int32 -> Int -> Int32
forall a. Bits a => a -> Int -> a
`shiftL` Int
7 Int32 -> Int32 -> Int32
forall a. Bits a => a -> a -> a
.|. Int32
g' Int32 -> Int -> Int32
forall a. Bits a => a -> Int -> a
`shiftR` Int
1,
		Int32
b' Int32 -> Int -> Int32
forall a. Bits a => a -> Int -> a
`shiftL` Int
23 Int32 -> Int32 -> Int32
forall a. Bits a => a -> a -> a
.|. Int32
b' Int32 -> Int -> Int32
forall a. Bits a => a -> Int -> a
`shiftL` Int
15 Int32 -> Int32 -> Int32
forall a. Bits a => a -> a -> a
.|.
		Int32
b' Int32 -> Int -> Int32
forall a. Bits a => a -> Int -> a
`shiftL` Int
7 Int32 -> Int32 -> Int32
forall a. Bits a => a -> a -> a
.|. Int32
b' Int32 -> Int -> Int32
forall a. Bits a => a -> Int -> a
`shiftR` Int
1,
		Int32
a' Int32 -> Int -> Int32
forall a. Bits a => a -> Int -> a
`shiftL` Int
23 Int32 -> Int32 -> Int32
forall a. Bits a => a -> a -> a
.|. Int32
a' Int32 -> Int -> Int32
forall a. Bits a => a -> Int -> a
`shiftL` Int
15 Int32 -> Int32 -> Int32
forall a. Bits a => a -> a -> a
.|.
		Int32
a' Int32 -> Int -> Int32
forall a. Bits a => a -> Int -> a
`shiftL` Int
7 Int32 -> Int32 -> Int32
forall a. Bits a => a -> a -> a
.|. Int32
a' Int32 -> Int -> Int32
forall a. Bits a => a -> Int -> a
`shiftR` Int
1 )
		where [Int32
r', Int32
g', Int32
b', Int32
a'] =
			Word8 -> Int32
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word8 -> Int32) -> [Word8] -> [Int32]
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' Int32 -> Int -> Int32
forall a. Bits a => a -> Int -> a
`shiftL` Int
15 Int32 -> Int32 -> Int32
forall a. Bits a => a -> a -> a
.|. Int32
r' Int32 -> Int -> Int32
forall a. Bits a => a -> Int -> a
`shiftR` Int
1,
		Int32
g' Int32 -> Int -> Int32
forall a. Bits a => a -> Int -> a
`shiftL` Int
15 Int32 -> Int32 -> Int32
forall a. Bits a => a -> a -> a
.|. Int32
g' Int32 -> Int -> Int32
forall a. Bits a => a -> Int -> a
`shiftR` Int
1,
		Int32
b' Int32 -> Int -> Int32
forall a. Bits a => a -> Int -> a
`shiftL` Int
15 Int32 -> Int32 -> Int32
forall a. Bits a => a -> a -> a
.|. Int32
b' Int32 -> Int -> Int32
forall a. Bits a => a -> Int -> a
`shiftR` Int
1,
		Int32
a' Int32 -> Int -> Int32
forall a. Bits a => a -> Int -> a
`shiftL` Int
15 Int32 -> Int32 -> Int32
forall a. Bits a => a -> a -> a
.|. Int32
a' Int32 -> Int -> Int32
forall a. Bits a => a -> Int -> a
`shiftR` Int
1 )
		where [Int32
r', Int32
g', Int32
b', Int32
a'] =
			Word16 -> Int32
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word16 -> Int32) -> [Word16] -> [Int32]
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'] =
			d -> Int32
forall d. RealFrac d => d -> Int32
cDoubleToInt32 (d -> Int32) -> [d] -> [Int32]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (d, d, d, d) -> [d]
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) -> (Void# -> r) -> r
RgbaDouble r g b a <- (fromRgbaDouble -> (r, g, b, a))

fromRgbaDouble :: (Eq d, Fractional d) => Rgba d -> (d, d, d, d)
fromRgbaDouble :: 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'] = Word8 -> d
forall d. Fractional d => Word8 -> d
word8ToCDouble (Word8 -> d) -> [Word8] -> [d]
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'] = Word16 -> d
forall d. Fractional d => Word16 -> d
word16ToCDouble (Word16 -> d) -> [Word16] -> [d]
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'] = Word32 -> d
forall d. Fractional d => Word32 -> d
word32ToCDouble (Word32 -> d) -> [Word32] -> [d]
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'] = Int32 -> d
forall d. Fractional d => Int32 -> d
int32ToCDouble (Int32 -> d) -> [Int32] -> [d]
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'] =
			Word8 -> d
forall d. Fractional d => Word8 -> d
word8ToCDouble (Word8 -> d) -> [Word8] -> [d]
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'] =
			Word16 -> d
forall d. Fractional d => Word16 -> d
word16ToCDouble (Word16 -> d) -> [Word16] -> [d]
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'] = (d, d, d, d) -> [d]
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 :: d -> d -> d -> d -> Maybe (Rgba d)
rgbaDouble d
r d
g d
b d
a
	| d -> Bool
forall d. (Ord d, Num d) => d -> Bool
from0to1 d
r Bool -> Bool -> Bool
&& d -> Bool
forall d. (Ord d, Num d) => d -> Bool
from0to1 d
g Bool -> Bool -> Bool
&& d -> Bool
forall d. (Ord d, Num d) => d -> Bool
from0to1 d
b Bool -> Bool -> Bool
&& d -> Bool
forall d. (Ord d, Num d) => d -> Bool
from0to1 d
a =
		Rgba d -> Maybe (Rgba d)
forall a. a -> Maybe a
Just (Rgba d -> Maybe (Rgba d)) -> Rgba d -> Maybe (Rgba d)
forall a b. (a -> b) -> a -> b
$ d -> d -> d -> d -> Rgba d
forall d. d -> d -> d -> d -> Rgba d
RgbaDouble_ d
r d
g d
b d
a
	| Bool
otherwise = Maybe (Rgba d)
forall a. Maybe a
Nothing

fromRgba :: (Eq d, Fractional d) => Rgba d -> (Rgb d, Alpha d)
fromRgba :: Rgba d -> (Rgb d, Alpha d)
fromRgba = \case
	RgbaWord8_ Word8
r Word8
g Word8
b Word8
a -> (Word8 -> Word8 -> Word8 -> Rgb d
forall d. Word8 -> Word8 -> Word8 -> Rgb d
RgbWord8_ Word8
r Word8
g Word8
b, Word8 -> Alpha d
forall d. Word8 -> Alpha d
AlphaWord8_ Word8
a)
	RgbaWord16_ Word16
r Word16
g Word16
b Word16
a -> (Word16 -> Word16 -> Word16 -> Rgb d
forall d. Word16 -> Word16 -> Word16 -> Rgb d
RgbWord16_ Word16
r Word16
g Word16
b, Word16 -> Alpha d
forall d. Word16 -> Alpha d
AlphaWord16_ Word16
a)
	RgbaWord32_ Word32
r Word32
g Word32
b Word32
a -> (Word32 -> Word32 -> Word32 -> Rgb d
forall d. Word32 -> Word32 -> Word32 -> Rgb d
RgbWord32_ Word32
r Word32
g Word32
b, Word32 -> Alpha d
forall d. Word32 -> Alpha d
AlphaWord32_ Word32
a)
	RgbaInt32_ Int32
r Int32
g Int32
b Int32
a -> (Int32 -> Int32 -> Int32 -> Rgb d
forall d. Int32 -> Int32 -> Int32 -> Rgb d
RgbInt32_ Int32
r Int32
g Int32
b, Int32 -> Alpha d
forall d. Int32 -> Alpha d
AlphaInt32_ Int32
a)
	RgbaDouble_ d
r d
g d
b d
a -> (d -> d -> d -> Rgb d
forall d. d -> d -> d -> Rgb d
RgbDouble_ d
r d
g d
b, d -> Alpha d
forall d. d -> Alpha d
AlphaDouble_ d
a)
	RgbaPremultipliedWord8_ Word8
r Word8
g Word8
b Word8
a -> (Word8 -> Word8 -> Word8 -> Rgb d
forall d. Word8 -> Word8 -> Word8 -> Rgb d
RgbWord8_ Word8
r' Word8
g' Word8
b', Word8 -> Alpha d
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 -> (Word16 -> Word16 -> Word16 -> Rgb d
forall d. Word16 -> Word16 -> Word16 -> Rgb d
RgbWord16_ Word16
r' Word16
g' Word16
b', Word16 -> Alpha d
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 -> (d -> d -> d -> Rgb d
forall d. d -> d -> d -> Rgb d
RgbDouble_ d
r' d
g' d
b', d -> Alpha d
forall d. d -> Alpha d
AlphaDouble_ d
a')
		where [d
r', d
g', d
b', d
a'] = (d, d, d, d) -> [d]
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 :: Rgb d -> Alpha d -> Rgba d
toRgba (RgbWord8_ Word8
r Word8
g Word8
b) (AlphaWord8 Word8
a) = Word8 -> Word8 -> Word8 -> Word8 -> Rgba d
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) = Word16 -> Word16 -> Word16 -> Word16 -> Rgba d
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) = Word32 -> Word32 -> Word32 -> Word32 -> Rgba d
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) = Int32 -> Int32 -> Int32 -> Int32 -> Rgba d
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) = d -> d -> d -> d -> Rgba d
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 :: Rgba d -> Rgba d'
rgbaRealToFrac = \case
	RgbaWord8_ Word8
r Word8
g Word8
b Word8
a -> Word8 -> Word8 -> Word8 -> Word8 -> Rgba d'
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 -> Word16 -> Word16 -> Word16 -> Word16 -> Rgba d'
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 -> Word32 -> Word32 -> Word32 -> Word32 -> Rgba d'
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 -> Int32 -> Int32 -> Int32 -> Int32 -> Rgba d'
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 -> d' -> d' -> d' -> d' -> Rgba d'
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'] = d -> d'
forall a b. (Real a, Fractional b) => a -> b
realToFrac (d -> d') -> [d] -> [d']
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 -> Word8 -> Word8 -> Word8 -> Rgba d'
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 -> Word16 -> Word16 -> Word16 -> Word16 -> Rgba d'
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 -> d' -> d' -> d' -> d' -> Rgba d'
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'] = d -> d'
forall a b. (Real a, Fractional b) => a -> b
realToFrac (d -> d') -> [d] -> [d']
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 :: d -> Word8
cDoubleToWord8 = d -> Word8
forall a b. (RealFrac a, Integral b) => a -> b
round (d -> Word8) -> (d -> d) -> d -> Word8
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (d -> d -> d
forall a. Num a => a -> a -> a
* d
0xff)

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

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

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

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

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

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

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

from0to1 :: (Ord d, Num d) => d -> Bool
from0to1 :: d -> Bool
from0to1 d
n = d
0 d -> d -> Bool
forall a. Ord a => a -> a -> Bool
<= d
n Bool -> Bool -> Bool
&& d
n d -> d -> Bool
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) -> (Void# -> r) -> r
RgbaPremultipliedWord8 r g b a <-
	(fromRgbaPremultipliedWord8 -> (r, g, b, a))

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

fromRgbaPremultipliedWord8 :: RealFrac d => Rgba d -> (Word8, Word8, Word8, Word8)
fromRgbaPremultipliedWord8 :: Rgba d -> (Word8, Word8, Word8, Word8)
fromRgbaPremultipliedWord8 = (Word8, Word8, Word8, Word8) -> (Word8, Word8, Word8, Word8)
toPremultipliedWord8 ((Word8, Word8, Word8, Word8) -> (Word8, Word8, Word8, Word8))
-> (Rgba d -> (Word8, Word8, Word8, Word8))
-> Rgba d
-> (Word8, Word8, Word8, Word8)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Rgba d -> (Word8, Word8, Word8, Word8)
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 (
	Word8 -> Word16
forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Word16
r, Word8 -> Word16
forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Word16
g,
	Word8 -> Word16
forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Word16
b, Word8 -> Word16
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'] = Word16 -> Word8
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word16 -> Word8) -> [Word16] -> [Word8]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [
		Word16
r Word16 -> Word16 -> Word16
forall a. Num a => a -> a -> a
* Word16
a Word16 -> Word16 -> Word16
forall a. Integral a => a -> a -> a
`div` Word16
0xff, Word16
g Word16 -> Word16 -> Word16
forall a. Num a => a -> a -> a
* Word16
a Word16 -> Word16 -> Word16
forall a. Integral a => a -> a -> a
`div` Word16
0xff, Word16
b Word16 -> Word16 -> Word16
forall a. Num a => a -> a -> a
* Word16
a Word16 -> Word16 -> Word16
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 (
	Word8 -> Word16
forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Word16
r, Word8 -> Word16
forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Word16
g,
	Word8 -> Word16
forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Word16
b, Word8 -> Word16
forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Word16
a ) = Word16 -> Word8
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word16 -> Word8) -> [Word16] -> [Word8]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [
		Word16
r Word16 -> Word16 -> Word16
forall a. Num a => a -> a -> a
* Word16
0xff Word16 -> Word16 -> Word16
forall a. Integral a => a -> a -> a
`div'` Word16
a, Word16
g Word16 -> Word16 -> Word16
forall a. Num a => a -> a -> a
* Word16
0xff Word16 -> Word16 -> Word16
forall a. Integral a => a -> a -> a
`div'` Word16
a, Word16
b Word16 -> Word16 -> Word16
forall a. Num a => a -> a -> a
* Word16
0xff Word16 -> Word16 -> Word16
forall a. Integral a => a -> a -> a
`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) -> (Void# -> r) -> r
RgbaPremultipliedWord16 r g b a <-
	(fromRgbaPremultipliedWord16 -> (r, g, b, a))

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

fromRgbaPremultipliedWord16 ::
	RealFrac d => Rgba d -> (Word16, Word16, Word16, Word16)
fromRgbaPremultipliedWord16 :: Rgba d -> (Word16, Word16, Word16, Word16)
fromRgbaPremultipliedWord16 = (Word16, Word16, Word16, Word16)
-> (Word16, Word16, Word16, Word16)
toPremultipliedWord16 ((Word16, Word16, Word16, Word16)
 -> (Word16, Word16, Word16, Word16))
-> (Rgba d -> (Word16, Word16, Word16, Word16))
-> Rgba d
-> (Word16, Word16, Word16, Word16)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Rgba d -> (Word16, Word16, Word16, Word16)
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 (
	Word16 -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Word32
r, Word16 -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Word32
g,
	Word16 -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Word32
b, Word16 -> Word32
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'] = Word32 -> Word16
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word32 -> Word16) -> [Word32] -> [Word16]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [
		Word32
r Word32 -> Word32 -> Word32
forall a. Num a => a -> a -> a
* Word32
a Word32 -> Word32 -> Word32
forall a. Integral a => a -> a -> a
`div` Word32
0xffff, Word32
g Word32 -> Word32 -> Word32
forall a. Num a => a -> a -> a
* Word32
a Word32 -> Word32 -> Word32
forall a. Integral a => a -> a -> a
`div` Word32
0xffff, Word32
b Word32 -> Word32 -> Word32
forall a. Num a => a -> a -> a
* Word32
a Word32 -> Word32 -> Word32
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 (
	Word16 -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Word32
r, Word16 -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Word32
g,
	Word16 -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Word32
b, Word16 -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral -> Word32
a ) = Word32 -> Word16
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word32 -> Word16) -> [Word32] -> [Word16]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [
		Word32
r Word32 -> Word32 -> Word32
forall a. Num a => a -> a -> a
* Word32
0xffff Word32 -> Word32 -> Word32
forall a. Integral a => a -> a -> a
`div'` Word32
a, Word32
g Word32 -> Word32 -> Word32
forall a. Num a => a -> a -> a
* Word32
0xffff Word32 -> Word32 -> Word32
forall a. Integral a => a -> a -> a
`div'` Word32
a, Word32
b Word32 -> Word32 -> Word32
forall a. Num a => a -> a -> a
* Word32
0xff Word32 -> Word32 -> Word32
forall a. Integral a => a -> a -> a
`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) -> (Void# -> 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 :: d -> d -> d -> d -> Maybe (Rgba d)
rgbaPremultipliedDouble d
r d
g d
b d
a
	| d
0 d -> d -> Bool
forall a. Ord a => a -> a -> Bool
<= d
r Bool -> Bool -> Bool
&& d
r d -> d -> Bool
forall a. Ord a => a -> a -> Bool
<= d
a, d
0 d -> d -> Bool
forall a. Ord a => a -> a -> Bool
<= d
g Bool -> Bool -> Bool
&& d
g d -> d -> Bool
forall a. Ord a => a -> a -> Bool
<= d
a, d
0 d -> d -> Bool
forall a. Ord a => a -> a -> Bool
<= d
b Bool -> Bool -> Bool
&& d
b d -> d -> Bool
forall a. Ord a => a -> a -> Bool
<= d
a,
		d
0 d -> d -> Bool
forall a. Ord a => a -> a -> Bool
<= d
a Bool -> Bool -> Bool
&& d
a d -> d -> Bool
forall a. Ord a => a -> a -> Bool
<= d
1 = Rgba d -> Maybe (Rgba d)
forall a. a -> Maybe a
Just (Rgba d -> Maybe (Rgba d)) -> Rgba d -> Maybe (Rgba d)
forall a b. (a -> b) -> a -> b
$ d -> d -> d -> d -> Rgba d
forall d. d -> d -> d -> d -> Rgba d
RgbaPremultipliedDouble_ d
r d
g d
b d
a
	| Bool
otherwise = Maybe (Rgba d)
forall a. Maybe a
Nothing

fromRgbaPremultipliedDouble :: (Eq d, Fractional d) => Rgba d -> (d, d, d, d)
fromRgbaPremultipliedDouble :: Rgba d -> (d, d, d, d)
fromRgbaPremultipliedDouble = (d, d, d, d) -> (d, d, d, d)
forall d. Fractional d => (d, d, d, d) -> (d, d, d, d)
toPremultipliedDouble ((d, d, d, d) -> (d, d, d, d))
-> (Rgba d -> (d, d, d, d)) -> Rgba d -> (d, d, d, d)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Rgba d -> (d, d, d, d)
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 :: (d, d, d, d) -> (d, d, d, d)
toPremultipliedDouble (d
r, d
g, d
b, d
a) = (d
r d -> d -> d
forall a. Num a => a -> a -> a
* d
a, d
g d -> d -> d
forall a. Num a => a -> a -> a
* d
a, d
b d -> d -> d
forall a. Num a => a -> a -> a
* d
a, d
a)

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

div' :: Integral n => n -> n -> n
n
0 div' :: n -> n -> n
`div'` n
0 = n
0
n
a `div'` n
b = n
a n -> n -> n
forall a. Integral a => a -> a -> a
`div` n
b

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