{-# LANGUAGE LambdaCase, ViewPatterns #-}
{-# LANGUAGE PatternSynonyms #-}
{-# OPTIONS_GHC -Wall -fno-warn-tabs #-}
module Data.Color.Internal (
Alpha(..), pattern AlphaWord8, pattern AlphaWord16, pattern AlphaWord32,
pattern AlphaInt32, alphaInt32,
pattern AlphaDouble, alphaDouble, alphaRealToFrac,
Rgb(..), pattern RgbWord8, pattern RgbWord16, pattern RgbWord32,
pattern RgbInt32, rgbInt32,
pattern RgbDouble, rgbDouble, rgbRealToFrac,
Rgba(..), pattern RgbaWord8, pattern RgbaWord16, pattern RgbaWord32,
pattern RgbaInt32, rgbaInt32,
pattern RgbaDouble, rgbaDouble,
pattern RgbaPremultipliedWord8, rgbaPremultipliedWord8,
pattern RgbaPremultipliedWord16, rgbaPremultipliedWord16,
pattern RgbaPremultipliedDouble, rgbaPremultipliedDouble,
toRgba, fromRgba,
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