--------------------------------------------------------------------------------
-- |
-- Module      :  Graphics.Rendering.OpenGL.GL.PixelRectangles.Convolution
-- Copyright   :  (c) Sven Panne 2002-2019
-- License     :  BSD3
--
-- Maintainer  :  Sven Panne <svenpanne@gmail.com>
-- Stability   :  stable
-- Portability :  portable
--
-- This module corresponds to a part of section 3.6.1 (Pixel Storage Modes) of
-- the OpenGL 2.1 specs.
--
--------------------------------------------------------------------------------

module Graphics.Rendering.OpenGL.GL.PixelRectangles.Convolution (
   ConvolutionTarget(..), convolution,
   convolutionFilter1D, getConvolutionFilter1D,
   convolutionFilter2D, getConvolutionFilter2D,
   separableFilter2D, getSeparableFilter2D,
   copyConvolutionFilter1D, copyConvolutionFilter2D,
   convolutionWidth, convolutionHeight,
   maxConvolutionWidth, maxConvolutionHeight,
   ConvolutionBorderMode(..), convolutionBorderMode,
   convolutionFilterScale, convolutionFilterBias,
) where

import Data.StateVar
import Foreign.Marshal.Alloc
import Foreign.Marshal.Utils
import Foreign.Ptr
import Foreign.Storable
import Graphics.Rendering.OpenGL.GL.Capability
import Graphics.Rendering.OpenGL.GL.CoordTrans
import Graphics.Rendering.OpenGL.GL.PeekPoke
import Graphics.Rendering.OpenGL.GL.PixelData
import Graphics.Rendering.OpenGL.GL.Texturing.PixelInternalFormat
import Graphics.Rendering.OpenGL.GL.VertexSpec
import Graphics.Rendering.OpenGL.GLU.ErrorsInternal
import Graphics.GL

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

data ConvolutionTarget =
     Convolution1D
   | Convolution2D
   | Separable2D
   deriving ( ConvolutionTarget -> ConvolutionTarget -> Bool
(ConvolutionTarget -> ConvolutionTarget -> Bool)
-> (ConvolutionTarget -> ConvolutionTarget -> Bool)
-> Eq ConvolutionTarget
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ConvolutionTarget -> ConvolutionTarget -> Bool
$c/= :: ConvolutionTarget -> ConvolutionTarget -> Bool
== :: ConvolutionTarget -> ConvolutionTarget -> Bool
$c== :: ConvolutionTarget -> ConvolutionTarget -> Bool
Eq, Eq ConvolutionTarget
Eq ConvolutionTarget =>
(ConvolutionTarget -> ConvolutionTarget -> Ordering)
-> (ConvolutionTarget -> ConvolutionTarget -> Bool)
-> (ConvolutionTarget -> ConvolutionTarget -> Bool)
-> (ConvolutionTarget -> ConvolutionTarget -> Bool)
-> (ConvolutionTarget -> ConvolutionTarget -> Bool)
-> (ConvolutionTarget -> ConvolutionTarget -> ConvolutionTarget)
-> (ConvolutionTarget -> ConvolutionTarget -> ConvolutionTarget)
-> Ord ConvolutionTarget
ConvolutionTarget -> ConvolutionTarget -> Bool
ConvolutionTarget -> ConvolutionTarget -> Ordering
ConvolutionTarget -> ConvolutionTarget -> ConvolutionTarget
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 :: ConvolutionTarget -> ConvolutionTarget -> ConvolutionTarget
$cmin :: ConvolutionTarget -> ConvolutionTarget -> ConvolutionTarget
max :: ConvolutionTarget -> ConvolutionTarget -> ConvolutionTarget
$cmax :: ConvolutionTarget -> ConvolutionTarget -> ConvolutionTarget
>= :: ConvolutionTarget -> ConvolutionTarget -> Bool
$c>= :: ConvolutionTarget -> ConvolutionTarget -> Bool
> :: ConvolutionTarget -> ConvolutionTarget -> Bool
$c> :: ConvolutionTarget -> ConvolutionTarget -> Bool
<= :: ConvolutionTarget -> ConvolutionTarget -> Bool
$c<= :: ConvolutionTarget -> ConvolutionTarget -> Bool
< :: ConvolutionTarget -> ConvolutionTarget -> Bool
$c< :: ConvolutionTarget -> ConvolutionTarget -> Bool
compare :: ConvolutionTarget -> ConvolutionTarget -> Ordering
$ccompare :: ConvolutionTarget -> ConvolutionTarget -> Ordering
$cp1Ord :: Eq ConvolutionTarget
Ord, Int -> ConvolutionTarget -> ShowS
[ConvolutionTarget] -> ShowS
ConvolutionTarget -> String
(Int -> ConvolutionTarget -> ShowS)
-> (ConvolutionTarget -> String)
-> ([ConvolutionTarget] -> ShowS)
-> Show ConvolutionTarget
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ConvolutionTarget] -> ShowS
$cshowList :: [ConvolutionTarget] -> ShowS
show :: ConvolutionTarget -> String
$cshow :: ConvolutionTarget -> String
showsPrec :: Int -> ConvolutionTarget -> ShowS
$cshowsPrec :: Int -> ConvolutionTarget -> ShowS
Show )

marshalConvolutionTarget :: ConvolutionTarget -> GLenum
marshalConvolutionTarget :: ConvolutionTarget -> GLenum
marshalConvolutionTarget x :: ConvolutionTarget
x = case ConvolutionTarget
x of
   Convolution1D -> GLenum
GL_CONVOLUTION_1D
   Convolution2D -> GLenum
GL_CONVOLUTION_2D
   Separable2D -> GLenum
GL_SEPARABLE_2D

convolutionTargetToEnableCap :: ConvolutionTarget -> EnableCap
convolutionTargetToEnableCap :: ConvolutionTarget -> EnableCap
convolutionTargetToEnableCap x :: ConvolutionTarget
x = case ConvolutionTarget
x of
   Convolution1D -> EnableCap
CapConvolution1D
   Convolution2D -> EnableCap
CapConvolution2D
   Separable2D -> EnableCap
CapSeparable2D

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

convolution :: ConvolutionTarget -> StateVar Capability
convolution :: ConvolutionTarget -> StateVar Capability
convolution = EnableCap -> StateVar Capability
makeCapability (EnableCap -> StateVar Capability)
-> (ConvolutionTarget -> EnableCap)
-> ConvolutionTarget
-> StateVar Capability
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ConvolutionTarget -> EnableCap
convolutionTargetToEnableCap

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

convolutionFilter1D :: PixelInternalFormat -> GLsizei -> PixelData a -> IO ()
convolutionFilter1D :: PixelInternalFormat -> GLsizei -> PixelData a -> IO ()
convolutionFilter1D int :: PixelInternalFormat
int w :: GLsizei
w pd :: PixelData a
pd =
   PixelData a -> (GLenum -> GLenum -> Ptr a -> IO ()) -> IO ()
forall a b. PixelData a -> (GLenum -> GLenum -> Ptr a -> b) -> b
withPixelData PixelData a
pd ((GLenum -> GLenum -> Ptr a -> IO ()) -> IO ())
-> (GLenum -> GLenum -> Ptr a -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$
      GLenum -> GLenum -> GLsizei -> GLenum -> GLenum -> Ptr a -> IO ()
forall (m :: * -> *) a.
MonadIO m =>
GLenum -> GLenum -> GLsizei -> GLenum -> GLenum -> Ptr a -> m ()
glConvolutionFilter1D
         (ConvolutionTarget -> GLenum
marshalConvolutionTarget ConvolutionTarget
Convolution1D)
         (PixelInternalFormat -> GLenum
marshalPixelInternalFormat' PixelInternalFormat
int) GLsizei
w

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

getConvolutionFilter1D :: PixelData a -> IO ()
getConvolutionFilter1D :: PixelData a -> IO ()
getConvolutionFilter1D = ConvolutionTarget -> PixelData a -> IO ()
forall a. ConvolutionTarget -> PixelData a -> IO ()
getConvolutionFilter ConvolutionTarget
Convolution1D

getConvolutionFilter :: ConvolutionTarget -> PixelData a -> IO ()
getConvolutionFilter :: ConvolutionTarget -> PixelData a -> IO ()
getConvolutionFilter t :: ConvolutionTarget
t pd :: PixelData a
pd =
   PixelData a -> (GLenum -> GLenum -> Ptr a -> IO ()) -> IO ()
forall a b. PixelData a -> (GLenum -> GLenum -> Ptr a -> b) -> b
withPixelData PixelData a
pd ((GLenum -> GLenum -> Ptr a -> IO ()) -> IO ())
-> (GLenum -> GLenum -> Ptr a -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ GLenum -> GLenum -> GLenum -> Ptr a -> IO ()
forall (m :: * -> *) a.
MonadIO m =>
GLenum -> GLenum -> GLenum -> Ptr a -> m ()
glGetConvolutionFilter (ConvolutionTarget -> GLenum
marshalConvolutionTarget ConvolutionTarget
t)

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

convolutionFilter2D :: PixelInternalFormat -> Size -> PixelData a -> IO ()
convolutionFilter2D :: PixelInternalFormat -> Size -> PixelData a -> IO ()
convolutionFilter2D int :: PixelInternalFormat
int (Size w :: GLsizei
w h :: GLsizei
h) pd :: PixelData a
pd =
   PixelData a -> (GLenum -> GLenum -> Ptr a -> IO ()) -> IO ()
forall a b. PixelData a -> (GLenum -> GLenum -> Ptr a -> b) -> b
withPixelData PixelData a
pd ((GLenum -> GLenum -> Ptr a -> IO ()) -> IO ())
-> (GLenum -> GLenum -> Ptr a -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$
      GLenum
-> GLenum
-> GLsizei
-> GLsizei
-> GLenum
-> GLenum
-> Ptr a
-> IO ()
forall (m :: * -> *) a.
MonadIO m =>
GLenum
-> GLenum
-> GLsizei
-> GLsizei
-> GLenum
-> GLenum
-> Ptr a
-> m ()
glConvolutionFilter2D
         (ConvolutionTarget -> GLenum
marshalConvolutionTarget ConvolutionTarget
Convolution2D)
         (PixelInternalFormat -> GLenum
marshalPixelInternalFormat' PixelInternalFormat
int) GLsizei
w GLsizei
h

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

getConvolutionFilter2D :: PixelData a -> IO ()
getConvolutionFilter2D :: PixelData a -> IO ()
getConvolutionFilter2D = ConvolutionTarget -> PixelData a -> IO ()
forall a. ConvolutionTarget -> PixelData a -> IO ()
getConvolutionFilter ConvolutionTarget
Convolution2D

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

separableFilter2D ::
   PixelInternalFormat -> Size -> PixelData a -> PixelData a -> IO ()
separableFilter2D :: PixelInternalFormat -> Size -> PixelData a -> PixelData a -> IO ()
separableFilter2D int :: PixelInternalFormat
int (Size w :: GLsizei
w h :: GLsizei
h) pdRow :: PixelData a
pdRow pdCol :: PixelData a
pdCol =
   PixelData a -> (GLenum -> GLenum -> Ptr a -> IO ()) -> IO ()
forall a b. PixelData a -> (GLenum -> GLenum -> Ptr a -> b) -> b
withPixelData PixelData a
pdRow ((GLenum -> GLenum -> Ptr a -> IO ()) -> IO ())
-> (GLenum -> GLenum -> Ptr a -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \f1 :: GLenum
f1 d1 :: GLenum
d1 p1 :: Ptr a
p1 ->
      PixelData a -> (GLenum -> GLenum -> Ptr a -> IO ()) -> IO ()
forall a b. PixelData a -> (GLenum -> GLenum -> Ptr a -> b) -> b
withPixelData PixelData a
pdCol ((GLenum -> GLenum -> Ptr a -> IO ()) -> IO ())
-> (GLenum -> GLenum -> Ptr a -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \f2 :: GLenum
f2 d2 :: GLenum
d2 p2 :: Ptr a
p2 ->
         if GLenum
f1 GLenum -> GLenum -> Bool
forall a. Eq a => a -> a -> Bool
== GLenum
f2 Bool -> Bool -> Bool
&& GLenum
d1 GLenum -> GLenum -> Bool
forall a. Eq a => a -> a -> Bool
== GLenum
d2
            then GLenum
-> GLenum
-> GLsizei
-> GLsizei
-> GLenum
-> GLenum
-> Ptr a
-> Ptr a
-> IO ()
forall (m :: * -> *) a b.
MonadIO m =>
GLenum
-> GLenum
-> GLsizei
-> GLsizei
-> GLenum
-> GLenum
-> Ptr a
-> Ptr b
-> m ()
glSeparableFilter2D
                    (ConvolutionTarget -> GLenum
marshalConvolutionTarget ConvolutionTarget
Separable2D)
                    (PixelInternalFormat -> GLenum
marshalPixelInternalFormat' PixelInternalFormat
int) GLsizei
w GLsizei
h GLenum
f1 GLenum
d1 Ptr a
p1 Ptr a
p2
            else IO ()
recordInvalidValue

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

getSeparableFilter2D :: PixelData a -> PixelData a -> IO ()
getSeparableFilter2D :: PixelData a -> PixelData a -> IO ()
getSeparableFilter2D pdRow :: PixelData a
pdRow pdCol :: PixelData a
pdCol =
   PixelData a -> (GLenum -> GLenum -> Ptr a -> IO ()) -> IO ()
forall a b. PixelData a -> (GLenum -> GLenum -> Ptr a -> b) -> b
withPixelData PixelData a
pdRow ((GLenum -> GLenum -> Ptr a -> IO ()) -> IO ())
-> (GLenum -> GLenum -> Ptr a -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \f1 :: GLenum
f1 d1 :: GLenum
d1 p1 :: Ptr a
p1 ->
      PixelData a -> (GLenum -> GLenum -> Ptr a -> IO ()) -> IO ()
forall a b. PixelData a -> (GLenum -> GLenum -> Ptr a -> b) -> b
withPixelData PixelData a
pdCol ((GLenum -> GLenum -> Ptr a -> IO ()) -> IO ())
-> (GLenum -> GLenum -> Ptr a -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \f2 :: GLenum
f2 d2 :: GLenum
d2 p2 :: Ptr a
p2 ->
         if GLenum
f1 GLenum -> GLenum -> Bool
forall a. Eq a => a -> a -> Bool
== GLenum
f2 Bool -> Bool -> Bool
&& GLenum
d1 GLenum -> GLenum -> Bool
forall a. Eq a => a -> a -> Bool
== GLenum
d2
            then GLenum -> GLenum -> GLenum -> Ptr a -> Ptr a -> Ptr Any -> IO ()
forall (m :: * -> *) a b c.
MonadIO m =>
GLenum -> GLenum -> GLenum -> Ptr a -> Ptr b -> Ptr c -> m ()
glGetSeparableFilter
                    (ConvolutionTarget -> GLenum
marshalConvolutionTarget ConvolutionTarget
Separable2D) GLenum
f1 GLenum
d1 Ptr a
p1 Ptr a
p2 Ptr Any
forall a. Ptr a
nullPtr
            else IO ()
recordInvalidValue

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

copyConvolutionFilter1D :: PixelInternalFormat -> Position -> GLsizei -> IO ()
copyConvolutionFilter1D :: PixelInternalFormat -> Position -> GLsizei -> IO ()
copyConvolutionFilter1D int :: PixelInternalFormat
int (Position x :: GLsizei
x y :: GLsizei
y) =
   GLenum -> GLenum -> GLsizei -> GLsizei -> GLsizei -> IO ()
forall (m :: * -> *).
MonadIO m =>
GLenum -> GLenum -> GLsizei -> GLsizei -> GLsizei -> m ()
glCopyConvolutionFilter1D
      (ConvolutionTarget -> GLenum
marshalConvolutionTarget ConvolutionTarget
Convolution1D) (PixelInternalFormat -> GLenum
marshalPixelInternalFormat' PixelInternalFormat
int)
      GLsizei
x GLsizei
y

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

copyConvolutionFilter2D :: PixelInternalFormat -> Position -> Size -> IO ()
copyConvolutionFilter2D :: PixelInternalFormat -> Position -> Size -> IO ()
copyConvolutionFilter2D int :: PixelInternalFormat
int (Position x :: GLsizei
x y :: GLsizei
y) (Size w :: GLsizei
w h :: GLsizei
h) =
   GLenum
-> GLenum -> GLsizei -> GLsizei -> GLsizei -> GLsizei -> IO ()
forall (m :: * -> *).
MonadIO m =>
GLenum
-> GLenum -> GLsizei -> GLsizei -> GLsizei -> GLsizei -> m ()
glCopyConvolutionFilter2D
      (ConvolutionTarget -> GLenum
marshalConvolutionTarget ConvolutionTarget
Convolution2D) (PixelInternalFormat -> GLenum
marshalPixelInternalFormat' PixelInternalFormat
int)
      GLsizei
x GLsizei
y GLsizei
w GLsizei
h

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

data ConvolutionParameter =
     ConvolutionBorderColor
   | ConvolutionBorderMode
   | ConvolutionFilterScale
   | ConvolutionFilterBias
   | ConvolutionFormat
   | ConvolutionWidth
   | ConvolutionHeight
   | MaxConvolutionWidth
   | MaxConvolutionHeight
   deriving ( ConvolutionParameter -> ConvolutionParameter -> Bool
(ConvolutionParameter -> ConvolutionParameter -> Bool)
-> (ConvolutionParameter -> ConvolutionParameter -> Bool)
-> Eq ConvolutionParameter
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ConvolutionParameter -> ConvolutionParameter -> Bool
$c/= :: ConvolutionParameter -> ConvolutionParameter -> Bool
== :: ConvolutionParameter -> ConvolutionParameter -> Bool
$c== :: ConvolutionParameter -> ConvolutionParameter -> Bool
Eq, Eq ConvolutionParameter
Eq ConvolutionParameter =>
(ConvolutionParameter -> ConvolutionParameter -> Ordering)
-> (ConvolutionParameter -> ConvolutionParameter -> Bool)
-> (ConvolutionParameter -> ConvolutionParameter -> Bool)
-> (ConvolutionParameter -> ConvolutionParameter -> Bool)
-> (ConvolutionParameter -> ConvolutionParameter -> Bool)
-> (ConvolutionParameter
    -> ConvolutionParameter -> ConvolutionParameter)
-> (ConvolutionParameter
    -> ConvolutionParameter -> ConvolutionParameter)
-> Ord ConvolutionParameter
ConvolutionParameter -> ConvolutionParameter -> Bool
ConvolutionParameter -> ConvolutionParameter -> Ordering
ConvolutionParameter
-> ConvolutionParameter -> ConvolutionParameter
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 :: ConvolutionParameter
-> ConvolutionParameter -> ConvolutionParameter
$cmin :: ConvolutionParameter
-> ConvolutionParameter -> ConvolutionParameter
max :: ConvolutionParameter
-> ConvolutionParameter -> ConvolutionParameter
$cmax :: ConvolutionParameter
-> ConvolutionParameter -> ConvolutionParameter
>= :: ConvolutionParameter -> ConvolutionParameter -> Bool
$c>= :: ConvolutionParameter -> ConvolutionParameter -> Bool
> :: ConvolutionParameter -> ConvolutionParameter -> Bool
$c> :: ConvolutionParameter -> ConvolutionParameter -> Bool
<= :: ConvolutionParameter -> ConvolutionParameter -> Bool
$c<= :: ConvolutionParameter -> ConvolutionParameter -> Bool
< :: ConvolutionParameter -> ConvolutionParameter -> Bool
$c< :: ConvolutionParameter -> ConvolutionParameter -> Bool
compare :: ConvolutionParameter -> ConvolutionParameter -> Ordering
$ccompare :: ConvolutionParameter -> ConvolutionParameter -> Ordering
$cp1Ord :: Eq ConvolutionParameter
Ord, Int -> ConvolutionParameter -> ShowS
[ConvolutionParameter] -> ShowS
ConvolutionParameter -> String
(Int -> ConvolutionParameter -> ShowS)
-> (ConvolutionParameter -> String)
-> ([ConvolutionParameter] -> ShowS)
-> Show ConvolutionParameter
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ConvolutionParameter] -> ShowS
$cshowList :: [ConvolutionParameter] -> ShowS
show :: ConvolutionParameter -> String
$cshow :: ConvolutionParameter -> String
showsPrec :: Int -> ConvolutionParameter -> ShowS
$cshowsPrec :: Int -> ConvolutionParameter -> ShowS
Show )

marshalConvolutionParameter :: ConvolutionParameter -> GLenum
marshalConvolutionParameter :: ConvolutionParameter -> GLenum
marshalConvolutionParameter x :: ConvolutionParameter
x = case ConvolutionParameter
x of
   ConvolutionBorderColor -> GLenum
GL_CONVOLUTION_BORDER_COLOR
   ConvolutionBorderMode -> GLenum
GL_CONVOLUTION_BORDER_MODE
   ConvolutionFilterScale -> GLenum
GL_CONVOLUTION_FILTER_SCALE
   ConvolutionFilterBias -> GLenum
GL_CONVOLUTION_FILTER_BIAS
   ConvolutionFormat -> GLenum
GL_CONVOLUTION_FORMAT
   ConvolutionWidth -> GLenum
GL_CONVOLUTION_WIDTH
   ConvolutionHeight -> GLenum
GL_CONVOLUTION_HEIGHT
   MaxConvolutionWidth -> GLenum
GL_MAX_CONVOLUTION_WIDTH
   MaxConvolutionHeight -> GLenum
GL_MAX_CONVOLUTION_HEIGHT

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

convolutionWidth :: ConvolutionTarget -> GettableStateVar GLsizei
convolutionWidth :: ConvolutionTarget -> GettableStateVar GLsizei
convolutionWidth t :: ConvolutionTarget
t = ConvolutionTarget
-> ConvolutionParameter -> GettableStateVar GLsizei
convolutionParameteri ConvolutionTarget
t ConvolutionParameter
ConvolutionWidth

convolutionHeight :: ConvolutionTarget -> GettableStateVar GLsizei
convolutionHeight :: ConvolutionTarget -> GettableStateVar GLsizei
convolutionHeight t :: ConvolutionTarget
t = ConvolutionTarget
-> ConvolutionParameter -> GettableStateVar GLsizei
convolutionParameteri ConvolutionTarget
t ConvolutionParameter
ConvolutionHeight

maxConvolutionWidth :: ConvolutionTarget -> GettableStateVar GLsizei
maxConvolutionWidth :: ConvolutionTarget -> GettableStateVar GLsizei
maxConvolutionWidth t :: ConvolutionTarget
t = ConvolutionTarget
-> ConvolutionParameter -> GettableStateVar GLsizei
convolutionParameteri ConvolutionTarget
t ConvolutionParameter
MaxConvolutionWidth

maxConvolutionHeight :: ConvolutionTarget -> GettableStateVar GLsizei
maxConvolutionHeight :: ConvolutionTarget -> GettableStateVar GLsizei
maxConvolutionHeight t :: ConvolutionTarget
t = ConvolutionTarget
-> ConvolutionParameter -> GettableStateVar GLsizei
convolutionParameteri ConvolutionTarget
t ConvolutionParameter
MaxConvolutionHeight

convolutionParameteri ::
   ConvolutionTarget -> ConvolutionParameter -> GettableStateVar GLsizei
convolutionParameteri :: ConvolutionTarget
-> ConvolutionParameter -> GettableStateVar GLsizei
convolutionParameteri t :: ConvolutionTarget
t p :: ConvolutionParameter
p =
   GettableStateVar GLsizei -> GettableStateVar GLsizei
forall a. IO a -> IO a
makeGettableStateVar ((GLsizei -> GLsizei)
-> ConvolutionTarget
-> ConvolutionParameter
-> GettableStateVar GLsizei
forall a.
(GLsizei -> a) -> ConvolutionTarget -> ConvolutionParameter -> IO a
getConvolutionParameteri GLsizei -> GLsizei
forall a b. (Integral a, Num b) => a -> b
fromIntegral ConvolutionTarget
t ConvolutionParameter
p)

getConvolutionParameteri ::
   (GLint -> a) -> ConvolutionTarget -> ConvolutionParameter -> IO a
getConvolutionParameteri :: (GLsizei -> a) -> ConvolutionTarget -> ConvolutionParameter -> IO a
getConvolutionParameteri f :: GLsizei -> a
f t :: ConvolutionTarget
t p :: ConvolutionParameter
p =
   GLsizei -> (Ptr GLsizei -> IO a) -> IO a
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with 0 ((Ptr GLsizei -> IO a) -> IO a) -> (Ptr GLsizei -> IO a) -> IO a
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 ()
glGetConvolutionParameteriv
         (ConvolutionTarget -> GLenum
marshalConvolutionTarget ConvolutionTarget
t) (ConvolutionParameter -> GLenum
marshalConvolutionParameter ConvolutionParameter
p) Ptr GLsizei
buf
      (GLsizei -> a) -> Ptr GLsizei -> IO a
forall a b. Storable a => (a -> b) -> Ptr a -> IO b
peek1 GLsizei -> a
f Ptr GLsizei
buf

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

data ConvolutionBorderMode' =
     Reduce'
   | ConstantBorder'
   | ReplicateBorder'

marshalConvolutionBorderMode' :: ConvolutionBorderMode' -> GLint
marshalConvolutionBorderMode' :: ConvolutionBorderMode' -> GLsizei
marshalConvolutionBorderMode' x :: ConvolutionBorderMode'
x = GLenum -> GLsizei
forall a b. (Integral a, Num b) => a -> b
fromIntegral (GLenum -> GLsizei) -> GLenum -> GLsizei
forall a b. (a -> b) -> a -> b
$ case ConvolutionBorderMode'
x of
   Reduce' -> GLenum
GL_REDUCE
   ConstantBorder' -> GLenum
GL_CONSTANT_BORDER
   ReplicateBorder' -> GLenum
GL_REPLICATE_BORDER

unmarshalConvolutionBorderMode' :: GLint -> ConvolutionBorderMode'
unmarshalConvolutionBorderMode' :: GLsizei -> ConvolutionBorderMode'
unmarshalConvolutionBorderMode' x :: GLsizei
x
   | GLenum
y GLenum -> GLenum -> Bool
forall a. Eq a => a -> a -> Bool
== GLenum
GL_REDUCE = ConvolutionBorderMode'
Reduce'
   | GLenum
y GLenum -> GLenum -> Bool
forall a. Eq a => a -> a -> Bool
== GLenum
GL_CONSTANT_BORDER = ConvolutionBorderMode'
ConstantBorder'
   | GLenum
y GLenum -> GLenum -> Bool
forall a. Eq a => a -> a -> Bool
== GLenum
GL_REPLICATE_BORDER = ConvolutionBorderMode'
ReplicateBorder'
   | Bool
otherwise = String -> ConvolutionBorderMode'
forall a. HasCallStack => String -> a
error ("unmarshalConvolutionBorderMode': illegal value " String -> ShowS
forall a. [a] -> [a] -> [a]
++ GLsizei -> String
forall a. Show a => a -> String
show GLsizei
x)
   where y :: GLenum
y = GLsizei -> GLenum
forall a b. (Integral a, Num b) => a -> b
fromIntegral GLsizei
x

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

data ConvolutionBorderMode =
     Reduce
   | ConstantBorder (Color4 GLfloat)
   | ReplicateBorder
   deriving ( ConvolutionBorderMode -> ConvolutionBorderMode -> Bool
(ConvolutionBorderMode -> ConvolutionBorderMode -> Bool)
-> (ConvolutionBorderMode -> ConvolutionBorderMode -> Bool)
-> Eq ConvolutionBorderMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ConvolutionBorderMode -> ConvolutionBorderMode -> Bool
$c/= :: ConvolutionBorderMode -> ConvolutionBorderMode -> Bool
== :: ConvolutionBorderMode -> ConvolutionBorderMode -> Bool
$c== :: ConvolutionBorderMode -> ConvolutionBorderMode -> Bool
Eq, Eq ConvolutionBorderMode
Eq ConvolutionBorderMode =>
(ConvolutionBorderMode -> ConvolutionBorderMode -> Ordering)
-> (ConvolutionBorderMode -> ConvolutionBorderMode -> Bool)
-> (ConvolutionBorderMode -> ConvolutionBorderMode -> Bool)
-> (ConvolutionBorderMode -> ConvolutionBorderMode -> Bool)
-> (ConvolutionBorderMode -> ConvolutionBorderMode -> Bool)
-> (ConvolutionBorderMode
    -> ConvolutionBorderMode -> ConvolutionBorderMode)
-> (ConvolutionBorderMode
    -> ConvolutionBorderMode -> ConvolutionBorderMode)
-> Ord ConvolutionBorderMode
ConvolutionBorderMode -> ConvolutionBorderMode -> Bool
ConvolutionBorderMode -> ConvolutionBorderMode -> Ordering
ConvolutionBorderMode
-> ConvolutionBorderMode -> ConvolutionBorderMode
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 :: ConvolutionBorderMode
-> ConvolutionBorderMode -> ConvolutionBorderMode
$cmin :: ConvolutionBorderMode
-> ConvolutionBorderMode -> ConvolutionBorderMode
max :: ConvolutionBorderMode
-> ConvolutionBorderMode -> ConvolutionBorderMode
$cmax :: ConvolutionBorderMode
-> ConvolutionBorderMode -> ConvolutionBorderMode
>= :: ConvolutionBorderMode -> ConvolutionBorderMode -> Bool
$c>= :: ConvolutionBorderMode -> ConvolutionBorderMode -> Bool
> :: ConvolutionBorderMode -> ConvolutionBorderMode -> Bool
$c> :: ConvolutionBorderMode -> ConvolutionBorderMode -> Bool
<= :: ConvolutionBorderMode -> ConvolutionBorderMode -> Bool
$c<= :: ConvolutionBorderMode -> ConvolutionBorderMode -> Bool
< :: ConvolutionBorderMode -> ConvolutionBorderMode -> Bool
$c< :: ConvolutionBorderMode -> ConvolutionBorderMode -> Bool
compare :: ConvolutionBorderMode -> ConvolutionBorderMode -> Ordering
$ccompare :: ConvolutionBorderMode -> ConvolutionBorderMode -> Ordering
$cp1Ord :: Eq ConvolutionBorderMode
Ord, Int -> ConvolutionBorderMode -> ShowS
[ConvolutionBorderMode] -> ShowS
ConvolutionBorderMode -> String
(Int -> ConvolutionBorderMode -> ShowS)
-> (ConvolutionBorderMode -> String)
-> ([ConvolutionBorderMode] -> ShowS)
-> Show ConvolutionBorderMode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ConvolutionBorderMode] -> ShowS
$cshowList :: [ConvolutionBorderMode] -> ShowS
show :: ConvolutionBorderMode -> String
$cshow :: ConvolutionBorderMode -> String
showsPrec :: Int -> ConvolutionBorderMode -> ShowS
$cshowsPrec :: Int -> ConvolutionBorderMode -> ShowS
Show )

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

convolutionBorderMode :: ConvolutionTarget -> StateVar ConvolutionBorderMode
convolutionBorderMode :: ConvolutionTarget -> StateVar ConvolutionBorderMode
convolutionBorderMode t :: ConvolutionTarget
t =
   IO ConvolutionBorderMode
-> (ConvolutionBorderMode -> IO ())
-> StateVar ConvolutionBorderMode
forall a. IO a -> (a -> IO ()) -> StateVar a
makeStateVar (ConvolutionTarget -> IO ConvolutionBorderMode
getConvolutionBorderMode ConvolutionTarget
t) (ConvolutionTarget -> ConvolutionBorderMode -> IO ()
setConvolutionBorderMode ConvolutionTarget
t)

getConvolutionBorderMode :: ConvolutionTarget -> IO ConvolutionBorderMode
getConvolutionBorderMode :: ConvolutionTarget -> IO ConvolutionBorderMode
getConvolutionBorderMode t :: ConvolutionTarget
t = do
   ConvolutionBorderMode'
mode <- (GLsizei -> ConvolutionBorderMode')
-> ConvolutionTarget
-> ConvolutionParameter
-> IO ConvolutionBorderMode'
forall a.
(GLsizei -> a) -> ConvolutionTarget -> ConvolutionParameter -> IO a
getConvolutionParameteri
              GLsizei -> ConvolutionBorderMode'
unmarshalConvolutionBorderMode' ConvolutionTarget
t ConvolutionParameter
ConvolutionBorderMode
   case ConvolutionBorderMode'
mode of
      Reduce' -> ConvolutionBorderMode -> IO ConvolutionBorderMode
forall (m :: * -> *) a. Monad m => a -> m a
return ConvolutionBorderMode
Reduce
      ConstantBorder' -> do
         Color4 GLfloat
c <- ConvolutionTarget -> ConvolutionParameter -> IO (Color4 GLfloat)
getConvolutionParameterC4f ConvolutionTarget
t ConvolutionParameter
ConvolutionBorderColor
         ConvolutionBorderMode -> IO ConvolutionBorderMode
forall (m :: * -> *) a. Monad m => a -> m a
return (ConvolutionBorderMode -> IO ConvolutionBorderMode)
-> ConvolutionBorderMode -> IO ConvolutionBorderMode
forall a b. (a -> b) -> a -> b
$ Color4 GLfloat -> ConvolutionBorderMode
ConstantBorder Color4 GLfloat
c
      ReplicateBorder' -> ConvolutionBorderMode -> IO ConvolutionBorderMode
forall (m :: * -> *) a. Monad m => a -> m a
return ConvolutionBorderMode
ReplicateBorder

setConvolutionBorderMode :: ConvolutionTarget -> ConvolutionBorderMode -> IO ()
setConvolutionBorderMode :: ConvolutionTarget -> ConvolutionBorderMode -> IO ()
setConvolutionBorderMode t :: ConvolutionTarget
t mode :: ConvolutionBorderMode
mode = do
   let setBM :: ConvolutionBorderMode' -> IO ()
setBM = (ConvolutionBorderMode' -> GLsizei)
-> ConvolutionTarget
-> ConvolutionParameter
-> ConvolutionBorderMode'
-> IO ()
forall a.
(a -> GLsizei)
-> ConvolutionTarget -> ConvolutionParameter -> a -> IO ()
setConvolutionParameteri
                  ConvolutionBorderMode' -> GLsizei
marshalConvolutionBorderMode' ConvolutionTarget
t ConvolutionParameter
ConvolutionBorderMode
   case ConvolutionBorderMode
mode of
      Reduce -> ConvolutionBorderMode' -> IO ()
setBM ConvolutionBorderMode'
Reduce'
      ConstantBorder c :: Color4 GLfloat
c -> do
         ConvolutionBorderMode' -> IO ()
setBM ConvolutionBorderMode'
ConstantBorder'
         ConvolutionTarget
-> ConvolutionParameter -> Color4 GLfloat -> IO ()
convolutionParameterC4f ConvolutionTarget
t ConvolutionParameter
ConvolutionBorderColor Color4 GLfloat
c
      ReplicateBorder -> ConvolutionBorderMode' -> IO ()
setBM ConvolutionBorderMode'
ReplicateBorder'

setConvolutionParameteri ::
   (a -> GLint) -> ConvolutionTarget -> ConvolutionParameter -> a -> IO ()
setConvolutionParameteri :: (a -> GLsizei)
-> ConvolutionTarget -> ConvolutionParameter -> a -> IO ()
setConvolutionParameteri f :: a -> GLsizei
f t :: ConvolutionTarget
t p :: ConvolutionParameter
p x :: a
x =
   GLenum -> GLenum -> GLsizei -> IO ()
forall (m :: * -> *).
MonadIO m =>
GLenum -> GLenum -> GLsizei -> m ()
glConvolutionParameteri
      (ConvolutionTarget -> GLenum
marshalConvolutionTarget ConvolutionTarget
t) (ConvolutionParameter -> GLenum
marshalConvolutionParameter ConvolutionParameter
p) (a -> GLsizei
f a
x)

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

convolutionFilterScale :: ConvolutionTarget -> StateVar (Color4 GLfloat)
convolutionFilterScale :: ConvolutionTarget -> StateVar (Color4 GLfloat)
convolutionFilterScale = ConvolutionParameter
-> ConvolutionTarget -> StateVar (Color4 GLfloat)
convolutionC4f ConvolutionParameter
ConvolutionFilterScale

convolutionFilterBias :: ConvolutionTarget -> StateVar (Color4 GLfloat)
convolutionFilterBias :: ConvolutionTarget -> StateVar (Color4 GLfloat)
convolutionFilterBias = ConvolutionParameter
-> ConvolutionTarget -> StateVar (Color4 GLfloat)
convolutionC4f ConvolutionParameter
ConvolutionFilterBias

convolutionC4f ::
   ConvolutionParameter -> ConvolutionTarget -> StateVar (Color4 GLfloat)
convolutionC4f :: ConvolutionParameter
-> ConvolutionTarget -> StateVar (Color4 GLfloat)
convolutionC4f p :: ConvolutionParameter
p t :: ConvolutionTarget
t =
   IO (Color4 GLfloat)
-> (Color4 GLfloat -> IO ()) -> StateVar (Color4 GLfloat)
forall a. IO a -> (a -> IO ()) -> StateVar a
makeStateVar (ConvolutionTarget -> ConvolutionParameter -> IO (Color4 GLfloat)
getConvolutionParameterC4f ConvolutionTarget
t ConvolutionParameter
p) (ConvolutionTarget
-> ConvolutionParameter -> Color4 GLfloat -> IO ()
convolutionParameterC4f ConvolutionTarget
t ConvolutionParameter
p)

getConvolutionParameterC4f ::
   ConvolutionTarget -> ConvolutionParameter -> IO (Color4 GLfloat)
getConvolutionParameterC4f :: ConvolutionTarget -> ConvolutionParameter -> IO (Color4 GLfloat)
getConvolutionParameterC4f t :: ConvolutionTarget
t p :: ConvolutionParameter
p =
   (Ptr (Color4 GLfloat) -> IO (Color4 GLfloat))
-> IO (Color4 GLfloat)
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr (Color4 GLfloat) -> IO (Color4 GLfloat))
 -> IO (Color4 GLfloat))
-> (Ptr (Color4 GLfloat) -> IO (Color4 GLfloat))
-> IO (Color4 GLfloat)
forall a b. (a -> b) -> a -> b
$ \buf :: Ptr (Color4 GLfloat)
buf -> do
      GLenum -> GLenum -> Ptr GLfloat -> IO ()
forall (m :: * -> *).
MonadIO m =>
GLenum -> GLenum -> Ptr GLfloat -> m ()
glGetConvolutionParameterfv
         (ConvolutionTarget -> GLenum
marshalConvolutionTarget ConvolutionTarget
t) (ConvolutionParameter -> GLenum
marshalConvolutionParameter ConvolutionParameter
p) (Ptr (Color4 GLfloat) -> Ptr GLfloat
forall a b. Ptr a -> Ptr b
castPtr Ptr (Color4 GLfloat)
buf)
      Ptr (Color4 GLfloat) -> IO (Color4 GLfloat)
forall a. Storable a => Ptr a -> IO a
peek Ptr (Color4 GLfloat)
buf

convolutionParameterC4f ::
   ConvolutionTarget -> ConvolutionParameter -> Color4 GLfloat -> IO ()
convolutionParameterC4f :: ConvolutionTarget
-> ConvolutionParameter -> Color4 GLfloat -> IO ()
convolutionParameterC4f t :: ConvolutionTarget
t p :: ConvolutionParameter
p 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
$ \ptr :: Ptr (Color4 GLfloat)
ptr ->
      GLenum -> GLenum -> Ptr GLfloat -> IO ()
forall (m :: * -> *).
MonadIO m =>
GLenum -> GLenum -> Ptr GLfloat -> m ()
glConvolutionParameterfv
         (ConvolutionTarget -> GLenum
marshalConvolutionTarget ConvolutionTarget
t) (ConvolutionParameter -> GLenum
marshalConvolutionParameter ConvolutionParameter
p) (Ptr (Color4 GLfloat) -> Ptr GLfloat
forall a b. Ptr a -> Ptr b
castPtr Ptr (Color4 GLfloat)
ptr)