-- This file was automatically generated.
{-# LANGUAGE CPP, ScopedTypeVariables, PatternSynonyms #-}
module Graphics.GL.Ext.NV.BlendEquationAdvanced (
  -- * Extension Support
    gl_NV_blend_equation_advanced

  -- * GL_NV_blend_equation_advanced
  , glBlendBarrierNV
  , glBlendParameteriNV
  , pattern GL_BLEND_OVERLAP_NV
  , pattern GL_BLEND_PREMULTIPLIED_SRC_NV
  , pattern GL_BLUE_NV
  , pattern GL_COLORBURN_NV
  , pattern GL_COLORDODGE_NV
  , pattern GL_CONJOINT_NV
  , pattern GL_CONTRAST_NV
  , pattern GL_DARKEN_NV
  , pattern GL_DIFFERENCE_NV
  , pattern GL_DISJOINT_NV
  , pattern GL_DST_ATOP_NV
  , pattern GL_DST_IN_NV
  , pattern GL_DST_NV
  , pattern GL_DST_OUT_NV
  , pattern GL_DST_OVER_NV
  , pattern GL_EXCLUSION_NV
  , pattern GL_GREEN_NV
  , pattern GL_HARDLIGHT_NV
  , pattern GL_HARDMIX_NV
  , pattern GL_HSL_COLOR_NV
  , pattern GL_HSL_HUE_NV
  , pattern GL_HSL_LUMINOSITY_NV
  , pattern GL_HSL_SATURATION_NV
  , pattern GL_INVERT
  , pattern GL_INVERT_OVG_NV
  , pattern GL_INVERT_RGB_NV
  , pattern GL_LIGHTEN_NV
  , pattern GL_LINEARBURN_NV
  , pattern GL_LINEARDODGE_NV
  , pattern GL_LINEARLIGHT_NV
  , pattern GL_MINUS_CLAMPED_NV
  , pattern GL_MINUS_NV
  , pattern GL_MULTIPLY_NV
  , pattern GL_OVERLAY_NV
  , pattern GL_PINLIGHT_NV
  , pattern GL_PLUS_CLAMPED_ALPHA_NV
  , pattern GL_PLUS_CLAMPED_NV
  , pattern GL_PLUS_DARKER_NV
  , pattern GL_PLUS_NV
  , pattern GL_RED_NV
  , pattern GL_SCREEN_NV
  , pattern GL_SOFTLIGHT_NV
  , pattern GL_SRC_ATOP_NV
  , pattern GL_SRC_IN_NV
  , pattern GL_SRC_NV
  , pattern GL_SRC_OUT_NV
  , pattern GL_SRC_OVER_NV
  , pattern GL_UNCORRELATED_NV
  , pattern GL_VIVIDLIGHT_NV
  , pattern GL_XOR_NV
  , pattern GL_ZERO
) where

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

-- | Checks that the <https://cvs.khronos.org/svn/repos/ogl/trunk/doc/registry/public/specs/NV/blend_equation_advanced.txt GL_NV_blend_equation_advanced> extension is available.

gl_NV_blend_equation_advanced :: Bool
gl_NV_blend_equation_advanced :: Bool
gl_NV_blend_equation_advanced = String -> Set String -> Bool
forall a. Ord a => a -> Set a -> Bool
member String
"GL_NV_blend_equation_advanced" Set String
extensions
{-# NOINLINE gl_NV_blend_equation_advanced #-}

-- | Usage: @'glBlendBarrierNV'@
--
-- This command is an alias for 'Graphics.GL.Embedded32.glBlendBarrier'.


glBlendBarrierNV :: MonadIO m => m ()
glBlendBarrierNV :: forall (m :: * -> *). MonadIO m => m ()
glBlendBarrierNV = FunPtr (IO ()) -> m ()
forall (m :: * -> *). MonadIO m => FunPtr (IO ()) -> m ()
ffiIOV FunPtr (IO ())
glBlendBarrierNVFunPtr

glBlendBarrierNVFunPtr :: FunPtr (IO ())
glBlendBarrierNVFunPtr :: FunPtr (IO ())
glBlendBarrierNVFunPtr = IO (FunPtr (IO ())) -> FunPtr (IO ())
forall a. IO a -> a
unsafePerformIO (String -> IO (FunPtr (IO ()))
forall a. String -> IO (FunPtr a)
getProcAddress String
"glBlendBarrierNV")

{-# NOINLINE glBlendBarrierNVFunPtr #-}

-- | Usage: @'glBlendParameteriNV' pname value@


glBlendParameteriNV :: MonadIO m => GLenum -> GLint -> m ()
glBlendParameteriNV :: forall (m :: * -> *). MonadIO m => GLenum -> GLint -> m ()
glBlendParameteriNV = FunPtr (GLenum -> GLint -> IO ()) -> GLenum -> GLint -> m ()
forall (m :: * -> *).
MonadIO m =>
FunPtr (GLenum -> GLint -> IO ()) -> GLenum -> GLint -> m ()
ffienumintIOV FunPtr (GLenum -> GLint -> IO ())
glBlendParameteriNVFunPtr

glBlendParameteriNVFunPtr :: FunPtr (GLenum -> GLint -> IO ())
glBlendParameteriNVFunPtr :: FunPtr (GLenum -> GLint -> IO ())
glBlendParameteriNVFunPtr = IO (FunPtr (GLenum -> GLint -> IO ()))
-> FunPtr (GLenum -> GLint -> IO ())
forall a. IO a -> a
unsafePerformIO (String -> IO (FunPtr (GLenum -> GLint -> IO ()))
forall a. String -> IO (FunPtr a)
getProcAddress String
"glBlendParameteriNV")

{-# NOINLINE glBlendParameteriNVFunPtr #-}

pattern GL_BLEND_OVERLAP_NV  :: (Eq a, Num a) => a

pattern $mGL_BLEND_OVERLAP_NV :: forall {r} {a}.
(Eq a, Num a) =>
a -> ((# #) -> r) -> ((# #) -> r) -> r
$bGL_BLEND_OVERLAP_NV :: forall a. (Eq a, Num a) => a
GL_BLEND_OVERLAP_NV = 0x9281

pattern GL_BLEND_PREMULTIPLIED_SRC_NV  :: (Eq a, Num a) => a

pattern $mGL_BLEND_PREMULTIPLIED_SRC_NV :: forall {r} {a}.
(Eq a, Num a) =>
a -> ((# #) -> r) -> ((# #) -> r) -> r
$bGL_BLEND_PREMULTIPLIED_SRC_NV :: forall a. (Eq a, Num a) => a
GL_BLEND_PREMULTIPLIED_SRC_NV = 0x9280

pattern GL_BLUE_NV  :: (Eq a, Num a) => a

pattern $mGL_BLUE_NV :: forall {r} {a}.
(Eq a, Num a) =>
a -> ((# #) -> r) -> ((# #) -> r) -> r
$bGL_BLUE_NV :: forall a. (Eq a, Num a) => a
GL_BLUE_NV = 0x1905

pattern GL_COLORBURN_NV  :: (Eq a, Num a) => a

pattern $mGL_COLORBURN_NV :: forall {r} {a}.
(Eq a, Num a) =>
a -> ((# #) -> r) -> ((# #) -> r) -> r
$bGL_COLORBURN_NV :: forall a. (Eq a, Num a) => a
GL_COLORBURN_NV = 0x929A

pattern GL_COLORDODGE_NV  :: (Eq a, Num a) => a

pattern $mGL_COLORDODGE_NV :: forall {r} {a}.
(Eq a, Num a) =>
a -> ((# #) -> r) -> ((# #) -> r) -> r
$bGL_COLORDODGE_NV :: forall a. (Eq a, Num a) => a
GL_COLORDODGE_NV = 0x9299

pattern GL_CONJOINT_NV  :: (Eq a, Num a) => a

pattern $mGL_CONJOINT_NV :: forall {r} {a}.
(Eq a, Num a) =>
a -> ((# #) -> r) -> ((# #) -> r) -> r
$bGL_CONJOINT_NV :: forall a. (Eq a, Num a) => a
GL_CONJOINT_NV = 0x9284

pattern GL_CONTRAST_NV  :: (Eq a, Num a) => a

pattern $mGL_CONTRAST_NV :: forall {r} {a}.
(Eq a, Num a) =>
a -> ((# #) -> r) -> ((# #) -> r) -> r
$bGL_CONTRAST_NV :: forall a. (Eq a, Num a) => a
GL_CONTRAST_NV = 0x92A1

pattern GL_DARKEN_NV  :: (Eq a, Num a) => a

pattern $mGL_DARKEN_NV :: forall {r} {a}.
(Eq a, Num a) =>
a -> ((# #) -> r) -> ((# #) -> r) -> r
$bGL_DARKEN_NV :: forall a. (Eq a, Num a) => a
GL_DARKEN_NV = 0x9297

pattern GL_DIFFERENCE_NV  :: (Eq a, Num a) => a

pattern $mGL_DIFFERENCE_NV :: forall {r} {a}.
(Eq a, Num a) =>
a -> ((# #) -> r) -> ((# #) -> r) -> r
$bGL_DIFFERENCE_NV :: forall a. (Eq a, Num a) => a
GL_DIFFERENCE_NV = 0x929E

pattern GL_DISJOINT_NV  :: (Eq a, Num a) => a

pattern $mGL_DISJOINT_NV :: forall {r} {a}.
(Eq a, Num a) =>
a -> ((# #) -> r) -> ((# #) -> r) -> r
$bGL_DISJOINT_NV :: forall a. (Eq a, Num a) => a
GL_DISJOINT_NV = 0x9283

pattern GL_DST_ATOP_NV  :: (Eq a, Num a) => a

pattern $mGL_DST_ATOP_NV :: forall {r} {a}.
(Eq a, Num a) =>
a -> ((# #) -> r) -> ((# #) -> r) -> r
$bGL_DST_ATOP_NV :: forall a. (Eq a, Num a) => a
GL_DST_ATOP_NV = 0x928F

pattern GL_DST_IN_NV  :: (Eq a, Num a) => a

pattern $mGL_DST_IN_NV :: forall {r} {a}.
(Eq a, Num a) =>
a -> ((# #) -> r) -> ((# #) -> r) -> r
$bGL_DST_IN_NV :: forall a. (Eq a, Num a) => a
GL_DST_IN_NV = 0x928B

pattern GL_DST_NV  :: (Eq a, Num a) => a

pattern $mGL_DST_NV :: forall {r} {a}.
(Eq a, Num a) =>
a -> ((# #) -> r) -> ((# #) -> r) -> r
$bGL_DST_NV :: forall a. (Eq a, Num a) => a
GL_DST_NV = 0x9287

pattern GL_DST_OUT_NV  :: (Eq a, Num a) => a

pattern $mGL_DST_OUT_NV :: forall {r} {a}.
(Eq a, Num a) =>
a -> ((# #) -> r) -> ((# #) -> r) -> r
$bGL_DST_OUT_NV :: forall a. (Eq a, Num a) => a
GL_DST_OUT_NV = 0x928D

pattern GL_DST_OVER_NV  :: (Eq a, Num a) => a

pattern $mGL_DST_OVER_NV :: forall {r} {a}.
(Eq a, Num a) =>
a -> ((# #) -> r) -> ((# #) -> r) -> r
$bGL_DST_OVER_NV :: forall a. (Eq a, Num a) => a
GL_DST_OVER_NV = 0x9289

pattern GL_EXCLUSION_NV  :: (Eq a, Num a) => a

pattern $mGL_EXCLUSION_NV :: forall {r} {a}.
(Eq a, Num a) =>
a -> ((# #) -> r) -> ((# #) -> r) -> r
$bGL_EXCLUSION_NV :: forall a. (Eq a, Num a) => a
GL_EXCLUSION_NV = 0x92A0

pattern GL_GREEN_NV  :: (Eq a, Num a) => a

pattern $mGL_GREEN_NV :: forall {r} {a}.
(Eq a, Num a) =>
a -> ((# #) -> r) -> ((# #) -> r) -> r
$bGL_GREEN_NV :: forall a. (Eq a, Num a) => a
GL_GREEN_NV = 0x1904

pattern GL_HARDLIGHT_NV  :: (Eq a, Num a) => a

pattern $mGL_HARDLIGHT_NV :: forall {r} {a}.
(Eq a, Num a) =>
a -> ((# #) -> r) -> ((# #) -> r) -> r
$bGL_HARDLIGHT_NV :: forall a. (Eq a, Num a) => a
GL_HARDLIGHT_NV = 0x929B

pattern GL_HARDMIX_NV  :: (Eq a, Num a) => a

pattern $mGL_HARDMIX_NV :: forall {r} {a}.
(Eq a, Num a) =>
a -> ((# #) -> r) -> ((# #) -> r) -> r
$bGL_HARDMIX_NV :: forall a. (Eq a, Num a) => a
GL_HARDMIX_NV = 0x92A9

pattern GL_HSL_COLOR_NV  :: (Eq a, Num a) => a

pattern $mGL_HSL_COLOR_NV :: forall {r} {a}.
(Eq a, Num a) =>
a -> ((# #) -> r) -> ((# #) -> r) -> r
$bGL_HSL_COLOR_NV :: forall a. (Eq a, Num a) => a
GL_HSL_COLOR_NV = 0x92AF

pattern GL_HSL_HUE_NV  :: (Eq a, Num a) => a

pattern $mGL_HSL_HUE_NV :: forall {r} {a}.
(Eq a, Num a) =>
a -> ((# #) -> r) -> ((# #) -> r) -> r
$bGL_HSL_HUE_NV :: forall a. (Eq a, Num a) => a
GL_HSL_HUE_NV = 0x92AD

pattern GL_HSL_LUMINOSITY_NV  :: (Eq a, Num a) => a

pattern $mGL_HSL_LUMINOSITY_NV :: forall {r} {a}.
(Eq a, Num a) =>
a -> ((# #) -> r) -> ((# #) -> r) -> r
$bGL_HSL_LUMINOSITY_NV :: forall a. (Eq a, Num a) => a
GL_HSL_LUMINOSITY_NV = 0x92B0

pattern GL_HSL_SATURATION_NV  :: (Eq a, Num a) => a

pattern $mGL_HSL_SATURATION_NV :: forall {r} {a}.
(Eq a, Num a) =>
a -> ((# #) -> r) -> ((# #) -> r) -> r
$bGL_HSL_SATURATION_NV :: forall a. (Eq a, Num a) => a
GL_HSL_SATURATION_NV = 0x92AE

pattern GL_INVERT_OVG_NV  :: (Eq a, Num a) => a

pattern $mGL_INVERT_OVG_NV :: forall {r} {a}.
(Eq a, Num a) =>
a -> ((# #) -> r) -> ((# #) -> r) -> r
$bGL_INVERT_OVG_NV :: forall a. (Eq a, Num a) => a
GL_INVERT_OVG_NV = 0x92B4

pattern GL_INVERT_RGB_NV  :: (Eq a, Num a) => a

pattern $mGL_INVERT_RGB_NV :: forall {r} {a}.
(Eq a, Num a) =>
a -> ((# #) -> r) -> ((# #) -> r) -> r
$bGL_INVERT_RGB_NV :: forall a. (Eq a, Num a) => a
GL_INVERT_RGB_NV = 0x92A3

pattern GL_LIGHTEN_NV  :: (Eq a, Num a) => a

pattern $mGL_LIGHTEN_NV :: forall {r} {a}.
(Eq a, Num a) =>
a -> ((# #) -> r) -> ((# #) -> r) -> r
$bGL_LIGHTEN_NV :: forall a. (Eq a, Num a) => a
GL_LIGHTEN_NV = 0x9298

pattern GL_LINEARBURN_NV  :: (Eq a, Num a) => a

pattern $mGL_LINEARBURN_NV :: forall {r} {a}.
(Eq a, Num a) =>
a -> ((# #) -> r) -> ((# #) -> r) -> r
$bGL_LINEARBURN_NV :: forall a. (Eq a, Num a) => a
GL_LINEARBURN_NV = 0x92A5

pattern GL_LINEARDODGE_NV  :: (Eq a, Num a) => a

pattern $mGL_LINEARDODGE_NV :: forall {r} {a}.
(Eq a, Num a) =>
a -> ((# #) -> r) -> ((# #) -> r) -> r
$bGL_LINEARDODGE_NV :: forall a. (Eq a, Num a) => a
GL_LINEARDODGE_NV = 0x92A4

pattern GL_LINEARLIGHT_NV  :: (Eq a, Num a) => a

pattern $mGL_LINEARLIGHT_NV :: forall {r} {a}.
(Eq a, Num a) =>
a -> ((# #) -> r) -> ((# #) -> r) -> r
$bGL_LINEARLIGHT_NV :: forall a. (Eq a, Num a) => a
GL_LINEARLIGHT_NV = 0x92A7

pattern GL_MINUS_CLAMPED_NV  :: (Eq a, Num a) => a

pattern $mGL_MINUS_CLAMPED_NV :: forall {r} {a}.
(Eq a, Num a) =>
a -> ((# #) -> r) -> ((# #) -> r) -> r
$bGL_MINUS_CLAMPED_NV :: forall a. (Eq a, Num a) => a
GL_MINUS_CLAMPED_NV = 0x92B3

pattern GL_MINUS_NV  :: (Eq a, Num a) => a

pattern $mGL_MINUS_NV :: forall {r} {a}.
(Eq a, Num a) =>
a -> ((# #) -> r) -> ((# #) -> r) -> r
$bGL_MINUS_NV :: forall a. (Eq a, Num a) => a
GL_MINUS_NV = 0x929F

pattern GL_MULTIPLY_NV  :: (Eq a, Num a) => a

pattern $mGL_MULTIPLY_NV :: forall {r} {a}.
(Eq a, Num a) =>
a -> ((# #) -> r) -> ((# #) -> r) -> r
$bGL_MULTIPLY_NV :: forall a. (Eq a, Num a) => a
GL_MULTIPLY_NV = 0x9294

pattern GL_OVERLAY_NV  :: (Eq a, Num a) => a

pattern $mGL_OVERLAY_NV :: forall {r} {a}.
(Eq a, Num a) =>
a -> ((# #) -> r) -> ((# #) -> r) -> r
$bGL_OVERLAY_NV :: forall a. (Eq a, Num a) => a
GL_OVERLAY_NV = 0x9296

pattern GL_PINLIGHT_NV  :: (Eq a, Num a) => a

pattern $mGL_PINLIGHT_NV :: forall {r} {a}.
(Eq a, Num a) =>
a -> ((# #) -> r) -> ((# #) -> r) -> r
$bGL_PINLIGHT_NV :: forall a. (Eq a, Num a) => a
GL_PINLIGHT_NV = 0x92A8

pattern GL_PLUS_CLAMPED_ALPHA_NV  :: (Eq a, Num a) => a

pattern $mGL_PLUS_CLAMPED_ALPHA_NV :: forall {r} {a}.
(Eq a, Num a) =>
a -> ((# #) -> r) -> ((# #) -> r) -> r
$bGL_PLUS_CLAMPED_ALPHA_NV :: forall a. (Eq a, Num a) => a
GL_PLUS_CLAMPED_ALPHA_NV = 0x92B2

pattern GL_PLUS_CLAMPED_NV  :: (Eq a, Num a) => a

pattern $mGL_PLUS_CLAMPED_NV :: forall {r} {a}.
(Eq a, Num a) =>
a -> ((# #) -> r) -> ((# #) -> r) -> r
$bGL_PLUS_CLAMPED_NV :: forall a. (Eq a, Num a) => a
GL_PLUS_CLAMPED_NV = 0x92B1

pattern GL_PLUS_DARKER_NV  :: (Eq a, Num a) => a

pattern $mGL_PLUS_DARKER_NV :: forall {r} {a}.
(Eq a, Num a) =>
a -> ((# #) -> r) -> ((# #) -> r) -> r
$bGL_PLUS_DARKER_NV :: forall a. (Eq a, Num a) => a
GL_PLUS_DARKER_NV = 0x9292

pattern GL_PLUS_NV  :: (Eq a, Num a) => a

pattern $mGL_PLUS_NV :: forall {r} {a}.
(Eq a, Num a) =>
a -> ((# #) -> r) -> ((# #) -> r) -> r
$bGL_PLUS_NV :: forall a. (Eq a, Num a) => a
GL_PLUS_NV = 0x9291

pattern GL_RED_NV  :: (Eq a, Num a) => a

pattern $mGL_RED_NV :: forall {r} {a}.
(Eq a, Num a) =>
a -> ((# #) -> r) -> ((# #) -> r) -> r
$bGL_RED_NV :: forall a. (Eq a, Num a) => a
GL_RED_NV = 0x1903

pattern GL_SCREEN_NV  :: (Eq a, Num a) => a

pattern $mGL_SCREEN_NV :: forall {r} {a}.
(Eq a, Num a) =>
a -> ((# #) -> r) -> ((# #) -> r) -> r
$bGL_SCREEN_NV :: forall a. (Eq a, Num a) => a
GL_SCREEN_NV = 0x9295

pattern GL_SOFTLIGHT_NV  :: (Eq a, Num a) => a

pattern $mGL_SOFTLIGHT_NV :: forall {r} {a}.
(Eq a, Num a) =>
a -> ((# #) -> r) -> ((# #) -> r) -> r
$bGL_SOFTLIGHT_NV :: forall a. (Eq a, Num a) => a
GL_SOFTLIGHT_NV = 0x929C

pattern GL_SRC_ATOP_NV  :: (Eq a, Num a) => a

pattern $mGL_SRC_ATOP_NV :: forall {r} {a}.
(Eq a, Num a) =>
a -> ((# #) -> r) -> ((# #) -> r) -> r
$bGL_SRC_ATOP_NV :: forall a. (Eq a, Num a) => a
GL_SRC_ATOP_NV = 0x928E

pattern GL_SRC_IN_NV  :: (Eq a, Num a) => a

pattern $mGL_SRC_IN_NV :: forall {r} {a}.
(Eq a, Num a) =>
a -> ((# #) -> r) -> ((# #) -> r) -> r
$bGL_SRC_IN_NV :: forall a. (Eq a, Num a) => a
GL_SRC_IN_NV = 0x928A

pattern GL_SRC_NV  :: (Eq a, Num a) => a

pattern $mGL_SRC_NV :: forall {r} {a}.
(Eq a, Num a) =>
a -> ((# #) -> r) -> ((# #) -> r) -> r
$bGL_SRC_NV :: forall a. (Eq a, Num a) => a
GL_SRC_NV = 0x9286

pattern GL_SRC_OUT_NV  :: (Eq a, Num a) => a

pattern $mGL_SRC_OUT_NV :: forall {r} {a}.
(Eq a, Num a) =>
a -> ((# #) -> r) -> ((# #) -> r) -> r
$bGL_SRC_OUT_NV :: forall a. (Eq a, Num a) => a
GL_SRC_OUT_NV = 0x928C

pattern GL_SRC_OVER_NV  :: (Eq a, Num a) => a

pattern $mGL_SRC_OVER_NV :: forall {r} {a}.
(Eq a, Num a) =>
a -> ((# #) -> r) -> ((# #) -> r) -> r
$bGL_SRC_OVER_NV :: forall a. (Eq a, Num a) => a
GL_SRC_OVER_NV = 0x9288

pattern GL_UNCORRELATED_NV  :: (Eq a, Num a) => a

pattern $mGL_UNCORRELATED_NV :: forall {r} {a}.
(Eq a, Num a) =>
a -> ((# #) -> r) -> ((# #) -> r) -> r
$bGL_UNCORRELATED_NV :: forall a. (Eq a, Num a) => a
GL_UNCORRELATED_NV = 0x9282

pattern GL_VIVIDLIGHT_NV  :: (Eq a, Num a) => a

pattern $mGL_VIVIDLIGHT_NV :: forall {r} {a}.
(Eq a, Num a) =>
a -> ((# #) -> r) -> ((# #) -> r) -> r
$bGL_VIVIDLIGHT_NV :: forall a. (Eq a, Num a) => a
GL_VIVIDLIGHT_NV = 0x92A6

pattern GL_XOR_NV  :: (Eq a, Num a) => a

pattern $mGL_XOR_NV :: forall {r} {a}.
(Eq a, Num a) =>
a -> ((# #) -> r) -> ((# #) -> r) -> r
$bGL_XOR_NV :: forall a. (Eq a, Num a) => a
GL_XOR_NV = 0x1506