{-# LANGUAGE DeriveDataTypeable, CPP #-}
{-# OPTIONS_HADDOCK hide #-}
--------------------------------------------------------------------------------
-- |
-- Module      :  Graphics.Rendering.OpenGL.GL.VertexAttributes
-- Copyright   :  (c) Sven Panne 2002-2019
-- License     :  BSD3
-- 
-- Maintainer  :  Sven Panne <svenpanne@gmail.com>
-- Stability   :  stable
-- Portability :  portable
--
-- This is a purely internal module for auxiliary vertex attributes.
--
--------------------------------------------------------------------------------

module Graphics.Rendering.OpenGL.GL.VertexAttributes (
   TexCoord1(..), TexCoord2(..), TexCoord3(..), TexCoord4(..),
   Normal3(..),
   FogCoord1(..),
   Color3(..), Color4(..),
   Index1(..)
) where

#if !MIN_VERSION_base(4,8,0)
import Control.Applicative ( Applicative(..) )
#endif
import Control.Monad
import Data.Foldable
import Data.Ix
import Data.Traversable
import Data.Typeable
import Foreign.Marshal.Array
import Foreign.Ptr
import Foreign.Storable

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

-- | Texture coordinates with /t/=0, /r/=0, and /q/=1.
newtype TexCoord1 a = TexCoord1 a
   deriving (TexCoord1 a -> TexCoord1 a -> Bool
(TexCoord1 a -> TexCoord1 a -> Bool)
-> (TexCoord1 a -> TexCoord1 a -> Bool) -> Eq (TexCoord1 a)
forall a. Eq a => TexCoord1 a -> TexCoord1 a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TexCoord1 a -> TexCoord1 a -> Bool
$c/= :: forall a. Eq a => TexCoord1 a -> TexCoord1 a -> Bool
== :: TexCoord1 a -> TexCoord1 a -> Bool
$c== :: forall a. Eq a => TexCoord1 a -> TexCoord1 a -> Bool
Eq, Eq (TexCoord1 a)
Eq (TexCoord1 a) =>
(TexCoord1 a -> TexCoord1 a -> Ordering)
-> (TexCoord1 a -> TexCoord1 a -> Bool)
-> (TexCoord1 a -> TexCoord1 a -> Bool)
-> (TexCoord1 a -> TexCoord1 a -> Bool)
-> (TexCoord1 a -> TexCoord1 a -> Bool)
-> (TexCoord1 a -> TexCoord1 a -> TexCoord1 a)
-> (TexCoord1 a -> TexCoord1 a -> TexCoord1 a)
-> Ord (TexCoord1 a)
TexCoord1 a -> TexCoord1 a -> Bool
TexCoord1 a -> TexCoord1 a -> Ordering
TexCoord1 a -> TexCoord1 a -> TexCoord1 a
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall a. Ord a => Eq (TexCoord1 a)
forall a. Ord a => TexCoord1 a -> TexCoord1 a -> Bool
forall a. Ord a => TexCoord1 a -> TexCoord1 a -> Ordering
forall a. Ord a => TexCoord1 a -> TexCoord1 a -> TexCoord1 a
min :: TexCoord1 a -> TexCoord1 a -> TexCoord1 a
$cmin :: forall a. Ord a => TexCoord1 a -> TexCoord1 a -> TexCoord1 a
max :: TexCoord1 a -> TexCoord1 a -> TexCoord1 a
$cmax :: forall a. Ord a => TexCoord1 a -> TexCoord1 a -> TexCoord1 a
>= :: TexCoord1 a -> TexCoord1 a -> Bool
$c>= :: forall a. Ord a => TexCoord1 a -> TexCoord1 a -> Bool
> :: TexCoord1 a -> TexCoord1 a -> Bool
$c> :: forall a. Ord a => TexCoord1 a -> TexCoord1 a -> Bool
<= :: TexCoord1 a -> TexCoord1 a -> Bool
$c<= :: forall a. Ord a => TexCoord1 a -> TexCoord1 a -> Bool
< :: TexCoord1 a -> TexCoord1 a -> Bool
$c< :: forall a. Ord a => TexCoord1 a -> TexCoord1 a -> Bool
compare :: TexCoord1 a -> TexCoord1 a -> Ordering
$ccompare :: forall a. Ord a => TexCoord1 a -> TexCoord1 a -> Ordering
$cp1Ord :: forall a. Ord a => Eq (TexCoord1 a)
Ord, Ord (TexCoord1 a)
Ord (TexCoord1 a) =>
((TexCoord1 a, TexCoord1 a) -> [TexCoord1 a])
-> ((TexCoord1 a, TexCoord1 a) -> TexCoord1 a -> Int)
-> ((TexCoord1 a, TexCoord1 a) -> TexCoord1 a -> Int)
-> ((TexCoord1 a, TexCoord1 a) -> TexCoord1 a -> Bool)
-> ((TexCoord1 a, TexCoord1 a) -> Int)
-> ((TexCoord1 a, TexCoord1 a) -> Int)
-> Ix (TexCoord1 a)
(TexCoord1 a, TexCoord1 a) -> Int
(TexCoord1 a, TexCoord1 a) -> [TexCoord1 a]
(TexCoord1 a, TexCoord1 a) -> TexCoord1 a -> Bool
(TexCoord1 a, TexCoord1 a) -> TexCoord1 a -> Int
forall a.
Ord a =>
((a, a) -> [a])
-> ((a, a) -> a -> Int)
-> ((a, a) -> a -> Int)
-> ((a, a) -> a -> Bool)
-> ((a, a) -> Int)
-> ((a, a) -> Int)
-> Ix a
forall a. Ix a => Ord (TexCoord1 a)
forall a. Ix a => (TexCoord1 a, TexCoord1 a) -> Int
forall a. Ix a => (TexCoord1 a, TexCoord1 a) -> [TexCoord1 a]
forall a. Ix a => (TexCoord1 a, TexCoord1 a) -> TexCoord1 a -> Bool
forall a. Ix a => (TexCoord1 a, TexCoord1 a) -> TexCoord1 a -> Int
unsafeRangeSize :: (TexCoord1 a, TexCoord1 a) -> Int
$cunsafeRangeSize :: forall a. Ix a => (TexCoord1 a, TexCoord1 a) -> Int
rangeSize :: (TexCoord1 a, TexCoord1 a) -> Int
$crangeSize :: forall a. Ix a => (TexCoord1 a, TexCoord1 a) -> Int
inRange :: (TexCoord1 a, TexCoord1 a) -> TexCoord1 a -> Bool
$cinRange :: forall a. Ix a => (TexCoord1 a, TexCoord1 a) -> TexCoord1 a -> Bool
unsafeIndex :: (TexCoord1 a, TexCoord1 a) -> TexCoord1 a -> Int
$cunsafeIndex :: forall a. Ix a => (TexCoord1 a, TexCoord1 a) -> TexCoord1 a -> Int
index :: (TexCoord1 a, TexCoord1 a) -> TexCoord1 a -> Int
$cindex :: forall a. Ix a => (TexCoord1 a, TexCoord1 a) -> TexCoord1 a -> Int
range :: (TexCoord1 a, TexCoord1 a) -> [TexCoord1 a]
$crange :: forall a. Ix a => (TexCoord1 a, TexCoord1 a) -> [TexCoord1 a]
$cp1Ix :: forall a. Ix a => Ord (TexCoord1 a)
Ix, TexCoord1 a
TexCoord1 a -> TexCoord1 a -> Bounded (TexCoord1 a)
forall a. a -> a -> Bounded a
forall a. Bounded a => TexCoord1 a
maxBound :: TexCoord1 a
$cmaxBound :: forall a. Bounded a => TexCoord1 a
minBound :: TexCoord1 a
$cminBound :: forall a. Bounded a => TexCoord1 a
Bounded, Int -> TexCoord1 a -> ShowS
[TexCoord1 a] -> ShowS
TexCoord1 a -> String
(Int -> TexCoord1 a -> ShowS)
-> (TexCoord1 a -> String)
-> ([TexCoord1 a] -> ShowS)
-> Show (TexCoord1 a)
forall a. Show a => Int -> TexCoord1 a -> ShowS
forall a. Show a => [TexCoord1 a] -> ShowS
forall a. Show a => TexCoord1 a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TexCoord1 a] -> ShowS
$cshowList :: forall a. Show a => [TexCoord1 a] -> ShowS
show :: TexCoord1 a -> String
$cshow :: forall a. Show a => TexCoord1 a -> String
showsPrec :: Int -> TexCoord1 a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> TexCoord1 a -> ShowS
Show, ReadPrec [TexCoord1 a]
ReadPrec (TexCoord1 a)
Int -> ReadS (TexCoord1 a)
ReadS [TexCoord1 a]
(Int -> ReadS (TexCoord1 a))
-> ReadS [TexCoord1 a]
-> ReadPrec (TexCoord1 a)
-> ReadPrec [TexCoord1 a]
-> Read (TexCoord1 a)
forall a. Read a => ReadPrec [TexCoord1 a]
forall a. Read a => ReadPrec (TexCoord1 a)
forall a. Read a => Int -> ReadS (TexCoord1 a)
forall a. Read a => ReadS [TexCoord1 a]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [TexCoord1 a]
$creadListPrec :: forall a. Read a => ReadPrec [TexCoord1 a]
readPrec :: ReadPrec (TexCoord1 a)
$creadPrec :: forall a. Read a => ReadPrec (TexCoord1 a)
readList :: ReadS [TexCoord1 a]
$creadList :: forall a. Read a => ReadS [TexCoord1 a]
readsPrec :: Int -> ReadS (TexCoord1 a)
$creadsPrec :: forall a. Read a => Int -> ReadS (TexCoord1 a)
Read, Typeable)

instance Functor TexCoord1 where
   fmap :: (a -> b) -> TexCoord1 a -> TexCoord1 b
fmap f :: a -> b
f (TexCoord1 x :: a
x) = b -> TexCoord1 b
forall a. a -> TexCoord1 a
TexCoord1 (a -> b
f a
x)

instance Applicative TexCoord1 where
   pure :: a -> TexCoord1 a
pure a :: a
a = a -> TexCoord1 a
forall a. a -> TexCoord1 a
TexCoord1 a
a
   TexCoord1 f :: a -> b
f <*> :: TexCoord1 (a -> b) -> TexCoord1 a -> TexCoord1 b
<*> TexCoord1 x :: a
x = b -> TexCoord1 b
forall a. a -> TexCoord1 a
TexCoord1 (a -> b
f a
x)

instance Foldable TexCoord1 where
   foldr :: (a -> b -> b) -> b -> TexCoord1 a -> b
foldr f :: a -> b -> b
f a :: b
a (TexCoord1 x :: a
x) = a
x `f ` b
a
   foldl :: (b -> a -> b) -> b -> TexCoord1 a -> b
foldl f :: b -> a -> b
f a :: b
a (TexCoord1 x :: a
x) = b
a b -> a -> b
`f` a
x
   foldr1 :: (a -> a -> a) -> TexCoord1 a -> a
foldr1 _ (TexCoord1 x :: a
x) = a
x
   foldl1 :: (a -> a -> a) -> TexCoord1 a -> a
foldl1 _ (TexCoord1 x :: a
x) = a
x

instance Traversable TexCoord1 where
   traverse :: (a -> f b) -> TexCoord1 a -> f (TexCoord1 b)
traverse f :: a -> f b
f (TexCoord1 x :: a
x) = (b -> TexCoord1 b) -> f (b -> TexCoord1 b)
forall (f :: * -> *) a. Applicative f => a -> f a
pure b -> TexCoord1 b
forall a. a -> TexCoord1 a
TexCoord1 f (b -> TexCoord1 b) -> f b -> f (TexCoord1 b)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a -> f b
f a
x
   sequenceA :: TexCoord1 (f a) -> f (TexCoord1 a)
sequenceA (TexCoord1 x :: f a
x) =  (a -> TexCoord1 a) -> f (a -> TexCoord1 a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure a -> TexCoord1 a
forall a. a -> TexCoord1 a
TexCoord1 f (a -> TexCoord1 a) -> f a -> f (TexCoord1 a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> f a
x
   mapM :: (a -> m b) -> TexCoord1 a -> m (TexCoord1 b)
mapM f :: a -> m b
f (TexCoord1 x :: a
x) = (b -> TexCoord1 b) -> m (b -> TexCoord1 b)
forall (m :: * -> *) a. Monad m => a -> m a
return b -> TexCoord1 b
forall a. a -> TexCoord1 a
TexCoord1 m (b -> TexCoord1 b) -> m b -> m (TexCoord1 b)
forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
`ap` a -> m b
f a
x
   sequence :: TexCoord1 (m a) -> m (TexCoord1 a)
sequence (TexCoord1 x :: m a
x) = (a -> TexCoord1 a) -> m (a -> TexCoord1 a)
forall (m :: * -> *) a. Monad m => a -> m a
return a -> TexCoord1 a
forall a. a -> TexCoord1 a
TexCoord1 m (a -> TexCoord1 a) -> m a -> m (TexCoord1 a)
forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
`ap` m a
x

instance Storable a => Storable (TexCoord1 a) where
   sizeOf :: TexCoord1 a -> Int
sizeOf    ~(TexCoord1 s :: a
s) = a -> Int
forall a. Storable a => a -> Int
sizeOf a
s
   alignment :: TexCoord1 a -> Int
alignment ~(TexCoord1 s :: a
s) = a -> Int
forall a. Storable a => a -> Int
alignment a
s
   peek :: Ptr (TexCoord1 a) -> IO (TexCoord1 a)
peek = Ptr (TexCoord1 a) -> IO (TexCoord1 a)
forall (t :: * -> *) a.
(Applicative t, Traversable t, Storable a) =>
Ptr (t a) -> IO (t a)
peekApplicativeTraversable
   poke :: Ptr (TexCoord1 a) -> TexCoord1 a -> IO ()
poke = Ptr (TexCoord1 a) -> TexCoord1 a -> IO ()
forall (t :: * -> *) a.
(Foldable t, Storable a) =>
Ptr (t a) -> t a -> IO ()
pokeFoldable

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

-- | Texture coordinates with /r/=0 and /q/=1.
data TexCoord2 a = TexCoord2 !a !a
   deriving (TexCoord2 a -> TexCoord2 a -> Bool
(TexCoord2 a -> TexCoord2 a -> Bool)
-> (TexCoord2 a -> TexCoord2 a -> Bool) -> Eq (TexCoord2 a)
forall a. Eq a => TexCoord2 a -> TexCoord2 a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TexCoord2 a -> TexCoord2 a -> Bool
$c/= :: forall a. Eq a => TexCoord2 a -> TexCoord2 a -> Bool
== :: TexCoord2 a -> TexCoord2 a -> Bool
$c== :: forall a. Eq a => TexCoord2 a -> TexCoord2 a -> Bool
Eq, Eq (TexCoord2 a)
Eq (TexCoord2 a) =>
(TexCoord2 a -> TexCoord2 a -> Ordering)
-> (TexCoord2 a -> TexCoord2 a -> Bool)
-> (TexCoord2 a -> TexCoord2 a -> Bool)
-> (TexCoord2 a -> TexCoord2 a -> Bool)
-> (TexCoord2 a -> TexCoord2 a -> Bool)
-> (TexCoord2 a -> TexCoord2 a -> TexCoord2 a)
-> (TexCoord2 a -> TexCoord2 a -> TexCoord2 a)
-> Ord (TexCoord2 a)
TexCoord2 a -> TexCoord2 a -> Bool
TexCoord2 a -> TexCoord2 a -> Ordering
TexCoord2 a -> TexCoord2 a -> TexCoord2 a
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall a. Ord a => Eq (TexCoord2 a)
forall a. Ord a => TexCoord2 a -> TexCoord2 a -> Bool
forall a. Ord a => TexCoord2 a -> TexCoord2 a -> Ordering
forall a. Ord a => TexCoord2 a -> TexCoord2 a -> TexCoord2 a
min :: TexCoord2 a -> TexCoord2 a -> TexCoord2 a
$cmin :: forall a. Ord a => TexCoord2 a -> TexCoord2 a -> TexCoord2 a
max :: TexCoord2 a -> TexCoord2 a -> TexCoord2 a
$cmax :: forall a. Ord a => TexCoord2 a -> TexCoord2 a -> TexCoord2 a
>= :: TexCoord2 a -> TexCoord2 a -> Bool
$c>= :: forall a. Ord a => TexCoord2 a -> TexCoord2 a -> Bool
> :: TexCoord2 a -> TexCoord2 a -> Bool
$c> :: forall a. Ord a => TexCoord2 a -> TexCoord2 a -> Bool
<= :: TexCoord2 a -> TexCoord2 a -> Bool
$c<= :: forall a. Ord a => TexCoord2 a -> TexCoord2 a -> Bool
< :: TexCoord2 a -> TexCoord2 a -> Bool
$c< :: forall a. Ord a => TexCoord2 a -> TexCoord2 a -> Bool
compare :: TexCoord2 a -> TexCoord2 a -> Ordering
$ccompare :: forall a. Ord a => TexCoord2 a -> TexCoord2 a -> Ordering
$cp1Ord :: forall a. Ord a => Eq (TexCoord2 a)
Ord, Ord (TexCoord2 a)
Ord (TexCoord2 a) =>
((TexCoord2 a, TexCoord2 a) -> [TexCoord2 a])
-> ((TexCoord2 a, TexCoord2 a) -> TexCoord2 a -> Int)
-> ((TexCoord2 a, TexCoord2 a) -> TexCoord2 a -> Int)
-> ((TexCoord2 a, TexCoord2 a) -> TexCoord2 a -> Bool)
-> ((TexCoord2 a, TexCoord2 a) -> Int)
-> ((TexCoord2 a, TexCoord2 a) -> Int)
-> Ix (TexCoord2 a)
(TexCoord2 a, TexCoord2 a) -> Int
(TexCoord2 a, TexCoord2 a) -> [TexCoord2 a]
(TexCoord2 a, TexCoord2 a) -> TexCoord2 a -> Bool
(TexCoord2 a, TexCoord2 a) -> TexCoord2 a -> Int
forall a.
Ord a =>
((a, a) -> [a])
-> ((a, a) -> a -> Int)
-> ((a, a) -> a -> Int)
-> ((a, a) -> a -> Bool)
-> ((a, a) -> Int)
-> ((a, a) -> Int)
-> Ix a
forall a. Ix a => Ord (TexCoord2 a)
forall a. Ix a => (TexCoord2 a, TexCoord2 a) -> Int
forall a. Ix a => (TexCoord2 a, TexCoord2 a) -> [TexCoord2 a]
forall a. Ix a => (TexCoord2 a, TexCoord2 a) -> TexCoord2 a -> Bool
forall a. Ix a => (TexCoord2 a, TexCoord2 a) -> TexCoord2 a -> Int
unsafeRangeSize :: (TexCoord2 a, TexCoord2 a) -> Int
$cunsafeRangeSize :: forall a. Ix a => (TexCoord2 a, TexCoord2 a) -> Int
rangeSize :: (TexCoord2 a, TexCoord2 a) -> Int
$crangeSize :: forall a. Ix a => (TexCoord2 a, TexCoord2 a) -> Int
inRange :: (TexCoord2 a, TexCoord2 a) -> TexCoord2 a -> Bool
$cinRange :: forall a. Ix a => (TexCoord2 a, TexCoord2 a) -> TexCoord2 a -> Bool
unsafeIndex :: (TexCoord2 a, TexCoord2 a) -> TexCoord2 a -> Int
$cunsafeIndex :: forall a. Ix a => (TexCoord2 a, TexCoord2 a) -> TexCoord2 a -> Int
index :: (TexCoord2 a, TexCoord2 a) -> TexCoord2 a -> Int
$cindex :: forall a. Ix a => (TexCoord2 a, TexCoord2 a) -> TexCoord2 a -> Int
range :: (TexCoord2 a, TexCoord2 a) -> [TexCoord2 a]
$crange :: forall a. Ix a => (TexCoord2 a, TexCoord2 a) -> [TexCoord2 a]
$cp1Ix :: forall a. Ix a => Ord (TexCoord2 a)
Ix, TexCoord2 a
TexCoord2 a -> TexCoord2 a -> Bounded (TexCoord2 a)
forall a. a -> a -> Bounded a
forall a. Bounded a => TexCoord2 a
maxBound :: TexCoord2 a
$cmaxBound :: forall a. Bounded a => TexCoord2 a
minBound :: TexCoord2 a
$cminBound :: forall a. Bounded a => TexCoord2 a
Bounded, Int -> TexCoord2 a -> ShowS
[TexCoord2 a] -> ShowS
TexCoord2 a -> String
(Int -> TexCoord2 a -> ShowS)
-> (TexCoord2 a -> String)
-> ([TexCoord2 a] -> ShowS)
-> Show (TexCoord2 a)
forall a. Show a => Int -> TexCoord2 a -> ShowS
forall a. Show a => [TexCoord2 a] -> ShowS
forall a. Show a => TexCoord2 a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TexCoord2 a] -> ShowS
$cshowList :: forall a. Show a => [TexCoord2 a] -> ShowS
show :: TexCoord2 a -> String
$cshow :: forall a. Show a => TexCoord2 a -> String
showsPrec :: Int -> TexCoord2 a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> TexCoord2 a -> ShowS
Show, ReadPrec [TexCoord2 a]
ReadPrec (TexCoord2 a)
Int -> ReadS (TexCoord2 a)
ReadS [TexCoord2 a]
(Int -> ReadS (TexCoord2 a))
-> ReadS [TexCoord2 a]
-> ReadPrec (TexCoord2 a)
-> ReadPrec [TexCoord2 a]
-> Read (TexCoord2 a)
forall a. Read a => ReadPrec [TexCoord2 a]
forall a. Read a => ReadPrec (TexCoord2 a)
forall a. Read a => Int -> ReadS (TexCoord2 a)
forall a. Read a => ReadS [TexCoord2 a]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [TexCoord2 a]
$creadListPrec :: forall a. Read a => ReadPrec [TexCoord2 a]
readPrec :: ReadPrec (TexCoord2 a)
$creadPrec :: forall a. Read a => ReadPrec (TexCoord2 a)
readList :: ReadS [TexCoord2 a]
$creadList :: forall a. Read a => ReadS [TexCoord2 a]
readsPrec :: Int -> ReadS (TexCoord2 a)
$creadsPrec :: forall a. Read a => Int -> ReadS (TexCoord2 a)
Read, Typeable)

instance Functor TexCoord2 where
   fmap :: (a -> b) -> TexCoord2 a -> TexCoord2 b
fmap f :: a -> b
f (TexCoord2 x :: a
x y :: a
y) = b -> b -> TexCoord2 b
forall a. a -> a -> TexCoord2 a
TexCoord2 (a -> b
f a
x) (a -> b
f a
y)

instance Applicative TexCoord2 where
   pure :: a -> TexCoord2 a
pure a :: a
a = a -> a -> TexCoord2 a
forall a. a -> a -> TexCoord2 a
TexCoord2 a
a a
a
   TexCoord2 f :: a -> b
f g :: a -> b
g <*> :: TexCoord2 (a -> b) -> TexCoord2 a -> TexCoord2 b
<*> TexCoord2 x :: a
x y :: a
y = b -> b -> TexCoord2 b
forall a. a -> a -> TexCoord2 a
TexCoord2 (a -> b
f a
x) (a -> b
g a
y)

instance Foldable TexCoord2 where
   foldr :: (a -> b -> b) -> b -> TexCoord2 a -> b
foldr f :: a -> b -> b
f a :: b
a (TexCoord2 x :: a
x y :: a
y) = a
x `f ` (a
y a -> b -> b
`f` b
a)
   foldl :: (b -> a -> b) -> b -> TexCoord2 a -> b
foldl f :: b -> a -> b
f a :: b
a (TexCoord2 x :: a
x y :: a
y) = (b
a b -> a -> b
`f` a
x) b -> a -> b
`f` a
y
   foldr1 :: (a -> a -> a) -> TexCoord2 a -> a
foldr1 f :: a -> a -> a
f (TexCoord2 x :: a
x y :: a
y) = a
x a -> a -> a
`f` a
y
   foldl1 :: (a -> a -> a) -> TexCoord2 a -> a
foldl1 f :: a -> a -> a
f (TexCoord2 x :: a
x y :: a
y) = a
x a -> a -> a
`f` a
y

instance Traversable TexCoord2 where
   traverse :: (a -> f b) -> TexCoord2 a -> f (TexCoord2 b)
traverse f :: a -> f b
f (TexCoord2 x :: a
x y :: a
y) = (b -> b -> TexCoord2 b) -> f (b -> b -> TexCoord2 b)
forall (f :: * -> *) a. Applicative f => a -> f a
pure b -> b -> TexCoord2 b
forall a. a -> a -> TexCoord2 a
TexCoord2 f (b -> b -> TexCoord2 b) -> f b -> f (b -> TexCoord2 b)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a -> f b
f a
x f (b -> TexCoord2 b) -> f b -> f (TexCoord2 b)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a -> f b
f a
y
   sequenceA :: TexCoord2 (f a) -> f (TexCoord2 a)
sequenceA (TexCoord2 x :: f a
x y :: f a
y) =  (a -> a -> TexCoord2 a) -> f (a -> a -> TexCoord2 a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure a -> a -> TexCoord2 a
forall a. a -> a -> TexCoord2 a
TexCoord2 f (a -> a -> TexCoord2 a) -> f a -> f (a -> TexCoord2 a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> f a
x f (a -> TexCoord2 a) -> f a -> f (TexCoord2 a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> f a
y
   mapM :: (a -> m b) -> TexCoord2 a -> m (TexCoord2 b)
mapM f :: a -> m b
f (TexCoord2 x :: a
x y :: a
y) = (b -> b -> TexCoord2 b) -> m (b -> b -> TexCoord2 b)
forall (m :: * -> *) a. Monad m => a -> m a
return b -> b -> TexCoord2 b
forall a. a -> a -> TexCoord2 a
TexCoord2 m (b -> b -> TexCoord2 b) -> m b -> m (b -> TexCoord2 b)
forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
`ap` a -> m b
f a
x m (b -> TexCoord2 b) -> m b -> m (TexCoord2 b)
forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
`ap` a -> m b
f a
y
   sequence :: TexCoord2 (m a) -> m (TexCoord2 a)
sequence (TexCoord2 x :: m a
x y :: m a
y) = (a -> a -> TexCoord2 a) -> m (a -> a -> TexCoord2 a)
forall (m :: * -> *) a. Monad m => a -> m a
return a -> a -> TexCoord2 a
forall a. a -> a -> TexCoord2 a
TexCoord2 m (a -> a -> TexCoord2 a) -> m a -> m (a -> TexCoord2 a)
forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
`ap` m a
x m (a -> TexCoord2 a) -> m a -> m (TexCoord2 a)
forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
`ap` m a
y

instance Storable a => Storable (TexCoord2 a) where
   sizeOf :: TexCoord2 a -> Int
sizeOf ~(TexCoord2 x :: a
x _) = 2 Int -> Int -> Int
forall a. Num a => a -> a -> a
* a -> Int
forall a. Storable a => a -> Int
sizeOf a
x
   alignment :: TexCoord2 a -> Int
alignment ~(TexCoord2 x :: a
x _) = a -> Int
forall a. Storable a => a -> Int
alignment a
x
   peek :: Ptr (TexCoord2 a) -> IO (TexCoord2 a)
peek = Ptr (TexCoord2 a) -> IO (TexCoord2 a)
forall (t :: * -> *) a.
(Applicative t, Traversable t, Storable a) =>
Ptr (t a) -> IO (t a)
peekApplicativeTraversable
   poke :: Ptr (TexCoord2 a) -> TexCoord2 a -> IO ()
poke = Ptr (TexCoord2 a) -> TexCoord2 a -> IO ()
forall (t :: * -> *) a.
(Foldable t, Storable a) =>
Ptr (t a) -> t a -> IO ()
pokeFoldable

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

-- | Texture coordinates with /q/=1.
data TexCoord3 a = TexCoord3 !a !a !a
   deriving (TexCoord3 a -> TexCoord3 a -> Bool
(TexCoord3 a -> TexCoord3 a -> Bool)
-> (TexCoord3 a -> TexCoord3 a -> Bool) -> Eq (TexCoord3 a)
forall a. Eq a => TexCoord3 a -> TexCoord3 a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TexCoord3 a -> TexCoord3 a -> Bool
$c/= :: forall a. Eq a => TexCoord3 a -> TexCoord3 a -> Bool
== :: TexCoord3 a -> TexCoord3 a -> Bool
$c== :: forall a. Eq a => TexCoord3 a -> TexCoord3 a -> Bool
Eq, Eq (TexCoord3 a)
Eq (TexCoord3 a) =>
(TexCoord3 a -> TexCoord3 a -> Ordering)
-> (TexCoord3 a -> TexCoord3 a -> Bool)
-> (TexCoord3 a -> TexCoord3 a -> Bool)
-> (TexCoord3 a -> TexCoord3 a -> Bool)
-> (TexCoord3 a -> TexCoord3 a -> Bool)
-> (TexCoord3 a -> TexCoord3 a -> TexCoord3 a)
-> (TexCoord3 a -> TexCoord3 a -> TexCoord3 a)
-> Ord (TexCoord3 a)
TexCoord3 a -> TexCoord3 a -> Bool
TexCoord3 a -> TexCoord3 a -> Ordering
TexCoord3 a -> TexCoord3 a -> TexCoord3 a
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall a. Ord a => Eq (TexCoord3 a)
forall a. Ord a => TexCoord3 a -> TexCoord3 a -> Bool
forall a. Ord a => TexCoord3 a -> TexCoord3 a -> Ordering
forall a. Ord a => TexCoord3 a -> TexCoord3 a -> TexCoord3 a
min :: TexCoord3 a -> TexCoord3 a -> TexCoord3 a
$cmin :: forall a. Ord a => TexCoord3 a -> TexCoord3 a -> TexCoord3 a
max :: TexCoord3 a -> TexCoord3 a -> TexCoord3 a
$cmax :: forall a. Ord a => TexCoord3 a -> TexCoord3 a -> TexCoord3 a
>= :: TexCoord3 a -> TexCoord3 a -> Bool
$c>= :: forall a. Ord a => TexCoord3 a -> TexCoord3 a -> Bool
> :: TexCoord3 a -> TexCoord3 a -> Bool
$c> :: forall a. Ord a => TexCoord3 a -> TexCoord3 a -> Bool
<= :: TexCoord3 a -> TexCoord3 a -> Bool
$c<= :: forall a. Ord a => TexCoord3 a -> TexCoord3 a -> Bool
< :: TexCoord3 a -> TexCoord3 a -> Bool
$c< :: forall a. Ord a => TexCoord3 a -> TexCoord3 a -> Bool
compare :: TexCoord3 a -> TexCoord3 a -> Ordering
$ccompare :: forall a. Ord a => TexCoord3 a -> TexCoord3 a -> Ordering
$cp1Ord :: forall a. Ord a => Eq (TexCoord3 a)
Ord, Ord (TexCoord3 a)
Ord (TexCoord3 a) =>
((TexCoord3 a, TexCoord3 a) -> [TexCoord3 a])
-> ((TexCoord3 a, TexCoord3 a) -> TexCoord3 a -> Int)
-> ((TexCoord3 a, TexCoord3 a) -> TexCoord3 a -> Int)
-> ((TexCoord3 a, TexCoord3 a) -> TexCoord3 a -> Bool)
-> ((TexCoord3 a, TexCoord3 a) -> Int)
-> ((TexCoord3 a, TexCoord3 a) -> Int)
-> Ix (TexCoord3 a)
(TexCoord3 a, TexCoord3 a) -> Int
(TexCoord3 a, TexCoord3 a) -> [TexCoord3 a]
(TexCoord3 a, TexCoord3 a) -> TexCoord3 a -> Bool
(TexCoord3 a, TexCoord3 a) -> TexCoord3 a -> Int
forall a.
Ord a =>
((a, a) -> [a])
-> ((a, a) -> a -> Int)
-> ((a, a) -> a -> Int)
-> ((a, a) -> a -> Bool)
-> ((a, a) -> Int)
-> ((a, a) -> Int)
-> Ix a
forall a. Ix a => Ord (TexCoord3 a)
forall a. Ix a => (TexCoord3 a, TexCoord3 a) -> Int
forall a. Ix a => (TexCoord3 a, TexCoord3 a) -> [TexCoord3 a]
forall a. Ix a => (TexCoord3 a, TexCoord3 a) -> TexCoord3 a -> Bool
forall a. Ix a => (TexCoord3 a, TexCoord3 a) -> TexCoord3 a -> Int
unsafeRangeSize :: (TexCoord3 a, TexCoord3 a) -> Int
$cunsafeRangeSize :: forall a. Ix a => (TexCoord3 a, TexCoord3 a) -> Int
rangeSize :: (TexCoord3 a, TexCoord3 a) -> Int
$crangeSize :: forall a. Ix a => (TexCoord3 a, TexCoord3 a) -> Int
inRange :: (TexCoord3 a, TexCoord3 a) -> TexCoord3 a -> Bool
$cinRange :: forall a. Ix a => (TexCoord3 a, TexCoord3 a) -> TexCoord3 a -> Bool
unsafeIndex :: (TexCoord3 a, TexCoord3 a) -> TexCoord3 a -> Int
$cunsafeIndex :: forall a. Ix a => (TexCoord3 a, TexCoord3 a) -> TexCoord3 a -> Int
index :: (TexCoord3 a, TexCoord3 a) -> TexCoord3 a -> Int
$cindex :: forall a. Ix a => (TexCoord3 a, TexCoord3 a) -> TexCoord3 a -> Int
range :: (TexCoord3 a, TexCoord3 a) -> [TexCoord3 a]
$crange :: forall a. Ix a => (TexCoord3 a, TexCoord3 a) -> [TexCoord3 a]
$cp1Ix :: forall a. Ix a => Ord (TexCoord3 a)
Ix, TexCoord3 a
TexCoord3 a -> TexCoord3 a -> Bounded (TexCoord3 a)
forall a. a -> a -> Bounded a
forall a. Bounded a => TexCoord3 a
maxBound :: TexCoord3 a
$cmaxBound :: forall a. Bounded a => TexCoord3 a
minBound :: TexCoord3 a
$cminBound :: forall a. Bounded a => TexCoord3 a
Bounded, Int -> TexCoord3 a -> ShowS
[TexCoord3 a] -> ShowS
TexCoord3 a -> String
(Int -> TexCoord3 a -> ShowS)
-> (TexCoord3 a -> String)
-> ([TexCoord3 a] -> ShowS)
-> Show (TexCoord3 a)
forall a. Show a => Int -> TexCoord3 a -> ShowS
forall a. Show a => [TexCoord3 a] -> ShowS
forall a. Show a => TexCoord3 a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TexCoord3 a] -> ShowS
$cshowList :: forall a. Show a => [TexCoord3 a] -> ShowS
show :: TexCoord3 a -> String
$cshow :: forall a. Show a => TexCoord3 a -> String
showsPrec :: Int -> TexCoord3 a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> TexCoord3 a -> ShowS
Show, ReadPrec [TexCoord3 a]
ReadPrec (TexCoord3 a)
Int -> ReadS (TexCoord3 a)
ReadS [TexCoord3 a]
(Int -> ReadS (TexCoord3 a))
-> ReadS [TexCoord3 a]
-> ReadPrec (TexCoord3 a)
-> ReadPrec [TexCoord3 a]
-> Read (TexCoord3 a)
forall a. Read a => ReadPrec [TexCoord3 a]
forall a. Read a => ReadPrec (TexCoord3 a)
forall a. Read a => Int -> ReadS (TexCoord3 a)
forall a. Read a => ReadS [TexCoord3 a]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [TexCoord3 a]
$creadListPrec :: forall a. Read a => ReadPrec [TexCoord3 a]
readPrec :: ReadPrec (TexCoord3 a)
$creadPrec :: forall a. Read a => ReadPrec (TexCoord3 a)
readList :: ReadS [TexCoord3 a]
$creadList :: forall a. Read a => ReadS [TexCoord3 a]
readsPrec :: Int -> ReadS (TexCoord3 a)
$creadsPrec :: forall a. Read a => Int -> ReadS (TexCoord3 a)
Read, Typeable)

instance Functor TexCoord3 where
   fmap :: (a -> b) -> TexCoord3 a -> TexCoord3 b
fmap f :: a -> b
f (TexCoord3 x :: a
x y :: a
y z :: a
z) = b -> b -> b -> TexCoord3 b
forall a. a -> a -> a -> TexCoord3 a
TexCoord3 (a -> b
f a
x) (a -> b
f a
y) (a -> b
f a
z)

instance Applicative TexCoord3 where
   pure :: a -> TexCoord3 a
pure a :: a
a = a -> a -> a -> TexCoord3 a
forall a. a -> a -> a -> TexCoord3 a
TexCoord3 a
a a
a a
a
   TexCoord3 f :: a -> b
f g :: a -> b
g h :: a -> b
h <*> :: TexCoord3 (a -> b) -> TexCoord3 a -> TexCoord3 b
<*> TexCoord3 x :: a
x y :: a
y z :: a
z = b -> b -> b -> TexCoord3 b
forall a. a -> a -> a -> TexCoord3 a
TexCoord3 (a -> b
f a
x) (a -> b
g a
y) (a -> b
h a
z)

instance Foldable TexCoord3 where
   foldr :: (a -> b -> b) -> b -> TexCoord3 a -> b
foldr f :: a -> b -> b
f a :: b
a (TexCoord3 x :: a
x y :: a
y z :: a
z) = a
x `f ` (a
y a -> b -> b
`f` (a
z a -> b -> b
`f` b
a))
   foldl :: (b -> a -> b) -> b -> TexCoord3 a -> b
foldl f :: b -> a -> b
f a :: b
a (TexCoord3 x :: a
x y :: a
y z :: a
z) = ((b
a b -> a -> b
`f` a
x) b -> a -> b
`f` a
y) b -> a -> b
`f` a
z
   foldr1 :: (a -> a -> a) -> TexCoord3 a -> a
foldr1 f :: a -> a -> a
f (TexCoord3 x :: a
x y :: a
y z :: a
z) = a
x a -> a -> a
`f` (a
y a -> a -> a
`f` a
z)
   foldl1 :: (a -> a -> a) -> TexCoord3 a -> a
foldl1 f :: a -> a -> a
f (TexCoord3 x :: a
x y :: a
y z :: a
z) = (a
x a -> a -> a
`f` a
y) a -> a -> a
`f` a
z

instance Traversable TexCoord3 where
   traverse :: (a -> f b) -> TexCoord3 a -> f (TexCoord3 b)
traverse f :: a -> f b
f (TexCoord3 x :: a
x y :: a
y z :: a
z) = (b -> b -> b -> TexCoord3 b) -> f (b -> b -> b -> TexCoord3 b)
forall (f :: * -> *) a. Applicative f => a -> f a
pure b -> b -> b -> TexCoord3 b
forall a. a -> a -> a -> TexCoord3 a
TexCoord3 f (b -> b -> b -> TexCoord3 b) -> f b -> f (b -> b -> TexCoord3 b)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a -> f b
f a
x f (b -> b -> TexCoord3 b) -> f b -> f (b -> TexCoord3 b)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a -> f b
f a
y f (b -> TexCoord3 b) -> f b -> f (TexCoord3 b)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a -> f b
f a
z
   sequenceA :: TexCoord3 (f a) -> f (TexCoord3 a)
sequenceA (TexCoord3 x :: f a
x y :: f a
y z :: f a
z) =  (a -> a -> a -> TexCoord3 a) -> f (a -> a -> a -> TexCoord3 a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure a -> a -> a -> TexCoord3 a
forall a. a -> a -> a -> TexCoord3 a
TexCoord3 f (a -> a -> a -> TexCoord3 a) -> f a -> f (a -> a -> TexCoord3 a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> f a
x f (a -> a -> TexCoord3 a) -> f a -> f (a -> TexCoord3 a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> f a
y f (a -> TexCoord3 a) -> f a -> f (TexCoord3 a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> f a
z
   mapM :: (a -> m b) -> TexCoord3 a -> m (TexCoord3 b)
mapM f :: a -> m b
f (TexCoord3 x :: a
x y :: a
y z :: a
z) = (b -> b -> b -> TexCoord3 b) -> m (b -> b -> b -> TexCoord3 b)
forall (m :: * -> *) a. Monad m => a -> m a
return b -> b -> b -> TexCoord3 b
forall a. a -> a -> a -> TexCoord3 a
TexCoord3 m (b -> b -> b -> TexCoord3 b) -> m b -> m (b -> b -> TexCoord3 b)
forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
`ap` a -> m b
f a
x m (b -> b -> TexCoord3 b) -> m b -> m (b -> TexCoord3 b)
forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
`ap` a -> m b
f a
y m (b -> TexCoord3 b) -> m b -> m (TexCoord3 b)
forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
`ap` a -> m b
f a
z
   sequence :: TexCoord3 (m a) -> m (TexCoord3 a)
sequence (TexCoord3 x :: m a
x y :: m a
y z :: m a
z) = (a -> a -> a -> TexCoord3 a) -> m (a -> a -> a -> TexCoord3 a)
forall (m :: * -> *) a. Monad m => a -> m a
return a -> a -> a -> TexCoord3 a
forall a. a -> a -> a -> TexCoord3 a
TexCoord3 m (a -> a -> a -> TexCoord3 a) -> m a -> m (a -> a -> TexCoord3 a)
forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
`ap` m a
x m (a -> a -> TexCoord3 a) -> m a -> m (a -> TexCoord3 a)
forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
`ap` m a
y m (a -> TexCoord3 a) -> m a -> m (TexCoord3 a)
forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
`ap` m a
z

instance Storable a => Storable (TexCoord3 a) where
   sizeOf :: TexCoord3 a -> Int
sizeOf ~(TexCoord3 x :: a
x _ _) = 3 Int -> Int -> Int
forall a. Num a => a -> a -> a
* a -> Int
forall a. Storable a => a -> Int
sizeOf a
x
   alignment :: TexCoord3 a -> Int
alignment ~(TexCoord3 x :: a
x _ _) = a -> Int
forall a. Storable a => a -> Int
alignment a
x
   peek :: Ptr (TexCoord3 a) -> IO (TexCoord3 a)
peek = Ptr (TexCoord3 a) -> IO (TexCoord3 a)
forall (t :: * -> *) a.
(Applicative t, Traversable t, Storable a) =>
Ptr (t a) -> IO (t a)
peekApplicativeTraversable
   poke :: Ptr (TexCoord3 a) -> TexCoord3 a -> IO ()
poke = Ptr (TexCoord3 a) -> TexCoord3 a -> IO ()
forall (t :: * -> *) a.
(Foldable t, Storable a) =>
Ptr (t a) -> t a -> IO ()
pokeFoldable

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

-- | Fully-fledged four-dimensional texture coordinates.
data TexCoord4 a = TexCoord4 !a !a !a !a
   deriving (TexCoord4 a -> TexCoord4 a -> Bool
(TexCoord4 a -> TexCoord4 a -> Bool)
-> (TexCoord4 a -> TexCoord4 a -> Bool) -> Eq (TexCoord4 a)
forall a. Eq a => TexCoord4 a -> TexCoord4 a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TexCoord4 a -> TexCoord4 a -> Bool
$c/= :: forall a. Eq a => TexCoord4 a -> TexCoord4 a -> Bool
== :: TexCoord4 a -> TexCoord4 a -> Bool
$c== :: forall a. Eq a => TexCoord4 a -> TexCoord4 a -> Bool
Eq, Eq (TexCoord4 a)
Eq (TexCoord4 a) =>
(TexCoord4 a -> TexCoord4 a -> Ordering)
-> (TexCoord4 a -> TexCoord4 a -> Bool)
-> (TexCoord4 a -> TexCoord4 a -> Bool)
-> (TexCoord4 a -> TexCoord4 a -> Bool)
-> (TexCoord4 a -> TexCoord4 a -> Bool)
-> (TexCoord4 a -> TexCoord4 a -> TexCoord4 a)
-> (TexCoord4 a -> TexCoord4 a -> TexCoord4 a)
-> Ord (TexCoord4 a)
TexCoord4 a -> TexCoord4 a -> Bool
TexCoord4 a -> TexCoord4 a -> Ordering
TexCoord4 a -> TexCoord4 a -> TexCoord4 a
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall a. Ord a => Eq (TexCoord4 a)
forall a. Ord a => TexCoord4 a -> TexCoord4 a -> Bool
forall a. Ord a => TexCoord4 a -> TexCoord4 a -> Ordering
forall a. Ord a => TexCoord4 a -> TexCoord4 a -> TexCoord4 a
min :: TexCoord4 a -> TexCoord4 a -> TexCoord4 a
$cmin :: forall a. Ord a => TexCoord4 a -> TexCoord4 a -> TexCoord4 a
max :: TexCoord4 a -> TexCoord4 a -> TexCoord4 a
$cmax :: forall a. Ord a => TexCoord4 a -> TexCoord4 a -> TexCoord4 a
>= :: TexCoord4 a -> TexCoord4 a -> Bool
$c>= :: forall a. Ord a => TexCoord4 a -> TexCoord4 a -> Bool
> :: TexCoord4 a -> TexCoord4 a -> Bool
$c> :: forall a. Ord a => TexCoord4 a -> TexCoord4 a -> Bool
<= :: TexCoord4 a -> TexCoord4 a -> Bool
$c<= :: forall a. Ord a => TexCoord4 a -> TexCoord4 a -> Bool
< :: TexCoord4 a -> TexCoord4 a -> Bool
$c< :: forall a. Ord a => TexCoord4 a -> TexCoord4 a -> Bool
compare :: TexCoord4 a -> TexCoord4 a -> Ordering
$ccompare :: forall a. Ord a => TexCoord4 a -> TexCoord4 a -> Ordering
$cp1Ord :: forall a. Ord a => Eq (TexCoord4 a)
Ord, Ord (TexCoord4 a)
Ord (TexCoord4 a) =>
((TexCoord4 a, TexCoord4 a) -> [TexCoord4 a])
-> ((TexCoord4 a, TexCoord4 a) -> TexCoord4 a -> Int)
-> ((TexCoord4 a, TexCoord4 a) -> TexCoord4 a -> Int)
-> ((TexCoord4 a, TexCoord4 a) -> TexCoord4 a -> Bool)
-> ((TexCoord4 a, TexCoord4 a) -> Int)
-> ((TexCoord4 a, TexCoord4 a) -> Int)
-> Ix (TexCoord4 a)
(TexCoord4 a, TexCoord4 a) -> Int
(TexCoord4 a, TexCoord4 a) -> [TexCoord4 a]
(TexCoord4 a, TexCoord4 a) -> TexCoord4 a -> Bool
(TexCoord4 a, TexCoord4 a) -> TexCoord4 a -> Int
forall a.
Ord a =>
((a, a) -> [a])
-> ((a, a) -> a -> Int)
-> ((a, a) -> a -> Int)
-> ((a, a) -> a -> Bool)
-> ((a, a) -> Int)
-> ((a, a) -> Int)
-> Ix a
forall a. Ix a => Ord (TexCoord4 a)
forall a. Ix a => (TexCoord4 a, TexCoord4 a) -> Int
forall a. Ix a => (TexCoord4 a, TexCoord4 a) -> [TexCoord4 a]
forall a. Ix a => (TexCoord4 a, TexCoord4 a) -> TexCoord4 a -> Bool
forall a. Ix a => (TexCoord4 a, TexCoord4 a) -> TexCoord4 a -> Int
unsafeRangeSize :: (TexCoord4 a, TexCoord4 a) -> Int
$cunsafeRangeSize :: forall a. Ix a => (TexCoord4 a, TexCoord4 a) -> Int
rangeSize :: (TexCoord4 a, TexCoord4 a) -> Int
$crangeSize :: forall a. Ix a => (TexCoord4 a, TexCoord4 a) -> Int
inRange :: (TexCoord4 a, TexCoord4 a) -> TexCoord4 a -> Bool
$cinRange :: forall a. Ix a => (TexCoord4 a, TexCoord4 a) -> TexCoord4 a -> Bool
unsafeIndex :: (TexCoord4 a, TexCoord4 a) -> TexCoord4 a -> Int
$cunsafeIndex :: forall a. Ix a => (TexCoord4 a, TexCoord4 a) -> TexCoord4 a -> Int
index :: (TexCoord4 a, TexCoord4 a) -> TexCoord4 a -> Int
$cindex :: forall a. Ix a => (TexCoord4 a, TexCoord4 a) -> TexCoord4 a -> Int
range :: (TexCoord4 a, TexCoord4 a) -> [TexCoord4 a]
$crange :: forall a. Ix a => (TexCoord4 a, TexCoord4 a) -> [TexCoord4 a]
$cp1Ix :: forall a. Ix a => Ord (TexCoord4 a)
Ix, TexCoord4 a
TexCoord4 a -> TexCoord4 a -> Bounded (TexCoord4 a)
forall a. a -> a -> Bounded a
forall a. Bounded a => TexCoord4 a
maxBound :: TexCoord4 a
$cmaxBound :: forall a. Bounded a => TexCoord4 a
minBound :: TexCoord4 a
$cminBound :: forall a. Bounded a => TexCoord4 a
Bounded, Int -> TexCoord4 a -> ShowS
[TexCoord4 a] -> ShowS
TexCoord4 a -> String
(Int -> TexCoord4 a -> ShowS)
-> (TexCoord4 a -> String)
-> ([TexCoord4 a] -> ShowS)
-> Show (TexCoord4 a)
forall a. Show a => Int -> TexCoord4 a -> ShowS
forall a. Show a => [TexCoord4 a] -> ShowS
forall a. Show a => TexCoord4 a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TexCoord4 a] -> ShowS
$cshowList :: forall a. Show a => [TexCoord4 a] -> ShowS
show :: TexCoord4 a -> String
$cshow :: forall a. Show a => TexCoord4 a -> String
showsPrec :: Int -> TexCoord4 a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> TexCoord4 a -> ShowS
Show, ReadPrec [TexCoord4 a]
ReadPrec (TexCoord4 a)
Int -> ReadS (TexCoord4 a)
ReadS [TexCoord4 a]
(Int -> ReadS (TexCoord4 a))
-> ReadS [TexCoord4 a]
-> ReadPrec (TexCoord4 a)
-> ReadPrec [TexCoord4 a]
-> Read (TexCoord4 a)
forall a. Read a => ReadPrec [TexCoord4 a]
forall a. Read a => ReadPrec (TexCoord4 a)
forall a. Read a => Int -> ReadS (TexCoord4 a)
forall a. Read a => ReadS [TexCoord4 a]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [TexCoord4 a]
$creadListPrec :: forall a. Read a => ReadPrec [TexCoord4 a]
readPrec :: ReadPrec (TexCoord4 a)
$creadPrec :: forall a. Read a => ReadPrec (TexCoord4 a)
readList :: ReadS [TexCoord4 a]
$creadList :: forall a. Read a => ReadS [TexCoord4 a]
readsPrec :: Int -> ReadS (TexCoord4 a)
$creadsPrec :: forall a. Read a => Int -> ReadS (TexCoord4 a)
Read, Typeable)

instance Functor TexCoord4 where
   fmap :: (a -> b) -> TexCoord4 a -> TexCoord4 b
fmap f :: a -> b
f (TexCoord4 x :: a
x y :: a
y z :: a
z w :: a
w) = b -> b -> b -> b -> TexCoord4 b
forall a. a -> a -> a -> a -> TexCoord4 a
TexCoord4 (a -> b
f a
x) (a -> b
f a
y) (a -> b
f a
z) (a -> b
f a
w)

instance Applicative TexCoord4 where
   pure :: a -> TexCoord4 a
pure a :: a
a = a -> a -> a -> a -> TexCoord4 a
forall a. a -> a -> a -> a -> TexCoord4 a
TexCoord4 a
a a
a a
a a
a
   TexCoord4 f :: a -> b
f g :: a -> b
g h :: a -> b
h i :: a -> b
i <*> :: TexCoord4 (a -> b) -> TexCoord4 a -> TexCoord4 b
<*> TexCoord4 x :: a
x y :: a
y z :: a
z w :: a
w = b -> b -> b -> b -> TexCoord4 b
forall a. a -> a -> a -> a -> TexCoord4 a
TexCoord4 (a -> b
f a
x) (a -> b
g a
y) (a -> b
h a
z) (a -> b
i a
w)

instance Foldable TexCoord4 where
   foldr :: (a -> b -> b) -> b -> TexCoord4 a -> b
foldr f :: a -> b -> b
f a :: b
a (TexCoord4 x :: a
x y :: a
y z :: a
z w :: a
w) = a
x `f ` (a
y a -> b -> b
`f` (a
z a -> b -> b
`f` (a
w a -> b -> b
`f` b
a)))
   foldl :: (b -> a -> b) -> b -> TexCoord4 a -> b
foldl f :: b -> a -> b
f a :: b
a (TexCoord4 x :: a
x y :: a
y z :: a
z w :: a
w) = (((b
a b -> a -> b
`f` a
x) b -> a -> b
`f` a
y) b -> a -> b
`f` a
z) b -> a -> b
`f` a
w
   foldr1 :: (a -> a -> a) -> TexCoord4 a -> a
foldr1 f :: a -> a -> a
f (TexCoord4 x :: a
x y :: a
y z :: a
z w :: a
w) = a
x a -> a -> a
`f` (a
y a -> a -> a
`f` (a
z a -> a -> a
`f` a
w))
   foldl1 :: (a -> a -> a) -> TexCoord4 a -> a
foldl1 f :: a -> a -> a
f (TexCoord4 x :: a
x y :: a
y z :: a
z w :: a
w) = ((a
x a -> a -> a
`f` a
y) a -> a -> a
`f` a
z) a -> a -> a
`f` a
w

instance Traversable TexCoord4 where
   traverse :: (a -> f b) -> TexCoord4 a -> f (TexCoord4 b)
traverse f :: a -> f b
f (TexCoord4 x :: a
x y :: a
y z :: a
z w :: a
w) = (b -> b -> b -> b -> TexCoord4 b)
-> f (b -> b -> b -> b -> TexCoord4 b)
forall (f :: * -> *) a. Applicative f => a -> f a
pure b -> b -> b -> b -> TexCoord4 b
forall a. a -> a -> a -> a -> TexCoord4 a
TexCoord4 f (b -> b -> b -> b -> TexCoord4 b)
-> f b -> f (b -> b -> b -> TexCoord4 b)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a -> f b
f a
x f (b -> b -> b -> TexCoord4 b) -> f b -> f (b -> b -> TexCoord4 b)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a -> f b
f a
y f (b -> b -> TexCoord4 b) -> f b -> f (b -> TexCoord4 b)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a -> f b
f a
z f (b -> TexCoord4 b) -> f b -> f (TexCoord4 b)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a -> f b
f a
w
   sequenceA :: TexCoord4 (f a) -> f (TexCoord4 a)
sequenceA (TexCoord4 x :: f a
x y :: f a
y z :: f a
z w :: f a
w) =  (a -> a -> a -> a -> TexCoord4 a)
-> f (a -> a -> a -> a -> TexCoord4 a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure a -> a -> a -> a -> TexCoord4 a
forall a. a -> a -> a -> a -> TexCoord4 a
TexCoord4 f (a -> a -> a -> a -> TexCoord4 a)
-> f a -> f (a -> a -> a -> TexCoord4 a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> f a
x f (a -> a -> a -> TexCoord4 a) -> f a -> f (a -> a -> TexCoord4 a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> f a
y f (a -> a -> TexCoord4 a) -> f a -> f (a -> TexCoord4 a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> f a
z f (a -> TexCoord4 a) -> f a -> f (TexCoord4 a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> f a
w
   mapM :: (a -> m b) -> TexCoord4 a -> m (TexCoord4 b)
mapM f :: a -> m b
f (TexCoord4 x :: a
x y :: a
y z :: a
z w :: a
w) = (b -> b -> b -> b -> TexCoord4 b)
-> m (b -> b -> b -> b -> TexCoord4 b)
forall (m :: * -> *) a. Monad m => a -> m a
return b -> b -> b -> b -> TexCoord4 b
forall a. a -> a -> a -> a -> TexCoord4 a
TexCoord4 m (b -> b -> b -> b -> TexCoord4 b)
-> m b -> m (b -> b -> b -> TexCoord4 b)
forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
`ap` a -> m b
f a
x m (b -> b -> b -> TexCoord4 b) -> m b -> m (b -> b -> TexCoord4 b)
forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
`ap` a -> m b
f a
y m (b -> b -> TexCoord4 b) -> m b -> m (b -> TexCoord4 b)
forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
`ap` a -> m b
f a
z m (b -> TexCoord4 b) -> m b -> m (TexCoord4 b)
forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
`ap` a -> m b
f a
w
   sequence :: TexCoord4 (m a) -> m (TexCoord4 a)
sequence (TexCoord4 x :: m a
x y :: m a
y z :: m a
z w :: m a
w) = (a -> a -> a -> a -> TexCoord4 a)
-> m (a -> a -> a -> a -> TexCoord4 a)
forall (m :: * -> *) a. Monad m => a -> m a
return a -> a -> a -> a -> TexCoord4 a
forall a. a -> a -> a -> a -> TexCoord4 a
TexCoord4 m (a -> a -> a -> a -> TexCoord4 a)
-> m a -> m (a -> a -> a -> TexCoord4 a)
forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
`ap` m a
x m (a -> a -> a -> TexCoord4 a) -> m a -> m (a -> a -> TexCoord4 a)
forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
`ap` m a
y m (a -> a -> TexCoord4 a) -> m a -> m (a -> TexCoord4 a)
forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
`ap` m a
z m (a -> TexCoord4 a) -> m a -> m (TexCoord4 a)
forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
`ap` m a
w

instance Storable a => Storable (TexCoord4 a) where
   sizeOf :: TexCoord4 a -> Int
sizeOf ~(TexCoord4 x :: a
x _ _ _) = 4 Int -> Int -> Int
forall a. Num a => a -> a -> a
* a -> Int
forall a. Storable a => a -> Int
sizeOf a
x
   alignment :: TexCoord4 a -> Int
alignment ~(TexCoord4 x :: a
x _ _ _) = a -> Int
forall a. Storable a => a -> Int
alignment a
x
   peek :: Ptr (TexCoord4 a) -> IO (TexCoord4 a)
peek = Ptr (TexCoord4 a) -> IO (TexCoord4 a)
forall (t :: * -> *) a.
(Applicative t, Traversable t, Storable a) =>
Ptr (t a) -> IO (t a)
peekApplicativeTraversable
   poke :: Ptr (TexCoord4 a) -> TexCoord4 a -> IO ()
poke = Ptr (TexCoord4 a) -> TexCoord4 a -> IO ()
forall (t :: * -> *) a.
(Foldable t, Storable a) =>
Ptr (t a) -> t a -> IO ()
pokeFoldable

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

-- A three-dimensional normal.
data Normal3 a = Normal3 !a !a !a
   deriving (Normal3 a -> Normal3 a -> Bool
(Normal3 a -> Normal3 a -> Bool)
-> (Normal3 a -> Normal3 a -> Bool) -> Eq (Normal3 a)
forall a. Eq a => Normal3 a -> Normal3 a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Normal3 a -> Normal3 a -> Bool
$c/= :: forall a. Eq a => Normal3 a -> Normal3 a -> Bool
== :: Normal3 a -> Normal3 a -> Bool
$c== :: forall a. Eq a => Normal3 a -> Normal3 a -> Bool
Eq, Eq (Normal3 a)
Eq (Normal3 a) =>
(Normal3 a -> Normal3 a -> Ordering)
-> (Normal3 a -> Normal3 a -> Bool)
-> (Normal3 a -> Normal3 a -> Bool)
-> (Normal3 a -> Normal3 a -> Bool)
-> (Normal3 a -> Normal3 a -> Bool)
-> (Normal3 a -> Normal3 a -> Normal3 a)
-> (Normal3 a -> Normal3 a -> Normal3 a)
-> Ord (Normal3 a)
Normal3 a -> Normal3 a -> Bool
Normal3 a -> Normal3 a -> Ordering
Normal3 a -> Normal3 a -> Normal3 a
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall a. Ord a => Eq (Normal3 a)
forall a. Ord a => Normal3 a -> Normal3 a -> Bool
forall a. Ord a => Normal3 a -> Normal3 a -> Ordering
forall a. Ord a => Normal3 a -> Normal3 a -> Normal3 a
min :: Normal3 a -> Normal3 a -> Normal3 a
$cmin :: forall a. Ord a => Normal3 a -> Normal3 a -> Normal3 a
max :: Normal3 a -> Normal3 a -> Normal3 a
$cmax :: forall a. Ord a => Normal3 a -> Normal3 a -> Normal3 a
>= :: Normal3 a -> Normal3 a -> Bool
$c>= :: forall a. Ord a => Normal3 a -> Normal3 a -> Bool
> :: Normal3 a -> Normal3 a -> Bool
$c> :: forall a. Ord a => Normal3 a -> Normal3 a -> Bool
<= :: Normal3 a -> Normal3 a -> Bool
$c<= :: forall a. Ord a => Normal3 a -> Normal3 a -> Bool
< :: Normal3 a -> Normal3 a -> Bool
$c< :: forall a. Ord a => Normal3 a -> Normal3 a -> Bool
compare :: Normal3 a -> Normal3 a -> Ordering
$ccompare :: forall a. Ord a => Normal3 a -> Normal3 a -> Ordering
$cp1Ord :: forall a. Ord a => Eq (Normal3 a)
Ord, Ord (Normal3 a)
Ord (Normal3 a) =>
((Normal3 a, Normal3 a) -> [Normal3 a])
-> ((Normal3 a, Normal3 a) -> Normal3 a -> Int)
-> ((Normal3 a, Normal3 a) -> Normal3 a -> Int)
-> ((Normal3 a, Normal3 a) -> Normal3 a -> Bool)
-> ((Normal3 a, Normal3 a) -> Int)
-> ((Normal3 a, Normal3 a) -> Int)
-> Ix (Normal3 a)
(Normal3 a, Normal3 a) -> Int
(Normal3 a, Normal3 a) -> [Normal3 a]
(Normal3 a, Normal3 a) -> Normal3 a -> Bool
(Normal3 a, Normal3 a) -> Normal3 a -> Int
forall a.
Ord a =>
((a, a) -> [a])
-> ((a, a) -> a -> Int)
-> ((a, a) -> a -> Int)
-> ((a, a) -> a -> Bool)
-> ((a, a) -> Int)
-> ((a, a) -> Int)
-> Ix a
forall a. Ix a => Ord (Normal3 a)
forall a. Ix a => (Normal3 a, Normal3 a) -> Int
forall a. Ix a => (Normal3 a, Normal3 a) -> [Normal3 a]
forall a. Ix a => (Normal3 a, Normal3 a) -> Normal3 a -> Bool
forall a. Ix a => (Normal3 a, Normal3 a) -> Normal3 a -> Int
unsafeRangeSize :: (Normal3 a, Normal3 a) -> Int
$cunsafeRangeSize :: forall a. Ix a => (Normal3 a, Normal3 a) -> Int
rangeSize :: (Normal3 a, Normal3 a) -> Int
$crangeSize :: forall a. Ix a => (Normal3 a, Normal3 a) -> Int
inRange :: (Normal3 a, Normal3 a) -> Normal3 a -> Bool
$cinRange :: forall a. Ix a => (Normal3 a, Normal3 a) -> Normal3 a -> Bool
unsafeIndex :: (Normal3 a, Normal3 a) -> Normal3 a -> Int
$cunsafeIndex :: forall a. Ix a => (Normal3 a, Normal3 a) -> Normal3 a -> Int
index :: (Normal3 a, Normal3 a) -> Normal3 a -> Int
$cindex :: forall a. Ix a => (Normal3 a, Normal3 a) -> Normal3 a -> Int
range :: (Normal3 a, Normal3 a) -> [Normal3 a]
$crange :: forall a. Ix a => (Normal3 a, Normal3 a) -> [Normal3 a]
$cp1Ix :: forall a. Ix a => Ord (Normal3 a)
Ix, Normal3 a
Normal3 a -> Normal3 a -> Bounded (Normal3 a)
forall a. a -> a -> Bounded a
forall a. Bounded a => Normal3 a
maxBound :: Normal3 a
$cmaxBound :: forall a. Bounded a => Normal3 a
minBound :: Normal3 a
$cminBound :: forall a. Bounded a => Normal3 a
Bounded, Int -> Normal3 a -> ShowS
[Normal3 a] -> ShowS
Normal3 a -> String
(Int -> Normal3 a -> ShowS)
-> (Normal3 a -> String)
-> ([Normal3 a] -> ShowS)
-> Show (Normal3 a)
forall a. Show a => Int -> Normal3 a -> ShowS
forall a. Show a => [Normal3 a] -> ShowS
forall a. Show a => Normal3 a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Normal3 a] -> ShowS
$cshowList :: forall a. Show a => [Normal3 a] -> ShowS
show :: Normal3 a -> String
$cshow :: forall a. Show a => Normal3 a -> String
showsPrec :: Int -> Normal3 a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> Normal3 a -> ShowS
Show, ReadPrec [Normal3 a]
ReadPrec (Normal3 a)
Int -> ReadS (Normal3 a)
ReadS [Normal3 a]
(Int -> ReadS (Normal3 a))
-> ReadS [Normal3 a]
-> ReadPrec (Normal3 a)
-> ReadPrec [Normal3 a]
-> Read (Normal3 a)
forall a. Read a => ReadPrec [Normal3 a]
forall a. Read a => ReadPrec (Normal3 a)
forall a. Read a => Int -> ReadS (Normal3 a)
forall a. Read a => ReadS [Normal3 a]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Normal3 a]
$creadListPrec :: forall a. Read a => ReadPrec [Normal3 a]
readPrec :: ReadPrec (Normal3 a)
$creadPrec :: forall a. Read a => ReadPrec (Normal3 a)
readList :: ReadS [Normal3 a]
$creadList :: forall a. Read a => ReadS [Normal3 a]
readsPrec :: Int -> ReadS (Normal3 a)
$creadsPrec :: forall a. Read a => Int -> ReadS (Normal3 a)
Read, Typeable) 
instance Functor Normal3 where
   fmap :: (a -> b) -> Normal3 a -> Normal3 b
fmap f :: a -> b
f (Normal3 x :: a
x y :: a
y z :: a
z) = b -> b -> b -> Normal3 b
forall a. a -> a -> a -> Normal3 a
Normal3 (a -> b
f a
x) (a -> b
f a
y) (a -> b
f a
z)

instance Applicative Normal3 where
   pure :: a -> Normal3 a
pure a :: a
a = a -> a -> a -> Normal3 a
forall a. a -> a -> a -> Normal3 a
Normal3 a
a a
a a
a
   Normal3 f :: a -> b
f g :: a -> b
g h :: a -> b
h <*> :: Normal3 (a -> b) -> Normal3 a -> Normal3 b
<*> Normal3 x :: a
x y :: a
y z :: a
z = b -> b -> b -> Normal3 b
forall a. a -> a -> a -> Normal3 a
Normal3 (a -> b
f a
x) (a -> b
g a
y) (a -> b
h a
z)

instance Foldable Normal3 where
   foldr :: (a -> b -> b) -> b -> Normal3 a -> b
foldr f :: a -> b -> b
f a :: b
a (Normal3 x :: a
x y :: a
y z :: a
z) = a
x `f ` (a
y a -> b -> b
`f` (a
z a -> b -> b
`f` b
a))
   foldl :: (b -> a -> b) -> b -> Normal3 a -> b
foldl f :: b -> a -> b
f a :: b
a (Normal3 x :: a
x y :: a
y z :: a
z) = ((b
a b -> a -> b
`f` a
x) b -> a -> b
`f` a
y) b -> a -> b
`f` a
z
   foldr1 :: (a -> a -> a) -> Normal3 a -> a
foldr1 f :: a -> a -> a
f (Normal3 x :: a
x y :: a
y z :: a
z) = a
x a -> a -> a
`f` (a
y a -> a -> a
`f` a
z)
   foldl1 :: (a -> a -> a) -> Normal3 a -> a
foldl1 f :: a -> a -> a
f (Normal3 x :: a
x y :: a
y z :: a
z) = (a
x a -> a -> a
`f` a
y) a -> a -> a
`f` a
z

instance Traversable Normal3 where
   traverse :: (a -> f b) -> Normal3 a -> f (Normal3 b)
traverse f :: a -> f b
f (Normal3 x :: a
x y :: a
y z :: a
z) = (b -> b -> b -> Normal3 b) -> f (b -> b -> b -> Normal3 b)
forall (f :: * -> *) a. Applicative f => a -> f a
pure b -> b -> b -> Normal3 b
forall a. a -> a -> a -> Normal3 a
Normal3 f (b -> b -> b -> Normal3 b) -> f b -> f (b -> b -> Normal3 b)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a -> f b
f a
x f (b -> b -> Normal3 b) -> f b -> f (b -> Normal3 b)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a -> f b
f a
y f (b -> Normal3 b) -> f b -> f (Normal3 b)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a -> f b
f a
z
   sequenceA :: Normal3 (f a) -> f (Normal3 a)
sequenceA (Normal3 x :: f a
x y :: f a
y z :: f a
z) =  (a -> a -> a -> Normal3 a) -> f (a -> a -> a -> Normal3 a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure a -> a -> a -> Normal3 a
forall a. a -> a -> a -> Normal3 a
Normal3 f (a -> a -> a -> Normal3 a) -> f a -> f (a -> a -> Normal3 a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> f a
x f (a -> a -> Normal3 a) -> f a -> f (a -> Normal3 a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> f a
y f (a -> Normal3 a) -> f a -> f (Normal3 a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> f a
z
   mapM :: (a -> m b) -> Normal3 a -> m (Normal3 b)
mapM f :: a -> m b
f (Normal3 x :: a
x y :: a
y z :: a
z) = (b -> b -> b -> Normal3 b) -> m (b -> b -> b -> Normal3 b)
forall (m :: * -> *) a. Monad m => a -> m a
return b -> b -> b -> Normal3 b
forall a. a -> a -> a -> Normal3 a
Normal3 m (b -> b -> b -> Normal3 b) -> m b -> m (b -> b -> Normal3 b)
forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
`ap` a -> m b
f a
x m (b -> b -> Normal3 b) -> m b -> m (b -> Normal3 b)
forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
`ap` a -> m b
f a
y m (b -> Normal3 b) -> m b -> m (Normal3 b)
forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
`ap` a -> m b
f a
z
   sequence :: Normal3 (m a) -> m (Normal3 a)
sequence (Normal3 x :: m a
x y :: m a
y z :: m a
z) = (a -> a -> a -> Normal3 a) -> m (a -> a -> a -> Normal3 a)
forall (m :: * -> *) a. Monad m => a -> m a
return a -> a -> a -> Normal3 a
forall a. a -> a -> a -> Normal3 a
Normal3 m (a -> a -> a -> Normal3 a) -> m a -> m (a -> a -> Normal3 a)
forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
`ap` m a
x m (a -> a -> Normal3 a) -> m a -> m (a -> Normal3 a)
forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
`ap` m a
y m (a -> Normal3 a) -> m a -> m (Normal3 a)
forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
`ap` m a
z

instance Storable a => Storable (Normal3 a) where
   sizeOf :: Normal3 a -> Int
sizeOf ~(Normal3 x :: a
x _ _) = 3 Int -> Int -> Int
forall a. Num a => a -> a -> a
* a -> Int
forall a. Storable a => a -> Int
sizeOf a
x
   alignment :: Normal3 a -> Int
alignment ~(Normal3 x :: a
x _ _) = a -> Int
forall a. Storable a => a -> Int
alignment a
x
   peek :: Ptr (Normal3 a) -> IO (Normal3 a)
peek = Ptr (Normal3 a) -> IO (Normal3 a)
forall (t :: * -> *) a.
(Applicative t, Traversable t, Storable a) =>
Ptr (t a) -> IO (t a)
peekApplicativeTraversable
   poke :: Ptr (Normal3 a) -> Normal3 a -> IO ()
poke = Ptr (Normal3 a) -> Normal3 a -> IO ()
forall (t :: * -> *) a.
(Foldable t, Storable a) =>
Ptr (t a) -> t a -> IO ()
pokeFoldable

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

-- | A fog coordinate.
newtype FogCoord1 a = FogCoord1 a
   deriving (FogCoord1 a -> FogCoord1 a -> Bool
(FogCoord1 a -> FogCoord1 a -> Bool)
-> (FogCoord1 a -> FogCoord1 a -> Bool) -> Eq (FogCoord1 a)
forall a. Eq a => FogCoord1 a -> FogCoord1 a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FogCoord1 a -> FogCoord1 a -> Bool
$c/= :: forall a. Eq a => FogCoord1 a -> FogCoord1 a -> Bool
== :: FogCoord1 a -> FogCoord1 a -> Bool
$c== :: forall a. Eq a => FogCoord1 a -> FogCoord1 a -> Bool
Eq, Eq (FogCoord1 a)
Eq (FogCoord1 a) =>
(FogCoord1 a -> FogCoord1 a -> Ordering)
-> (FogCoord1 a -> FogCoord1 a -> Bool)
-> (FogCoord1 a -> FogCoord1 a -> Bool)
-> (FogCoord1 a -> FogCoord1 a -> Bool)
-> (FogCoord1 a -> FogCoord1 a -> Bool)
-> (FogCoord1 a -> FogCoord1 a -> FogCoord1 a)
-> (FogCoord1 a -> FogCoord1 a -> FogCoord1 a)
-> Ord (FogCoord1 a)
FogCoord1 a -> FogCoord1 a -> Bool
FogCoord1 a -> FogCoord1 a -> Ordering
FogCoord1 a -> FogCoord1 a -> FogCoord1 a
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall a. Ord a => Eq (FogCoord1 a)
forall a. Ord a => FogCoord1 a -> FogCoord1 a -> Bool
forall a. Ord a => FogCoord1 a -> FogCoord1 a -> Ordering
forall a. Ord a => FogCoord1 a -> FogCoord1 a -> FogCoord1 a
min :: FogCoord1 a -> FogCoord1 a -> FogCoord1 a
$cmin :: forall a. Ord a => FogCoord1 a -> FogCoord1 a -> FogCoord1 a
max :: FogCoord1 a -> FogCoord1 a -> FogCoord1 a
$cmax :: forall a. Ord a => FogCoord1 a -> FogCoord1 a -> FogCoord1 a
>= :: FogCoord1 a -> FogCoord1 a -> Bool
$c>= :: forall a. Ord a => FogCoord1 a -> FogCoord1 a -> Bool
> :: FogCoord1 a -> FogCoord1 a -> Bool
$c> :: forall a. Ord a => FogCoord1 a -> FogCoord1 a -> Bool
<= :: FogCoord1 a -> FogCoord1 a -> Bool
$c<= :: forall a. Ord a => FogCoord1 a -> FogCoord1 a -> Bool
< :: FogCoord1 a -> FogCoord1 a -> Bool
$c< :: forall a. Ord a => FogCoord1 a -> FogCoord1 a -> Bool
compare :: FogCoord1 a -> FogCoord1 a -> Ordering
$ccompare :: forall a. Ord a => FogCoord1 a -> FogCoord1 a -> Ordering
$cp1Ord :: forall a. Ord a => Eq (FogCoord1 a)
Ord, Ord (FogCoord1 a)
Ord (FogCoord1 a) =>
((FogCoord1 a, FogCoord1 a) -> [FogCoord1 a])
-> ((FogCoord1 a, FogCoord1 a) -> FogCoord1 a -> Int)
-> ((FogCoord1 a, FogCoord1 a) -> FogCoord1 a -> Int)
-> ((FogCoord1 a, FogCoord1 a) -> FogCoord1 a -> Bool)
-> ((FogCoord1 a, FogCoord1 a) -> Int)
-> ((FogCoord1 a, FogCoord1 a) -> Int)
-> Ix (FogCoord1 a)
(FogCoord1 a, FogCoord1 a) -> Int
(FogCoord1 a, FogCoord1 a) -> [FogCoord1 a]
(FogCoord1 a, FogCoord1 a) -> FogCoord1 a -> Bool
(FogCoord1 a, FogCoord1 a) -> FogCoord1 a -> Int
forall a.
Ord a =>
((a, a) -> [a])
-> ((a, a) -> a -> Int)
-> ((a, a) -> a -> Int)
-> ((a, a) -> a -> Bool)
-> ((a, a) -> Int)
-> ((a, a) -> Int)
-> Ix a
forall a. Ix a => Ord (FogCoord1 a)
forall a. Ix a => (FogCoord1 a, FogCoord1 a) -> Int
forall a. Ix a => (FogCoord1 a, FogCoord1 a) -> [FogCoord1 a]
forall a. Ix a => (FogCoord1 a, FogCoord1 a) -> FogCoord1 a -> Bool
forall a. Ix a => (FogCoord1 a, FogCoord1 a) -> FogCoord1 a -> Int
unsafeRangeSize :: (FogCoord1 a, FogCoord1 a) -> Int
$cunsafeRangeSize :: forall a. Ix a => (FogCoord1 a, FogCoord1 a) -> Int
rangeSize :: (FogCoord1 a, FogCoord1 a) -> Int
$crangeSize :: forall a. Ix a => (FogCoord1 a, FogCoord1 a) -> Int
inRange :: (FogCoord1 a, FogCoord1 a) -> FogCoord1 a -> Bool
$cinRange :: forall a. Ix a => (FogCoord1 a, FogCoord1 a) -> FogCoord1 a -> Bool
unsafeIndex :: (FogCoord1 a, FogCoord1 a) -> FogCoord1 a -> Int
$cunsafeIndex :: forall a. Ix a => (FogCoord1 a, FogCoord1 a) -> FogCoord1 a -> Int
index :: (FogCoord1 a, FogCoord1 a) -> FogCoord1 a -> Int
$cindex :: forall a. Ix a => (FogCoord1 a, FogCoord1 a) -> FogCoord1 a -> Int
range :: (FogCoord1 a, FogCoord1 a) -> [FogCoord1 a]
$crange :: forall a. Ix a => (FogCoord1 a, FogCoord1 a) -> [FogCoord1 a]
$cp1Ix :: forall a. Ix a => Ord (FogCoord1 a)
Ix, FogCoord1 a
FogCoord1 a -> FogCoord1 a -> Bounded (FogCoord1 a)
forall a. a -> a -> Bounded a
forall a. Bounded a => FogCoord1 a
maxBound :: FogCoord1 a
$cmaxBound :: forall a. Bounded a => FogCoord1 a
minBound :: FogCoord1 a
$cminBound :: forall a. Bounded a => FogCoord1 a
Bounded, Int -> FogCoord1 a -> ShowS
[FogCoord1 a] -> ShowS
FogCoord1 a -> String
(Int -> FogCoord1 a -> ShowS)
-> (FogCoord1 a -> String)
-> ([FogCoord1 a] -> ShowS)
-> Show (FogCoord1 a)
forall a. Show a => Int -> FogCoord1 a -> ShowS
forall a. Show a => [FogCoord1 a] -> ShowS
forall a. Show a => FogCoord1 a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FogCoord1 a] -> ShowS
$cshowList :: forall a. Show a => [FogCoord1 a] -> ShowS
show :: FogCoord1 a -> String
$cshow :: forall a. Show a => FogCoord1 a -> String
showsPrec :: Int -> FogCoord1 a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> FogCoord1 a -> ShowS
Show, ReadPrec [FogCoord1 a]
ReadPrec (FogCoord1 a)
Int -> ReadS (FogCoord1 a)
ReadS [FogCoord1 a]
(Int -> ReadS (FogCoord1 a))
-> ReadS [FogCoord1 a]
-> ReadPrec (FogCoord1 a)
-> ReadPrec [FogCoord1 a]
-> Read (FogCoord1 a)
forall a. Read a => ReadPrec [FogCoord1 a]
forall a. Read a => ReadPrec (FogCoord1 a)
forall a. Read a => Int -> ReadS (FogCoord1 a)
forall a. Read a => ReadS [FogCoord1 a]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [FogCoord1 a]
$creadListPrec :: forall a. Read a => ReadPrec [FogCoord1 a]
readPrec :: ReadPrec (FogCoord1 a)
$creadPrec :: forall a. Read a => ReadPrec (FogCoord1 a)
readList :: ReadS [FogCoord1 a]
$creadList :: forall a. Read a => ReadS [FogCoord1 a]
readsPrec :: Int -> ReadS (FogCoord1 a)
$creadsPrec :: forall a. Read a => Int -> ReadS (FogCoord1 a)
Read, Typeable)

instance Functor FogCoord1 where
   fmap :: (a -> b) -> FogCoord1 a -> FogCoord1 b
fmap f :: a -> b
f (FogCoord1 x :: a
x) = b -> FogCoord1 b
forall a. a -> FogCoord1 a
FogCoord1 (a -> b
f a
x)

instance Applicative FogCoord1 where
   pure :: a -> FogCoord1 a
pure a :: a
a = a -> FogCoord1 a
forall a. a -> FogCoord1 a
FogCoord1 a
a
   FogCoord1 f :: a -> b
f <*> :: FogCoord1 (a -> b) -> FogCoord1 a -> FogCoord1 b
<*> FogCoord1 x :: a
x = b -> FogCoord1 b
forall a. a -> FogCoord1 a
FogCoord1 (a -> b
f a
x)

instance Foldable FogCoord1 where
   foldr :: (a -> b -> b) -> b -> FogCoord1 a -> b
foldr f :: a -> b -> b
f a :: b
a (FogCoord1 x :: a
x) = a
x `f ` b
a
   foldl :: (b -> a -> b) -> b -> FogCoord1 a -> b
foldl f :: b -> a -> b
f a :: b
a (FogCoord1 x :: a
x)  = b
a b -> a -> b
`f` a
x
   foldr1 :: (a -> a -> a) -> FogCoord1 a -> a
foldr1 _ (FogCoord1 x :: a
x) = a
x
   foldl1 :: (a -> a -> a) -> FogCoord1 a -> a
foldl1 _ (FogCoord1 x :: a
x) = a
x

instance Traversable FogCoord1 where
   traverse :: (a -> f b) -> FogCoord1 a -> f (FogCoord1 b)
traverse f :: a -> f b
f (FogCoord1 x :: a
x) = (b -> FogCoord1 b) -> f (b -> FogCoord1 b)
forall (f :: * -> *) a. Applicative f => a -> f a
pure b -> FogCoord1 b
forall a. a -> FogCoord1 a
FogCoord1 f (b -> FogCoord1 b) -> f b -> f (FogCoord1 b)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a -> f b
f a
x
   sequenceA :: FogCoord1 (f a) -> f (FogCoord1 a)
sequenceA (FogCoord1 x :: f a
x) =  (a -> FogCoord1 a) -> f (a -> FogCoord1 a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure a -> FogCoord1 a
forall a. a -> FogCoord1 a
FogCoord1 f (a -> FogCoord1 a) -> f a -> f (FogCoord1 a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> f a
x
   mapM :: (a -> m b) -> FogCoord1 a -> m (FogCoord1 b)
mapM f :: a -> m b
f (FogCoord1 x :: a
x) = (b -> FogCoord1 b) -> m (b -> FogCoord1 b)
forall (m :: * -> *) a. Monad m => a -> m a
return b -> FogCoord1 b
forall a. a -> FogCoord1 a
FogCoord1 m (b -> FogCoord1 b) -> m b -> m (FogCoord1 b)
forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
`ap` a -> m b
f a
x
   sequence :: FogCoord1 (m a) -> m (FogCoord1 a)
sequence (FogCoord1 x :: m a
x) = (a -> FogCoord1 a) -> m (a -> FogCoord1 a)
forall (m :: * -> *) a. Monad m => a -> m a
return a -> FogCoord1 a
forall a. a -> FogCoord1 a
FogCoord1 m (a -> FogCoord1 a) -> m a -> m (FogCoord1 a)
forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
`ap` m a
x

instance Storable a => Storable (FogCoord1 a) where
   sizeOf :: FogCoord1 a -> Int
sizeOf    ~(FogCoord1 s :: a
s) = a -> Int
forall a. Storable a => a -> Int
sizeOf a
s
   alignment :: FogCoord1 a -> Int
alignment ~(FogCoord1 s :: a
s) = a -> Int
forall a. Storable a => a -> Int
alignment a
s
   peek :: Ptr (FogCoord1 a) -> IO (FogCoord1 a)
peek = Ptr (FogCoord1 a) -> IO (FogCoord1 a)
forall (t :: * -> *) a.
(Applicative t, Traversable t, Storable a) =>
Ptr (t a) -> IO (t a)
peekApplicativeTraversable
   poke :: Ptr (FogCoord1 a) -> FogCoord1 a -> IO ()
poke = Ptr (FogCoord1 a) -> FogCoord1 a -> IO ()
forall (t :: * -> *) a.
(Foldable t, Storable a) =>
Ptr (t a) -> t a -> IO ()
pokeFoldable

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

-- An RGBA color with /A/=1.
data Color3 a = Color3 !a !a !a
   deriving (Color3 a -> Color3 a -> Bool
(Color3 a -> Color3 a -> Bool)
-> (Color3 a -> Color3 a -> Bool) -> Eq (Color3 a)
forall a. Eq a => Color3 a -> Color3 a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Color3 a -> Color3 a -> Bool
$c/= :: forall a. Eq a => Color3 a -> Color3 a -> Bool
== :: Color3 a -> Color3 a -> Bool
$c== :: forall a. Eq a => Color3 a -> Color3 a -> Bool
Eq, Eq (Color3 a)
Eq (Color3 a) =>
(Color3 a -> Color3 a -> Ordering)
-> (Color3 a -> Color3 a -> Bool)
-> (Color3 a -> Color3 a -> Bool)
-> (Color3 a -> Color3 a -> Bool)
-> (Color3 a -> Color3 a -> Bool)
-> (Color3 a -> Color3 a -> Color3 a)
-> (Color3 a -> Color3 a -> Color3 a)
-> Ord (Color3 a)
Color3 a -> Color3 a -> Bool
Color3 a -> Color3 a -> Ordering
Color3 a -> Color3 a -> Color3 a
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall a. Ord a => Eq (Color3 a)
forall a. Ord a => Color3 a -> Color3 a -> Bool
forall a. Ord a => Color3 a -> Color3 a -> Ordering
forall a. Ord a => Color3 a -> Color3 a -> Color3 a
min :: Color3 a -> Color3 a -> Color3 a
$cmin :: forall a. Ord a => Color3 a -> Color3 a -> Color3 a
max :: Color3 a -> Color3 a -> Color3 a
$cmax :: forall a. Ord a => Color3 a -> Color3 a -> Color3 a
>= :: Color3 a -> Color3 a -> Bool
$c>= :: forall a. Ord a => Color3 a -> Color3 a -> Bool
> :: Color3 a -> Color3 a -> Bool
$c> :: forall a. Ord a => Color3 a -> Color3 a -> Bool
<= :: Color3 a -> Color3 a -> Bool
$c<= :: forall a. Ord a => Color3 a -> Color3 a -> Bool
< :: Color3 a -> Color3 a -> Bool
$c< :: forall a. Ord a => Color3 a -> Color3 a -> Bool
compare :: Color3 a -> Color3 a -> Ordering
$ccompare :: forall a. Ord a => Color3 a -> Color3 a -> Ordering
$cp1Ord :: forall a. Ord a => Eq (Color3 a)
Ord, Ord (Color3 a)
Ord (Color3 a) =>
((Color3 a, Color3 a) -> [Color3 a])
-> ((Color3 a, Color3 a) -> Color3 a -> Int)
-> ((Color3 a, Color3 a) -> Color3 a -> Int)
-> ((Color3 a, Color3 a) -> Color3 a -> Bool)
-> ((Color3 a, Color3 a) -> Int)
-> ((Color3 a, Color3 a) -> Int)
-> Ix (Color3 a)
(Color3 a, Color3 a) -> Int
(Color3 a, Color3 a) -> [Color3 a]
(Color3 a, Color3 a) -> Color3 a -> Bool
(Color3 a, Color3 a) -> Color3 a -> Int
forall a.
Ord a =>
((a, a) -> [a])
-> ((a, a) -> a -> Int)
-> ((a, a) -> a -> Int)
-> ((a, a) -> a -> Bool)
-> ((a, a) -> Int)
-> ((a, a) -> Int)
-> Ix a
forall a. Ix a => Ord (Color3 a)
forall a. Ix a => (Color3 a, Color3 a) -> Int
forall a. Ix a => (Color3 a, Color3 a) -> [Color3 a]
forall a. Ix a => (Color3 a, Color3 a) -> Color3 a -> Bool
forall a. Ix a => (Color3 a, Color3 a) -> Color3 a -> Int
unsafeRangeSize :: (Color3 a, Color3 a) -> Int
$cunsafeRangeSize :: forall a. Ix a => (Color3 a, Color3 a) -> Int
rangeSize :: (Color3 a, Color3 a) -> Int
$crangeSize :: forall a. Ix a => (Color3 a, Color3 a) -> Int
inRange :: (Color3 a, Color3 a) -> Color3 a -> Bool
$cinRange :: forall a. Ix a => (Color3 a, Color3 a) -> Color3 a -> Bool
unsafeIndex :: (Color3 a, Color3 a) -> Color3 a -> Int
$cunsafeIndex :: forall a. Ix a => (Color3 a, Color3 a) -> Color3 a -> Int
index :: (Color3 a, Color3 a) -> Color3 a -> Int
$cindex :: forall a. Ix a => (Color3 a, Color3 a) -> Color3 a -> Int
range :: (Color3 a, Color3 a) -> [Color3 a]
$crange :: forall a. Ix a => (Color3 a, Color3 a) -> [Color3 a]
$cp1Ix :: forall a. Ix a => Ord (Color3 a)
Ix, Color3 a
Color3 a -> Color3 a -> Bounded (Color3 a)
forall a. a -> a -> Bounded a
forall a. Bounded a => Color3 a
maxBound :: Color3 a
$cmaxBound :: forall a. Bounded a => Color3 a
minBound :: Color3 a
$cminBound :: forall a. Bounded a => Color3 a
Bounded, Int -> Color3 a -> ShowS
[Color3 a] -> ShowS
Color3 a -> String
(Int -> Color3 a -> ShowS)
-> (Color3 a -> String) -> ([Color3 a] -> ShowS) -> Show (Color3 a)
forall a. Show a => Int -> Color3 a -> ShowS
forall a. Show a => [Color3 a] -> ShowS
forall a. Show a => Color3 a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Color3 a] -> ShowS
$cshowList :: forall a. Show a => [Color3 a] -> ShowS
show :: Color3 a -> String
$cshow :: forall a. Show a => Color3 a -> String
showsPrec :: Int -> Color3 a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> Color3 a -> ShowS
Show, ReadPrec [Color3 a]
ReadPrec (Color3 a)
Int -> ReadS (Color3 a)
ReadS [Color3 a]
(Int -> ReadS (Color3 a))
-> ReadS [Color3 a]
-> ReadPrec (Color3 a)
-> ReadPrec [Color3 a]
-> Read (Color3 a)
forall a. Read a => ReadPrec [Color3 a]
forall a. Read a => ReadPrec (Color3 a)
forall a. Read a => Int -> ReadS (Color3 a)
forall a. Read a => ReadS [Color3 a]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Color3 a]
$creadListPrec :: forall a. Read a => ReadPrec [Color3 a]
readPrec :: ReadPrec (Color3 a)
$creadPrec :: forall a. Read a => ReadPrec (Color3 a)
readList :: ReadS [Color3 a]
$creadList :: forall a. Read a => ReadS [Color3 a]
readsPrec :: Int -> ReadS (Color3 a)
$creadsPrec :: forall a. Read a => Int -> ReadS (Color3 a)
Read, Typeable)

instance Functor Color3 where
   fmap :: (a -> b) -> Color3 a -> Color3 b
fmap f :: a -> b
f (Color3 x :: a
x y :: a
y z :: a
z) = b -> b -> b -> Color3 b
forall a. a -> a -> a -> Color3 a
Color3 (a -> b
f a
x) (a -> b
f a
y) (a -> b
f a
z)

instance Applicative Color3 where
   pure :: a -> Color3 a
pure a :: a
a = a -> a -> a -> Color3 a
forall a. a -> a -> a -> Color3 a
Color3 a
a a
a a
a
   Color3 f :: a -> b
f g :: a -> b
g h :: a -> b
h <*> :: Color3 (a -> b) -> Color3 a -> Color3 b
<*> Color3 x :: a
x y :: a
y z :: a
z = b -> b -> b -> Color3 b
forall a. a -> a -> a -> Color3 a
Color3 (a -> b
f a
x) (a -> b
g a
y) (a -> b
h a
z)

instance Foldable Color3 where
   foldr :: (a -> b -> b) -> b -> Color3 a -> b
foldr f :: a -> b -> b
f a :: b
a (Color3 x :: a
x y :: a
y z :: a
z) = a
x `f ` (a
y a -> b -> b
`f` (a
z a -> b -> b
`f` b
a))
   foldl :: (b -> a -> b) -> b -> Color3 a -> b
foldl f :: b -> a -> b
f a :: b
a (Color3 x :: a
x y :: a
y z :: a
z) = ((b
a b -> a -> b
`f` a
x) b -> a -> b
`f` a
y) b -> a -> b
`f` a
z
   foldr1 :: (a -> a -> a) -> Color3 a -> a
foldr1 f :: a -> a -> a
f (Color3 x :: a
x y :: a
y z :: a
z) = a
x a -> a -> a
`f` (a
y a -> a -> a
`f` a
z)
   foldl1 :: (a -> a -> a) -> Color3 a -> a
foldl1 f :: a -> a -> a
f (Color3 x :: a
x y :: a
y z :: a
z) = (a
x a -> a -> a
`f` a
y) a -> a -> a
`f` a
z

instance Traversable Color3 where
   traverse :: (a -> f b) -> Color3 a -> f (Color3 b)
traverse f :: a -> f b
f (Color3 x :: a
x y :: a
y z :: a
z) = (b -> b -> b -> Color3 b) -> f (b -> b -> b -> Color3 b)
forall (f :: * -> *) a. Applicative f => a -> f a
pure b -> b -> b -> Color3 b
forall a. a -> a -> a -> Color3 a
Color3 f (b -> b -> b -> Color3 b) -> f b -> f (b -> b -> Color3 b)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a -> f b
f a
x f (b -> b -> Color3 b) -> f b -> f (b -> Color3 b)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a -> f b
f a
y f (b -> Color3 b) -> f b -> f (Color3 b)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a -> f b
f a
z
   sequenceA :: Color3 (f a) -> f (Color3 a)
sequenceA (Color3 x :: f a
x y :: f a
y z :: f a
z) =  (a -> a -> a -> Color3 a) -> f (a -> a -> a -> Color3 a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure a -> a -> a -> Color3 a
forall a. a -> a -> a -> Color3 a
Color3 f (a -> a -> a -> Color3 a) -> f a -> f (a -> a -> Color3 a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> f a
x f (a -> a -> Color3 a) -> f a -> f (a -> Color3 a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> f a
y f (a -> Color3 a) -> f a -> f (Color3 a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> f a
z
   mapM :: (a -> m b) -> Color3 a -> m (Color3 b)
mapM f :: a -> m b
f (Color3 x :: a
x y :: a
y z :: a
z) = (b -> b -> b -> Color3 b) -> m (b -> b -> b -> Color3 b)
forall (m :: * -> *) a. Monad m => a -> m a
return b -> b -> b -> Color3 b
forall a. a -> a -> a -> Color3 a
Color3 m (b -> b -> b -> Color3 b) -> m b -> m (b -> b -> Color3 b)
forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
`ap` a -> m b
f a
x m (b -> b -> Color3 b) -> m b -> m (b -> Color3 b)
forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
`ap` a -> m b
f a
y m (b -> Color3 b) -> m b -> m (Color3 b)
forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
`ap` a -> m b
f a
z
   sequence :: Color3 (m a) -> m (Color3 a)
sequence (Color3 x :: m a
x y :: m a
y z :: m a
z) = (a -> a -> a -> Color3 a) -> m (a -> a -> a -> Color3 a)
forall (m :: * -> *) a. Monad m => a -> m a
return a -> a -> a -> Color3 a
forall a. a -> a -> a -> Color3 a
Color3 m (a -> a -> a -> Color3 a) -> m a -> m (a -> a -> Color3 a)
forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
`ap` m a
x m (a -> a -> Color3 a) -> m a -> m (a -> Color3 a)
forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
`ap` m a
y m (a -> Color3 a) -> m a -> m (Color3 a)
forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
`ap` m a
z

instance Storable a => Storable (Color3 a) where
   sizeOf :: Color3 a -> Int
sizeOf ~(Color3 x :: a
x _ _) = 3 Int -> Int -> Int
forall a. Num a => a -> a -> a
* a -> Int
forall a. Storable a => a -> Int
sizeOf a
x
   alignment :: Color3 a -> Int
alignment ~(Color3 x :: a
x _ _) = a -> Int
forall a. Storable a => a -> Int
alignment a
x
   peek :: Ptr (Color3 a) -> IO (Color3 a)
peek = Ptr (Color3 a) -> IO (Color3 a)
forall (t :: * -> *) a.
(Applicative t, Traversable t, Storable a) =>
Ptr (t a) -> IO (t a)
peekApplicativeTraversable
   poke :: Ptr (Color3 a) -> Color3 a -> IO ()
poke = Ptr (Color3 a) -> Color3 a -> IO ()
forall (t :: * -> *) a.
(Foldable t, Storable a) =>
Ptr (t a) -> t a -> IO ()
pokeFoldable

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

-- | A fully-fledged RGBA color.
data Color4 a = Color4 !a !a !a !a
   deriving (Color4 a -> Color4 a -> Bool
(Color4 a -> Color4 a -> Bool)
-> (Color4 a -> Color4 a -> Bool) -> Eq (Color4 a)
forall a. Eq a => Color4 a -> Color4 a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Color4 a -> Color4 a -> Bool
$c/= :: forall a. Eq a => Color4 a -> Color4 a -> Bool
== :: Color4 a -> Color4 a -> Bool
$c== :: forall a. Eq a => Color4 a -> Color4 a -> Bool
Eq, Eq (Color4 a)
Eq (Color4 a) =>
(Color4 a -> Color4 a -> Ordering)
-> (Color4 a -> Color4 a -> Bool)
-> (Color4 a -> Color4 a -> Bool)
-> (Color4 a -> Color4 a -> Bool)
-> (Color4 a -> Color4 a -> Bool)
-> (Color4 a -> Color4 a -> Color4 a)
-> (Color4 a -> Color4 a -> Color4 a)
-> Ord (Color4 a)
Color4 a -> Color4 a -> Bool
Color4 a -> Color4 a -> Ordering
Color4 a -> Color4 a -> Color4 a
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall a. Ord a => Eq (Color4 a)
forall a. Ord a => Color4 a -> Color4 a -> Bool
forall a. Ord a => Color4 a -> Color4 a -> Ordering
forall a. Ord a => Color4 a -> Color4 a -> Color4 a
min :: Color4 a -> Color4 a -> Color4 a
$cmin :: forall a. Ord a => Color4 a -> Color4 a -> Color4 a
max :: Color4 a -> Color4 a -> Color4 a
$cmax :: forall a. Ord a => Color4 a -> Color4 a -> Color4 a
>= :: Color4 a -> Color4 a -> Bool
$c>= :: forall a. Ord a => Color4 a -> Color4 a -> Bool
> :: Color4 a -> Color4 a -> Bool
$c> :: forall a. Ord a => Color4 a -> Color4 a -> Bool
<= :: Color4 a -> Color4 a -> Bool
$c<= :: forall a. Ord a => Color4 a -> Color4 a -> Bool
< :: Color4 a -> Color4 a -> Bool
$c< :: forall a. Ord a => Color4 a -> Color4 a -> Bool
compare :: Color4 a -> Color4 a -> Ordering
$ccompare :: forall a. Ord a => Color4 a -> Color4 a -> Ordering
$cp1Ord :: forall a. Ord a => Eq (Color4 a)
Ord, Ord (Color4 a)
Ord (Color4 a) =>
((Color4 a, Color4 a) -> [Color4 a])
-> ((Color4 a, Color4 a) -> Color4 a -> Int)
-> ((Color4 a, Color4 a) -> Color4 a -> Int)
-> ((Color4 a, Color4 a) -> Color4 a -> Bool)
-> ((Color4 a, Color4 a) -> Int)
-> ((Color4 a, Color4 a) -> Int)
-> Ix (Color4 a)
(Color4 a, Color4 a) -> Int
(Color4 a, Color4 a) -> [Color4 a]
(Color4 a, Color4 a) -> Color4 a -> Bool
(Color4 a, Color4 a) -> Color4 a -> Int
forall a.
Ord a =>
((a, a) -> [a])
-> ((a, a) -> a -> Int)
-> ((a, a) -> a -> Int)
-> ((a, a) -> a -> Bool)
-> ((a, a) -> Int)
-> ((a, a) -> Int)
-> Ix a
forall a. Ix a => Ord (Color4 a)
forall a. Ix a => (Color4 a, Color4 a) -> Int
forall a. Ix a => (Color4 a, Color4 a) -> [Color4 a]
forall a. Ix a => (Color4 a, Color4 a) -> Color4 a -> Bool
forall a. Ix a => (Color4 a, Color4 a) -> Color4 a -> Int
unsafeRangeSize :: (Color4 a, Color4 a) -> Int
$cunsafeRangeSize :: forall a. Ix a => (Color4 a, Color4 a) -> Int
rangeSize :: (Color4 a, Color4 a) -> Int
$crangeSize :: forall a. Ix a => (Color4 a, Color4 a) -> Int
inRange :: (Color4 a, Color4 a) -> Color4 a -> Bool
$cinRange :: forall a. Ix a => (Color4 a, Color4 a) -> Color4 a -> Bool
unsafeIndex :: (Color4 a, Color4 a) -> Color4 a -> Int
$cunsafeIndex :: forall a. Ix a => (Color4 a, Color4 a) -> Color4 a -> Int
index :: (Color4 a, Color4 a) -> Color4 a -> Int
$cindex :: forall a. Ix a => (Color4 a, Color4 a) -> Color4 a -> Int
range :: (Color4 a, Color4 a) -> [Color4 a]
$crange :: forall a. Ix a => (Color4 a, Color4 a) -> [Color4 a]
$cp1Ix :: forall a. Ix a => Ord (Color4 a)
Ix, Color4 a
Color4 a -> Color4 a -> Bounded (Color4 a)
forall a. a -> a -> Bounded a
forall a. Bounded a => Color4 a
maxBound :: Color4 a
$cmaxBound :: forall a. Bounded a => Color4 a
minBound :: Color4 a
$cminBound :: forall a. Bounded a => Color4 a
Bounded, Int -> Color4 a -> ShowS
[Color4 a] -> ShowS
Color4 a -> String
(Int -> Color4 a -> ShowS)
-> (Color4 a -> String) -> ([Color4 a] -> ShowS) -> Show (Color4 a)
forall a. Show a => Int -> Color4 a -> ShowS
forall a. Show a => [Color4 a] -> ShowS
forall a. Show a => Color4 a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Color4 a] -> ShowS
$cshowList :: forall a. Show a => [Color4 a] -> ShowS
show :: Color4 a -> String
$cshow :: forall a. Show a => Color4 a -> String
showsPrec :: Int -> Color4 a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> Color4 a -> ShowS
Show, ReadPrec [Color4 a]
ReadPrec (Color4 a)
Int -> ReadS (Color4 a)
ReadS [Color4 a]
(Int -> ReadS (Color4 a))
-> ReadS [Color4 a]
-> ReadPrec (Color4 a)
-> ReadPrec [Color4 a]
-> Read (Color4 a)
forall a. Read a => ReadPrec [Color4 a]
forall a. Read a => ReadPrec (Color4 a)
forall a. Read a => Int -> ReadS (Color4 a)
forall a. Read a => ReadS [Color4 a]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Color4 a]
$creadListPrec :: forall a. Read a => ReadPrec [Color4 a]
readPrec :: ReadPrec (Color4 a)
$creadPrec :: forall a. Read a => ReadPrec (Color4 a)
readList :: ReadS [Color4 a]
$creadList :: forall a. Read a => ReadS [Color4 a]
readsPrec :: Int -> ReadS (Color4 a)
$creadsPrec :: forall a. Read a => Int -> ReadS (Color4 a)
Read, Typeable)

instance Functor Color4 where
   fmap :: (a -> b) -> Color4 a -> Color4 b
fmap f :: a -> b
f (Color4 x :: a
x y :: a
y z :: a
z w :: a
w) = b -> b -> b -> b -> Color4 b
forall a. a -> a -> a -> a -> Color4 a
Color4 (a -> b
f a
x) (a -> b
f a
y) (a -> b
f a
z) (a -> b
f a
w)

instance Applicative Color4 where
   pure :: a -> Color4 a
pure a :: a
a = a -> a -> a -> a -> Color4 a
forall a. a -> a -> a -> a -> Color4 a
Color4 a
a a
a a
a a
a
   Color4 f :: a -> b
f g :: a -> b
g h :: a -> b
h i :: a -> b
i <*> :: Color4 (a -> b) -> Color4 a -> Color4 b
<*> Color4 x :: a
x y :: a
y z :: a
z w :: a
w = b -> b -> b -> b -> Color4 b
forall a. a -> a -> a -> a -> Color4 a
Color4 (a -> b
f a
x) (a -> b
g a
y) (a -> b
h a
z) (a -> b
i a
w)

instance Foldable Color4 where
   foldr :: (a -> b -> b) -> b -> Color4 a -> b
foldr f :: a -> b -> b
f a :: b
a (Color4 x :: a
x y :: a
y z :: a
z w :: a
w) = a
x `f ` (a
y a -> b -> b
`f` (a
z a -> b -> b
`f` (a
w a -> b -> b
`f` b
a)))
   foldl :: (b -> a -> b) -> b -> Color4 a -> b
foldl f :: b -> a -> b
f a :: b
a (Color4 x :: a
x y :: a
y z :: a
z w :: a
w) = (((b
a b -> a -> b
`f` a
x) b -> a -> b
`f` a
y) b -> a -> b
`f` a
z) b -> a -> b
`f` a
w
   foldr1 :: (a -> a -> a) -> Color4 a -> a
foldr1 f :: a -> a -> a
f (Color4 x :: a
x y :: a
y z :: a
z w :: a
w) = a
x a -> a -> a
`f` (a
y a -> a -> a
`f` (a
z a -> a -> a
`f` a
w))
   foldl1 :: (a -> a -> a) -> Color4 a -> a
foldl1 f :: a -> a -> a
f (Color4 x :: a
x y :: a
y z :: a
z w :: a
w) = ((a
x a -> a -> a
`f` a
y) a -> a -> a
`f` a
z) a -> a -> a
`f` a
w

instance Traversable Color4 where
   traverse :: (a -> f b) -> Color4 a -> f (Color4 b)
traverse f :: a -> f b
f (Color4 x :: a
x y :: a
y z :: a
z w :: a
w) = (b -> b -> b -> b -> Color4 b) -> f (b -> b -> b -> b -> Color4 b)
forall (f :: * -> *) a. Applicative f => a -> f a
pure b -> b -> b -> b -> Color4 b
forall a. a -> a -> a -> a -> Color4 a
Color4 f (b -> b -> b -> b -> Color4 b)
-> f b -> f (b -> b -> b -> Color4 b)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a -> f b
f a
x f (b -> b -> b -> Color4 b) -> f b -> f (b -> b -> Color4 b)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a -> f b
f a
y f (b -> b -> Color4 b) -> f b -> f (b -> Color4 b)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a -> f b
f a
z f (b -> Color4 b) -> f b -> f (Color4 b)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a -> f b
f a
w
   sequenceA :: Color4 (f a) -> f (Color4 a)
sequenceA (Color4 x :: f a
x y :: f a
y z :: f a
z w :: f a
w) =  (a -> a -> a -> a -> Color4 a) -> f (a -> a -> a -> a -> Color4 a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure a -> a -> a -> a -> Color4 a
forall a. a -> a -> a -> a -> Color4 a
Color4 f (a -> a -> a -> a -> Color4 a)
-> f a -> f (a -> a -> a -> Color4 a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> f a
x f (a -> a -> a -> Color4 a) -> f a -> f (a -> a -> Color4 a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> f a
y f (a -> a -> Color4 a) -> f a -> f (a -> Color4 a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> f a
z f (a -> Color4 a) -> f a -> f (Color4 a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> f a
w
   mapM :: (a -> m b) -> Color4 a -> m (Color4 b)
mapM f :: a -> m b
f (Color4 x :: a
x y :: a
y z :: a
z w :: a
w) = (b -> b -> b -> b -> Color4 b) -> m (b -> b -> b -> b -> Color4 b)
forall (m :: * -> *) a. Monad m => a -> m a
return b -> b -> b -> b -> Color4 b
forall a. a -> a -> a -> a -> Color4 a
Color4 m (b -> b -> b -> b -> Color4 b)
-> m b -> m (b -> b -> b -> Color4 b)
forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
`ap` a -> m b
f a
x m (b -> b -> b -> Color4 b) -> m b -> m (b -> b -> Color4 b)
forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
`ap` a -> m b
f a
y m (b -> b -> Color4 b) -> m b -> m (b -> Color4 b)
forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
`ap` a -> m b
f a
z m (b -> Color4 b) -> m b -> m (Color4 b)
forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
`ap` a -> m b
f a
w
   sequence :: Color4 (m a) -> m (Color4 a)
sequence (Color4 x :: m a
x y :: m a
y z :: m a
z w :: m a
w) = (a -> a -> a -> a -> Color4 a) -> m (a -> a -> a -> a -> Color4 a)
forall (m :: * -> *) a. Monad m => a -> m a
return a -> a -> a -> a -> Color4 a
forall a. a -> a -> a -> a -> Color4 a
Color4 m (a -> a -> a -> a -> Color4 a)
-> m a -> m (a -> a -> a -> Color4 a)
forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
`ap` m a
x m (a -> a -> a -> Color4 a) -> m a -> m (a -> a -> Color4 a)
forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
`ap` m a
y m (a -> a -> Color4 a) -> m a -> m (a -> Color4 a)
forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
`ap` m a
z m (a -> Color4 a) -> m a -> m (Color4 a)
forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
`ap` m a
w

instance Storable a => Storable (Color4 a) where
   sizeOf :: Color4 a -> Int
sizeOf ~(Color4 x :: a
x _ _ _) = 4 Int -> Int -> Int
forall a. Num a => a -> a -> a
* a -> Int
forall a. Storable a => a -> Int
sizeOf a
x
   alignment :: Color4 a -> Int
alignment ~(Color4 x :: a
x _ _ _) = a -> Int
forall a. Storable a => a -> Int
alignment a
x
   peek :: Ptr (Color4 a) -> IO (Color4 a)
peek = Ptr (Color4 a) -> IO (Color4 a)
forall (t :: * -> *) a.
(Applicative t, Traversable t, Storable a) =>
Ptr (t a) -> IO (t a)
peekApplicativeTraversable
   poke :: Ptr (Color4 a) -> Color4 a -> IO ()
poke = Ptr (Color4 a) -> Color4 a -> IO ()
forall (t :: * -> *) a.
(Foldable t, Storable a) =>
Ptr (t a) -> t a -> IO ()
pokeFoldable

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

-- | A color index.
newtype Index1 a = Index1 a
   deriving (Index1 a -> Index1 a -> Bool
(Index1 a -> Index1 a -> Bool)
-> (Index1 a -> Index1 a -> Bool) -> Eq (Index1 a)
forall a. Eq a => Index1 a -> Index1 a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Index1 a -> Index1 a -> Bool
$c/= :: forall a. Eq a => Index1 a -> Index1 a -> Bool
== :: Index1 a -> Index1 a -> Bool
$c== :: forall a. Eq a => Index1 a -> Index1 a -> Bool
Eq, Eq (Index1 a)
Eq (Index1 a) =>
(Index1 a -> Index1 a -> Ordering)
-> (Index1 a -> Index1 a -> Bool)
-> (Index1 a -> Index1 a -> Bool)
-> (Index1 a -> Index1 a -> Bool)
-> (Index1 a -> Index1 a -> Bool)
-> (Index1 a -> Index1 a -> Index1 a)
-> (Index1 a -> Index1 a -> Index1 a)
-> Ord (Index1 a)
Index1 a -> Index1 a -> Bool
Index1 a -> Index1 a -> Ordering
Index1 a -> Index1 a -> Index1 a
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall a. Ord a => Eq (Index1 a)
forall a. Ord a => Index1 a -> Index1 a -> Bool
forall a. Ord a => Index1 a -> Index1 a -> Ordering
forall a. Ord a => Index1 a -> Index1 a -> Index1 a
min :: Index1 a -> Index1 a -> Index1 a
$cmin :: forall a. Ord a => Index1 a -> Index1 a -> Index1 a
max :: Index1 a -> Index1 a -> Index1 a
$cmax :: forall a. Ord a => Index1 a -> Index1 a -> Index1 a
>= :: Index1 a -> Index1 a -> Bool
$c>= :: forall a. Ord a => Index1 a -> Index1 a -> Bool
> :: Index1 a -> Index1 a -> Bool
$c> :: forall a. Ord a => Index1 a -> Index1 a -> Bool
<= :: Index1 a -> Index1 a -> Bool
$c<= :: forall a. Ord a => Index1 a -> Index1 a -> Bool
< :: Index1 a -> Index1 a -> Bool
$c< :: forall a. Ord a => Index1 a -> Index1 a -> Bool
compare :: Index1 a -> Index1 a -> Ordering
$ccompare :: forall a. Ord a => Index1 a -> Index1 a -> Ordering
$cp1Ord :: forall a. Ord a => Eq (Index1 a)
Ord, Ord (Index1 a)
Ord (Index1 a) =>
((Index1 a, Index1 a) -> [Index1 a])
-> ((Index1 a, Index1 a) -> Index1 a -> Int)
-> ((Index1 a, Index1 a) -> Index1 a -> Int)
-> ((Index1 a, Index1 a) -> Index1 a -> Bool)
-> ((Index1 a, Index1 a) -> Int)
-> ((Index1 a, Index1 a) -> Int)
-> Ix (Index1 a)
(Index1 a, Index1 a) -> Int
(Index1 a, Index1 a) -> [Index1 a]
(Index1 a, Index1 a) -> Index1 a -> Bool
(Index1 a, Index1 a) -> Index1 a -> Int
forall a.
Ord a =>
((a, a) -> [a])
-> ((a, a) -> a -> Int)
-> ((a, a) -> a -> Int)
-> ((a, a) -> a -> Bool)
-> ((a, a) -> Int)
-> ((a, a) -> Int)
-> Ix a
forall a. Ix a => Ord (Index1 a)
forall a. Ix a => (Index1 a, Index1 a) -> Int
forall a. Ix a => (Index1 a, Index1 a) -> [Index1 a]
forall a. Ix a => (Index1 a, Index1 a) -> Index1 a -> Bool
forall a. Ix a => (Index1 a, Index1 a) -> Index1 a -> Int
unsafeRangeSize :: (Index1 a, Index1 a) -> Int
$cunsafeRangeSize :: forall a. Ix a => (Index1 a, Index1 a) -> Int
rangeSize :: (Index1 a, Index1 a) -> Int
$crangeSize :: forall a. Ix a => (Index1 a, Index1 a) -> Int
inRange :: (Index1 a, Index1 a) -> Index1 a -> Bool
$cinRange :: forall a. Ix a => (Index1 a, Index1 a) -> Index1 a -> Bool
unsafeIndex :: (Index1 a, Index1 a) -> Index1 a -> Int
$cunsafeIndex :: forall a. Ix a => (Index1 a, Index1 a) -> Index1 a -> Int
index :: (Index1 a, Index1 a) -> Index1 a -> Int
$cindex :: forall a. Ix a => (Index1 a, Index1 a) -> Index1 a -> Int
range :: (Index1 a, Index1 a) -> [Index1 a]
$crange :: forall a. Ix a => (Index1 a, Index1 a) -> [Index1 a]
$cp1Ix :: forall a. Ix a => Ord (Index1 a)
Ix, Index1 a
Index1 a -> Index1 a -> Bounded (Index1 a)
forall a. a -> a -> Bounded a
forall a. Bounded a => Index1 a
maxBound :: Index1 a
$cmaxBound :: forall a. Bounded a => Index1 a
minBound :: Index1 a
$cminBound :: forall a. Bounded a => Index1 a
Bounded, Int -> Index1 a -> ShowS
[Index1 a] -> ShowS
Index1 a -> String
(Int -> Index1 a -> ShowS)
-> (Index1 a -> String) -> ([Index1 a] -> ShowS) -> Show (Index1 a)
forall a. Show a => Int -> Index1 a -> ShowS
forall a. Show a => [Index1 a] -> ShowS
forall a. Show a => Index1 a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Index1 a] -> ShowS
$cshowList :: forall a. Show a => [Index1 a] -> ShowS
show :: Index1 a -> String
$cshow :: forall a. Show a => Index1 a -> String
showsPrec :: Int -> Index1 a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> Index1 a -> ShowS
Show, ReadPrec [Index1 a]
ReadPrec (Index1 a)
Int -> ReadS (Index1 a)
ReadS [Index1 a]
(Int -> ReadS (Index1 a))
-> ReadS [Index1 a]
-> ReadPrec (Index1 a)
-> ReadPrec [Index1 a]
-> Read (Index1 a)
forall a. Read a => ReadPrec [Index1 a]
forall a. Read a => ReadPrec (Index1 a)
forall a. Read a => Int -> ReadS (Index1 a)
forall a. Read a => ReadS [Index1 a]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Index1 a]
$creadListPrec :: forall a. Read a => ReadPrec [Index1 a]
readPrec :: ReadPrec (Index1 a)
$creadPrec :: forall a. Read a => ReadPrec (Index1 a)
readList :: ReadS [Index1 a]
$creadList :: forall a. Read a => ReadS [Index1 a]
readsPrec :: Int -> ReadS (Index1 a)
$creadsPrec :: forall a. Read a => Int -> ReadS (Index1 a)
Read, Typeable)

instance Functor Index1 where
   fmap :: (a -> b) -> Index1 a -> Index1 b
fmap f :: a -> b
f (Index1 x :: a
x) = b -> Index1 b
forall a. a -> Index1 a
Index1 (a -> b
f a
x)

instance Applicative Index1 where
   pure :: a -> Index1 a
pure a :: a
a = a -> Index1 a
forall a. a -> Index1 a
Index1 a
a
   Index1 f :: a -> b
f <*> :: Index1 (a -> b) -> Index1 a -> Index1 b
<*> Index1 x :: a
x = b -> Index1 b
forall a. a -> Index1 a
Index1 (a -> b
f a
x)

instance Foldable Index1 where
   foldr :: (a -> b -> b) -> b -> Index1 a -> b
foldr f :: a -> b -> b
f a :: b
a (Index1 x :: a
x) = a
x `f ` b
a
   foldl :: (b -> a -> b) -> b -> Index1 a -> b
foldl f :: b -> a -> b
f a :: b
a (Index1 x :: a
x)  = b
a b -> a -> b
`f` a
x
   foldr1 :: (a -> a -> a) -> Index1 a -> a
foldr1 _ (Index1 x :: a
x) = a
x
   foldl1 :: (a -> a -> a) -> Index1 a -> a
foldl1 _ (Index1 x :: a
x) = a
x

instance Traversable Index1 where
   traverse :: (a -> f b) -> Index1 a -> f (Index1 b)
traverse f :: a -> f b
f (Index1 x :: a
x) = (b -> Index1 b) -> f (b -> Index1 b)
forall (f :: * -> *) a. Applicative f => a -> f a
pure b -> Index1 b
forall a. a -> Index1 a
Index1 f (b -> Index1 b) -> f b -> f (Index1 b)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a -> f b
f a
x
   sequenceA :: Index1 (f a) -> f (Index1 a)
sequenceA (Index1 x :: f a
x) =  (a -> Index1 a) -> f (a -> Index1 a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure a -> Index1 a
forall a. a -> Index1 a
Index1 f (a -> Index1 a) -> f a -> f (Index1 a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> f a
x
   mapM :: (a -> m b) -> Index1 a -> m (Index1 b)
mapM f :: a -> m b
f (Index1 x :: a
x) = (b -> Index1 b) -> m (b -> Index1 b)
forall (m :: * -> *) a. Monad m => a -> m a
return b -> Index1 b
forall a. a -> Index1 a
Index1 m (b -> Index1 b) -> m b -> m (Index1 b)
forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
`ap` a -> m b
f a
x
   sequence :: Index1 (m a) -> m (Index1 a)
sequence (Index1 x :: m a
x) = (a -> Index1 a) -> m (a -> Index1 a)
forall (m :: * -> *) a. Monad m => a -> m a
return a -> Index1 a
forall a. a -> Index1 a
Index1 m (a -> Index1 a) -> m a -> m (Index1 a)
forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
`ap` m a
x

instance Storable a => Storable (Index1 a) where
   sizeOf :: Index1 a -> Int
sizeOf    ~(Index1 s :: a
s) = a -> Int
forall a. Storable a => a -> Int
sizeOf a
s
   alignment :: Index1 a -> Int
alignment ~(Index1 s :: a
s) = a -> Int
forall a. Storable a => a -> Int
alignment a
s
   peek :: Ptr (Index1 a) -> IO (Index1 a)
peek = Ptr (Index1 a) -> IO (Index1 a)
forall (t :: * -> *) a.
(Applicative t, Traversable t, Storable a) =>
Ptr (t a) -> IO (t a)
peekApplicativeTraversable
   poke :: Ptr (Index1 a) -> Index1 a -> IO ()
poke = Ptr (Index1 a) -> Index1 a -> IO ()
forall (t :: * -> *) a.
(Foldable t, Storable a) =>
Ptr (t a) -> t a -> IO ()
pokeFoldable

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

peekApplicativeTraversable :: (Applicative t, Traversable t, Storable a) => Ptr (t a) -> IO (t a)
peekApplicativeTraversable :: Ptr (t a) -> IO (t a)
peekApplicativeTraversable = (Ptr a -> IO a) -> t (Ptr a) -> IO (t a)
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
Data.Traversable.mapM Ptr a -> IO a
forall a. Storable a => Ptr a -> IO a
peek (t (Ptr a) -> IO (t a))
-> (Ptr (t a) -> t (Ptr a)) -> Ptr (t a) -> IO (t a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Ptr (t a) -> t (Ptr a)
forall (t :: * -> *) a.
(Applicative t, Traversable t, Storable a) =>
Ptr (t a) -> t (Ptr a)
addresses

addresses :: (Applicative t, Traversable t, Storable a) => Ptr (t a) -> t (Ptr a)
addresses :: Ptr (t a) -> t (Ptr a)
addresses = (Int, t (Ptr a)) -> t (Ptr a)
forall a b. (a, b) -> b
snd ((Int, t (Ptr a)) -> t (Ptr a))
-> (Ptr (t a) -> (Int, t (Ptr a))) -> Ptr (t a) -> t (Ptr a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Int -> Ptr a -> (Int, Ptr a))
-> Int -> t (Ptr a) -> (Int, t (Ptr a))
forall (t :: * -> *) a b c.
Traversable t =>
(a -> b -> (a, c)) -> a -> t b -> (a, t c)
mapAccumL Int -> Ptr a -> (Int, Ptr a)
forall a. Storable a => Int -> Ptr a -> (Int, Ptr a)
nextPtr 0 (t (Ptr a) -> (Int, t (Ptr a)))
-> (Ptr (t a) -> t (Ptr a)) -> Ptr (t a) -> (Int, t (Ptr a))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Ptr a -> t (Ptr a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Ptr a -> t (Ptr a))
-> (Ptr (t a) -> Ptr a) -> Ptr (t a) -> t (Ptr a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Ptr (t a) -> Ptr a
forall a b. Ptr a -> Ptr b
castPtr

nextPtr :: Storable a => Int -> Ptr a -> (Int, Ptr a)
nextPtr :: Int -> Ptr a -> (Int, Ptr a)
nextPtr offset :: Int
offset ptr :: Ptr a
ptr = (Int
offset Int -> Int -> Int
forall a. Num a => a -> a -> a
+ 1, Ptr a -> Int -> Ptr a
forall a. Storable a => Ptr a -> Int -> Ptr a
advancePtr Ptr a
ptr Int
offset)

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

pokeFoldable :: (Foldable t, Storable a) => Ptr (t a) -> t a -> IO ()
pokeFoldable :: Ptr (t a) -> t a -> IO ()
pokeFoldable ptr :: Ptr (t a)
ptr xs :: t a
xs = (Ptr a -> a -> IO (Ptr a)) -> Ptr a -> t a -> IO (Ptr a)
forall (t :: * -> *) (m :: * -> *) b a.
(Foldable t, Monad m) =>
(b -> a -> m b) -> b -> t a -> m b
foldlM Ptr a -> a -> IO (Ptr a)
forall a. Storable a => Ptr a -> a -> IO (Ptr a)
pokeAndAdvance (Ptr (t a) -> Ptr a
forall a b. Ptr a -> Ptr b
castPtr Ptr (t a)
ptr) t a
xs IO (Ptr a) -> IO () -> IO ()
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

pokeAndAdvance :: Storable a => Ptr a -> a -> IO (Ptr a)
pokeAndAdvance :: Ptr a -> a -> IO (Ptr a)
pokeAndAdvance ptr :: Ptr a
ptr value :: a
value = do
   Ptr a -> a -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke Ptr a
ptr a
value
   Ptr a -> IO (Ptr a)
forall (m :: * -> *) a. Monad m => a -> m a
return (Ptr a -> IO (Ptr a)) -> Ptr a -> IO (Ptr a)
forall a b. (a -> b) -> a -> b
$ Ptr a
ptr Ptr a -> Int -> Ptr a
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` a -> Int
forall a. Storable a => a -> Int
sizeOf a
value