OpenGL-2.8.0.0: A binding for the OpenGL graphics system

Portabilityportable
Stabilitystable
Maintainersven.panne@aedion.de
Safe HaskellNone

Graphics.Rendering.OpenGL.GL.VertexSpec

Contents

Description

This module corresponds to section 2.7 (Vertex Specification) of the OpenGL 2.1 specs.

Synopsis

Vertex Coordinates

class Vertex a whereSource

Specify the (x, y, z, w) coordinates of a four-dimensional vertex. This must only be done during renderPrimitive, otherwise the behaviour is unspecified. The current values of the auxiliary vertex attributes are associated with the vertex.

Note that there is no such thing as a "current vertex" which could be retrieved.

Methods

vertex :: a -> IO ()Source

vertexv :: Ptr a -> IO ()Source

class VertexComponent a Source

The class of all types which can be used as a vertex coordinate.

Auxiliary Vertex Attributes

Apart from its coordinates in four-dimensional space, every vertex has associated auxiliary attributes: Its texture coordinates, a normal, a fog coordinate, and a color plus a secondary color. For every attribute, the OpenGL state contains its current value, which can be changed at any time.

Every attribute has a "natural" format via which it can be manipulated directly as part of the OpenGL state, e.g. the current texture coordinates are internally handled as TexCoord4 GLfloat. Different formats are converted to this format, e.g. the s, r, and t coordinates of a TexCoord3 GLint are converted to floating point values and a q coordinate of 1.0 is implicitly assumed.

Consequently, the vast majority of classes, functions, and data types in this module are for convenience only and offer no additional functionality.

Texture Coordinates

currentTextureCoords :: StateVar (TexCoord4 GLfloat)Source

The current texture coordinates (s, t, r, q) for the current texture unit (see activeTexture). The initial value is (0,0,0,1) for all texture units.

class TexCoord a whereSource

Change the current texture coordinates of the current or given texture unit.

Methods

texCoord :: a -> IO ()Source

texCoordv :: Ptr a -> IO ()Source

multiTexCoord :: TextureUnit -> a -> IO ()Source

multiTexCoordv :: TextureUnit -> Ptr a -> IO ()Source

class TexCoordComponent a Source

The class of all types which can be used as a texture coordinate.

newtype TexCoord1 a Source

Texture coordinates with t=0, r=0, and q=1.

Constructors

TexCoord1 a 

Instances

Functor TexCoord1 
Typeable1 TexCoord1 
Applicative TexCoord1 
Foldable TexCoord1 
Traversable TexCoord1 
ControlPoint TexCoord1 
Bounded a => Bounded (TexCoord1 a) 
Eq a => Eq (TexCoord1 a) 
Ord a => Ord (TexCoord1 a) 
Read a => Read (TexCoord1 a) 
Show a => Show (TexCoord1 a) 
Ix a => Ix (TexCoord1 a) 
Storable a => Storable (TexCoord1 a) 
VertexAttribComponent a => VertexAttrib (TexCoord1 a) 
TexCoordComponent a => TexCoord (TexCoord1 a) 
UniformComponent a => Uniform (TexCoord1 a) 

data TexCoord2 a Source

Texture coordinates with r=0 and q=1.

Constructors

TexCoord2 !a !a 

Instances

Functor TexCoord2 
Typeable1 TexCoord2 
Applicative TexCoord2 
Foldable TexCoord2 
Traversable TexCoord2 
ControlPoint TexCoord2 
Bounded a => Bounded (TexCoord2 a) 
Eq a => Eq (TexCoord2 a) 
Ord a => Ord (TexCoord2 a) 
Read a => Read (TexCoord2 a) 
Show a => Show (TexCoord2 a) 
Ix a => Ix (TexCoord2 a) 
Storable a => Storable (TexCoord2 a) 
VertexAttribComponent a => VertexAttrib (TexCoord2 a) 
TexCoordComponent a => TexCoord (TexCoord2 a) 
UniformComponent a => Uniform (TexCoord2 a) 

data TexCoord3 a Source

Texture coordinates with q=1.

Constructors

TexCoord3 !a !a !a 

Instances

Functor TexCoord3 
Typeable1 TexCoord3 
Applicative TexCoord3 
Foldable TexCoord3 
Traversable TexCoord3 
ControlPoint TexCoord3 
Bounded a => Bounded (TexCoord3 a) 
Eq a => Eq (TexCoord3 a) 
Ord a => Ord (TexCoord3 a) 
Read a => Read (TexCoord3 a) 
Show a => Show (TexCoord3 a) 
Ix a => Ix (TexCoord3 a) 
Storable a => Storable (TexCoord3 a) 
VertexAttribComponent a => VertexAttrib (TexCoord3 a) 
TexCoordComponent a => TexCoord (TexCoord3 a) 
UniformComponent a => Uniform (TexCoord3 a) 

data TexCoord4 a Source

Fully-fledged four-dimensional texture coordinates.

Constructors

TexCoord4 !a !a !a !a 

Instances

Functor TexCoord4 
Typeable1 TexCoord4 
Applicative TexCoord4 
Foldable TexCoord4 
Traversable TexCoord4 
ControlPoint TexCoord4 
Bounded a => Bounded (TexCoord4 a) 
Eq a => Eq (TexCoord4 a) 
Ord a => Ord (TexCoord4 a) 
Read a => Read (TexCoord4 a) 
Show a => Show (TexCoord4 a) 
Ix a => Ix (TexCoord4 a) 
Storable a => Storable (TexCoord4 a) 
VertexAttribComponent a => VertexAttrib (TexCoord4 a) 
TexCoordComponent a => TexCoord (TexCoord4 a) 
UniformComponent a => Uniform (TexCoord4 a) 

Normal

currentNormal :: StateVar (Normal3 GLfloat)Source

The current normal (x, y, z). The initial value is the unit vector (0, 0, 1).

class Normal a whereSource

Change the current normal. Integral arguments are converted to floating-point with a linear mapping that maps the most positive representable integer value to 1.0, and the most negative representable integer value to -1.0.

Normals specified with normal or normalv need not have unit length. If normalize is enabled, then normals of any length specified with normal or normalv are normalized after transformation. If rescaleNormal is enabled, normals are scaled by a scaling factor derived from the modelview matrix. rescaleNormal requires that the originally specified normals were of unit length, and that the modelview matrix contains only uniform scales for proper results. Normalization is initially disabled.

Methods

normal :: a -> IO ()Source

normalv :: Ptr a -> IO ()Source

Instances

class NormalComponent a Source

The class of all types which can be used as a component of a normal.

data Normal3 a Source

Constructors

Normal3 !a !a !a 

Instances

Functor Normal3 
Typeable1 Normal3 
Applicative Normal3 
Foldable Normal3 
Traversable Normal3 
ControlPoint Normal3 
Bounded a => Bounded (Normal3 a) 
Eq a => Eq (Normal3 a) 
Ord a => Ord (Normal3 a) 
Read a => Read (Normal3 a) 
Show a => Show (Normal3 a) 
Ix a => Ix (Normal3 a) 
Storable a => Storable (Normal3 a) 
VertexAttribComponent a => VertexAttrib (Normal3 a) 
NormalComponent a => Normal (Normal3 a) 
UniformComponent a => Uniform (Normal3 a) 

Fog Coordinate

currentFogCoord :: StateVar (FogCoord1 GLfloat)Source

The current fog coordinate. The initial value is 0.

class FogCoord a whereSource

Change the current fog coordinate.

Methods

fogCoord :: a -> IO ()Source

fogCoordv :: Ptr a -> IO ()Source

class FogCoordComponent a Source

The class of all types which can be used as the fog coordinate.

newtype FogCoord1 a Source

A fog coordinate.

Constructors

FogCoord1 a 

Instances

Functor FogCoord1 
Typeable1 FogCoord1 
Applicative FogCoord1 
Foldable FogCoord1 
Traversable FogCoord1 
Bounded a => Bounded (FogCoord1 a) 
Eq a => Eq (FogCoord1 a) 
Ord a => Ord (FogCoord1 a) 
Read a => Read (FogCoord1 a) 
Show a => Show (FogCoord1 a) 
Ix a => Ix (FogCoord1 a) 
Storable a => Storable (FogCoord1 a) 
VertexAttribComponent a => VertexAttrib (FogCoord1 a) 
FogCoordComponent a => FogCoord (FogCoord1 a) 
UniformComponent a => Uniform (FogCoord1 a) 

Color and Secondary Color

rgbaMode :: GettableStateVar BoolSource

If rgbaMode contains True, the color buffers store RGBA value. If color indexes are stored, it contains False.

class Color a whereSource

Change the current color.

Methods

color :: a -> IO ()Source

colorv :: Ptr a -> IO ()Source

Instances

class SecondaryColor a whereSource

Change the current secondary color.

Methods

secondaryColor :: a -> IO ()Source

secondaryColorv :: Ptr a -> IO ()Source

data Color3 a Source

Constructors

Color3 !a !a !a 

Instances

Functor Color3 
Typeable1 Color3 
Applicative Color3 
Foldable Color3 
Traversable Color3 
Bounded a => Bounded (Color3 a) 
Eq a => Eq (Color3 a) 
Ord a => Ord (Color3 a) 
Read a => Read (Color3 a) 
Show a => Show (Color3 a) 
Ix a => Ix (Color3 a) 
Storable a => Storable (Color3 a) 
VertexAttribComponent a => VertexAttrib (Color3 a) 
ColorComponent a => SecondaryColor (Color3 a) 
ColorComponent a => Color (Color3 a) 
UniformComponent a => Uniform (Color3 a) 

data Color4 a Source

A fully-fledged RGBA color.

Constructors

Color4 !a !a !a !a 

Instances

Functor Color4 
Typeable1 Color4 
Applicative Color4 
Foldable Color4 
Traversable Color4 
ControlPoint Color4 
Bounded a => Bounded (Color4 a) 
Eq a => Eq (Color4 a) 
Ord a => Ord (Color4 a) 
Read a => Read (Color4 a) 
Show a => Show (Color4 a) 
Ix a => Ix (Color4 a) 
Storable a => Storable (Color4 a) 
VertexAttribComponent a => VertexAttrib (Color4 a) 
ColorComponent a => Color (Color4 a) 
UniformComponent a => Uniform (Color4 a) 

class Index a whereSource

Change the current color index.

Methods

index :: a -> IO ()Source

indexv :: Ptr a -> IO ()Source

Instances

class IndexComponent a Source

The class of all types which can be used as a color index.

newtype Index1 a Source

A color index.

Constructors

Index1 a 

Instances

Functor Index1 
Typeable1 Index1 
Applicative Index1 
Foldable Index1 
Traversable Index1 
ControlPoint Index1 
Bounded a => Bounded (Index1 a) 
Eq a => Eq (Index1 a) 
Ord a => Ord (Index1 a) 
Read a => Read (Index1 a) 
Show a => Show (Index1 a) 
Ix a => Ix (Index1 a) 
Storable a => Storable (Index1 a) 
VertexAttribComponent a => VertexAttrib (Index1 a) 
IndexComponent a => Index (Index1 a) 
UniformComponent a => Uniform (Index1 a) 

Generic Vertex Attributes

class (Storable a, Num a) => VertexAttribComponent a whereSource

The class of all types which can be used as a generic vertex attribute. NOTE: Do not use the methods of this class directly, they were only exported by accident and will be hidden in future versions of this package.

Methods

vertexAttrib1 :: AttribLocation -> a -> IO ()Source

vertexAttrib2 :: AttribLocation -> a -> a -> IO ()Source

vertexAttrib3 :: AttribLocation -> a -> a -> a -> IO ()Source

vertexAttrib4 :: AttribLocation -> a -> a -> a -> a -> IO ()Source

vertexAttrib1N :: AttribLocation -> a -> IO ()Source

vertexAttrib2N :: AttribLocation -> a -> a -> IO ()Source

vertexAttrib3N :: AttribLocation -> a -> a -> a -> IO ()Source

vertexAttrib4N :: AttribLocation -> a -> a -> a -> a -> IO ()Source

vertexAttrib1I :: AttribLocation -> a -> IO ()Source

vertexAttrib2I :: AttribLocation -> a -> a -> IO ()Source

vertexAttrib3I :: AttribLocation -> a -> a -> a -> IO ()Source

vertexAttrib4I :: AttribLocation -> a -> a -> a -> a -> IO ()Source

vertexAttrib1v :: AttribLocation -> Ptr a -> IO ()Source

vertexAttrib2v :: AttribLocation -> Ptr a -> IO ()Source

vertexAttrib3v :: AttribLocation -> Ptr a -> IO ()Source

vertexAttrib4v :: AttribLocation -> Ptr a -> IO ()Source

vertexAttrib1Nv :: AttribLocation -> Ptr a -> IO ()Source

vertexAttrib2Nv :: AttribLocation -> Ptr a -> IO ()Source

vertexAttrib3Nv :: AttribLocation -> Ptr a -> IO ()Source

vertexAttrib4Nv :: AttribLocation -> Ptr a -> IO ()Source

vertexAttrib1Iv :: AttribLocation -> Ptr a -> IO ()Source

vertexAttrib2Iv :: AttribLocation -> Ptr a -> IO ()Source

vertexAttrib3Iv :: AttribLocation -> Ptr a -> IO ()Source

vertexAttrib4Iv :: AttribLocation -> Ptr a -> IO ()Source

Texture Units

newtype TextureUnit Source

Identifies a texture unit via its number, which must be in the range of (0 .. maxTextureUnit).

Constructors

TextureUnit GLuint 

maxTextureUnit :: GettableStateVar TextureUnitSource

An implementation must support at least 2 texture units, but it may support up to 32 ones. This state variable can be used to query the actual implementation limit.