{-# OPTIONS_HADDOCK hide #-}
--------------------------------------------------------------------------------
-- |
-- Module      :  Graphics.GL.Functions.F30
-- 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.F30 (
  glVertexArrayVertexBindingDivisorEXT,
  glVertexArrayVertexBuffer,
  glVertexArrayVertexBuffers,
  glVertexArrayVertexOffsetEXT,
  glVertexAttrib1d,
  glVertexAttrib1dARB,
  glVertexAttrib1dNV,
  glVertexAttrib1dv,
  glVertexAttrib1dvARB,
  glVertexAttrib1dvNV,
  glVertexAttrib1f,
  glVertexAttrib1fARB,
  glVertexAttrib1fNV,
  glVertexAttrib1fv,
  glVertexAttrib1fvARB,
  glVertexAttrib1fvNV,
  glVertexAttrib1hNV,
  glVertexAttrib1hvNV,
  glVertexAttrib1s,
  glVertexAttrib1sARB,
  glVertexAttrib1sNV,
  glVertexAttrib1sv,
  glVertexAttrib1svARB,
  glVertexAttrib1svNV,
  glVertexAttrib2d,
  glVertexAttrib2dARB,
  glVertexAttrib2dNV,
  glVertexAttrib2dv,
  glVertexAttrib2dvARB,
  glVertexAttrib2dvNV,
  glVertexAttrib2f,
  glVertexAttrib2fARB,
  glVertexAttrib2fNV,
  glVertexAttrib2fv,
  glVertexAttrib2fvARB,
  glVertexAttrib2fvNV,
  glVertexAttrib2hNV,
  glVertexAttrib2hvNV,
  glVertexAttrib2s,
  glVertexAttrib2sARB,
  glVertexAttrib2sNV,
  glVertexAttrib2sv,
  glVertexAttrib2svARB,
  glVertexAttrib2svNV,
  glVertexAttrib3d,
  glVertexAttrib3dARB,
  glVertexAttrib3dNV,
  glVertexAttrib3dv,
  glVertexAttrib3dvARB,
  glVertexAttrib3dvNV,
  glVertexAttrib3f,
  glVertexAttrib3fARB,
  glVertexAttrib3fNV,
  glVertexAttrib3fv,
  glVertexAttrib3fvARB,
  glVertexAttrib3fvNV,
  glVertexAttrib3hNV,
  glVertexAttrib3hvNV,
  glVertexAttrib3s,
  glVertexAttrib3sARB,
  glVertexAttrib3sNV,
  glVertexAttrib3sv,
  glVertexAttrib3svARB,
  glVertexAttrib3svNV,
  glVertexAttrib4Nbv,
  glVertexAttrib4NbvARB,
  glVertexAttrib4Niv,
  glVertexAttrib4NivARB,
  glVertexAttrib4Nsv,
  glVertexAttrib4NsvARB,
  glVertexAttrib4Nub,
  glVertexAttrib4NubARB,
  glVertexAttrib4Nubv,
  glVertexAttrib4NubvARB,
  glVertexAttrib4Nuiv,
  glVertexAttrib4NuivARB,
  glVertexAttrib4Nusv,
  glVertexAttrib4NusvARB,
  glVertexAttrib4bv,
  glVertexAttrib4bvARB,
  glVertexAttrib4d,
  glVertexAttrib4dARB,
  glVertexAttrib4dNV,
  glVertexAttrib4dv,
  glVertexAttrib4dvARB,
  glVertexAttrib4dvNV,
  glVertexAttrib4f,
  glVertexAttrib4fARB,
  glVertexAttrib4fNV,
  glVertexAttrib4fv,
  glVertexAttrib4fvARB,
  glVertexAttrib4fvNV,
  glVertexAttrib4hNV,
  glVertexAttrib4hvNV,
  glVertexAttrib4iv,
  glVertexAttrib4ivARB,
  glVertexAttrib4s,
  glVertexAttrib4sARB,
  glVertexAttrib4sNV,
  glVertexAttrib4sv
) where

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

-- glVertexArrayVertexBindingDivisorEXT ----------------------------------------

glVertexArrayVertexBindingDivisorEXT
  :: MonadIO m
  => GLuint -- ^ @vaobj@.
  -> GLuint -- ^ @bindingindex@.
  -> GLuint -- ^ @divisor@.
  -> m ()
glVertexArrayVertexBindingDivisorEXT :: GLuint -> GLuint -> GLuint -> m ()
glVertexArrayVertexBindingDivisorEXT GLuint
v1 GLuint
v2 GLuint
v3 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> GLuint -> GLuint -> IO ())
-> GLuint -> GLuint -> GLuint -> IO ()
dyn109 FunPtr (GLuint -> GLuint -> GLuint -> IO ())
ptr_glVertexArrayVertexBindingDivisorEXT GLuint
v1 GLuint
v2 GLuint
v3

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

-- glVertexArrayVertexBuffer ---------------------------------------------------

-- | Manual page for <https://www.opengl.org/sdk/docs/man4/html/glBindVertexBuffer.xhtml OpenGL 4.x>.
glVertexArrayVertexBuffer
  :: MonadIO m
  => GLuint -- ^ @vaobj@.
  -> GLuint -- ^ @bindingindex@.
  -> GLuint -- ^ @buffer@.
  -> GLintptr -- ^ @offset@.
  -> GLsizei -- ^ @stride@.
  -> m ()
glVertexArrayVertexBuffer :: GLuint -> GLuint -> GLuint -> GLintptr -> GLsizei -> m ()
glVertexArrayVertexBuffer GLuint
v1 GLuint
v2 GLuint
v3 GLintptr
v4 GLsizei
v5 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> GLuint -> GLuint -> GLintptr -> GLsizei -> IO ())
-> GLuint -> GLuint -> GLuint -> GLintptr -> GLsizei -> IO ()
dyn887 FunPtr (GLuint -> GLuint -> GLuint -> GLintptr -> GLsizei -> IO ())
ptr_glVertexArrayVertexBuffer GLuint
v1 GLuint
v2 GLuint
v3 GLintptr
v4 GLsizei
v5

{-# NOINLINE ptr_glVertexArrayVertexBuffer #-}
ptr_glVertexArrayVertexBuffer :: FunPtr (GLuint -> GLuint -> GLuint -> GLintptr -> GLsizei -> IO ())
ptr_glVertexArrayVertexBuffer :: FunPtr (GLuint -> GLuint -> GLuint -> GLintptr -> GLsizei -> IO ())
ptr_glVertexArrayVertexBuffer = IO
  (FunPtr
     (GLuint -> GLuint -> GLuint -> GLintptr -> GLsizei -> IO ()))
-> FunPtr
     (GLuint -> GLuint -> GLuint -> GLintptr -> GLsizei -> IO ())
forall a. IO a -> a
unsafePerformIO (IO
   (FunPtr
      (GLuint -> GLuint -> GLuint -> GLintptr -> GLsizei -> IO ()))
 -> FunPtr
      (GLuint -> GLuint -> GLuint -> GLintptr -> GLsizei -> IO ()))
-> IO
     (FunPtr
        (GLuint -> GLuint -> GLuint -> GLintptr -> GLsizei -> IO ()))
-> FunPtr
     (GLuint -> GLuint -> GLuint -> GLintptr -> GLsizei -> IO ())
forall a b. (a -> b) -> a -> b
$ String
-> IO
     (FunPtr
        (GLuint -> GLuint -> GLuint -> GLintptr -> GLsizei -> IO ()))
forall a. String -> IO (FunPtr a)
getCommand String
"glVertexArrayVertexBuffer"

-- glVertexArrayVertexBuffers --------------------------------------------------

-- | Manual page for <https://www.opengl.org/sdk/docs/man4/html/glBindVertexBuffers.xhtml OpenGL 4.x>.
glVertexArrayVertexBuffers
  :: MonadIO m
  => GLuint -- ^ @vaobj@.
  -> GLuint -- ^ @first@.
  -> GLsizei -- ^ @count@.
  -> Ptr GLuint -- ^ @buffers@.
  -> Ptr GLintptr -- ^ @offsets@.
  -> Ptr GLsizei -- ^ @strides@.
  -> m ()
glVertexArrayVertexBuffers :: GLuint
-> GLuint
-> GLsizei
-> Ptr GLuint
-> Ptr GLintptr
-> Ptr GLsizei
-> m ()
glVertexArrayVertexBuffers GLuint
v1 GLuint
v2 GLsizei
v3 Ptr GLuint
v4 Ptr GLintptr
v5 Ptr GLsizei
v6 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr
  (GLuint
   -> GLuint
   -> GLsizei
   -> Ptr GLuint
   -> Ptr GLintptr
   -> Ptr GLsizei
   -> IO ())
-> GLuint
-> GLuint
-> GLsizei
-> Ptr GLuint
-> Ptr GLintptr
-> Ptr GLsizei
-> IO ()
dyn894 FunPtr
  (GLuint
   -> GLuint
   -> GLsizei
   -> Ptr GLuint
   -> Ptr GLintptr
   -> Ptr GLsizei
   -> IO ())
ptr_glVertexArrayVertexBuffers GLuint
v1 GLuint
v2 GLsizei
v3 Ptr GLuint
v4 Ptr GLintptr
v5 Ptr GLsizei
v6

{-# NOINLINE ptr_glVertexArrayVertexBuffers #-}
ptr_glVertexArrayVertexBuffers :: FunPtr (GLuint -> GLuint -> GLsizei -> Ptr GLuint -> Ptr GLintptr -> Ptr GLsizei -> IO ())
ptr_glVertexArrayVertexBuffers :: FunPtr
  (GLuint
   -> GLuint
   -> GLsizei
   -> Ptr GLuint
   -> Ptr GLintptr
   -> Ptr GLsizei
   -> IO ())
ptr_glVertexArrayVertexBuffers = IO
  (FunPtr
     (GLuint
      -> GLuint
      -> GLsizei
      -> Ptr GLuint
      -> Ptr GLintptr
      -> Ptr GLsizei
      -> IO ()))
-> FunPtr
     (GLuint
      -> GLuint
      -> GLsizei
      -> Ptr GLuint
      -> Ptr GLintptr
      -> Ptr GLsizei
      -> IO ())
forall a. IO a -> a
unsafePerformIO (IO
   (FunPtr
      (GLuint
       -> GLuint
       -> GLsizei
       -> Ptr GLuint
       -> Ptr GLintptr
       -> Ptr GLsizei
       -> IO ()))
 -> FunPtr
      (GLuint
       -> GLuint
       -> GLsizei
       -> Ptr GLuint
       -> Ptr GLintptr
       -> Ptr GLsizei
       -> IO ()))
-> IO
     (FunPtr
        (GLuint
         -> GLuint
         -> GLsizei
         -> Ptr GLuint
         -> Ptr GLintptr
         -> Ptr GLsizei
         -> IO ()))
-> FunPtr
     (GLuint
      -> GLuint
      -> GLsizei
      -> Ptr GLuint
      -> Ptr GLintptr
      -> Ptr GLsizei
      -> IO ())
forall a b. (a -> b) -> a -> b
$ String
-> IO
     (FunPtr
        (GLuint
         -> GLuint
         -> GLsizei
         -> Ptr GLuint
         -> Ptr GLintptr
         -> Ptr GLsizei
         -> IO ()))
forall a. String -> IO (FunPtr a)
getCommand String
"glVertexArrayVertexBuffers"

-- glVertexArrayVertexOffsetEXT ------------------------------------------------

glVertexArrayVertexOffsetEXT
  :: MonadIO m
  => GLuint -- ^ @vaobj@.
  -> GLuint -- ^ @buffer@.
  -> GLint -- ^ @size@.
  -> GLenum -- ^ @type@ of type [VertexPointerType](Graphics-GL-Groups.html#VertexPointerType).
  -> GLsizei -- ^ @stride@.
  -> GLintptr -- ^ @offset@.
  -> m ()
glVertexArrayVertexOffsetEXT :: GLuint
-> GLuint -> GLsizei -> GLuint -> GLsizei -> GLintptr -> m ()
glVertexArrayVertexOffsetEXT GLuint
v1 GLuint
v2 GLsizei
v3 GLuint
v4 GLsizei
v5 GLintptr
v6 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr
  (GLuint
   -> GLuint -> GLsizei -> GLuint -> GLsizei -> GLintptr -> IO ())
-> GLuint
-> GLuint
-> GLsizei
-> GLuint
-> GLsizei
-> GLintptr
-> IO ()
dyn888 FunPtr
  (GLuint
   -> GLuint -> GLsizei -> GLuint -> GLsizei -> GLintptr -> IO ())
ptr_glVertexArrayVertexOffsetEXT GLuint
v1 GLuint
v2 GLsizei
v3 GLuint
v4 GLsizei
v5 GLintptr
v6

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

-- glVertexAttrib1d ------------------------------------------------------------

-- | 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>. The vector equivalent of this command is 'glVertexAttrib1dv'.
glVertexAttrib1d
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> GLdouble -- ^ @x@.
  -> m ()
glVertexAttrib1d :: GLuint -> GLdouble -> m ()
glVertexAttrib1d GLuint
v1 GLdouble
v2 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> GLdouble -> IO ()) -> GLuint -> GLdouble -> IO ()
dyn895 FunPtr (GLuint -> GLdouble -> IO ())
ptr_glVertexAttrib1d GLuint
v1 GLdouble
v2

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

-- glVertexAttrib1dARB ---------------------------------------------------------

-- | The vector equivalent of this command is 'glVertexAttrib1dvARB'. This command is an alias for 'glVertexAttrib1d'.
glVertexAttrib1dARB
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> GLdouble -- ^ @x@.
  -> m ()
glVertexAttrib1dARB :: GLuint -> GLdouble -> m ()
glVertexAttrib1dARB GLuint
v1 GLdouble
v2 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> GLdouble -> IO ()) -> GLuint -> GLdouble -> IO ()
dyn895 FunPtr (GLuint -> GLdouble -> IO ())
ptr_glVertexAttrib1dARB GLuint
v1 GLdouble
v2

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

-- glVertexAttrib1dNV ----------------------------------------------------------

-- | The vector equivalent of this command is 'glVertexAttrib1dvNV'. This command is an alias for 'glVertexAttrib1d'.
glVertexAttrib1dNV
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> GLdouble -- ^ @x@.
  -> m ()
glVertexAttrib1dNV :: GLuint -> GLdouble -> m ()
glVertexAttrib1dNV GLuint
v1 GLdouble
v2 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> GLdouble -> IO ()) -> GLuint -> GLdouble -> IO ()
dyn895 FunPtr (GLuint -> GLdouble -> IO ())
ptr_glVertexAttrib1dNV GLuint
v1 GLdouble
v2

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

-- glVertexAttrib1dv -----------------------------------------------------------

-- | 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>.
glVertexAttrib1dv
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> Ptr GLdouble -- ^ @v@ pointing to @1@ element of type @GLdouble@.
  -> m ()
glVertexAttrib1dv :: GLuint -> Ptr GLdouble -> m ()
glVertexAttrib1dv GLuint
v1 Ptr GLdouble
v2 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> Ptr GLdouble -> IO ())
-> GLuint -> Ptr GLdouble -> IO ()
dyn882 FunPtr (GLuint -> Ptr GLdouble -> IO ())
ptr_glVertexAttrib1dv GLuint
v1 Ptr GLdouble
v2

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

-- glVertexAttrib1dvARB --------------------------------------------------------

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

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

-- glVertexAttrib1dvNV ---------------------------------------------------------

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

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

-- glVertexAttrib1f ------------------------------------------------------------

-- | 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>. The vector equivalent of this command is 'glVertexAttrib1fv'.
glVertexAttrib1f
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> GLfloat -- ^ @x@.
  -> m ()
glVertexAttrib1f :: GLuint -> GLfloat -> m ()
glVertexAttrib1f GLuint
v1 GLfloat
v2 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> GLfloat -> IO ()) -> GLuint -> GLfloat -> IO ()
dyn896 FunPtr (GLuint -> GLfloat -> IO ())
ptr_glVertexAttrib1f GLuint
v1 GLfloat
v2

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

-- glVertexAttrib1fARB ---------------------------------------------------------

-- | The vector equivalent of this command is 'glVertexAttrib1fvARB'. This command is an alias for 'glVertexAttrib1f'.
glVertexAttrib1fARB
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> GLfloat -- ^ @x@.
  -> m ()
glVertexAttrib1fARB :: GLuint -> GLfloat -> m ()
glVertexAttrib1fARB GLuint
v1 GLfloat
v2 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> GLfloat -> IO ()) -> GLuint -> GLfloat -> IO ()
dyn896 FunPtr (GLuint -> GLfloat -> IO ())
ptr_glVertexAttrib1fARB GLuint
v1 GLfloat
v2

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

-- glVertexAttrib1fNV ----------------------------------------------------------

-- | The vector equivalent of this command is 'glVertexAttrib1fvNV'. This command is an alias for 'glVertexAttrib1f'.
glVertexAttrib1fNV
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> GLfloat -- ^ @x@.
  -> m ()
glVertexAttrib1fNV :: GLuint -> GLfloat -> m ()
glVertexAttrib1fNV GLuint
v1 GLfloat
v2 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> GLfloat -> IO ()) -> GLuint -> GLfloat -> IO ()
dyn896 FunPtr (GLuint -> GLfloat -> IO ())
ptr_glVertexAttrib1fNV GLuint
v1 GLfloat
v2

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

-- glVertexAttrib1fv -----------------------------------------------------------

-- | 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>.
glVertexAttrib1fv
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> Ptr GLfloat -- ^ @v@ pointing to @1@ element of type @GLfloat@.
  -> m ()
glVertexAttrib1fv :: GLuint -> Ptr GLfloat -> m ()
glVertexAttrib1fv GLuint
v1 Ptr GLfloat
v2 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> Ptr GLfloat -> IO ())
-> GLuint -> Ptr GLfloat -> IO ()
dyn394 FunPtr (GLuint -> Ptr GLfloat -> IO ())
ptr_glVertexAttrib1fv GLuint
v1 Ptr GLfloat
v2

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

-- glVertexAttrib1fvARB --------------------------------------------------------

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

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

-- glVertexAttrib1fvNV ---------------------------------------------------------

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

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

-- glVertexAttrib1hNV ----------------------------------------------------------

-- | The vector equivalent of this command is 'glVertexAttrib1hvNV'.
glVertexAttrib1hNV
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> GLhalfNV -- ^ @x@ of type @Half16NV@.
  -> m ()
glVertexAttrib1hNV :: GLuint -> GLhalfNV -> m ()
glVertexAttrib1hNV GLuint
v1 GLhalfNV
v2 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> GLhalfNV -> IO ()) -> GLuint -> GLhalfNV -> IO ()
dyn897 FunPtr (GLuint -> GLhalfNV -> IO ())
ptr_glVertexAttrib1hNV GLuint
v1 GLhalfNV
v2

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

-- glVertexAttrib1hvNV ---------------------------------------------------------

glVertexAttrib1hvNV
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> Ptr GLhalfNV -- ^ @v@ pointing to @1@ element of type @Half16NV@.
  -> m ()
glVertexAttrib1hvNV :: GLuint -> Ptr GLhalfNV -> m ()
glVertexAttrib1hvNV GLuint
v1 Ptr GLhalfNV
v2 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> Ptr GLhalfNV -> IO ())
-> GLuint -> Ptr GLhalfNV -> IO ()
dyn898 FunPtr (GLuint -> Ptr GLhalfNV -> IO ())
ptr_glVertexAttrib1hvNV GLuint
v1 Ptr GLhalfNV
v2

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

-- glVertexAttrib1s ------------------------------------------------------------

-- | 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>. The vector equivalent of this command is 'glVertexAttrib1sv'.
glVertexAttrib1s
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> GLshort -- ^ @x@.
  -> m ()
glVertexAttrib1s :: GLuint -> GLshort -> m ()
glVertexAttrib1s GLuint
v1 GLshort
v2 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> GLshort -> IO ()) -> GLuint -> GLshort -> IO ()
dyn899 FunPtr (GLuint -> GLshort -> IO ())
ptr_glVertexAttrib1s GLuint
v1 GLshort
v2

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

-- glVertexAttrib1sARB ---------------------------------------------------------

-- | The vector equivalent of this command is 'glVertexAttrib1svARB'. This command is an alias for 'glVertexAttrib1s'.
glVertexAttrib1sARB
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> GLshort -- ^ @x@.
  -> m ()
glVertexAttrib1sARB :: GLuint -> GLshort -> m ()
glVertexAttrib1sARB GLuint
v1 GLshort
v2 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> GLshort -> IO ()) -> GLuint -> GLshort -> IO ()
dyn899 FunPtr (GLuint -> GLshort -> IO ())
ptr_glVertexAttrib1sARB GLuint
v1 GLshort
v2

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

-- glVertexAttrib1sNV ----------------------------------------------------------

-- | The vector equivalent of this command is 'glVertexAttrib1svNV'. This command is an alias for 'glVertexAttrib1s'.
glVertexAttrib1sNV
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> GLshort -- ^ @x@.
  -> m ()
glVertexAttrib1sNV :: GLuint -> GLshort -> m ()
glVertexAttrib1sNV GLuint
v1 GLshort
v2 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> GLshort -> IO ()) -> GLuint -> GLshort -> IO ()
dyn899 FunPtr (GLuint -> GLshort -> IO ())
ptr_glVertexAttrib1sNV GLuint
v1 GLshort
v2

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

-- glVertexAttrib1sv -----------------------------------------------------------

-- | 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>.
glVertexAttrib1sv
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> Ptr GLshort -- ^ @v@ pointing to @1@ element of type @GLshort@.
  -> m ()
glVertexAttrib1sv :: GLuint -> Ptr GLshort -> m ()
glVertexAttrib1sv GLuint
v1 Ptr GLshort
v2 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> Ptr GLshort -> IO ())
-> GLuint -> Ptr GLshort -> IO ()
dyn883 FunPtr (GLuint -> Ptr GLshort -> IO ())
ptr_glVertexAttrib1sv GLuint
v1 Ptr GLshort
v2

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

-- glVertexAttrib1svARB --------------------------------------------------------

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

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

-- glVertexAttrib1svNV ---------------------------------------------------------

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

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

-- glVertexAttrib2d ------------------------------------------------------------

-- | 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>. The vector equivalent of this command is 'glVertexAttrib2dv'.
glVertexAttrib2d
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> GLdouble -- ^ @x@.
  -> GLdouble -- ^ @y@.
  -> m ()
glVertexAttrib2d :: GLuint -> GLdouble -> GLdouble -> m ()
glVertexAttrib2d GLuint
v1 GLdouble
v2 GLdouble
v3 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> GLdouble -> GLdouble -> IO ())
-> GLuint -> GLdouble -> GLdouble -> IO ()
dyn228 FunPtr (GLuint -> GLdouble -> GLdouble -> IO ())
ptr_glVertexAttrib2d GLuint
v1 GLdouble
v2 GLdouble
v3

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

-- glVertexAttrib2dARB ---------------------------------------------------------

-- | The vector equivalent of this command is 'glVertexAttrib2dvARB'. This command is an alias for 'glVertexAttrib2d'.
glVertexAttrib2dARB
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> GLdouble -- ^ @x@.
  -> GLdouble -- ^ @y@.
  -> m ()
glVertexAttrib2dARB :: GLuint -> GLdouble -> GLdouble -> m ()
glVertexAttrib2dARB GLuint
v1 GLdouble
v2 GLdouble
v3 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> GLdouble -> GLdouble -> IO ())
-> GLuint -> GLdouble -> GLdouble -> IO ()
dyn228 FunPtr (GLuint -> GLdouble -> GLdouble -> IO ())
ptr_glVertexAttrib2dARB GLuint
v1 GLdouble
v2 GLdouble
v3

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

-- glVertexAttrib2dNV ----------------------------------------------------------

-- | The vector equivalent of this command is 'glVertexAttrib2dvNV'. This command is an alias for 'glVertexAttrib2d'.
glVertexAttrib2dNV
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> GLdouble -- ^ @x@.
  -> GLdouble -- ^ @y@.
  -> m ()
glVertexAttrib2dNV :: GLuint -> GLdouble -> GLdouble -> m ()
glVertexAttrib2dNV GLuint
v1 GLdouble
v2 GLdouble
v3 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> GLdouble -> GLdouble -> IO ())
-> GLuint -> GLdouble -> GLdouble -> IO ()
dyn228 FunPtr (GLuint -> GLdouble -> GLdouble -> IO ())
ptr_glVertexAttrib2dNV GLuint
v1 GLdouble
v2 GLdouble
v3

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

-- glVertexAttrib2dv -----------------------------------------------------------

-- | 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>.
glVertexAttrib2dv
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> Ptr GLdouble -- ^ @v@ pointing to @2@ elements of type @GLdouble@.
  -> m ()
glVertexAttrib2dv :: GLuint -> Ptr GLdouble -> m ()
glVertexAttrib2dv GLuint
v1 Ptr GLdouble
v2 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> Ptr GLdouble -> IO ())
-> GLuint -> Ptr GLdouble -> IO ()
dyn882 FunPtr (GLuint -> Ptr GLdouble -> IO ())
ptr_glVertexAttrib2dv GLuint
v1 Ptr GLdouble
v2

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

-- glVertexAttrib2dvARB --------------------------------------------------------

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

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

-- glVertexAttrib2dvNV ---------------------------------------------------------

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

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

-- glVertexAttrib2f ------------------------------------------------------------

-- | 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>. The vector equivalent of this command is 'glVertexAttrib2fv'.
glVertexAttrib2f
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> GLfloat -- ^ @x@.
  -> GLfloat -- ^ @y@.
  -> m ()
glVertexAttrib2f :: GLuint -> GLfloat -> GLfloat -> m ()
glVertexAttrib2f GLuint
v1 GLfloat
v2 GLfloat
v3 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> GLfloat -> GLfloat -> IO ())
-> GLuint -> GLfloat -> GLfloat -> IO ()
dyn229 FunPtr (GLuint -> GLfloat -> GLfloat -> IO ())
ptr_glVertexAttrib2f GLuint
v1 GLfloat
v2 GLfloat
v3

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

-- glVertexAttrib2fARB ---------------------------------------------------------

-- | The vector equivalent of this command is 'glVertexAttrib2fvARB'. This command is an alias for 'glVertexAttrib2f'.
glVertexAttrib2fARB
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> GLfloat -- ^ @x@.
  -> GLfloat -- ^ @y@.
  -> m ()
glVertexAttrib2fARB :: GLuint -> GLfloat -> GLfloat -> m ()
glVertexAttrib2fARB GLuint
v1 GLfloat
v2 GLfloat
v3 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> GLfloat -> GLfloat -> IO ())
-> GLuint -> GLfloat -> GLfloat -> IO ()
dyn229 FunPtr (GLuint -> GLfloat -> GLfloat -> IO ())
ptr_glVertexAttrib2fARB GLuint
v1 GLfloat
v2 GLfloat
v3

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

-- glVertexAttrib2fNV ----------------------------------------------------------

-- | The vector equivalent of this command is 'glVertexAttrib2fvNV'. This command is an alias for 'glVertexAttrib2f'.
glVertexAttrib2fNV
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> GLfloat -- ^ @x@.
  -> GLfloat -- ^ @y@.
  -> m ()
glVertexAttrib2fNV :: GLuint -> GLfloat -> GLfloat -> m ()
glVertexAttrib2fNV GLuint
v1 GLfloat
v2 GLfloat
v3 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> GLfloat -> GLfloat -> IO ())
-> GLuint -> GLfloat -> GLfloat -> IO ()
dyn229 FunPtr (GLuint -> GLfloat -> GLfloat -> IO ())
ptr_glVertexAttrib2fNV GLuint
v1 GLfloat
v2 GLfloat
v3

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

-- glVertexAttrib2fv -----------------------------------------------------------

-- | 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>.
glVertexAttrib2fv
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> Ptr GLfloat -- ^ @v@ pointing to @2@ elements of type @GLfloat@.
  -> m ()
glVertexAttrib2fv :: GLuint -> Ptr GLfloat -> m ()
glVertexAttrib2fv GLuint
v1 Ptr GLfloat
v2 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> Ptr GLfloat -> IO ())
-> GLuint -> Ptr GLfloat -> IO ()
dyn394 FunPtr (GLuint -> Ptr GLfloat -> IO ())
ptr_glVertexAttrib2fv GLuint
v1 Ptr GLfloat
v2

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

-- glVertexAttrib2fvARB --------------------------------------------------------

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

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

-- glVertexAttrib2fvNV ---------------------------------------------------------

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

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

-- glVertexAttrib2hNV ----------------------------------------------------------

-- | The vector equivalent of this command is 'glVertexAttrib2hvNV'.
glVertexAttrib2hNV
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> GLhalfNV -- ^ @x@ of type @Half16NV@.
  -> GLhalfNV -- ^ @y@ of type @Half16NV@.
  -> m ()
glVertexAttrib2hNV :: GLuint -> GLhalfNV -> GLhalfNV -> m ()
glVertexAttrib2hNV GLuint
v1 GLhalfNV
v2 GLhalfNV
v3 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> GLhalfNV -> GLhalfNV -> IO ())
-> GLuint -> GLhalfNV -> GLhalfNV -> IO ()
dyn900 FunPtr (GLuint -> GLhalfNV -> GLhalfNV -> IO ())
ptr_glVertexAttrib2hNV GLuint
v1 GLhalfNV
v2 GLhalfNV
v3

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

-- glVertexAttrib2hvNV ---------------------------------------------------------

glVertexAttrib2hvNV
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> Ptr GLhalfNV -- ^ @v@ pointing to @2@ elements of type @Half16NV@.
  -> m ()
glVertexAttrib2hvNV :: GLuint -> Ptr GLhalfNV -> m ()
glVertexAttrib2hvNV GLuint
v1 Ptr GLhalfNV
v2 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> Ptr GLhalfNV -> IO ())
-> GLuint -> Ptr GLhalfNV -> IO ()
dyn898 FunPtr (GLuint -> Ptr GLhalfNV -> IO ())
ptr_glVertexAttrib2hvNV GLuint
v1 Ptr GLhalfNV
v2

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

-- glVertexAttrib2s ------------------------------------------------------------

-- | 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>. The vector equivalent of this command is 'glVertexAttrib2sv'.
glVertexAttrib2s
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> GLshort -- ^ @x@.
  -> GLshort -- ^ @y@.
  -> m ()
glVertexAttrib2s :: GLuint -> GLshort -> GLshort -> m ()
glVertexAttrib2s GLuint
v1 GLshort
v2 GLshort
v3 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> GLshort -> GLshort -> IO ())
-> GLuint -> GLshort -> GLshort -> IO ()
dyn901 FunPtr (GLuint -> GLshort -> GLshort -> IO ())
ptr_glVertexAttrib2s GLuint
v1 GLshort
v2 GLshort
v3

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

-- glVertexAttrib2sARB ---------------------------------------------------------

-- | The vector equivalent of this command is 'glVertexAttrib2svARB'. This command is an alias for 'glVertexAttrib2s'.
glVertexAttrib2sARB
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> GLshort -- ^ @x@.
  -> GLshort -- ^ @y@.
  -> m ()
glVertexAttrib2sARB :: GLuint -> GLshort -> GLshort -> m ()
glVertexAttrib2sARB GLuint
v1 GLshort
v2 GLshort
v3 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> GLshort -> GLshort -> IO ())
-> GLuint -> GLshort -> GLshort -> IO ()
dyn901 FunPtr (GLuint -> GLshort -> GLshort -> IO ())
ptr_glVertexAttrib2sARB GLuint
v1 GLshort
v2 GLshort
v3

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

-- glVertexAttrib2sNV ----------------------------------------------------------

-- | The vector equivalent of this command is 'glVertexAttrib2svNV'. This command is an alias for 'glVertexAttrib2s'.
glVertexAttrib2sNV
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> GLshort -- ^ @x@.
  -> GLshort -- ^ @y@.
  -> m ()
glVertexAttrib2sNV :: GLuint -> GLshort -> GLshort -> m ()
glVertexAttrib2sNV GLuint
v1 GLshort
v2 GLshort
v3 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> GLshort -> GLshort -> IO ())
-> GLuint -> GLshort -> GLshort -> IO ()
dyn901 FunPtr (GLuint -> GLshort -> GLshort -> IO ())
ptr_glVertexAttrib2sNV GLuint
v1 GLshort
v2 GLshort
v3

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

-- glVertexAttrib2sv -----------------------------------------------------------

-- | 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>.
glVertexAttrib2sv
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> Ptr GLshort -- ^ @v@ pointing to @2@ elements of type @GLshort@.
  -> m ()
glVertexAttrib2sv :: GLuint -> Ptr GLshort -> m ()
glVertexAttrib2sv GLuint
v1 Ptr GLshort
v2 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> Ptr GLshort -> IO ())
-> GLuint -> Ptr GLshort -> IO ()
dyn883 FunPtr (GLuint -> Ptr GLshort -> IO ())
ptr_glVertexAttrib2sv GLuint
v1 Ptr GLshort
v2

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

-- glVertexAttrib2svARB --------------------------------------------------------

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

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

-- glVertexAttrib2svNV ---------------------------------------------------------

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

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

-- glVertexAttrib3d ------------------------------------------------------------

-- | 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>. The vector equivalent of this command is 'glVertexAttrib3dv'.
glVertexAttrib3d
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> GLdouble -- ^ @x@.
  -> GLdouble -- ^ @y@.
  -> GLdouble -- ^ @z@.
  -> m ()
glVertexAttrib3d :: GLuint -> GLdouble -> GLdouble -> GLdouble -> m ()
glVertexAttrib3d GLuint
v1 GLdouble
v2 GLdouble
v3 GLdouble
v4 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
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_glVertexAttrib3d GLuint
v1 GLdouble
v2 GLdouble
v3 GLdouble
v4

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

-- glVertexAttrib3dARB ---------------------------------------------------------

-- | The vector equivalent of this command is 'glVertexAttrib3dvARB'. This command is an alias for 'glVertexAttrib3d'.
glVertexAttrib3dARB
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> GLdouble -- ^ @x@.
  -> GLdouble -- ^ @y@.
  -> GLdouble -- ^ @z@.
  -> m ()
glVertexAttrib3dARB :: GLuint -> GLdouble -> GLdouble -> GLdouble -> m ()
glVertexAttrib3dARB GLuint
v1 GLdouble
v2 GLdouble
v3 GLdouble
v4 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
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_glVertexAttrib3dARB GLuint
v1 GLdouble
v2 GLdouble
v3 GLdouble
v4

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

-- glVertexAttrib3dNV ----------------------------------------------------------

-- | The vector equivalent of this command is 'glVertexAttrib3dvNV'. This command is an alias for 'glVertexAttrib3d'.
glVertexAttrib3dNV
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> GLdouble -- ^ @x@.
  -> GLdouble -- ^ @y@.
  -> GLdouble -- ^ @z@.
  -> m ()
glVertexAttrib3dNV :: GLuint -> GLdouble -> GLdouble -> GLdouble -> m ()
glVertexAttrib3dNV GLuint
v1 GLdouble
v2 GLdouble
v3 GLdouble
v4 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
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_glVertexAttrib3dNV GLuint
v1 GLdouble
v2 GLdouble
v3 GLdouble
v4

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

-- glVertexAttrib3dv -----------------------------------------------------------

-- | 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>.
glVertexAttrib3dv
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> Ptr GLdouble -- ^ @v@ pointing to @3@ elements of type @GLdouble@.
  -> m ()
glVertexAttrib3dv :: GLuint -> Ptr GLdouble -> m ()
glVertexAttrib3dv GLuint
v1 Ptr GLdouble
v2 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> Ptr GLdouble -> IO ())
-> GLuint -> Ptr GLdouble -> IO ()
dyn882 FunPtr (GLuint -> Ptr GLdouble -> IO ())
ptr_glVertexAttrib3dv GLuint
v1 Ptr GLdouble
v2

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

-- glVertexAttrib3dvARB --------------------------------------------------------

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

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

-- glVertexAttrib3dvNV ---------------------------------------------------------

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

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

-- glVertexAttrib3f ------------------------------------------------------------

-- | 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>. The vector equivalent of this command is 'glVertexAttrib3fv'.
glVertexAttrib3f
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> GLfloat -- ^ @x@.
  -> GLfloat -- ^ @y@.
  -> GLfloat -- ^ @z@.
  -> m ()
glVertexAttrib3f :: GLuint -> GLfloat -> GLfloat -> GLfloat -> m ()
glVertexAttrib3f GLuint
v1 GLfloat
v2 GLfloat
v3 GLfloat
v4 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> GLfloat -> GLfloat -> GLfloat -> IO ())
-> GLuint -> GLfloat -> GLfloat -> GLfloat -> IO ()
dyn733 FunPtr (GLuint -> GLfloat -> GLfloat -> GLfloat -> IO ())
ptr_glVertexAttrib3f GLuint
v1 GLfloat
v2 GLfloat
v3 GLfloat
v4

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

-- glVertexAttrib3fARB ---------------------------------------------------------

-- | The vector equivalent of this command is 'glVertexAttrib3fvARB'. This command is an alias for 'glVertexAttrib3f'.
glVertexAttrib3fARB
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> GLfloat -- ^ @x@.
  -> GLfloat -- ^ @y@.
  -> GLfloat -- ^ @z@.
  -> m ()
glVertexAttrib3fARB :: GLuint -> GLfloat -> GLfloat -> GLfloat -> m ()
glVertexAttrib3fARB GLuint
v1 GLfloat
v2 GLfloat
v3 GLfloat
v4 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> GLfloat -> GLfloat -> GLfloat -> IO ())
-> GLuint -> GLfloat -> GLfloat -> GLfloat -> IO ()
dyn733 FunPtr (GLuint -> GLfloat -> GLfloat -> GLfloat -> IO ())
ptr_glVertexAttrib3fARB GLuint
v1 GLfloat
v2 GLfloat
v3 GLfloat
v4

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

-- glVertexAttrib3fNV ----------------------------------------------------------

-- | The vector equivalent of this command is 'glVertexAttrib3fvNV'. This command is an alias for 'glVertexAttrib3f'.
glVertexAttrib3fNV
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> GLfloat -- ^ @x@.
  -> GLfloat -- ^ @y@.
  -> GLfloat -- ^ @z@.
  -> m ()
glVertexAttrib3fNV :: GLuint -> GLfloat -> GLfloat -> GLfloat -> m ()
glVertexAttrib3fNV GLuint
v1 GLfloat
v2 GLfloat
v3 GLfloat
v4 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> GLfloat -> GLfloat -> GLfloat -> IO ())
-> GLuint -> GLfloat -> GLfloat -> GLfloat -> IO ()
dyn733 FunPtr (GLuint -> GLfloat -> GLfloat -> GLfloat -> IO ())
ptr_glVertexAttrib3fNV GLuint
v1 GLfloat
v2 GLfloat
v3 GLfloat
v4

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

-- glVertexAttrib3fv -----------------------------------------------------------

-- | 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>.
glVertexAttrib3fv
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> Ptr GLfloat -- ^ @v@ pointing to @3@ elements of type @GLfloat@.
  -> m ()
glVertexAttrib3fv :: GLuint -> Ptr GLfloat -> m ()
glVertexAttrib3fv GLuint
v1 Ptr GLfloat
v2 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> Ptr GLfloat -> IO ())
-> GLuint -> Ptr GLfloat -> IO ()
dyn394 FunPtr (GLuint -> Ptr GLfloat -> IO ())
ptr_glVertexAttrib3fv GLuint
v1 Ptr GLfloat
v2

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

-- glVertexAttrib3fvARB --------------------------------------------------------

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

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

-- glVertexAttrib3fvNV ---------------------------------------------------------

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

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

-- glVertexAttrib3hNV ----------------------------------------------------------

-- | The vector equivalent of this command is 'glVertexAttrib3hvNV'.
glVertexAttrib3hNV
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> GLhalfNV -- ^ @x@ of type @Half16NV@.
  -> GLhalfNV -- ^ @y@ of type @Half16NV@.
  -> GLhalfNV -- ^ @z@ of type @Half16NV@.
  -> m ()
glVertexAttrib3hNV :: GLuint -> GLhalfNV -> GLhalfNV -> GLhalfNV -> m ()
glVertexAttrib3hNV GLuint
v1 GLhalfNV
v2 GLhalfNV
v3 GLhalfNV
v4 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> GLhalfNV -> GLhalfNV -> GLhalfNV -> IO ())
-> GLuint -> GLhalfNV -> GLhalfNV -> GLhalfNV -> IO ()
dyn903 FunPtr (GLuint -> GLhalfNV -> GLhalfNV -> GLhalfNV -> IO ())
ptr_glVertexAttrib3hNV GLuint
v1 GLhalfNV
v2 GLhalfNV
v3 GLhalfNV
v4

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

-- glVertexAttrib3hvNV ---------------------------------------------------------

glVertexAttrib3hvNV
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> Ptr GLhalfNV -- ^ @v@ pointing to @3@ elements of type @Half16NV@.
  -> m ()
glVertexAttrib3hvNV :: GLuint -> Ptr GLhalfNV -> m ()
glVertexAttrib3hvNV GLuint
v1 Ptr GLhalfNV
v2 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> Ptr GLhalfNV -> IO ())
-> GLuint -> Ptr GLhalfNV -> IO ()
dyn898 FunPtr (GLuint -> Ptr GLhalfNV -> IO ())
ptr_glVertexAttrib3hvNV GLuint
v1 Ptr GLhalfNV
v2

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

-- glVertexAttrib3s ------------------------------------------------------------

-- | 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>. The vector equivalent of this command is 'glVertexAttrib3sv'.
glVertexAttrib3s
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> GLshort -- ^ @x@.
  -> GLshort -- ^ @y@.
  -> GLshort -- ^ @z@.
  -> m ()
glVertexAttrib3s :: GLuint -> GLshort -> GLshort -> GLshort -> m ()
glVertexAttrib3s GLuint
v1 GLshort
v2 GLshort
v3 GLshort
v4 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> GLshort -> GLshort -> GLshort -> IO ())
-> GLuint -> GLshort -> GLshort -> GLshort -> IO ()
dyn904 FunPtr (GLuint -> GLshort -> GLshort -> GLshort -> IO ())
ptr_glVertexAttrib3s GLuint
v1 GLshort
v2 GLshort
v3 GLshort
v4

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

-- glVertexAttrib3sARB ---------------------------------------------------------

-- | The vector equivalent of this command is 'glVertexAttrib3svARB'. This command is an alias for 'glVertexAttrib3s'.
glVertexAttrib3sARB
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> GLshort -- ^ @x@.
  -> GLshort -- ^ @y@.
  -> GLshort -- ^ @z@.
  -> m ()
glVertexAttrib3sARB :: GLuint -> GLshort -> GLshort -> GLshort -> m ()
glVertexAttrib3sARB GLuint
v1 GLshort
v2 GLshort
v3 GLshort
v4 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> GLshort -> GLshort -> GLshort -> IO ())
-> GLuint -> GLshort -> GLshort -> GLshort -> IO ()
dyn904 FunPtr (GLuint -> GLshort -> GLshort -> GLshort -> IO ())
ptr_glVertexAttrib3sARB GLuint
v1 GLshort
v2 GLshort
v3 GLshort
v4

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

-- glVertexAttrib3sNV ----------------------------------------------------------

-- | The vector equivalent of this command is 'glVertexAttrib3svNV'. This command is an alias for 'glVertexAttrib3s'.
glVertexAttrib3sNV
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> GLshort -- ^ @x@.
  -> GLshort -- ^ @y@.
  -> GLshort -- ^ @z@.
  -> m ()
glVertexAttrib3sNV :: GLuint -> GLshort -> GLshort -> GLshort -> m ()
glVertexAttrib3sNV GLuint
v1 GLshort
v2 GLshort
v3 GLshort
v4 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> GLshort -> GLshort -> GLshort -> IO ())
-> GLuint -> GLshort -> GLshort -> GLshort -> IO ()
dyn904 FunPtr (GLuint -> GLshort -> GLshort -> GLshort -> IO ())
ptr_glVertexAttrib3sNV GLuint
v1 GLshort
v2 GLshort
v3 GLshort
v4

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

-- glVertexAttrib3sv -----------------------------------------------------------

-- | 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>.
glVertexAttrib3sv
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> Ptr GLshort -- ^ @v@ pointing to @3@ elements of type @GLshort@.
  -> m ()
glVertexAttrib3sv :: GLuint -> Ptr GLshort -> m ()
glVertexAttrib3sv GLuint
v1 Ptr GLshort
v2 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> Ptr GLshort -> IO ())
-> GLuint -> Ptr GLshort -> IO ()
dyn883 FunPtr (GLuint -> Ptr GLshort -> IO ())
ptr_glVertexAttrib3sv GLuint
v1 Ptr GLshort
v2

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

-- glVertexAttrib3svARB --------------------------------------------------------

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

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

-- glVertexAttrib3svNV ---------------------------------------------------------

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

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

-- glVertexAttrib4Nbv ----------------------------------------------------------

-- | 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>.
glVertexAttrib4Nbv
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> Ptr GLbyte -- ^ @v@ pointing to @4@ elements of type @GLbyte@.
  -> m ()
glVertexAttrib4Nbv :: GLuint -> Ptr GLbyte -> m ()
glVertexAttrib4Nbv GLuint
v1 Ptr GLbyte
v2 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> Ptr GLbyte -> IO ())
-> GLuint -> Ptr GLbyte -> IO ()
dyn881 FunPtr (GLuint -> Ptr GLbyte -> IO ())
ptr_glVertexAttrib4Nbv GLuint
v1 Ptr GLbyte
v2

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

-- glVertexAttrib4NbvARB -------------------------------------------------------

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

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

-- glVertexAttrib4Niv ----------------------------------------------------------

-- | 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>.
glVertexAttrib4Niv
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> Ptr GLint -- ^ @v@ pointing to @4@ elements of type @GLint@.
  -> m ()
glVertexAttrib4Niv :: GLuint -> Ptr GLsizei -> m ()
glVertexAttrib4Niv GLuint
v1 Ptr GLsizei
v2 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> Ptr GLsizei -> IO ())
-> GLuint -> Ptr GLsizei -> IO ()
dyn741 FunPtr (GLuint -> Ptr GLsizei -> IO ())
ptr_glVertexAttrib4Niv GLuint
v1 Ptr GLsizei
v2

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

-- glVertexAttrib4NivARB -------------------------------------------------------

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

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

-- glVertexAttrib4Nsv ----------------------------------------------------------

-- | 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>.
glVertexAttrib4Nsv
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> Ptr GLshort -- ^ @v@ pointing to @4@ elements of type @GLshort@.
  -> m ()
glVertexAttrib4Nsv :: GLuint -> Ptr GLshort -> m ()
glVertexAttrib4Nsv GLuint
v1 Ptr GLshort
v2 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> Ptr GLshort -> IO ())
-> GLuint -> Ptr GLshort -> IO ()
dyn883 FunPtr (GLuint -> Ptr GLshort -> IO ())
ptr_glVertexAttrib4Nsv GLuint
v1 Ptr GLshort
v2

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

-- glVertexAttrib4NsvARB -------------------------------------------------------

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

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

-- glVertexAttrib4Nub ----------------------------------------------------------

-- | 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>.
glVertexAttrib4Nub
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> GLubyte -- ^ @x@.
  -> GLubyte -- ^ @y@.
  -> GLubyte -- ^ @z@.
  -> GLubyte -- ^ @w@.
  -> m ()
glVertexAttrib4Nub :: GLuint -> GLubyte -> GLubyte -> GLubyte -> GLubyte -> m ()
glVertexAttrib4Nub GLuint
v1 GLubyte
v2 GLubyte
v3 GLubyte
v4 GLubyte
v5 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
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_glVertexAttrib4Nub GLuint
v1 GLubyte
v2 GLubyte
v3 GLubyte
v4 GLubyte
v5

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

-- glVertexAttrib4NubARB -------------------------------------------------------

-- | This command is an alias for 'glVertexAttrib4Nub'.
glVertexAttrib4NubARB
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> GLubyte -- ^ @x@.
  -> GLubyte -- ^ @y@.
  -> GLubyte -- ^ @z@.
  -> GLubyte -- ^ @w@.
  -> m ()
glVertexAttrib4NubARB :: GLuint -> GLubyte -> GLubyte -> GLubyte -> GLubyte -> m ()
glVertexAttrib4NubARB GLuint
v1 GLubyte
v2 GLubyte
v3 GLubyte
v4 GLubyte
v5 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
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_glVertexAttrib4NubARB GLuint
v1 GLubyte
v2 GLubyte
v3 GLubyte
v4 GLubyte
v5

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

-- glVertexAttrib4Nubv ---------------------------------------------------------

-- | 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>.
glVertexAttrib4Nubv
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> Ptr GLubyte -- ^ @v@ pointing to @4@ elements of type @GLubyte@.
  -> m ()
glVertexAttrib4Nubv :: GLuint -> Ptr GLubyte -> m ()
glVertexAttrib4Nubv GLuint
v1 Ptr GLubyte
v2 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> Ptr GLubyte -> IO ())
-> GLuint -> Ptr GLubyte -> IO ()
dyn393 FunPtr (GLuint -> Ptr GLubyte -> IO ())
ptr_glVertexAttrib4Nubv GLuint
v1 Ptr GLubyte
v2

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

-- glVertexAttrib4NubvARB ------------------------------------------------------

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

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

-- glVertexAttrib4Nuiv ---------------------------------------------------------

-- | 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>.
glVertexAttrib4Nuiv
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> Ptr GLuint -- ^ @v@ pointing to @4@ elements of type @GLuint@.
  -> m ()
glVertexAttrib4Nuiv :: GLuint -> Ptr GLuint -> m ()
glVertexAttrib4Nuiv GLuint
v1 Ptr GLuint
v2 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> Ptr GLuint -> IO ())
-> GLuint -> Ptr GLuint -> IO ()
dyn201 FunPtr (GLuint -> Ptr GLuint -> IO ())
ptr_glVertexAttrib4Nuiv GLuint
v1 Ptr GLuint
v2

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

-- glVertexAttrib4NuivARB ------------------------------------------------------

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

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

-- glVertexAttrib4Nusv ---------------------------------------------------------

-- | 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>.
glVertexAttrib4Nusv
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> Ptr GLushort -- ^ @v@ pointing to @4@ elements of type @GLushort@.
  -> m ()
glVertexAttrib4Nusv :: GLuint -> Ptr GLushort -> m ()
glVertexAttrib4Nusv GLuint
v1 Ptr GLushort
v2 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> Ptr GLushort -> IO ())
-> GLuint -> Ptr GLushort -> IO ()
dyn884 FunPtr (GLuint -> Ptr GLushort -> IO ())
ptr_glVertexAttrib4Nusv GLuint
v1 Ptr GLushort
v2

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

-- glVertexAttrib4NusvARB ------------------------------------------------------

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

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

-- glVertexAttrib4bv -----------------------------------------------------------

-- | 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>.
glVertexAttrib4bv
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> Ptr GLbyte -- ^ @v@ pointing to @4@ elements of type @GLbyte@.
  -> m ()
glVertexAttrib4bv :: GLuint -> Ptr GLbyte -> m ()
glVertexAttrib4bv GLuint
v1 Ptr GLbyte
v2 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> Ptr GLbyte -> IO ())
-> GLuint -> Ptr GLbyte -> IO ()
dyn881 FunPtr (GLuint -> Ptr GLbyte -> IO ())
ptr_glVertexAttrib4bv GLuint
v1 Ptr GLbyte
v2

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

-- glVertexAttrib4bvARB --------------------------------------------------------

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

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

-- glVertexAttrib4d ------------------------------------------------------------

-- | 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>. The vector equivalent of this command is 'glVertexAttrib4dv'.
glVertexAttrib4d
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> GLdouble -- ^ @x@.
  -> GLdouble -- ^ @y@.
  -> GLdouble -- ^ @z@.
  -> GLdouble -- ^ @w@.
  -> m ()
glVertexAttrib4d :: GLuint -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> m ()
glVertexAttrib4d GLuint
v1 GLdouble
v2 GLdouble
v3 GLdouble
v4 GLdouble
v5 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
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_glVertexAttrib4d GLuint
v1 GLdouble
v2 GLdouble
v3 GLdouble
v4 GLdouble
v5

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

-- glVertexAttrib4dARB ---------------------------------------------------------

-- | The vector equivalent of this command is 'glVertexAttrib4dvARB'. This command is an alias for 'glVertexAttrib4d'.
glVertexAttrib4dARB
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> GLdouble -- ^ @x@.
  -> GLdouble -- ^ @y@.
  -> GLdouble -- ^ @z@.
  -> GLdouble -- ^ @w@.
  -> m ()
glVertexAttrib4dARB :: GLuint -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> m ()
glVertexAttrib4dARB GLuint
v1 GLdouble
v2 GLdouble
v3 GLdouble
v4 GLdouble
v5 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
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_glVertexAttrib4dARB GLuint
v1 GLdouble
v2 GLdouble
v3 GLdouble
v4 GLdouble
v5

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

-- glVertexAttrib4dNV ----------------------------------------------------------

-- | The vector equivalent of this command is 'glVertexAttrib4dvNV'. This command is an alias for 'glVertexAttrib4d'.
glVertexAttrib4dNV
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> GLdouble -- ^ @x@.
  -> GLdouble -- ^ @y@.
  -> GLdouble -- ^ @z@.
  -> GLdouble -- ^ @w@.
  -> m ()
glVertexAttrib4dNV :: GLuint -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> m ()
glVertexAttrib4dNV GLuint
v1 GLdouble
v2 GLdouble
v3 GLdouble
v4 GLdouble
v5 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
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_glVertexAttrib4dNV GLuint
v1 GLdouble
v2 GLdouble
v3 GLdouble
v4 GLdouble
v5

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

-- glVertexAttrib4dv -----------------------------------------------------------

-- | 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>.
glVertexAttrib4dv
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> Ptr GLdouble -- ^ @v@ pointing to @4@ elements of type @GLdouble@.
  -> m ()
glVertexAttrib4dv :: GLuint -> Ptr GLdouble -> m ()
glVertexAttrib4dv GLuint
v1 Ptr GLdouble
v2 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> Ptr GLdouble -> IO ())
-> GLuint -> Ptr GLdouble -> IO ()
dyn882 FunPtr (GLuint -> Ptr GLdouble -> IO ())
ptr_glVertexAttrib4dv GLuint
v1 Ptr GLdouble
v2

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

-- glVertexAttrib4dvARB --------------------------------------------------------

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

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

-- glVertexAttrib4dvNV ---------------------------------------------------------

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

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

-- glVertexAttrib4f ------------------------------------------------------------

-- | 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>. The vector equivalent of this command is 'glVertexAttrib4fv'.
glVertexAttrib4f
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> GLfloat -- ^ @x@.
  -> GLfloat -- ^ @y@.
  -> GLfloat -- ^ @z@.
  -> GLfloat -- ^ @w@.
  -> m ()
glVertexAttrib4f :: GLuint -> GLfloat -> GLfloat -> GLfloat -> GLfloat -> m ()
glVertexAttrib4f GLuint
v1 GLfloat
v2 GLfloat
v3 GLfloat
v4 GLfloat
v5 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr
  (GLuint -> GLfloat -> GLfloat -> GLfloat -> GLfloat -> IO ())
-> GLuint -> GLfloat -> GLfloat -> GLfloat -> GLfloat -> IO ()
dyn907 FunPtr
  (GLuint -> GLfloat -> GLfloat -> GLfloat -> GLfloat -> IO ())
ptr_glVertexAttrib4f GLuint
v1 GLfloat
v2 GLfloat
v3 GLfloat
v4 GLfloat
v5

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

-- glVertexAttrib4fARB ---------------------------------------------------------

-- | The vector equivalent of this command is 'glVertexAttrib4fvARB'. This command is an alias for 'glVertexAttrib4f'.
glVertexAttrib4fARB
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> GLfloat -- ^ @x@.
  -> GLfloat -- ^ @y@.
  -> GLfloat -- ^ @z@.
  -> GLfloat -- ^ @w@.
  -> m ()
glVertexAttrib4fARB :: GLuint -> GLfloat -> GLfloat -> GLfloat -> GLfloat -> m ()
glVertexAttrib4fARB GLuint
v1 GLfloat
v2 GLfloat
v3 GLfloat
v4 GLfloat
v5 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr
  (GLuint -> GLfloat -> GLfloat -> GLfloat -> GLfloat -> IO ())
-> GLuint -> GLfloat -> GLfloat -> GLfloat -> GLfloat -> IO ()
dyn907 FunPtr
  (GLuint -> GLfloat -> GLfloat -> GLfloat -> GLfloat -> IO ())
ptr_glVertexAttrib4fARB GLuint
v1 GLfloat
v2 GLfloat
v3 GLfloat
v4 GLfloat
v5

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

-- glVertexAttrib4fNV ----------------------------------------------------------

-- | The vector equivalent of this command is 'glVertexAttrib4fvNV'. This command is an alias for 'glVertexAttrib4f'.
glVertexAttrib4fNV
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> GLfloat -- ^ @x@.
  -> GLfloat -- ^ @y@.
  -> GLfloat -- ^ @z@.
  -> GLfloat -- ^ @w@.
  -> m ()
glVertexAttrib4fNV :: GLuint -> GLfloat -> GLfloat -> GLfloat -> GLfloat -> m ()
glVertexAttrib4fNV GLuint
v1 GLfloat
v2 GLfloat
v3 GLfloat
v4 GLfloat
v5 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr
  (GLuint -> GLfloat -> GLfloat -> GLfloat -> GLfloat -> IO ())
-> GLuint -> GLfloat -> GLfloat -> GLfloat -> GLfloat -> IO ()
dyn907 FunPtr
  (GLuint -> GLfloat -> GLfloat -> GLfloat -> GLfloat -> IO ())
ptr_glVertexAttrib4fNV GLuint
v1 GLfloat
v2 GLfloat
v3 GLfloat
v4 GLfloat
v5

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

-- glVertexAttrib4fv -----------------------------------------------------------

-- | 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>.
glVertexAttrib4fv
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> Ptr GLfloat -- ^ @v@ pointing to @4@ elements of type @GLfloat@.
  -> m ()
glVertexAttrib4fv :: GLuint -> Ptr GLfloat -> m ()
glVertexAttrib4fv GLuint
v1 Ptr GLfloat
v2 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> Ptr GLfloat -> IO ())
-> GLuint -> Ptr GLfloat -> IO ()
dyn394 FunPtr (GLuint -> Ptr GLfloat -> IO ())
ptr_glVertexAttrib4fv GLuint
v1 Ptr GLfloat
v2

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

-- glVertexAttrib4fvARB --------------------------------------------------------

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

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

-- glVertexAttrib4fvNV ---------------------------------------------------------

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

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

-- glVertexAttrib4hNV ----------------------------------------------------------

-- | The vector equivalent of this command is 'glVertexAttrib4hvNV'.
glVertexAttrib4hNV
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> GLhalfNV -- ^ @x@ of type @Half16NV@.
  -> GLhalfNV -- ^ @y@ of type @Half16NV@.
  -> GLhalfNV -- ^ @z@ of type @Half16NV@.
  -> GLhalfNV -- ^ @w@ of type @Half16NV@.
  -> m ()
glVertexAttrib4hNV :: GLuint -> GLhalfNV -> GLhalfNV -> GLhalfNV -> GLhalfNV -> m ()
glVertexAttrib4hNV GLuint
v1 GLhalfNV
v2 GLhalfNV
v3 GLhalfNV
v4 GLhalfNV
v5 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr
  (GLuint -> GLhalfNV -> GLhalfNV -> GLhalfNV -> GLhalfNV -> IO ())
-> GLuint -> GLhalfNV -> GLhalfNV -> GLhalfNV -> GLhalfNV -> IO ()
dyn908 FunPtr
  (GLuint -> GLhalfNV -> GLhalfNV -> GLhalfNV -> GLhalfNV -> IO ())
ptr_glVertexAttrib4hNV GLuint
v1 GLhalfNV
v2 GLhalfNV
v3 GLhalfNV
v4 GLhalfNV
v5

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

-- glVertexAttrib4hvNV ---------------------------------------------------------

glVertexAttrib4hvNV
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> Ptr GLhalfNV -- ^ @v@ pointing to @4@ elements of type @Half16NV@.
  -> m ()
glVertexAttrib4hvNV :: GLuint -> Ptr GLhalfNV -> m ()
glVertexAttrib4hvNV GLuint
v1 Ptr GLhalfNV
v2 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> Ptr GLhalfNV -> IO ())
-> GLuint -> Ptr GLhalfNV -> IO ()
dyn898 FunPtr (GLuint -> Ptr GLhalfNV -> IO ())
ptr_glVertexAttrib4hvNV GLuint
v1 Ptr GLhalfNV
v2

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

-- glVertexAttrib4iv -----------------------------------------------------------

-- | 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>.
glVertexAttrib4iv
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> Ptr GLint -- ^ @v@ pointing to @4@ elements of type @GLint@.
  -> m ()
glVertexAttrib4iv :: GLuint -> Ptr GLsizei -> m ()
glVertexAttrib4iv GLuint
v1 Ptr GLsizei
v2 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> Ptr GLsizei -> IO ())
-> GLuint -> Ptr GLsizei -> IO ()
dyn741 FunPtr (GLuint -> Ptr GLsizei -> IO ())
ptr_glVertexAttrib4iv GLuint
v1 Ptr GLsizei
v2

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

-- glVertexAttrib4ivARB --------------------------------------------------------

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

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

-- glVertexAttrib4s ------------------------------------------------------------

-- | 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>. The vector equivalent of this command is 'glVertexAttrib4sv'.
glVertexAttrib4s
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> GLshort -- ^ @x@.
  -> GLshort -- ^ @y@.
  -> GLshort -- ^ @z@.
  -> GLshort -- ^ @w@.
  -> m ()
glVertexAttrib4s :: GLuint -> GLshort -> GLshort -> GLshort -> GLshort -> m ()
glVertexAttrib4s GLuint
v1 GLshort
v2 GLshort
v3 GLshort
v4 GLshort
v5 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr
  (GLuint -> GLshort -> GLshort -> GLshort -> GLshort -> IO ())
-> GLuint -> GLshort -> GLshort -> GLshort -> GLshort -> IO ()
dyn909 FunPtr
  (GLuint -> GLshort -> GLshort -> GLshort -> GLshort -> IO ())
ptr_glVertexAttrib4s GLuint
v1 GLshort
v2 GLshort
v3 GLshort
v4 GLshort
v5

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

-- glVertexAttrib4sARB ---------------------------------------------------------

-- | The vector equivalent of this command is 'glVertexAttrib4svARB'. This command is an alias for 'glVertexAttrib4s'.
glVertexAttrib4sARB
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> GLshort -- ^ @x@.
  -> GLshort -- ^ @y@.
  -> GLshort -- ^ @z@.
  -> GLshort -- ^ @w@.
  -> m ()
glVertexAttrib4sARB :: GLuint -> GLshort -> GLshort -> GLshort -> GLshort -> m ()
glVertexAttrib4sARB GLuint
v1 GLshort
v2 GLshort
v3 GLshort
v4 GLshort
v5 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr
  (GLuint -> GLshort -> GLshort -> GLshort -> GLshort -> IO ())
-> GLuint -> GLshort -> GLshort -> GLshort -> GLshort -> IO ()
dyn909 FunPtr
  (GLuint -> GLshort -> GLshort -> GLshort -> GLshort -> IO ())
ptr_glVertexAttrib4sARB GLuint
v1 GLshort
v2 GLshort
v3 GLshort
v4 GLshort
v5

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

-- glVertexAttrib4sNV ----------------------------------------------------------

-- | The vector equivalent of this command is 'glVertexAttrib4svNV'. This command is an alias for 'glVertexAttrib4s'.
glVertexAttrib4sNV
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> GLshort -- ^ @x@.
  -> GLshort -- ^ @y@.
  -> GLshort -- ^ @z@.
  -> GLshort -- ^ @w@.
  -> m ()
glVertexAttrib4sNV :: GLuint -> GLshort -> GLshort -> GLshort -> GLshort -> m ()
glVertexAttrib4sNV GLuint
v1 GLshort
v2 GLshort
v3 GLshort
v4 GLshort
v5 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr
  (GLuint -> GLshort -> GLshort -> GLshort -> GLshort -> IO ())
-> GLuint -> GLshort -> GLshort -> GLshort -> GLshort -> IO ()
dyn909 FunPtr
  (GLuint -> GLshort -> GLshort -> GLshort -> GLshort -> IO ())
ptr_glVertexAttrib4sNV GLuint
v1 GLshort
v2 GLshort
v3 GLshort
v4 GLshort
v5

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

-- glVertexAttrib4sv -----------------------------------------------------------

-- | 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>.
glVertexAttrib4sv
  :: MonadIO m
  => GLuint -- ^ @index@.
  -> Ptr GLshort -- ^ @v@ pointing to @4@ elements of type @GLshort@.
  -> m ()
glVertexAttrib4sv :: GLuint -> Ptr GLshort -> m ()
glVertexAttrib4sv GLuint
v1 Ptr GLshort
v2 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (GLuint -> Ptr GLshort -> IO ())
-> GLuint -> Ptr GLshort -> IO ()
dyn883 FunPtr (GLuint -> Ptr GLshort -> IO ())
ptr_glVertexAttrib4sv GLuint
v1 Ptr GLshort
v2

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