-- This file was automatically generated.
{-# LANGUAGE ScopedTypeVariables, PatternSynonyms #-}
module Graphics.GL.Raw.Extension.NV.HalfFloat (
  -- * Extension Support
    gl_NV_half_float

  -- * GL_NV_half_float
  , glColor3hNV
  , glColor3hvNV
  , glColor4hNV
  , glColor4hvNV
  , glFogCoordhNV
  , glFogCoordhvNV
  , glMultiTexCoord1hNV
  , glMultiTexCoord1hvNV
  , glMultiTexCoord2hNV
  , glMultiTexCoord2hvNV
  , glMultiTexCoord3hNV
  , glMultiTexCoord3hvNV
  , glMultiTexCoord4hNV
  , glMultiTexCoord4hvNV
  , glNormal3hNV
  , glNormal3hvNV
  , glSecondaryColor3hNV
  , glSecondaryColor3hvNV
  , glTexCoord1hNV
  , glTexCoord1hvNV
  , glTexCoord2hNV
  , glTexCoord2hvNV
  , glTexCoord3hNV
  , glTexCoord3hvNV
  , glTexCoord4hNV
  , glTexCoord4hvNV
  , glVertex2hNV
  , glVertex2hvNV
  , glVertex3hNV
  , glVertex3hvNV
  , glVertex4hNV
  , glVertex4hvNV
  , glVertexAttrib1hNV
  , glVertexAttrib1hvNV
  , glVertexAttrib2hNV
  , glVertexAttrib2hvNV
  , glVertexAttrib3hNV
  , glVertexAttrib3hvNV
  , glVertexAttrib4hNV
  , glVertexAttrib4hvNV
  , glVertexAttribs1hvNV
  , glVertexAttribs2hvNV
  , glVertexAttribs3hvNV
  , glVertexAttribs4hvNV
  , glVertexWeighthNV
  , glVertexWeighthvNV
  , pattern GL_HALF_FLOAT_NV
) where

import Control.Monad.IO.Class
import Data.Set
import Foreign.Ptr
import Graphics.GL.Raw.Internal.FFI
import Graphics.GL.Raw.Internal.Proc
import Graphics.GL.Raw.Types
import System.IO.Unsafe

gl_NV_half_float :: Bool
gl_NV_half_float = member "GL_NV_half_float" extensions

glColor3hNV :: MonadIO m => GLhalfNV -> GLhalfNV -> GLhalfNV -> m ()
glColor3hNV = ffihalfNVhalfNVhalfNVIOV glColor3hNVFunPtr

glColor3hNVFunPtr :: FunPtr (GLhalfNV -> GLhalfNV -> GLhalfNV -> IO ())
glColor3hNVFunPtr = unsafePerformIO (getProcAddress "glColor3hNV")

{-# NOINLINE glColor3hNVFunPtr #-}

glColor3hvNV :: MonadIO m => Ptr GLhalfNV -> m ()
glColor3hvNV = ffiPtrhalfNVIOV glColor3hvNVFunPtr

glColor3hvNVFunPtr :: FunPtr (Ptr GLhalfNV -> IO ())
glColor3hvNVFunPtr = unsafePerformIO (getProcAddress "glColor3hvNV")

{-# NOINLINE glColor3hvNVFunPtr #-}

glColor4hNV :: MonadIO m => GLhalfNV -> GLhalfNV -> GLhalfNV -> GLhalfNV -> m ()
glColor4hNV = ffihalfNVhalfNVhalfNVhalfNVIOV glColor4hNVFunPtr

glColor4hNVFunPtr :: FunPtr (GLhalfNV -> GLhalfNV -> GLhalfNV -> GLhalfNV -> IO ())
glColor4hNVFunPtr = unsafePerformIO (getProcAddress "glColor4hNV")

{-# NOINLINE glColor4hNVFunPtr #-}

glColor4hvNV :: MonadIO m => Ptr GLhalfNV -> m ()
glColor4hvNV = ffiPtrhalfNVIOV glColor4hvNVFunPtr

glColor4hvNVFunPtr :: FunPtr (Ptr GLhalfNV -> IO ())
glColor4hvNVFunPtr = unsafePerformIO (getProcAddress "glColor4hvNV")

{-# NOINLINE glColor4hvNVFunPtr #-}

glFogCoordhNV :: MonadIO m => GLhalfNV -> m ()
glFogCoordhNV = ffihalfNVIOV glFogCoordhNVFunPtr

glFogCoordhNVFunPtr :: FunPtr (GLhalfNV -> IO ())
glFogCoordhNVFunPtr = unsafePerformIO (getProcAddress "glFogCoordhNV")

{-# NOINLINE glFogCoordhNVFunPtr #-}

glFogCoordhvNV :: MonadIO m => Ptr GLhalfNV -> m ()
glFogCoordhvNV = ffiPtrhalfNVIOV glFogCoordhvNVFunPtr

glFogCoordhvNVFunPtr :: FunPtr (Ptr GLhalfNV -> IO ())
glFogCoordhvNVFunPtr = unsafePerformIO (getProcAddress "glFogCoordhvNV")

{-# NOINLINE glFogCoordhvNVFunPtr #-}

glMultiTexCoord1hNV :: MonadIO m => GLenum -> GLhalfNV -> m ()
glMultiTexCoord1hNV = ffienumhalfNVIOV glMultiTexCoord1hNVFunPtr

glMultiTexCoord1hNVFunPtr :: FunPtr (GLenum -> GLhalfNV -> IO ())
glMultiTexCoord1hNVFunPtr = unsafePerformIO (getProcAddress "glMultiTexCoord1hNV")

{-# NOINLINE glMultiTexCoord1hNVFunPtr #-}

glMultiTexCoord1hvNV :: MonadIO m => GLenum -> Ptr GLhalfNV -> m ()
glMultiTexCoord1hvNV = ffienumPtrhalfNVIOV glMultiTexCoord1hvNVFunPtr

glMultiTexCoord1hvNVFunPtr :: FunPtr (GLenum -> Ptr GLhalfNV -> IO ())
glMultiTexCoord1hvNVFunPtr = unsafePerformIO (getProcAddress "glMultiTexCoord1hvNV")

{-# NOINLINE glMultiTexCoord1hvNVFunPtr #-}

glMultiTexCoord2hNV :: MonadIO m => GLenum -> GLhalfNV -> GLhalfNV -> m ()
glMultiTexCoord2hNV = ffienumhalfNVhalfNVIOV glMultiTexCoord2hNVFunPtr

glMultiTexCoord2hNVFunPtr :: FunPtr (GLenum -> GLhalfNV -> GLhalfNV -> IO ())
glMultiTexCoord2hNVFunPtr = unsafePerformIO (getProcAddress "glMultiTexCoord2hNV")

{-# NOINLINE glMultiTexCoord2hNVFunPtr #-}

glMultiTexCoord2hvNV :: MonadIO m => GLenum -> Ptr GLhalfNV -> m ()
glMultiTexCoord2hvNV = ffienumPtrhalfNVIOV glMultiTexCoord2hvNVFunPtr

glMultiTexCoord2hvNVFunPtr :: FunPtr (GLenum -> Ptr GLhalfNV -> IO ())
glMultiTexCoord2hvNVFunPtr = unsafePerformIO (getProcAddress "glMultiTexCoord2hvNV")

{-# NOINLINE glMultiTexCoord2hvNVFunPtr #-}

glMultiTexCoord3hNV :: MonadIO m => GLenum -> GLhalfNV -> GLhalfNV -> GLhalfNV -> m ()
glMultiTexCoord3hNV = ffienumhalfNVhalfNVhalfNVIOV glMultiTexCoord3hNVFunPtr

glMultiTexCoord3hNVFunPtr :: FunPtr (GLenum -> GLhalfNV -> GLhalfNV -> GLhalfNV -> IO ())
glMultiTexCoord3hNVFunPtr = unsafePerformIO (getProcAddress "glMultiTexCoord3hNV")

{-# NOINLINE glMultiTexCoord3hNVFunPtr #-}

glMultiTexCoord3hvNV :: MonadIO m => GLenum -> Ptr GLhalfNV -> m ()
glMultiTexCoord3hvNV = ffienumPtrhalfNVIOV glMultiTexCoord3hvNVFunPtr

glMultiTexCoord3hvNVFunPtr :: FunPtr (GLenum -> Ptr GLhalfNV -> IO ())
glMultiTexCoord3hvNVFunPtr = unsafePerformIO (getProcAddress "glMultiTexCoord3hvNV")

{-# NOINLINE glMultiTexCoord3hvNVFunPtr #-}

glMultiTexCoord4hNV :: MonadIO m => GLenum -> GLhalfNV -> GLhalfNV -> GLhalfNV -> GLhalfNV -> m ()
glMultiTexCoord4hNV = ffienumhalfNVhalfNVhalfNVhalfNVIOV glMultiTexCoord4hNVFunPtr

glMultiTexCoord4hNVFunPtr :: FunPtr (GLenum -> GLhalfNV -> GLhalfNV -> GLhalfNV -> GLhalfNV -> IO ())
glMultiTexCoord4hNVFunPtr = unsafePerformIO (getProcAddress "glMultiTexCoord4hNV")

{-# NOINLINE glMultiTexCoord4hNVFunPtr #-}

glMultiTexCoord4hvNV :: MonadIO m => GLenum -> Ptr GLhalfNV -> m ()
glMultiTexCoord4hvNV = ffienumPtrhalfNVIOV glMultiTexCoord4hvNVFunPtr

glMultiTexCoord4hvNVFunPtr :: FunPtr (GLenum -> Ptr GLhalfNV -> IO ())
glMultiTexCoord4hvNVFunPtr = unsafePerformIO (getProcAddress "glMultiTexCoord4hvNV")

{-# NOINLINE glMultiTexCoord4hvNVFunPtr #-}

glNormal3hNV :: MonadIO m => GLhalfNV -> GLhalfNV -> GLhalfNV -> m ()
glNormal3hNV = ffihalfNVhalfNVhalfNVIOV glNormal3hNVFunPtr

glNormal3hNVFunPtr :: FunPtr (GLhalfNV -> GLhalfNV -> GLhalfNV -> IO ())
glNormal3hNVFunPtr = unsafePerformIO (getProcAddress "glNormal3hNV")

{-# NOINLINE glNormal3hNVFunPtr #-}

glNormal3hvNV :: MonadIO m => Ptr GLhalfNV -> m ()
glNormal3hvNV = ffiPtrhalfNVIOV glNormal3hvNVFunPtr

glNormal3hvNVFunPtr :: FunPtr (Ptr GLhalfNV -> IO ())
glNormal3hvNVFunPtr = unsafePerformIO (getProcAddress "glNormal3hvNV")

{-# NOINLINE glNormal3hvNVFunPtr #-}

glSecondaryColor3hNV :: MonadIO m => GLhalfNV -> GLhalfNV -> GLhalfNV -> m ()
glSecondaryColor3hNV = ffihalfNVhalfNVhalfNVIOV glSecondaryColor3hNVFunPtr

glSecondaryColor3hNVFunPtr :: FunPtr (GLhalfNV -> GLhalfNV -> GLhalfNV -> IO ())
glSecondaryColor3hNVFunPtr = unsafePerformIO (getProcAddress "glSecondaryColor3hNV")

{-# NOINLINE glSecondaryColor3hNVFunPtr #-}

glSecondaryColor3hvNV :: MonadIO m => Ptr GLhalfNV -> m ()
glSecondaryColor3hvNV = ffiPtrhalfNVIOV glSecondaryColor3hvNVFunPtr

glSecondaryColor3hvNVFunPtr :: FunPtr (Ptr GLhalfNV -> IO ())
glSecondaryColor3hvNVFunPtr = unsafePerformIO (getProcAddress "glSecondaryColor3hvNV")

{-# NOINLINE glSecondaryColor3hvNVFunPtr #-}

glTexCoord1hNV :: MonadIO m => GLhalfNV -> m ()
glTexCoord1hNV = ffihalfNVIOV glTexCoord1hNVFunPtr

glTexCoord1hNVFunPtr :: FunPtr (GLhalfNV -> IO ())
glTexCoord1hNVFunPtr = unsafePerformIO (getProcAddress "glTexCoord1hNV")

{-# NOINLINE glTexCoord1hNVFunPtr #-}

glTexCoord1hvNV :: MonadIO m => Ptr GLhalfNV -> m ()
glTexCoord1hvNV = ffiPtrhalfNVIOV glTexCoord1hvNVFunPtr

glTexCoord1hvNVFunPtr :: FunPtr (Ptr GLhalfNV -> IO ())
glTexCoord1hvNVFunPtr = unsafePerformIO (getProcAddress "glTexCoord1hvNV")

{-# NOINLINE glTexCoord1hvNVFunPtr #-}

glTexCoord2hNV :: MonadIO m => GLhalfNV -> GLhalfNV -> m ()
glTexCoord2hNV = ffihalfNVhalfNVIOV glTexCoord2hNVFunPtr

glTexCoord2hNVFunPtr :: FunPtr (GLhalfNV -> GLhalfNV -> IO ())
glTexCoord2hNVFunPtr = unsafePerformIO (getProcAddress "glTexCoord2hNV")

{-# NOINLINE glTexCoord2hNVFunPtr #-}

glTexCoord2hvNV :: MonadIO m => Ptr GLhalfNV -> m ()
glTexCoord2hvNV = ffiPtrhalfNVIOV glTexCoord2hvNVFunPtr

glTexCoord2hvNVFunPtr :: FunPtr (Ptr GLhalfNV -> IO ())
glTexCoord2hvNVFunPtr = unsafePerformIO (getProcAddress "glTexCoord2hvNV")

{-# NOINLINE glTexCoord2hvNVFunPtr #-}

glTexCoord3hNV :: MonadIO m => GLhalfNV -> GLhalfNV -> GLhalfNV -> m ()
glTexCoord3hNV = ffihalfNVhalfNVhalfNVIOV glTexCoord3hNVFunPtr

glTexCoord3hNVFunPtr :: FunPtr (GLhalfNV -> GLhalfNV -> GLhalfNV -> IO ())
glTexCoord3hNVFunPtr = unsafePerformIO (getProcAddress "glTexCoord3hNV")

{-# NOINLINE glTexCoord3hNVFunPtr #-}

glTexCoord3hvNV :: MonadIO m => Ptr GLhalfNV -> m ()
glTexCoord3hvNV = ffiPtrhalfNVIOV glTexCoord3hvNVFunPtr

glTexCoord3hvNVFunPtr :: FunPtr (Ptr GLhalfNV -> IO ())
glTexCoord3hvNVFunPtr = unsafePerformIO (getProcAddress "glTexCoord3hvNV")

{-# NOINLINE glTexCoord3hvNVFunPtr #-}

glTexCoord4hNV :: MonadIO m => GLhalfNV -> GLhalfNV -> GLhalfNV -> GLhalfNV -> m ()
glTexCoord4hNV = ffihalfNVhalfNVhalfNVhalfNVIOV glTexCoord4hNVFunPtr

glTexCoord4hNVFunPtr :: FunPtr (GLhalfNV -> GLhalfNV -> GLhalfNV -> GLhalfNV -> IO ())
glTexCoord4hNVFunPtr = unsafePerformIO (getProcAddress "glTexCoord4hNV")

{-# NOINLINE glTexCoord4hNVFunPtr #-}

glTexCoord4hvNV :: MonadIO m => Ptr GLhalfNV -> m ()
glTexCoord4hvNV = ffiPtrhalfNVIOV glTexCoord4hvNVFunPtr

glTexCoord4hvNVFunPtr :: FunPtr (Ptr GLhalfNV -> IO ())
glTexCoord4hvNVFunPtr = unsafePerformIO (getProcAddress "glTexCoord4hvNV")

{-# NOINLINE glTexCoord4hvNVFunPtr #-}

glVertex2hNV :: MonadIO m => GLhalfNV -> GLhalfNV -> m ()
glVertex2hNV = ffihalfNVhalfNVIOV glVertex2hNVFunPtr

glVertex2hNVFunPtr :: FunPtr (GLhalfNV -> GLhalfNV -> IO ())
glVertex2hNVFunPtr = unsafePerformIO (getProcAddress "glVertex2hNV")

{-# NOINLINE glVertex2hNVFunPtr #-}

glVertex2hvNV :: MonadIO m => Ptr GLhalfNV -> m ()
glVertex2hvNV = ffiPtrhalfNVIOV glVertex2hvNVFunPtr

glVertex2hvNVFunPtr :: FunPtr (Ptr GLhalfNV -> IO ())
glVertex2hvNVFunPtr = unsafePerformIO (getProcAddress "glVertex2hvNV")

{-# NOINLINE glVertex2hvNVFunPtr #-}

glVertex3hNV :: MonadIO m => GLhalfNV -> GLhalfNV -> GLhalfNV -> m ()
glVertex3hNV = ffihalfNVhalfNVhalfNVIOV glVertex3hNVFunPtr

glVertex3hNVFunPtr :: FunPtr (GLhalfNV -> GLhalfNV -> GLhalfNV -> IO ())
glVertex3hNVFunPtr = unsafePerformIO (getProcAddress "glVertex3hNV")

{-# NOINLINE glVertex3hNVFunPtr #-}

glVertex3hvNV :: MonadIO m => Ptr GLhalfNV -> m ()
glVertex3hvNV = ffiPtrhalfNVIOV glVertex3hvNVFunPtr

glVertex3hvNVFunPtr :: FunPtr (Ptr GLhalfNV -> IO ())
glVertex3hvNVFunPtr = unsafePerformIO (getProcAddress "glVertex3hvNV")

{-# NOINLINE glVertex3hvNVFunPtr #-}

glVertex4hNV :: MonadIO m => GLhalfNV -> GLhalfNV -> GLhalfNV -> GLhalfNV -> m ()
glVertex4hNV = ffihalfNVhalfNVhalfNVhalfNVIOV glVertex4hNVFunPtr

glVertex4hNVFunPtr :: FunPtr (GLhalfNV -> GLhalfNV -> GLhalfNV -> GLhalfNV -> IO ())
glVertex4hNVFunPtr = unsafePerformIO (getProcAddress "glVertex4hNV")

{-# NOINLINE glVertex4hNVFunPtr #-}

glVertex4hvNV :: MonadIO m => Ptr GLhalfNV -> m ()
glVertex4hvNV = ffiPtrhalfNVIOV glVertex4hvNVFunPtr

glVertex4hvNVFunPtr :: FunPtr (Ptr GLhalfNV -> IO ())
glVertex4hvNVFunPtr = unsafePerformIO (getProcAddress "glVertex4hvNV")

{-# NOINLINE glVertex4hvNVFunPtr #-}

glVertexAttrib1hNV :: MonadIO m => GLuint -> GLhalfNV -> m ()
glVertexAttrib1hNV = ffiuinthalfNVIOV glVertexAttrib1hNVFunPtr

glVertexAttrib1hNVFunPtr :: FunPtr (GLuint -> GLhalfNV -> IO ())
glVertexAttrib1hNVFunPtr = unsafePerformIO (getProcAddress "glVertexAttrib1hNV")

{-# NOINLINE glVertexAttrib1hNVFunPtr #-}

glVertexAttrib1hvNV :: MonadIO m => GLuint -> Ptr GLhalfNV -> m ()
glVertexAttrib1hvNV = ffiuintPtrhalfNVIOV glVertexAttrib1hvNVFunPtr

glVertexAttrib1hvNVFunPtr :: FunPtr (GLuint -> Ptr GLhalfNV -> IO ())
glVertexAttrib1hvNVFunPtr = unsafePerformIO (getProcAddress "glVertexAttrib1hvNV")

{-# NOINLINE glVertexAttrib1hvNVFunPtr #-}

glVertexAttrib2hNV :: MonadIO m => GLuint -> GLhalfNV -> GLhalfNV -> m ()
glVertexAttrib2hNV = ffiuinthalfNVhalfNVIOV glVertexAttrib2hNVFunPtr

glVertexAttrib2hNVFunPtr :: FunPtr (GLuint -> GLhalfNV -> GLhalfNV -> IO ())
glVertexAttrib2hNVFunPtr = unsafePerformIO (getProcAddress "glVertexAttrib2hNV")

{-# NOINLINE glVertexAttrib2hNVFunPtr #-}

glVertexAttrib2hvNV :: MonadIO m => GLuint -> Ptr GLhalfNV -> m ()
glVertexAttrib2hvNV = ffiuintPtrhalfNVIOV glVertexAttrib2hvNVFunPtr

glVertexAttrib2hvNVFunPtr :: FunPtr (GLuint -> Ptr GLhalfNV -> IO ())
glVertexAttrib2hvNVFunPtr = unsafePerformIO (getProcAddress "glVertexAttrib2hvNV")

{-# NOINLINE glVertexAttrib2hvNVFunPtr #-}

glVertexAttrib3hNV :: MonadIO m => GLuint -> GLhalfNV -> GLhalfNV -> GLhalfNV -> m ()
glVertexAttrib3hNV = ffiuinthalfNVhalfNVhalfNVIOV glVertexAttrib3hNVFunPtr

glVertexAttrib3hNVFunPtr :: FunPtr (GLuint -> GLhalfNV -> GLhalfNV -> GLhalfNV -> IO ())
glVertexAttrib3hNVFunPtr = unsafePerformIO (getProcAddress "glVertexAttrib3hNV")

{-# NOINLINE glVertexAttrib3hNVFunPtr #-}

glVertexAttrib3hvNV :: MonadIO m => GLuint -> Ptr GLhalfNV -> m ()
glVertexAttrib3hvNV = ffiuintPtrhalfNVIOV glVertexAttrib3hvNVFunPtr

glVertexAttrib3hvNVFunPtr :: FunPtr (GLuint -> Ptr GLhalfNV -> IO ())
glVertexAttrib3hvNVFunPtr = unsafePerformIO (getProcAddress "glVertexAttrib3hvNV")

{-# NOINLINE glVertexAttrib3hvNVFunPtr #-}

glVertexAttrib4hNV :: MonadIO m => GLuint -> GLhalfNV -> GLhalfNV -> GLhalfNV -> GLhalfNV -> m ()
glVertexAttrib4hNV = ffiuinthalfNVhalfNVhalfNVhalfNVIOV glVertexAttrib4hNVFunPtr

glVertexAttrib4hNVFunPtr :: FunPtr (GLuint -> GLhalfNV -> GLhalfNV -> GLhalfNV -> GLhalfNV -> IO ())
glVertexAttrib4hNVFunPtr = unsafePerformIO (getProcAddress "glVertexAttrib4hNV")

{-# NOINLINE glVertexAttrib4hNVFunPtr #-}

glVertexAttrib4hvNV :: MonadIO m => GLuint -> Ptr GLhalfNV -> m ()
glVertexAttrib4hvNV = ffiuintPtrhalfNVIOV glVertexAttrib4hvNVFunPtr

glVertexAttrib4hvNVFunPtr :: FunPtr (GLuint -> Ptr GLhalfNV -> IO ())
glVertexAttrib4hvNVFunPtr = unsafePerformIO (getProcAddress "glVertexAttrib4hvNV")

{-# NOINLINE glVertexAttrib4hvNVFunPtr #-}

glVertexAttribs1hvNV :: MonadIO m => GLuint -> GLsizei -> Ptr GLhalfNV -> m ()
glVertexAttribs1hvNV = ffiuintsizeiPtrhalfNVIOV glVertexAttribs1hvNVFunPtr

glVertexAttribs1hvNVFunPtr :: FunPtr (GLuint -> GLsizei -> Ptr GLhalfNV -> IO ())
glVertexAttribs1hvNVFunPtr = unsafePerformIO (getProcAddress "glVertexAttribs1hvNV")

{-# NOINLINE glVertexAttribs1hvNVFunPtr #-}

glVertexAttribs2hvNV :: MonadIO m => GLuint -> GLsizei -> Ptr GLhalfNV -> m ()
glVertexAttribs2hvNV = ffiuintsizeiPtrhalfNVIOV glVertexAttribs2hvNVFunPtr

glVertexAttribs2hvNVFunPtr :: FunPtr (GLuint -> GLsizei -> Ptr GLhalfNV -> IO ())
glVertexAttribs2hvNVFunPtr = unsafePerformIO (getProcAddress "glVertexAttribs2hvNV")

{-# NOINLINE glVertexAttribs2hvNVFunPtr #-}

glVertexAttribs3hvNV :: MonadIO m => GLuint -> GLsizei -> Ptr GLhalfNV -> m ()
glVertexAttribs3hvNV = ffiuintsizeiPtrhalfNVIOV glVertexAttribs3hvNVFunPtr

glVertexAttribs3hvNVFunPtr :: FunPtr (GLuint -> GLsizei -> Ptr GLhalfNV -> IO ())
glVertexAttribs3hvNVFunPtr = unsafePerformIO (getProcAddress "glVertexAttribs3hvNV")

{-# NOINLINE glVertexAttribs3hvNVFunPtr #-}

glVertexAttribs4hvNV :: MonadIO m => GLuint -> GLsizei -> Ptr GLhalfNV -> m ()
glVertexAttribs4hvNV = ffiuintsizeiPtrhalfNVIOV glVertexAttribs4hvNVFunPtr

glVertexAttribs4hvNVFunPtr :: FunPtr (GLuint -> GLsizei -> Ptr GLhalfNV -> IO ())
glVertexAttribs4hvNVFunPtr = unsafePerformIO (getProcAddress "glVertexAttribs4hvNV")

{-# NOINLINE glVertexAttribs4hvNVFunPtr #-}

glVertexWeighthNV :: MonadIO m => GLhalfNV -> m ()
glVertexWeighthNV = ffihalfNVIOV glVertexWeighthNVFunPtr

glVertexWeighthNVFunPtr :: FunPtr (GLhalfNV -> IO ())
glVertexWeighthNVFunPtr = unsafePerformIO (getProcAddress "glVertexWeighthNV")

{-# NOINLINE glVertexWeighthNVFunPtr #-}

glVertexWeighthvNV :: MonadIO m => Ptr GLhalfNV -> m ()
glVertexWeighthvNV = ffiPtrhalfNVIOV glVertexWeighthvNVFunPtr

glVertexWeighthvNVFunPtr :: FunPtr (Ptr GLhalfNV -> IO ())
glVertexWeighthvNVFunPtr = unsafePerformIO (getProcAddress "glVertexWeighthvNV")

{-# NOINLINE glVertexWeighthvNVFunPtr #-}

pattern GL_HALF_FLOAT_NV = 0x140B