Copyright	(c) Sven Panne 2016
License	BSD3
Maintainer	Sven Panne <svenpanne@gmail.com>
Stability	stable
Portability	portable
Safe Haskell	Safe
Language	Haskell2010

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 #
Methods minBound :: Vertex1 a # maxBound :: Vertex1 a #
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 #
Methods readsPrec :: Int -> ReadS (Vertex1 a) # readList :: ReadS [Vertex1 a] # readPrec :: ReadPrec (Vertex1 a) # readListPrec :: ReadPrec [Vertex1 a] #
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 #
Methods vertexAttrib :: IntegerHandling -> AttribLocation -> Vertex1 a -> IO () Source # vertexAttribv :: IntegerHandling -> AttribLocation -> Ptr (Vertex1 a) -> IO () Source #
UniformComponent a => Uniform (Vertex1 a) Source #
Methods uniform :: UniformLocation -> StateVar (Vertex1 a) Source # uniformv :: UniformLocation -> GLsizei -> Ptr (Vertex1 a) -> IO () 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 #
Methods trimmingTarget :: Vertex2 GLfloat -> GLenum
Bounded a => Bounded (Vertex2 a) Source #
Methods minBound :: Vertex2 a # maxBound :: Vertex2 a #
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 #
Methods readsPrec :: Int -> ReadS (Vertex2 a) # readList :: ReadS [Vertex2 a] # readPrec :: ReadPrec (Vertex2 a) # readListPrec :: ReadPrec [Vertex2 a] #
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 #
Methods vertexAttrib :: IntegerHandling -> AttribLocation -> Vertex2 a -> IO () Source # vertexAttribv :: IntegerHandling -> AttribLocation -> Ptr (Vertex2 a) -> IO () 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 #
Methods uniform :: UniformLocation -> StateVar (Vertex2 a) Source # uniformv :: UniformLocation -> GLsizei -> Ptr (Vertex2 a) -> IO () 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 #
Methods trimmingTarget :: Vertex3 GLfloat -> GLenum
Bounded a => Bounded (Vertex3 a) Source #
Methods minBound :: Vertex3 a # maxBound :: Vertex3 a #
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 #
Methods readsPrec :: Int -> ReadS (Vertex3 a) # readList :: ReadS [Vertex3 a] # readPrec :: ReadPrec (Vertex3 a) # readListPrec :: ReadPrec [Vertex3 a] #
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 #
Methods vertexAttrib :: IntegerHandling -> AttribLocation -> Vertex3 a -> IO () Source # vertexAttribv :: IntegerHandling -> AttribLocation -> Ptr (Vertex3 a) -> IO () 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 #
Methods uniform :: UniformLocation -> StateVar (Vertex3 a) Source # uniformv :: UniformLocation -> GLsizei -> Ptr (Vertex3 a) -> IO () 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 #
Methods minBound :: Vertex4 a # maxBound :: Vertex4 a #
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 #
Methods readsPrec :: Int -> ReadS (Vertex4 a) # readList :: ReadS [Vertex4 a] # readPrec :: ReadPrec (Vertex4 a) # readListPrec :: ReadPrec [Vertex4 a] #
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 #
Methods vertexAttrib :: IntegerHandling -> AttribLocation -> Vertex4 a -> IO () Source # vertexAttribv :: IntegerHandling -> AttribLocation -> Ptr (Vertex4 a) -> IO () 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 #
Methods uniform :: UniformLocation -> StateVar (Vertex4 a) Source # uniformv :: UniformLocation -> GLsizei -> Ptr (Vertex4 a) -> IO () 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 #
Methods minBound :: Vector1 a # maxBound :: Vector1 a #
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 #
Methods readsPrec :: Int -> ReadS (Vector1 a) # readList :: ReadS [Vector1 a] # readPrec :: ReadPrec (Vector1 a) # readListPrec :: ReadPrec [Vector1 a] #
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 #
Methods vertexAttrib :: IntegerHandling -> AttribLocation -> Vector1 a -> IO () Source # vertexAttribv :: IntegerHandling -> AttribLocation -> Ptr (Vector1 a) -> IO () Source #
UniformComponent a => Uniform (Vector1 a) Source #
Methods uniform :: UniformLocation -> StateVar (Vector1 a) Source # uniformv :: UniformLocation -> GLsizei -> Ptr (Vector1 a) -> IO () 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 #
Methods minBound :: Vector2 a # maxBound :: Vector2 a #
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 #
Methods readsPrec :: Int -> ReadS (Vector2 a) # readList :: ReadS [Vector2 a] # readPrec :: ReadPrec (Vector2 a) # readListPrec :: ReadPrec [Vector2 a] #
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 #
Methods vertexAttrib :: IntegerHandling -> AttribLocation -> Vector2 a -> IO () Source # vertexAttribv :: IntegerHandling -> AttribLocation -> Ptr (Vector2 a) -> IO () Source #
UniformComponent a => Uniform (Vector2 a) Source #
Methods uniform :: UniformLocation -> StateVar (Vector2 a) Source # uniformv :: UniformLocation -> GLsizei -> Ptr (Vector2 a) -> IO () 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 #
Methods minBound :: Vector3 a # maxBound :: Vector3 a #
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 #
Methods readsPrec :: Int -> ReadS (Vector3 a) # readList :: ReadS [Vector3 a] # readPrec :: ReadPrec (Vector3 a) # readListPrec :: ReadPrec [Vector3 a] #
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 #
Methods vertexAttrib :: IntegerHandling -> AttribLocation -> Vector3 a -> IO () Source # vertexAttribv :: IntegerHandling -> AttribLocation -> Ptr (Vector3 a) -> IO () Source #
UniformComponent a => Uniform (Vector3 a) Source #
Methods uniform :: UniformLocation -> StateVar (Vector3 a) Source # uniformv :: UniformLocation -> GLsizei -> Ptr (Vector3 a) -> IO () 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 #
Methods minBound :: Vector4 a # maxBound :: Vector4 a #
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 #
Methods readsPrec :: Int -> ReadS (Vector4 a) # readList :: ReadS [Vector4 a] # readPrec :: ReadPrec (Vector4 a) # readListPrec :: ReadPrec [Vector4 a] #
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 #
Methods vertexAttrib :: IntegerHandling -> AttribLocation -> Vector4 a -> IO () Source # vertexAttribv :: IntegerHandling -> AttribLocation -> Ptr (Vector4 a) -> IO () Source #
UniformComponent a => Uniform (Vector4 a) Source #
Methods uniform :: UniformLocation -> StateVar (Vector4 a) Source # uniformv :: UniformLocation -> GLsizei -> Ptr (Vector4 a) -> IO () Source #