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

module Data.Color.Internal (
	-- * Alpha
	Alpha(..), pattern AlphaWord8, pattern AlphaWord16, pattern AlphaDouble,
	alphaDouble, alphaRealToFrac,
	-- * RGB
	Rgb(..), pattern RgbWord8, pattern RgbWord16, pattern RgbDouble,
	rgbDouble, rgbRealToFrac,
	-- * RGBA
	-- ** Straight
	Rgba(..), pattern RgbaWord8, pattern RgbaWord16, 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.Word

data Alpha d = AlphaWord8_ Word8 | AlphaWord16_ Word16 | 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
	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
	AlphaDouble_ d
a -> d -> Word16
forall d. RealFrac d => d -> Word16
cDoubleToWord16 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
	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
	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
	| 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 )
	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)
	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 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')
	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
	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
	| 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 )
	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)
	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 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]
	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)
	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 (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
	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)

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

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