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

module Graphics.Rendering.OpenGL.GL.Colors (
   -- * Lighting
   lighting, Light(..), light, maxLights,
   FrontFaceDirection(..), frontFace,

   -- * Lighting Parameter Specification
   Face(..),
   materialAmbient, materialDiffuse, materialAmbientAndDiffuse,
   materialSpecular, materialEmission, materialShininess, maxShininess,
   materialColorIndexes,

   ambient, diffuse, specular,
   position, spotDirection, spotExponent, maxSpotExponent, spotCutoff,
   attenuation,

   lightModelAmbient, lightModelLocalViewer, lightModelTwoSide,
   vertexProgramTwoSide,
   LightModelColorControl(..), lightModelColorControl,

   -- * ColorMaterial
   ColorMaterialParameter(..), colorMaterial,

   -- * Flatshading
   ShadingModel(..), shadeModel,

   -- * Color clamping
   ClampTarget(..), ClampMode(..),
   clampColor,
) where

import Control.Monad
import Data.StateVar
import Foreign.Marshal.Alloc
import Foreign.Marshal.Array
import Foreign.Marshal.Utils
import Foreign.Ptr
import Foreign.Storable
import Graphics.Rendering.OpenGL.GL.Tensor
import Graphics.Rendering.OpenGL.GL.Capability
import Graphics.Rendering.OpenGL.GL.Face
import Graphics.Rendering.OpenGL.GL.PeekPoke
import Graphics.Rendering.OpenGL.GL.QueryUtils
import Graphics.Rendering.OpenGL.GL.VertexSpec
import Graphics.Rendering.OpenGL.GLU.ErrorsInternal
import Graphics.GL

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

lighting :: StateVar Capability
lighting :: StateVar Capability
lighting = EnableCap -> StateVar Capability
makeCapability EnableCap
CapLighting

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

newtype Light = Light GLsizei
   deriving ( Light -> Light -> Bool
(Light -> Light -> Bool) -> (Light -> Light -> Bool) -> Eq Light
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Light -> Light -> Bool
$c/= :: Light -> Light -> Bool
== :: Light -> Light -> Bool
$c== :: Light -> Light -> Bool
Eq, Eq Light
Eq Light =>
(Light -> Light -> Ordering)
-> (Light -> Light -> Bool)
-> (Light -> Light -> Bool)
-> (Light -> Light -> Bool)
-> (Light -> Light -> Bool)
-> (Light -> Light -> Light)
-> (Light -> Light -> Light)
-> Ord Light
Light -> Light -> Bool
Light -> Light -> Ordering
Light -> Light -> Light
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Light -> Light -> Light
$cmin :: Light -> Light -> Light
max :: Light -> Light -> Light
$cmax :: Light -> Light -> Light
>= :: Light -> Light -> Bool
$c>= :: Light -> Light -> Bool
> :: Light -> Light -> Bool
$c> :: Light -> Light -> Bool
<= :: Light -> Light -> Bool
$c<= :: Light -> Light -> Bool
< :: Light -> Light -> Bool
$c< :: Light -> Light -> Bool
compare :: Light -> Light -> Ordering
$ccompare :: Light -> Light -> Ordering
$cp1Ord :: Eq Light
Ord, Int -> Light -> ShowS
[Light] -> ShowS
Light -> String
(Int -> Light -> ShowS)
-> (Light -> String) -> ([Light] -> ShowS) -> Show Light
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Light] -> ShowS
$cshowList :: [Light] -> ShowS
show :: Light -> String
$cshow :: Light -> String
showsPrec :: Int -> Light -> ShowS
$cshowsPrec :: Int -> Light -> ShowS
Show )

marshalLight :: Light -> Maybe GLenum
marshalLight :: Light -> Maybe GLenum
marshalLight (Light l :: GLsizei
l) = GLsizei -> Maybe GLenum
lightIndexToEnum GLsizei
l

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

light :: Light -> StateVar Capability
light :: Light -> StateVar Capability
light (Light l :: GLsizei
l) = EnableCap -> StateVar Capability
makeCapability (GLsizei -> EnableCap
CapLight GLsizei
l)

maxLights :: GettableStateVar GLsizei
maxLights :: GettableStateVar GLsizei
maxLights = GettableStateVar GLsizei -> GettableStateVar GLsizei
forall a. IO a -> IO a
makeGettableStateVar ((GLsizei -> GLsizei) -> PName1I -> GettableStateVar GLsizei
forall p a. GetPName1I p => (GLsizei -> a) -> p -> IO a
getSizei1 GLsizei -> GLsizei
forall a. a -> a
id PName1I
GetMaxLights)

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

data FrontFaceDirection =
     CW
   | CCW
   deriving ( FrontFaceDirection -> FrontFaceDirection -> Bool
(FrontFaceDirection -> FrontFaceDirection -> Bool)
-> (FrontFaceDirection -> FrontFaceDirection -> Bool)
-> Eq FrontFaceDirection
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FrontFaceDirection -> FrontFaceDirection -> Bool
$c/= :: FrontFaceDirection -> FrontFaceDirection -> Bool
== :: FrontFaceDirection -> FrontFaceDirection -> Bool
$c== :: FrontFaceDirection -> FrontFaceDirection -> Bool
Eq, Eq FrontFaceDirection
Eq FrontFaceDirection =>
(FrontFaceDirection -> FrontFaceDirection -> Ordering)
-> (FrontFaceDirection -> FrontFaceDirection -> Bool)
-> (FrontFaceDirection -> FrontFaceDirection -> Bool)
-> (FrontFaceDirection -> FrontFaceDirection -> Bool)
-> (FrontFaceDirection -> FrontFaceDirection -> Bool)
-> (FrontFaceDirection -> FrontFaceDirection -> FrontFaceDirection)
-> (FrontFaceDirection -> FrontFaceDirection -> FrontFaceDirection)
-> Ord FrontFaceDirection
FrontFaceDirection -> FrontFaceDirection -> Bool
FrontFaceDirection -> FrontFaceDirection -> Ordering
FrontFaceDirection -> FrontFaceDirection -> FrontFaceDirection
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: FrontFaceDirection -> FrontFaceDirection -> FrontFaceDirection
$cmin :: FrontFaceDirection -> FrontFaceDirection -> FrontFaceDirection
max :: FrontFaceDirection -> FrontFaceDirection -> FrontFaceDirection
$cmax :: FrontFaceDirection -> FrontFaceDirection -> FrontFaceDirection
>= :: FrontFaceDirection -> FrontFaceDirection -> Bool
$c>= :: FrontFaceDirection -> FrontFaceDirection -> Bool
> :: FrontFaceDirection -> FrontFaceDirection -> Bool
$c> :: FrontFaceDirection -> FrontFaceDirection -> Bool
<= :: FrontFaceDirection -> FrontFaceDirection -> Bool
$c<= :: FrontFaceDirection -> FrontFaceDirection -> Bool
< :: FrontFaceDirection -> FrontFaceDirection -> Bool
$c< :: FrontFaceDirection -> FrontFaceDirection -> Bool
compare :: FrontFaceDirection -> FrontFaceDirection -> Ordering
$ccompare :: FrontFaceDirection -> FrontFaceDirection -> Ordering
$cp1Ord :: Eq FrontFaceDirection
Ord, Int -> FrontFaceDirection -> ShowS
[FrontFaceDirection] -> ShowS
FrontFaceDirection -> String
(Int -> FrontFaceDirection -> ShowS)
-> (FrontFaceDirection -> String)
-> ([FrontFaceDirection] -> ShowS)
-> Show FrontFaceDirection
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FrontFaceDirection] -> ShowS
$cshowList :: [FrontFaceDirection] -> ShowS
show :: FrontFaceDirection -> String
$cshow :: FrontFaceDirection -> String
showsPrec :: Int -> FrontFaceDirection -> ShowS
$cshowsPrec :: Int -> FrontFaceDirection -> ShowS
Show )

marshalFrontFaceDirection :: FrontFaceDirection -> GLenum
marshalFrontFaceDirection :: FrontFaceDirection -> GLenum
marshalFrontFaceDirection x :: FrontFaceDirection
x = case FrontFaceDirection
x of
   CW -> GLenum
GL_CW
   CCW -> GLenum
GL_CCW

unmarshalFrontFaceDirection :: GLenum -> FrontFaceDirection
unmarshalFrontFaceDirection :: GLenum -> FrontFaceDirection
unmarshalFrontFaceDirection x :: GLenum
x
   | GLenum
x GLenum -> GLenum -> Bool
forall a. Eq a => a -> a -> Bool
== GLenum
GL_CW = FrontFaceDirection
CW
   | GLenum
x GLenum -> GLenum -> Bool
forall a. Eq a => a -> a -> Bool
== GLenum
GL_CCW = FrontFaceDirection
CCW
   | Bool
otherwise = String -> FrontFaceDirection
forall a. HasCallStack => String -> a
error ("unmarshalFrontFaceDirection: illegal value " String -> ShowS
forall a. [a] -> [a] -> [a]
++ GLenum -> String
forall a. Show a => a -> String
show GLenum
x)

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

frontFace :: StateVar FrontFaceDirection
frontFace :: StateVar FrontFaceDirection
frontFace =
   IO FrontFaceDirection
-> (FrontFaceDirection -> IO ()) -> StateVar FrontFaceDirection
forall a. IO a -> (a -> IO ()) -> StateVar a
makeStateVar
      ((GLenum -> FrontFaceDirection) -> PName1I -> IO FrontFaceDirection
forall p a. GetPName1I p => (GLenum -> a) -> p -> IO a
getEnum1 GLenum -> FrontFaceDirection
unmarshalFrontFaceDirection PName1I
GetFrontFace)
      (GLenum -> IO ()
forall (m :: * -> *). MonadIO m => GLenum -> m ()
glFrontFace (GLenum -> IO ())
-> (FrontFaceDirection -> GLenum) -> FrontFaceDirection -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. FrontFaceDirection -> GLenum
marshalFrontFaceDirection)

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

data MaterialParameter =
     MaterialEmission
   | MaterialShininess
   | MaterialAmbientAndDiffuse
   | MaterialColorIndexes
   | MaterialAmbient
   | MaterialDiffuse
   | MaterialSpecular

marshalMaterialParameter :: MaterialParameter -> GLenum
marshalMaterialParameter :: MaterialParameter -> GLenum
marshalMaterialParameter x :: MaterialParameter
x = case MaterialParameter
x of
   MaterialEmission -> GLenum
GL_EMISSION
   MaterialShininess -> GLenum
GL_SHININESS
   MaterialAmbientAndDiffuse -> GLenum
GL_AMBIENT_AND_DIFFUSE
   MaterialColorIndexes -> GLenum
GL_COLOR_INDEXES
   MaterialAmbient -> GLenum
GL_AMBIENT
   MaterialDiffuse -> GLenum
GL_DIFFUSE
   MaterialSpecular -> GLenum
GL_SPECULAR

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

materialAmbient :: Face -> StateVar (Color4 GLfloat)
materialAmbient :: Face -> StateVar (Color4 GLfloat)
materialAmbient =
   (GLenum -> GLenum -> Ptr (Color4 GLfloat) -> IO ())
-> (GLenum -> GLenum -> Ptr (Color4 GLfloat) -> IO ())
-> MaterialParameter
-> Face
-> StateVar (Color4 GLfloat)
forall a.
Storable a =>
(GLenum -> GLenum -> Ptr a -> IO ())
-> (GLenum -> GLenum -> Ptr a -> IO ())
-> MaterialParameter
-> Face
-> StateVar a
makeMaterialVar GLenum -> GLenum -> Ptr (Color4 GLfloat) -> IO ()
glGetMaterialfvc GLenum -> GLenum -> Ptr (Color4 GLfloat) -> IO ()
glMaterialfvc MaterialParameter
MaterialAmbient

materialDiffuse :: Face -> StateVar (Color4 GLfloat)
materialDiffuse :: Face -> StateVar (Color4 GLfloat)
materialDiffuse =
   (GLenum -> GLenum -> Ptr (Color4 GLfloat) -> IO ())
-> (GLenum -> GLenum -> Ptr (Color4 GLfloat) -> IO ())
-> MaterialParameter
-> Face
-> StateVar (Color4 GLfloat)
forall a.
Storable a =>
(GLenum -> GLenum -> Ptr a -> IO ())
-> (GLenum -> GLenum -> Ptr a -> IO ())
-> MaterialParameter
-> Face
-> StateVar a
makeMaterialVar GLenum -> GLenum -> Ptr (Color4 GLfloat) -> IO ()
glGetMaterialfvc GLenum -> GLenum -> Ptr (Color4 GLfloat) -> IO ()
glMaterialfvc MaterialParameter
MaterialDiffuse

materialAmbientAndDiffuse :: Face -> StateVar (Color4 GLfloat)
materialAmbientAndDiffuse :: Face -> StateVar (Color4 GLfloat)
materialAmbientAndDiffuse =
   (GLenum -> GLenum -> Ptr (Color4 GLfloat) -> IO ())
-> (GLenum -> GLenum -> Ptr (Color4 GLfloat) -> IO ())
-> MaterialParameter
-> Face
-> StateVar (Color4 GLfloat)
forall a.
Storable a =>
(GLenum -> GLenum -> Ptr a -> IO ())
-> (GLenum -> GLenum -> Ptr a -> IO ())
-> MaterialParameter
-> Face
-> StateVar a
makeMaterialVar GLenum -> GLenum -> Ptr (Color4 GLfloat) -> IO ()
glGetMaterialfvc GLenum -> GLenum -> Ptr (Color4 GLfloat) -> IO ()
glMaterialfvc MaterialParameter
MaterialAmbientAndDiffuse

materialSpecular :: Face -> StateVar (Color4 GLfloat)
materialSpecular :: Face -> StateVar (Color4 GLfloat)
materialSpecular =
   (GLenum -> GLenum -> Ptr (Color4 GLfloat) -> IO ())
-> (GLenum -> GLenum -> Ptr (Color4 GLfloat) -> IO ())
-> MaterialParameter
-> Face
-> StateVar (Color4 GLfloat)
forall a.
Storable a =>
(GLenum -> GLenum -> Ptr a -> IO ())
-> (GLenum -> GLenum -> Ptr a -> IO ())
-> MaterialParameter
-> Face
-> StateVar a
makeMaterialVar GLenum -> GLenum -> Ptr (Color4 GLfloat) -> IO ()
glGetMaterialfvc GLenum -> GLenum -> Ptr (Color4 GLfloat) -> IO ()
glMaterialfvc MaterialParameter
MaterialSpecular

materialEmission :: Face -> StateVar (Color4 GLfloat)
materialEmission :: Face -> StateVar (Color4 GLfloat)
materialEmission =
   (GLenum -> GLenum -> Ptr (Color4 GLfloat) -> IO ())
-> (GLenum -> GLenum -> Ptr (Color4 GLfloat) -> IO ())
-> MaterialParameter
-> Face
-> StateVar (Color4 GLfloat)
forall a.
Storable a =>
(GLenum -> GLenum -> Ptr a -> IO ())
-> (GLenum -> GLenum -> Ptr a -> IO ())
-> MaterialParameter
-> Face
-> StateVar a
makeMaterialVar GLenum -> GLenum -> Ptr (Color4 GLfloat) -> IO ()
glGetMaterialfvc GLenum -> GLenum -> Ptr (Color4 GLfloat) -> IO ()
glMaterialfvc MaterialParameter
MaterialEmission

makeMaterialVar :: Storable a
                => (GLenum -> GLenum -> Ptr a -> IO ())
                -> (GLenum -> GLenum -> Ptr a -> IO ())
                -> MaterialParameter -> Face -> StateVar a
makeMaterialVar :: (GLenum -> GLenum -> Ptr a -> IO ())
-> (GLenum -> GLenum -> Ptr a -> IO ())
-> MaterialParameter
-> Face
-> StateVar a
makeMaterialVar getter :: GLenum -> GLenum -> Ptr a -> IO ()
getter setter :: GLenum -> GLenum -> Ptr a -> IO ()
setter materialParameter :: MaterialParameter
materialParameter face :: Face
face =
   IO a -> (a -> IO ()) -> StateVar a
forall a. IO a -> (a -> IO ()) -> StateVar a
makeStateVar ((Ptr a -> IO a) -> IO a
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr a -> IO a) -> IO a) -> (Ptr a -> IO a) -> IO a
forall a b. (a -> b) -> a -> b
$ \buf :: Ptr a
buf -> do GLenum -> GLenum -> Ptr a -> IO ()
getter GLenum
f GLenum
mp Ptr a
buf ; Ptr a -> IO a
forall a. Storable a => Ptr a -> IO a
peek Ptr a
buf)
                (\val :: a
val -> a -> (Ptr a -> IO ()) -> IO ()
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with a
val ((Ptr a -> IO ()) -> IO ()) -> (Ptr a -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ GLenum -> GLenum -> Ptr a -> IO ()
setter GLenum
f GLenum
mp)
   where mp :: GLenum
mp = MaterialParameter -> GLenum
marshalMaterialParameter MaterialParameter
materialParameter
         f :: GLenum
f  = Face -> GLenum
marshalFace Face
face

glGetMaterialfvc :: GLenum -> GLenum -> Ptr (Color4 GLfloat) -> IO ()
glGetMaterialfvc :: GLenum -> GLenum -> Ptr (Color4 GLfloat) -> IO ()
glGetMaterialfvc face :: GLenum
face pname :: GLenum
pname ptr :: Ptr (Color4 GLfloat)
ptr = GLenum -> GLenum -> Ptr GLfloat -> IO ()
forall (m :: * -> *).
MonadIO m =>
GLenum -> GLenum -> Ptr GLfloat -> m ()
glGetMaterialfv GLenum
face GLenum
pname (Ptr (Color4 GLfloat) -> Ptr GLfloat
forall a b. Ptr a -> Ptr b
castPtr Ptr (Color4 GLfloat)
ptr)

glMaterialfvc :: GLenum -> GLenum -> Ptr (Color4 GLfloat) -> IO ()
glMaterialfvc :: GLenum -> GLenum -> Ptr (Color4 GLfloat) -> IO ()
glMaterialfvc face :: GLenum
face pname :: GLenum
pname ptr :: Ptr (Color4 GLfloat)
ptr = GLenum -> GLenum -> Ptr GLfloat -> IO ()
forall (m :: * -> *).
MonadIO m =>
GLenum -> GLenum -> Ptr GLfloat -> m ()
glMaterialfv GLenum
face GLenum
pname (Ptr (Color4 GLfloat) -> Ptr GLfloat
forall a b. Ptr a -> Ptr b
castPtr Ptr (Color4 GLfloat)
ptr)

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

materialShininess :: Face -> StateVar GLfloat
materialShininess :: Face -> StateVar GLfloat
materialShininess =
   (GLenum -> GLenum -> Ptr GLfloat -> IO ())
-> (GLenum -> GLenum -> Ptr GLfloat -> IO ())
-> MaterialParameter
-> Face
-> StateVar GLfloat
forall a.
Storable a =>
(GLenum -> GLenum -> Ptr a -> IO ())
-> (GLenum -> GLenum -> Ptr a -> IO ())
-> MaterialParameter
-> Face
-> StateVar a
makeMaterialVar GLenum -> GLenum -> Ptr GLfloat -> IO ()
glGetMaterialfvf GLenum -> GLenum -> Ptr GLfloat -> IO ()
glMaterialff MaterialParameter
MaterialShininess

glGetMaterialfvf :: GLenum -> GLenum -> Ptr GLfloat -> IO ()
glGetMaterialfvf :: GLenum -> GLenum -> Ptr GLfloat -> IO ()
glGetMaterialfvf face :: GLenum
face pname :: GLenum
pname ptr :: Ptr GLfloat
ptr = GLenum -> GLenum -> Ptr GLfloat -> IO ()
forall (m :: * -> *).
MonadIO m =>
GLenum -> GLenum -> Ptr GLfloat -> m ()
glGetMaterialfv GLenum
face GLenum
pname (Ptr GLfloat -> Ptr GLfloat
forall a b. Ptr a -> Ptr b
castPtr Ptr GLfloat
ptr)

glMaterialff :: GLenum -> GLenum -> Ptr GLfloat -> IO ()
glMaterialff :: GLenum -> GLenum -> Ptr GLfloat -> IO ()
glMaterialff face :: GLenum
face pname :: GLenum
pname ptr :: Ptr GLfloat
ptr = GLenum -> GLenum -> Ptr GLfloat -> IO ()
forall (m :: * -> *).
MonadIO m =>
GLenum -> GLenum -> Ptr GLfloat -> m ()
glMaterialfv GLenum
face GLenum
pname (Ptr GLfloat -> Ptr GLfloat
forall a b. Ptr a -> Ptr b
castPtr Ptr GLfloat
ptr)

maxShininess :: GettableStateVar GLfloat
maxShininess :: GettableStateVar GLfloat
maxShininess = GettableStateVar GLfloat -> GettableStateVar GLfloat
forall a. IO a -> IO a
makeGettableStateVar (GettableStateVar GLfloat -> GettableStateVar GLfloat)
-> GettableStateVar GLfloat -> GettableStateVar GLfloat
forall a b. (a -> b) -> a -> b
$ (GLfloat -> GLfloat) -> PName1F -> GettableStateVar GLfloat
forall p a. GetPName1F p => (GLfloat -> a) -> p -> IO a
getFloat1 GLfloat -> GLfloat
forall a. a -> a
id PName1F
GetMaxShininess

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

-- Alas, (Index1 GLint, Index1 GLint, Index1 GLint) is not an instance of
-- Storable...

materialColorIndexes ::
   Face -> StateVar (Index1 GLint, Index1 GLint, Index1 GLint)
materialColorIndexes :: Face -> StateVar (Index1 GLsizei, Index1 GLsizei, Index1 GLsizei)
materialColorIndexes face :: Face
face =
   IO (Index1 GLsizei, Index1 GLsizei, Index1 GLsizei)
-> ((Index1 GLsizei, Index1 GLsizei, Index1 GLsizei) -> IO ())
-> StateVar (Index1 GLsizei, Index1 GLsizei, Index1 GLsizei)
forall a. IO a -> (a -> IO ()) -> StateVar a
makeStateVar (Face -> IO (Index1 GLsizei, Index1 GLsizei, Index1 GLsizei)
getMaterialColorIndexes Face
face) (Face -> (Index1 GLsizei, Index1 GLsizei, Index1 GLsizei) -> IO ()
setMaterialColorIndexes Face
face)

getMaterialColorIndexes :: Face -> IO (Index1 GLint, Index1 GLint, Index1 GLint)
getMaterialColorIndexes :: Face -> IO (Index1 GLsizei, Index1 GLsizei, Index1 GLsizei)
getMaterialColorIndexes face :: Face
face =
   Int
-> (Ptr GLsizei
    -> IO (Index1 GLsizei, Index1 GLsizei, Index1 GLsizei))
-> IO (Index1 GLsizei, Index1 GLsizei, Index1 GLsizei)
forall a b. Storable a => Int -> (Ptr a -> IO b) -> IO b
allocaArray 3 ((Ptr GLsizei
  -> IO (Index1 GLsizei, Index1 GLsizei, Index1 GLsizei))
 -> IO (Index1 GLsizei, Index1 GLsizei, Index1 GLsizei))
-> (Ptr GLsizei
    -> IO (Index1 GLsizei, Index1 GLsizei, Index1 GLsizei))
-> IO (Index1 GLsizei, Index1 GLsizei, Index1 GLsizei)
forall a b. (a -> b) -> a -> b
$ \buf :: Ptr GLsizei
buf -> do
      GLenum -> GLenum -> Ptr GLsizei -> IO ()
forall (m :: * -> *).
MonadIO m =>
GLenum -> GLenum -> Ptr GLsizei -> m ()
glGetMaterialiv (Face -> GLenum
marshalFace Face
face)
                      (MaterialParameter -> GLenum
marshalMaterialParameter MaterialParameter
MaterialColorIndexes)
                      Ptr GLsizei
buf
      (GLsizei
 -> GLsizei
 -> GLsizei
 -> (Index1 GLsizei, Index1 GLsizei, Index1 GLsizei))
-> Ptr GLsizei
-> IO (Index1 GLsizei, Index1 GLsizei, Index1 GLsizei)
forall a b. Storable a => (a -> a -> a -> b) -> Ptr a -> IO b
peek3 (\a :: GLsizei
a d :: GLsizei
d s :: GLsizei
s -> (GLsizei -> Index1 GLsizei
forall a. a -> Index1 a
Index1 GLsizei
a, GLsizei -> Index1 GLsizei
forall a. a -> Index1 a
Index1 GLsizei
d, GLsizei -> Index1 GLsizei
forall a. a -> Index1 a
Index1 GLsizei
s)) Ptr GLsizei
buf

setMaterialColorIndexes ::
   Face -> (Index1 GLint, Index1 GLint, Index1 GLint) -> IO ()
setMaterialColorIndexes :: Face -> (Index1 GLsizei, Index1 GLsizei, Index1 GLsizei) -> IO ()
setMaterialColorIndexes face :: Face
face (Index1 a :: GLsizei
a, Index1 d :: GLsizei
d, Index1 s :: GLsizei
s) =
   [GLsizei] -> (Ptr GLsizei -> IO ()) -> IO ()
forall a b. Storable a => [a] -> (Ptr a -> IO b) -> IO b
withArray [GLsizei
a, GLsizei
d, GLsizei
s] ((Ptr GLsizei -> IO ()) -> IO ())
-> (Ptr GLsizei -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$
      GLenum -> GLenum -> Ptr GLsizei -> IO ()
forall (m :: * -> *).
MonadIO m =>
GLenum -> GLenum -> Ptr GLsizei -> m ()
glMaterialiv (Face -> GLenum
marshalFace Face
face)
                   (MaterialParameter -> GLenum
marshalMaterialParameter MaterialParameter
MaterialColorIndexes)

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

data LightParameter =
     Ambient'
   | Diffuse'
   | Specular'
   | Position
   | SpotDirection
   | SpotExponent
   | SpotCutoff
   | ConstantAttenuation
   | LinearAttenuation
   | QuadraticAttenuation

marshalLightParameter :: LightParameter -> GLenum
marshalLightParameter :: LightParameter -> GLenum
marshalLightParameter x :: LightParameter
x = case LightParameter
x of
   Ambient' -> GLenum
GL_AMBIENT
   Diffuse' -> GLenum
GL_DIFFUSE
   Specular' -> GLenum
GL_SPECULAR
   Position -> GLenum
GL_POSITION
   SpotDirection -> GLenum
GL_SPOT_DIRECTION
   SpotExponent -> GLenum
GL_SPOT_EXPONENT
   SpotCutoff -> GLenum
GL_SPOT_CUTOFF
   ConstantAttenuation -> GLenum
GL_CONSTANT_ATTENUATION
   LinearAttenuation -> GLenum
GL_LINEAR_ATTENUATION
   QuadraticAttenuation -> GLenum
GL_QUADRATIC_ATTENUATION

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

ambient :: Light -> StateVar (Color4 GLfloat)
ambient :: Light -> StateVar (Color4 GLfloat)
ambient = (GLenum -> GLenum -> Ptr (Color4 GLfloat) -> IO ())
-> (GLenum -> GLenum -> Ptr (Color4 GLfloat) -> IO ())
-> LightParameter
-> Color4 GLfloat
-> Light
-> StateVar (Color4 GLfloat)
forall a.
Storable a =>
(GLenum -> GLenum -> Ptr a -> IO ())
-> (GLenum -> GLenum -> Ptr a -> IO ())
-> LightParameter
-> a
-> Light
-> StateVar a
makeLightVar GLenum -> GLenum -> Ptr (Color4 GLfloat) -> IO ()
glGetLightfvc GLenum -> GLenum -> Ptr (Color4 GLfloat) -> IO ()
glLightfvc LightParameter
Ambient' Color4 GLfloat
black

black :: Color4 GLfloat
black :: Color4 GLfloat
black = GLfloat -> GLfloat -> GLfloat -> GLfloat -> Color4 GLfloat
forall a. a -> a -> a -> a -> Color4 a
Color4 0 0 0 0

diffuse :: Light -> StateVar (Color4 GLfloat)
diffuse :: Light -> StateVar (Color4 GLfloat)
diffuse = (GLenum -> GLenum -> Ptr (Color4 GLfloat) -> IO ())
-> (GLenum -> GLenum -> Ptr (Color4 GLfloat) -> IO ())
-> LightParameter
-> Color4 GLfloat
-> Light
-> StateVar (Color4 GLfloat)
forall a.
Storable a =>
(GLenum -> GLenum -> Ptr a -> IO ())
-> (GLenum -> GLenum -> Ptr a -> IO ())
-> LightParameter
-> a
-> Light
-> StateVar a
makeLightVar GLenum -> GLenum -> Ptr (Color4 GLfloat) -> IO ()
glGetLightfvc GLenum -> GLenum -> Ptr (Color4 GLfloat) -> IO ()
glLightfvc LightParameter
Diffuse' Color4 GLfloat
black

specular :: Light -> StateVar (Color4 GLfloat)
specular :: Light -> StateVar (Color4 GLfloat)
specular = (GLenum -> GLenum -> Ptr (Color4 GLfloat) -> IO ())
-> (GLenum -> GLenum -> Ptr (Color4 GLfloat) -> IO ())
-> LightParameter
-> Color4 GLfloat
-> Light
-> StateVar (Color4 GLfloat)
forall a.
Storable a =>
(GLenum -> GLenum -> Ptr a -> IO ())
-> (GLenum -> GLenum -> Ptr a -> IO ())
-> LightParameter
-> a
-> Light
-> StateVar a
makeLightVar GLenum -> GLenum -> Ptr (Color4 GLfloat) -> IO ()
glGetLightfvc GLenum -> GLenum -> Ptr (Color4 GLfloat) -> IO ()
glLightfvc LightParameter
Specular' Color4 GLfloat
black

makeLightVar :: Storable a
             => (GLenum -> GLenum -> Ptr a -> IO ())
             -> (GLenum -> GLenum -> Ptr a -> IO ())
             -> LightParameter -> a -> Light -> StateVar a
makeLightVar :: (GLenum -> GLenum -> Ptr a -> IO ())
-> (GLenum -> GLenum -> Ptr a -> IO ())
-> LightParameter
-> a
-> Light
-> StateVar a
makeLightVar getter :: GLenum -> GLenum -> Ptr a -> IO ()
getter setter :: GLenum -> GLenum -> Ptr a -> IO ()
setter lightParameter :: LightParameter
lightParameter defaultValue :: a
defaultValue theLight :: Light
theLight =
   IO a -> (a -> IO ()) -> StateVar a
forall a. IO a -> (a -> IO ()) -> StateVar a
makeStateVar (IO a -> (GLenum -> IO a) -> Maybe GLenum -> IO a
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return a
defaultValue) GLenum -> IO a
getLightVar Maybe GLenum
ml)
                (\val :: a
val -> IO () -> (GLenum -> IO ()) -> Maybe GLenum -> IO ()
forall b a. b -> (a -> b) -> Maybe a -> b
maybe IO ()
recordInvalidEnum (a -> GLenum -> IO ()
setLightVar a
val) Maybe GLenum
ml)
   where lp :: GLenum
lp          = LightParameter -> GLenum
marshalLightParameter LightParameter
lightParameter
         ml :: Maybe GLenum
ml          = Light -> Maybe GLenum
marshalLight Light
theLight
         getLightVar :: GLenum -> IO a
getLightVar = \l :: GLenum
l -> (Ptr a -> IO a) -> IO a
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr a -> IO a) -> IO a) -> (Ptr a -> IO a) -> IO a
forall a b. (a -> b) -> a -> b
$ \buf :: Ptr a
buf -> do GLenum -> GLenum -> Ptr a -> IO ()
getter GLenum
l GLenum
lp Ptr a
buf ; Ptr a -> IO a
forall a. Storable a => Ptr a -> IO a
peek Ptr a
buf
         setLightVar :: a -> GLenum -> IO ()
setLightVar = \val :: a
val l :: GLenum
l -> a -> (Ptr a -> IO ()) -> IO ()
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with a
val ((Ptr a -> IO ()) -> IO ()) -> (Ptr a -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ GLenum -> GLenum -> Ptr a -> IO ()
setter GLenum
l GLenum
lp

glGetLightfvc :: GLenum -> GLenum -> Ptr (Color4 GLfloat) -> IO ()
glGetLightfvc :: GLenum -> GLenum -> Ptr (Color4 GLfloat) -> IO ()
glGetLightfvc l :: GLenum
l pname :: GLenum
pname ptr :: Ptr (Color4 GLfloat)
ptr = GLenum -> GLenum -> Ptr GLfloat -> IO ()
forall (m :: * -> *).
MonadIO m =>
GLenum -> GLenum -> Ptr GLfloat -> m ()
glGetLightfv GLenum
l GLenum
pname (Ptr (Color4 GLfloat) -> Ptr GLfloat
forall a b. Ptr a -> Ptr b
castPtr Ptr (Color4 GLfloat)
ptr)

glLightfvc :: GLenum -> GLenum -> Ptr (Color4 GLfloat) -> IO ()
glLightfvc :: GLenum -> GLenum -> Ptr (Color4 GLfloat) -> IO ()
glLightfvc l :: GLenum
l pname :: GLenum
pname ptr :: Ptr (Color4 GLfloat)
ptr = GLenum -> GLenum -> Ptr GLfloat -> IO ()
forall (m :: * -> *).
MonadIO m =>
GLenum -> GLenum -> Ptr GLfloat -> m ()
glLightfv GLenum
l GLenum
pname (Ptr (Color4 GLfloat) -> Ptr GLfloat
forall a b. Ptr a -> Ptr b
castPtr Ptr (Color4 GLfloat)
ptr)

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

position :: Light -> StateVar (Vertex4 GLfloat)
position :: Light -> StateVar (Vertex4 GLfloat)
position = (GLenum -> GLenum -> Ptr (Vertex4 GLfloat) -> IO ())
-> (GLenum -> GLenum -> Ptr (Vertex4 GLfloat) -> IO ())
-> LightParameter
-> Vertex4 GLfloat
-> Light
-> StateVar (Vertex4 GLfloat)
forall a.
Storable a =>
(GLenum -> GLenum -> Ptr a -> IO ())
-> (GLenum -> GLenum -> Ptr a -> IO ())
-> LightParameter
-> a
-> Light
-> StateVar a
makeLightVar GLenum -> GLenum -> Ptr (Vertex4 GLfloat) -> IO ()
glGetLightfvv GLenum -> GLenum -> Ptr (Vertex4 GLfloat) -> IO ()
glLightfvv LightParameter
Position (GLfloat -> GLfloat -> GLfloat -> GLfloat -> Vertex4 GLfloat
forall a. a -> a -> a -> a -> Vertex4 a
Vertex4 0 0 0 0)

glLightfvv :: GLenum -> GLenum -> Ptr (Vertex4 GLfloat) -> IO ()
glLightfvv :: GLenum -> GLenum -> Ptr (Vertex4 GLfloat) -> IO ()
glLightfvv l :: GLenum
l pname :: GLenum
pname ptr :: Ptr (Vertex4 GLfloat)
ptr = GLenum -> GLenum -> Ptr GLfloat -> IO ()
forall (m :: * -> *).
MonadIO m =>
GLenum -> GLenum -> Ptr GLfloat -> m ()
glLightfv GLenum
l GLenum
pname (Ptr (Vertex4 GLfloat) -> Ptr GLfloat
forall a b. Ptr a -> Ptr b
castPtr Ptr (Vertex4 GLfloat)
ptr)

glGetLightfvv :: GLenum -> GLenum -> Ptr (Vertex4 GLfloat) -> IO ()
glGetLightfvv :: GLenum -> GLenum -> Ptr (Vertex4 GLfloat) -> IO ()
glGetLightfvv l :: GLenum
l pname :: GLenum
pname ptr :: Ptr (Vertex4 GLfloat)
ptr = GLenum -> GLenum -> Ptr GLfloat -> IO ()
forall (m :: * -> *).
MonadIO m =>
GLenum -> GLenum -> Ptr GLfloat -> m ()
glGetLightfv GLenum
l GLenum
pname (Ptr (Vertex4 GLfloat) -> Ptr GLfloat
forall a b. Ptr a -> Ptr b
castPtr Ptr (Vertex4 GLfloat)
ptr)

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

spotDirection :: Light -> StateVar (Normal3 GLfloat)
spotDirection :: Light -> StateVar (Normal3 GLfloat)
spotDirection =
   (GLenum -> GLenum -> Ptr (Normal3 GLfloat) -> IO ())
-> (GLenum -> GLenum -> Ptr (Normal3 GLfloat) -> IO ())
-> LightParameter
-> Normal3 GLfloat
-> Light
-> StateVar (Normal3 GLfloat)
forall a.
Storable a =>
(GLenum -> GLenum -> Ptr a -> IO ())
-> (GLenum -> GLenum -> Ptr a -> IO ())
-> LightParameter
-> a
-> Light
-> StateVar a
makeLightVar GLenum -> GLenum -> Ptr (Normal3 GLfloat) -> IO ()
glGetLightfvn GLenum -> GLenum -> Ptr (Normal3 GLfloat) -> IO ()
glLightfvn LightParameter
SpotDirection (GLfloat -> GLfloat -> GLfloat -> Normal3 GLfloat
forall a. a -> a -> a -> Normal3 a
Normal3 0 0 0)

glLightfvn :: GLenum -> GLenum -> Ptr (Normal3 GLfloat) -> IO ()
glLightfvn :: GLenum -> GLenum -> Ptr (Normal3 GLfloat) -> IO ()
glLightfvn l :: GLenum
l pname :: GLenum
pname ptr :: Ptr (Normal3 GLfloat)
ptr = GLenum -> GLenum -> Ptr GLfloat -> IO ()
forall (m :: * -> *).
MonadIO m =>
GLenum -> GLenum -> Ptr GLfloat -> m ()
glLightfv GLenum
l GLenum
pname (Ptr (Normal3 GLfloat) -> Ptr GLfloat
forall a b. Ptr a -> Ptr b
castPtr Ptr (Normal3 GLfloat)
ptr)

glGetLightfvn :: GLenum -> GLenum -> Ptr (Normal3 GLfloat) -> IO ()
glGetLightfvn :: GLenum -> GLenum -> Ptr (Normal3 GLfloat) -> IO ()
glGetLightfvn l :: GLenum
l pname :: GLenum
pname ptr :: Ptr (Normal3 GLfloat)
ptr = GLenum -> GLenum -> Ptr GLfloat -> IO ()
forall (m :: * -> *).
MonadIO m =>
GLenum -> GLenum -> Ptr GLfloat -> m ()
glGetLightfv GLenum
l GLenum
pname (Ptr (Normal3 GLfloat) -> Ptr GLfloat
forall a b. Ptr a -> Ptr b
castPtr Ptr (Normal3 GLfloat)
ptr)

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

spotExponent :: Light -> StateVar GLfloat
spotExponent :: Light -> StateVar GLfloat
spotExponent = (GLenum -> GLenum -> Ptr GLfloat -> IO ())
-> (GLenum -> GLenum -> Ptr GLfloat -> IO ())
-> LightParameter
-> GLfloat
-> Light
-> StateVar GLfloat
forall a.
Storable a =>
(GLenum -> GLenum -> Ptr a -> IO ())
-> (GLenum -> GLenum -> Ptr a -> IO ())
-> LightParameter
-> a
-> Light
-> StateVar a
makeLightVar GLenum -> GLenum -> Ptr GLfloat -> IO ()
forall (m :: * -> *).
MonadIO m =>
GLenum -> GLenum -> Ptr GLfloat -> m ()
glGetLightfv GLenum -> GLenum -> Ptr GLfloat -> IO ()
forall (m :: * -> *).
MonadIO m =>
GLenum -> GLenum -> Ptr GLfloat -> m ()
glLightfv LightParameter
SpotExponent 0

maxSpotExponent :: GettableStateVar GLfloat
maxSpotExponent :: GettableStateVar GLfloat
maxSpotExponent = GettableStateVar GLfloat -> GettableStateVar GLfloat
forall a. IO a -> IO a
makeGettableStateVar (GettableStateVar GLfloat -> GettableStateVar GLfloat)
-> GettableStateVar GLfloat -> GettableStateVar GLfloat
forall a b. (a -> b) -> a -> b
$ (GLfloat -> GLfloat) -> PName1F -> GettableStateVar GLfloat
forall p a. GetPName1F p => (GLfloat -> a) -> p -> IO a
getFloat1 GLfloat -> GLfloat
forall a. a -> a
id PName1F
GetMaxSpotExponent

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

spotCutoff :: Light -> StateVar GLfloat
spotCutoff :: Light -> StateVar GLfloat
spotCutoff = (GLenum -> GLenum -> Ptr GLfloat -> IO ())
-> (GLenum -> GLenum -> Ptr GLfloat -> IO ())
-> LightParameter
-> GLfloat
-> Light
-> StateVar GLfloat
forall a.
Storable a =>
(GLenum -> GLenum -> Ptr a -> IO ())
-> (GLenum -> GLenum -> Ptr a -> IO ())
-> LightParameter
-> a
-> Light
-> StateVar a
makeLightVar GLenum -> GLenum -> Ptr GLfloat -> IO ()
forall (m :: * -> *).
MonadIO m =>
GLenum -> GLenum -> Ptr GLfloat -> m ()
glGetLightfv GLenum -> GLenum -> Ptr GLfloat -> IO ()
forall (m :: * -> *).
MonadIO m =>
GLenum -> GLenum -> Ptr GLfloat -> m ()
glLightfv LightParameter
SpotCutoff 0

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

attenuation :: Light -> StateVar (GLfloat, GLfloat, GLfloat)
attenuation :: Light -> StateVar (GLfloat, GLfloat, GLfloat)
attenuation theLight :: Light
theLight =
   IO (GLfloat, GLfloat, GLfloat)
-> ((GLfloat, GLfloat, GLfloat) -> IO ())
-> StateVar (GLfloat, GLfloat, GLfloat)
forall a. IO a -> (a -> IO ()) -> StateVar a
makeStateVar
      ((GLfloat -> GLfloat -> GLfloat -> (GLfloat, GLfloat, GLfloat))
-> GettableStateVar GLfloat
-> GettableStateVar GLfloat
-> GettableStateVar GLfloat
-> IO (GLfloat, GLfloat, GLfloat)
forall (m :: * -> *) a1 a2 a3 r.
Monad m =>
(a1 -> a2 -> a3 -> r) -> m a1 -> m a2 -> m a3 -> m r
liftM3 (,,) (StateVar GLfloat -> GettableStateVar GLfloat
forall t a (m :: * -> *). (HasGetter t a, MonadIO m) => t -> m a
get (Light -> StateVar GLfloat
constantAttenuation  Light
theLight))
                   (StateVar GLfloat -> GettableStateVar GLfloat
forall t a (m :: * -> *). (HasGetter t a, MonadIO m) => t -> m a
get (Light -> StateVar GLfloat
linearAttenuation    Light
theLight))
                   (StateVar GLfloat -> GettableStateVar GLfloat
forall t a (m :: * -> *). (HasGetter t a, MonadIO m) => t -> m a
get (Light -> StateVar GLfloat
quadraticAttenuation Light
theLight)))
      (\(constant :: GLfloat
constant, linear :: GLfloat
linear, quadratic :: GLfloat
quadratic) -> do
         Light -> StateVar GLfloat
constantAttenuation  Light
theLight StateVar GLfloat -> GLfloat -> IO ()
forall t a (m :: * -> *).
(HasSetter t a, MonadIO m) =>
t -> a -> m ()
$= GLfloat
constant
         Light -> StateVar GLfloat
linearAttenuation    Light
theLight StateVar GLfloat -> GLfloat -> IO ()
forall t a (m :: * -> *).
(HasSetter t a, MonadIO m) =>
t -> a -> m ()
$= GLfloat
linear
         Light -> StateVar GLfloat
quadraticAttenuation Light
theLight StateVar GLfloat -> GLfloat -> IO ()
forall t a (m :: * -> *).
(HasSetter t a, MonadIO m) =>
t -> a -> m ()
$= GLfloat
quadratic)

constantAttenuation :: Light -> StateVar GLfloat
constantAttenuation :: Light -> StateVar GLfloat
constantAttenuation = (GLenum -> GLenum -> Ptr GLfloat -> IO ())
-> (GLenum -> GLenum -> Ptr GLfloat -> IO ())
-> LightParameter
-> GLfloat
-> Light
-> StateVar GLfloat
forall a.
Storable a =>
(GLenum -> GLenum -> Ptr a -> IO ())
-> (GLenum -> GLenum -> Ptr a -> IO ())
-> LightParameter
-> a
-> Light
-> StateVar a
makeLightVar GLenum -> GLenum -> Ptr GLfloat -> IO ()
forall (m :: * -> *).
MonadIO m =>
GLenum -> GLenum -> Ptr GLfloat -> m ()
glGetLightfv GLenum -> GLenum -> Ptr GLfloat -> IO ()
forall (m :: * -> *).
MonadIO m =>
GLenum -> GLenum -> Ptr GLfloat -> m ()
glLightfv LightParameter
ConstantAttenuation 0

linearAttenuation :: Light -> StateVar GLfloat
linearAttenuation :: Light -> StateVar GLfloat
linearAttenuation = (GLenum -> GLenum -> Ptr GLfloat -> IO ())
-> (GLenum -> GLenum -> Ptr GLfloat -> IO ())
-> LightParameter
-> GLfloat
-> Light
-> StateVar GLfloat
forall a.
Storable a =>
(GLenum -> GLenum -> Ptr a -> IO ())
-> (GLenum -> GLenum -> Ptr a -> IO ())
-> LightParameter
-> a
-> Light
-> StateVar a
makeLightVar GLenum -> GLenum -> Ptr GLfloat -> IO ()
forall (m :: * -> *).
MonadIO m =>
GLenum -> GLenum -> Ptr GLfloat -> m ()
glGetLightfv GLenum -> GLenum -> Ptr GLfloat -> IO ()
forall (m :: * -> *).
MonadIO m =>
GLenum -> GLenum -> Ptr GLfloat -> m ()
glLightfv LightParameter
LinearAttenuation 0

quadraticAttenuation :: Light -> StateVar GLfloat
quadraticAttenuation :: Light -> StateVar GLfloat
quadraticAttenuation =
   (GLenum -> GLenum -> Ptr GLfloat -> IO ())
-> (GLenum -> GLenum -> Ptr GLfloat -> IO ())
-> LightParameter
-> GLfloat
-> Light
-> StateVar GLfloat
forall a.
Storable a =>
(GLenum -> GLenum -> Ptr a -> IO ())
-> (GLenum -> GLenum -> Ptr a -> IO ())
-> LightParameter
-> a
-> Light
-> StateVar a
makeLightVar GLenum -> GLenum -> Ptr GLfloat -> IO ()
forall (m :: * -> *).
MonadIO m =>
GLenum -> GLenum -> Ptr GLfloat -> m ()
glGetLightfv GLenum -> GLenum -> Ptr GLfloat -> IO ()
forall (m :: * -> *).
MonadIO m =>
GLenum -> GLenum -> Ptr GLfloat -> m ()
glLightfv LightParameter
QuadraticAttenuation 0

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

data LightModelParameter =
     LightModelAmbient
   | LightModelLocalViewer
   | LightModelTwoSide
   | LightModelColorControl

marshalLightModelParameter :: LightModelParameter -> GLenum
marshalLightModelParameter :: LightModelParameter -> GLenum
marshalLightModelParameter x :: LightModelParameter
x = case LightModelParameter
x of
   LightModelAmbient -> GLenum
GL_LIGHT_MODEL_AMBIENT
   LightModelLocalViewer -> GLenum
GL_LIGHT_MODEL_LOCAL_VIEWER
   LightModelTwoSide -> GLenum
GL_LIGHT_MODEL_TWO_SIDE
   LightModelColorControl -> GLenum
GL_LIGHT_MODEL_COLOR_CONTROL

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

lightModelAmbient :: StateVar (Color4 GLfloat)
lightModelAmbient :: StateVar (Color4 GLfloat)
lightModelAmbient =
   IO (Color4 GLfloat)
-> (Color4 GLfloat -> IO ()) -> StateVar (Color4 GLfloat)
forall a. IO a -> (a -> IO ()) -> StateVar a
makeStateVar
      ((GLfloat -> GLfloat -> GLfloat -> GLfloat -> Color4 GLfloat)
-> PName4F -> IO (Color4 GLfloat)
forall p a.
GetPName4F p =>
(GLfloat -> GLfloat -> GLfloat -> GLfloat -> a) -> p -> IO a
getFloat4 GLfloat -> GLfloat -> GLfloat -> GLfloat -> Color4 GLfloat
forall a. a -> a -> a -> a -> Color4 a
Color4 PName4F
GetLightModelAmbient)
      (\c :: Color4 GLfloat
c -> Color4 GLfloat -> (Ptr (Color4 GLfloat) -> IO ()) -> IO ()
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with Color4 GLfloat
c ((Ptr (Color4 GLfloat) -> IO ()) -> IO ())
-> (Ptr (Color4 GLfloat) -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$
                GLenum -> Ptr GLfloat -> IO ()
forall (m :: * -> *). MonadIO m => GLenum -> Ptr GLfloat -> m ()
glLightModelfv (LightModelParameter -> GLenum
marshalLightModelParameter LightModelParameter
LightModelAmbient) (Ptr GLfloat -> IO ())
-> (Ptr (Color4 GLfloat) -> Ptr GLfloat)
-> Ptr (Color4 GLfloat)
-> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Ptr (Color4 GLfloat) -> Ptr GLfloat
forall a b. Ptr a -> Ptr b
castPtr)

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

lightModelLocalViewer :: StateVar Capability
lightModelLocalViewer :: StateVar Capability
lightModelLocalViewer =
   PName1I -> LightModelParameter -> StateVar Capability
makeLightModelCapVar PName1I
GetLightModelLocalViewer LightModelParameter
LightModelLocalViewer

makeLightModelCapVar :: PName1I -> LightModelParameter -> StateVar Capability
makeLightModelCapVar :: PName1I -> LightModelParameter -> StateVar Capability
makeLightModelCapVar pname :: PName1I
pname lightModelParameter :: LightModelParameter
lightModelParameter =
   IO Capability -> (Capability -> IO ()) -> StateVar Capability
forall a. IO a -> (a -> IO ()) -> StateVar a
makeStateVar
      ((GLboolean -> Capability) -> PName1I -> IO Capability
forall p a. GetPName1I p => (GLboolean -> a) -> p -> IO a
getBoolean1 GLboolean -> Capability
unmarshalCapability PName1I
pname)
      (GLenum -> GLsizei -> IO ()
forall (m :: * -> *). MonadIO m => GLenum -> GLsizei -> m ()
glLightModeli (LightModelParameter -> GLenum
marshalLightModelParameter LightModelParameter
lightModelParameter) (GLsizei -> IO ())
-> (Capability -> GLsizei) -> Capability -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
                     GLboolean -> GLsizei
forall a b. (Integral a, Num b) => a -> b
fromIntegral (GLboolean -> GLsizei)
-> (Capability -> GLboolean) -> Capability -> GLsizei
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Capability -> GLboolean
marshalCapability)

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

lightModelTwoSide :: StateVar Capability
lightModelTwoSide :: StateVar Capability
lightModelTwoSide = PName1I -> LightModelParameter -> StateVar Capability
makeLightModelCapVar PName1I
GetLightModelTwoSide LightModelParameter
LightModelTwoSide

vertexProgramTwoSide :: StateVar Capability
vertexProgramTwoSide :: StateVar Capability
vertexProgramTwoSide = EnableCap -> StateVar Capability
makeCapability EnableCap
CapVertexProgramTwoSide

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

data LightModelColorControl =
     SingleColor
   | SeparateSpecularColor
   deriving ( LightModelColorControl -> LightModelColorControl -> Bool
(LightModelColorControl -> LightModelColorControl -> Bool)
-> (LightModelColorControl -> LightModelColorControl -> Bool)
-> Eq LightModelColorControl
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: LightModelColorControl -> LightModelColorControl -> Bool
$c/= :: LightModelColorControl -> LightModelColorControl -> Bool
== :: LightModelColorControl -> LightModelColorControl -> Bool
$c== :: LightModelColorControl -> LightModelColorControl -> Bool
Eq, Eq LightModelColorControl
Eq LightModelColorControl =>
(LightModelColorControl -> LightModelColorControl -> Ordering)
-> (LightModelColorControl -> LightModelColorControl -> Bool)
-> (LightModelColorControl -> LightModelColorControl -> Bool)
-> (LightModelColorControl -> LightModelColorControl -> Bool)
-> (LightModelColorControl -> LightModelColorControl -> Bool)
-> (LightModelColorControl
    -> LightModelColorControl -> LightModelColorControl)
-> (LightModelColorControl
    -> LightModelColorControl -> LightModelColorControl)
-> Ord LightModelColorControl
LightModelColorControl -> LightModelColorControl -> Bool
LightModelColorControl -> LightModelColorControl -> Ordering
LightModelColorControl
-> LightModelColorControl -> LightModelColorControl
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: LightModelColorControl
-> LightModelColorControl -> LightModelColorControl
$cmin :: LightModelColorControl
-> LightModelColorControl -> LightModelColorControl
max :: LightModelColorControl
-> LightModelColorControl -> LightModelColorControl
$cmax :: LightModelColorControl
-> LightModelColorControl -> LightModelColorControl
>= :: LightModelColorControl -> LightModelColorControl -> Bool
$c>= :: LightModelColorControl -> LightModelColorControl -> Bool
> :: LightModelColorControl -> LightModelColorControl -> Bool
$c> :: LightModelColorControl -> LightModelColorControl -> Bool
<= :: LightModelColorControl -> LightModelColorControl -> Bool
$c<= :: LightModelColorControl -> LightModelColorControl -> Bool
< :: LightModelColorControl -> LightModelColorControl -> Bool
$c< :: LightModelColorControl -> LightModelColorControl -> Bool
compare :: LightModelColorControl -> LightModelColorControl -> Ordering
$ccompare :: LightModelColorControl -> LightModelColorControl -> Ordering
$cp1Ord :: Eq LightModelColorControl
Ord, Int -> LightModelColorControl -> ShowS
[LightModelColorControl] -> ShowS
LightModelColorControl -> String
(Int -> LightModelColorControl -> ShowS)
-> (LightModelColorControl -> String)
-> ([LightModelColorControl] -> ShowS)
-> Show LightModelColorControl
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [LightModelColorControl] -> ShowS
$cshowList :: [LightModelColorControl] -> ShowS
show :: LightModelColorControl -> String
$cshow :: LightModelColorControl -> String
showsPrec :: Int -> LightModelColorControl -> ShowS
$cshowsPrec :: Int -> LightModelColorControl -> ShowS
Show )

marshalLightModelColorControl :: LightModelColorControl -> GLenum
marshalLightModelColorControl :: LightModelColorControl -> GLenum
marshalLightModelColorControl x :: LightModelColorControl
x = case LightModelColorControl
x of
   SingleColor -> GLenum
GL_SINGLE_COLOR
   SeparateSpecularColor -> GLenum
GL_SEPARATE_SPECULAR_COLOR

unmarshalLightModelColorControl :: GLenum -> LightModelColorControl
unmarshalLightModelColorControl :: GLenum -> LightModelColorControl
unmarshalLightModelColorControl x :: GLenum
x
   | GLenum
x GLenum -> GLenum -> Bool
forall a. Eq a => a -> a -> Bool
== GLenum
GL_SINGLE_COLOR = LightModelColorControl
SingleColor
   | GLenum
x GLenum -> GLenum -> Bool
forall a. Eq a => a -> a -> Bool
== GLenum
GL_SEPARATE_SPECULAR_COLOR = LightModelColorControl
SeparateSpecularColor
   | Bool
otherwise = String -> LightModelColorControl
forall a. HasCallStack => String -> a
error ("unmarshalLightModelColorControl: illegal value " String -> ShowS
forall a. [a] -> [a] -> [a]
++ GLenum -> String
forall a. Show a => a -> String
show GLenum
x)

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

lightModelColorControl :: StateVar LightModelColorControl
lightModelColorControl :: StateVar LightModelColorControl
lightModelColorControl =
   IO LightModelColorControl
-> (LightModelColorControl -> IO ())
-> StateVar LightModelColorControl
forall a. IO a -> (a -> IO ()) -> StateVar a
makeStateVar
      ((GLenum -> LightModelColorControl)
-> PName1I -> IO LightModelColorControl
forall p a. GetPName1I p => (GLenum -> a) -> p -> IO a
getEnum1 GLenum -> LightModelColorControl
unmarshalLightModelColorControl PName1I
GetLightModelColorControl)
      (GLenum -> GLsizei -> IO ()
forall (m :: * -> *). MonadIO m => GLenum -> GLsizei -> m ()
glLightModeli (LightModelParameter -> GLenum
marshalLightModelParameter LightModelParameter
LightModelColorControl) (GLsizei -> IO ())
-> (LightModelColorControl -> GLsizei)
-> LightModelColorControl
-> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
                     GLenum -> GLsizei
forall a b. (Integral a, Num b) => a -> b
fromIntegral (GLenum -> GLsizei)
-> (LightModelColorControl -> GLenum)
-> LightModelColorControl
-> GLsizei
forall b c a. (b -> c) -> (a -> b) -> a -> c
. LightModelColorControl -> GLenum
marshalLightModelColorControl)

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

data ColorMaterialParameter =
     Ambient
   | Diffuse
   | Specular
   | Emission
   | AmbientAndDiffuse
   deriving ( ColorMaterialParameter -> ColorMaterialParameter -> Bool
(ColorMaterialParameter -> ColorMaterialParameter -> Bool)
-> (ColorMaterialParameter -> ColorMaterialParameter -> Bool)
-> Eq ColorMaterialParameter
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ColorMaterialParameter -> ColorMaterialParameter -> Bool
$c/= :: ColorMaterialParameter -> ColorMaterialParameter -> Bool
== :: ColorMaterialParameter -> ColorMaterialParameter -> Bool
$c== :: ColorMaterialParameter -> ColorMaterialParameter -> Bool
Eq, Eq ColorMaterialParameter
Eq ColorMaterialParameter =>
(ColorMaterialParameter -> ColorMaterialParameter -> Ordering)
-> (ColorMaterialParameter -> ColorMaterialParameter -> Bool)
-> (ColorMaterialParameter -> ColorMaterialParameter -> Bool)
-> (ColorMaterialParameter -> ColorMaterialParameter -> Bool)
-> (ColorMaterialParameter -> ColorMaterialParameter -> Bool)
-> (ColorMaterialParameter
    -> ColorMaterialParameter -> ColorMaterialParameter)
-> (ColorMaterialParameter
    -> ColorMaterialParameter -> ColorMaterialParameter)
-> Ord ColorMaterialParameter
ColorMaterialParameter -> ColorMaterialParameter -> Bool
ColorMaterialParameter -> ColorMaterialParameter -> Ordering
ColorMaterialParameter
-> ColorMaterialParameter -> ColorMaterialParameter
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: ColorMaterialParameter
-> ColorMaterialParameter -> ColorMaterialParameter
$cmin :: ColorMaterialParameter
-> ColorMaterialParameter -> ColorMaterialParameter
max :: ColorMaterialParameter
-> ColorMaterialParameter -> ColorMaterialParameter
$cmax :: ColorMaterialParameter
-> ColorMaterialParameter -> ColorMaterialParameter
>= :: ColorMaterialParameter -> ColorMaterialParameter -> Bool
$c>= :: ColorMaterialParameter -> ColorMaterialParameter -> Bool
> :: ColorMaterialParameter -> ColorMaterialParameter -> Bool
$c> :: ColorMaterialParameter -> ColorMaterialParameter -> Bool
<= :: ColorMaterialParameter -> ColorMaterialParameter -> Bool
$c<= :: ColorMaterialParameter -> ColorMaterialParameter -> Bool
< :: ColorMaterialParameter -> ColorMaterialParameter -> Bool
$c< :: ColorMaterialParameter -> ColorMaterialParameter -> Bool
compare :: ColorMaterialParameter -> ColorMaterialParameter -> Ordering
$ccompare :: ColorMaterialParameter -> ColorMaterialParameter -> Ordering
$cp1Ord :: Eq ColorMaterialParameter
Ord, Int -> ColorMaterialParameter -> ShowS
[ColorMaterialParameter] -> ShowS
ColorMaterialParameter -> String
(Int -> ColorMaterialParameter -> ShowS)
-> (ColorMaterialParameter -> String)
-> ([ColorMaterialParameter] -> ShowS)
-> Show ColorMaterialParameter
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ColorMaterialParameter] -> ShowS
$cshowList :: [ColorMaterialParameter] -> ShowS
show :: ColorMaterialParameter -> String
$cshow :: ColorMaterialParameter -> String
showsPrec :: Int -> ColorMaterialParameter -> ShowS
$cshowsPrec :: Int -> ColorMaterialParameter -> ShowS
Show )

marshalColorMaterialParameter :: ColorMaterialParameter -> GLenum
marshalColorMaterialParameter :: ColorMaterialParameter -> GLenum
marshalColorMaterialParameter x :: ColorMaterialParameter
x = case ColorMaterialParameter
x of
   Ambient -> GLenum
GL_AMBIENT
   Diffuse -> GLenum
GL_DIFFUSE
   Specular -> GLenum
GL_SPECULAR
   Emission -> GLenum
GL_EMISSION
   AmbientAndDiffuse -> GLenum
GL_AMBIENT_AND_DIFFUSE

unmarshalColorMaterialParameter :: GLenum -> ColorMaterialParameter
unmarshalColorMaterialParameter :: GLenum -> ColorMaterialParameter
unmarshalColorMaterialParameter x :: GLenum
x
   | GLenum
x GLenum -> GLenum -> Bool
forall a. Eq a => a -> a -> Bool
== GLenum
GL_AMBIENT = ColorMaterialParameter
Ambient
   | GLenum
x GLenum -> GLenum -> Bool
forall a. Eq a => a -> a -> Bool
== GLenum
GL_DIFFUSE = ColorMaterialParameter
Diffuse
   | GLenum
x GLenum -> GLenum -> Bool
forall a. Eq a => a -> a -> Bool
== GLenum
GL_SPECULAR = ColorMaterialParameter
Specular
   | GLenum
x GLenum -> GLenum -> Bool
forall a. Eq a => a -> a -> Bool
== GLenum
GL_EMISSION = ColorMaterialParameter
Emission
   | GLenum
x GLenum -> GLenum -> Bool
forall a. Eq a => a -> a -> Bool
== GLenum
GL_AMBIENT_AND_DIFFUSE = ColorMaterialParameter
AmbientAndDiffuse
   | Bool
otherwise = String -> ColorMaterialParameter
forall a. HasCallStack => String -> a
error ("unmarshalColorMaterialParameter: illegal value " String -> ShowS
forall a. [a] -> [a] -> [a]
++ GLenum -> String
forall a. Show a => a -> String
show GLenum
x)

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

colorMaterial :: StateVar (Maybe (Face, ColorMaterialParameter))
colorMaterial :: StateVar (Maybe (Face, ColorMaterialParameter))
colorMaterial =
   IO EnableCap
-> IO (Face, ColorMaterialParameter)
-> ((Face, ColorMaterialParameter) -> IO ())
-> StateVar (Maybe (Face, ColorMaterialParameter))
forall a.
IO EnableCap -> IO a -> (a -> IO ()) -> StateVar (Maybe a)
makeStateVarMaybe
      (EnableCap -> IO EnableCap
forall (m :: * -> *) a. Monad m => a -> m a
return EnableCap
CapColorMaterial)
      ((Face -> ColorMaterialParameter -> (Face, ColorMaterialParameter))
-> IO Face
-> IO ColorMaterialParameter
-> IO (Face, ColorMaterialParameter)
forall (m :: * -> *) a1 a2 r.
Monad m =>
(a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM2
         (,)
         ((GLenum -> Face) -> PName1I -> IO Face
forall p a. GetPName1I p => (GLenum -> a) -> p -> IO a
getEnum1 GLenum -> Face
unmarshalFace PName1I
GetColorMaterialFace)
         ((GLenum -> ColorMaterialParameter)
-> PName1I -> IO ColorMaterialParameter
forall p a. GetPName1I p => (GLenum -> a) -> p -> IO a
getEnum1 GLenum -> ColorMaterialParameter
unmarshalColorMaterialParameter PName1I
GetColorMaterialParameter))
      (\(face :: Face
face, param :: ColorMaterialParameter
param) -> GLenum -> GLenum -> IO ()
forall (m :: * -> *). MonadIO m => GLenum -> GLenum -> m ()
glColorMaterial (Face -> GLenum
marshalFace Face
face)
                                         (ColorMaterialParameter -> GLenum
marshalColorMaterialParameter ColorMaterialParameter
param))

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

data ShadingModel =
     Flat
   | Smooth
   deriving ( ShadingModel -> ShadingModel -> Bool
(ShadingModel -> ShadingModel -> Bool)
-> (ShadingModel -> ShadingModel -> Bool) -> Eq ShadingModel
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ShadingModel -> ShadingModel -> Bool
$c/= :: ShadingModel -> ShadingModel -> Bool
== :: ShadingModel -> ShadingModel -> Bool
$c== :: ShadingModel -> ShadingModel -> Bool
Eq, Eq ShadingModel
Eq ShadingModel =>
(ShadingModel -> ShadingModel -> Ordering)
-> (ShadingModel -> ShadingModel -> Bool)
-> (ShadingModel -> ShadingModel -> Bool)
-> (ShadingModel -> ShadingModel -> Bool)
-> (ShadingModel -> ShadingModel -> Bool)
-> (ShadingModel -> ShadingModel -> ShadingModel)
-> (ShadingModel -> ShadingModel -> ShadingModel)
-> Ord ShadingModel
ShadingModel -> ShadingModel -> Bool
ShadingModel -> ShadingModel -> Ordering
ShadingModel -> ShadingModel -> ShadingModel
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: ShadingModel -> ShadingModel -> ShadingModel
$cmin :: ShadingModel -> ShadingModel -> ShadingModel
max :: ShadingModel -> ShadingModel -> ShadingModel
$cmax :: ShadingModel -> ShadingModel -> ShadingModel
>= :: ShadingModel -> ShadingModel -> Bool
$c>= :: ShadingModel -> ShadingModel -> Bool
> :: ShadingModel -> ShadingModel -> Bool
$c> :: ShadingModel -> ShadingModel -> Bool
<= :: ShadingModel -> ShadingModel -> Bool
$c<= :: ShadingModel -> ShadingModel -> Bool
< :: ShadingModel -> ShadingModel -> Bool
$c< :: ShadingModel -> ShadingModel -> Bool
compare :: ShadingModel -> ShadingModel -> Ordering
$ccompare :: ShadingModel -> ShadingModel -> Ordering
$cp1Ord :: Eq ShadingModel
Ord, Int -> ShadingModel -> ShowS
[ShadingModel] -> ShowS
ShadingModel -> String
(Int -> ShadingModel -> ShowS)
-> (ShadingModel -> String)
-> ([ShadingModel] -> ShowS)
-> Show ShadingModel
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ShadingModel] -> ShowS
$cshowList :: [ShadingModel] -> ShowS
show :: ShadingModel -> String
$cshow :: ShadingModel -> String
showsPrec :: Int -> ShadingModel -> ShowS
$cshowsPrec :: Int -> ShadingModel -> ShowS
Show )

marshalShadingModel :: ShadingModel -> GLenum
marshalShadingModel :: ShadingModel -> GLenum
marshalShadingModel x :: ShadingModel
x = case ShadingModel
x of
   Flat -> GLenum
GL_FLAT
   Smooth -> GLenum
GL_SMOOTH

unmarshalShadingModel :: GLenum -> ShadingModel
unmarshalShadingModel :: GLenum -> ShadingModel
unmarshalShadingModel x :: GLenum
x
   | GLenum
x GLenum -> GLenum -> Bool
forall a. Eq a => a -> a -> Bool
== GLenum
GL_FLAT = ShadingModel
Flat
   | GLenum
x GLenum -> GLenum -> Bool
forall a. Eq a => a -> a -> Bool
== GLenum
GL_SMOOTH = ShadingModel
Smooth
   | Bool
otherwise = String -> ShadingModel
forall a. HasCallStack => String -> a
error ("unmarshalShadingModel: illegal value " String -> ShowS
forall a. [a] -> [a] -> [a]
++ GLenum -> String
forall a. Show a => a -> String
show GLenum
x)

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

shadeModel :: StateVar ShadingModel
shadeModel :: StateVar ShadingModel
shadeModel =
   IO ShadingModel -> (ShadingModel -> IO ()) -> StateVar ShadingModel
forall a. IO a -> (a -> IO ()) -> StateVar a
makeStateVar
      ((GLenum -> ShadingModel) -> PName1I -> IO ShadingModel
forall p a. GetPName1I p => (GLenum -> a) -> p -> IO a
getEnum1 GLenum -> ShadingModel
unmarshalShadingModel PName1I
GetShadeModel)
      (GLenum -> IO ()
forall (m :: * -> *). MonadIO m => GLenum -> m ()
glShadeModel (GLenum -> IO ())
-> (ShadingModel -> GLenum) -> ShadingModel -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ShadingModel -> GLenum
marshalShadingModel)

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

data ClampTarget =
     ClampVertexColor
   | ClampFragmentColor
   | ClampReadColor
   deriving ( ClampTarget -> ClampTarget -> Bool
(ClampTarget -> ClampTarget -> Bool)
-> (ClampTarget -> ClampTarget -> Bool) -> Eq ClampTarget
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ClampTarget -> ClampTarget -> Bool
$c/= :: ClampTarget -> ClampTarget -> Bool
== :: ClampTarget -> ClampTarget -> Bool
$c== :: ClampTarget -> ClampTarget -> Bool
Eq, Eq ClampTarget
Eq ClampTarget =>
(ClampTarget -> ClampTarget -> Ordering)
-> (ClampTarget -> ClampTarget -> Bool)
-> (ClampTarget -> ClampTarget -> Bool)
-> (ClampTarget -> ClampTarget -> Bool)
-> (ClampTarget -> ClampTarget -> Bool)
-> (ClampTarget -> ClampTarget -> ClampTarget)
-> (ClampTarget -> ClampTarget -> ClampTarget)
-> Ord ClampTarget
ClampTarget -> ClampTarget -> Bool
ClampTarget -> ClampTarget -> Ordering
ClampTarget -> ClampTarget -> ClampTarget
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: ClampTarget -> ClampTarget -> ClampTarget
$cmin :: ClampTarget -> ClampTarget -> ClampTarget
max :: ClampTarget -> ClampTarget -> ClampTarget
$cmax :: ClampTarget -> ClampTarget -> ClampTarget
>= :: ClampTarget -> ClampTarget -> Bool
$c>= :: ClampTarget -> ClampTarget -> Bool
> :: ClampTarget -> ClampTarget -> Bool
$c> :: ClampTarget -> ClampTarget -> Bool
<= :: ClampTarget -> ClampTarget -> Bool
$c<= :: ClampTarget -> ClampTarget -> Bool
< :: ClampTarget -> ClampTarget -> Bool
$c< :: ClampTarget -> ClampTarget -> Bool
compare :: ClampTarget -> ClampTarget -> Ordering
$ccompare :: ClampTarget -> ClampTarget -> Ordering
$cp1Ord :: Eq ClampTarget
Ord, Int -> ClampTarget -> ShowS
[ClampTarget] -> ShowS
ClampTarget -> String
(Int -> ClampTarget -> ShowS)
-> (ClampTarget -> String)
-> ([ClampTarget] -> ShowS)
-> Show ClampTarget
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ClampTarget] -> ShowS
$cshowList :: [ClampTarget] -> ShowS
show :: ClampTarget -> String
$cshow :: ClampTarget -> String
showsPrec :: Int -> ClampTarget -> ShowS
$cshowsPrec :: Int -> ClampTarget -> ShowS
Show )

marshalClampTarget :: ClampTarget -> GLenum
marshalClampTarget :: ClampTarget -> GLenum
marshalClampTarget x :: ClampTarget
x = case ClampTarget
x of
   ClampVertexColor -> GLenum
GL_CLAMP_VERTEX_COLOR
   ClampFragmentColor -> GLenum
GL_CLAMP_FRAGMENT_COLOR
   ClampReadColor -> GLenum
GL_CLAMP_READ_COLOR

marshalClampTargetToPName :: ClampTarget -> PName1I
marshalClampTargetToPName :: ClampTarget -> PName1I
marshalClampTargetToPName x :: ClampTarget
x = case ClampTarget
x of
   ClampFragmentColor -> PName1I
GetFragmentColorClamp
   ClampVertexColor -> PName1I
GetVertexColorClamp
   ClampReadColor -> PName1I
GetReadColorClamp

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

data ClampMode =
     ClampOn
   | FixedOnly
   | ClampOff
   deriving ( ClampMode -> ClampMode -> Bool
(ClampMode -> ClampMode -> Bool)
-> (ClampMode -> ClampMode -> Bool) -> Eq ClampMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ClampMode -> ClampMode -> Bool
$c/= :: ClampMode -> ClampMode -> Bool
== :: ClampMode -> ClampMode -> Bool
$c== :: ClampMode -> ClampMode -> Bool
Eq, Eq ClampMode
Eq ClampMode =>
(ClampMode -> ClampMode -> Ordering)
-> (ClampMode -> ClampMode -> Bool)
-> (ClampMode -> ClampMode -> Bool)
-> (ClampMode -> ClampMode -> Bool)
-> (ClampMode -> ClampMode -> Bool)
-> (ClampMode -> ClampMode -> ClampMode)
-> (ClampMode -> ClampMode -> ClampMode)
-> Ord ClampMode
ClampMode -> ClampMode -> Bool
ClampMode -> ClampMode -> Ordering
ClampMode -> ClampMode -> ClampMode
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: ClampMode -> ClampMode -> ClampMode
$cmin :: ClampMode -> ClampMode -> ClampMode
max :: ClampMode -> ClampMode -> ClampMode
$cmax :: ClampMode -> ClampMode -> ClampMode
>= :: ClampMode -> ClampMode -> Bool
$c>= :: ClampMode -> ClampMode -> Bool
> :: ClampMode -> ClampMode -> Bool
$c> :: ClampMode -> ClampMode -> Bool
<= :: ClampMode -> ClampMode -> Bool
$c<= :: ClampMode -> ClampMode -> Bool
< :: ClampMode -> ClampMode -> Bool
$c< :: ClampMode -> ClampMode -> Bool
compare :: ClampMode -> ClampMode -> Ordering
$ccompare :: ClampMode -> ClampMode -> Ordering
$cp1Ord :: Eq ClampMode
Ord, Int -> ClampMode -> ShowS
[ClampMode] -> ShowS
ClampMode -> String
(Int -> ClampMode -> ShowS)
-> (ClampMode -> String)
-> ([ClampMode] -> ShowS)
-> Show ClampMode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ClampMode] -> ShowS
$cshowList :: [ClampMode] -> ShowS
show :: ClampMode -> String
$cshow :: ClampMode -> String
showsPrec :: Int -> ClampMode -> ShowS
$cshowsPrec :: Int -> ClampMode -> ShowS
Show )

marshalClampMode :: ClampMode -> GLenum
marshalClampMode :: ClampMode -> GLenum
marshalClampMode x :: ClampMode
x = case ClampMode
x of
   ClampOn -> GLboolean -> GLenum
forall a b. (Integral a, Num b) => a -> b
fromIntegral GLboolean
GL_TRUE
   FixedOnly -> GLenum
GL_FIXED_ONLY
   ClampOff -> GLboolean -> GLenum
forall a b. (Integral a, Num b) => a -> b
fromIntegral GLboolean
GL_FALSE

unmarshalClampMode :: GLenum -> ClampMode
unmarshalClampMode :: GLenum -> ClampMode
unmarshalClampMode x :: GLenum
x
   | GLenum
x GLenum -> GLenum -> Bool
forall a. Eq a => a -> a -> Bool
== GLboolean -> GLenum
forall a b. (Integral a, Num b) => a -> b
fromIntegral GLboolean
GL_TRUE = ClampMode
ClampOn
   | GLenum
x GLenum -> GLenum -> Bool
forall a. Eq a => a -> a -> Bool
== GLenum
GL_FIXED_ONLY = ClampMode
FixedOnly
   | GLenum
x GLenum -> GLenum -> Bool
forall a. Eq a => a -> a -> Bool
== GLboolean -> GLenum
forall a b. (Integral a, Num b) => a -> b
fromIntegral GLboolean
GL_FALSE = ClampMode
ClampOff
   | Bool
otherwise = String -> ClampMode
forall a. HasCallStack => String -> a
error (String -> ClampMode) -> String -> ClampMode
forall a b. (a -> b) -> a -> b
$ "unmarshalClampMode: unknown enum value " String -> ShowS
forall a. [a] -> [a] -> [a]
++ GLenum -> String
forall a. Show a => a -> String
show GLenum
x

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

clampColor :: ClampTarget -> StateVar ClampMode
clampColor :: ClampTarget -> StateVar ClampMode
clampColor ct :: ClampTarget
ct = IO ClampMode -> (ClampMode -> IO ()) -> StateVar ClampMode
forall a. IO a -> (a -> IO ()) -> StateVar a
makeStateVar (ClampTarget -> IO ClampMode
getClampColor ClampTarget
ct) (ClampTarget -> ClampMode -> IO ()
forall (m :: * -> *). MonadIO m => ClampTarget -> ClampMode -> m ()
setClampColor ClampTarget
ct)
   where getClampColor :: ClampTarget -> IO ClampMode
getClampColor = (GLenum -> ClampMode) -> PName1I -> IO ClampMode
forall p a. GetPName1I p => (GLenum -> a) -> p -> IO a
getEnum1 GLenum -> ClampMode
unmarshalClampMode (PName1I -> IO ClampMode)
-> (ClampTarget -> PName1I) -> ClampTarget -> IO ClampMode
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ClampTarget -> PName1I
marshalClampTargetToPName
         setClampColor :: ClampTarget -> ClampMode -> m ()
setClampColor t :: ClampTarget
t = GLenum -> GLenum -> m ()
forall (m :: * -> *). MonadIO m => GLenum -> GLenum -> m ()
glClampColor (ClampTarget -> GLenum
marshalClampTarget ClampTarget
t) (GLenum -> m ()) -> (ClampMode -> GLenum) -> ClampMode -> m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ClampMode -> GLenum
marshalClampMode