Documentation

Methods

fmap :: (a -> b) -> Vertex1 a -> Vertex1 b #

(<$) :: a -> Vertex1 b -> Vertex1 a #

Methods

pure :: a -> Vertex1 a #

(<*>) :: Vertex1 (a -> b) -> Vertex1 a -> Vertex1 b #

liftA2 :: (a -> b -> c) -> Vertex1 a -> Vertex1 b -> Vertex1 c #

(*>) :: Vertex1 a -> Vertex1 b -> Vertex1 b #

(<*) :: Vertex1 a -> Vertex1 b -> Vertex1 a #

Methods

fold :: Monoid m => Vertex1 m -> m #

foldMap :: Monoid m => (a -> m) -> Vertex1 a -> m #

foldr :: (a -> b -> b) -> b -> Vertex1 a -> b #

foldr' :: (a -> b -> b) -> b -> Vertex1 a -> b #

foldl :: (b -> a -> b) -> b -> Vertex1 a -> b #

foldl' :: (b -> a -> b) -> b -> Vertex1 a -> b #

foldr1 :: (a -> a -> a) -> Vertex1 a -> a #

foldl1 :: (a -> a -> a) -> Vertex1 a -> a #

toList :: Vertex1 a -> [a] #

null :: Vertex1 a -> Bool #

length :: Vertex1 a -> Int #

elem :: Eq a => a -> Vertex1 a -> Bool #

maximum :: Ord a => Vertex1 a -> a #

minimum :: Ord a => Vertex1 a -> a #

sum :: Num a => Vertex1 a -> a #

product :: Num a => Vertex1 a -> a #

Methods

traverse :: Applicative f => (a -> f b) -> Vertex1 a -> f (Vertex1 b) #

sequenceA :: Applicative f => Vertex1 (f a) -> f (Vertex1 a) #

mapM :: Monad m => (a -> m b) -> Vertex1 a -> m (Vertex1 b) #

sequence :: Monad m => Vertex1 (m a) -> m (Vertex1 a) #

Methods

minBound :: Vertex1 a #

maxBound :: Vertex1 a #

Methods

(==) :: Vertex1 a -> Vertex1 a -> Bool #

(/=) :: Vertex1 a -> Vertex1 a -> Bool #

Methods

compare :: Vertex1 a -> Vertex1 a -> Ordering #

(<) :: Vertex1 a -> Vertex1 a -> Bool #

(<=) :: Vertex1 a -> Vertex1 a -> Bool #

(>) :: Vertex1 a -> Vertex1 a -> Bool #

(>=) :: Vertex1 a -> Vertex1 a -> Bool #

max :: Vertex1 a -> Vertex1 a -> Vertex1 a #

min :: Vertex1 a -> Vertex1 a -> Vertex1 a #

Methods

readsPrec :: Int -> ReadS (Vertex1 a) #

readList :: ReadS [Vertex1 a] #

readPrec :: ReadPrec (Vertex1 a) #

readListPrec :: ReadPrec [Vertex1 a] #

Methods

showsPrec :: Int -> Vertex1 a -> ShowS #

show :: Vertex1 a -> String #

showList :: [Vertex1 a] -> ShowS #

Methods

range :: (Vertex1 a, Vertex1 a) -> [Vertex1 a] #

index :: (Vertex1 a, Vertex1 a) -> Vertex1 a -> Int #

unsafeIndex :: (Vertex1 a, Vertex1 a) -> Vertex1 a -> Int

inRange :: (Vertex1 a, Vertex1 a) -> Vertex1 a -> Bool #

rangeSize :: (Vertex1 a, Vertex1 a) -> Int #

unsafeRangeSize :: (Vertex1 a, Vertex1 a) -> Int

Methods

sizeOf :: Vertex1 a -> Int #

alignment :: Vertex1 a -> Int #

peekElemOff :: Ptr (Vertex1 a) -> Int -> IO (Vertex1 a) #

pokeElemOff :: Ptr (Vertex1 a) -> Int -> Vertex1 a -> IO () #

peekByteOff :: Ptr b -> Int -> IO (Vertex1 a) #

pokeByteOff :: Ptr b -> Int -> Vertex1 a -> IO () #

peek :: Ptr (Vertex1 a) -> IO (Vertex1 a) #

poke :: Ptr (Vertex1 a) -> Vertex1 a -> IO () #

Methods

vertexAttrib :: IntegerHandling -> AttribLocation -> Vertex1 a -> IO () Source #

vertexAttribv :: IntegerHandling -> AttribLocation -> Ptr (Vertex1 a) -> IO () Source #

Methods

uniform :: UniformLocation -> StateVar (Vertex1 a) Source #

uniformv :: UniformLocation -> GLsizei -> Ptr (Vertex1 a) -> IO () Source #

Methods

fmap :: (a -> b) -> Vertex2 a -> Vertex2 b #

(<$) :: a -> Vertex2 b -> Vertex2 a #

Methods

pure :: a -> Vertex2 a #

(<*>) :: Vertex2 (a -> b) -> Vertex2 a -> Vertex2 b #

liftA2 :: (a -> b -> c) -> Vertex2 a -> Vertex2 b -> Vertex2 c #

(*>) :: Vertex2 a -> Vertex2 b -> Vertex2 b #

(<*) :: Vertex2 a -> Vertex2 b -> Vertex2 a #

Methods

fold :: Monoid m => Vertex2 m -> m #

foldMap :: Monoid m => (a -> m) -> Vertex2 a -> m #

foldr :: (a -> b -> b) -> b -> Vertex2 a -> b #

foldr' :: (a -> b -> b) -> b -> Vertex2 a -> b #

foldl :: (b -> a -> b) -> b -> Vertex2 a -> b #

foldl' :: (b -> a -> b) -> b -> Vertex2 a -> b #

foldr1 :: (a -> a -> a) -> Vertex2 a -> a #

foldl1 :: (a -> a -> a) -> Vertex2 a -> a #

toList :: Vertex2 a -> [a] #

null :: Vertex2 a -> Bool #

length :: Vertex2 a -> Int #

elem :: Eq a => a -> Vertex2 a -> Bool #

maximum :: Ord a => Vertex2 a -> a #

minimum :: Ord a => Vertex2 a -> a #

sum :: Num a => Vertex2 a -> a #

product :: Num a => Vertex2 a -> a #

Methods

traverse :: Applicative f => (a -> f b) -> Vertex2 a -> f (Vertex2 b) #

sequenceA :: Applicative f => Vertex2 (f a) -> f (Vertex2 a) #

mapM :: Monad m => (a -> m b) -> Vertex2 a -> m (Vertex2 b) #

sequence :: Monad m => Vertex2 (m a) -> m (Vertex2 a) #

Methods

trimmingTarget :: Vertex2 GLfloat -> GLenum

Methods

minBound :: Vertex2 a #

maxBound :: Vertex2 a #

Methods

(==) :: Vertex2 a -> Vertex2 a -> Bool #

(/=) :: Vertex2 a -> Vertex2 a -> Bool #

Methods

compare :: Vertex2 a -> Vertex2 a -> Ordering #

(<) :: Vertex2 a -> Vertex2 a -> Bool #

(<=) :: Vertex2 a -> Vertex2 a -> Bool #

(>) :: Vertex2 a -> Vertex2 a -> Bool #

(>=) :: Vertex2 a -> Vertex2 a -> Bool #

max :: Vertex2 a -> Vertex2 a -> Vertex2 a #

min :: Vertex2 a -> Vertex2 a -> Vertex2 a #

Methods

readsPrec :: Int -> ReadS (Vertex2 a) #

readList :: ReadS [Vertex2 a] #

readPrec :: ReadPrec (Vertex2 a) #

readListPrec :: ReadPrec [Vertex2 a] #

Methods

showsPrec :: Int -> Vertex2 a -> ShowS #

show :: Vertex2 a -> String #

showList :: [Vertex2 a] -> ShowS #

Methods

range :: (Vertex2 a, Vertex2 a) -> [Vertex2 a] #

index :: (Vertex2 a, Vertex2 a) -> Vertex2 a -> Int #

unsafeIndex :: (Vertex2 a, Vertex2 a) -> Vertex2 a -> Int

inRange :: (Vertex2 a, Vertex2 a) -> Vertex2 a -> Bool #

rangeSize :: (Vertex2 a, Vertex2 a) -> Int #

unsafeRangeSize :: (Vertex2 a, Vertex2 a) -> Int

Methods

sizeOf :: Vertex2 a -> Int #

alignment :: Vertex2 a -> Int #

peekElemOff :: Ptr (Vertex2 a) -> Int -> IO (Vertex2 a) #

pokeElemOff :: Ptr (Vertex2 a) -> Int -> Vertex2 a -> IO () #

peekByteOff :: Ptr b -> Int -> IO (Vertex2 a) #

pokeByteOff :: Ptr b -> Int -> Vertex2 a -> IO () #

peek :: Ptr (Vertex2 a) -> IO (Vertex2 a) #

poke :: Ptr (Vertex2 a) -> Vertex2 a -> IO () #

Methods

vertexAttrib :: IntegerHandling -> AttribLocation -> Vertex2 a -> IO () Source #

vertexAttribv :: IntegerHandling -> AttribLocation -> Ptr (Vertex2 a) -> IO () Source #

Methods

vertex :: Vertex2 a -> IO () Source #

vertexv :: Ptr (Vertex2 a) -> IO () Source #

Methods

windowPos :: Vertex2 a -> IO () Source #

windowPosv :: Ptr (Vertex2 a) -> IO () Source #

Methods

rasterPos :: Vertex2 a -> IO () Source #

rasterPosv :: Ptr (Vertex2 a) -> IO () Source #

Methods

uniform :: UniformLocation -> StateVar (Vertex2 a) Source #

uniformv :: UniformLocation -> GLsizei -> Ptr (Vertex2 a) -> IO () Source #

Methods

fmap :: (a -> b) -> Vertex3 a -> Vertex3 b #

(<$) :: a -> Vertex3 b -> Vertex3 a #

Methods

pure :: a -> Vertex3 a #

(<*>) :: Vertex3 (a -> b) -> Vertex3 a -> Vertex3 b #

liftA2 :: (a -> b -> c) -> Vertex3 a -> Vertex3 b -> Vertex3 c #

(*>) :: Vertex3 a -> Vertex3 b -> Vertex3 b #

(<*) :: Vertex3 a -> Vertex3 b -> Vertex3 a #

Methods

fold :: Monoid m => Vertex3 m -> m #

foldMap :: Monoid m => (a -> m) -> Vertex3 a -> m #

foldr :: (a -> b -> b) -> b -> Vertex3 a -> b #

foldr' :: (a -> b -> b) -> b -> Vertex3 a -> b #

foldl :: (b -> a -> b) -> b -> Vertex3 a -> b #

foldl' :: (b -> a -> b) -> b -> Vertex3 a -> b #

foldr1 :: (a -> a -> a) -> Vertex3 a -> a #

foldl1 :: (a -> a -> a) -> Vertex3 a -> a #

toList :: Vertex3 a -> [a] #

null :: Vertex3 a -> Bool #

length :: Vertex3 a -> Int #

elem :: Eq a => a -> Vertex3 a -> Bool #

maximum :: Ord a => Vertex3 a -> a #

minimum :: Ord a => Vertex3 a -> a #

sum :: Num a => Vertex3 a -> a #

product :: Num a => Vertex3 a -> a #

Methods

traverse :: Applicative f => (a -> f b) -> Vertex3 a -> f (Vertex3 b) #

sequenceA :: Applicative f => Vertex3 (f a) -> f (Vertex3 a) #

mapM :: Monad m => (a -> m b) -> Vertex3 a -> m (Vertex3 b) #

sequence :: Monad m => Vertex3 (m a) -> m (Vertex3 a) #

Methods

map1Target :: Domain d => Vertex3 d -> GLenum

map2Target :: Domain d => Vertex3 d -> GLenum

enableCap1 :: Domain d => Vertex3 d -> EnableCap

enableCap2 :: Domain d => Vertex3 d -> EnableCap

numComponents :: Domain d => Vertex3 d -> Stride

peekControlPoint :: Domain d => Ptr (Vertex3 d) -> IO (Vertex3 d)

pokeControlPoint :: Domain d => Ptr (Vertex3 d) -> Vertex3 d -> IO ()

Methods

trimmingTarget :: Vertex3 GLfloat -> GLenum

Methods

minBound :: Vertex3 a #

maxBound :: Vertex3 a #

Methods

(==) :: Vertex3 a -> Vertex3 a -> Bool #

(/=) :: Vertex3 a -> Vertex3 a -> Bool #

Methods

compare :: Vertex3 a -> Vertex3 a -> Ordering #

(<) :: Vertex3 a -> Vertex3 a -> Bool #

(<=) :: Vertex3 a -> Vertex3 a -> Bool #

(>) :: Vertex3 a -> Vertex3 a -> Bool #

(>=) :: Vertex3 a -> Vertex3 a -> Bool #

max :: Vertex3 a -> Vertex3 a -> Vertex3 a #

min :: Vertex3 a -> Vertex3 a -> Vertex3 a #

Methods

readsPrec :: Int -> ReadS (Vertex3 a) #

readList :: ReadS [Vertex3 a] #

readPrec :: ReadPrec (Vertex3 a) #

readListPrec :: ReadPrec [Vertex3 a] #

Methods

showsPrec :: Int -> Vertex3 a -> ShowS #

show :: Vertex3 a -> String #

showList :: [Vertex3 a] -> ShowS #

Methods

range :: (Vertex3 a, Vertex3 a) -> [Vertex3 a] #

index :: (Vertex3 a, Vertex3 a) -> Vertex3 a -> Int #

unsafeIndex :: (Vertex3 a, Vertex3 a) -> Vertex3 a -> Int

inRange :: (Vertex3 a, Vertex3 a) -> Vertex3 a -> Bool #

rangeSize :: (Vertex3 a, Vertex3 a) -> Int #

unsafeRangeSize :: (Vertex3 a, Vertex3 a) -> Int

Methods

sizeOf :: Vertex3 a -> Int #

alignment :: Vertex3 a -> Int #

peekElemOff :: Ptr (Vertex3 a) -> Int -> IO (Vertex3 a) #

pokeElemOff :: Ptr (Vertex3 a) -> Int -> Vertex3 a -> IO () #

peekByteOff :: Ptr b -> Int -> IO (Vertex3 a) #

pokeByteOff :: Ptr b -> Int -> Vertex3 a -> IO () #

peek :: Ptr (Vertex3 a) -> IO (Vertex3 a) #

poke :: Ptr (Vertex3 a) -> Vertex3 a -> IO () #

Methods

vertexAttrib :: IntegerHandling -> AttribLocation -> Vertex3 a -> IO () Source #

vertexAttribv :: IntegerHandling -> AttribLocation -> Ptr (Vertex3 a) -> IO () Source #

Methods

vertex :: Vertex3 a -> IO () Source #

vertexv :: Ptr (Vertex3 a) -> IO () Source #

Methods

windowPos :: Vertex3 a -> IO () Source #

windowPosv :: Ptr (Vertex3 a) -> IO () Source #

Methods

rasterPos :: Vertex3 a -> IO () Source #

rasterPosv :: Ptr (Vertex3 a) -> IO () Source #

Methods

uniform :: UniformLocation -> StateVar (Vertex3 a) Source #

uniformv :: UniformLocation -> GLsizei -> Ptr (Vertex3 a) -> IO () Source #

Methods

fmap :: (a -> b) -> Vertex4 a -> Vertex4 b #

(<$) :: a -> Vertex4 b -> Vertex4 a #

Methods

pure :: a -> Vertex4 a #

(<*>) :: Vertex4 (a -> b) -> Vertex4 a -> Vertex4 b #

liftA2 :: (a -> b -> c) -> Vertex4 a -> Vertex4 b -> Vertex4 c #

(*>) :: Vertex4 a -> Vertex4 b -> Vertex4 b #

(<*) :: Vertex4 a -> Vertex4 b -> Vertex4 a #

Methods

fold :: Monoid m => Vertex4 m -> m #

foldMap :: Monoid m => (a -> m) -> Vertex4 a -> m #

foldr :: (a -> b -> b) -> b -> Vertex4 a -> b #

foldr' :: (a -> b -> b) -> b -> Vertex4 a -> b #

foldl :: (b -> a -> b) -> b -> Vertex4 a -> b #

foldl' :: (b -> a -> b) -> b -> Vertex4 a -> b #

foldr1 :: (a -> a -> a) -> Vertex4 a -> a #

foldl1 :: (a -> a -> a) -> Vertex4 a -> a #

toList :: Vertex4 a -> [a] #

null :: Vertex4 a -> Bool #

length :: Vertex4 a -> Int #

elem :: Eq a => a -> Vertex4 a -> Bool #

maximum :: Ord a => Vertex4 a -> a #

minimum :: Ord a => Vertex4 a -> a #

sum :: Num a => Vertex4 a -> a #

product :: Num a => Vertex4 a -> a #

Methods

traverse :: Applicative f => (a -> f b) -> Vertex4 a -> f (Vertex4 b) #

sequenceA :: Applicative f => Vertex4 (f a) -> f (Vertex4 a) #

mapM :: Monad m => (a -> m b) -> Vertex4 a -> m (Vertex4 b) #

sequence :: Monad m => Vertex4 (m a) -> m (Vertex4 a) #

Methods

map1Target :: Domain d => Vertex4 d -> GLenum

map2Target :: Domain d => Vertex4 d -> GLenum

enableCap1 :: Domain d => Vertex4 d -> EnableCap

enableCap2 :: Domain d => Vertex4 d -> EnableCap

numComponents :: Domain d => Vertex4 d -> Stride

peekControlPoint :: Domain d => Ptr (Vertex4 d) -> IO (Vertex4 d)

pokeControlPoint :: Domain d => Ptr (Vertex4 d) -> Vertex4 d -> IO ()

Methods

minBound :: Vertex4 a #

maxBound :: Vertex4 a #

Methods

(==) :: Vertex4 a -> Vertex4 a -> Bool #

(/=) :: Vertex4 a -> Vertex4 a -> Bool #

Methods

compare :: Vertex4 a -> Vertex4 a -> Ordering #

(<) :: Vertex4 a -> Vertex4 a -> Bool #

(<=) :: Vertex4 a -> Vertex4 a -> Bool #

(>) :: Vertex4 a -> Vertex4 a -> Bool #

(>=) :: Vertex4 a -> Vertex4 a -> Bool #

max :: Vertex4 a -> Vertex4 a -> Vertex4 a #

min :: Vertex4 a -> Vertex4 a -> Vertex4 a #

Methods

readsPrec :: Int -> ReadS (Vertex4 a) #

readList :: ReadS [Vertex4 a] #

readPrec :: ReadPrec (Vertex4 a) #

readListPrec :: ReadPrec [Vertex4 a] #

Methods

showsPrec :: Int -> Vertex4 a -> ShowS #

show :: Vertex4 a -> String #

showList :: [Vertex4 a] -> ShowS #

Methods

range :: (Vertex4 a, Vertex4 a) -> [Vertex4 a] #

index :: (Vertex4 a, Vertex4 a) -> Vertex4 a -> Int #

unsafeIndex :: (Vertex4 a, Vertex4 a) -> Vertex4 a -> Int

inRange :: (Vertex4 a, Vertex4 a) -> Vertex4 a -> Bool #

rangeSize :: (Vertex4 a, Vertex4 a) -> Int #

unsafeRangeSize :: (Vertex4 a, Vertex4 a) -> Int

Methods

sizeOf :: Vertex4 a -> Int #

alignment :: Vertex4 a -> Int #

peekElemOff :: Ptr (Vertex4 a) -> Int -> IO (Vertex4 a) #

pokeElemOff :: Ptr (Vertex4 a) -> Int -> Vertex4 a -> IO () #

peekByteOff :: Ptr b -> Int -> IO (Vertex4 a) #

pokeByteOff :: Ptr b -> Int -> Vertex4 a -> IO () #

peek :: Ptr (Vertex4 a) -> IO (Vertex4 a) #

poke :: Ptr (Vertex4 a) -> Vertex4 a -> IO () #

Methods

vertexAttrib :: IntegerHandling -> AttribLocation -> Vertex4 a -> IO () Source #

vertexAttribv :: IntegerHandling -> AttribLocation -> Ptr (Vertex4 a) -> IO () Source #

Methods

vertex :: Vertex4 a -> IO () Source #

vertexv :: Ptr (Vertex4 a) -> IO () Source #

Methods

rasterPos :: Vertex4 a -> IO () Source #

rasterPosv :: Ptr (Vertex4 a) -> IO () Source #

Methods

uniform :: UniformLocation -> StateVar (Vertex4 a) Source #

uniformv :: UniformLocation -> GLsizei -> Ptr (Vertex4 a) -> IO () Source #

Methods

fmap :: (a -> b) -> Vector1 a -> Vector1 b #

(<$) :: a -> Vector1 b -> Vector1 a #

Methods

pure :: a -> Vector1 a #

(<*>) :: Vector1 (a -> b) -> Vector1 a -> Vector1 b #

liftA2 :: (a -> b -> c) -> Vector1 a -> Vector1 b -> Vector1 c #

(*>) :: Vector1 a -> Vector1 b -> Vector1 b #

(<*) :: Vector1 a -> Vector1 b -> Vector1 a #

Methods

fold :: Monoid m => Vector1 m -> m #

foldMap :: Monoid m => (a -> m) -> Vector1 a -> m #

foldr :: (a -> b -> b) -> b -> Vector1 a -> b #

foldr' :: (a -> b -> b) -> b -> Vector1 a -> b #

foldl :: (b -> a -> b) -> b -> Vector1 a -> b #

foldl' :: (b -> a -> b) -> b -> Vector1 a -> b #

foldr1 :: (a -> a -> a) -> Vector1 a -> a #

foldl1 :: (a -> a -> a) -> Vector1 a -> a #

toList :: Vector1 a -> [a] #

null :: Vector1 a -> Bool #

length :: Vector1 a -> Int #

elem :: Eq a => a -> Vector1 a -> Bool #

maximum :: Ord a => Vector1 a -> a #

minimum :: Ord a => Vector1 a -> a #

sum :: Num a => Vector1 a -> a #

product :: Num a => Vector1 a -> a #

Methods

traverse :: Applicative f => (a -> f b) -> Vector1 a -> f (Vector1 b) #

sequenceA :: Applicative f => Vector1 (f a) -> f (Vector1 a) #

mapM :: Monad m => (a -> m b) -> Vector1 a -> m (Vector1 b) #

sequence :: Monad m => Vector1 (m a) -> m (Vector1 a) #

Methods

minBound :: Vector1 a #

maxBound :: Vector1 a #

Methods

(==) :: Vector1 a -> Vector1 a -> Bool #

(/=) :: Vector1 a -> Vector1 a -> Bool #

Methods

compare :: Vector1 a -> Vector1 a -> Ordering #

(<) :: Vector1 a -> Vector1 a -> Bool #

(<=) :: Vector1 a -> Vector1 a -> Bool #

(>) :: Vector1 a -> Vector1 a -> Bool #

(>=) :: Vector1 a -> Vector1 a -> Bool #

max :: Vector1 a -> Vector1 a -> Vector1 a #

min :: Vector1 a -> Vector1 a -> Vector1 a #

Methods

readsPrec :: Int -> ReadS (Vector1 a) #

readList :: ReadS [Vector1 a] #

readPrec :: ReadPrec (Vector1 a) #

readListPrec :: ReadPrec [Vector1 a] #

Methods

showsPrec :: Int -> Vector1 a -> ShowS #

show :: Vector1 a -> String #

showList :: [Vector1 a] -> ShowS #

Methods

range :: (Vector1 a, Vector1 a) -> [Vector1 a] #

index :: (Vector1 a, Vector1 a) -> Vector1 a -> Int #

unsafeIndex :: (Vector1 a, Vector1 a) -> Vector1 a -> Int

inRange :: (Vector1 a, Vector1 a) -> Vector1 a -> Bool #

rangeSize :: (Vector1 a, Vector1 a) -> Int #

unsafeRangeSize :: (Vector1 a, Vector1 a) -> Int

Methods

sizeOf :: Vector1 a -> Int #

alignment :: Vector1 a -> Int #

peekElemOff :: Ptr (Vector1 a) -> Int -> IO (Vector1 a) #

pokeElemOff :: Ptr (Vector1 a) -> Int -> Vector1 a -> IO () #

peekByteOff :: Ptr b -> Int -> IO (Vector1 a) #

pokeByteOff :: Ptr b -> Int -> Vector1 a -> IO () #

peek :: Ptr (Vector1 a) -> IO (Vector1 a) #

poke :: Ptr (Vector1 a) -> Vector1 a -> IO () #

Methods

vertexAttrib :: IntegerHandling -> AttribLocation -> Vector1 a -> IO () Source #

vertexAttribv :: IntegerHandling -> AttribLocation -> Ptr (Vector1 a) -> IO () Source #

Methods

uniform :: UniformLocation -> StateVar (Vector1 a) Source #

uniformv :: UniformLocation -> GLsizei -> Ptr (Vector1 a) -> IO () Source #

Methods

fmap :: (a -> b) -> Vector2 a -> Vector2 b #

(<$) :: a -> Vector2 b -> Vector2 a #

Methods

pure :: a -> Vector2 a #

(<*>) :: Vector2 (a -> b) -> Vector2 a -> Vector2 b #

liftA2 :: (a -> b -> c) -> Vector2 a -> Vector2 b -> Vector2 c #

(*>) :: Vector2 a -> Vector2 b -> Vector2 b #

(<*) :: Vector2 a -> Vector2 b -> Vector2 a #

Methods

fold :: Monoid m => Vector2 m -> m #

foldMap :: Monoid m => (a -> m) -> Vector2 a -> m #

foldr :: (a -> b -> b) -> b -> Vector2 a -> b #

foldr' :: (a -> b -> b) -> b -> Vector2 a -> b #

foldl :: (b -> a -> b) -> b -> Vector2 a -> b #

foldl' :: (b -> a -> b) -> b -> Vector2 a -> b #

foldr1 :: (a -> a -> a) -> Vector2 a -> a #

foldl1 :: (a -> a -> a) -> Vector2 a -> a #

toList :: Vector2 a -> [a] #

null :: Vector2 a -> Bool #

length :: Vector2 a -> Int #

elem :: Eq a => a -> Vector2 a -> Bool #

maximum :: Ord a => Vector2 a -> a #

minimum :: Ord a => Vector2 a -> a #

sum :: Num a => Vector2 a -> a #

product :: Num a => Vector2 a -> a #

Methods

traverse :: Applicative f => (a -> f b) -> Vector2 a -> f (Vector2 b) #

sequenceA :: Applicative f => Vector2 (f a) -> f (Vector2 a) #

mapM :: Monad m => (a -> m b) -> Vector2 a -> m (Vector2 b) #

sequence :: Monad m => Vector2 (m a) -> m (Vector2 a) #

Methods

minBound :: Vector2 a #

maxBound :: Vector2 a #

Methods

(==) :: Vector2 a -> Vector2 a -> Bool #

(/=) :: Vector2 a -> Vector2 a -> Bool #

Methods

compare :: Vector2 a -> Vector2 a -> Ordering #

(<) :: Vector2 a -> Vector2 a -> Bool #

(<=) :: Vector2 a -> Vector2 a -> Bool #

(>) :: Vector2 a -> Vector2 a -> Bool #

(>=) :: Vector2 a -> Vector2 a -> Bool #

max :: Vector2 a -> Vector2 a -> Vector2 a #

min :: Vector2 a -> Vector2 a -> Vector2 a #

Methods

readsPrec :: Int -> ReadS (Vector2 a) #

readList :: ReadS [Vector2 a] #

readPrec :: ReadPrec (Vector2 a) #

readListPrec :: ReadPrec [Vector2 a] #

Methods

showsPrec :: Int -> Vector2 a -> ShowS #

show :: Vector2 a -> String #

showList :: [Vector2 a] -> ShowS #

Methods

range :: (Vector2 a, Vector2 a) -> [Vector2 a] #

index :: (Vector2 a, Vector2 a) -> Vector2 a -> Int #

unsafeIndex :: (Vector2 a, Vector2 a) -> Vector2 a -> Int

inRange :: (Vector2 a, Vector2 a) -> Vector2 a -> Bool #

rangeSize :: (Vector2 a, Vector2 a) -> Int #

unsafeRangeSize :: (Vector2 a, Vector2 a) -> Int

Methods

sizeOf :: Vector2 a -> Int #

alignment :: Vector2 a -> Int #

peekElemOff :: Ptr (Vector2 a) -> Int -> IO (Vector2 a) #

pokeElemOff :: Ptr (Vector2 a) -> Int -> Vector2 a -> IO () #

peekByteOff :: Ptr b -> Int -> IO (Vector2 a) #

pokeByteOff :: Ptr b -> Int -> Vector2 a -> IO () #

peek :: Ptr (Vector2 a) -> IO (Vector2 a) #

poke :: Ptr (Vector2 a) -> Vector2 a -> IO () #

Methods

vertexAttrib :: IntegerHandling -> AttribLocation -> Vector2 a -> IO () Source #

vertexAttribv :: IntegerHandling -> AttribLocation -> Ptr (Vector2 a) -> IO () Source #

Methods

uniform :: UniformLocation -> StateVar (Vector2 a) Source #

uniformv :: UniformLocation -> GLsizei -> Ptr (Vector2 a) -> IO () Source #

Methods

fmap :: (a -> b) -> Vector3 a -> Vector3 b #

(<$) :: a -> Vector3 b -> Vector3 a #

Methods

pure :: a -> Vector3 a #

(<*>) :: Vector3 (a -> b) -> Vector3 a -> Vector3 b #

liftA2 :: (a -> b -> c) -> Vector3 a -> Vector3 b -> Vector3 c #

(*>) :: Vector3 a -> Vector3 b -> Vector3 b #

(<*) :: Vector3 a -> Vector3 b -> Vector3 a #

Methods

fold :: Monoid m => Vector3 m -> m #

foldMap :: Monoid m => (a -> m) -> Vector3 a -> m #

foldr :: (a -> b -> b) -> b -> Vector3 a -> b #

foldr' :: (a -> b -> b) -> b -> Vector3 a -> b #

foldl :: (b -> a -> b) -> b -> Vector3 a -> b #

foldl' :: (b -> a -> b) -> b -> Vector3 a -> b #

foldr1 :: (a -> a -> a) -> Vector3 a -> a #

foldl1 :: (a -> a -> a) -> Vector3 a -> a #

toList :: Vector3 a -> [a] #

null :: Vector3 a -> Bool #

length :: Vector3 a -> Int #

elem :: Eq a => a -> Vector3 a -> Bool #

maximum :: Ord a => Vector3 a -> a #

minimum :: Ord a => Vector3 a -> a #

sum :: Num a => Vector3 a -> a #

product :: Num a => Vector3 a -> a #

Methods

traverse :: Applicative f => (a -> f b) -> Vector3 a -> f (Vector3 b) #

sequenceA :: Applicative f => Vector3 (f a) -> f (Vector3 a) #

mapM :: Monad m => (a -> m b) -> Vector3 a -> m (Vector3 b) #

sequence :: Monad m => Vector3 (m a) -> m (Vector3 a) #

Methods

minBound :: Vector3 a #

maxBound :: Vector3 a #

Methods

(==) :: Vector3 a -> Vector3 a -> Bool #

(/=) :: Vector3 a -> Vector3 a -> Bool #

Methods

compare :: Vector3 a -> Vector3 a -> Ordering #

(<) :: Vector3 a -> Vector3 a -> Bool #

(<=) :: Vector3 a -> Vector3 a -> Bool #

(>) :: Vector3 a -> Vector3 a -> Bool #

(>=) :: Vector3 a -> Vector3 a -> Bool #

max :: Vector3 a -> Vector3 a -> Vector3 a #

min :: Vector3 a -> Vector3 a -> Vector3 a #

Methods

readsPrec :: Int -> ReadS (Vector3 a) #

readList :: ReadS [Vector3 a] #

readPrec :: ReadPrec (Vector3 a) #

readListPrec :: ReadPrec [Vector3 a] #

Methods

showsPrec :: Int -> Vector3 a -> ShowS #

show :: Vector3 a -> String #

showList :: [Vector3 a] -> ShowS #

Methods

range :: (Vector3 a, Vector3 a) -> [Vector3 a] #

index :: (Vector3 a, Vector3 a) -> Vector3 a -> Int #

unsafeIndex :: (Vector3 a, Vector3 a) -> Vector3 a -> Int

inRange :: (Vector3 a, Vector3 a) -> Vector3 a -> Bool #

rangeSize :: (Vector3 a, Vector3 a) -> Int #

unsafeRangeSize :: (Vector3 a, Vector3 a) -> Int

Methods

sizeOf :: Vector3 a -> Int #

alignment :: Vector3 a -> Int #

peekElemOff :: Ptr (Vector3 a) -> Int -> IO (Vector3 a) #

pokeElemOff :: Ptr (Vector3 a) -> Int -> Vector3 a -> IO () #

peekByteOff :: Ptr b -> Int -> IO (Vector3 a) #

pokeByteOff :: Ptr b -> Int -> Vector3 a -> IO () #

peek :: Ptr (Vector3 a) -> IO (Vector3 a) #

poke :: Ptr (Vector3 a) -> Vector3 a -> IO () #

Methods

vertexAttrib :: IntegerHandling -> AttribLocation -> Vector3 a -> IO () Source #

vertexAttribv :: IntegerHandling -> AttribLocation -> Ptr (Vector3 a) -> IO () Source #

Methods

uniform :: UniformLocation -> StateVar (Vector3 a) Source #

uniformv :: UniformLocation -> GLsizei -> Ptr (Vector3 a) -> IO () Source #

Methods

fmap :: (a -> b) -> Vector4 a -> Vector4 b #

(<$) :: a -> Vector4 b -> Vector4 a #

Methods

pure :: a -> Vector4 a #

(<*>) :: Vector4 (a -> b) -> Vector4 a -> Vector4 b #

liftA2 :: (a -> b -> c) -> Vector4 a -> Vector4 b -> Vector4 c #

(*>) :: Vector4 a -> Vector4 b -> Vector4 b #

(<*) :: Vector4 a -> Vector4 b -> Vector4 a #

Methods

fold :: Monoid m => Vector4 m -> m #

foldMap :: Monoid m => (a -> m) -> Vector4 a -> m #

foldr :: (a -> b -> b) -> b -> Vector4 a -> b #

foldr' :: (a -> b -> b) -> b -> Vector4 a -> b #

foldl :: (b -> a -> b) -> b -> Vector4 a -> b #

foldl' :: (b -> a -> b) -> b -> Vector4 a -> b #

foldr1 :: (a -> a -> a) -> Vector4 a -> a #

foldl1 :: (a -> a -> a) -> Vector4 a -> a #

toList :: Vector4 a -> [a] #

null :: Vector4 a -> Bool #

length :: Vector4 a -> Int #

elem :: Eq a => a -> Vector4 a -> Bool #

maximum :: Ord a => Vector4 a -> a #

minimum :: Ord a => Vector4 a -> a #

sum :: Num a => Vector4 a -> a #

product :: Num a => Vector4 a -> a #

Methods

traverse :: Applicative f => (a -> f b) -> Vector4 a -> f (Vector4 b) #

sequenceA :: Applicative f => Vector4 (f a) -> f (Vector4 a) #

mapM :: Monad m => (a -> m b) -> Vector4 a -> m (Vector4 b) #

sequence :: Monad m => Vector4 (m a) -> m (Vector4 a) #

Methods

minBound :: Vector4 a #

maxBound :: Vector4 a #

Methods

(==) :: Vector4 a -> Vector4 a -> Bool #

(/=) :: Vector4 a -> Vector4 a -> Bool #

Methods

compare :: Vector4 a -> Vector4 a -> Ordering #

(<) :: Vector4 a -> Vector4 a -> Bool #

(<=) :: Vector4 a -> Vector4 a -> Bool #

(>) :: Vector4 a -> Vector4 a -> Bool #

(>=) :: Vector4 a -> Vector4 a -> Bool #

max :: Vector4 a -> Vector4 a -> Vector4 a #

min :: Vector4 a -> Vector4 a -> Vector4 a #

Methods

readsPrec :: Int -> ReadS (Vector4 a) #

readList :: ReadS [Vector4 a] #

readPrec :: ReadPrec (Vector4 a) #

readListPrec :: ReadPrec [Vector4 a] #

Methods

showsPrec :: Int -> Vector4 a -> ShowS #

show :: Vector4 a -> String #

showList :: [Vector4 a] -> ShowS #

Methods

range :: (Vector4 a, Vector4 a) -> [Vector4 a] #

index :: (Vector4 a, Vector4 a) -> Vector4 a -> Int #

unsafeIndex :: (Vector4 a, Vector4 a) -> Vector4 a -> Int

inRange :: (Vector4 a, Vector4 a) -> Vector4 a -> Bool #

rangeSize :: (Vector4 a, Vector4 a) -> Int #

unsafeRangeSize :: (Vector4 a, Vector4 a) -> Int

Methods

sizeOf :: Vector4 a -> Int #

alignment :: Vector4 a -> Int #

peekElemOff :: Ptr (Vector4 a) -> Int -> IO (Vector4 a) #

pokeElemOff :: Ptr (Vector4 a) -> Int -> Vector4 a -> IO () #

peekByteOff :: Ptr b -> Int -> IO (Vector4 a) #

pokeByteOff :: Ptr b -> Int -> Vector4 a -> IO () #

peek :: Ptr (Vector4 a) -> IO (Vector4 a) #

poke :: Ptr (Vector4 a) -> Vector4 a -> IO () #

Methods

vertexAttrib :: IntegerHandling -> AttribLocation -> Vector4 a -> IO () Source #

vertexAttribv :: IntegerHandling -> AttribLocation -> Ptr (Vector4 a) -> IO () Source #

Methods

uniform :: UniformLocation -> StateVar (Vector4 a) Source #

uniformv :: UniformLocation -> GLsizei -> Ptr (Vector4 a) -> IO () Source #