{-# OPTIONS_HADDOCK hide #-}
--------------------------------------------------------------------------------
-- |
-- Module      :  Graphics.GL.Functions.F31
-- Copyright   :  (c) Sven Panne 2019
-- License     :  BSD3
--
-- Maintainer  :  Sven Panne <svenpanne@gmail.com>
-- Stability   :  stable
-- Portability :  portable
--
-- Raw functions from the
-- <http://www.opengl.org/registry/ OpenGL registry>.
--
--------------------------------------------------------------------------------

module Graphics.GL.Functions.F31 (
  glVertexAttrib4svARB,
  glVertexAttrib4svNV,
  glVertexAttrib4ubNV,
  glVertexAttrib4ubv,
  glVertexAttrib4ubvARB,
  glVertexAttrib4ubvNV,
  glVertexAttrib4uiv,
  glVertexAttrib4uivARB,
  glVertexAttrib4usv,
  glVertexAttrib4usvARB,
  glVertexAttribArrayObjectATI,
  glVertexAttribBinding,
  glVertexAttribDivisor,
  glVertexAttribDivisorANGLE,
  glVertexAttribDivisorARB,
  glVertexAttribDivisorEXT,
  glVertexAttribDivisorNV,
  glVertexAttribFormat,
  glVertexAttribFormatNV,
  glVertexAttribI1i,
  glVertexAttribI1iEXT,
  glVertexAttribI1iv,
  glVertexAttribI1ivEXT,
  glVertexAttribI1ui,
  glVertexAttribI1uiEXT,
  glVertexAttribI1uiv,
  glVertexAttribI1uivEXT,
  glVertexAttribI2i,
  glVertexAttribI2iEXT,
  glVertexAttribI2iv,
  glVertexAttribI2ivEXT,
  glVertexAttribI2ui,
  glVertexAttribI2uiEXT,
  glVertexAttribI2uiv,
  glVertexAttribI2uivEXT,
  glVertexAttribI3i,
  glVertexAttribI3iEXT,
  glVertexAttribI3iv,
  glVertexAttribI3ivEXT,
  glVertexAttribI3ui,
  glVertexAttribI3uiEXT,
  glVertexAttribI3uiv,
  glVertexAttribI3uivEXT,
  glVertexAttribI4bv,
  glVertexAttribI4bvEXT,
  glVertexAttribI4i,
  glVertexAttribI4iEXT,
  glVertexAttribI4iv,
  glVertexAttribI4ivEXT,
  glVertexAttribI4sv,
  glVertexAttribI4svEXT,
  glVertexAttribI4ubv,
  glVertexAttribI4ubvEXT,
  glVertexAttribI4ui,
  glVertexAttribI4uiEXT,
  glVertexAttribI4uiv,
  glVertexAttribI4uivEXT,
  glVertexAttribI4usv,
  glVertexAttribI4usvEXT,
  glVertexAttribIFormat,
  glVertexAttribIFormatNV,
  glVertexAttribIPointer,
  glVertexAttribIPointerEXT,
  glVertexAttribL1d,
  glVertexAttribL1dEXT,
  glVertexAttribL1dv,
  glVertexAttribL1dvEXT,
  glVertexAttribL1i64NV,
  glVertexAttribL1i64vNV,
  glVertexAttribL1ui64ARB,
  glVertexAttribL1ui64NV,
  glVertexAttribL1ui64vARB,
  glVertexAttribL1ui64vNV,
  glVertexAttribL2d,
  glVertexAttribL2dEXT,
  glVertexAttribL2dv,
  glVertexAttribL2dvEXT,
  glVertexAttribL2i64NV,
  glVertexAttribL2i64vNV,
  glVertexAttribL2ui64NV,
  glVertexAttribL2ui64vNV,
  glVertexAttribL3d,
  glVertexAttribL3dEXT,
  glVertexAttribL3dv,
  glVertexAttribL3dvEXT,
  glVertexAttribL3i64NV,
  glVertexAttribL3i64vNV,
  glVertexAttribL3ui64NV,
  glVertexAttribL3ui64vNV,
  glVertexAttribL4d,
  glVertexAttribL4dEXT,
  glVertexAttribL4dv,
  glVertexAttribL4dvEXT,
  glVertexAttribL4i64NV,
  glVertexAttribL4i64vNV,
  glVertexAttribL4ui64NV,
  glVertexAttribL4ui64vNV,
  glVertexAttribLFormat,
  glVertexAttribLFormatNV,
  glVertexAttribLPointer
) where

import Control.Monad.IO.Class ( MonadIO(..) )
import Foreign.Ptr
import Graphics.GL.Foreign
import Graphics.GL.Types
import System.IO.Unsafe ( unsafePerformIO )

-- glVertexAttrib4svARB --------------------------------------------------------

-- | This command is an alias for 'glVertexAttrib4sv'.
glVertexAttrib4svARB
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> Ptr GLshort -- ^ @v@ pointing to @4@ elements of type @GLshort@.
  -> m ()
glVertexAttrib4svARB :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLshort -> m ()
glVertexAttrib4svARB GLuint
v1 Ptr GLshort
v2 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> Ptr GLshort -> IO ())
-> GLuint -> Ptr GLshort -> IO ()
dyn883 FunPtr (GLuint -> Ptr GLshort -> IO ())
ptr_glVertexAttrib4svARB GLuint
v1 Ptr GLshort
v2

{-# NOINLINE ptr_glVertexAttrib4svARB #-}
ptr_glVertexAttrib4svARB :: FunPtr (GLuint -> Ptr GLshort -> IO ())
ptr_glVertexAttrib4svARB :: FunPtr (GLuint -> Ptr GLshort -> IO ())
ptr_glVertexAttrib4svARB = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ forall a. String -> IO (FunPtr a)
getCommand String
"glVertexAttrib4svARB"

-- glVertexAttrib4svNV ---------------------------------------------------------

-- | This command is an alias for 'glVertexAttrib4sv'.
glVertexAttrib4svNV
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> Ptr GLshort -- ^ @v@ pointing to @4@ elements of type @GLshort@.
  -> m ()
glVertexAttrib4svNV :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLshort -> m ()
glVertexAttrib4svNV GLuint
v1 Ptr GLshort
v2 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> Ptr GLshort -> IO ())
-> GLuint -> Ptr GLshort -> IO ()
dyn883 FunPtr (GLuint -> Ptr GLshort -> IO ())
ptr_glVertexAttrib4svNV GLuint
v1 Ptr GLshort
v2

{-# NOINLINE ptr_glVertexAttrib4svNV #-}
ptr_glVertexAttrib4svNV :: FunPtr (GLuint -> Ptr GLshort -> IO ())
ptr_glVertexAttrib4svNV :: FunPtr (GLuint -> Ptr GLshort -> IO ())
ptr_glVertexAttrib4svNV = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ forall a. String -> IO (FunPtr a)
getCommand String
"glVertexAttrib4svNV"

-- glVertexAttrib4ubNV ---------------------------------------------------------

-- | The vector equivalent of this command is 'glVertexAttrib4ubvNV'. This command is an alias for 'glVertexAttrib4Nub'.
glVertexAttrib4ubNV
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> GLubyte -- ^ @x@ of type @ColorUB@.
  -> GLubyte -- ^ @y@ of type @ColorUB@.
  -> GLubyte -- ^ @z@ of type @ColorUB@.
  -> GLubyte -- ^ @w@ of type @ColorUB@.
  -> m ()
glVertexAttrib4ubNV :: forall (m :: * -> *).
MonadIO m =>
GLuint -> GLubyte -> GLubyte -> GLubyte -> GLubyte -> m ()
glVertexAttrib4ubNV GLuint
v1 GLubyte
v2 GLubyte
v3 GLubyte
v4 GLubyte
v5 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ FunPtr
  (GLuint -> GLubyte -> GLubyte -> GLubyte -> GLubyte -> IO ())
-> GLuint -> GLubyte -> GLubyte -> GLubyte -> GLubyte -> IO ()
dyn905 FunPtr
  (GLuint -> GLubyte -> GLubyte -> GLubyte -> GLubyte -> IO ())
ptr_glVertexAttrib4ubNV GLuint
v1 GLubyte
v2 GLubyte
v3 GLubyte
v4 GLubyte
v5

{-# NOINLINE ptr_glVertexAttrib4ubNV #-}
ptr_glVertexAttrib4ubNV :: FunPtr (GLuint -> GLubyte -> GLubyte -> GLubyte -> GLubyte -> IO ())
ptr_glVertexAttrib4ubNV :: FunPtr
  (GLuint -> GLubyte -> GLubyte -> GLubyte -> GLubyte -> IO ())
ptr_glVertexAttrib4ubNV = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ forall a. String -> IO (FunPtr a)
getCommand String
"glVertexAttrib4ubNV"

-- glVertexAttrib4ubv ----------------------------------------------------------

-- | Manual pages for <https://www.opengl.org/sdk/docs/man2/xhtml/glVertexAttrib.xml OpenGL 2.x> or <https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib.xml OpenGL 3.x> or <https://www.opengl.org/sdk/docs/man4/html/glVertexAttrib.xhtml OpenGL 4.x>.
glVertexAttrib4ubv
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> Ptr GLubyte -- ^ @v@ pointing to @4@ elements of type @GLubyte@.
  -> m ()
glVertexAttrib4ubv :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLubyte -> m ()
glVertexAttrib4ubv GLuint
v1 Ptr GLubyte
v2 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> Ptr GLubyte -> IO ())
-> GLuint -> Ptr GLubyte -> IO ()
dyn393 FunPtr (GLuint -> Ptr GLubyte -> IO ())
ptr_glVertexAttrib4ubv GLuint
v1 Ptr GLubyte
v2

{-# NOINLINE ptr_glVertexAttrib4ubv #-}
ptr_glVertexAttrib4ubv :: FunPtr (GLuint -> Ptr GLubyte -> IO ())
ptr_glVertexAttrib4ubv :: FunPtr (GLuint -> Ptr GLubyte -> IO ())
ptr_glVertexAttrib4ubv = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ forall a. String -> IO (FunPtr a)
getCommand String
"glVertexAttrib4ubv"

-- glVertexAttrib4ubvARB -------------------------------------------------------

-- | This command is an alias for 'glVertexAttrib4ubv'.
glVertexAttrib4ubvARB
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> Ptr GLubyte -- ^ @v@ pointing to @4@ elements of type @GLubyte@.
  -> m ()
glVertexAttrib4ubvARB :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLubyte -> m ()
glVertexAttrib4ubvARB GLuint
v1 Ptr GLubyte
v2 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> Ptr GLubyte -> IO ())
-> GLuint -> Ptr GLubyte -> IO ()
dyn393 FunPtr (GLuint -> Ptr GLubyte -> IO ())
ptr_glVertexAttrib4ubvARB GLuint
v1 Ptr GLubyte
v2

{-# NOINLINE ptr_glVertexAttrib4ubvARB #-}
ptr_glVertexAttrib4ubvARB :: FunPtr (GLuint -> Ptr GLubyte -> IO ())
ptr_glVertexAttrib4ubvARB :: FunPtr (GLuint -> Ptr GLubyte -> IO ())
ptr_glVertexAttrib4ubvARB = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ forall a. String -> IO (FunPtr a)
getCommand String
"glVertexAttrib4ubvARB"

-- glVertexAttrib4ubvNV --------------------------------------------------------

-- | This command is an alias for 'glVertexAttrib4Nubv'.
glVertexAttrib4ubvNV
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> Ptr GLubyte -- ^ @v@ pointing to @4@ elements of type @ColorUB@.
  -> m ()
glVertexAttrib4ubvNV :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLubyte -> m ()
glVertexAttrib4ubvNV GLuint
v1 Ptr GLubyte
v2 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> Ptr GLubyte -> IO ())
-> GLuint -> Ptr GLubyte -> IO ()
dyn393 FunPtr (GLuint -> Ptr GLubyte -> IO ())
ptr_glVertexAttrib4ubvNV GLuint
v1 Ptr GLubyte
v2

{-# NOINLINE ptr_glVertexAttrib4ubvNV #-}
ptr_glVertexAttrib4ubvNV :: FunPtr (GLuint -> Ptr GLubyte -> IO ())
ptr_glVertexAttrib4ubvNV :: FunPtr (GLuint -> Ptr GLubyte -> IO ())
ptr_glVertexAttrib4ubvNV = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ forall a. String -> IO (FunPtr a)
getCommand String
"glVertexAttrib4ubvNV"

-- glVertexAttrib4uiv ----------------------------------------------------------

-- | Manual pages for <https://www.opengl.org/sdk/docs/man2/xhtml/glVertexAttrib.xml OpenGL 2.x> or <https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib.xml OpenGL 3.x> or <https://www.opengl.org/sdk/docs/man4/html/glVertexAttrib.xhtml OpenGL 4.x>.
glVertexAttrib4uiv
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> Ptr GLuint -- ^ @v@ pointing to @4@ elements of type @GLuint@.
  -> m ()
glVertexAttrib4uiv :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLuint -> m ()
glVertexAttrib4uiv GLuint
v1 Ptr GLuint
v2 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> Ptr GLuint -> IO ())
-> GLuint -> Ptr GLuint -> IO ()
dyn201 FunPtr (GLuint -> Ptr GLuint -> IO ())
ptr_glVertexAttrib4uiv GLuint
v1 Ptr GLuint
v2

{-# NOINLINE ptr_glVertexAttrib4uiv #-}
ptr_glVertexAttrib4uiv :: FunPtr (GLuint -> Ptr GLuint -> IO ())
ptr_glVertexAttrib4uiv :: FunPtr (GLuint -> Ptr GLuint -> IO ())
ptr_glVertexAttrib4uiv = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ forall a. String -> IO (FunPtr a)
getCommand String
"glVertexAttrib4uiv"

-- glVertexAttrib4uivARB -------------------------------------------------------

-- | This command is an alias for 'glVertexAttrib4uiv'.
glVertexAttrib4uivARB
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> Ptr GLuint -- ^ @v@ pointing to @4@ elements of type @GLuint@.
  -> m ()
glVertexAttrib4uivARB :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLuint -> m ()
glVertexAttrib4uivARB GLuint
v1 Ptr GLuint
v2 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> Ptr GLuint -> IO ())
-> GLuint -> Ptr GLuint -> IO ()
dyn201 FunPtr (GLuint -> Ptr GLuint -> IO ())
ptr_glVertexAttrib4uivARB GLuint
v1 Ptr GLuint
v2

{-# NOINLINE ptr_glVertexAttrib4uivARB #-}
ptr_glVertexAttrib4uivARB :: FunPtr (GLuint -> Ptr GLuint -> IO ())
ptr_glVertexAttrib4uivARB :: FunPtr (GLuint -> Ptr GLuint -> IO ())
ptr_glVertexAttrib4uivARB = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ forall a. String -> IO (FunPtr a)
getCommand String
"glVertexAttrib4uivARB"

-- glVertexAttrib4usv ----------------------------------------------------------

-- | Manual pages for <https://www.opengl.org/sdk/docs/man2/xhtml/glVertexAttrib.xml OpenGL 2.x> or <https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib.xml OpenGL 3.x> or <https://www.opengl.org/sdk/docs/man4/html/glVertexAttrib.xhtml OpenGL 4.x>.
glVertexAttrib4usv
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> Ptr GLushort -- ^ @v@ pointing to @4@ elements of type @GLushort@.
  -> m ()
glVertexAttrib4usv :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLushort -> m ()
glVertexAttrib4usv GLuint
v1 Ptr GLushort
v2 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> Ptr GLushort -> IO ())
-> GLuint -> Ptr GLushort -> IO ()
dyn884 FunPtr (GLuint -> Ptr GLushort -> IO ())
ptr_glVertexAttrib4usv GLuint
v1 Ptr GLushort
v2

{-# NOINLINE ptr_glVertexAttrib4usv #-}
ptr_glVertexAttrib4usv :: FunPtr (GLuint -> Ptr GLushort -> IO ())
ptr_glVertexAttrib4usv :: FunPtr (GLuint -> Ptr GLushort -> IO ())
ptr_glVertexAttrib4usv = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ forall a. String -> IO (FunPtr a)
getCommand String
"glVertexAttrib4usv"

-- glVertexAttrib4usvARB -------------------------------------------------------

-- | This command is an alias for 'glVertexAttrib4usv'.
glVertexAttrib4usvARB
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> Ptr GLushort -- ^ @v@ pointing to @4@ elements of type @GLushort@.
  -> m ()
glVertexAttrib4usvARB :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLushort -> m ()
glVertexAttrib4usvARB GLuint
v1 Ptr GLushort
v2 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> Ptr GLushort -> IO ())
-> GLuint -> Ptr GLushort -> IO ()
dyn884 FunPtr (GLuint -> Ptr GLushort -> IO ())
ptr_glVertexAttrib4usvARB GLuint
v1 Ptr GLushort
v2

{-# NOINLINE ptr_glVertexAttrib4usvARB #-}
ptr_glVertexAttrib4usvARB :: FunPtr (GLuint -> Ptr GLushort -> IO ())
ptr_glVertexAttrib4usvARB :: FunPtr (GLuint -> Ptr GLushort -> IO ())
ptr_glVertexAttrib4usvARB = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ forall a. String -> IO (FunPtr a)
getCommand String
"glVertexAttrib4usvARB"

-- glVertexAttribArrayObjectATI ------------------------------------------------

glVertexAttribArrayObjectATI
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> GLint -- ^ @size@.
  -> GLenum -- ^ @type@ of type [VertexAttribPointerType](Graphics-GL-Groups.html#VertexAttribPointerType).
  -> GLboolean -- ^ @normalized@ of type [Boolean](Graphics-GL-Groups.html#Boolean).
  -> GLsizei -- ^ @stride@.
  -> GLuint -- ^ @buffer@.
  -> GLuint -- ^ @offset@.
  -> m ()
glVertexAttribArrayObjectATI :: forall (m :: * -> *).
MonadIO m =>
GLuint
-> GLint -> GLuint -> GLubyte -> GLint -> GLuint -> GLuint -> m ()
glVertexAttribArrayObjectATI GLuint
v1 GLint
v2 GLuint
v3 GLubyte
v4 GLint
v5 GLuint
v6 GLuint
v7 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ FunPtr
  (GLuint
   -> GLint
   -> GLuint
   -> GLubyte
   -> GLint
   -> GLuint
   -> GLuint
   -> IO ())
-> GLuint
-> GLint
-> GLuint
-> GLubyte
-> GLint
-> GLuint
-> GLuint
-> IO ()
dyn910 FunPtr
  (GLuint
   -> GLint
   -> GLuint
   -> GLubyte
   -> GLint
   -> GLuint
   -> GLuint
   -> IO ())
ptr_glVertexAttribArrayObjectATI GLuint
v1 GLint
v2 GLuint
v3 GLubyte
v4 GLint
v5 GLuint
v6 GLuint
v7

{-# NOINLINE ptr_glVertexAttribArrayObjectATI #-}
ptr_glVertexAttribArrayObjectATI :: FunPtr (GLuint -> GLint -> GLenum -> GLboolean -> GLsizei -> GLuint -> GLuint -> IO ())
ptr_glVertexAttribArrayObjectATI :: FunPtr
  (GLuint
   -> GLint
   -> GLuint
   -> GLubyte
   -> GLint
   -> GLuint
   -> GLuint
   -> IO ())
ptr_glVertexAttribArrayObjectATI = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ forall a. String -> IO (FunPtr a)
getCommand String
"glVertexAttribArrayObjectATI"

-- glVertexAttribBinding -------------------------------------------------------

-- | Manual page for <https://www.opengl.org/sdk/docs/man4/html/glVertexAttribBinding.xhtml OpenGL 4.x>.
glVertexAttribBinding
  :: MonadIO m
  => GLuint -- ^ @attribindex@.
  -> GLuint -- ^ @bindingindex@.
  -> m ()
glVertexAttribBinding :: forall (m :: * -> *). MonadIO m => GLuint -> GLuint -> m ()
glVertexAttribBinding GLuint
v1 GLuint
v2 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> GLuint -> IO ()) -> GLuint -> GLuint -> IO ()
dyn4 FunPtr (GLuint -> GLuint -> IO ())
ptr_glVertexAttribBinding GLuint
v1 GLuint
v2

{-# NOINLINE ptr_glVertexAttribBinding #-}
ptr_glVertexAttribBinding :: FunPtr (GLuint -> GLuint -> IO ())
ptr_glVertexAttribBinding :: FunPtr (GLuint -> GLuint -> IO ())
ptr_glVertexAttribBinding = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ forall a. String -> IO (FunPtr a)
getCommand String
"glVertexAttribBinding"

-- glVertexAttribDivisor -------------------------------------------------------

-- | Manual pages for <https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttribDivisor.xml OpenGL 3.x> or <https://www.opengl.org/sdk/docs/man4/html/glVertexAttribDivisor.xhtml OpenGL 4.x>.
glVertexAttribDivisor
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> GLuint -- ^ @divisor@.
  -> m ()
glVertexAttribDivisor :: forall (m :: * -> *). MonadIO m => GLuint -> GLuint -> m ()
glVertexAttribDivisor GLuint
v1 GLuint
v2 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> GLuint -> IO ()) -> GLuint -> GLuint -> IO ()
dyn4 FunPtr (GLuint -> GLuint -> IO ())
ptr_glVertexAttribDivisor GLuint
v1 GLuint
v2

{-# NOINLINE ptr_glVertexAttribDivisor #-}
ptr_glVertexAttribDivisor :: FunPtr (GLuint -> GLuint -> IO ())
ptr_glVertexAttribDivisor :: FunPtr (GLuint -> GLuint -> IO ())
ptr_glVertexAttribDivisor = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ forall a. String -> IO (FunPtr a)
getCommand String
"glVertexAttribDivisor"

-- glVertexAttribDivisorANGLE --------------------------------------------------

-- | This command is an alias for 'glVertexAttribDivisor'.
glVertexAttribDivisorANGLE
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> GLuint -- ^ @divisor@.
  -> m ()
glVertexAttribDivisorANGLE :: forall (m :: * -> *). MonadIO m => GLuint -> GLuint -> m ()
glVertexAttribDivisorANGLE GLuint
v1 GLuint
v2 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> GLuint -> IO ()) -> GLuint -> GLuint -> IO ()
dyn4 FunPtr (GLuint -> GLuint -> IO ())
ptr_glVertexAttribDivisorANGLE GLuint
v1 GLuint
v2

{-# NOINLINE ptr_glVertexAttribDivisorANGLE #-}
ptr_glVertexAttribDivisorANGLE :: FunPtr (GLuint -> GLuint -> IO ())
ptr_glVertexAttribDivisorANGLE :: FunPtr (GLuint -> GLuint -> IO ())
ptr_glVertexAttribDivisorANGLE = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ forall a. String -> IO (FunPtr a)
getCommand String
"glVertexAttribDivisorANGLE"

-- glVertexAttribDivisorARB ----------------------------------------------------

-- | This command is an alias for 'glVertexAttribDivisor'.
glVertexAttribDivisorARB
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> GLuint -- ^ @divisor@.
  -> m ()
glVertexAttribDivisorARB :: forall (m :: * -> *). MonadIO m => GLuint -> GLuint -> m ()
glVertexAttribDivisorARB GLuint
v1 GLuint
v2 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> GLuint -> IO ()) -> GLuint -> GLuint -> IO ()
dyn4 FunPtr (GLuint -> GLuint -> IO ())
ptr_glVertexAttribDivisorARB GLuint
v1 GLuint
v2

{-# NOINLINE ptr_glVertexAttribDivisorARB #-}
ptr_glVertexAttribDivisorARB :: FunPtr (GLuint -> GLuint -> IO ())
ptr_glVertexAttribDivisorARB :: FunPtr (GLuint -> GLuint -> IO ())
ptr_glVertexAttribDivisorARB = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ forall a. String -> IO (FunPtr a)
getCommand String
"glVertexAttribDivisorARB"

-- glVertexAttribDivisorEXT ----------------------------------------------------

-- | This command is an alias for 'glVertexAttribDivisor'.
glVertexAttribDivisorEXT
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> GLuint -- ^ @divisor@.
  -> m ()
glVertexAttribDivisorEXT :: forall (m :: * -> *). MonadIO m => GLuint -> GLuint -> m ()
glVertexAttribDivisorEXT GLuint
v1 GLuint
v2 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> GLuint -> IO ()) -> GLuint -> GLuint -> IO ()
dyn4 FunPtr (GLuint -> GLuint -> IO ())
ptr_glVertexAttribDivisorEXT GLuint
v1 GLuint
v2

{-# NOINLINE ptr_glVertexAttribDivisorEXT #-}
ptr_glVertexAttribDivisorEXT :: FunPtr (GLuint -> GLuint -> IO ())
ptr_glVertexAttribDivisorEXT :: FunPtr (GLuint -> GLuint -> IO ())
ptr_glVertexAttribDivisorEXT = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ forall a. String -> IO (FunPtr a)
getCommand String
"glVertexAttribDivisorEXT"

-- glVertexAttribDivisorNV -----------------------------------------------------

-- | This command is an alias for 'glVertexAttribDivisor'.
glVertexAttribDivisorNV
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> GLuint -- ^ @divisor@.
  -> m ()
glVertexAttribDivisorNV :: forall (m :: * -> *). MonadIO m => GLuint -> GLuint -> m ()
glVertexAttribDivisorNV GLuint
v1 GLuint
v2 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> GLuint -> IO ()) -> GLuint -> GLuint -> IO ()
dyn4 FunPtr (GLuint -> GLuint -> IO ())
ptr_glVertexAttribDivisorNV GLuint
v1 GLuint
v2

{-# NOINLINE ptr_glVertexAttribDivisorNV #-}
ptr_glVertexAttribDivisorNV :: FunPtr (GLuint -> GLuint -> IO ())
ptr_glVertexAttribDivisorNV :: FunPtr (GLuint -> GLuint -> IO ())
ptr_glVertexAttribDivisorNV = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ forall a. String -> IO (FunPtr a)
getCommand String
"glVertexAttribDivisorNV"

-- glVertexAttribFormat --------------------------------------------------------

-- | Manual page for <https://www.opengl.org/sdk/docs/man4/html/glVertexAttribFormat.xhtml OpenGL 4.x>.
glVertexAttribFormat
  :: MonadIO m
  => GLuint -- ^ @attribindex@.
  -> GLint -- ^ @size@.
  -> GLenum -- ^ @type@ of type [VertexAttribType](Graphics-GL-Groups.html#VertexAttribType).
  -> GLboolean -- ^ @normalized@ of type [Boolean](Graphics-GL-Groups.html#Boolean).
  -> GLuint -- ^ @relativeoffset@.
  -> m ()
glVertexAttribFormat :: forall (m :: * -> *).
MonadIO m =>
GLuint -> GLint -> GLuint -> GLubyte -> GLuint -> m ()
glVertexAttribFormat GLuint
v1 GLint
v2 GLuint
v3 GLubyte
v4 GLuint
v5 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> GLint -> GLuint -> GLubyte -> GLuint -> IO ())
-> GLuint -> GLint -> GLuint -> GLubyte -> GLuint -> IO ()
dyn911 FunPtr (GLuint -> GLint -> GLuint -> GLubyte -> GLuint -> IO ())
ptr_glVertexAttribFormat GLuint
v1 GLint
v2 GLuint
v3 GLubyte
v4 GLuint
v5

{-# NOINLINE ptr_glVertexAttribFormat #-}
ptr_glVertexAttribFormat :: FunPtr (GLuint -> GLint -> GLenum -> GLboolean -> GLuint -> IO ())
ptr_glVertexAttribFormat :: FunPtr (GLuint -> GLint -> GLuint -> GLubyte -> GLuint -> IO ())
ptr_glVertexAttribFormat = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ forall a. String -> IO (FunPtr a)
getCommand String
"glVertexAttribFormat"

-- glVertexAttribFormatNV ------------------------------------------------------

glVertexAttribFormatNV
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> GLint -- ^ @size@.
  -> GLenum -- ^ @type@ of type [VertexAttribType](Graphics-GL-Groups.html#VertexAttribType).
  -> GLboolean -- ^ @normalized@ of type [Boolean](Graphics-GL-Groups.html#Boolean).
  -> GLsizei -- ^ @stride@.
  -> m ()
glVertexAttribFormatNV :: forall (m :: * -> *).
MonadIO m =>
GLuint -> GLint -> GLuint -> GLubyte -> GLint -> m ()
glVertexAttribFormatNV GLuint
v1 GLint
v2 GLuint
v3 GLubyte
v4 GLint
v5 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> GLint -> GLuint -> GLubyte -> GLint -> IO ())
-> GLuint -> GLint -> GLuint -> GLubyte -> GLint -> IO ()
dyn912 FunPtr (GLuint -> GLint -> GLuint -> GLubyte -> GLint -> IO ())
ptr_glVertexAttribFormatNV GLuint
v1 GLint
v2 GLuint
v3 GLubyte
v4 GLint
v5

{-# NOINLINE ptr_glVertexAttribFormatNV #-}
ptr_glVertexAttribFormatNV :: FunPtr (GLuint -> GLint -> GLenum -> GLboolean -> GLsizei -> IO ())
ptr_glVertexAttribFormatNV :: FunPtr (GLuint -> GLint -> GLuint -> GLubyte -> GLint -> IO ())
ptr_glVertexAttribFormatNV = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ forall a. String -> IO (FunPtr a)
getCommand String
"glVertexAttribFormatNV"

-- glVertexAttribI1i -----------------------------------------------------------

-- | Manual pages for <https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib.xml OpenGL 3.x> or <https://www.opengl.org/sdk/docs/man4/html/glVertexAttrib.xhtml OpenGL 4.x>. The vector equivalent of this command is 'glVertexAttribI1iv'.
glVertexAttribI1i
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> GLint -- ^ @x@.
  -> m ()
glVertexAttribI1i :: forall (m :: * -> *). MonadIO m => GLuint -> GLint -> m ()
glVertexAttribI1i GLuint
v1 GLint
v2 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> GLint -> IO ()) -> GLuint -> GLint -> IO ()
dyn499 FunPtr (GLuint -> GLint -> IO ())
ptr_glVertexAttribI1i GLuint
v1 GLint
v2

{-# NOINLINE ptr_glVertexAttribI1i #-}
ptr_glVertexAttribI1i :: FunPtr (GLuint -> GLint -> IO ())
ptr_glVertexAttribI1i :: FunPtr (GLuint -> GLint -> IO ())
ptr_glVertexAttribI1i = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ forall a. String -> IO (FunPtr a)
getCommand String
"glVertexAttribI1i"

-- glVertexAttribI1iEXT --------------------------------------------------------

-- | The vector equivalent of this command is 'glVertexAttribI1ivEXT'. This command is an alias for 'glVertexAttribI1i'.
glVertexAttribI1iEXT
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> GLint -- ^ @x@.
  -> m ()
glVertexAttribI1iEXT :: forall (m :: * -> *). MonadIO m => GLuint -> GLint -> m ()
glVertexAttribI1iEXT GLuint
v1 GLint
v2 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> GLint -> IO ()) -> GLuint -> GLint -> IO ()
dyn499 FunPtr (GLuint -> GLint -> IO ())
ptr_glVertexAttribI1iEXT GLuint
v1 GLint
v2

{-# NOINLINE ptr_glVertexAttribI1iEXT #-}
ptr_glVertexAttribI1iEXT :: FunPtr (GLuint -> GLint -> IO ())
ptr_glVertexAttribI1iEXT :: FunPtr (GLuint -> GLint -> IO ())
ptr_glVertexAttribI1iEXT = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ forall a. String -> IO (FunPtr a)
getCommand String
"glVertexAttribI1iEXT"

-- glVertexAttribI1iv ----------------------------------------------------------

-- | Manual pages for <https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib.xml OpenGL 3.x> or <https://www.opengl.org/sdk/docs/man4/html/glVertexAttrib.xhtml OpenGL 4.x>.
glVertexAttribI1iv
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> Ptr GLint -- ^ @v@ pointing to @1@ element of type @GLint@.
  -> m ()
glVertexAttribI1iv :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLint -> m ()
glVertexAttribI1iv GLuint
v1 Ptr GLint
v2 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> Ptr GLint -> IO ())
-> GLuint -> Ptr GLint -> IO ()
dyn741 FunPtr (GLuint -> Ptr GLint -> IO ())
ptr_glVertexAttribI1iv GLuint
v1 Ptr GLint
v2

{-# NOINLINE ptr_glVertexAttribI1iv #-}
ptr_glVertexAttribI1iv :: FunPtr (GLuint -> Ptr GLint -> IO ())
ptr_glVertexAttribI1iv :: FunPtr (GLuint -> Ptr GLint -> IO ())
ptr_glVertexAttribI1iv = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ forall a. String -> IO (FunPtr a)
getCommand String
"glVertexAttribI1iv"

-- glVertexAttribI1ivEXT -------------------------------------------------------

-- | This command is an alias for 'glVertexAttribI1iv'.
glVertexAttribI1ivEXT
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> Ptr GLint -- ^ @v@ pointing to @1@ element of type @GLint@.
  -> m ()
glVertexAttribI1ivEXT :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLint -> m ()
glVertexAttribI1ivEXT GLuint
v1 Ptr GLint
v2 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> Ptr GLint -> IO ())
-> GLuint -> Ptr GLint -> IO ()
dyn741 FunPtr (GLuint -> Ptr GLint -> IO ())
ptr_glVertexAttribI1ivEXT GLuint
v1 Ptr GLint
v2

{-# NOINLINE ptr_glVertexAttribI1ivEXT #-}
ptr_glVertexAttribI1ivEXT :: FunPtr (GLuint -> Ptr GLint -> IO ())
ptr_glVertexAttribI1ivEXT :: FunPtr (GLuint -> Ptr GLint -> IO ())
ptr_glVertexAttribI1ivEXT = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ forall a. String -> IO (FunPtr a)
getCommand String
"glVertexAttribI1ivEXT"

-- glVertexAttribI1ui ----------------------------------------------------------

-- | Manual pages for <https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib.xml OpenGL 3.x> or <https://www.opengl.org/sdk/docs/man4/html/glVertexAttrib.xhtml OpenGL 4.x>. The vector equivalent of this command is 'glVertexAttribI1uiv'.
glVertexAttribI1ui
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> GLuint -- ^ @x@.
  -> m ()
glVertexAttribI1ui :: forall (m :: * -> *). MonadIO m => GLuint -> GLuint -> m ()
glVertexAttribI1ui GLuint
v1 GLuint
v2 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> GLuint -> IO ()) -> GLuint -> GLuint -> IO ()
dyn4 FunPtr (GLuint -> GLuint -> IO ())
ptr_glVertexAttribI1ui GLuint
v1 GLuint
v2

{-# NOINLINE ptr_glVertexAttribI1ui #-}
ptr_glVertexAttribI1ui :: FunPtr (GLuint -> GLuint -> IO ())
ptr_glVertexAttribI1ui :: FunPtr (GLuint -> GLuint -> IO ())
ptr_glVertexAttribI1ui = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ forall a. String -> IO (FunPtr a)
getCommand String
"glVertexAttribI1ui"

-- glVertexAttribI1uiEXT -------------------------------------------------------

-- | The vector equivalent of this command is 'glVertexAttribI1uivEXT'. This command is an alias for 'glVertexAttribI1ui'.
glVertexAttribI1uiEXT
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> GLuint -- ^ @x@.
  -> m ()
glVertexAttribI1uiEXT :: forall (m :: * -> *). MonadIO m => GLuint -> GLuint -> m ()
glVertexAttribI1uiEXT GLuint
v1 GLuint
v2 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> GLuint -> IO ()) -> GLuint -> GLuint -> IO ()
dyn4 FunPtr (GLuint -> GLuint -> IO ())
ptr_glVertexAttribI1uiEXT GLuint
v1 GLuint
v2

{-# NOINLINE ptr_glVertexAttribI1uiEXT #-}
ptr_glVertexAttribI1uiEXT :: FunPtr (GLuint -> GLuint -> IO ())
ptr_glVertexAttribI1uiEXT :: FunPtr (GLuint -> GLuint -> IO ())
ptr_glVertexAttribI1uiEXT = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ forall a. String -> IO (FunPtr a)
getCommand String
"glVertexAttribI1uiEXT"

-- glVertexAttribI1uiv ---------------------------------------------------------

-- | Manual pages for <https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib.xml OpenGL 3.x> or <https://www.opengl.org/sdk/docs/man4/html/glVertexAttrib.xhtml OpenGL 4.x>.
glVertexAttribI1uiv
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> Ptr GLuint -- ^ @v@ pointing to @1@ element of type @GLuint@.
  -> m ()
glVertexAttribI1uiv :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLuint -> m ()
glVertexAttribI1uiv GLuint
v1 Ptr GLuint
v2 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> Ptr GLuint -> IO ())
-> GLuint -> Ptr GLuint -> IO ()
dyn201 FunPtr (GLuint -> Ptr GLuint -> IO ())
ptr_glVertexAttribI1uiv GLuint
v1 Ptr GLuint
v2

{-# NOINLINE ptr_glVertexAttribI1uiv #-}
ptr_glVertexAttribI1uiv :: FunPtr (GLuint -> Ptr GLuint -> IO ())
ptr_glVertexAttribI1uiv :: FunPtr (GLuint -> Ptr GLuint -> IO ())
ptr_glVertexAttribI1uiv = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ forall a. String -> IO (FunPtr a)
getCommand String
"glVertexAttribI1uiv"

-- glVertexAttribI1uivEXT ------------------------------------------------------

-- | This command is an alias for 'glVertexAttribI1uiv'.
glVertexAttribI1uivEXT
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> Ptr GLuint -- ^ @v@ pointing to @1@ element of type @GLuint@.
  -> m ()
glVertexAttribI1uivEXT :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLuint -> m ()
glVertexAttribI1uivEXT GLuint
v1 Ptr GLuint
v2 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> Ptr GLuint -> IO ())
-> GLuint -> Ptr GLuint -> IO ()
dyn201 FunPtr (GLuint -> Ptr GLuint -> IO ())
ptr_glVertexAttribI1uivEXT GLuint
v1 Ptr GLuint
v2

{-# NOINLINE ptr_glVertexAttribI1uivEXT #-}
ptr_glVertexAttribI1uivEXT :: FunPtr (GLuint -> Ptr GLuint -> IO ())
ptr_glVertexAttribI1uivEXT :: FunPtr (GLuint -> Ptr GLuint -> IO ())
ptr_glVertexAttribI1uivEXT = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ forall a. String -> IO (FunPtr a)
getCommand String
"glVertexAttribI1uivEXT"

-- glVertexAttribI2i -----------------------------------------------------------

-- | Manual pages for <https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib.xml OpenGL 3.x> or <https://www.opengl.org/sdk/docs/man4/html/glVertexAttrib.xhtml OpenGL 4.x>. The vector equivalent of this command is 'glVertexAttribI2iv'.
glVertexAttribI2i
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> GLint -- ^ @x@.
  -> GLint -- ^ @y@.
  -> m ()
glVertexAttribI2i :: forall (m :: * -> *). MonadIO m => GLuint -> GLint -> GLint -> m ()
glVertexAttribI2i GLuint
v1 GLint
v2 GLint
v3 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> GLint -> GLint -> IO ())
-> GLuint -> GLint -> GLint -> IO ()
dyn672 FunPtr (GLuint -> GLint -> GLint -> IO ())
ptr_glVertexAttribI2i GLuint
v1 GLint
v2 GLint
v3

{-# NOINLINE ptr_glVertexAttribI2i #-}
ptr_glVertexAttribI2i :: FunPtr (GLuint -> GLint -> GLint -> IO ())
ptr_glVertexAttribI2i :: FunPtr (GLuint -> GLint -> GLint -> IO ())
ptr_glVertexAttribI2i = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ forall a. String -> IO (FunPtr a)
getCommand String
"glVertexAttribI2i"

-- glVertexAttribI2iEXT --------------------------------------------------------

-- | The vector equivalent of this command is 'glVertexAttribI2ivEXT'. This command is an alias for 'glVertexAttribI2i'.
glVertexAttribI2iEXT
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> GLint -- ^ @x@.
  -> GLint -- ^ @y@.
  -> m ()
glVertexAttribI2iEXT :: forall (m :: * -> *). MonadIO m => GLuint -> GLint -> GLint -> m ()
glVertexAttribI2iEXT GLuint
v1 GLint
v2 GLint
v3 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> GLint -> GLint -> IO ())
-> GLuint -> GLint -> GLint -> IO ()
dyn672 FunPtr (GLuint -> GLint -> GLint -> IO ())
ptr_glVertexAttribI2iEXT GLuint
v1 GLint
v2 GLint
v3

{-# NOINLINE ptr_glVertexAttribI2iEXT #-}
ptr_glVertexAttribI2iEXT :: FunPtr (GLuint -> GLint -> GLint -> IO ())
ptr_glVertexAttribI2iEXT :: FunPtr (GLuint -> GLint -> GLint -> IO ())
ptr_glVertexAttribI2iEXT = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ forall a. String -> IO (FunPtr a)
getCommand String
"glVertexAttribI2iEXT"

-- glVertexAttribI2iv ----------------------------------------------------------

-- | Manual pages for <https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib.xml OpenGL 3.x> or <https://www.opengl.org/sdk/docs/man4/html/glVertexAttrib.xhtml OpenGL 4.x>.
glVertexAttribI2iv
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> Ptr GLint -- ^ @v@ pointing to @2@ elements of type @GLint@.
  -> m ()
glVertexAttribI2iv :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLint -> m ()
glVertexAttribI2iv GLuint
v1 Ptr GLint
v2 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> Ptr GLint -> IO ())
-> GLuint -> Ptr GLint -> IO ()
dyn741 FunPtr (GLuint -> Ptr GLint -> IO ())
ptr_glVertexAttribI2iv GLuint
v1 Ptr GLint
v2

{-# NOINLINE ptr_glVertexAttribI2iv #-}
ptr_glVertexAttribI2iv :: FunPtr (GLuint -> Ptr GLint -> IO ())
ptr_glVertexAttribI2iv :: FunPtr (GLuint -> Ptr GLint -> IO ())
ptr_glVertexAttribI2iv = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ forall a. String -> IO (FunPtr a)
getCommand String
"glVertexAttribI2iv"

-- glVertexAttribI2ivEXT -------------------------------------------------------

-- | This command is an alias for 'glVertexAttribI2iv'.
glVertexAttribI2ivEXT
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> Ptr GLint -- ^ @v@ pointing to @2@ elements of type @GLint@.
  -> m ()
glVertexAttribI2ivEXT :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLint -> m ()
glVertexAttribI2ivEXT GLuint
v1 Ptr GLint
v2 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> Ptr GLint -> IO ())
-> GLuint -> Ptr GLint -> IO ()
dyn741 FunPtr (GLuint -> Ptr GLint -> IO ())
ptr_glVertexAttribI2ivEXT GLuint
v1 Ptr GLint
v2

{-# NOINLINE ptr_glVertexAttribI2ivEXT #-}
ptr_glVertexAttribI2ivEXT :: FunPtr (GLuint -> Ptr GLint -> IO ())
ptr_glVertexAttribI2ivEXT :: FunPtr (GLuint -> Ptr GLint -> IO ())
ptr_glVertexAttribI2ivEXT = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ forall a. String -> IO (FunPtr a)
getCommand String
"glVertexAttribI2ivEXT"

-- glVertexAttribI2ui ----------------------------------------------------------

-- | Manual pages for <https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib.xml OpenGL 3.x> or <https://www.opengl.org/sdk/docs/man4/html/glVertexAttrib.xhtml OpenGL 4.x>. The vector equivalent of this command is 'glVertexAttribI2uiv'.
glVertexAttribI2ui
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> GLuint -- ^ @x@.
  -> GLuint -- ^ @y@.
  -> m ()
glVertexAttribI2ui :: forall (m :: * -> *).
MonadIO m =>
GLuint -> GLuint -> GLuint -> m ()
glVertexAttribI2ui GLuint
v1 GLuint
v2 GLuint
v3 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> GLuint -> GLuint -> IO ())
-> GLuint -> GLuint -> GLuint -> IO ()
dyn109 FunPtr (GLuint -> GLuint -> GLuint -> IO ())
ptr_glVertexAttribI2ui GLuint
v1 GLuint
v2 GLuint
v3

{-# NOINLINE ptr_glVertexAttribI2ui #-}
ptr_glVertexAttribI2ui :: FunPtr (GLuint -> GLuint -> GLuint -> IO ())
ptr_glVertexAttribI2ui :: FunPtr (GLuint -> GLuint -> GLuint -> IO ())
ptr_glVertexAttribI2ui = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ forall a. String -> IO (FunPtr a)
getCommand String
"glVertexAttribI2ui"

-- glVertexAttribI2uiEXT -------------------------------------------------------

-- | The vector equivalent of this command is 'glVertexAttribI2uivEXT'. This command is an alias for 'glVertexAttribI2ui'.
glVertexAttribI2uiEXT
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> GLuint -- ^ @x@.
  -> GLuint -- ^ @y@.
  -> m ()
glVertexAttribI2uiEXT :: forall (m :: * -> *).
MonadIO m =>
GLuint -> GLuint -> GLuint -> m ()
glVertexAttribI2uiEXT GLuint
v1 GLuint
v2 GLuint
v3 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> GLuint -> GLuint -> IO ())
-> GLuint -> GLuint -> GLuint -> IO ()
dyn109 FunPtr (GLuint -> GLuint -> GLuint -> IO ())
ptr_glVertexAttribI2uiEXT GLuint
v1 GLuint
v2 GLuint
v3

{-# NOINLINE ptr_glVertexAttribI2uiEXT #-}
ptr_glVertexAttribI2uiEXT :: FunPtr (GLuint -> GLuint -> GLuint -> IO ())
ptr_glVertexAttribI2uiEXT :: FunPtr (GLuint -> GLuint -> GLuint -> IO ())
ptr_glVertexAttribI2uiEXT = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ forall a. String -> IO (FunPtr a)
getCommand String
"glVertexAttribI2uiEXT"

-- glVertexAttribI2uiv ---------------------------------------------------------

-- | Manual pages for <https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib.xml OpenGL 3.x> or <https://www.opengl.org/sdk/docs/man4/html/glVertexAttrib.xhtml OpenGL 4.x>.
glVertexAttribI2uiv
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> Ptr GLuint -- ^ @v@ pointing to @2@ elements of type @GLuint@.
  -> m ()
glVertexAttribI2uiv :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLuint -> m ()
glVertexAttribI2uiv GLuint
v1 Ptr GLuint
v2 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> Ptr GLuint -> IO ())
-> GLuint -> Ptr GLuint -> IO ()
dyn201 FunPtr (GLuint -> Ptr GLuint -> IO ())
ptr_glVertexAttribI2uiv GLuint
v1 Ptr GLuint
v2

{-# NOINLINE ptr_glVertexAttribI2uiv #-}
ptr_glVertexAttribI2uiv :: FunPtr (GLuint -> Ptr GLuint -> IO ())
ptr_glVertexAttribI2uiv :: FunPtr (GLuint -> Ptr GLuint -> IO ())
ptr_glVertexAttribI2uiv = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ forall a. String -> IO (FunPtr a)
getCommand String
"glVertexAttribI2uiv"

-- glVertexAttribI2uivEXT ------------------------------------------------------

-- | This command is an alias for 'glVertexAttribI2uiv'.
glVertexAttribI2uivEXT
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> Ptr GLuint -- ^ @v@ pointing to @2@ elements of type @GLuint@.
  -> m ()
glVertexAttribI2uivEXT :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLuint -> m ()
glVertexAttribI2uivEXT GLuint
v1 Ptr GLuint
v2 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> Ptr GLuint -> IO ())
-> GLuint -> Ptr GLuint -> IO ()
dyn201 FunPtr (GLuint -> Ptr GLuint -> IO ())
ptr_glVertexAttribI2uivEXT GLuint
v1 Ptr GLuint
v2

{-# NOINLINE ptr_glVertexAttribI2uivEXT #-}
ptr_glVertexAttribI2uivEXT :: FunPtr (GLuint -> Ptr GLuint -> IO ())
ptr_glVertexAttribI2uivEXT :: FunPtr (GLuint -> Ptr GLuint -> IO ())
ptr_glVertexAttribI2uivEXT = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ forall a. String -> IO (FunPtr a)
getCommand String
"glVertexAttribI2uivEXT"

-- glVertexAttribI3i -----------------------------------------------------------

-- | Manual pages for <https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib.xml OpenGL 3.x> or <https://www.opengl.org/sdk/docs/man4/html/glVertexAttrib.xhtml OpenGL 4.x>. The vector equivalent of this command is 'glVertexAttribI3iv'.
glVertexAttribI3i
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> GLint -- ^ @x@.
  -> GLint -- ^ @y@.
  -> GLint -- ^ @z@.
  -> m ()
glVertexAttribI3i :: forall (m :: * -> *).
MonadIO m =>
GLuint -> GLint -> GLint -> GLint -> m ()
glVertexAttribI3i GLuint
v1 GLint
v2 GLint
v3 GLint
v4 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> GLint -> GLint -> GLint -> IO ())
-> GLuint -> GLint -> GLint -> GLint -> IO ()
dyn682 FunPtr (GLuint -> GLint -> GLint -> GLint -> IO ())
ptr_glVertexAttribI3i GLuint
v1 GLint
v2 GLint
v3 GLint
v4

{-# NOINLINE ptr_glVertexAttribI3i #-}
ptr_glVertexAttribI3i :: FunPtr (GLuint -> GLint -> GLint -> GLint -> IO ())
ptr_glVertexAttribI3i :: FunPtr (GLuint -> GLint -> GLint -> GLint -> IO ())
ptr_glVertexAttribI3i = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ forall a. String -> IO (FunPtr a)
getCommand String
"glVertexAttribI3i"

-- glVertexAttribI3iEXT --------------------------------------------------------

-- | The vector equivalent of this command is 'glVertexAttribI3ivEXT'. This command is an alias for 'glVertexAttribI3i'.
glVertexAttribI3iEXT
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> GLint -- ^ @x@.
  -> GLint -- ^ @y@.
  -> GLint -- ^ @z@.
  -> m ()
glVertexAttribI3iEXT :: forall (m :: * -> *).
MonadIO m =>
GLuint -> GLint -> GLint -> GLint -> m ()
glVertexAttribI3iEXT GLuint
v1 GLint
v2 GLint
v3 GLint
v4 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> GLint -> GLint -> GLint -> IO ())
-> GLuint -> GLint -> GLint -> GLint -> IO ()
dyn682 FunPtr (GLuint -> GLint -> GLint -> GLint -> IO ())
ptr_glVertexAttribI3iEXT GLuint
v1 GLint
v2 GLint
v3 GLint
v4

{-# NOINLINE ptr_glVertexAttribI3iEXT #-}
ptr_glVertexAttribI3iEXT :: FunPtr (GLuint -> GLint -> GLint -> GLint -> IO ())
ptr_glVertexAttribI3iEXT :: FunPtr (GLuint -> GLint -> GLint -> GLint -> IO ())
ptr_glVertexAttribI3iEXT = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ forall a. String -> IO (FunPtr a)
getCommand String
"glVertexAttribI3iEXT"

-- glVertexAttribI3iv ----------------------------------------------------------

-- | Manual pages for <https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib.xml OpenGL 3.x> or <https://www.opengl.org/sdk/docs/man4/html/glVertexAttrib.xhtml OpenGL 4.x>.
glVertexAttribI3iv
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> Ptr GLint -- ^ @v@ pointing to @3@ elements of type @GLint@.
  -> m ()
glVertexAttribI3iv :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLint -> m ()
glVertexAttribI3iv GLuint
v1 Ptr GLint
v2 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> Ptr GLint -> IO ())
-> GLuint -> Ptr GLint -> IO ()
dyn741 FunPtr (GLuint -> Ptr GLint -> IO ())
ptr_glVertexAttribI3iv GLuint
v1 Ptr GLint
v2

{-# NOINLINE ptr_glVertexAttribI3iv #-}
ptr_glVertexAttribI3iv :: FunPtr (GLuint -> Ptr GLint -> IO ())
ptr_glVertexAttribI3iv :: FunPtr (GLuint -> Ptr GLint -> IO ())
ptr_glVertexAttribI3iv = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ forall a. String -> IO (FunPtr a)
getCommand String
"glVertexAttribI3iv"

-- glVertexAttribI3ivEXT -------------------------------------------------------

-- | This command is an alias for 'glVertexAttribI3iv'.
glVertexAttribI3ivEXT
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> Ptr GLint -- ^ @v@ pointing to @3@ elements of type @GLint@.
  -> m ()
glVertexAttribI3ivEXT :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLint -> m ()
glVertexAttribI3ivEXT GLuint
v1 Ptr GLint
v2 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> Ptr GLint -> IO ())
-> GLuint -> Ptr GLint -> IO ()
dyn741 FunPtr (GLuint -> Ptr GLint -> IO ())
ptr_glVertexAttribI3ivEXT GLuint
v1 Ptr GLint
v2

{-# NOINLINE ptr_glVertexAttribI3ivEXT #-}
ptr_glVertexAttribI3ivEXT :: FunPtr (GLuint -> Ptr GLint -> IO ())
ptr_glVertexAttribI3ivEXT :: FunPtr (GLuint -> Ptr GLint -> IO ())
ptr_glVertexAttribI3ivEXT = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ forall a. String -> IO (FunPtr a)
getCommand String
"glVertexAttribI3ivEXT"

-- glVertexAttribI3ui ----------------------------------------------------------

-- | Manual pages for <https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib.xml OpenGL 3.x> or <https://www.opengl.org/sdk/docs/man4/html/glVertexAttrib.xhtml OpenGL 4.x>. The vector equivalent of this command is 'glVertexAttribI3uiv'.
glVertexAttribI3ui
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> GLuint -- ^ @x@.
  -> GLuint -- ^ @y@.
  -> GLuint -- ^ @z@.
  -> m ()
glVertexAttribI3ui :: forall (m :: * -> *).
MonadIO m =>
GLuint -> GLuint -> GLuint -> GLuint -> m ()
glVertexAttribI3ui GLuint
v1 GLuint
v2 GLuint
v3 GLuint
v4 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> GLuint -> GLuint -> GLuint -> IO ())
-> GLuint -> GLuint -> GLuint -> GLuint -> IO ()
dyn83 FunPtr (GLuint -> GLuint -> GLuint -> GLuint -> IO ())
ptr_glVertexAttribI3ui GLuint
v1 GLuint
v2 GLuint
v3 GLuint
v4

{-# NOINLINE ptr_glVertexAttribI3ui #-}
ptr_glVertexAttribI3ui :: FunPtr (GLuint -> GLuint -> GLuint -> GLuint -> IO ())
ptr_glVertexAttribI3ui :: FunPtr (GLuint -> GLuint -> GLuint -> GLuint -> IO ())
ptr_glVertexAttribI3ui = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ forall a. String -> IO (FunPtr a)
getCommand String
"glVertexAttribI3ui"

-- glVertexAttribI3uiEXT -------------------------------------------------------

-- | The vector equivalent of this command is 'glVertexAttribI3uivEXT'. This command is an alias for 'glVertexAttribI3ui'.
glVertexAttribI3uiEXT
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> GLuint -- ^ @x@.
  -> GLuint -- ^ @y@.
  -> GLuint -- ^ @z@.
  -> m ()
glVertexAttribI3uiEXT :: forall (m :: * -> *).
MonadIO m =>
GLuint -> GLuint -> GLuint -> GLuint -> m ()
glVertexAttribI3uiEXT GLuint
v1 GLuint
v2 GLuint
v3 GLuint
v4 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> GLuint -> GLuint -> GLuint -> IO ())
-> GLuint -> GLuint -> GLuint -> GLuint -> IO ()
dyn83 FunPtr (GLuint -> GLuint -> GLuint -> GLuint -> IO ())
ptr_glVertexAttribI3uiEXT GLuint
v1 GLuint
v2 GLuint
v3 GLuint
v4

{-# NOINLINE ptr_glVertexAttribI3uiEXT #-}
ptr_glVertexAttribI3uiEXT :: FunPtr (GLuint -> GLuint -> GLuint -> GLuint -> IO ())
ptr_glVertexAttribI3uiEXT :: FunPtr (GLuint -> GLuint -> GLuint -> GLuint -> IO ())
ptr_glVertexAttribI3uiEXT = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ forall a. String -> IO (FunPtr a)
getCommand String
"glVertexAttribI3uiEXT"

-- glVertexAttribI3uiv ---------------------------------------------------------

-- | Manual pages for <https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib.xml OpenGL 3.x> or <https://www.opengl.org/sdk/docs/man4/html/glVertexAttrib.xhtml OpenGL 4.x>.
glVertexAttribI3uiv
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> Ptr GLuint -- ^ @v@ pointing to @3@ elements of type @GLuint@.
  -> m ()
glVertexAttribI3uiv :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLuint -> m ()
glVertexAttribI3uiv GLuint
v1 Ptr GLuint
v2 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> Ptr GLuint -> IO ())
-> GLuint -> Ptr GLuint -> IO ()
dyn201 FunPtr (GLuint -> Ptr GLuint -> IO ())
ptr_glVertexAttribI3uiv GLuint
v1 Ptr GLuint
v2

{-# NOINLINE ptr_glVertexAttribI3uiv #-}
ptr_glVertexAttribI3uiv :: FunPtr (GLuint -> Ptr GLuint -> IO ())
ptr_glVertexAttribI3uiv :: FunPtr (GLuint -> Ptr GLuint -> IO ())
ptr_glVertexAttribI3uiv = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ forall a. String -> IO (FunPtr a)
getCommand String
"glVertexAttribI3uiv"

-- glVertexAttribI3uivEXT ------------------------------------------------------

-- | This command is an alias for 'glVertexAttribI3uiv'.
glVertexAttribI3uivEXT
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> Ptr GLuint -- ^ @v@ pointing to @3@ elements of type @GLuint@.
  -> m ()
glVertexAttribI3uivEXT :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLuint -> m ()
glVertexAttribI3uivEXT GLuint
v1 Ptr GLuint
v2 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> Ptr GLuint -> IO ())
-> GLuint -> Ptr GLuint -> IO ()
dyn201 FunPtr (GLuint -> Ptr GLuint -> IO ())
ptr_glVertexAttribI3uivEXT GLuint
v1 Ptr GLuint
v2

{-# NOINLINE ptr_glVertexAttribI3uivEXT #-}
ptr_glVertexAttribI3uivEXT :: FunPtr (GLuint -> Ptr GLuint -> IO ())
ptr_glVertexAttribI3uivEXT :: FunPtr (GLuint -> Ptr GLuint -> IO ())
ptr_glVertexAttribI3uivEXT = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ forall a. String -> IO (FunPtr a)
getCommand String
"glVertexAttribI3uivEXT"

-- glVertexAttribI4bv ----------------------------------------------------------

-- | Manual pages for <https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib.xml OpenGL 3.x> or <https://www.opengl.org/sdk/docs/man4/html/glVertexAttrib.xhtml OpenGL 4.x>.
glVertexAttribI4bv
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> Ptr GLbyte -- ^ @v@ pointing to @4@ elements of type @GLbyte@.
  -> m ()
glVertexAttribI4bv :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLbyte -> m ()
glVertexAttribI4bv GLuint
v1 Ptr GLbyte
v2 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> Ptr GLbyte -> IO ())
-> GLuint -> Ptr GLbyte -> IO ()
dyn881 FunPtr (GLuint -> Ptr GLbyte -> IO ())
ptr_glVertexAttribI4bv GLuint
v1 Ptr GLbyte
v2

{-# NOINLINE ptr_glVertexAttribI4bv #-}
ptr_glVertexAttribI4bv :: FunPtr (GLuint -> Ptr GLbyte -> IO ())
ptr_glVertexAttribI4bv :: FunPtr (GLuint -> Ptr GLbyte -> IO ())
ptr_glVertexAttribI4bv = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ forall a. String -> IO (FunPtr a)
getCommand String
"glVertexAttribI4bv"

-- glVertexAttribI4bvEXT -------------------------------------------------------

-- | This command is an alias for 'glVertexAttribI4bv'.
glVertexAttribI4bvEXT
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> Ptr GLbyte -- ^ @v@ pointing to @4@ elements of type @GLbyte@.
  -> m ()
glVertexAttribI4bvEXT :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLbyte -> m ()
glVertexAttribI4bvEXT GLuint
v1 Ptr GLbyte
v2 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> Ptr GLbyte -> IO ())
-> GLuint -> Ptr GLbyte -> IO ()
dyn881 FunPtr (GLuint -> Ptr GLbyte -> IO ())
ptr_glVertexAttribI4bvEXT GLuint
v1 Ptr GLbyte
v2

{-# NOINLINE ptr_glVertexAttribI4bvEXT #-}
ptr_glVertexAttribI4bvEXT :: FunPtr (GLuint -> Ptr GLbyte -> IO ())
ptr_glVertexAttribI4bvEXT :: FunPtr (GLuint -> Ptr GLbyte -> IO ())
ptr_glVertexAttribI4bvEXT = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ forall a. String -> IO (FunPtr a)
getCommand String
"glVertexAttribI4bvEXT"

-- glVertexAttribI4i -----------------------------------------------------------

-- | Manual pages for <https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib.xml OpenGL 3.x> or <https://www.opengl.org/sdk/docs/man4/html/glVertexAttrib.xhtml OpenGL 4.x>. The vector equivalent of this command is 'glVertexAttribI4iv'.
glVertexAttribI4i
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> GLint -- ^ @x@.
  -> GLint -- ^ @y@.
  -> GLint -- ^ @z@.
  -> GLint -- ^ @w@.
  -> m ()
glVertexAttribI4i :: forall (m :: * -> *).
MonadIO m =>
GLuint -> GLint -> GLint -> GLint -> GLint -> m ()
glVertexAttribI4i GLuint
v1 GLint
v2 GLint
v3 GLint
v4 GLint
v5 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> GLint -> GLint -> GLint -> GLint -> IO ())
-> GLuint -> GLint -> GLint -> GLint -> GLint -> IO ()
dyn690 FunPtr (GLuint -> GLint -> GLint -> GLint -> GLint -> IO ())
ptr_glVertexAttribI4i GLuint
v1 GLint
v2 GLint
v3 GLint
v4 GLint
v5

{-# NOINLINE ptr_glVertexAttribI4i #-}
ptr_glVertexAttribI4i :: FunPtr (GLuint -> GLint -> GLint -> GLint -> GLint -> IO ())
ptr_glVertexAttribI4i :: FunPtr (GLuint -> GLint -> GLint -> GLint -> GLint -> IO ())
ptr_glVertexAttribI4i = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ forall a. String -> IO (FunPtr a)
getCommand String
"glVertexAttribI4i"

-- glVertexAttribI4iEXT --------------------------------------------------------

-- | The vector equivalent of this command is 'glVertexAttribI4ivEXT'. This command is an alias for 'glVertexAttribI4i'.
glVertexAttribI4iEXT
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> GLint -- ^ @x@.
  -> GLint -- ^ @y@.
  -> GLint -- ^ @z@.
  -> GLint -- ^ @w@.
  -> m ()
glVertexAttribI4iEXT :: forall (m :: * -> *).
MonadIO m =>
GLuint -> GLint -> GLint -> GLint -> GLint -> m ()
glVertexAttribI4iEXT GLuint
v1 GLint
v2 GLint
v3 GLint
v4 GLint
v5 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> GLint -> GLint -> GLint -> GLint -> IO ())
-> GLuint -> GLint -> GLint -> GLint -> GLint -> IO ()
dyn690 FunPtr (GLuint -> GLint -> GLint -> GLint -> GLint -> IO ())
ptr_glVertexAttribI4iEXT GLuint
v1 GLint
v2 GLint
v3 GLint
v4 GLint
v5

{-# NOINLINE ptr_glVertexAttribI4iEXT #-}
ptr_glVertexAttribI4iEXT :: FunPtr (GLuint -> GLint -> GLint -> GLint -> GLint -> IO ())
ptr_glVertexAttribI4iEXT :: FunPtr (GLuint -> GLint -> GLint -> GLint -> GLint -> IO ())
ptr_glVertexAttribI4iEXT = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ forall a. String -> IO (FunPtr a)
getCommand String
"glVertexAttribI4iEXT"

-- glVertexAttribI4iv ----------------------------------------------------------

-- | Manual pages for <https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib.xml OpenGL 3.x> or <https://www.opengl.org/sdk/docs/man4/html/glVertexAttrib.xhtml OpenGL 4.x>.
glVertexAttribI4iv
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> Ptr GLint -- ^ @v@ pointing to @4@ elements of type @GLint@.
  -> m ()
glVertexAttribI4iv :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLint -> m ()
glVertexAttribI4iv GLuint
v1 Ptr GLint
v2 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> Ptr GLint -> IO ())
-> GLuint -> Ptr GLint -> IO ()
dyn741 FunPtr (GLuint -> Ptr GLint -> IO ())
ptr_glVertexAttribI4iv GLuint
v1 Ptr GLint
v2

{-# NOINLINE ptr_glVertexAttribI4iv #-}
ptr_glVertexAttribI4iv :: FunPtr (GLuint -> Ptr GLint -> IO ())
ptr_glVertexAttribI4iv :: FunPtr (GLuint -> Ptr GLint -> IO ())
ptr_glVertexAttribI4iv = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ forall a. String -> IO (FunPtr a)
getCommand String
"glVertexAttribI4iv"

-- glVertexAttribI4ivEXT -------------------------------------------------------

-- | This command is an alias for 'glVertexAttribI4iv'.
glVertexAttribI4ivEXT
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> Ptr GLint -- ^ @v@ pointing to @4@ elements of type @GLint@.
  -> m ()
glVertexAttribI4ivEXT :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLint -> m ()
glVertexAttribI4ivEXT GLuint
v1 Ptr GLint
v2 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> Ptr GLint -> IO ())
-> GLuint -> Ptr GLint -> IO ()
dyn741 FunPtr (GLuint -> Ptr GLint -> IO ())
ptr_glVertexAttribI4ivEXT GLuint
v1 Ptr GLint
v2

{-# NOINLINE ptr_glVertexAttribI4ivEXT #-}
ptr_glVertexAttribI4ivEXT :: FunPtr (GLuint -> Ptr GLint -> IO ())
ptr_glVertexAttribI4ivEXT :: FunPtr (GLuint -> Ptr GLint -> IO ())
ptr_glVertexAttribI4ivEXT = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ forall a. String -> IO (FunPtr a)
getCommand String
"glVertexAttribI4ivEXT"

-- glVertexAttribI4sv ----------------------------------------------------------

-- | Manual pages for <https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib.xml OpenGL 3.x> or <https://www.opengl.org/sdk/docs/man4/html/glVertexAttrib.xhtml OpenGL 4.x>.
glVertexAttribI4sv
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> Ptr GLshort -- ^ @v@ pointing to @4@ elements of type @GLshort@.
  -> m ()
glVertexAttribI4sv :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLshort -> m ()
glVertexAttribI4sv GLuint
v1 Ptr GLshort
v2 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> Ptr GLshort -> IO ())
-> GLuint -> Ptr GLshort -> IO ()
dyn883 FunPtr (GLuint -> Ptr GLshort -> IO ())
ptr_glVertexAttribI4sv GLuint
v1 Ptr GLshort
v2

{-# NOINLINE ptr_glVertexAttribI4sv #-}
ptr_glVertexAttribI4sv :: FunPtr (GLuint -> Ptr GLshort -> IO ())
ptr_glVertexAttribI4sv :: FunPtr (GLuint -> Ptr GLshort -> IO ())
ptr_glVertexAttribI4sv = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ forall a. String -> IO (FunPtr a)
getCommand String
"glVertexAttribI4sv"

-- glVertexAttribI4svEXT -------------------------------------------------------

-- | This command is an alias for 'glVertexAttribI4sv'.
glVertexAttribI4svEXT
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> Ptr GLshort -- ^ @v@ pointing to @4@ elements of type @GLshort@.
  -> m ()
glVertexAttribI4svEXT :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLshort -> m ()
glVertexAttribI4svEXT GLuint
v1 Ptr GLshort
v2 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> Ptr GLshort -> IO ())
-> GLuint -> Ptr GLshort -> IO ()
dyn883 FunPtr (GLuint -> Ptr GLshort -> IO ())
ptr_glVertexAttribI4svEXT GLuint
v1 Ptr GLshort
v2

{-# NOINLINE ptr_glVertexAttribI4svEXT #-}
ptr_glVertexAttribI4svEXT :: FunPtr (GLuint -> Ptr GLshort -> IO ())
ptr_glVertexAttribI4svEXT :: FunPtr (GLuint -> Ptr GLshort -> IO ())
ptr_glVertexAttribI4svEXT = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ forall a. String -> IO (FunPtr a)
getCommand String
"glVertexAttribI4svEXT"

-- glVertexAttribI4ubv ---------------------------------------------------------

-- | Manual pages for <https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib.xml OpenGL 3.x> or <https://www.opengl.org/sdk/docs/man4/html/glVertexAttrib.xhtml OpenGL 4.x>.
glVertexAttribI4ubv
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> Ptr GLubyte -- ^ @v@ pointing to @4@ elements of type @GLubyte@.
  -> m ()
glVertexAttribI4ubv :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLubyte -> m ()
glVertexAttribI4ubv GLuint
v1 Ptr GLubyte
v2 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> Ptr GLubyte -> IO ())
-> GLuint -> Ptr GLubyte -> IO ()
dyn393 FunPtr (GLuint -> Ptr GLubyte -> IO ())
ptr_glVertexAttribI4ubv GLuint
v1 Ptr GLubyte
v2

{-# NOINLINE ptr_glVertexAttribI4ubv #-}
ptr_glVertexAttribI4ubv :: FunPtr (GLuint -> Ptr GLubyte -> IO ())
ptr_glVertexAttribI4ubv :: FunPtr (GLuint -> Ptr GLubyte -> IO ())
ptr_glVertexAttribI4ubv = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ forall a. String -> IO (FunPtr a)
getCommand String
"glVertexAttribI4ubv"

-- glVertexAttribI4ubvEXT ------------------------------------------------------

-- | This command is an alias for 'glVertexAttribI4ubv'.
glVertexAttribI4ubvEXT
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> Ptr GLubyte -- ^ @v@ pointing to @4@ elements of type @GLubyte@.
  -> m ()
glVertexAttribI4ubvEXT :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLubyte -> m ()
glVertexAttribI4ubvEXT GLuint
v1 Ptr GLubyte
v2 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> Ptr GLubyte -> IO ())
-> GLuint -> Ptr GLubyte -> IO ()
dyn393 FunPtr (GLuint -> Ptr GLubyte -> IO ())
ptr_glVertexAttribI4ubvEXT GLuint
v1 Ptr GLubyte
v2

{-# NOINLINE ptr_glVertexAttribI4ubvEXT #-}
ptr_glVertexAttribI4ubvEXT :: FunPtr (GLuint -> Ptr GLubyte -> IO ())
ptr_glVertexAttribI4ubvEXT :: FunPtr (GLuint -> Ptr GLubyte -> IO ())
ptr_glVertexAttribI4ubvEXT = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ forall a. String -> IO (FunPtr a)
getCommand String
"glVertexAttribI4ubvEXT"

-- glVertexAttribI4ui ----------------------------------------------------------

-- | Manual pages for <https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib.xml OpenGL 3.x> or <https://www.opengl.org/sdk/docs/man4/html/glVertexAttrib.xhtml OpenGL 4.x>. The vector equivalent of this command is 'glVertexAttribI4uiv'.
glVertexAttribI4ui
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> GLuint -- ^ @x@.
  -> GLuint -- ^ @y@.
  -> GLuint -- ^ @z@.
  -> GLuint -- ^ @w@.
  -> m ()
glVertexAttribI4ui :: forall (m :: * -> *).
MonadIO m =>
GLuint -> GLuint -> GLuint -> GLuint -> GLuint -> m ()
glVertexAttribI4ui GLuint
v1 GLuint
v2 GLuint
v3 GLuint
v4 GLuint
v5 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> GLuint -> GLuint -> GLuint -> GLuint -> IO ())
-> GLuint -> GLuint -> GLuint -> GLuint -> GLuint -> IO ()
dyn913 FunPtr (GLuint -> GLuint -> GLuint -> GLuint -> GLuint -> IO ())
ptr_glVertexAttribI4ui GLuint
v1 GLuint
v2 GLuint
v3 GLuint
v4 GLuint
v5

{-# NOINLINE ptr_glVertexAttribI4ui #-}
ptr_glVertexAttribI4ui :: FunPtr (GLuint -> GLuint -> GLuint -> GLuint -> GLuint -> IO ())
ptr_glVertexAttribI4ui :: FunPtr (GLuint -> GLuint -> GLuint -> GLuint -> GLuint -> IO ())
ptr_glVertexAttribI4ui = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ forall a. String -> IO (FunPtr a)
getCommand String
"glVertexAttribI4ui"

-- glVertexAttribI4uiEXT -------------------------------------------------------

-- | The vector equivalent of this command is 'glVertexAttribI4uivEXT'. This command is an alias for 'glVertexAttribI4ui'.
glVertexAttribI4uiEXT
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> GLuint -- ^ @x@.
  -> GLuint -- ^ @y@.
  -> GLuint -- ^ @z@.
  -> GLuint -- ^ @w@.
  -> m ()
glVertexAttribI4uiEXT :: forall (m :: * -> *).
MonadIO m =>
GLuint -> GLuint -> GLuint -> GLuint -> GLuint -> m ()
glVertexAttribI4uiEXT GLuint
v1 GLuint
v2 GLuint
v3 GLuint
v4 GLuint
v5 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> GLuint -> GLuint -> GLuint -> GLuint -> IO ())
-> GLuint -> GLuint -> GLuint -> GLuint -> GLuint -> IO ()
dyn913 FunPtr (GLuint -> GLuint -> GLuint -> GLuint -> GLuint -> IO ())
ptr_glVertexAttribI4uiEXT GLuint
v1 GLuint
v2 GLuint
v3 GLuint
v4 GLuint
v5

{-# NOINLINE ptr_glVertexAttribI4uiEXT #-}
ptr_glVertexAttribI4uiEXT :: FunPtr (GLuint -> GLuint -> GLuint -> GLuint -> GLuint -> IO ())
ptr_glVertexAttribI4uiEXT :: FunPtr (GLuint -> GLuint -> GLuint -> GLuint -> GLuint -> IO ())
ptr_glVertexAttribI4uiEXT = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ forall a. String -> IO (FunPtr a)
getCommand String
"glVertexAttribI4uiEXT"

-- glVertexAttribI4uiv ---------------------------------------------------------

-- | Manual pages for <https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib.xml OpenGL 3.x> or <https://www.opengl.org/sdk/docs/man4/html/glVertexAttrib.xhtml OpenGL 4.x>.
glVertexAttribI4uiv
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> Ptr GLuint -- ^ @v@ pointing to @4@ elements of type @GLuint@.
  -> m ()
glVertexAttribI4uiv :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLuint -> m ()
glVertexAttribI4uiv GLuint
v1 Ptr GLuint
v2 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> Ptr GLuint -> IO ())
-> GLuint -> Ptr GLuint -> IO ()
dyn201 FunPtr (GLuint -> Ptr GLuint -> IO ())
ptr_glVertexAttribI4uiv GLuint
v1 Ptr GLuint
v2

{-# NOINLINE ptr_glVertexAttribI4uiv #-}
ptr_glVertexAttribI4uiv :: FunPtr (GLuint -> Ptr GLuint -> IO ())
ptr_glVertexAttribI4uiv :: FunPtr (GLuint -> Ptr GLuint -> IO ())
ptr_glVertexAttribI4uiv = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ forall a. String -> IO (FunPtr a)
getCommand String
"glVertexAttribI4uiv"

-- glVertexAttribI4uivEXT ------------------------------------------------------

-- | This command is an alias for 'glVertexAttribI4uiv'.
glVertexAttribI4uivEXT
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> Ptr GLuint -- ^ @v@ pointing to @4@ elements of type @GLuint@.
  -> m ()
glVertexAttribI4uivEXT :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLuint -> m ()
glVertexAttribI4uivEXT GLuint
v1 Ptr GLuint
v2 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> Ptr GLuint -> IO ())
-> GLuint -> Ptr GLuint -> IO ()
dyn201 FunPtr (GLuint -> Ptr GLuint -> IO ())
ptr_glVertexAttribI4uivEXT GLuint
v1 Ptr GLuint
v2

{-# NOINLINE ptr_glVertexAttribI4uivEXT #-}
ptr_glVertexAttribI4uivEXT :: FunPtr (GLuint -> Ptr GLuint -> IO ())
ptr_glVertexAttribI4uivEXT :: FunPtr (GLuint -> Ptr GLuint -> IO ())
ptr_glVertexAttribI4uivEXT = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ forall a. String -> IO (FunPtr a)
getCommand String
"glVertexAttribI4uivEXT"

-- glVertexAttribI4usv ---------------------------------------------------------

-- | Manual pages for <https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib.xml OpenGL 3.x> or <https://www.opengl.org/sdk/docs/man4/html/glVertexAttrib.xhtml OpenGL 4.x>.
glVertexAttribI4usv
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> Ptr GLushort -- ^ @v@ pointing to @4@ elements of type @GLushort@.
  -> m ()
glVertexAttribI4usv :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLushort -> m ()
glVertexAttribI4usv GLuint
v1 Ptr GLushort
v2 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> Ptr GLushort -> IO ())
-> GLuint -> Ptr GLushort -> IO ()
dyn884 FunPtr (GLuint -> Ptr GLushort -> IO ())
ptr_glVertexAttribI4usv GLuint
v1 Ptr GLushort
v2

{-# NOINLINE ptr_glVertexAttribI4usv #-}
ptr_glVertexAttribI4usv :: FunPtr (GLuint -> Ptr GLushort -> IO ())
ptr_glVertexAttribI4usv :: FunPtr (GLuint -> Ptr GLushort -> IO ())
ptr_glVertexAttribI4usv = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ forall a. String -> IO (FunPtr a)
getCommand String
"glVertexAttribI4usv"

-- glVertexAttribI4usvEXT ------------------------------------------------------

-- | This command is an alias for 'glVertexAttribI4usv'.
glVertexAttribI4usvEXT
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> Ptr GLushort -- ^ @v@ pointing to @4@ elements of type @GLushort@.
  -> m ()
glVertexAttribI4usvEXT :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLushort -> m ()
glVertexAttribI4usvEXT GLuint
v1 Ptr GLushort
v2 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> Ptr GLushort -> IO ())
-> GLuint -> Ptr GLushort -> IO ()
dyn884 FunPtr (GLuint -> Ptr GLushort -> IO ())
ptr_glVertexAttribI4usvEXT GLuint
v1 Ptr GLushort
v2

{-# NOINLINE ptr_glVertexAttribI4usvEXT #-}
ptr_glVertexAttribI4usvEXT :: FunPtr (GLuint -> Ptr GLushort -> IO ())
ptr_glVertexAttribI4usvEXT :: FunPtr (GLuint -> Ptr GLushort -> IO ())
ptr_glVertexAttribI4usvEXT = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ forall a. String -> IO (FunPtr a)
getCommand String
"glVertexAttribI4usvEXT"

-- glVertexAttribIFormat -------------------------------------------------------

-- | Manual page for <https://www.opengl.org/sdk/docs/man4/html/glVertexAttribFormat.xhtml OpenGL 4.x>.
glVertexAttribIFormat
  :: MonadIO m
  => GLuint -- ^ @attribindex@.
  -> GLint -- ^ @size@.
  -> GLenum -- ^ @type@ of type [VertexAttribIType](Graphics-GL-Groups.html#VertexAttribIType).
  -> GLuint -- ^ @relativeoffset@.
  -> m ()
glVertexAttribIFormat :: forall (m :: * -> *).
MonadIO m =>
GLuint -> GLint -> GLuint -> GLuint -> m ()
glVertexAttribIFormat GLuint
v1 GLint
v2 GLuint
v3 GLuint
v4 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> GLint -> GLuint -> GLuint -> IO ())
-> GLuint -> GLint -> GLuint -> GLuint -> IO ()
dyn914 FunPtr (GLuint -> GLint -> GLuint -> GLuint -> IO ())
ptr_glVertexAttribIFormat GLuint
v1 GLint
v2 GLuint
v3 GLuint
v4

{-# NOINLINE ptr_glVertexAttribIFormat #-}
ptr_glVertexAttribIFormat :: FunPtr (GLuint -> GLint -> GLenum -> GLuint -> IO ())
ptr_glVertexAttribIFormat :: FunPtr (GLuint -> GLint -> GLuint -> GLuint -> IO ())
ptr_glVertexAttribIFormat = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ forall a. String -> IO (FunPtr a)
getCommand String
"glVertexAttribIFormat"

-- glVertexAttribIFormatNV -----------------------------------------------------

glVertexAttribIFormatNV
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> GLint -- ^ @size@.
  -> GLenum -- ^ @type@ of type [VertexAttribIType](Graphics-GL-Groups.html#VertexAttribIType).
  -> GLsizei -- ^ @stride@.
  -> m ()
glVertexAttribIFormatNV :: forall (m :: * -> *).
MonadIO m =>
GLuint -> GLint -> GLuint -> GLint -> m ()
glVertexAttribIFormatNV GLuint
v1 GLint
v2 GLuint
v3 GLint
v4 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> GLint -> GLuint -> GLint -> IO ())
-> GLuint -> GLint -> GLuint -> GLint -> IO ()
dyn915 FunPtr (GLuint -> GLint -> GLuint -> GLint -> IO ())
ptr_glVertexAttribIFormatNV GLuint
v1 GLint
v2 GLuint
v3 GLint
v4

{-# NOINLINE ptr_glVertexAttribIFormatNV #-}
ptr_glVertexAttribIFormatNV :: FunPtr (GLuint -> GLint -> GLenum -> GLsizei -> IO ())
ptr_glVertexAttribIFormatNV :: FunPtr (GLuint -> GLint -> GLuint -> GLint -> IO ())
ptr_glVertexAttribIFormatNV = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ forall a. String -> IO (FunPtr a)
getCommand String
"glVertexAttribIFormatNV"

-- glVertexAttribIPointer ------------------------------------------------------

-- | Manual pages for <https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttribPointer.xml OpenGL 3.x> or <https://www.opengl.org/sdk/docs/man4/html/glVertexAttribPointer.xhtml OpenGL 4.x>.
glVertexAttribIPointer
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> GLint -- ^ @size@.
  -> GLenum -- ^ @type@ of type [VertexAttribPointerType](Graphics-GL-Groups.html#VertexAttribPointerType).
  -> GLsizei -- ^ @stride@.
  -> Ptr a -- ^ @pointer@ pointing to @COMPSIZE(size,type,stride)@ elements of type @a@.
  -> m ()
glVertexAttribIPointer :: forall (m :: * -> *) a.
MonadIO m =>
GLuint -> GLint -> GLuint -> GLint -> Ptr a -> m ()
glVertexAttribIPointer GLuint
v1 GLint
v2 GLuint
v3 GLint
v4 Ptr a
v5 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a.
FunPtr (GLuint -> GLint -> GLuint -> GLint -> Ptr a -> IO ())
-> GLuint -> GLint -> GLuint -> GLint -> Ptr a -> IO ()
dyn916 forall a.
FunPtr (GLuint -> GLint -> GLuint -> GLint -> Ptr a -> IO ())
ptr_glVertexAttribIPointer GLuint
v1 GLint
v2 GLuint
v3 GLint
v4 Ptr a
v5

{-# NOINLINE ptr_glVertexAttribIPointer #-}
ptr_glVertexAttribIPointer :: FunPtr (GLuint -> GLint -> GLenum -> GLsizei -> Ptr a -> IO ())
ptr_glVertexAttribIPointer :: forall a.
FunPtr (GLuint -> GLint -> GLuint -> GLint -> Ptr a -> IO ())
ptr_glVertexAttribIPointer = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ forall a. String -> IO (FunPtr a)
getCommand String
"glVertexAttribIPointer"

-- glVertexAttribIPointerEXT ---------------------------------------------------

-- | This command is an alias for 'glVertexAttribIPointer'.
glVertexAttribIPointerEXT
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> GLint -- ^ @size@.
  -> GLenum -- ^ @type@ of type [VertexAttribPointerType](Graphics-GL-Groups.html#VertexAttribPointerType).
  -> GLsizei -- ^ @stride@.
  -> Ptr a -- ^ @pointer@ pointing to @COMPSIZE(size,type,stride)@ elements of type @a@.
  -> m ()
glVertexAttribIPointerEXT :: forall (m :: * -> *) a.
MonadIO m =>
GLuint -> GLint -> GLuint -> GLint -> Ptr a -> m ()
glVertexAttribIPointerEXT GLuint
v1 GLint
v2 GLuint
v3 GLint
v4 Ptr a
v5 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a.
FunPtr (GLuint -> GLint -> GLuint -> GLint -> Ptr a -> IO ())
-> GLuint -> GLint -> GLuint -> GLint -> Ptr a -> IO ()
dyn916 forall a.
FunPtr (GLuint -> GLint -> GLuint -> GLint -> Ptr a -> IO ())
ptr_glVertexAttribIPointerEXT GLuint
v1 GLint
v2 GLuint
v3 GLint
v4 Ptr a
v5

{-# NOINLINE ptr_glVertexAttribIPointerEXT #-}
ptr_glVertexAttribIPointerEXT :: FunPtr (GLuint -> GLint -> GLenum -> GLsizei -> Ptr a -> IO ())
ptr_glVertexAttribIPointerEXT :: forall a.
FunPtr (GLuint -> GLint -> GLuint -> GLint -> Ptr a -> IO ())
ptr_glVertexAttribIPointerEXT = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ forall a. String -> IO (FunPtr a)
getCommand String
"glVertexAttribIPointerEXT"

-- glVertexAttribL1d -----------------------------------------------------------

-- | Manual page for <https://www.opengl.org/sdk/docs/man4/html/glVertexAttrib.xhtml OpenGL 4.x>.
glVertexAttribL1d
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> GLdouble -- ^ @x@.
  -> m ()
glVertexAttribL1d :: forall (m :: * -> *). MonadIO m => GLuint -> GLdouble -> m ()
glVertexAttribL1d GLuint
v1 GLdouble
v2 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> GLdouble -> IO ()) -> GLuint -> GLdouble -> IO ()
dyn895 FunPtr (GLuint -> GLdouble -> IO ())
ptr_glVertexAttribL1d GLuint
v1 GLdouble
v2

{-# NOINLINE ptr_glVertexAttribL1d #-}
ptr_glVertexAttribL1d :: FunPtr (GLuint -> GLdouble -> IO ())
ptr_glVertexAttribL1d :: FunPtr (GLuint -> GLdouble -> IO ())
ptr_glVertexAttribL1d = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ forall a. String -> IO (FunPtr a)
getCommand String
"glVertexAttribL1d"

-- glVertexAttribL1dEXT --------------------------------------------------------

-- | This command is an alias for 'glVertexAttribL1d'.
glVertexAttribL1dEXT
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> GLdouble -- ^ @x@.
  -> m ()
glVertexAttribL1dEXT :: forall (m :: * -> *). MonadIO m => GLuint -> GLdouble -> m ()
glVertexAttribL1dEXT GLuint
v1 GLdouble
v2 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> GLdouble -> IO ()) -> GLuint -> GLdouble -> IO ()
dyn895 FunPtr (GLuint -> GLdouble -> IO ())
ptr_glVertexAttribL1dEXT GLuint
v1 GLdouble
v2

{-# NOINLINE ptr_glVertexAttribL1dEXT #-}
ptr_glVertexAttribL1dEXT :: FunPtr (GLuint -> GLdouble -> IO ())
ptr_glVertexAttribL1dEXT :: FunPtr (GLuint -> GLdouble -> IO ())
ptr_glVertexAttribL1dEXT = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ forall a. String -> IO (FunPtr a)
getCommand String
"glVertexAttribL1dEXT"

-- glVertexAttribL1dv ----------------------------------------------------------

-- | Manual page for <https://www.opengl.org/sdk/docs/man4/html/glVertexAttrib.xhtml OpenGL 4.x>.
glVertexAttribL1dv
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> Ptr GLdouble -- ^ @v@ pointing to @1@ element of type @GLdouble@.
  -> m ()
glVertexAttribL1dv :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLdouble -> m ()
glVertexAttribL1dv GLuint
v1 Ptr GLdouble
v2 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> Ptr GLdouble -> IO ())
-> GLuint -> Ptr GLdouble -> IO ()
dyn882 FunPtr (GLuint -> Ptr GLdouble -> IO ())
ptr_glVertexAttribL1dv GLuint
v1 Ptr GLdouble
v2

{-# NOINLINE ptr_glVertexAttribL1dv #-}
ptr_glVertexAttribL1dv :: FunPtr (GLuint -> Ptr GLdouble -> IO ())
ptr_glVertexAttribL1dv :: FunPtr (GLuint -> Ptr GLdouble -> IO ())
ptr_glVertexAttribL1dv = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ forall a. String -> IO (FunPtr a)
getCommand String
"glVertexAttribL1dv"

-- glVertexAttribL1dvEXT -------------------------------------------------------

-- | This command is an alias for 'glVertexAttribL1dv'.
glVertexAttribL1dvEXT
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> Ptr GLdouble -- ^ @v@ pointing to @1@ element of type @GLdouble@.
  -> m ()
glVertexAttribL1dvEXT :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLdouble -> m ()
glVertexAttribL1dvEXT GLuint
v1 Ptr GLdouble
v2 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> Ptr GLdouble -> IO ())
-> GLuint -> Ptr GLdouble -> IO ()
dyn882 FunPtr (GLuint -> Ptr GLdouble -> IO ())
ptr_glVertexAttribL1dvEXT GLuint
v1 Ptr GLdouble
v2

{-# NOINLINE ptr_glVertexAttribL1dvEXT #-}
ptr_glVertexAttribL1dvEXT :: FunPtr (GLuint -> Ptr GLdouble -> IO ())
ptr_glVertexAttribL1dvEXT :: FunPtr (GLuint -> Ptr GLdouble -> IO ())
ptr_glVertexAttribL1dvEXT = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ forall a. String -> IO (FunPtr a)
getCommand String
"glVertexAttribL1dvEXT"

-- glVertexAttribL1i64NV -------------------------------------------------------

glVertexAttribL1i64NV
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> GLint64EXT -- ^ @x@.
  -> m ()
glVertexAttribL1i64NV :: forall (m :: * -> *). MonadIO m => GLuint -> GLint64EXT -> m ()
glVertexAttribL1i64NV GLuint
v1 GLint64EXT
v2 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> GLint64EXT -> IO ())
-> GLuint -> GLint64EXT -> IO ()
dyn917 FunPtr (GLuint -> GLint64EXT -> IO ())
ptr_glVertexAttribL1i64NV GLuint
v1 GLint64EXT
v2

{-# NOINLINE ptr_glVertexAttribL1i64NV #-}
ptr_glVertexAttribL1i64NV :: FunPtr (GLuint -> GLint64EXT -> IO ())
ptr_glVertexAttribL1i64NV :: FunPtr (GLuint -> GLint64EXT -> IO ())
ptr_glVertexAttribL1i64NV = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ forall a. String -> IO (FunPtr a)
getCommand String
"glVertexAttribL1i64NV"

-- glVertexAttribL1i64vNV ------------------------------------------------------

glVertexAttribL1i64vNV
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> Ptr GLint64EXT -- ^ @v@ pointing to @1@ element of type @GLint64EXT@.
  -> m ()
glVertexAttribL1i64vNV :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLint64EXT -> m ()
glVertexAttribL1i64vNV GLuint
v1 Ptr GLint64EXT
v2 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> Ptr GLint64EXT -> IO ())
-> GLuint -> Ptr GLint64EXT -> IO ()
dyn918 FunPtr (GLuint -> Ptr GLint64EXT -> IO ())
ptr_glVertexAttribL1i64vNV GLuint
v1 Ptr GLint64EXT
v2

{-# NOINLINE ptr_glVertexAttribL1i64vNV #-}
ptr_glVertexAttribL1i64vNV :: FunPtr (GLuint -> Ptr GLint64EXT -> IO ())
ptr_glVertexAttribL1i64vNV :: FunPtr (GLuint -> Ptr GLint64EXT -> IO ())
ptr_glVertexAttribL1i64vNV = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ forall a. String -> IO (FunPtr a)
getCommand String
"glVertexAttribL1i64vNV"

-- glVertexAttribL1ui64ARB -----------------------------------------------------

glVertexAttribL1ui64ARB
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> GLuint64EXT -- ^ @x@.
  -> m ()
glVertexAttribL1ui64ARB :: forall (m :: * -> *). MonadIO m => GLuint -> GLuint64EXT -> m ()
glVertexAttribL1ui64ARB GLuint
v1 GLuint64EXT
v2 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> GLuint64EXT -> IO ())
-> GLuint -> GLuint64EXT -> IO ()
dyn919 FunPtr (GLuint -> GLuint64EXT -> IO ())
ptr_glVertexAttribL1ui64ARB GLuint
v1 GLuint64EXT
v2

{-# NOINLINE ptr_glVertexAttribL1ui64ARB #-}
ptr_glVertexAttribL1ui64ARB :: FunPtr (GLuint -> GLuint64EXT -> IO ())
ptr_glVertexAttribL1ui64ARB :: FunPtr (GLuint -> GLuint64EXT -> IO ())
ptr_glVertexAttribL1ui64ARB = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ forall a. String -> IO (FunPtr a)
getCommand String
"glVertexAttribL1ui64ARB"

-- glVertexAttribL1ui64NV ------------------------------------------------------

glVertexAttribL1ui64NV
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> GLuint64EXT -- ^ @x@.
  -> m ()
glVertexAttribL1ui64NV :: forall (m :: * -> *). MonadIO m => GLuint -> GLuint64EXT -> m ()
glVertexAttribL1ui64NV GLuint
v1 GLuint64EXT
v2 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> GLuint64EXT -> IO ())
-> GLuint -> GLuint64EXT -> IO ()
dyn919 FunPtr (GLuint -> GLuint64EXT -> IO ())
ptr_glVertexAttribL1ui64NV GLuint
v1 GLuint64EXT
v2

{-# NOINLINE ptr_glVertexAttribL1ui64NV #-}
ptr_glVertexAttribL1ui64NV :: FunPtr (GLuint -> GLuint64EXT -> IO ())
ptr_glVertexAttribL1ui64NV :: FunPtr (GLuint -> GLuint64EXT -> IO ())
ptr_glVertexAttribL1ui64NV = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ forall a. String -> IO (FunPtr a)
getCommand String
"glVertexAttribL1ui64NV"

-- glVertexAttribL1ui64vARB ----------------------------------------------------

glVertexAttribL1ui64vARB
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> Ptr GLuint64EXT -- ^ @v@.
  -> m ()
glVertexAttribL1ui64vARB :: forall (m :: * -> *).
MonadIO m =>
GLuint -> Ptr GLuint64EXT -> m ()
glVertexAttribL1ui64vARB GLuint
v1 Ptr GLuint64EXT
v2 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> Ptr GLuint64EXT -> IO ())
-> GLuint -> Ptr GLuint64EXT -> IO ()
dyn920 FunPtr (GLuint -> Ptr GLuint64EXT -> IO ())
ptr_glVertexAttribL1ui64vARB GLuint
v1 Ptr GLuint64EXT
v2

{-# NOINLINE ptr_glVertexAttribL1ui64vARB #-}
ptr_glVertexAttribL1ui64vARB :: FunPtr (GLuint -> Ptr GLuint64EXT -> IO ())
ptr_glVertexAttribL1ui64vARB :: FunPtr (GLuint -> Ptr GLuint64EXT -> IO ())
ptr_glVertexAttribL1ui64vARB = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ forall a. String -> IO (FunPtr a)
getCommand String
"glVertexAttribL1ui64vARB"

-- glVertexAttribL1ui64vNV -----------------------------------------------------

glVertexAttribL1ui64vNV
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> Ptr GLuint64EXT -- ^ @v@ pointing to @1@ element of type @GLuint64EXT@.
  -> m ()
glVertexAttribL1ui64vNV :: forall (m :: * -> *).
MonadIO m =>
GLuint -> Ptr GLuint64EXT -> m ()
glVertexAttribL1ui64vNV GLuint
v1 Ptr GLuint64EXT
v2 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> Ptr GLuint64EXT -> IO ())
-> GLuint -> Ptr GLuint64EXT -> IO ()
dyn920 FunPtr (GLuint -> Ptr GLuint64EXT -> IO ())
ptr_glVertexAttribL1ui64vNV GLuint
v1 Ptr GLuint64EXT
v2

{-# NOINLINE ptr_glVertexAttribL1ui64vNV #-}
ptr_glVertexAttribL1ui64vNV :: FunPtr (GLuint -> Ptr GLuint64EXT -> IO ())
ptr_glVertexAttribL1ui64vNV :: FunPtr (GLuint -> Ptr GLuint64EXT -> IO ())
ptr_glVertexAttribL1ui64vNV = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ forall a. String -> IO (FunPtr a)
getCommand String
"glVertexAttribL1ui64vNV"

-- glVertexAttribL2d -----------------------------------------------------------

-- | Manual page for <https://www.opengl.org/sdk/docs/man4/html/glVertexAttrib.xhtml OpenGL 4.x>.
glVertexAttribL2d
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> GLdouble -- ^ @x@.
  -> GLdouble -- ^ @y@.
  -> m ()
glVertexAttribL2d :: forall (m :: * -> *).
MonadIO m =>
GLuint -> GLdouble -> GLdouble -> m ()
glVertexAttribL2d GLuint
v1 GLdouble
v2 GLdouble
v3 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> GLdouble -> GLdouble -> IO ())
-> GLuint -> GLdouble -> GLdouble -> IO ()
dyn228 FunPtr (GLuint -> GLdouble -> GLdouble -> IO ())
ptr_glVertexAttribL2d GLuint
v1 GLdouble
v2 GLdouble
v3

{-# NOINLINE ptr_glVertexAttribL2d #-}
ptr_glVertexAttribL2d :: FunPtr (GLuint -> GLdouble -> GLdouble -> IO ())
ptr_glVertexAttribL2d :: FunPtr (GLuint -> GLdouble -> GLdouble -> IO ())
ptr_glVertexAttribL2d = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ forall a. String -> IO (FunPtr a)
getCommand String
"glVertexAttribL2d"

-- glVertexAttribL2dEXT --------------------------------------------------------

-- | This command is an alias for 'glVertexAttribL2d'.
glVertexAttribL2dEXT
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> GLdouble -- ^ @x@.
  -> GLdouble -- ^ @y@.
  -> m ()
glVertexAttribL2dEXT :: forall (m :: * -> *).
MonadIO m =>
GLuint -> GLdouble -> GLdouble -> m ()
glVertexAttribL2dEXT GLuint
v1 GLdouble
v2 GLdouble
v3 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> GLdouble -> GLdouble -> IO ())
-> GLuint -> GLdouble -> GLdouble -> IO ()
dyn228 FunPtr (GLuint -> GLdouble -> GLdouble -> IO ())
ptr_glVertexAttribL2dEXT GLuint
v1 GLdouble
v2 GLdouble
v3

{-# NOINLINE ptr_glVertexAttribL2dEXT #-}
ptr_glVertexAttribL2dEXT :: FunPtr (GLuint -> GLdouble -> GLdouble -> IO ())
ptr_glVertexAttribL2dEXT :: FunPtr (GLuint -> GLdouble -> GLdouble -> IO ())
ptr_glVertexAttribL2dEXT = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ forall a. String -> IO (FunPtr a)
getCommand String
"glVertexAttribL2dEXT"

-- glVertexAttribL2dv ----------------------------------------------------------

-- | Manual page for <https://www.opengl.org/sdk/docs/man4/html/glVertexAttrib.xhtml OpenGL 4.x>.
glVertexAttribL2dv
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> Ptr GLdouble -- ^ @v@ pointing to @2@ elements of type @GLdouble@.
  -> m ()
glVertexAttribL2dv :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLdouble -> m ()
glVertexAttribL2dv GLuint
v1 Ptr GLdouble
v2 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> Ptr GLdouble -> IO ())
-> GLuint -> Ptr GLdouble -> IO ()
dyn882 FunPtr (GLuint -> Ptr GLdouble -> IO ())
ptr_glVertexAttribL2dv GLuint
v1 Ptr GLdouble
v2

{-# NOINLINE ptr_glVertexAttribL2dv #-}
ptr_glVertexAttribL2dv :: FunPtr (GLuint -> Ptr GLdouble -> IO ())
ptr_glVertexAttribL2dv :: FunPtr (GLuint -> Ptr GLdouble -> IO ())
ptr_glVertexAttribL2dv = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ forall a. String -> IO (FunPtr a)
getCommand String
"glVertexAttribL2dv"

-- glVertexAttribL2dvEXT -------------------------------------------------------

-- | This command is an alias for 'glVertexAttribL2dv'.
glVertexAttribL2dvEXT
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> Ptr GLdouble -- ^ @v@ pointing to @2@ elements of type @GLdouble@.
  -> m ()
glVertexAttribL2dvEXT :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLdouble -> m ()
glVertexAttribL2dvEXT GLuint
v1 Ptr GLdouble
v2 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> Ptr GLdouble -> IO ())
-> GLuint -> Ptr GLdouble -> IO ()
dyn882 FunPtr (GLuint -> Ptr GLdouble -> IO ())
ptr_glVertexAttribL2dvEXT GLuint
v1 Ptr GLdouble
v2

{-# NOINLINE ptr_glVertexAttribL2dvEXT #-}
ptr_glVertexAttribL2dvEXT :: FunPtr (GLuint -> Ptr GLdouble -> IO ())
ptr_glVertexAttribL2dvEXT :: FunPtr (GLuint -> Ptr GLdouble -> IO ())
ptr_glVertexAttribL2dvEXT = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ forall a. String -> IO (FunPtr a)
getCommand String
"glVertexAttribL2dvEXT"

-- glVertexAttribL2i64NV -------------------------------------------------------

glVertexAttribL2i64NV
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> GLint64EXT -- ^ @x@.
  -> GLint64EXT -- ^ @y@.
  -> m ()
glVertexAttribL2i64NV :: forall (m :: * -> *).
MonadIO m =>
GLuint -> GLint64EXT -> GLint64EXT -> m ()
glVertexAttribL2i64NV GLuint
v1 GLint64EXT
v2 GLint64EXT
v3 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> GLint64EXT -> GLint64EXT -> IO ())
-> GLuint -> GLint64EXT -> GLint64EXT -> IO ()
dyn921 FunPtr (GLuint -> GLint64EXT -> GLint64EXT -> IO ())
ptr_glVertexAttribL2i64NV GLuint
v1 GLint64EXT
v2 GLint64EXT
v3

{-# NOINLINE ptr_glVertexAttribL2i64NV #-}
ptr_glVertexAttribL2i64NV :: FunPtr (GLuint -> GLint64EXT -> GLint64EXT -> IO ())
ptr_glVertexAttribL2i64NV :: FunPtr (GLuint -> GLint64EXT -> GLint64EXT -> IO ())
ptr_glVertexAttribL2i64NV = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ forall a. String -> IO (FunPtr a)
getCommand String
"glVertexAttribL2i64NV"

-- glVertexAttribL2i64vNV ------------------------------------------------------

glVertexAttribL2i64vNV
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> Ptr GLint64EXT -- ^ @v@ pointing to @2@ elements of type @GLint64EXT@.
  -> m ()
glVertexAttribL2i64vNV :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLint64EXT -> m ()
glVertexAttribL2i64vNV GLuint
v1 Ptr GLint64EXT
v2 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> Ptr GLint64EXT -> IO ())
-> GLuint -> Ptr GLint64EXT -> IO ()
dyn918 FunPtr (GLuint -> Ptr GLint64EXT -> IO ())
ptr_glVertexAttribL2i64vNV GLuint
v1 Ptr GLint64EXT
v2

{-# NOINLINE ptr_glVertexAttribL2i64vNV #-}
ptr_glVertexAttribL2i64vNV :: FunPtr (GLuint -> Ptr GLint64EXT -> IO ())
ptr_glVertexAttribL2i64vNV :: FunPtr (GLuint -> Ptr GLint64EXT -> IO ())
ptr_glVertexAttribL2i64vNV = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ forall a. String -> IO (FunPtr a)
getCommand String
"glVertexAttribL2i64vNV"

-- glVertexAttribL2ui64NV ------------------------------------------------------

glVertexAttribL2ui64NV
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> GLuint64EXT -- ^ @x@.
  -> GLuint64EXT -- ^ @y@.
  -> m ()
glVertexAttribL2ui64NV :: forall (m :: * -> *).
MonadIO m =>
GLuint -> GLuint64EXT -> GLuint64EXT -> m ()
glVertexAttribL2ui64NV GLuint
v1 GLuint64EXT
v2 GLuint64EXT
v3 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> GLuint64EXT -> GLuint64EXT -> IO ())
-> GLuint -> GLuint64EXT -> GLuint64EXT -> IO ()
dyn922 FunPtr (GLuint -> GLuint64EXT -> GLuint64EXT -> IO ())
ptr_glVertexAttribL2ui64NV GLuint
v1 GLuint64EXT
v2 GLuint64EXT
v3

{-# NOINLINE ptr_glVertexAttribL2ui64NV #-}
ptr_glVertexAttribL2ui64NV :: FunPtr (GLuint -> GLuint64EXT -> GLuint64EXT -> IO ())
ptr_glVertexAttribL2ui64NV :: FunPtr (GLuint -> GLuint64EXT -> GLuint64EXT -> IO ())
ptr_glVertexAttribL2ui64NV = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ forall a. String -> IO (FunPtr a)
getCommand String
"glVertexAttribL2ui64NV"

-- glVertexAttribL2ui64vNV -----------------------------------------------------

glVertexAttribL2ui64vNV
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> Ptr GLuint64EXT -- ^ @v@ pointing to @2@ elements of type @GLuint64EXT@.
  -> m ()
glVertexAttribL2ui64vNV :: forall (m :: * -> *).
MonadIO m =>
GLuint -> Ptr GLuint64EXT -> m ()
glVertexAttribL2ui64vNV GLuint
v1 Ptr GLuint64EXT
v2 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> Ptr GLuint64EXT -> IO ())
-> GLuint -> Ptr GLuint64EXT -> IO ()
dyn920 FunPtr (GLuint -> Ptr GLuint64EXT -> IO ())
ptr_glVertexAttribL2ui64vNV GLuint
v1 Ptr GLuint64EXT
v2

{-# NOINLINE ptr_glVertexAttribL2ui64vNV #-}
ptr_glVertexAttribL2ui64vNV :: FunPtr (GLuint -> Ptr GLuint64EXT -> IO ())
ptr_glVertexAttribL2ui64vNV :: FunPtr (GLuint -> Ptr GLuint64EXT -> IO ())
ptr_glVertexAttribL2ui64vNV = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ forall a. String -> IO (FunPtr a)
getCommand String
"glVertexAttribL2ui64vNV"

-- glVertexAttribL3d -----------------------------------------------------------

-- | Manual page for <https://www.opengl.org/sdk/docs/man4/html/glVertexAttrib.xhtml OpenGL 4.x>.
glVertexAttribL3d
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> GLdouble -- ^ @x@.
  -> GLdouble -- ^ @y@.
  -> GLdouble -- ^ @z@.
  -> m ()
glVertexAttribL3d :: forall (m :: * -> *).
MonadIO m =>
GLuint -> GLdouble -> GLdouble -> GLdouble -> m ()
glVertexAttribL3d GLuint
v1 GLdouble
v2 GLdouble
v3 GLdouble
v4 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> GLdouble -> GLdouble -> GLdouble -> IO ())
-> GLuint -> GLdouble -> GLdouble -> GLdouble -> IO ()
dyn902 FunPtr (GLuint -> GLdouble -> GLdouble -> GLdouble -> IO ())
ptr_glVertexAttribL3d GLuint
v1 GLdouble
v2 GLdouble
v3 GLdouble
v4

{-# NOINLINE ptr_glVertexAttribL3d #-}
ptr_glVertexAttribL3d :: FunPtr (GLuint -> GLdouble -> GLdouble -> GLdouble -> IO ())
ptr_glVertexAttribL3d :: FunPtr (GLuint -> GLdouble -> GLdouble -> GLdouble -> IO ())
ptr_glVertexAttribL3d = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ forall a. String -> IO (FunPtr a)
getCommand String
"glVertexAttribL3d"

-- glVertexAttribL3dEXT --------------------------------------------------------

-- | This command is an alias for 'glVertexAttribL3d'.
glVertexAttribL3dEXT
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> GLdouble -- ^ @x@.
  -> GLdouble -- ^ @y@.
  -> GLdouble -- ^ @z@.
  -> m ()
glVertexAttribL3dEXT :: forall (m :: * -> *).
MonadIO m =>
GLuint -> GLdouble -> GLdouble -> GLdouble -> m ()
glVertexAttribL3dEXT GLuint
v1 GLdouble
v2 GLdouble
v3 GLdouble
v4 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> GLdouble -> GLdouble -> GLdouble -> IO ())
-> GLuint -> GLdouble -> GLdouble -> GLdouble -> IO ()
dyn902 FunPtr (GLuint -> GLdouble -> GLdouble -> GLdouble -> IO ())
ptr_glVertexAttribL3dEXT GLuint
v1 GLdouble
v2 GLdouble
v3 GLdouble
v4

{-# NOINLINE ptr_glVertexAttribL3dEXT #-}
ptr_glVertexAttribL3dEXT :: FunPtr (GLuint -> GLdouble -> GLdouble -> GLdouble -> IO ())
ptr_glVertexAttribL3dEXT :: FunPtr (GLuint -> GLdouble -> GLdouble -> GLdouble -> IO ())
ptr_glVertexAttribL3dEXT = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ forall a. String -> IO (FunPtr a)
getCommand String
"glVertexAttribL3dEXT"

-- glVertexAttribL3dv ----------------------------------------------------------

-- | Manual page for <https://www.opengl.org/sdk/docs/man4/html/glVertexAttrib.xhtml OpenGL 4.x>.
glVertexAttribL3dv
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> Ptr GLdouble -- ^ @v@ pointing to @3@ elements of type @GLdouble@.
  -> m ()
glVertexAttribL3dv :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLdouble -> m ()
glVertexAttribL3dv GLuint
v1 Ptr GLdouble
v2 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> Ptr GLdouble -> IO ())
-> GLuint -> Ptr GLdouble -> IO ()
dyn882 FunPtr (GLuint -> Ptr GLdouble -> IO ())
ptr_glVertexAttribL3dv GLuint
v1 Ptr GLdouble
v2

{-# NOINLINE ptr_glVertexAttribL3dv #-}
ptr_glVertexAttribL3dv :: FunPtr (GLuint -> Ptr GLdouble -> IO ())
ptr_glVertexAttribL3dv :: FunPtr (GLuint -> Ptr GLdouble -> IO ())
ptr_glVertexAttribL3dv = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ forall a. String -> IO (FunPtr a)
getCommand String
"glVertexAttribL3dv"

-- glVertexAttribL3dvEXT -------------------------------------------------------

-- | This command is an alias for 'glVertexAttribL3dv'.
glVertexAttribL3dvEXT
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> Ptr GLdouble -- ^ @v@ pointing to @3@ elements of type @GLdouble@.
  -> m ()
glVertexAttribL3dvEXT :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLdouble -> m ()
glVertexAttribL3dvEXT GLuint
v1 Ptr GLdouble
v2 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> Ptr GLdouble -> IO ())
-> GLuint -> Ptr GLdouble -> IO ()
dyn882 FunPtr (GLuint -> Ptr GLdouble -> IO ())
ptr_glVertexAttribL3dvEXT GLuint
v1 Ptr GLdouble
v2

{-# NOINLINE ptr_glVertexAttribL3dvEXT #-}
ptr_glVertexAttribL3dvEXT :: FunPtr (GLuint -> Ptr GLdouble -> IO ())
ptr_glVertexAttribL3dvEXT :: FunPtr (GLuint -> Ptr GLdouble -> IO ())
ptr_glVertexAttribL3dvEXT = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ forall a. String -> IO (FunPtr a)
getCommand String
"glVertexAttribL3dvEXT"

-- glVertexAttribL3i64NV -------------------------------------------------------

glVertexAttribL3i64NV
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> GLint64EXT -- ^ @x@.
  -> GLint64EXT -- ^ @y@.
  -> GLint64EXT -- ^ @z@.
  -> m ()
glVertexAttribL3i64NV :: forall (m :: * -> *).
MonadIO m =>
GLuint -> GLint64EXT -> GLint64EXT -> GLint64EXT -> m ()
glVertexAttribL3i64NV GLuint
v1 GLint64EXT
v2 GLint64EXT
v3 GLint64EXT
v4 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> GLint64EXT -> GLint64EXT -> GLint64EXT -> IO ())
-> GLuint -> GLint64EXT -> GLint64EXT -> GLint64EXT -> IO ()
dyn923 FunPtr (GLuint -> GLint64EXT -> GLint64EXT -> GLint64EXT -> IO ())
ptr_glVertexAttribL3i64NV GLuint
v1 GLint64EXT
v2 GLint64EXT
v3 GLint64EXT
v4

{-# NOINLINE ptr_glVertexAttribL3i64NV #-}
ptr_glVertexAttribL3i64NV :: FunPtr (GLuint -> GLint64EXT -> GLint64EXT -> GLint64EXT -> IO ())
ptr_glVertexAttribL3i64NV :: FunPtr (GLuint -> GLint64EXT -> GLint64EXT -> GLint64EXT -> IO ())
ptr_glVertexAttribL3i64NV = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ forall a. String -> IO (FunPtr a)
getCommand String
"glVertexAttribL3i64NV"

-- glVertexAttribL3i64vNV ------------------------------------------------------

glVertexAttribL3i64vNV
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> Ptr GLint64EXT -- ^ @v@ pointing to @3@ elements of type @GLint64EXT@.
  -> m ()
glVertexAttribL3i64vNV :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLint64EXT -> m ()
glVertexAttribL3i64vNV GLuint
v1 Ptr GLint64EXT
v2 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> Ptr GLint64EXT -> IO ())
-> GLuint -> Ptr GLint64EXT -> IO ()
dyn918 FunPtr (GLuint -> Ptr GLint64EXT -> IO ())
ptr_glVertexAttribL3i64vNV GLuint
v1 Ptr GLint64EXT
v2

{-# NOINLINE ptr_glVertexAttribL3i64vNV #-}
ptr_glVertexAttribL3i64vNV :: FunPtr (GLuint -> Ptr GLint64EXT -> IO ())
ptr_glVertexAttribL3i64vNV :: FunPtr (GLuint -> Ptr GLint64EXT -> IO ())
ptr_glVertexAttribL3i64vNV = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ forall a. String -> IO (FunPtr a)
getCommand String
"glVertexAttribL3i64vNV"

-- glVertexAttribL3ui64NV ------------------------------------------------------

glVertexAttribL3ui64NV
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> GLuint64EXT -- ^ @x@.
  -> GLuint64EXT -- ^ @y@.
  -> GLuint64EXT -- ^ @z@.
  -> m ()
glVertexAttribL3ui64NV :: forall (m :: * -> *).
MonadIO m =>
GLuint -> GLuint64EXT -> GLuint64EXT -> GLuint64EXT -> m ()
glVertexAttribL3ui64NV GLuint
v1 GLuint64EXT
v2 GLuint64EXT
v3 GLuint64EXT
v4 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ FunPtr
  (GLuint -> GLuint64EXT -> GLuint64EXT -> GLuint64EXT -> IO ())
-> GLuint -> GLuint64EXT -> GLuint64EXT -> GLuint64EXT -> IO ()
dyn924 FunPtr
  (GLuint -> GLuint64EXT -> GLuint64EXT -> GLuint64EXT -> IO ())
ptr_glVertexAttribL3ui64NV GLuint
v1 GLuint64EXT
v2 GLuint64EXT
v3 GLuint64EXT
v4

{-# NOINLINE ptr_glVertexAttribL3ui64NV #-}
ptr_glVertexAttribL3ui64NV :: FunPtr (GLuint -> GLuint64EXT -> GLuint64EXT -> GLuint64EXT -> IO ())
ptr_glVertexAttribL3ui64NV :: FunPtr
  (GLuint -> GLuint64EXT -> GLuint64EXT -> GLuint64EXT -> IO ())
ptr_glVertexAttribL3ui64NV = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ forall a. String -> IO (FunPtr a)
getCommand String
"glVertexAttribL3ui64NV"

-- glVertexAttribL3ui64vNV -----------------------------------------------------

glVertexAttribL3ui64vNV
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> Ptr GLuint64EXT -- ^ @v@ pointing to @3@ elements of type @GLuint64EXT@.
  -> m ()
glVertexAttribL3ui64vNV :: forall (m :: * -> *).
MonadIO m =>
GLuint -> Ptr GLuint64EXT -> m ()
glVertexAttribL3ui64vNV GLuint
v1 Ptr GLuint64EXT
v2 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> Ptr GLuint64EXT -> IO ())
-> GLuint -> Ptr GLuint64EXT -> IO ()
dyn920 FunPtr (GLuint -> Ptr GLuint64EXT -> IO ())
ptr_glVertexAttribL3ui64vNV GLuint
v1 Ptr GLuint64EXT
v2

{-# NOINLINE ptr_glVertexAttribL3ui64vNV #-}
ptr_glVertexAttribL3ui64vNV :: FunPtr (GLuint -> Ptr GLuint64EXT -> IO ())
ptr_glVertexAttribL3ui64vNV :: FunPtr (GLuint -> Ptr GLuint64EXT -> IO ())
ptr_glVertexAttribL3ui64vNV = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ forall a. String -> IO (FunPtr a)
getCommand String
"glVertexAttribL3ui64vNV"

-- glVertexAttribL4d -----------------------------------------------------------

-- | Manual page for <https://www.opengl.org/sdk/docs/man4/html/glVertexAttrib.xhtml OpenGL 4.x>.
glVertexAttribL4d
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> GLdouble -- ^ @x@.
  -> GLdouble -- ^ @y@.
  -> GLdouble -- ^ @z@.
  -> GLdouble -- ^ @w@.
  -> m ()
glVertexAttribL4d :: forall (m :: * -> *).
MonadIO m =>
GLuint -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> m ()
glVertexAttribL4d GLuint
v1 GLdouble
v2 GLdouble
v3 GLdouble
v4 GLdouble
v5 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ FunPtr
  (GLuint -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> IO ())
-> GLuint -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> IO ()
dyn906 FunPtr
  (GLuint -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> IO ())
ptr_glVertexAttribL4d GLuint
v1 GLdouble
v2 GLdouble
v3 GLdouble
v4 GLdouble
v5

{-# NOINLINE ptr_glVertexAttribL4d #-}
ptr_glVertexAttribL4d :: FunPtr (GLuint -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> IO ())
ptr_glVertexAttribL4d :: FunPtr
  (GLuint -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> IO ())
ptr_glVertexAttribL4d = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ forall a. String -> IO (FunPtr a)
getCommand String
"glVertexAttribL4d"

-- glVertexAttribL4dEXT --------------------------------------------------------

-- | This command is an alias for 'glVertexAttribL4d'.
glVertexAttribL4dEXT
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> GLdouble -- ^ @x@.
  -> GLdouble -- ^ @y@.
  -> GLdouble -- ^ @z@.
  -> GLdouble -- ^ @w@.
  -> m ()
glVertexAttribL4dEXT :: forall (m :: * -> *).
MonadIO m =>
GLuint -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> m ()
glVertexAttribL4dEXT GLuint
v1 GLdouble
v2 GLdouble
v3 GLdouble
v4 GLdouble
v5 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ FunPtr
  (GLuint -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> IO ())
-> GLuint -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> IO ()
dyn906 FunPtr
  (GLuint -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> IO ())
ptr_glVertexAttribL4dEXT GLuint
v1 GLdouble
v2 GLdouble
v3 GLdouble
v4 GLdouble
v5

{-# NOINLINE ptr_glVertexAttribL4dEXT #-}
ptr_glVertexAttribL4dEXT :: FunPtr (GLuint -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> IO ())
ptr_glVertexAttribL4dEXT :: FunPtr
  (GLuint -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> IO ())
ptr_glVertexAttribL4dEXT = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ forall a. String -> IO (FunPtr a)
getCommand String
"glVertexAttribL4dEXT"

-- glVertexAttribL4dv ----------------------------------------------------------

-- | Manual page for <https://www.opengl.org/sdk/docs/man4/html/glVertexAttrib.xhtml OpenGL 4.x>.
glVertexAttribL4dv
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> Ptr GLdouble -- ^ @v@ pointing to @4@ elements of type @GLdouble@.
  -> m ()
glVertexAttribL4dv :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLdouble -> m ()
glVertexAttribL4dv GLuint
v1 Ptr GLdouble
v2 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> Ptr GLdouble -> IO ())
-> GLuint -> Ptr GLdouble -> IO ()
dyn882 FunPtr (GLuint -> Ptr GLdouble -> IO ())
ptr_glVertexAttribL4dv GLuint
v1 Ptr GLdouble
v2

{-# NOINLINE ptr_glVertexAttribL4dv #-}
ptr_glVertexAttribL4dv :: FunPtr (GLuint -> Ptr GLdouble -> IO ())
ptr_glVertexAttribL4dv :: FunPtr (GLuint -> Ptr GLdouble -> IO ())
ptr_glVertexAttribL4dv = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ forall a. String -> IO (FunPtr a)
getCommand String
"glVertexAttribL4dv"

-- glVertexAttribL4dvEXT -------------------------------------------------------

-- | This command is an alias for 'glVertexAttribL4dv'.
glVertexAttribL4dvEXT
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> Ptr GLdouble -- ^ @v@ pointing to @4@ elements of type @GLdouble@.
  -> m ()
glVertexAttribL4dvEXT :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLdouble -> m ()
glVertexAttribL4dvEXT GLuint
v1 Ptr GLdouble
v2 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> Ptr GLdouble -> IO ())
-> GLuint -> Ptr GLdouble -> IO ()
dyn882 FunPtr (GLuint -> Ptr GLdouble -> IO ())
ptr_glVertexAttribL4dvEXT GLuint
v1 Ptr GLdouble
v2

{-# NOINLINE ptr_glVertexAttribL4dvEXT #-}
ptr_glVertexAttribL4dvEXT :: FunPtr (GLuint -> Ptr GLdouble -> IO ())
ptr_glVertexAttribL4dvEXT :: FunPtr (GLuint -> Ptr GLdouble -> IO ())
ptr_glVertexAttribL4dvEXT = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ forall a. String -> IO (FunPtr a)
getCommand String
"glVertexAttribL4dvEXT"

-- glVertexAttribL4i64NV -------------------------------------------------------

glVertexAttribL4i64NV
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> GLint64EXT -- ^ @x@.
  -> GLint64EXT -- ^ @y@.
  -> GLint64EXT -- ^ @z@.
  -> GLint64EXT -- ^ @w@.
  -> m ()
glVertexAttribL4i64NV :: forall (m :: * -> *).
MonadIO m =>
GLuint
-> GLint64EXT -> GLint64EXT -> GLint64EXT -> GLint64EXT -> m ()
glVertexAttribL4i64NV GLuint
v1 GLint64EXT
v2 GLint64EXT
v3 GLint64EXT
v4 GLint64EXT
v5 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ FunPtr
  (GLuint
   -> GLint64EXT -> GLint64EXT -> GLint64EXT -> GLint64EXT -> IO ())
-> GLuint
-> GLint64EXT
-> GLint64EXT
-> GLint64EXT
-> GLint64EXT
-> IO ()
dyn925 FunPtr
  (GLuint
   -> GLint64EXT -> GLint64EXT -> GLint64EXT -> GLint64EXT -> IO ())
ptr_glVertexAttribL4i64NV GLuint
v1 GLint64EXT
v2 GLint64EXT
v3 GLint64EXT
v4 GLint64EXT
v5

{-# NOINLINE ptr_glVertexAttribL4i64NV #-}
ptr_glVertexAttribL4i64NV :: FunPtr (GLuint -> GLint64EXT -> GLint64EXT -> GLint64EXT -> GLint64EXT -> IO ())
ptr_glVertexAttribL4i64NV :: FunPtr
  (GLuint
   -> GLint64EXT -> GLint64EXT -> GLint64EXT -> GLint64EXT -> IO ())
ptr_glVertexAttribL4i64NV = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ forall a. String -> IO (FunPtr a)
getCommand String
"glVertexAttribL4i64NV"

-- glVertexAttribL4i64vNV ------------------------------------------------------

glVertexAttribL4i64vNV
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> Ptr GLint64EXT -- ^ @v@ pointing to @4@ elements of type @GLint64EXT@.
  -> m ()
glVertexAttribL4i64vNV :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLint64EXT -> m ()
glVertexAttribL4i64vNV GLuint
v1 Ptr GLint64EXT
v2 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> Ptr GLint64EXT -> IO ())
-> GLuint -> Ptr GLint64EXT -> IO ()
dyn918 FunPtr (GLuint -> Ptr GLint64EXT -> IO ())
ptr_glVertexAttribL4i64vNV GLuint
v1 Ptr GLint64EXT
v2

{-# NOINLINE ptr_glVertexAttribL4i64vNV #-}
ptr_glVertexAttribL4i64vNV :: FunPtr (GLuint -> Ptr GLint64EXT -> IO ())
ptr_glVertexAttribL4i64vNV :: FunPtr (GLuint -> Ptr GLint64EXT -> IO ())
ptr_glVertexAttribL4i64vNV = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ forall a. String -> IO (FunPtr a)
getCommand String
"glVertexAttribL4i64vNV"

-- glVertexAttribL4ui64NV ------------------------------------------------------

glVertexAttribL4ui64NV
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> GLuint64EXT -- ^ @x@.
  -> GLuint64EXT -- ^ @y@.
  -> GLuint64EXT -- ^ @z@.
  -> GLuint64EXT -- ^ @w@.
  -> m ()
glVertexAttribL4ui64NV :: forall (m :: * -> *).
MonadIO m =>
GLuint
-> GLuint64EXT -> GLuint64EXT -> GLuint64EXT -> GLuint64EXT -> m ()
glVertexAttribL4ui64NV GLuint
v1 GLuint64EXT
v2 GLuint64EXT
v3 GLuint64EXT
v4 GLuint64EXT
v5 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ FunPtr
  (GLuint
   -> GLuint64EXT
   -> GLuint64EXT
   -> GLuint64EXT
   -> GLuint64EXT
   -> IO ())
-> GLuint
-> GLuint64EXT
-> GLuint64EXT
-> GLuint64EXT
-> GLuint64EXT
-> IO ()
dyn926 FunPtr
  (GLuint
   -> GLuint64EXT
   -> GLuint64EXT
   -> GLuint64EXT
   -> GLuint64EXT
   -> IO ())
ptr_glVertexAttribL4ui64NV GLuint
v1 GLuint64EXT
v2 GLuint64EXT
v3 GLuint64EXT
v4 GLuint64EXT
v5

{-# NOINLINE ptr_glVertexAttribL4ui64NV #-}
ptr_glVertexAttribL4ui64NV :: FunPtr (GLuint -> GLuint64EXT -> GLuint64EXT -> GLuint64EXT -> GLuint64EXT -> IO ())
ptr_glVertexAttribL4ui64NV :: FunPtr
  (GLuint
   -> GLuint64EXT
   -> GLuint64EXT
   -> GLuint64EXT
   -> GLuint64EXT
   -> IO ())
ptr_glVertexAttribL4ui64NV = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ forall a. String -> IO (FunPtr a)
getCommand String
"glVertexAttribL4ui64NV"

-- glVertexAttribL4ui64vNV -----------------------------------------------------

glVertexAttribL4ui64vNV
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> Ptr GLuint64EXT -- ^ @v@ pointing to @4@ elements of type @GLuint64EXT@.
  -> m ()
glVertexAttribL4ui64vNV :: forall (m :: * -> *).
MonadIO m =>
GLuint -> Ptr GLuint64EXT -> m ()
glVertexAttribL4ui64vNV GLuint
v1 Ptr GLuint64EXT
v2 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> Ptr GLuint64EXT -> IO ())
-> GLuint -> Ptr GLuint64EXT -> IO ()
dyn920 FunPtr (GLuint -> Ptr GLuint64EXT -> IO ())
ptr_glVertexAttribL4ui64vNV GLuint
v1 Ptr GLuint64EXT
v2

{-# NOINLINE ptr_glVertexAttribL4ui64vNV #-}
ptr_glVertexAttribL4ui64vNV :: FunPtr (GLuint -> Ptr GLuint64EXT -> IO ())
ptr_glVertexAttribL4ui64vNV :: FunPtr (GLuint -> Ptr GLuint64EXT -> IO ())
ptr_glVertexAttribL4ui64vNV = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ forall a. String -> IO (FunPtr a)
getCommand String
"glVertexAttribL4ui64vNV"

-- glVertexAttribLFormat -------------------------------------------------------

-- | Manual page for <https://www.opengl.org/sdk/docs/man4/html/glVertexAttribFormat.xhtml OpenGL 4.x>.
glVertexAttribLFormat
  :: MonadIO m
  => GLuint -- ^ @attribindex@.
  -> GLint -- ^ @size@.
  -> GLenum -- ^ @type@ of type [VertexAttribLType](Graphics-GL-Groups.html#VertexAttribLType).
  -> GLuint -- ^ @relativeoffset@.
  -> m ()
glVertexAttribLFormat :: forall (m :: * -> *).
MonadIO m =>
GLuint -> GLint -> GLuint -> GLuint -> m ()
glVertexAttribLFormat GLuint
v1 GLint
v2 GLuint
v3 GLuint
v4 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> GLint -> GLuint -> GLuint -> IO ())
-> GLuint -> GLint -> GLuint -> GLuint -> IO ()
dyn914 FunPtr (GLuint -> GLint -> GLuint -> GLuint -> IO ())
ptr_glVertexAttribLFormat GLuint
v1 GLint
v2 GLuint
v3 GLuint
v4

{-# NOINLINE ptr_glVertexAttribLFormat #-}
ptr_glVertexAttribLFormat :: FunPtr (GLuint -> GLint -> GLenum -> GLuint -> IO ())
ptr_glVertexAttribLFormat :: FunPtr (GLuint -> GLint -> GLuint -> GLuint -> IO ())
ptr_glVertexAttribLFormat = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ forall a. String -> IO (FunPtr a)
getCommand String
"glVertexAttribLFormat"

-- glVertexAttribLFormatNV -----------------------------------------------------

glVertexAttribLFormatNV
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> GLint -- ^ @size@.
  -> GLenum -- ^ @type@ of type [VertexAttribLType](Graphics-GL-Groups.html#VertexAttribLType).
  -> GLsizei -- ^ @stride@.
  -> m ()
glVertexAttribLFormatNV :: forall (m :: * -> *).
MonadIO m =>
GLuint -> GLint -> GLuint -> GLint -> m ()
glVertexAttribLFormatNV GLuint
v1 GLint
v2 GLuint
v3 GLint
v4 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> GLint -> GLuint -> GLint -> IO ())
-> GLuint -> GLint -> GLuint -> GLint -> IO ()
dyn915 FunPtr (GLuint -> GLint -> GLuint -> GLint -> IO ())
ptr_glVertexAttribLFormatNV GLuint
v1 GLint
v2 GLuint
v3 GLint
v4

{-# NOINLINE ptr_glVertexAttribLFormatNV #-}
ptr_glVertexAttribLFormatNV :: FunPtr (GLuint -> GLint -> GLenum -> GLsizei -> IO ())
ptr_glVertexAttribLFormatNV :: FunPtr (GLuint -> GLint -> GLuint -> GLint -> IO ())
ptr_glVertexAttribLFormatNV = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ forall a. String -> IO (FunPtr a)
getCommand String
"glVertexAttribLFormatNV"

-- glVertexAttribLPointer ------------------------------------------------------

-- | Manual page for <https://www.opengl.org/sdk/docs/man4/html/glVertexAttribPointer.xhtml OpenGL 4.x>.
glVertexAttribLPointer
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> GLint -- ^ @size@.
  -> GLenum -- ^ @type@ of type [VertexAttribPointerType](Graphics-GL-Groups.html#VertexAttribPointerType).
  -> GLsizei -- ^ @stride@.
  -> Ptr a -- ^ @pointer@ pointing to @size@ elements of type @a@.
  -> m ()
glVertexAttribLPointer :: forall (m :: * -> *) a.
MonadIO m =>
GLuint -> GLint -> GLuint -> GLint -> Ptr a -> m ()
glVertexAttribLPointer GLuint
v1 GLint
v2 GLuint
v3 GLint
v4 Ptr a
v5 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a.
FunPtr (GLuint -> GLint -> GLuint -> GLint -> Ptr a -> IO ())
-> GLuint -> GLint -> GLuint -> GLint -> Ptr a -> IO ()
dyn916 forall a.
FunPtr (GLuint -> GLint -> GLuint -> GLint -> Ptr a -> IO ())
ptr_glVertexAttribLPointer GLuint
v1 GLint
v2 GLuint
v3 GLint
v4 Ptr a
v5

{-# NOINLINE ptr_glVertexAttribLPointer #-}
ptr_glVertexAttribLPointer :: FunPtr (GLuint -> GLint -> GLenum -> GLsizei -> Ptr a -> IO ())
ptr_glVertexAttribLPointer :: forall a.
FunPtr (GLuint -> GLint -> GLuint -> GLint -> Ptr a -> IO ())
ptr_glVertexAttribLPointer = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ forall a. String -> IO (FunPtr a)
getCommand String
"glVertexAttribLPointer"