Graphics.Rendering.OpenGL.GL.Tensor

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

Documentation

newtype Vertex1 a

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

Constructors

Vertex1 a

Instances

Functor Vertex1

Methods

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

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

Applicative Vertex1

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

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

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)

Methods

minBound :: Vertex1 a

maxBound :: Vertex1 a

Eq a => Eq (Vertex1 a)

Methods

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

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

Ord a => Ord (Vertex1 a)

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)

Methods

readsPrec :: Int -> ReadS (Vertex1 a)

readList :: ReadS [Vertex1 a]

readPrec :: ReadPrec (Vertex1 a)

readListPrec :: ReadPrec [Vertex1 a]

Show a => Show (Vertex1 a)

Methods

showsPrec :: Int -> Vertex1 a -> ShowS

show :: Vertex1 a -> String

showList :: [Vertex1 a] -> ShowS

Ix a => Ix (Vertex1 a)

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)

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)

Methods

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

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

UniformComponent a => Uniform (Vertex1 a)

Methods

uniform :: UniformLocation -> StateVar (Vertex1 a)

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

data Vertex2 a

A vertex with z=0 and w=1.

Constructors

Vertex2 !a !a

Instances

Functor Vertex2

Methods

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

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

Applicative Vertex2

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

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

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

Methods

trimmingTarget :: Vertex2 GLfloat -> GLenum

Bounded a => Bounded (Vertex2 a)

Methods

minBound :: Vertex2 a

maxBound :: Vertex2 a

Eq a => Eq (Vertex2 a)

Methods

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

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

Ord a => Ord (Vertex2 a)

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)

Methods

readsPrec :: Int -> ReadS (Vertex2 a)

readList :: ReadS [Vertex2 a]

readPrec :: ReadPrec (Vertex2 a)

readListPrec :: ReadPrec [Vertex2 a]

Show a => Show (Vertex2 a)

Methods

showsPrec :: Int -> Vertex2 a -> ShowS

show :: Vertex2 a -> String

showList :: [Vertex2 a] -> ShowS

Ix a => Ix (Vertex2 a)

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)

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)

Methods

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

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

VertexComponent a => Vertex (Vertex2 a)

Methods

vertex :: Vertex2 a -> IO ()

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

WindowPosComponent a => WindowPos (Vertex2 a)

Methods

windowPos :: Vertex2 a -> IO ()

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

RasterPosComponent a => RasterPos (Vertex2 a)

Methods

rasterPos :: Vertex2 a -> IO ()

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

UniformComponent a => Uniform (Vertex2 a)

Methods

uniform :: UniformLocation -> StateVar (Vertex2 a)

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

data Vertex3 a

A vertex with w=1.

Constructors

Vertex3 !a !a !a

Instances

Functor Vertex3

Methods

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

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

Applicative Vertex3

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

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

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

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

Methods

trimmingTarget :: Vertex3 GLfloat -> GLenum

Bounded a => Bounded (Vertex3 a)

Methods

minBound :: Vertex3 a

maxBound :: Vertex3 a

Eq a => Eq (Vertex3 a)

Methods

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

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

Ord a => Ord (Vertex3 a)

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)

Methods

readsPrec :: Int -> ReadS (Vertex3 a)

readList :: ReadS [Vertex3 a]

readPrec :: ReadPrec (Vertex3 a)

readListPrec :: ReadPrec [Vertex3 a]

Show a => Show (Vertex3 a)

Methods

showsPrec :: Int -> Vertex3 a -> ShowS

show :: Vertex3 a -> String

showList :: [Vertex3 a] -> ShowS

Ix a => Ix (Vertex3 a)

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)

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)

Methods

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

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

VertexComponent a => Vertex (Vertex3 a)

Methods

vertex :: Vertex3 a -> IO ()

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

WindowPosComponent a => WindowPos (Vertex3 a)

Methods

windowPos :: Vertex3 a -> IO ()

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

RasterPosComponent a => RasterPos (Vertex3 a)

Methods

rasterPos :: Vertex3 a -> IO ()

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

UniformComponent a => Uniform (Vertex3 a)

Methods

uniform :: UniformLocation -> StateVar (Vertex3 a)

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

data Vertex4 a

A fully-fledged four-dimensional vertex.

Constructors

Vertex4 !a !a !a !a

Instances

Functor Vertex4

Methods

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

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

Applicative Vertex4

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

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

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

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)

Methods

minBound :: Vertex4 a

maxBound :: Vertex4 a

Eq a => Eq (Vertex4 a)

Methods

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

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

Ord a => Ord (Vertex4 a)

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)

Methods

readsPrec :: Int -> ReadS (Vertex4 a)

readList :: ReadS [Vertex4 a]

readPrec :: ReadPrec (Vertex4 a)

readListPrec :: ReadPrec [Vertex4 a]

Show a => Show (Vertex4 a)

Methods

showsPrec :: Int -> Vertex4 a -> ShowS

show :: Vertex4 a -> String

showList :: [Vertex4 a] -> ShowS

Ix a => Ix (Vertex4 a)

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)

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)

Methods

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

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

VertexComponent a => Vertex (Vertex4 a)

Methods

vertex :: Vertex4 a -> IO ()

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

RasterPosComponent a => RasterPos (Vertex4 a)

Methods

rasterPos :: Vertex4 a -> IO ()

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

UniformComponent a => Uniform (Vertex4 a)

Methods

uniform :: UniformLocation -> StateVar (Vertex4 a)

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

newtype Vector1 a

A one-dimensional vector.

Constructors

Vector1 a

Instances

Functor Vector1

Methods

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

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

Applicative Vector1

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

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

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)

Methods

minBound :: Vector1 a

maxBound :: Vector1 a

Eq a => Eq (Vector1 a)

Methods

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

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

Ord a => Ord (Vector1 a)

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)

Methods

readsPrec :: Int -> ReadS (Vector1 a)

readList :: ReadS [Vector1 a]

readPrec :: ReadPrec (Vector1 a)

readListPrec :: ReadPrec [Vector1 a]

Show a => Show (Vector1 a)

Methods

showsPrec :: Int -> Vector1 a -> ShowS

show :: Vector1 a -> String

showList :: [Vector1 a] -> ShowS

Ix a => Ix (Vector1 a)

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)

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)

Methods

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

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

UniformComponent a => Uniform (Vector1 a)

Methods

uniform :: UniformLocation -> StateVar (Vector1 a)

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

data Vector2 a

A two-dimensional vector.

Constructors

Vector2 !a !a

Instances

Functor Vector2

Methods

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

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

Applicative Vector2

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

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

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)

Methods

minBound :: Vector2 a

maxBound :: Vector2 a

Eq a => Eq (Vector2 a)

Methods

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

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

Ord a => Ord (Vector2 a)

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)

Methods

readsPrec :: Int -> ReadS (Vector2 a)

readList :: ReadS [Vector2 a]

readPrec :: ReadPrec (Vector2 a)

readListPrec :: ReadPrec [Vector2 a]

Show a => Show (Vector2 a)

Methods

showsPrec :: Int -> Vector2 a -> ShowS

show :: Vector2 a -> String

showList :: [Vector2 a] -> ShowS

Ix a => Ix (Vector2 a)

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)

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)

Methods

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

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

UniformComponent a => Uniform (Vector2 a)

Methods

uniform :: UniformLocation -> StateVar (Vector2 a)

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

data Vector3 a

A three-dimensional vector.

Constructors

Vector3 !a !a !a

Instances

Functor Vector3

Methods

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

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

Applicative Vector3

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

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

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)

Methods

minBound :: Vector3 a

maxBound :: Vector3 a

Eq a => Eq (Vector3 a)

Methods

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

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

Ord a => Ord (Vector3 a)

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)

Methods

readsPrec :: Int -> ReadS (Vector3 a)

readList :: ReadS [Vector3 a]

readPrec :: ReadPrec (Vector3 a)

readListPrec :: ReadPrec [Vector3 a]

Show a => Show (Vector3 a)

Methods

showsPrec :: Int -> Vector3 a -> ShowS

show :: Vector3 a -> String

showList :: [Vector3 a] -> ShowS

Ix a => Ix (Vector3 a)

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)

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)

Methods

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

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

UniformComponent a => Uniform (Vector3 a)

Methods

uniform :: UniformLocation -> StateVar (Vector3 a)

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

data Vector4 a

A four-dimensional vector.

Constructors

Vector4 !a !a !a !a

Instances

Functor Vector4

Methods

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

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

Applicative Vector4

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

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

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)

Methods

minBound :: Vector4 a

maxBound :: Vector4 a

Eq a => Eq (Vector4 a)

Methods

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

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

Ord a => Ord (Vector4 a)

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)

Methods

readsPrec :: Int -> ReadS (Vector4 a)

readList :: ReadS [Vector4 a]

readPrec :: ReadPrec (Vector4 a)

readListPrec :: ReadPrec [Vector4 a]

Show a => Show (Vector4 a)

Methods

showsPrec :: Int -> Vector4 a -> ShowS

show :: Vector4 a -> String

showList :: [Vector4 a] -> ShowS

Ix a => Ix (Vector4 a)

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)

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)

Methods

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

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

UniformComponent a => Uniform (Vector4 a)

Methods

uniform :: UniformLocation -> StateVar (Vector4 a)

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