{-# 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
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, 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
Ord, (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]
Ix, 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
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)
ReadS [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 :: forall a b. (a -> b) -> TexCoord1 a -> TexCoord1 b
fmap a -> b
f (TexCoord1 a
x) = forall a. a -> TexCoord1 a
TexCoord1 (a -> b
f a
x)

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

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

instance Traversable TexCoord1 where
   traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> TexCoord1 a -> f (TexCoord1 b)
traverse a -> f b
f (TexCoord1 a
x) = forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a. a -> TexCoord1 a
TexCoord1 forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a -> f b
f a
x
   sequenceA :: forall (f :: * -> *) a.
Applicative f =>
TexCoord1 (f a) -> f (TexCoord1 a)
sequenceA (TexCoord1 f a
x) =  forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a. a -> TexCoord1 a
TexCoord1 forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> f a
x
   mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> TexCoord1 a -> m (TexCoord1 b)
mapM a -> m b
f (TexCoord1 a
x) = forall (m :: * -> *) a. Monad m => a -> m a
return forall a. a -> TexCoord1 a
TexCoord1 forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
`ap` a -> m b
f a
x
   sequence :: forall (m :: * -> *) a.
Monad m =>
TexCoord1 (m a) -> m (TexCoord1 a)
sequence (TexCoord1 m a
x) = forall (m :: * -> *) a. Monad m => a -> m a
return forall a. a -> TexCoord1 a
TexCoord1 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 a
s) = forall a. Storable a => a -> Int
sizeOf a
s
   alignment :: TexCoord1 a -> Int
alignment ~(TexCoord1 a
s) = forall a. Storable a => a -> Int
alignment a
s
   peek :: Ptr (TexCoord1 a) -> IO (TexCoord1 a)
peek = forall (t :: * -> *) a.
(Applicative t, Traversable t, Storable a) =>
Ptr (t a) -> IO (t a)
peekApplicativeTraversable
   poke :: Ptr (TexCoord1 a) -> TexCoord1 a -> IO ()
poke = 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
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, TexCoord2 a -> TexCoord2 a -> Bool
TexCoord2 a -> TexCoord2 a -> Ordering
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
Ord, (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]
Ix, 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
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)
ReadS [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 :: forall a b. (a -> b) -> TexCoord2 a -> TexCoord2 b
fmap a -> b
f (TexCoord2 a
x a
y) = forall a. a -> a -> TexCoord2 a
TexCoord2 (a -> b
f a
x) (a -> b
f a
y)

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

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

instance Traversable TexCoord2 where
   traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> TexCoord2 a -> f (TexCoord2 b)
traverse a -> f b
f (TexCoord2 a
x a
y) = forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a. a -> a -> TexCoord2 a
TexCoord2 forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a -> f b
f a
x forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a -> f b
f a
y
   sequenceA :: forall (f :: * -> *) a.
Applicative f =>
TexCoord2 (f a) -> f (TexCoord2 a)
sequenceA (TexCoord2 f a
x f a
y) =  forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a. a -> a -> TexCoord2 a
TexCoord2 forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> f a
x forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> f a
y
   mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> TexCoord2 a -> m (TexCoord2 b)
mapM a -> m b
f (TexCoord2 a
x a
y) = forall (m :: * -> *) a. Monad m => a -> m a
return forall a. a -> a -> TexCoord2 a
TexCoord2 forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
`ap` a -> m b
f a
x forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
`ap` a -> m b
f a
y
   sequence :: forall (m :: * -> *) a.
Monad m =>
TexCoord2 (m a) -> m (TexCoord2 a)
sequence (TexCoord2 m a
x m a
y) = forall (m :: * -> *) a. Monad m => a -> m a
return forall a. a -> a -> TexCoord2 a
TexCoord2 forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
`ap` m a
x 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 a
x a
_) = Int
2 forall a. Num a => a -> a -> a
* forall a. Storable a => a -> Int
sizeOf a
x
   alignment :: TexCoord2 a -> Int
alignment ~(TexCoord2 a
x a
_) = forall a. Storable a => a -> Int
alignment a
x
   peek :: Ptr (TexCoord2 a) -> IO (TexCoord2 a)
peek = forall (t :: * -> *) a.
(Applicative t, Traversable t, Storable a) =>
Ptr (t a) -> IO (t a)
peekApplicativeTraversable
   poke :: Ptr (TexCoord2 a) -> TexCoord2 a -> IO ()
poke = 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
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, TexCoord3 a -> TexCoord3 a -> Bool
TexCoord3 a -> TexCoord3 a -> Ordering
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
Ord, (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]
Ix, 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
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)
ReadS [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 :: forall a b. (a -> b) -> TexCoord3 a -> TexCoord3 b
fmap a -> b
f (TexCoord3 a
x a
y a
z) = 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 :: forall a. a -> TexCoord3 a
pure a
a = forall a. a -> a -> a -> TexCoord3 a
TexCoord3 a
a a
a a
a
   TexCoord3 a -> b
f a -> b
g a -> b
h <*> :: forall a b. TexCoord3 (a -> b) -> TexCoord3 a -> TexCoord3 b
<*> TexCoord3 a
x a
y a
z = 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 :: forall a b. (a -> b -> b) -> b -> TexCoord3 a -> b
foldr a -> b -> b
f b
a (TexCoord3 a
x a
y a
z) = a
x `f ` (a
y a -> b -> b
`f` (a
z a -> b -> b
`f` b
a))
   foldl :: forall b a. (b -> a -> b) -> b -> TexCoord3 a -> b
foldl b -> a -> b
f b
a (TexCoord3 a
x a
y a
z) = ((b
a b -> a -> b
`f` a
x) b -> a -> b
`f` a
y) b -> a -> b
`f` a
z
   foldr1 :: forall a. (a -> a -> a) -> TexCoord3 a -> a
foldr1 a -> a -> a
f (TexCoord3 a
x a
y a
z) = a
x a -> a -> a
`f` (a
y a -> a -> a
`f` a
z)
   foldl1 :: forall a. (a -> a -> a) -> TexCoord3 a -> a
foldl1 a -> a -> a
f (TexCoord3 a
x a
y a
z) = (a
x a -> a -> a
`f` a
y) a -> a -> a
`f` a
z

instance Traversable TexCoord3 where
   traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> TexCoord3 a -> f (TexCoord3 b)
traverse a -> f b
f (TexCoord3 a
x a
y a
z) = forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a. a -> a -> a -> TexCoord3 a
TexCoord3 forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a -> f b
f a
x forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a -> f b
f a
y forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a -> f b
f a
z
   sequenceA :: forall (f :: * -> *) a.
Applicative f =>
TexCoord3 (f a) -> f (TexCoord3 a)
sequenceA (TexCoord3 f a
x f a
y f a
z) =  forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a. a -> a -> a -> TexCoord3 a
TexCoord3 forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> f a
x forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> f a
y forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> f a
z
   mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> TexCoord3 a -> m (TexCoord3 b)
mapM a -> m b
f (TexCoord3 a
x a
y a
z) = forall (m :: * -> *) a. Monad m => a -> m a
return forall a. a -> a -> a -> TexCoord3 a
TexCoord3 forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
`ap` a -> m b
f a
x forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
`ap` a -> m b
f a
y forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
`ap` a -> m b
f a
z
   sequence :: forall (m :: * -> *) a.
Monad m =>
TexCoord3 (m a) -> m (TexCoord3 a)
sequence (TexCoord3 m a
x m a
y m a
z) = forall (m :: * -> *) a. Monad m => a -> m a
return forall a. a -> a -> a -> TexCoord3 a
TexCoord3 forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
`ap` m a
x forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
`ap` m a
y 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 a
x a
_ a
_) = Int
3 forall a. Num a => a -> a -> a
* forall a. Storable a => a -> Int
sizeOf a
x
   alignment :: TexCoord3 a -> Int
alignment ~(TexCoord3 a
x a
_ a
_) = forall a. Storable a => a -> Int
alignment a
x
   peek :: Ptr (TexCoord3 a) -> IO (TexCoord3 a)
peek = forall (t :: * -> *) a.
(Applicative t, Traversable t, Storable a) =>
Ptr (t a) -> IO (t a)
peekApplicativeTraversable
   poke :: Ptr (TexCoord3 a) -> TexCoord3 a -> IO ()
poke = 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
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, TexCoord4 a -> TexCoord4 a -> Bool
TexCoord4 a -> TexCoord4 a -> Ordering
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
Ord, (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]
Ix, 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
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)
ReadS [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 :: forall a b. (a -> b) -> TexCoord4 a -> TexCoord4 b
fmap a -> b
f (TexCoord4 a
x a
y a
z a
w) = 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 :: forall a. a -> TexCoord4 a
pure a
a = forall a. a -> a -> a -> a -> TexCoord4 a
TexCoord4 a
a a
a a
a a
a
   TexCoord4 a -> b
f a -> b
g a -> b
h a -> b
i <*> :: forall a b. TexCoord4 (a -> b) -> TexCoord4 a -> TexCoord4 b
<*> TexCoord4 a
x a
y a
z a
w = 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 :: forall a b. (a -> b -> b) -> b -> TexCoord4 a -> b
foldr a -> b -> b
f b
a (TexCoord4 a
x a
y a
z 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 :: forall b a. (b -> a -> b) -> b -> TexCoord4 a -> b
foldl b -> a -> b
f b
a (TexCoord4 a
x a
y a
z 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 :: forall a. (a -> a -> a) -> TexCoord4 a -> a
foldr1 a -> a -> a
f (TexCoord4 a
x a
y a
z a
w) = a
x a -> a -> a
`f` (a
y a -> a -> a
`f` (a
z a -> a -> a
`f` a
w))
   foldl1 :: forall a. (a -> a -> a) -> TexCoord4 a -> a
foldl1 a -> a -> a
f (TexCoord4 a
x a
y a
z 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 :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> TexCoord4 a -> f (TexCoord4 b)
traverse a -> f b
f (TexCoord4 a
x a
y a
z a
w) = forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a. a -> a -> a -> a -> TexCoord4 a
TexCoord4 forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a -> f b
f a
x forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a -> f b
f a
y forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a -> f b
f a
z forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a -> f b
f a
w
   sequenceA :: forall (f :: * -> *) a.
Applicative f =>
TexCoord4 (f a) -> f (TexCoord4 a)
sequenceA (TexCoord4 f a
x f a
y f a
z f a
w) =  forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a. a -> a -> a -> a -> TexCoord4 a
TexCoord4 forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> f a
x forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> f a
y forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> f a
z forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> f a
w
   mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> TexCoord4 a -> m (TexCoord4 b)
mapM a -> m b
f (TexCoord4 a
x a
y a
z a
w) = forall (m :: * -> *) a. Monad m => a -> m a
return forall a. a -> a -> a -> a -> TexCoord4 a
TexCoord4 forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
`ap` a -> m b
f a
x forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
`ap` a -> m b
f a
y forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
`ap` a -> m b
f a
z forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
`ap` a -> m b
f a
w
   sequence :: forall (m :: * -> *) a.
Monad m =>
TexCoord4 (m a) -> m (TexCoord4 a)
sequence (TexCoord4 m a
x m a
y m a
z m a
w) = forall (m :: * -> *) a. Monad m => a -> m a
return forall a. a -> a -> a -> a -> TexCoord4 a
TexCoord4 forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
`ap` m a
x forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
`ap` m a
y forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
`ap` m a
z 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 a
x a
_ a
_ a
_) = Int
4 forall a. Num a => a -> a -> a
* forall a. Storable a => a -> Int
sizeOf a
x
   alignment :: TexCoord4 a -> Int
alignment ~(TexCoord4 a
x a
_ a
_ a
_) = forall a. Storable a => a -> Int
alignment a
x
   peek :: Ptr (TexCoord4 a) -> IO (TexCoord4 a)
peek = forall (t :: * -> *) a.
(Applicative t, Traversable t, Storable a) =>
Ptr (t a) -> IO (t a)
peekApplicativeTraversable
   poke :: Ptr (TexCoord4 a) -> TexCoord4 a -> IO ()
poke = 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
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, Normal3 a -> Normal3 a -> Bool
Normal3 a -> Normal3 a -> Ordering
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
Ord, (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]
Ix, 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
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)
ReadS [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 :: forall a b. (a -> b) -> Normal3 a -> Normal3 b
fmap a -> b
f (Normal3 a
x a
y a
z) = 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 :: forall a. a -> Normal3 a
pure a
a = forall a. a -> a -> a -> Normal3 a
Normal3 a
a a
a a
a
   Normal3 a -> b
f a -> b
g a -> b
h <*> :: forall a b. Normal3 (a -> b) -> Normal3 a -> Normal3 b
<*> Normal3 a
x a
y a
z = 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 :: forall a b. (a -> b -> b) -> b -> Normal3 a -> b
foldr a -> b -> b
f b
a (Normal3 a
x a
y a
z) = a
x `f ` (a
y a -> b -> b
`f` (a
z a -> b -> b
`f` b
a))
   foldl :: forall b a. (b -> a -> b) -> b -> Normal3 a -> b
foldl b -> a -> b
f b
a (Normal3 a
x a
y a
z) = ((b
a b -> a -> b
`f` a
x) b -> a -> b
`f` a
y) b -> a -> b
`f` a
z
   foldr1 :: forall a. (a -> a -> a) -> Normal3 a -> a
foldr1 a -> a -> a
f (Normal3 a
x a
y a
z) = a
x a -> a -> a
`f` (a
y a -> a -> a
`f` a
z)
   foldl1 :: forall a. (a -> a -> a) -> Normal3 a -> a
foldl1 a -> a -> a
f (Normal3 a
x a
y a
z) = (a
x a -> a -> a
`f` a
y) a -> a -> a
`f` a
z

instance Traversable Normal3 where
   traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Normal3 a -> f (Normal3 b)
traverse a -> f b
f (Normal3 a
x a
y a
z) = forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a. a -> a -> a -> Normal3 a
Normal3 forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a -> f b
f a
x forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a -> f b
f a
y forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a -> f b
f a
z
   sequenceA :: forall (f :: * -> *) a.
Applicative f =>
Normal3 (f a) -> f (Normal3 a)
sequenceA (Normal3 f a
x f a
y f a
z) =  forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a. a -> a -> a -> Normal3 a
Normal3 forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> f a
x forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> f a
y forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> f a
z
   mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Normal3 a -> m (Normal3 b)
mapM a -> m b
f (Normal3 a
x a
y a
z) = forall (m :: * -> *) a. Monad m => a -> m a
return forall a. a -> a -> a -> Normal3 a
Normal3 forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
`ap` a -> m b
f a
x forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
`ap` a -> m b
f a
y forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
`ap` a -> m b
f a
z
   sequence :: forall (m :: * -> *) a. Monad m => Normal3 (m a) -> m (Normal3 a)
sequence (Normal3 m a
x m a
y m a
z) = forall (m :: * -> *) a. Monad m => a -> m a
return forall a. a -> a -> a -> Normal3 a
Normal3 forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
`ap` m a
x forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
`ap` m a
y 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 a
x a
_ a
_) = Int
3 forall a. Num a => a -> a -> a
* forall a. Storable a => a -> Int
sizeOf a
x
   alignment :: Normal3 a -> Int
alignment ~(Normal3 a
x a
_ a
_) = forall a. Storable a => a -> Int
alignment a
x
   peek :: Ptr (Normal3 a) -> IO (Normal3 a)
peek = forall (t :: * -> *) a.
(Applicative t, Traversable t, Storable a) =>
Ptr (t a) -> IO (t a)
peekApplicativeTraversable
   poke :: Ptr (Normal3 a) -> Normal3 a -> IO ()
poke = 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
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, 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
Ord, (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]
Ix, 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
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)
ReadS [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 :: forall a b. (a -> b) -> FogCoord1 a -> FogCoord1 b
fmap a -> b
f (FogCoord1 a
x) = forall a. a -> FogCoord1 a
FogCoord1 (a -> b
f a
x)

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

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

instance Traversable FogCoord1 where
   traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> FogCoord1 a -> f (FogCoord1 b)
traverse a -> f b
f (FogCoord1 a
x) = forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a. a -> FogCoord1 a
FogCoord1 forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a -> f b
f a
x
   sequenceA :: forall (f :: * -> *) a.
Applicative f =>
FogCoord1 (f a) -> f (FogCoord1 a)
sequenceA (FogCoord1 f a
x) =  forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a. a -> FogCoord1 a
FogCoord1 forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> f a
x
   mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> FogCoord1 a -> m (FogCoord1 b)
mapM a -> m b
f (FogCoord1 a
x) = forall (m :: * -> *) a. Monad m => a -> m a
return forall a. a -> FogCoord1 a
FogCoord1 forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
`ap` a -> m b
f a
x
   sequence :: forall (m :: * -> *) a.
Monad m =>
FogCoord1 (m a) -> m (FogCoord1 a)
sequence (FogCoord1 m a
x) = forall (m :: * -> *) a. Monad m => a -> m a
return forall a. a -> FogCoord1 a
FogCoord1 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 a
s) = forall a. Storable a => a -> Int
sizeOf a
s
   alignment :: FogCoord1 a -> Int
alignment ~(FogCoord1 a
s) = forall a. Storable a => a -> Int
alignment a
s
   peek :: Ptr (FogCoord1 a) -> IO (FogCoord1 a)
peek = forall (t :: * -> *) a.
(Applicative t, Traversable t, Storable a) =>
Ptr (t a) -> IO (t a)
peekApplicativeTraversable
   poke :: Ptr (FogCoord1 a) -> FogCoord1 a -> IO ()
poke = 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
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, Color3 a -> Color3 a -> Bool
Color3 a -> Color3 a -> Ordering
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
Ord, (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]
Ix, 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
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)
ReadS [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 :: forall a b. (a -> b) -> Color3 a -> Color3 b
fmap a -> b
f (Color3 a
x a
y a
z) = 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 :: forall a. a -> Color3 a
pure a
a = forall a. a -> a -> a -> Color3 a
Color3 a
a a
a a
a
   Color3 a -> b
f a -> b
g a -> b
h <*> :: forall a b. Color3 (a -> b) -> Color3 a -> Color3 b
<*> Color3 a
x a
y a
z = 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 :: forall a b. (a -> b -> b) -> b -> Color3 a -> b
foldr a -> b -> b
f b
a (Color3 a
x a
y a
z) = a
x `f ` (a
y a -> b -> b
`f` (a
z a -> b -> b
`f` b
a))
   foldl :: forall b a. (b -> a -> b) -> b -> Color3 a -> b
foldl b -> a -> b
f b
a (Color3 a
x a
y a
z) = ((b
a b -> a -> b
`f` a
x) b -> a -> b
`f` a
y) b -> a -> b
`f` a
z
   foldr1 :: forall a. (a -> a -> a) -> Color3 a -> a
foldr1 a -> a -> a
f (Color3 a
x a
y a
z) = a
x a -> a -> a
`f` (a
y a -> a -> a
`f` a
z)
   foldl1 :: forall a. (a -> a -> a) -> Color3 a -> a
foldl1 a -> a -> a
f (Color3 a
x a
y a
z) = (a
x a -> a -> a
`f` a
y) a -> a -> a
`f` a
z

instance Traversable Color3 where
   traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Color3 a -> f (Color3 b)
traverse a -> f b
f (Color3 a
x a
y a
z) = forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a. a -> a -> a -> Color3 a
Color3 forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a -> f b
f a
x forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a -> f b
f a
y forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a -> f b
f a
z
   sequenceA :: forall (f :: * -> *) a.
Applicative f =>
Color3 (f a) -> f (Color3 a)
sequenceA (Color3 f a
x f a
y f a
z) =  forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a. a -> a -> a -> Color3 a
Color3 forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> f a
x forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> f a
y forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> f a
z
   mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Color3 a -> m (Color3 b)
mapM a -> m b
f (Color3 a
x a
y a
z) = forall (m :: * -> *) a. Monad m => a -> m a
return forall a. a -> a -> a -> Color3 a
Color3 forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
`ap` a -> m b
f a
x forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
`ap` a -> m b
f a
y forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
`ap` a -> m b
f a
z
   sequence :: forall (m :: * -> *) a. Monad m => Color3 (m a) -> m (Color3 a)
sequence (Color3 m a
x m a
y m a
z) = forall (m :: * -> *) a. Monad m => a -> m a
return forall a. a -> a -> a -> Color3 a
Color3 forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
`ap` m a
x forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
`ap` m a
y 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 a
x a
_ a
_) = Int
3 forall a. Num a => a -> a -> a
* forall a. Storable a => a -> Int
sizeOf a
x
   alignment :: Color3 a -> Int
alignment ~(Color3 a
x a
_ a
_) = forall a. Storable a => a -> Int
alignment a
x
   peek :: Ptr (Color3 a) -> IO (Color3 a)
peek = forall (t :: * -> *) a.
(Applicative t, Traversable t, Storable a) =>
Ptr (t a) -> IO (t a)
peekApplicativeTraversable
   poke :: Ptr (Color3 a) -> Color3 a -> IO ()
poke = 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
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, Color4 a -> Color4 a -> Bool
Color4 a -> Color4 a -> Ordering
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
Ord, (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]
Ix, 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
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)
ReadS [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 :: forall a b. (a -> b) -> Color4 a -> Color4 b
fmap a -> b
f (Color4 a
x a
y a
z a
w) = 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 :: forall a. a -> Color4 a
pure a
a = forall a. a -> a -> a -> a -> Color4 a
Color4 a
a a
a a
a a
a
   Color4 a -> b
f a -> b
g a -> b
h a -> b
i <*> :: forall a b. Color4 (a -> b) -> Color4 a -> Color4 b
<*> Color4 a
x a
y a
z a
w = 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 :: forall a b. (a -> b -> b) -> b -> Color4 a -> b
foldr a -> b -> b
f b
a (Color4 a
x a
y a
z 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 :: forall b a. (b -> a -> b) -> b -> Color4 a -> b
foldl b -> a -> b
f b
a (Color4 a
x a
y a
z 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 :: forall a. (a -> a -> a) -> Color4 a -> a
foldr1 a -> a -> a
f (Color4 a
x a
y a
z a
w) = a
x a -> a -> a
`f` (a
y a -> a -> a
`f` (a
z a -> a -> a
`f` a
w))
   foldl1 :: forall a. (a -> a -> a) -> Color4 a -> a
foldl1 a -> a -> a
f (Color4 a
x a
y a
z 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 :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Color4 a -> f (Color4 b)
traverse a -> f b
f (Color4 a
x a
y a
z a
w) = forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a. a -> a -> a -> a -> Color4 a
Color4 forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a -> f b
f a
x forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a -> f b
f a
y forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a -> f b
f a
z forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a -> f b
f a
w
   sequenceA :: forall (f :: * -> *) a.
Applicative f =>
Color4 (f a) -> f (Color4 a)
sequenceA (Color4 f a
x f a
y f a
z f a
w) =  forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a. a -> a -> a -> a -> Color4 a
Color4 forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> f a
x forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> f a
y forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> f a
z forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> f a
w
   mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Color4 a -> m (Color4 b)
mapM a -> m b
f (Color4 a
x a
y a
z a
w) = forall (m :: * -> *) a. Monad m => a -> m a
return forall a. a -> a -> a -> a -> Color4 a
Color4 forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
`ap` a -> m b
f a
x forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
`ap` a -> m b
f a
y forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
`ap` a -> m b
f a
z forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
`ap` a -> m b
f a
w
   sequence :: forall (m :: * -> *) a. Monad m => Color4 (m a) -> m (Color4 a)
sequence (Color4 m a
x m a
y m a
z m a
w) = forall (m :: * -> *) a. Monad m => a -> m a
return forall a. a -> a -> a -> a -> Color4 a
Color4 forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
`ap` m a
x forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
`ap` m a
y forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
`ap` m a
z 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 a
x a
_ a
_ a
_) = Int
4 forall a. Num a => a -> a -> a
* forall a. Storable a => a -> Int
sizeOf a
x
   alignment :: Color4 a -> Int
alignment ~(Color4 a
x a
_ a
_ a
_) = forall a. Storable a => a -> Int
alignment a
x
   peek :: Ptr (Color4 a) -> IO (Color4 a)
peek = forall (t :: * -> *) a.
(Applicative t, Traversable t, Storable a) =>
Ptr (t a) -> IO (t a)
peekApplicativeTraversable
   poke :: Ptr (Color4 a) -> Color4 a -> IO ()
poke = 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
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, 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
Ord, (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]
Ix, 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
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)
ReadS [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 :: forall a b. (a -> b) -> Index1 a -> Index1 b
fmap a -> b
f (Index1 a
x) = forall a. a -> Index1 a
Index1 (a -> b
f a
x)

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

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

instance Traversable Index1 where
   traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Index1 a -> f (Index1 b)
traverse a -> f b
f (Index1 a
x) = forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a. a -> Index1 a
Index1 forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a -> f b
f a
x
   sequenceA :: forall (f :: * -> *) a.
Applicative f =>
Index1 (f a) -> f (Index1 a)
sequenceA (Index1 f a
x) =  forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a. a -> Index1 a
Index1 forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> f a
x
   mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Index1 a -> m (Index1 b)
mapM a -> m b
f (Index1 a
x) = forall (m :: * -> *) a. Monad m => a -> m a
return forall a. a -> Index1 a
Index1 forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
`ap` a -> m b
f a
x
   sequence :: forall (m :: * -> *) a. Monad m => Index1 (m a) -> m (Index1 a)
sequence (Index1 m a
x) = forall (m :: * -> *) a. Monad m => a -> m a
return forall a. a -> Index1 a
Index1 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 a
s) = forall a. Storable a => a -> Int
sizeOf a
s
   alignment :: Index1 a -> Int
alignment ~(Index1 a
s) = forall a. Storable a => a -> Int
alignment a
s
   peek :: Ptr (Index1 a) -> IO (Index1 a)
peek = forall (t :: * -> *) a.
(Applicative t, Traversable t, Storable a) =>
Ptr (t a) -> IO (t a)
peekApplicativeTraversable
   poke :: Ptr (Index1 a) -> Index1 a -> IO ()
poke = 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 :: forall (t :: * -> *) a.
(Applicative t, Traversable t, Storable a) =>
Ptr (t a) -> IO (t a)
peekApplicativeTraversable = forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
Data.Traversable.mapM forall a. Storable a => Ptr a -> IO a
peek forall b c a. (b -> c) -> (a -> b) -> a -> c
. 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 :: forall (t :: * -> *) a.
(Applicative t, Traversable t, Storable a) =>
Ptr (t a) -> t (Ptr a)
addresses = forall a b. (a, b) -> b
snd forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (t :: * -> *) s a b.
Traversable t =>
(s -> a -> (s, b)) -> s -> t a -> (s, t b)
mapAccumL forall a. Storable a => Int -> Ptr a -> (Int, Ptr a)
nextPtr Int
0 forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a. Applicative f => a -> f a
pure forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. Ptr a -> Ptr b
castPtr

nextPtr :: Storable a => Int -> Ptr a -> (Int, Ptr a)
nextPtr :: forall a. Storable a => Int -> Ptr a -> (Int, Ptr a)
nextPtr Int
offset Ptr a
ptr = (Int
offset forall a. Num a => a -> a -> a
+ Int
1, 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 :: forall (t :: * -> *) a.
(Foldable t, Storable a) =>
Ptr (t a) -> t a -> IO ()
pokeFoldable Ptr (t a)
ptr t a
xs = forall (t :: * -> *) (m :: * -> *) b a.
(Foldable t, Monad m) =>
(b -> a -> m b) -> b -> t a -> m b
foldlM forall a. Storable a => Ptr a -> a -> IO (Ptr a)
pokeAndAdvance (forall a b. Ptr a -> Ptr b
castPtr Ptr (t a)
ptr) t a
xs forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. Monad m => a -> m a
return ()

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