--------------------------------------------------------------------------------
-- |
-- 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
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
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
Ord, Int -> ConvolutionTarget -> ShowS
[ConvolutionTarget] -> ShowS
ConvolutionTarget -> String
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 ConvolutionTarget
x = case ConvolutionTarget
x of
   ConvolutionTarget
Convolution1D -> GLenum
GL_CONVOLUTION_1D
   ConvolutionTarget
Convolution2D -> GLenum
GL_CONVOLUTION_2D
   ConvolutionTarget
Separable2D -> GLenum
GL_SEPARABLE_2D

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

getSeparableFilter2D :: PixelData a -> PixelData a -> IO ()
getSeparableFilter2D :: forall a. PixelData a -> PixelData a -> IO ()
getSeparableFilter2D PixelData a
pdRow PixelData a
pdCol =
   forall a b. PixelData a -> (GLenum -> GLenum -> Ptr a -> b) -> b
withPixelData PixelData a
pdRow forall a b. (a -> b) -> a -> b
$ \GLenum
f1 GLenum
d1 Ptr a
p1 ->
      forall a b. PixelData a -> (GLenum -> GLenum -> Ptr a -> b) -> b
withPixelData PixelData a
pdCol forall a b. (a -> b) -> a -> b
$ \GLenum
f2 GLenum
d2 Ptr a
p2 ->
         if GLenum
f1 forall a. Eq a => a -> a -> Bool
== GLenum
f2 Bool -> Bool -> Bool
&& GLenum
d1 forall a. Eq a => a -> a -> Bool
== GLenum
d2
            then 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 forall a. Ptr a
nullPtr
            else IO ()
recordInvalidValue

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

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

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

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

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

data ConvolutionParameter =
     ConvolutionBorderColor
   | ConvolutionBorderMode
   | ConvolutionFilterScale
   | ConvolutionFilterBias
   | ConvolutionFormat
   | ConvolutionWidth
   | ConvolutionHeight
   | MaxConvolutionWidth
   | MaxConvolutionHeight
   deriving ( ConvolutionParameter -> ConvolutionParameter -> Bool
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
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
Ord, Int -> ConvolutionParameter -> ShowS
[ConvolutionParameter] -> ShowS
ConvolutionParameter -> String
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 ConvolutionParameter
x = case ConvolutionParameter
x of
   ConvolutionParameter
ConvolutionBorderColor -> GLenum
GL_CONVOLUTION_BORDER_COLOR
   ConvolutionParameter
ConvolutionBorderMode -> GLenum
GL_CONVOLUTION_BORDER_MODE
   ConvolutionParameter
ConvolutionFilterScale -> GLenum
GL_CONVOLUTION_FILTER_SCALE
   ConvolutionParameter
ConvolutionFilterBias -> GLenum
GL_CONVOLUTION_FILTER_BIAS
   ConvolutionParameter
ConvolutionFormat -> GLenum
GL_CONVOLUTION_FORMAT
   ConvolutionParameter
ConvolutionWidth -> GLenum
GL_CONVOLUTION_WIDTH
   ConvolutionParameter
ConvolutionHeight -> GLenum
GL_CONVOLUTION_HEIGHT
   ConvolutionParameter
MaxConvolutionWidth -> GLenum
GL_MAX_CONVOLUTION_WIDTH
   ConvolutionParameter
MaxConvolutionHeight -> GLenum
GL_MAX_CONVOLUTION_HEIGHT

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

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

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

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

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

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

getConvolutionParameteri ::
   (GLint -> a) -> ConvolutionTarget -> ConvolutionParameter -> IO a
getConvolutionParameteri :: forall a.
(GLint -> a) -> ConvolutionTarget -> ConvolutionParameter -> IO a
getConvolutionParameteri GLint -> a
f ConvolutionTarget
t ConvolutionParameter
p =
   forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with GLint
0 forall a b. (a -> b) -> a -> b
$ \Ptr GLint
buf -> do
      forall (m :: * -> *).
MonadIO m =>
GLenum -> GLenum -> Ptr GLint -> m ()
glGetConvolutionParameteriv
         (ConvolutionTarget -> GLenum
marshalConvolutionTarget ConvolutionTarget
t) (ConvolutionParameter -> GLenum
marshalConvolutionParameter ConvolutionParameter
p) Ptr GLint
buf
      forall a b. Storable a => (a -> b) -> Ptr a -> IO b
peek1 GLint -> a
f Ptr GLint
buf

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

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

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

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

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

data ConvolutionBorderMode =
     Reduce
   | ConstantBorder (Color4 GLfloat)
   | ReplicateBorder
   deriving ( ConvolutionBorderMode -> ConvolutionBorderMode -> Bool
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
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
Ord, Int -> ConvolutionBorderMode -> ShowS
[ConvolutionBorderMode] -> ShowS
ConvolutionBorderMode -> String
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 ConvolutionTarget
t =
   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 ConvolutionTarget
t = do
   ConvolutionBorderMode'
mode <- forall a.
(GLint -> a) -> ConvolutionTarget -> ConvolutionParameter -> IO a
getConvolutionParameteri
              GLint -> ConvolutionBorderMode'
unmarshalConvolutionBorderMode' ConvolutionTarget
t ConvolutionParameter
ConvolutionBorderMode
   case ConvolutionBorderMode'
mode of
      ConvolutionBorderMode'
Reduce' -> forall (m :: * -> *) a. Monad m => a -> m a
return ConvolutionBorderMode
Reduce
      ConvolutionBorderMode'
ConstantBorder' -> do
         Color4 GLfloat
c <- ConvolutionTarget -> ConvolutionParameter -> IO (Color4 GLfloat)
getConvolutionParameterC4f ConvolutionTarget
t ConvolutionParameter
ConvolutionBorderColor
         forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Color4 GLfloat -> ConvolutionBorderMode
ConstantBorder Color4 GLfloat
c
      ConvolutionBorderMode'
ReplicateBorder' -> forall (m :: * -> *) a. Monad m => a -> m a
return ConvolutionBorderMode
ReplicateBorder

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

setConvolutionParameteri ::
   (a -> GLint) -> ConvolutionTarget -> ConvolutionParameter -> a -> IO ()
setConvolutionParameteri :: forall a.
(a -> GLint)
-> ConvolutionTarget -> ConvolutionParameter -> a -> IO ()
setConvolutionParameteri a -> GLint
f ConvolutionTarget
t ConvolutionParameter
p a
x =
   forall (m :: * -> *).
MonadIO m =>
GLenum -> GLenum -> GLint -> m ()
glConvolutionParameteri
      (ConvolutionTarget -> GLenum
marshalConvolutionTarget ConvolutionTarget
t) (ConvolutionParameter -> GLenum
marshalConvolutionParameter ConvolutionParameter
p) (a -> GLint
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 ConvolutionParameter
p ConvolutionTarget
t =
   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 ConvolutionTarget
t ConvolutionParameter
p =
   forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca forall a b. (a -> b) -> a -> b
$ \Ptr (Color4 GLfloat)
buf -> do
      forall (m :: * -> *).
MonadIO m =>
GLenum -> GLenum -> Ptr GLfloat -> m ()
glGetConvolutionParameterfv
         (ConvolutionTarget -> GLenum
marshalConvolutionTarget ConvolutionTarget
t) (ConvolutionParameter -> GLenum
marshalConvolutionParameter ConvolutionParameter
p) (forall a b. Ptr a -> Ptr b
castPtr Ptr (Color4 GLfloat)
buf)
      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 ConvolutionTarget
t ConvolutionParameter
p Color4 GLfloat
c =
   forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with Color4 GLfloat
c forall a b. (a -> b) -> a -> b
$ \Ptr (Color4 GLfloat)
ptr ->
      forall (m :: * -> *).
MonadIO m =>
GLenum -> GLenum -> Ptr GLfloat -> m ()
glConvolutionParameterfv
         (ConvolutionTarget -> GLenum
marshalConvolutionTarget ConvolutionTarget
t) (ConvolutionParameter -> GLenum
marshalConvolutionParameter ConvolutionParameter
p) (forall a b. Ptr a -> Ptr b
castPtr Ptr (Color4 GLfloat)
ptr)