--------------------------------------------------------------------------------
-- |
-- Module      :  Graphics.Rendering.OpenGL.GL.VertexArrays
-- Copyright   :  (c) Sven Panne 2002-2019
-- License     :  BSD3
--
-- Maintainer  :  Sven Panne <svenpanne@gmail.com>
-- Stability   :  stable
-- Portability :  portable
--
-- This module corresponds to section 2.8 (Vertex Arrays) of the OpenGL 2.1
-- specs.
--
--------------------------------------------------------------------------------

module Graphics.Rendering.OpenGL.GL.VertexArrays (
   -- * Describing Data for the Arrays
   NumComponents, DataType(..), Stride, VertexArrayDescriptor(..),

   -- * Specifying Data for the Arrays
   Capability(..),
   ClientArrayType(..), arrayPointer,
   InterleavedArrays(..), interleavedArrays,

   -- * Enabling Arrays
   clientState, clientActiveTexture,

   -- * Dereferencing and Rendering
   ArrayIndex, NumArrayIndices, NumIndexBlocks, NumInstances,
   BaseInstance, BaseVertex,
   arrayElement,

   drawArrays, drawArraysInstancedBaseInstance, drawArraysInstanced,
   multiDrawArrays,

   drawElements, drawElementsInstancedBaseInstance, drawElementsInstanced,
   multiDrawElements, drawRangeElements,

   drawElementsBaseVertex, drawRangeElementsBaseVertex,
   drawElementsInstancedBaseVertex, drawElementsInstancedBaseVertexBaseInstance,
   multiDrawElementsBaseVertex,

   maxElementsVertices, maxElementsIndices, lockArrays,
   primitiveRestartIndex, primitiveRestartIndexNV,

   -- * Generic Vertex Attribute Arrays
   vertexAttribPointer, vertexAttribArray,
) where

import Data.StateVar
import Foreign.Ptr ( Ptr, nullPtr )
import Graphics.Rendering.OpenGL.GL.Capability
import Graphics.Rendering.OpenGL.GL.DataType
import Graphics.Rendering.OpenGL.GL.GLboolean
import Graphics.Rendering.OpenGL.GL.PrimitiveMode
import Graphics.Rendering.OpenGL.GL.PrimitiveModeInternal
import Graphics.Rendering.OpenGL.GL.QueryUtils
import Graphics.Rendering.OpenGL.GL.Texturing.TextureUnit
import Graphics.Rendering.OpenGL.GL.VertexSpec
import Graphics.Rendering.OpenGL.GLU.ErrorsInternal
import Graphics.GL

--------------------------------------------------------------------------------

type NumComponents = GLint

type Stride = GLsizei

data VertexArrayDescriptor a =
   VertexArrayDescriptor !NumComponents !DataType !Stride !(Ptr a)
   deriving ( VertexArrayDescriptor a -> VertexArrayDescriptor a -> Bool
forall a.
VertexArrayDescriptor a -> VertexArrayDescriptor a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VertexArrayDescriptor a -> VertexArrayDescriptor a -> Bool
$c/= :: forall a.
VertexArrayDescriptor a -> VertexArrayDescriptor a -> Bool
== :: VertexArrayDescriptor a -> VertexArrayDescriptor a -> Bool
$c== :: forall a.
VertexArrayDescriptor a -> VertexArrayDescriptor a -> Bool
Eq, VertexArrayDescriptor a -> VertexArrayDescriptor a -> Bool
VertexArrayDescriptor a -> VertexArrayDescriptor a -> Ordering
forall a. Eq (VertexArrayDescriptor a)
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall a.
VertexArrayDescriptor a -> VertexArrayDescriptor a -> Bool
forall a.
VertexArrayDescriptor a -> VertexArrayDescriptor a -> Ordering
forall a.
VertexArrayDescriptor a
-> VertexArrayDescriptor a -> VertexArrayDescriptor a
min :: VertexArrayDescriptor a
-> VertexArrayDescriptor a -> VertexArrayDescriptor a
$cmin :: forall a.
VertexArrayDescriptor a
-> VertexArrayDescriptor a -> VertexArrayDescriptor a
max :: VertexArrayDescriptor a
-> VertexArrayDescriptor a -> VertexArrayDescriptor a
$cmax :: forall a.
VertexArrayDescriptor a
-> VertexArrayDescriptor a -> VertexArrayDescriptor a
>= :: VertexArrayDescriptor a -> VertexArrayDescriptor a -> Bool
$c>= :: forall a.
VertexArrayDescriptor a -> VertexArrayDescriptor a -> Bool
> :: VertexArrayDescriptor a -> VertexArrayDescriptor a -> Bool
$c> :: forall a.
VertexArrayDescriptor a -> VertexArrayDescriptor a -> Bool
<= :: VertexArrayDescriptor a -> VertexArrayDescriptor a -> Bool
$c<= :: forall a.
VertexArrayDescriptor a -> VertexArrayDescriptor a -> Bool
< :: VertexArrayDescriptor a -> VertexArrayDescriptor a -> Bool
$c< :: forall a.
VertexArrayDescriptor a -> VertexArrayDescriptor a -> Bool
compare :: VertexArrayDescriptor a -> VertexArrayDescriptor a -> Ordering
$ccompare :: forall a.
VertexArrayDescriptor a -> VertexArrayDescriptor a -> Ordering
Ord, Int -> VertexArrayDescriptor a -> ShowS
forall a. Int -> VertexArrayDescriptor a -> ShowS
forall a. [VertexArrayDescriptor a] -> ShowS
forall a. VertexArrayDescriptor a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [VertexArrayDescriptor a] -> ShowS
$cshowList :: forall a. [VertexArrayDescriptor a] -> ShowS
show :: VertexArrayDescriptor a -> String
$cshow :: forall a. VertexArrayDescriptor a -> String
showsPrec :: Int -> VertexArrayDescriptor a -> ShowS
$cshowsPrec :: forall a. Int -> VertexArrayDescriptor a -> ShowS
Show )

noVertexArrayDescriptor :: VertexArrayDescriptor a
noVertexArrayDescriptor :: forall a. VertexArrayDescriptor a
noVertexArrayDescriptor = forall a.
ArrayIndex
-> DataType -> ArrayIndex -> Ptr a -> VertexArrayDescriptor a
VertexArrayDescriptor ArrayIndex
0 DataType
Byte ArrayIndex
0 forall a. Ptr a
nullPtr

--------------------------------------------------------------------------------

data ClientArrayType =
     VertexArray
   | NormalArray
   | ColorArray
   | IndexArray
   | TextureCoordArray
   | EdgeFlagArray
   | FogCoordArray
   | SecondaryColorArray
   | MatrixIndexArray
   deriving ( ClientArrayType -> ClientArrayType -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ClientArrayType -> ClientArrayType -> Bool
$c/= :: ClientArrayType -> ClientArrayType -> Bool
== :: ClientArrayType -> ClientArrayType -> Bool
$c== :: ClientArrayType -> ClientArrayType -> Bool
Eq, Eq ClientArrayType
ClientArrayType -> ClientArrayType -> Bool
ClientArrayType -> ClientArrayType -> Ordering
ClientArrayType -> ClientArrayType -> ClientArrayType
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: ClientArrayType -> ClientArrayType -> ClientArrayType
$cmin :: ClientArrayType -> ClientArrayType -> ClientArrayType
max :: ClientArrayType -> ClientArrayType -> ClientArrayType
$cmax :: ClientArrayType -> ClientArrayType -> ClientArrayType
>= :: ClientArrayType -> ClientArrayType -> Bool
$c>= :: ClientArrayType -> ClientArrayType -> Bool
> :: ClientArrayType -> ClientArrayType -> Bool
$c> :: ClientArrayType -> ClientArrayType -> Bool
<= :: ClientArrayType -> ClientArrayType -> Bool
$c<= :: ClientArrayType -> ClientArrayType -> Bool
< :: ClientArrayType -> ClientArrayType -> Bool
$c< :: ClientArrayType -> ClientArrayType -> Bool
compare :: ClientArrayType -> ClientArrayType -> Ordering
$ccompare :: ClientArrayType -> ClientArrayType -> Ordering
Ord, Int -> ClientArrayType -> ShowS
[ClientArrayType] -> ShowS
ClientArrayType -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ClientArrayType] -> ShowS
$cshowList :: [ClientArrayType] -> ShowS
show :: ClientArrayType -> String
$cshow :: ClientArrayType -> String
showsPrec :: Int -> ClientArrayType -> ShowS
$cshowsPrec :: Int -> ClientArrayType -> ShowS
Show )

marshalClientArrayType :: ClientArrayType -> GLenum
marshalClientArrayType :: ClientArrayType -> GLuint
marshalClientArrayType ClientArrayType
x = case ClientArrayType
x of
   ClientArrayType
VertexArray -> GLuint
GL_VERTEX_ARRAY
   ClientArrayType
NormalArray -> GLuint
GL_NORMAL_ARRAY
   ClientArrayType
ColorArray -> GLuint
GL_COLOR_ARRAY
   ClientArrayType
IndexArray -> GLuint
GL_INDEX_ARRAY
   ClientArrayType
TextureCoordArray -> GLuint
GL_TEXTURE_COORD_ARRAY
   ClientArrayType
EdgeFlagArray -> GLuint
GL_EDGE_FLAG_ARRAY
   ClientArrayType
FogCoordArray -> GLuint
GL_FOG_COORD_ARRAY
   ClientArrayType
SecondaryColorArray -> GLuint
GL_SECONDARY_COLOR_ARRAY
   ClientArrayType
MatrixIndexArray -> GLuint
GL_MATRIX_INDEX_ARRAY_ARB

-- Hmmm...
clientArrayTypeToEnableCap :: ClientArrayType -> EnableCap
clientArrayTypeToEnableCap :: ClientArrayType -> EnableCap
clientArrayTypeToEnableCap ClientArrayType
x = case ClientArrayType
x of
   ClientArrayType
VertexArray -> EnableCap
CapVertexArray
   ClientArrayType
NormalArray -> EnableCap
CapNormalArray
   ClientArrayType
ColorArray -> EnableCap
CapColorArray
   ClientArrayType
IndexArray -> EnableCap
CapIndexArray
   ClientArrayType
TextureCoordArray -> EnableCap
CapTextureCoordArray
   ClientArrayType
EdgeFlagArray -> EnableCap
CapEdgeFlagArray
   ClientArrayType
FogCoordArray -> EnableCap
CapFogCoordArray
   ClientArrayType
SecondaryColorArray -> EnableCap
CapSecondaryColorArray
   ClientArrayType
MatrixIndexArray -> EnableCap
CapMatrixIndexArray

--------------------------------------------------------------------------------

arrayPointer :: ClientArrayType -> StateVar (VertexArrayDescriptor a)
arrayPointer :: forall a. ClientArrayType -> StateVar (VertexArrayDescriptor a)
arrayPointer ClientArrayType
t = case ClientArrayType
t of
   ClientArrayType
VertexArray -> forall a. StateVar (VertexArrayDescriptor a)
vertexPointer
   ClientArrayType
NormalArray -> forall a. StateVar (VertexArrayDescriptor a)
normalPointer
   ClientArrayType
ColorArray -> forall a. StateVar (VertexArrayDescriptor a)
colorPointer
   ClientArrayType
IndexArray -> forall a. StateVar (VertexArrayDescriptor a)
indexPointer
   ClientArrayType
TextureCoordArray -> forall a. StateVar (VertexArrayDescriptor a)
texCoordPointer
   ClientArrayType
EdgeFlagArray -> forall a. StateVar (VertexArrayDescriptor a)
edgeFlagPointer
   ClientArrayType
FogCoordArray -> forall a. StateVar (VertexArrayDescriptor a)
fogCoordPointer
   ClientArrayType
SecondaryColorArray -> forall a. StateVar (VertexArrayDescriptor a)
secondaryColorPointer
   ClientArrayType
MatrixIndexArray ->
      forall a. IO a -> (a -> IO ()) -> StateVar a
makeStateVar
        (do IO ()
recordInvalidEnum ; forall (m :: * -> *) a. Monad m => a -> m a
return forall a. VertexArrayDescriptor a
noVertexArrayDescriptor)
        (forall a b. a -> b -> a
const IO ()
recordInvalidEnum)

check :: Bool -> IO () -> IO ()
check :: Bool -> IO () -> IO ()
check Bool
flag IO ()
val = if Bool
flag then IO ()
val else IO ()
recordInvalidValue

--------------------------------------------------------------------------------

vertexPointer :: StateVar (VertexArrayDescriptor a)
vertexPointer :: forall a. StateVar (VertexArrayDescriptor a)
vertexPointer = forall a. IO a -> (a -> IO ()) -> StateVar a
makeStateVar forall a. IO (VertexArrayDescriptor a)
getVertexPointer forall a. VertexArrayDescriptor a -> IO ()
setVertexPointer

getVertexPointer :: IO (VertexArrayDescriptor a)
getVertexPointer :: forall a. IO (VertexArrayDescriptor a)
getVertexPointer = do
   ArrayIndex
n <- forall p a. GetPName1I p => (ArrayIndex -> a) -> p -> IO a
getInteger1 forall a. a -> a
id PName1I
GetVertexArraySize
   DataType
d <- forall p a. GetPName1I p => (GLuint -> a) -> p -> IO a
getEnum1 GLuint -> DataType
unmarshalDataType PName1I
GetVertexArrayType
   ArrayIndex
s <- forall p a. GetPName1I p => (ArrayIndex -> a) -> p -> IO a
getInteger1 forall a b. (Integral a, Num b) => a -> b
fromIntegral PName1I
GetVertexArrayStride
   Ptr a
p <- forall a. GetPointervPName -> IO (Ptr a)
getPointer GetPointervPName
VertexArrayPointer
   forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a.
ArrayIndex
-> DataType -> ArrayIndex -> Ptr a -> VertexArrayDescriptor a
VertexArrayDescriptor ArrayIndex
n DataType
d ArrayIndex
s Ptr a
p

setVertexPointer :: VertexArrayDescriptor a -> IO ()
setVertexPointer :: forall a. VertexArrayDescriptor a -> IO ()
setVertexPointer (VertexArrayDescriptor ArrayIndex
n DataType
d ArrayIndex
s Ptr a
p) =
   forall (m :: * -> *) a.
MonadIO m =>
ArrayIndex -> GLuint -> ArrayIndex -> Ptr a -> m ()
glVertexPointer ArrayIndex
n (DataType -> GLuint
marshalDataType DataType
d) ArrayIndex
s Ptr a
p

--------------------------------------------------------------------------------

normalPointer :: StateVar (VertexArrayDescriptor a)
normalPointer :: forall a. StateVar (VertexArrayDescriptor a)
normalPointer = forall a. IO a -> (a -> IO ()) -> StateVar a
makeStateVar forall a. IO (VertexArrayDescriptor a)
getNormalPointer forall a. VertexArrayDescriptor a -> IO ()
setNormalPointer

getNormalPointer :: IO (VertexArrayDescriptor a)
getNormalPointer :: forall a. IO (VertexArrayDescriptor a)
getNormalPointer = do
   DataType
d <- forall p a. GetPName1I p => (GLuint -> a) -> p -> IO a
getEnum1 GLuint -> DataType
unmarshalDataType PName1I
GetNormalArrayType
   ArrayIndex
s <- forall p a. GetPName1I p => (ArrayIndex -> a) -> p -> IO a
getInteger1 forall a b. (Integral a, Num b) => a -> b
fromIntegral PName1I
GetNormalArrayStride
   Ptr a
p <- forall a. GetPointervPName -> IO (Ptr a)
getPointer GetPointervPName
NormalArrayPointer
   forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a.
ArrayIndex
-> DataType -> ArrayIndex -> Ptr a -> VertexArrayDescriptor a
VertexArrayDescriptor ArrayIndex
3 DataType
d ArrayIndex
s Ptr a
p

setNormalPointer :: VertexArrayDescriptor a -> IO ()
setNormalPointer :: forall a. VertexArrayDescriptor a -> IO ()
setNormalPointer (VertexArrayDescriptor ArrayIndex
n DataType
d ArrayIndex
s Ptr a
p) =
   Bool -> IO () -> IO ()
check (ArrayIndex
n forall a. Eq a => a -> a -> Bool
== ArrayIndex
3) forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a.
MonadIO m =>
GLuint -> ArrayIndex -> Ptr a -> m ()
glNormalPointer (DataType -> GLuint
marshalDataType DataType
d) ArrayIndex
s Ptr a
p

--------------------------------------------------------------------------------

colorPointer :: StateVar (VertexArrayDescriptor a)
colorPointer :: forall a. StateVar (VertexArrayDescriptor a)
colorPointer = forall a. IO a -> (a -> IO ()) -> StateVar a
makeStateVar forall a. IO (VertexArrayDescriptor a)
getColorPointer forall a. VertexArrayDescriptor a -> IO ()
setColorPointer

getColorPointer :: IO (VertexArrayDescriptor a)
getColorPointer :: forall a. IO (VertexArrayDescriptor a)
getColorPointer = do
   ArrayIndex
n <- forall p a. GetPName1I p => (ArrayIndex -> a) -> p -> IO a
getInteger1 forall a. a -> a
id PName1I
GetColorArraySize
   DataType
d <- forall p a. GetPName1I p => (GLuint -> a) -> p -> IO a
getEnum1 GLuint -> DataType
unmarshalDataType PName1I
GetColorArrayType
   ArrayIndex
s <- forall p a. GetPName1I p => (ArrayIndex -> a) -> p -> IO a
getInteger1 forall a b. (Integral a, Num b) => a -> b
fromIntegral PName1I
GetColorArrayStride
   Ptr a
p <- forall a. GetPointervPName -> IO (Ptr a)
getPointer GetPointervPName
ColorArrayPointer
   forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a.
ArrayIndex
-> DataType -> ArrayIndex -> Ptr a -> VertexArrayDescriptor a
VertexArrayDescriptor ArrayIndex
n DataType
d ArrayIndex
s Ptr a
p

setColorPointer :: VertexArrayDescriptor a -> IO ()
setColorPointer :: forall a. VertexArrayDescriptor a -> IO ()
setColorPointer (VertexArrayDescriptor ArrayIndex
n DataType
d ArrayIndex
s Ptr a
p) =
   Bool -> IO () -> IO ()
check (ArrayIndex
n forall a. Eq a => a -> a -> Bool
== ArrayIndex
3 Bool -> Bool -> Bool
|| ArrayIndex
n forall a. Eq a => a -> a -> Bool
== ArrayIndex
4) forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a.
MonadIO m =>
ArrayIndex -> GLuint -> ArrayIndex -> Ptr a -> m ()
glColorPointer ArrayIndex
n (DataType -> GLuint
marshalDataType DataType
d) ArrayIndex
s Ptr a
p

--------------------------------------------------------------------------------

indexPointer :: StateVar (VertexArrayDescriptor a)
indexPointer :: forall a. StateVar (VertexArrayDescriptor a)
indexPointer = forall a. IO a -> (a -> IO ()) -> StateVar a
makeStateVar forall a. IO (VertexArrayDescriptor a)
getIndexPointer forall a. VertexArrayDescriptor a -> IO ()
setIndexPointer

getIndexPointer :: IO (VertexArrayDescriptor a)
getIndexPointer :: forall a. IO (VertexArrayDescriptor a)
getIndexPointer = do
   DataType
d <- forall p a. GetPName1I p => (GLuint -> a) -> p -> IO a
getEnum1 GLuint -> DataType
unmarshalDataType PName1I
GetIndexArrayType
   ArrayIndex
s <- forall p a. GetPName1I p => (ArrayIndex -> a) -> p -> IO a
getInteger1 forall a b. (Integral a, Num b) => a -> b
fromIntegral PName1I
GetIndexArrayStride
   Ptr a
p <- forall a. GetPointervPName -> IO (Ptr a)
getPointer GetPointervPName
IndexArrayPointer
   forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a.
ArrayIndex
-> DataType -> ArrayIndex -> Ptr a -> VertexArrayDescriptor a
VertexArrayDescriptor ArrayIndex
1 DataType
d ArrayIndex
s Ptr a
p

setIndexPointer :: VertexArrayDescriptor a -> IO ()
setIndexPointer :: forall a. VertexArrayDescriptor a -> IO ()
setIndexPointer (VertexArrayDescriptor ArrayIndex
n DataType
d ArrayIndex
s Ptr a
p) =
   Bool -> IO () -> IO ()
check (ArrayIndex
n forall a. Eq a => a -> a -> Bool
== ArrayIndex
1) forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a.
MonadIO m =>
GLuint -> ArrayIndex -> Ptr a -> m ()
glIndexPointer (DataType -> GLuint
marshalDataType DataType
d) ArrayIndex
s Ptr a
p

--------------------------------------------------------------------------------

texCoordPointer :: StateVar (VertexArrayDescriptor a)
texCoordPointer :: forall a. StateVar (VertexArrayDescriptor a)
texCoordPointer = forall a. IO a -> (a -> IO ()) -> StateVar a
makeStateVar forall a. IO (VertexArrayDescriptor a)
getTexCoordPointer forall a. VertexArrayDescriptor a -> IO ()
setTexCoordPointer

getTexCoordPointer :: IO (VertexArrayDescriptor a)
getTexCoordPointer :: forall a. IO (VertexArrayDescriptor a)
getTexCoordPointer = do
   ArrayIndex
n <- forall p a. GetPName1I p => (ArrayIndex -> a) -> p -> IO a
getInteger1 forall a. a -> a
id PName1I
GetTextureCoordArraySize
   DataType
d <- forall p a. GetPName1I p => (GLuint -> a) -> p -> IO a
getEnum1 GLuint -> DataType
unmarshalDataType PName1I
GetTextureCoordArrayType
   ArrayIndex
s <- forall p a. GetPName1I p => (ArrayIndex -> a) -> p -> IO a
getInteger1 forall a b. (Integral a, Num b) => a -> b
fromIntegral PName1I
GetTextureCoordArrayStride
   Ptr a
p <- forall a. GetPointervPName -> IO (Ptr a)
getPointer GetPointervPName
TextureCoordArrayPointer
   forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a.
ArrayIndex
-> DataType -> ArrayIndex -> Ptr a -> VertexArrayDescriptor a
VertexArrayDescriptor ArrayIndex
n DataType
d ArrayIndex
s Ptr a
p

setTexCoordPointer :: VertexArrayDescriptor a -> IO ()
setTexCoordPointer :: forall a. VertexArrayDescriptor a -> IO ()
setTexCoordPointer (VertexArrayDescriptor ArrayIndex
n DataType
d ArrayIndex
s Ptr a
p) =
   forall (m :: * -> *) a.
MonadIO m =>
ArrayIndex -> GLuint -> ArrayIndex -> Ptr a -> m ()
glTexCoordPointer ArrayIndex
n (DataType -> GLuint
marshalDataType DataType
d) ArrayIndex
s Ptr a
p

--------------------------------------------------------------------------------

edgeFlagPointer :: StateVar (VertexArrayDescriptor a)
edgeFlagPointer :: forall a. StateVar (VertexArrayDescriptor a)
edgeFlagPointer = forall a. IO a -> (a -> IO ()) -> StateVar a
makeStateVar forall a. IO (VertexArrayDescriptor a)
getEdgeFlagPointer forall a. VertexArrayDescriptor a -> IO ()
setEdgeFlagPointer

getEdgeFlagPointer :: IO (VertexArrayDescriptor a)
getEdgeFlagPointer :: forall a. IO (VertexArrayDescriptor a)
getEdgeFlagPointer = do
   ArrayIndex
s <- forall p a. GetPName1I p => (ArrayIndex -> a) -> p -> IO a
getInteger1 forall a b. (Integral a, Num b) => a -> b
fromIntegral PName1I
GetEdgeFlagArrayStride
   Ptr a
p <- forall a. GetPointervPName -> IO (Ptr a)
getPointer GetPointervPName
EdgeFlagArrayPointer
   forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a.
ArrayIndex
-> DataType -> ArrayIndex -> Ptr a -> VertexArrayDescriptor a
VertexArrayDescriptor ArrayIndex
1 DataType
UnsignedByte ArrayIndex
s Ptr a
p

setEdgeFlagPointer :: VertexArrayDescriptor a -> IO ()
setEdgeFlagPointer :: forall a. VertexArrayDescriptor a -> IO ()
setEdgeFlagPointer (VertexArrayDescriptor ArrayIndex
n DataType
d ArrayIndex
s Ptr a
p) =
   Bool -> IO () -> IO ()
check (ArrayIndex
n forall a. Eq a => a -> a -> Bool
== ArrayIndex
1 Bool -> Bool -> Bool
&& DataType
d forall a. Eq a => a -> a -> Bool
== DataType
UnsignedByte) forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a. MonadIO m => ArrayIndex -> Ptr a -> m ()
glEdgeFlagPointer ArrayIndex
s Ptr a
p

--------------------------------------------------------------------------------

fogCoordPointer :: StateVar (VertexArrayDescriptor a)
fogCoordPointer :: forall a. StateVar (VertexArrayDescriptor a)
fogCoordPointer = forall a. IO a -> (a -> IO ()) -> StateVar a
makeStateVar forall a. IO (VertexArrayDescriptor a)
getFogCoordPointer forall a. VertexArrayDescriptor a -> IO ()
setFogCoordPointer

getFogCoordPointer :: IO (VertexArrayDescriptor a)
getFogCoordPointer :: forall a. IO (VertexArrayDescriptor a)
getFogCoordPointer = do
   DataType
d <- forall p a. GetPName1I p => (GLuint -> a) -> p -> IO a
getEnum1 GLuint -> DataType
unmarshalDataType PName1I
GetFogCoordArrayType
   ArrayIndex
s <- forall p a. GetPName1I p => (ArrayIndex -> a) -> p -> IO a
getInteger1 forall a b. (Integral a, Num b) => a -> b
fromIntegral PName1I
GetFogCoordArrayStride
   Ptr a
p <- forall a. GetPointervPName -> IO (Ptr a)
getPointer GetPointervPName
FogCoordArrayPointer
   forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a.
ArrayIndex
-> DataType -> ArrayIndex -> Ptr a -> VertexArrayDescriptor a
VertexArrayDescriptor ArrayIndex
1 DataType
d ArrayIndex
s Ptr a
p

setFogCoordPointer :: VertexArrayDescriptor a -> IO ()
setFogCoordPointer :: forall a. VertexArrayDescriptor a -> IO ()
setFogCoordPointer (VertexArrayDescriptor ArrayIndex
n DataType
d ArrayIndex
s Ptr a
p) =
   Bool -> IO () -> IO ()
check (ArrayIndex
n forall a. Eq a => a -> a -> Bool
== ArrayIndex
1) forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a.
MonadIO m =>
GLuint -> ArrayIndex -> Ptr a -> m ()
glFogCoordPointer (DataType -> GLuint
marshalDataType DataType
d) ArrayIndex
s Ptr a
p

--------------------------------------------------------------------------------

secondaryColorPointer :: StateVar (VertexArrayDescriptor a)
secondaryColorPointer :: forall a. StateVar (VertexArrayDescriptor a)
secondaryColorPointer =
   forall a. IO a -> (a -> IO ()) -> StateVar a
makeStateVar forall a. IO (VertexArrayDescriptor a)
getSecondaryColorPointer forall a. VertexArrayDescriptor a -> IO ()
setSecondaryColorPointer

getSecondaryColorPointer :: IO (VertexArrayDescriptor a)
getSecondaryColorPointer :: forall a. IO (VertexArrayDescriptor a)
getSecondaryColorPointer = do
   ArrayIndex
n <- forall p a. GetPName1I p => (ArrayIndex -> a) -> p -> IO a
getInteger1 forall a. a -> a
id PName1I
GetSecondaryColorArraySize
   DataType
d <- forall p a. GetPName1I p => (GLuint -> a) -> p -> IO a
getEnum1 GLuint -> DataType
unmarshalDataType PName1I
GetSecondaryColorArrayType
   ArrayIndex
s <- forall p a. GetPName1I p => (ArrayIndex -> a) -> p -> IO a
getInteger1 forall a b. (Integral a, Num b) => a -> b
fromIntegral PName1I
GetSecondaryColorArrayStride
   Ptr a
p <- forall a. GetPointervPName -> IO (Ptr a)
getPointer GetPointervPName
SecondaryColorArrayPointer
   forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a.
ArrayIndex
-> DataType -> ArrayIndex -> Ptr a -> VertexArrayDescriptor a
VertexArrayDescriptor ArrayIndex
n DataType
d ArrayIndex
s Ptr a
p

setSecondaryColorPointer :: (VertexArrayDescriptor a) -> IO ()
setSecondaryColorPointer :: forall a. VertexArrayDescriptor a -> IO ()
setSecondaryColorPointer (VertexArrayDescriptor ArrayIndex
n DataType
d ArrayIndex
s Ptr a
p) =
   forall (m :: * -> *) a.
MonadIO m =>
ArrayIndex -> GLuint -> ArrayIndex -> Ptr a -> m ()
glSecondaryColorPointer ArrayIndex
n (DataType -> GLuint
marshalDataType DataType
d) ArrayIndex
s Ptr a
p

--------------------------------------------------------------------------------

data InterleavedArrays =
     V2f
   | V3f
   | C4ubV2f
   | C4ubV3f
   | C3fV3f
   | N3fV3f
   | C4fN3fV3f
   | T2fV3f
   | T4fV4f
   | T2fC4ubV3f
   | T2fC3fV3f
   | T2fN3fV3f
   | T2fC4fN3fV3f
   | T4fC4fN3fV4f
   deriving ( InterleavedArrays -> InterleavedArrays -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: InterleavedArrays -> InterleavedArrays -> Bool
$c/= :: InterleavedArrays -> InterleavedArrays -> Bool
== :: InterleavedArrays -> InterleavedArrays -> Bool
$c== :: InterleavedArrays -> InterleavedArrays -> Bool
Eq, Eq InterleavedArrays
InterleavedArrays -> InterleavedArrays -> Bool
InterleavedArrays -> InterleavedArrays -> Ordering
InterleavedArrays -> InterleavedArrays -> InterleavedArrays
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: InterleavedArrays -> InterleavedArrays -> InterleavedArrays
$cmin :: InterleavedArrays -> InterleavedArrays -> InterleavedArrays
max :: InterleavedArrays -> InterleavedArrays -> InterleavedArrays
$cmax :: InterleavedArrays -> InterleavedArrays -> InterleavedArrays
>= :: InterleavedArrays -> InterleavedArrays -> Bool
$c>= :: InterleavedArrays -> InterleavedArrays -> Bool
> :: InterleavedArrays -> InterleavedArrays -> Bool
$c> :: InterleavedArrays -> InterleavedArrays -> Bool
<= :: InterleavedArrays -> InterleavedArrays -> Bool
$c<= :: InterleavedArrays -> InterleavedArrays -> Bool
< :: InterleavedArrays -> InterleavedArrays -> Bool
$c< :: InterleavedArrays -> InterleavedArrays -> Bool
compare :: InterleavedArrays -> InterleavedArrays -> Ordering
$ccompare :: InterleavedArrays -> InterleavedArrays -> Ordering
Ord, Int -> InterleavedArrays -> ShowS
[InterleavedArrays] -> ShowS
InterleavedArrays -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [InterleavedArrays] -> ShowS
$cshowList :: [InterleavedArrays] -> ShowS
show :: InterleavedArrays -> String
$cshow :: InterleavedArrays -> String
showsPrec :: Int -> InterleavedArrays -> ShowS
$cshowsPrec :: Int -> InterleavedArrays -> ShowS
Show )

marshalInterleavedArrays :: InterleavedArrays -> GLenum
marshalInterleavedArrays :: InterleavedArrays -> GLuint
marshalInterleavedArrays InterleavedArrays
x = case InterleavedArrays
x of
   InterleavedArrays
V2f -> GLuint
GL_V2F
   InterleavedArrays
V3f -> GLuint
GL_V3F
   InterleavedArrays
C4ubV2f -> GLuint
GL_C4UB_V2F
   InterleavedArrays
C4ubV3f -> GLuint
GL_C4UB_V3F
   InterleavedArrays
C3fV3f -> GLuint
GL_C3F_V3F
   InterleavedArrays
N3fV3f -> GLuint
GL_N3F_V3F
   InterleavedArrays
C4fN3fV3f -> GLuint
GL_C4F_N3F_V3F
   InterleavedArrays
T2fV3f -> GLuint
GL_T2F_V3F
   InterleavedArrays
T4fV4f -> GLuint
GL_T4F_V4F
   InterleavedArrays
T2fC4ubV3f -> GLuint
GL_T2F_C4UB_V3F
   InterleavedArrays
T2fC3fV3f -> GLuint
GL_T2F_C3F_V3F
   InterleavedArrays
T2fN3fV3f -> GLuint
GL_T2F_N3F_V3F
   InterleavedArrays
T2fC4fN3fV3f -> GLuint
GL_T2F_C4F_N3F_V3F
   InterleavedArrays
T4fC4fN3fV4f -> GLuint
GL_T4F_C4F_N3F_V4F

--------------------------------------------------------------------------------

interleavedArrays :: InterleavedArrays -> Stride -> Ptr a -> IO ()
interleavedArrays :: forall a. InterleavedArrays -> ArrayIndex -> Ptr a -> IO ()
interleavedArrays = forall (m :: * -> *) a.
MonadIO m =>
GLuint -> ArrayIndex -> Ptr a -> m ()
glInterleavedArrays forall b c a. (b -> c) -> (a -> b) -> a -> c
. InterleavedArrays -> GLuint
marshalInterleavedArrays

--------------------------------------------------------------------------------

clientState :: ClientArrayType -> StateVar Capability
clientState :: ClientArrayType -> StateVar Capability
clientState ClientArrayType
arrayType =
   forall a. IO a -> (a -> IO ()) -> StateVar a
makeStateVar (ClientArrayType -> IO Capability
getClientState ClientArrayType
arrayType) (ClientArrayType -> Capability -> IO ()
setClientState ClientArrayType
arrayType)

getClientState :: ClientArrayType -> IO Capability
getClientState :: ClientArrayType -> IO Capability
getClientState ClientArrayType
arrayType = forall t a (m :: * -> *). (HasGetter t a, MonadIO m) => t -> m a
get forall b c a. (b -> c) -> (a -> b) -> a -> c
. EnableCap -> StateVar Capability
makeCapability forall b c a. (b -> c) -> (a -> b) -> a -> c
. ClientArrayType -> EnableCap
clientArrayTypeToEnableCap forall a b. (a -> b) -> a -> b
$ ClientArrayType
arrayType

setClientState :: ClientArrayType -> Capability -> IO ()
setClientState :: ClientArrayType -> Capability -> IO ()
setClientState ClientArrayType
arrayType Capability
val =
   (if Capability
val forall a. Eq a => a -> a -> Bool
== Capability
Enabled then forall (m :: * -> *). MonadIO m => GLuint -> m ()
glEnableClientState else forall (m :: * -> *). MonadIO m => GLuint -> m ()
glDisableClientState)
      (ClientArrayType -> GLuint
marshalClientArrayType ClientArrayType
arrayType)

--------------------------------------------------------------------------------

clientActiveTexture :: StateVar TextureUnit
clientActiveTexture :: StateVar TextureUnit
clientActiveTexture =
   forall a. IO a -> (a -> IO ()) -> StateVar a
makeStateVar (forall p a. GetPName1I p => (GLuint -> a) -> p -> IO a
getEnum1 GLuint -> TextureUnit
unmarshalTextureUnit PName1I
GetClientActiveTexture)
                (forall (m :: * -> *). MonadIO m => GLuint -> m ()
glClientActiveTexture forall b c a. (b -> c) -> (a -> b) -> a -> c
. TextureUnit -> GLuint
marshalTextureUnit)

--------------------------------------------------------------------------------

type ArrayIndex = GLint

type NumArrayIndices = GLsizei

type NumIndexBlocks = GLsizei

type NumInstances = GLsizei

type BaseInstance = GLuint

type BaseVertex = GLint

-- TODO: The ranges (ArrayIndex, ArrayIndex) below should actually use GLuint:
-- type RangeStart = GLuint
-- type RangeEnd = GLuint

--------------------------------------------------------------------------------

arrayElement :: ArrayIndex -> IO ()
arrayElement :: ArrayIndex -> IO ()
arrayElement = forall (m :: * -> *). MonadIO m => ArrayIndex -> m ()
glArrayElement

drawArrays :: PrimitiveMode -> ArrayIndex -> NumArrayIndices -> IO ()
drawArrays :: PrimitiveMode -> ArrayIndex -> ArrayIndex -> IO ()
drawArrays = forall (m :: * -> *).
MonadIO m =>
GLuint -> ArrayIndex -> ArrayIndex -> m ()
glDrawArrays forall b c a. (b -> c) -> (a -> b) -> a -> c
. PrimitiveMode -> GLuint
marshalPrimitiveMode

drawArraysInstancedBaseInstance :: PrimitiveMode -> ArrayIndex -> NumArrayIndices -> NumInstances -> BaseInstance -> IO ()
drawArraysInstancedBaseInstance :: PrimitiveMode
-> ArrayIndex -> ArrayIndex -> ArrayIndex -> GLuint -> IO ()
drawArraysInstancedBaseInstance = forall (m :: * -> *).
MonadIO m =>
GLuint -> ArrayIndex -> ArrayIndex -> ArrayIndex -> GLuint -> m ()
glDrawArraysInstancedBaseInstance forall b c a. (b -> c) -> (a -> b) -> a -> c
. PrimitiveMode -> GLuint
marshalPrimitiveMode

drawArraysInstanced :: PrimitiveMode -> ArrayIndex -> NumArrayIndices -> NumInstances -> IO ()
drawArraysInstanced :: PrimitiveMode -> ArrayIndex -> ArrayIndex -> ArrayIndex -> IO ()
drawArraysInstanced = forall (m :: * -> *).
MonadIO m =>
GLuint -> ArrayIndex -> ArrayIndex -> ArrayIndex -> m ()
glDrawArraysInstanced forall b c a. (b -> c) -> (a -> b) -> a -> c
. PrimitiveMode -> GLuint
marshalPrimitiveMode

multiDrawArrays :: PrimitiveMode -> Ptr ArrayIndex -> Ptr NumArrayIndices -> NumIndexBlocks -> IO ()
multiDrawArrays :: PrimitiveMode
-> Ptr ArrayIndex -> Ptr ArrayIndex -> ArrayIndex -> IO ()
multiDrawArrays = forall (m :: * -> *).
MonadIO m =>
GLuint -> Ptr ArrayIndex -> Ptr ArrayIndex -> ArrayIndex -> m ()
glMultiDrawArrays forall b c a. (b -> c) -> (a -> b) -> a -> c
. PrimitiveMode -> GLuint
marshalPrimitiveMode

drawElements :: PrimitiveMode -> NumArrayIndices -> DataType -> Ptr a -> IO ()
drawElements :: forall a. PrimitiveMode -> ArrayIndex -> DataType -> Ptr a -> IO ()
drawElements PrimitiveMode
m ArrayIndex
c = forall (m :: * -> *) a.
MonadIO m =>
GLuint -> ArrayIndex -> GLuint -> Ptr a -> m ()
glDrawElements (PrimitiveMode -> GLuint
marshalPrimitiveMode PrimitiveMode
m) ArrayIndex
c forall b c a. (b -> c) -> (a -> b) -> a -> c
. DataType -> GLuint
marshalDataType

drawElementsInstancedBaseInstance :: PrimitiveMode -> NumArrayIndices -> DataType -> Ptr a -> NumInstances -> BaseInstance -> IO ()
drawElementsInstancedBaseInstance :: forall a.
PrimitiveMode
-> ArrayIndex -> DataType -> Ptr a -> ArrayIndex -> GLuint -> IO ()
drawElementsInstancedBaseInstance PrimitiveMode
m ArrayIndex
c = forall (m :: * -> *) a.
MonadIO m =>
GLuint
-> ArrayIndex -> GLuint -> Ptr a -> ArrayIndex -> GLuint -> m ()
glDrawElementsInstancedBaseInstance (PrimitiveMode -> GLuint
marshalPrimitiveMode PrimitiveMode
m) ArrayIndex
c forall b c a. (b -> c) -> (a -> b) -> a -> c
. DataType -> GLuint
marshalDataType

drawElementsInstanced :: PrimitiveMode -> NumArrayIndices -> DataType -> Ptr a -> NumInstances -> IO ()
drawElementsInstanced :: forall a.
PrimitiveMode
-> ArrayIndex -> DataType -> Ptr a -> ArrayIndex -> IO ()
drawElementsInstanced PrimitiveMode
m ArrayIndex
c = forall (m :: * -> *) a.
MonadIO m =>
GLuint -> ArrayIndex -> GLuint -> Ptr a -> ArrayIndex -> m ()
glDrawElementsInstanced (PrimitiveMode -> GLuint
marshalPrimitiveMode PrimitiveMode
m) ArrayIndex
c forall b c a. (b -> c) -> (a -> b) -> a -> c
. DataType -> GLuint
marshalDataType

multiDrawElements :: PrimitiveMode -> Ptr NumArrayIndices -> DataType -> Ptr (Ptr a) -> NumIndexBlocks -> IO ()
multiDrawElements :: forall a.
PrimitiveMode
-> Ptr ArrayIndex -> DataType -> Ptr (Ptr a) -> ArrayIndex -> IO ()
multiDrawElements PrimitiveMode
m Ptr ArrayIndex
c = forall (m :: * -> *) a.
MonadIO m =>
GLuint
-> Ptr ArrayIndex -> GLuint -> Ptr (Ptr a) -> ArrayIndex -> m ()
glMultiDrawElements (PrimitiveMode -> GLuint
marshalPrimitiveMode PrimitiveMode
m) Ptr ArrayIndex
c forall b c a. (b -> c) -> (a -> b) -> a -> c
. DataType -> GLuint
marshalDataType

drawRangeElements :: PrimitiveMode -> (ArrayIndex, ArrayIndex) -> NumArrayIndices -> DataType -> Ptr a -> IO ()
drawRangeElements :: forall a.
PrimitiveMode
-> (ArrayIndex, ArrayIndex)
-> ArrayIndex
-> DataType
-> Ptr a
-> IO ()
drawRangeElements PrimitiveMode
m (ArrayIndex
s, ArrayIndex
e) ArrayIndex
c = forall (m :: * -> *) a.
MonadIO m =>
GLuint -> GLuint -> GLuint -> ArrayIndex -> GLuint -> Ptr a -> m ()
glDrawRangeElements (PrimitiveMode -> GLuint
marshalPrimitiveMode PrimitiveMode
m) (forall a b. (Integral a, Num b) => a -> b
fromIntegral ArrayIndex
s) (forall a b. (Integral a, Num b) => a -> b
fromIntegral ArrayIndex
e) ArrayIndex
c forall b c a. (b -> c) -> (a -> b) -> a -> c
. DataType -> GLuint
marshalDataType

drawElementsBaseVertex :: PrimitiveMode -> NumArrayIndices -> DataType -> Ptr a -> BaseVertex -> IO ()
drawElementsBaseVertex :: forall a.
PrimitiveMode
-> ArrayIndex -> DataType -> Ptr a -> ArrayIndex -> IO ()
drawElementsBaseVertex PrimitiveMode
m ArrayIndex
c = forall (m :: * -> *) a.
MonadIO m =>
GLuint -> ArrayIndex -> GLuint -> Ptr a -> ArrayIndex -> m ()
glDrawElementsBaseVertex (PrimitiveMode -> GLuint
marshalPrimitiveMode PrimitiveMode
m) ArrayIndex
c forall b c a. (b -> c) -> (a -> b) -> a -> c
. DataType -> GLuint
marshalDataType

drawRangeElementsBaseVertex :: PrimitiveMode -> (ArrayIndex, ArrayIndex) -> NumArrayIndices -> DataType -> Ptr a -> BaseVertex -> IO ()
drawRangeElementsBaseVertex :: forall a.
PrimitiveMode
-> (ArrayIndex, ArrayIndex)
-> ArrayIndex
-> DataType
-> Ptr a
-> ArrayIndex
-> IO ()
drawRangeElementsBaseVertex PrimitiveMode
m (ArrayIndex
s, ArrayIndex
e) ArrayIndex
c = forall (m :: * -> *) a.
MonadIO m =>
GLuint
-> GLuint
-> GLuint
-> ArrayIndex
-> GLuint
-> Ptr a
-> ArrayIndex
-> m ()
glDrawRangeElementsBaseVertex (PrimitiveMode -> GLuint
marshalPrimitiveMode PrimitiveMode
m) (forall a b. (Integral a, Num b) => a -> b
fromIntegral ArrayIndex
s) (forall a b. (Integral a, Num b) => a -> b
fromIntegral ArrayIndex
e) ArrayIndex
c forall b c a. (b -> c) -> (a -> b) -> a -> c
. DataType -> GLuint
marshalDataType

drawElementsInstancedBaseVertex :: PrimitiveMode -> NumArrayIndices -> DataType -> Ptr a -> NumInstances -> BaseVertex -> IO ()
drawElementsInstancedBaseVertex :: forall a.
PrimitiveMode
-> ArrayIndex
-> DataType
-> Ptr a
-> ArrayIndex
-> ArrayIndex
-> IO ()
drawElementsInstancedBaseVertex PrimitiveMode
m ArrayIndex
c = forall (m :: * -> *) a.
MonadIO m =>
GLuint
-> ArrayIndex
-> GLuint
-> Ptr a
-> ArrayIndex
-> ArrayIndex
-> m ()
glDrawElementsInstancedBaseVertex (PrimitiveMode -> GLuint
marshalPrimitiveMode PrimitiveMode
m) ArrayIndex
c forall b c a. (b -> c) -> (a -> b) -> a -> c
. DataType -> GLuint
marshalDataType

drawElementsInstancedBaseVertexBaseInstance :: PrimitiveMode -> NumArrayIndices -> DataType -> Ptr a -> NumInstances -> BaseVertex -> BaseInstance -> IO ()
drawElementsInstancedBaseVertexBaseInstance :: forall a.
PrimitiveMode
-> ArrayIndex
-> DataType
-> Ptr a
-> ArrayIndex
-> ArrayIndex
-> GLuint
-> IO ()
drawElementsInstancedBaseVertexBaseInstance PrimitiveMode
m ArrayIndex
c = forall (m :: * -> *) a.
MonadIO m =>
GLuint
-> ArrayIndex
-> GLuint
-> Ptr a
-> ArrayIndex
-> ArrayIndex
-> GLuint
-> m ()
glDrawElementsInstancedBaseVertexBaseInstance (PrimitiveMode -> GLuint
marshalPrimitiveMode PrimitiveMode
m) ArrayIndex
c forall b c a. (b -> c) -> (a -> b) -> a -> c
. DataType -> GLuint
marshalDataType

multiDrawElementsBaseVertex :: PrimitiveMode -> Ptr NumArrayIndices -> DataType -> Ptr (Ptr a) -> NumIndexBlocks -> Ptr BaseVertex -> IO ()
multiDrawElementsBaseVertex :: forall a.
PrimitiveMode
-> Ptr ArrayIndex
-> DataType
-> Ptr (Ptr a)
-> ArrayIndex
-> Ptr ArrayIndex
-> IO ()
multiDrawElementsBaseVertex PrimitiveMode
m Ptr ArrayIndex
c = forall (m :: * -> *) a.
MonadIO m =>
GLuint
-> Ptr ArrayIndex
-> GLuint
-> Ptr (Ptr a)
-> ArrayIndex
-> Ptr ArrayIndex
-> m ()
glMultiDrawElementsBaseVertex (PrimitiveMode -> GLuint
marshalPrimitiveMode PrimitiveMode
m) Ptr ArrayIndex
c forall b c a. (b -> c) -> (a -> b) -> a -> c
. DataType -> GLuint
marshalDataType

maxElementsVertices :: GettableStateVar NumArrayIndices
maxElementsVertices :: GettableStateVar ArrayIndex
maxElementsVertices = forall a. IO a -> IO a
makeGettableStateVar (forall p a. GetPName1I p => (ArrayIndex -> a) -> p -> IO a
getSizei1 forall a. a -> a
id PName1I
GetMaxElementsVertices)

maxElementsIndices :: GettableStateVar NumArrayIndices
maxElementsIndices :: GettableStateVar ArrayIndex
maxElementsIndices = forall a. IO a -> IO a
makeGettableStateVar (forall p a. GetPName1I p => (ArrayIndex -> a) -> p -> IO a
getSizei1 forall a. a -> a
id PName1I
GetMaxElementsIndices)

--------------------------------------------------------------------------------

lockArrays :: StateVar (Maybe (ArrayIndex, NumArrayIndices))
lockArrays :: StateVar (Maybe (ArrayIndex, ArrayIndex))
lockArrays = forall a. IO a -> (a -> IO ()) -> StateVar a
makeStateVar IO (Maybe (ArrayIndex, ArrayIndex))
getLockArrays Maybe (ArrayIndex, ArrayIndex) -> IO ()
setLockArrays

getLockArrays :: IO (Maybe (ArrayIndex, NumArrayIndices))
getLockArrays :: IO (Maybe (ArrayIndex, ArrayIndex))
getLockArrays = do
   ArrayIndex
count <- forall p a. GetPName1I p => (ArrayIndex -> a) -> p -> IO a
getInteger1 forall a b. (Integral a, Num b) => a -> b
fromIntegral PName1I
GetArrayElementLockCount
   if ArrayIndex
count forall a. Ord a => a -> a -> Bool
> ArrayIndex
0
      then do ArrayIndex
first <- forall p a. GetPName1I p => (ArrayIndex -> a) -> p -> IO a
getInteger1 forall a. a -> a
id PName1I
GetArrayElementLockFirst
              forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a. a -> Maybe a
Just (ArrayIndex
first, ArrayIndex
count)
      else forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Maybe a
Nothing

setLockArrays :: Maybe (ArrayIndex, NumArrayIndices) -> IO ()
setLockArrays :: Maybe (ArrayIndex, ArrayIndex) -> IO ()
setLockArrays = forall b a. b -> (a -> b) -> Maybe a -> b
maybe forall (m :: * -> *). MonadIO m => m ()
glUnlockArraysEXT (forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry forall (m :: * -> *). MonadIO m => ArrayIndex -> ArrayIndex -> m ()
glLockArraysEXT)

--------------------------------------------------------------------------------

primitiveRestartIndex :: StateVar (Maybe ArrayIndex)
primitiveRestartIndex :: StateVar (Maybe ArrayIndex)
primitiveRestartIndex =
   forall a.
IO EnableCap -> IO a -> (a -> IO ()) -> StateVar (Maybe a)
makeStateVarMaybe
      (forall (m :: * -> *) a. Monad m => a -> m a
return EnableCap
CapPrimitiveRestart)
      (forall p a. GetPName1I p => (ArrayIndex -> a) -> p -> IO a
getInteger1 forall a. a -> a
id PName1I
GetPrimitiveRestartIndex)
      (forall (m :: * -> *). MonadIO m => GLuint -> m ()
glPrimitiveRestartIndex forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (Integral a, Num b) => a -> b
fromIntegral)

--------------------------------------------------------------------------------

-- We almost could use makeStateVarMaybe below, but, alas, this is client state.

primitiveRestartIndexNV :: StateVar (Maybe ArrayIndex)
primitiveRestartIndexNV :: StateVar (Maybe ArrayIndex)
primitiveRestartIndexNV =
   forall a. IO a -> (a -> IO ()) -> StateVar a
makeStateVar IO (Maybe ArrayIndex)
getPrimitiveRestartIndexNV Maybe ArrayIndex -> IO ()
setPrimitiveRestartIndexNV

getPrimitiveRestartIndexNV :: IO (Maybe ArrayIndex)
getPrimitiveRestartIndexNV :: IO (Maybe ArrayIndex)
getPrimitiveRestartIndexNV = do
   Bool
on <- forall p a. GetPName1I p => (GLboolean -> a) -> p -> IO a
getBoolean1 forall a. (Eq a, Num a) => a -> Bool
unmarshalGLboolean PName1I
GetPrimitiveRestartNV
   if Bool
on
      then forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ forall p a. GetPName1I p => (ArrayIndex -> a) -> p -> IO a
getInteger1 forall a b. (Integral a, Num b) => a -> b
fromIntegral PName1I
GetPrimitiveRestartIndexNV
      else forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Maybe a
Nothing

setPrimitiveRestartIndexNV :: Maybe ArrayIndex -> IO ()
setPrimitiveRestartIndexNV :: Maybe ArrayIndex -> IO ()
setPrimitiveRestartIndexNV Maybe ArrayIndex
maybeIdx = case Maybe ArrayIndex
maybeIdx of
   Maybe ArrayIndex
Nothing  -> forall (m :: * -> *). MonadIO m => GLuint -> m ()
glDisableClientState GLuint
GL_PRIMITIVE_RESTART_NV
   Just ArrayIndex
idx -> do forall (m :: * -> *). MonadIO m => GLuint -> m ()
glEnableClientState GLuint
GL_PRIMITIVE_RESTART_NV
                  forall (m :: * -> *). MonadIO m => GLuint -> m ()
glPrimitiveRestartIndexNV (forall a b. (Integral a, Num b) => a -> b
fromIntegral ArrayIndex
idx)

--------------------------------------------------------------------------------

vertexAttribPointer :: AttribLocation -> StateVar (IntegerHandling, VertexArrayDescriptor a)
vertexAttribPointer :: forall a.
AttribLocation
-> StateVar (IntegerHandling, VertexArrayDescriptor a)
vertexAttribPointer AttribLocation
location =
   forall a. IO a -> (a -> IO ()) -> StateVar a
makeStateVar (forall a.
AttribLocation -> IO (IntegerHandling, VertexArrayDescriptor a)
getVertexAttribPointer_ AttribLocation
location) (forall a.
AttribLocation
-> (IntegerHandling, VertexArrayDescriptor a) -> IO ()
setVertexAttribPointer AttribLocation
location)

getVertexAttribPointer_ :: AttribLocation -> IO (IntegerHandling, VertexArrayDescriptor a)
getVertexAttribPointer_ :: forall a.
AttribLocation -> IO (IntegerHandling, VertexArrayDescriptor a)
getVertexAttribPointer_ AttribLocation
location = do
   Bool
i <- forall b.
(GLboolean -> b) -> AttribLocation -> GetVertexAttribPName -> IO b
getVertexAttribBoolean1 forall a. (Eq a, Num a) => a -> Bool
unmarshalGLboolean AttribLocation
location GetVertexAttribPName
GetVertexAttribArrayInteger
   IntegerHandling
h <- if Bool
i
           then forall (m :: * -> *) a. Monad m => a -> m a
return IntegerHandling
KeepIntegral
           else do Bool
f <- forall b.
(GLboolean -> b) -> AttribLocation -> GetVertexAttribPName -> IO b
getVertexAttribBoolean1 forall a. (Eq a, Num a) => a -> Bool
unmarshalGLboolean AttribLocation
location GetVertexAttribPName
GetVertexAttribArrayNormalized
                   forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ if Bool
f then IntegerHandling
ToNormalizedFloat else IntegerHandling
ToFloat
   ArrayIndex
n <- forall b.
(ArrayIndex -> b) -> AttribLocation -> GetVertexAttribPName -> IO b
getVertexAttribInteger1 forall a. a -> a
id AttribLocation
location GetVertexAttribPName
GetVertexAttribArraySize
   DataType
d <- forall b.
(GLuint -> b) -> AttribLocation -> GetVertexAttribPName -> IO b
getVertexAttribEnum1 GLuint -> DataType
unmarshalDataType AttribLocation
location GetVertexAttribPName
GetVertexAttribArrayType
   ArrayIndex
s <- forall b.
(ArrayIndex -> b) -> AttribLocation -> GetVertexAttribPName -> IO b
getVertexAttribInteger1 forall a b. (Integral a, Num b) => a -> b
fromIntegral AttribLocation
location GetVertexAttribPName
GetVertexAttribArrayStride
   Ptr a
p <- forall a.
AttribLocation -> GetVertexAttribPointerPName -> IO (Ptr a)
getVertexAttribPointer AttribLocation
location GetVertexAttribPointerPName
VertexAttribArrayPointer
   forall (m :: * -> *) a. Monad m => a -> m a
return (IntegerHandling
h, forall a.
ArrayIndex
-> DataType -> ArrayIndex -> Ptr a -> VertexArrayDescriptor a
VertexArrayDescriptor ArrayIndex
n DataType
d ArrayIndex
s Ptr a
p)

setVertexAttribPointer :: AttribLocation -> (IntegerHandling, VertexArrayDescriptor a) -> IO ()
setVertexAttribPointer :: forall a.
AttribLocation
-> (IntegerHandling, VertexArrayDescriptor a) -> IO ()
setVertexAttribPointer (AttribLocation GLuint
location) (IntegerHandling
h, VertexArrayDescriptor ArrayIndex
n DataType
d ArrayIndex
s Ptr a
p) = case IntegerHandling
h of
   IntegerHandling
ToFloat -> forall (m :: * -> *) a.
MonadIO m =>
GLuint
-> ArrayIndex -> GLuint -> GLboolean -> ArrayIndex -> Ptr a -> m ()
glVertexAttribPointer GLuint
location ArrayIndex
n GLuint
md (forall a. Num a => Bool -> a
marshalGLboolean Bool
False) ArrayIndex
s Ptr a
p
   IntegerHandling
ToNormalizedFloat -> forall (m :: * -> *) a.
MonadIO m =>
GLuint
-> ArrayIndex -> GLuint -> GLboolean -> ArrayIndex -> Ptr a -> m ()
glVertexAttribPointer GLuint
location ArrayIndex
n GLuint
md (forall a. Num a => Bool -> a
marshalGLboolean Bool
True) ArrayIndex
s Ptr a
p
   IntegerHandling
KeepIntegral -> forall (m :: * -> *) a.
MonadIO m =>
GLuint -> ArrayIndex -> GLuint -> ArrayIndex -> Ptr a -> m ()
glVertexAttribIPointer GLuint
location ArrayIndex
n GLuint
md ArrayIndex
s Ptr a
p
  where md :: GLuint
md = DataType -> GLuint
marshalDataType DataType
d

--------------------------------------------------------------------------------

vertexAttribArray :: AttribLocation -> StateVar Capability
vertexAttribArray :: AttribLocation -> StateVar Capability
vertexAttribArray AttribLocation
location =
   forall a. IO a -> (a -> IO ()) -> StateVar a
makeStateVar (AttribLocation -> IO Capability
getVertexAttribArray AttribLocation
location) (forall a b c. (a -> b -> c) -> b -> a -> c
flip Capability -> AttribLocation -> IO ()
setVertexAttribArray AttribLocation
location)

getVertexAttribArray :: AttribLocation -> IO Capability
getVertexAttribArray :: AttribLocation -> IO Capability
getVertexAttribArray AttribLocation
location =
   forall b.
(GLboolean -> b) -> AttribLocation -> GetVertexAttribPName -> IO b
getVertexAttribBoolean1 GLboolean -> Capability
unmarshalCapability AttribLocation
location GetVertexAttribPName
GetVertexAttribArrayEnabled

setVertexAttribArray :: Capability -> AttribLocation -> IO ()
setVertexAttribArray :: Capability -> AttribLocation -> IO ()
setVertexAttribArray Capability
Disabled (AttribLocation GLuint
location) = forall (m :: * -> *). MonadIO m => GLuint -> m ()
glDisableVertexAttribArray GLuint
location
setVertexAttribArray Capability
Enabled (AttribLocation GLuint
location) = forall (m :: * -> *). MonadIO m => GLuint -> m ()
glEnableVertexAttribArray GLuint
location