OpenGL-3.0.1.0: A binding for the OpenGL graphics system

Copyright(c) Sven Panne 2016
LicenseBSD3
MaintainerSven Panne <svenpanne@gmail.com>
Stabilitystable
Portabilityportable
Safe HaskellSafe
LanguageHaskell2010

Graphics.Rendering.OpenGL.GL.Tensor

Description

This package contains tensor data types and their instances for some basic type classes.

Synopsis

Documentation

newtype Vertex1 a Source #

A vertex with y=0, z=0 and w=1.

Constructors

Vertex1 a 

Instances

Functor Vertex1 Source # 

Methods

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

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

Applicative Vertex1 Source # 

Methods

pure :: a -> Vertex1 a #

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

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

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

Foldable Vertex1 Source # 

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 #

Traversable Vertex1 Source # 

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) #

Bounded a => Bounded (Vertex1 a) Source # 
Eq a => Eq (Vertex1 a) Source # 

Methods

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

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

Ord a => Ord (Vertex1 a) Source # 

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 #

Read a => Read (Vertex1 a) Source # 
Show a => Show (Vertex1 a) Source # 

Methods

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

show :: Vertex1 a -> String #

showList :: [Vertex1 a] -> ShowS #

Ix a => Ix (Vertex1 a) Source # 

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

Storable a => Storable (Vertex1 a) Source # 

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 () #

VertexAttribComponent a => VertexAttrib (Vertex1 a) Source # 
UniformComponent a => Uniform (Vertex1 a) Source # 

data Vertex2 a Source #

A vertex with z=0 and w=1.

Constructors

Vertex2 !a !a 

Instances

Functor Vertex2 Source # 

Methods

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

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

Applicative Vertex2 Source # 

Methods

pure :: a -> Vertex2 a #

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

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

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

Foldable Vertex2 Source # 

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 #

Traversable Vertex2 Source # 

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) #

TrimmingPoint Vertex2 Source # 
Bounded a => Bounded (Vertex2 a) Source # 
Eq a => Eq (Vertex2 a) Source # 

Methods

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

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

Ord a => Ord (Vertex2 a) Source # 

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 #

Read a => Read (Vertex2 a) Source # 
Show a => Show (Vertex2 a) Source # 

Methods

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

show :: Vertex2 a -> String #

showList :: [Vertex2 a] -> ShowS #

Ix a => Ix (Vertex2 a) Source # 

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

Storable a => Storable (Vertex2 a) Source # 

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 () #

VertexAttribComponent a => VertexAttrib (Vertex2 a) Source # 
VertexComponent a => Vertex (Vertex2 a) Source # 

Methods

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

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

WindowPosComponent a => WindowPos (Vertex2 a) Source # 

Methods

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

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

RasterPosComponent a => RasterPos (Vertex2 a) Source # 

Methods

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

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

UniformComponent a => Uniform (Vertex2 a) Source # 

data Vertex3 a Source #

A vertex with w=1.

Constructors

Vertex3 !a !a !a 

Instances

Functor Vertex3 Source # 

Methods

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

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

Applicative Vertex3 Source # 

Methods

pure :: a -> Vertex3 a #

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

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

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

Foldable Vertex3 Source # 

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 #

Traversable Vertex3 Source # 

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) #

ControlPoint Vertex3 Source # 

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 ()

TrimmingPoint Vertex3 Source # 
Bounded a => Bounded (Vertex3 a) Source # 
Eq a => Eq (Vertex3 a) Source # 

Methods

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

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

Ord a => Ord (Vertex3 a) Source # 

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 #

Read a => Read (Vertex3 a) Source # 
Show a => Show (Vertex3 a) Source # 

Methods

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

show :: Vertex3 a -> String #

showList :: [Vertex3 a] -> ShowS #

Ix a => Ix (Vertex3 a) Source # 

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

Storable a => Storable (Vertex3 a) Source # 

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 () #

VertexAttribComponent a => VertexAttrib (Vertex3 a) Source # 
VertexComponent a => Vertex (Vertex3 a) Source # 

Methods

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

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

WindowPosComponent a => WindowPos (Vertex3 a) Source # 

Methods

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

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

RasterPosComponent a => RasterPos (Vertex3 a) Source # 

Methods

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

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

UniformComponent a => Uniform (Vertex3 a) Source # 

data Vertex4 a Source #

A fully-fledged four-dimensional vertex.

Constructors

Vertex4 !a !a !a !a 

Instances

Functor Vertex4 Source # 

Methods

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

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

Applicative Vertex4 Source # 

Methods

pure :: a -> Vertex4 a #

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

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

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

Foldable Vertex4 Source # 

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 #

Traversable Vertex4 Source # 

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) #

ControlPoint Vertex4 Source # 

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 ()

Bounded a => Bounded (Vertex4 a) Source # 
Eq a => Eq (Vertex4 a) Source # 

Methods

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

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

Ord a => Ord (Vertex4 a) Source # 

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 #

Read a => Read (Vertex4 a) Source # 
Show a => Show (Vertex4 a) Source # 

Methods

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

show :: Vertex4 a -> String #

showList :: [Vertex4 a] -> ShowS #

Ix a => Ix (Vertex4 a) Source # 

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

Storable a => Storable (Vertex4 a) Source # 

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 () #

VertexAttribComponent a => VertexAttrib (Vertex4 a) Source # 
VertexComponent a => Vertex (Vertex4 a) Source # 

Methods

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

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

RasterPosComponent a => RasterPos (Vertex4 a) Source # 

Methods

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

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

UniformComponent a => Uniform (Vertex4 a) Source # 

newtype Vector1 a Source #

A one-dimensional vector.

Constructors

Vector1 a 

Instances

Functor Vector1 Source # 

Methods

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

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

Applicative Vector1 Source # 

Methods

pure :: a -> Vector1 a #

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

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

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

Foldable Vector1 Source # 

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 #

Traversable Vector1 Source # 

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) #

Bounded a => Bounded (Vector1 a) Source # 
Eq a => Eq (Vector1 a) Source # 

Methods

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

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

Ord a => Ord (Vector1 a) Source # 

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 #

Read a => Read (Vector1 a) Source # 
Show a => Show (Vector1 a) Source # 

Methods

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

show :: Vector1 a -> String #

showList :: [Vector1 a] -> ShowS #

Ix a => Ix (Vector1 a) Source # 

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

Storable a => Storable (Vector1 a) Source # 

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 () #

VertexAttribComponent a => VertexAttrib (Vector1 a) Source # 
UniformComponent a => Uniform (Vector1 a) Source # 

data Vector2 a Source #

A two-dimensional vector.

Constructors

Vector2 !a !a 

Instances

Functor Vector2 Source # 

Methods

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

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

Applicative Vector2 Source # 

Methods

pure :: a -> Vector2 a #

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

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

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

Foldable Vector2 Source # 

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 #

Traversable Vector2 Source # 

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) #

Bounded a => Bounded (Vector2 a) Source # 
Eq a => Eq (Vector2 a) Source # 

Methods

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

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

Ord a => Ord (Vector2 a) Source # 

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 #

Read a => Read (Vector2 a) Source # 
Show a => Show (Vector2 a) Source # 

Methods

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

show :: Vector2 a -> String #

showList :: [Vector2 a] -> ShowS #

Ix a => Ix (Vector2 a) Source # 

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

Storable a => Storable (Vector2 a) Source # 

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 () #

VertexAttribComponent a => VertexAttrib (Vector2 a) Source # 
UniformComponent a => Uniform (Vector2 a) Source # 

data Vector3 a Source #

A three-dimensional vector.

Constructors

Vector3 !a !a !a 

Instances

Functor Vector3 Source # 

Methods

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

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

Applicative Vector3 Source # 

Methods

pure :: a -> Vector3 a #

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

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

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

Foldable Vector3 Source # 

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 #

Traversable Vector3 Source # 

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) #

Bounded a => Bounded (Vector3 a) Source # 
Eq a => Eq (Vector3 a) Source # 

Methods

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

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

Ord a => Ord (Vector3 a) Source # 

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 #

Read a => Read (Vector3 a) Source # 
Show a => Show (Vector3 a) Source # 

Methods

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

show :: Vector3 a -> String #

showList :: [Vector3 a] -> ShowS #

Ix a => Ix (Vector3 a) Source # 

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

Storable a => Storable (Vector3 a) Source # 

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 () #

VertexAttribComponent a => VertexAttrib (Vector3 a) Source # 
UniformComponent a => Uniform (Vector3 a) Source # 

data Vector4 a Source #

A four-dimensional vector.

Constructors

Vector4 !a !a !a !a 

Instances

Functor Vector4 Source # 

Methods

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

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

Applicative Vector4 Source # 

Methods

pure :: a -> Vector4 a #

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

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

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

Foldable Vector4 Source # 

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 #

Traversable Vector4 Source # 

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) #

Bounded a => Bounded (Vector4 a) Source # 
Eq a => Eq (Vector4 a) Source # 

Methods

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

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

Ord a => Ord (Vector4 a) Source # 

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 #

Read a => Read (Vector4 a) Source # 
Show a => Show (Vector4 a) Source # 

Methods

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

show :: Vector4 a -> String #

showList :: [Vector4 a] -> ShowS #

Ix a => Ix (Vector4 a) Source # 

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

Storable a => Storable (Vector4 a) Source # 

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 () #

VertexAttribComponent a => VertexAttrib (Vector4 a) Source # 
UniformComponent a => Uniform (Vector4 a) Source #