Graphics.Rendering.OpenGL.Raw.Types

All types from the whole OpenGL registry.

Types from OpenGL itself.

type GLboolean = CUChar

8bit boolean.

type GLbyte = CSChar

8bit signed two's complement binary integer.

type GLubyte = CUChar

8bit unsigned binary integer.

type GLchar = CChar

8bit characters making up strings.

type GLshort = CShort

16bit signed two's complement binary integer.

type GLushort = CUShort

16bit unsigned binary integer.

type GLint = CInt

32bit signed two's complement binary integer.

type GLuint = CUInt

32bit unsigned binary integer.

type GLfixed = CInt

32bit signed two's complement 16.16 scaled integer.

type GLint64 = Int64

64bit signed two's complement binary integer.

type GLuint64 = Word64

64bit unsigned binary integer.

type GLsizei = CInt

32bit non-negative binary integer size.

type GLenum = CUInt

32bit enumerated binary integer value.

type GLintptr = CPtrdiff

Pointer-sized signed two's complement binary integer.

type GLsizeiptr = CPtrdiff

Pointer-sized non-negative binary integer size.

type GLsync = Ptr ()

Pointer-sized sync object handle.

type GLbitfield = CUInt

32bit bit field.

type GLhalf = CUShort

16bit half-precision floating-point value encoded in an unsigned scalar.

type GLfloat = CFloat

32bit floating-point value.

type GLclampf = CFloat

32bit floating-point value clamped to [0, 1].

type GLdouble = CDouble

64bit floating-point value.

type GLclampd = CDouble

64bit floating-point value clamped to [0, 1].

type GLDEBUGPROC = FunPtr GLDEBUGPROCFunc

A pointer to a debug callback.

type GLDEBUGPROCFunc

Arguments

 = GLenum

source.

-> GLenum

type.

-> GLuint

id.

-> GLenum

severity.

-> GLsizei

length.

-> Ptr GLchar

message.

-> Ptr ()

userParam.

-> IO ()

Debug callback.

makeGLDEBUGPROC :: GLDEBUGPROCFunc -> IO (FunPtr GLDEBUGPROCFunc)

The storage associated with the resulting FunPtr has to be released with freeHaskellFunPtr when it is no longer required.

type GLvoid = ()

Not an actual GL type, though used in headers in the past.

Pre-standard OpenGL types.

type GLcharARB = CChar

type GLint64EXT = Int64

type GLuint64EXT = Word64

type GLintptrARB = CPtrdiff

type GLsizeiptrARB = CPtrdiff

type GLhalfARB = CUShort

type GLhalfNV = CUShort

type GLDEBUGPROCAMD = FunPtr GLDEBUGPROCAMDFunc

type GLDEBUGPROCAMDFunc

Arguments

 = GLuint

id.

-> GLenum

category.

-> GLenum

severity.

-> GLsizei

length.

-> Ptr GLchar

message.

-> Ptr ()

userParam.

-> IO ()

Debug callback.

makeGLDEBUGPROCAMD :: GLDEBUGPROCAMDFunc -> IO (FunPtr GLDEBUGPROCAMDFunc)

The storage associated with the resulting FunPtr has to be released with freeHaskellFunPtr when it is no longer required.

type GLDEBUGPROCARB = GLDEBUGPROC

type GLDEBUGPROCARBFunc = GLDEBUGPROCFunc

makeGLDEBUGPROCARB :: GLDEBUGPROCARBFunc -> IO (FunPtr GLDEBUGPROCARBFunc)

type GLDEBUGPROCKHR = GLDEBUGPROC

type GLDEBUGPROCKHRFunc = GLDEBUGPROCFunc

makeGLDEBUGPROCKHR :: GLDEBUGPROCKHRFunc -> IO (FunPtr GLDEBUGPROCKHRFunc)

Types from various extensions.

type GLclampx = CInt

type GLhandleARB = CUInt

type GLvdpauSurfaceNV = GLintptr

type GLeglImageOES = Ptr ()

Re-exports

newtype CChar :: *

Haskell type representing the C char type.

Constructors

CChar Int8

Instances

Bounded CChar

Enum CChar

Eq CChar

Integral CChar

Num CChar

Ord CChar

Read CChar

Real CChar

Show CChar

Storable CChar

Bits CChar

FiniteBits CChar

Typeable * CChar

newtype CDouble :: *

Haskell type representing the C double type.

Constructors

CDouble Double

Instances

Enum CDouble

Eq CDouble

Floating CDouble

Fractional CDouble

Num CDouble

Ord CDouble

Read CDouble

Real CDouble

RealFloat CDouble

RealFrac CDouble

Show CDouble

Storable CDouble

Typeable * CDouble

newtype CFloat :: *

Haskell type representing the C float type.

Constructors

CFloat Float

Instances

Enum CFloat

Eq CFloat

Floating CFloat

Fractional CFloat

Num CFloat

Ord CFloat

Read CFloat

Real CFloat

RealFloat CFloat

RealFrac CFloat

Show CFloat

Storable CFloat

Typeable * CFloat

newtype CInt :: *

Haskell type representing the C int type.

Constructors

CInt Int32

Instances

Bounded CInt

Enum CInt

Eq CInt

Integral CInt

Num CInt

Ord CInt

Read CInt

Real CInt

Show CInt

Storable CInt

Bits CInt

FiniteBits CInt

Typeable * CInt

newtype CPtrdiff :: *

Haskell type representing the C ptrdiff_t type.

Constructors

CPtrdiff Int64

Instances

Bounded CPtrdiff

Enum CPtrdiff

Eq CPtrdiff

Integral CPtrdiff

Num CPtrdiff

Ord CPtrdiff

Read CPtrdiff

Real CPtrdiff

Show CPtrdiff

Storable CPtrdiff

Bits CPtrdiff

FiniteBits CPtrdiff

Typeable * CPtrdiff

newtype CSChar :: *

Haskell type representing the C signed char type.

Constructors

CSChar Int8

Instances

Bounded CSChar

Enum CSChar

Eq CSChar

Integral CSChar

Num CSChar

Ord CSChar

Read CSChar

Real CSChar

Show CSChar

Storable CSChar

Bits CSChar

FiniteBits CSChar

Typeable * CSChar

newtype CShort :: *

Haskell type representing the C short type.

Constructors

CShort Int16

Instances

Bounded CShort

Enum CShort

Eq CShort

Integral CShort

Num CShort

Ord CShort

Read CShort

Real CShort

Show CShort

Storable CShort

Bits CShort

FiniteBits CShort

Typeable * CShort

newtype CUChar :: *

Haskell type representing the C unsigned char type.

Constructors

CUChar Word8

Instances

Bounded CUChar

Enum CUChar

Eq CUChar

Integral CUChar

Num CUChar

Ord CUChar

Read CUChar

Real CUChar

Show CUChar

Storable CUChar

Bits CUChar

FiniteBits CUChar

Typeable * CUChar

newtype CUInt :: *

Haskell type representing the C unsigned int type.

Constructors

CUInt Word32

Instances

Bounded CUInt

Enum CUInt

Eq CUInt

Integral CUInt

Num CUInt

Ord CUInt

Read CUInt

Real CUInt

Show CUInt

Storable CUInt

Bits CUInt

FiniteBits CUInt

Typeable * CUInt

newtype CUShort :: *

Haskell type representing the C unsigned short type.

Constructors

CUShort Word16

Instances

Bounded CUShort

Enum CUShort

Eq CUShort

Integral CUShort

Num CUShort

Ord CUShort

Read CUShort

Real CUShort

Show CUShort

Storable CUShort

Bits CUShort

FiniteBits CUShort

Typeable * CUShort

data Int64 :: *

64-bit signed integer type

Instances

Bounded Int64

Enum Int64

Eq Int64

Integral Int64

Num Int64

Ord Int64

Read Int64

Real Int64

Show Int64

Ix Int64

Bits Int64

FiniteBits Int64

Typeable * Int64

data Word64 :: *

64-bit unsigned integer type

Instances

Bounded Word64

Enum Word64

Eq Word64

Integral Word64

Num Word64

Ord Word64

Read Word64

Real Word64

Show Word64

Ix Word64

Bits Word64

FiniteBits Word64

data FunPtr a :: * -> *

A value of type FunPtr a is a pointer to a function callable from foreign code. The type a will normally be a foreign type, a function type with zero or more arguments where

• the argument types are marshallable foreign types, i.e. Char, Int, Double, Float, Bool, Int8, Int16, Int32, Int64, Word8, Word16, Word32, Word64, Ptr a, FunPtr a, StablePtr a or a renaming of any of these using newtype.
• the return type is either a marshallable foreign type or has the form IO t where t is a marshallable foreign type or ().

A value of type FunPtr a may be a pointer to a foreign function, either returned by another foreign function or imported with a a static address import like

foreign import ccall "stdlib.h &free"
  p_free :: FunPtr (Ptr a -> IO ())

or a pointer to a Haskell function created using a wrapper stub declared to produce a FunPtr of the correct type. For example:

type Compare = Int -> Int -> Bool
foreign import ccall "wrapper"
  mkCompare :: Compare -> IO (FunPtr Compare)

Calls to wrapper stubs like mkCompare allocate storage, which should be released with freeHaskellFunPtr when no longer required.

To convert FunPtr values to corresponding Haskell functions, one can define a dynamic stub for the specific foreign type, e.g.

type IntFunction = CInt -> IO ()
foreign import ccall "dynamic" 
  mkFun :: FunPtr IntFunction -> IntFunction

Instances

Eq (FunPtr a)

Ord (FunPtr a)

Show (FunPtr a)

data Ptr a :: * -> *

A value of type Ptr a represents a pointer to an object, or an array of objects, which may be marshalled to or from Haskell values of type a.

The type a will often be an instance of class Storable which provides the marshalling operations. However this is not essential, and you can provide your own operations to access the pointer. For example you might write small foreign functions to get or set the fields of a C struct.

Instances

Eq (Ptr a)

Ord (Ptr a)

Show (Ptr a)