{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Cogl.Structs.Material
(
Material(..) ,
#if defined(ENABLE_OVERLOADING)
ResolveMaterialMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
MaterialGetAmbientMethodInfo ,
#endif
materialGetAmbient ,
#if defined(ENABLE_OVERLOADING)
MaterialGetColorMethodInfo ,
#endif
materialGetColor ,
#if defined(ENABLE_OVERLOADING)
MaterialGetDiffuseMethodInfo ,
#endif
materialGetDiffuse ,
#if defined(ENABLE_OVERLOADING)
MaterialGetEmissionMethodInfo ,
#endif
materialGetEmission ,
#if defined(ENABLE_OVERLOADING)
MaterialGetLayerPointSpriteCoordsEnabledMethodInfo,
#endif
materialGetLayerPointSpriteCoordsEnabled,
#if defined(ENABLE_OVERLOADING)
MaterialGetLayerWrapModePMethodInfo ,
#endif
materialGetLayerWrapModeP ,
#if defined(ENABLE_OVERLOADING)
MaterialGetLayerWrapModeSMethodInfo ,
#endif
materialGetLayerWrapModeS ,
#if defined(ENABLE_OVERLOADING)
MaterialGetLayerWrapModeTMethodInfo ,
#endif
materialGetLayerWrapModeT ,
#if defined(ENABLE_OVERLOADING)
MaterialGetLayersMethodInfo ,
#endif
materialGetLayers ,
#if defined(ENABLE_OVERLOADING)
MaterialGetNLayersMethodInfo ,
#endif
materialGetNLayers ,
#if defined(ENABLE_OVERLOADING)
MaterialGetPointSizeMethodInfo ,
#endif
materialGetPointSize ,
#if defined(ENABLE_OVERLOADING)
MaterialGetShininessMethodInfo ,
#endif
materialGetShininess ,
#if defined(ENABLE_OVERLOADING)
MaterialGetSpecularMethodInfo ,
#endif
materialGetSpecular ,
#if defined(ENABLE_OVERLOADING)
MaterialGetUserProgramMethodInfo ,
#endif
materialGetUserProgram ,
materialRef ,
#if defined(ENABLE_OVERLOADING)
MaterialRemoveLayerMethodInfo ,
#endif
materialRemoveLayer ,
#if defined(ENABLE_OVERLOADING)
MaterialSetAlphaTestFunctionMethodInfo ,
#endif
materialSetAlphaTestFunction ,
#if defined(ENABLE_OVERLOADING)
MaterialSetAmbientMethodInfo ,
#endif
materialSetAmbient ,
#if defined(ENABLE_OVERLOADING)
MaterialSetAmbientAndDiffuseMethodInfo ,
#endif
materialSetAmbientAndDiffuse ,
#if defined(ENABLE_OVERLOADING)
MaterialSetBlendMethodInfo ,
#endif
materialSetBlend ,
#if defined(ENABLE_OVERLOADING)
MaterialSetBlendConstantMethodInfo ,
#endif
materialSetBlendConstant ,
#if defined(ENABLE_OVERLOADING)
MaterialSetColorMethodInfo ,
#endif
materialSetColor ,
#if defined(ENABLE_OVERLOADING)
MaterialSetColor4fMethodInfo ,
#endif
materialSetColor4f ,
#if defined(ENABLE_OVERLOADING)
MaterialSetColor4ubMethodInfo ,
#endif
materialSetColor4ub ,
#if defined(ENABLE_OVERLOADING)
MaterialSetDiffuseMethodInfo ,
#endif
materialSetDiffuse ,
#if defined(ENABLE_OVERLOADING)
MaterialSetEmissionMethodInfo ,
#endif
materialSetEmission ,
#if defined(ENABLE_OVERLOADING)
MaterialSetLayerMethodInfo ,
#endif
materialSetLayer ,
#if defined(ENABLE_OVERLOADING)
MaterialSetLayerCombineMethodInfo ,
#endif
materialSetLayerCombine ,
#if defined(ENABLE_OVERLOADING)
MaterialSetLayerCombineConstantMethodInfo,
#endif
materialSetLayerCombineConstant ,
#if defined(ENABLE_OVERLOADING)
MaterialSetLayerFiltersMethodInfo ,
#endif
materialSetLayerFilters ,
#if defined(ENABLE_OVERLOADING)
MaterialSetLayerMatrixMethodInfo ,
#endif
materialSetLayerMatrix ,
#if defined(ENABLE_OVERLOADING)
MaterialSetLayerPointSpriteCoordsEnabledMethodInfo,
#endif
materialSetLayerPointSpriteCoordsEnabled,
#if defined(ENABLE_OVERLOADING)
MaterialSetLayerWrapModeMethodInfo ,
#endif
materialSetLayerWrapMode ,
#if defined(ENABLE_OVERLOADING)
MaterialSetLayerWrapModePMethodInfo ,
#endif
materialSetLayerWrapModeP ,
#if defined(ENABLE_OVERLOADING)
MaterialSetLayerWrapModeSMethodInfo ,
#endif
materialSetLayerWrapModeS ,
#if defined(ENABLE_OVERLOADING)
MaterialSetLayerWrapModeTMethodInfo ,
#endif
materialSetLayerWrapModeT ,
#if defined(ENABLE_OVERLOADING)
MaterialSetPointSizeMethodInfo ,
#endif
materialSetPointSize ,
#if defined(ENABLE_OVERLOADING)
MaterialSetShininessMethodInfo ,
#endif
materialSetShininess ,
#if defined(ENABLE_OVERLOADING)
MaterialSetSpecularMethodInfo ,
#endif
materialSetSpecular ,
#if defined(ENABLE_OVERLOADING)
MaterialSetUserProgramMethodInfo ,
#endif
materialSetUserProgram ,
materialUnref ,
) where
import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P
import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GHashTable as B.GHT
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Coerce as Coerce
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GHC.Records as R
import {-# SOURCE #-} qualified GI.Cogl.Enums as Cogl.Enums
import {-# SOURCE #-} qualified GI.Cogl.Structs.Color as Cogl.Color
import {-# SOURCE #-} qualified GI.Cogl.Structs.MaterialLayer as Cogl.MaterialLayer
import {-# SOURCE #-} qualified GI.Cogl.Structs.Matrix as Cogl.Matrix
newtype Material = Material (SP.ManagedPtr Material)
deriving (Material -> Material -> Bool
(Material -> Material -> Bool)
-> (Material -> Material -> Bool) -> Eq Material
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Material -> Material -> Bool
== :: Material -> Material -> Bool
$c/= :: Material -> Material -> Bool
/= :: Material -> Material -> Bool
Eq)
instance SP.ManagedPtrNewtype Material where
toManagedPtr :: Material -> ManagedPtr Material
toManagedPtr (Material ManagedPtr Material
p) = ManagedPtr Material
p
instance BoxedPtr Material where
boxedPtrCopy :: Material -> IO Material
boxedPtrCopy = Material -> IO Material
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return
boxedPtrFree :: Material -> IO ()
boxedPtrFree = \Material
_x -> () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Material
type instance O.AttributeList Material = MaterialAttributeList
type MaterialAttributeList = ('[ ] :: [(Symbol, *)])
#endif
foreign import ccall "cogl_material_get_ambient" cogl_material_get_ambient ::
Ptr Material ->
Ptr Cogl.Color.Color ->
IO ()
{-# DEPRECATED materialGetAmbient ["(Since version 1.16)","Use the @/CoglSnippet/@ shader api for lighting"] #-}
materialGetAmbient ::
(B.CallStack.HasCallStack, MonadIO m) =>
Material
-> Cogl.Color.Color
-> m ()
materialGetAmbient :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Material -> Color -> m ()
materialGetAmbient Material
material Color
ambient = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Material
material' <- Material -> IO (Ptr Material)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Material
material
Ptr Color
ambient' <- Color -> IO (Ptr Color)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Color
ambient
Ptr Material -> Ptr Color -> IO ()
cogl_material_get_ambient Ptr Material
material' Ptr Color
ambient'
Material -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Material
material
Color -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Color
ambient
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data MaterialGetAmbientMethodInfo
instance (signature ~ (Cogl.Color.Color -> m ()), MonadIO m) => O.OverloadedMethod MaterialGetAmbientMethodInfo Material signature where
overloadedMethod = materialGetAmbient
instance O.OverloadedMethodInfo MaterialGetAmbientMethodInfo Material where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Cogl.Structs.Material.materialGetAmbient",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-cogl-1.0.3/docs/GI-Cogl-Structs-Material.html#v:materialGetAmbient"
})
#endif
foreign import ccall "cogl_material_get_color" cogl_material_get_color ::
Ptr Material ->
Ptr Cogl.Color.Color ->
IO ()
{-# DEPRECATED materialGetColor ["(Since version 1.16)","Use @/cogl_pipeline_get_color()/@ instead"] #-}
materialGetColor ::
(B.CallStack.HasCallStack, MonadIO m) =>
Material
-> m (Cogl.Color.Color)
materialGetColor :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Material -> m Color
materialGetColor Material
material = IO Color -> m Color
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Color -> m Color) -> IO Color -> m Color
forall a b. (a -> b) -> a -> b
$ do
Ptr Material
material' <- Material -> IO (Ptr Material)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Material
material
Ptr Color
color <- Int -> IO (Ptr Color)
forall a. GBoxed a => Int -> IO (Ptr a)
SP.callocBoxedBytes Int
16 :: IO (Ptr Cogl.Color.Color)
Ptr Material -> Ptr Color -> IO ()
cogl_material_get_color Ptr Material
material' Ptr Color
color
Color
color' <- ((ManagedPtr Color -> Color) -> Ptr Color -> IO Color
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Color -> Color
Cogl.Color.Color) Ptr Color
color
Material -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Material
material
Color -> IO Color
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Color
color'
#if defined(ENABLE_OVERLOADING)
data MaterialGetColorMethodInfo
instance (signature ~ (m (Cogl.Color.Color)), MonadIO m) => O.OverloadedMethod MaterialGetColorMethodInfo Material signature where
overloadedMethod = materialGetColor
instance O.OverloadedMethodInfo MaterialGetColorMethodInfo Material where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Cogl.Structs.Material.materialGetColor",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-cogl-1.0.3/docs/GI-Cogl-Structs-Material.html#v:materialGetColor"
})
#endif
foreign import ccall "cogl_material_get_diffuse" cogl_material_get_diffuse ::
Ptr Material ->
Ptr Cogl.Color.Color ->
IO ()
{-# DEPRECATED materialGetDiffuse ["(Since version 1.16)","Use the @/CoglSnippet/@ shader api for lighting"] #-}
materialGetDiffuse ::
(B.CallStack.HasCallStack, MonadIO m) =>
Material
-> Cogl.Color.Color
-> m ()
materialGetDiffuse :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Material -> Color -> m ()
materialGetDiffuse Material
material Color
diffuse = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Material
material' <- Material -> IO (Ptr Material)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Material
material
Ptr Color
diffuse' <- Color -> IO (Ptr Color)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Color
diffuse
Ptr Material -> Ptr Color -> IO ()
cogl_material_get_diffuse Ptr Material
material' Ptr Color
diffuse'
Material -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Material
material
Color -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Color
diffuse
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data MaterialGetDiffuseMethodInfo
instance (signature ~ (Cogl.Color.Color -> m ()), MonadIO m) => O.OverloadedMethod MaterialGetDiffuseMethodInfo Material signature where
overloadedMethod = materialGetDiffuse
instance O.OverloadedMethodInfo MaterialGetDiffuseMethodInfo Material where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Cogl.Structs.Material.materialGetDiffuse",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-cogl-1.0.3/docs/GI-Cogl-Structs-Material.html#v:materialGetDiffuse"
})
#endif
foreign import ccall "cogl_material_get_emission" cogl_material_get_emission ::
Ptr Material ->
Ptr Cogl.Color.Color ->
IO ()
{-# DEPRECATED materialGetEmission ["(Since version 1.16)","Use the @/CoglSnippet/@ shader api for lighting"] #-}
materialGetEmission ::
(B.CallStack.HasCallStack, MonadIO m) =>
Material
-> Cogl.Color.Color
-> m ()
materialGetEmission :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Material -> Color -> m ()
materialGetEmission Material
material Color
emission = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Material
material' <- Material -> IO (Ptr Material)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Material
material
Ptr Color
emission' <- Color -> IO (Ptr Color)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Color
emission
Ptr Material -> Ptr Color -> IO ()
cogl_material_get_emission Ptr Material
material' Ptr Color
emission'
Material -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Material
material
Color -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Color
emission
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data MaterialGetEmissionMethodInfo
instance (signature ~ (Cogl.Color.Color -> m ()), MonadIO m) => O.OverloadedMethod MaterialGetEmissionMethodInfo Material signature where
overloadedMethod = materialGetEmission
instance O.OverloadedMethodInfo MaterialGetEmissionMethodInfo Material where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Cogl.Structs.Material.materialGetEmission",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-cogl-1.0.3/docs/GI-Cogl-Structs-Material.html#v:materialGetEmission"
})
#endif
foreign import ccall "cogl_material_get_layer_point_sprite_coords_enabled" cogl_material_get_layer_point_sprite_coords_enabled ::
Ptr Material ->
Int32 ->
IO Int32
{-# DEPRECATED materialGetLayerPointSpriteCoordsEnabled ["(Since version 1.16)","Use @/cogl_pipeline_get_layer_point_sprite_coords_enabled()/@"," instead"] #-}
materialGetLayerPointSpriteCoordsEnabled ::
(B.CallStack.HasCallStack, MonadIO m) =>
Material
-> Int32
-> m Int32
materialGetLayerPointSpriteCoordsEnabled :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Material -> Int32 -> m Int32
materialGetLayerPointSpriteCoordsEnabled Material
material Int32
layerIndex = IO Int32 -> m Int32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
Ptr Material
material' <- Material -> IO (Ptr Material)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Material
material
Int32
result <- Ptr Material -> Int32 -> IO Int32
cogl_material_get_layer_point_sprite_coords_enabled Ptr Material
material' Int32
layerIndex
Material -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Material
material
Int32 -> IO Int32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
#if defined(ENABLE_OVERLOADING)
data MaterialGetLayerPointSpriteCoordsEnabledMethodInfo
instance (signature ~ (Int32 -> m Int32), MonadIO m) => O.OverloadedMethod MaterialGetLayerPointSpriteCoordsEnabledMethodInfo Material signature where
overloadedMethod = materialGetLayerPointSpriteCoordsEnabled
instance O.OverloadedMethodInfo MaterialGetLayerPointSpriteCoordsEnabledMethodInfo Material where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Cogl.Structs.Material.materialGetLayerPointSpriteCoordsEnabled",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-cogl-1.0.3/docs/GI-Cogl-Structs-Material.html#v:materialGetLayerPointSpriteCoordsEnabled"
})
#endif
foreign import ccall "cogl_material_get_layer_wrap_mode_p" cogl_material_get_layer_wrap_mode_p ::
Ptr Material ->
Int32 ->
IO CUInt
{-# DEPRECATED materialGetLayerWrapModeP ["(Since version 1.16)","Use @/cogl_pipeline_get_layer_wrap_mode_p()/@ instead"] #-}
materialGetLayerWrapModeP ::
(B.CallStack.HasCallStack, MonadIO m) =>
Material
-> Int32
-> m Cogl.Enums.MaterialWrapMode
materialGetLayerWrapModeP :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Material -> Int32 -> m MaterialWrapMode
materialGetLayerWrapModeP Material
material Int32
layerIndex = IO MaterialWrapMode -> m MaterialWrapMode
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO MaterialWrapMode -> m MaterialWrapMode)
-> IO MaterialWrapMode -> m MaterialWrapMode
forall a b. (a -> b) -> a -> b
$ do
Ptr Material
material' <- Material -> IO (Ptr Material)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Material
material
CUInt
result <- Ptr Material -> Int32 -> IO CUInt
cogl_material_get_layer_wrap_mode_p Ptr Material
material' Int32
layerIndex
let result' :: MaterialWrapMode
result' = (Int -> MaterialWrapMode
forall a. Enum a => Int -> a
toEnum (Int -> MaterialWrapMode)
-> (CUInt -> Int) -> CUInt -> MaterialWrapMode
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
Material -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Material
material
MaterialWrapMode -> IO MaterialWrapMode
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return MaterialWrapMode
result'
#if defined(ENABLE_OVERLOADING)
data MaterialGetLayerWrapModePMethodInfo
instance (signature ~ (Int32 -> m Cogl.Enums.MaterialWrapMode), MonadIO m) => O.OverloadedMethod MaterialGetLayerWrapModePMethodInfo Material signature where
overloadedMethod = materialGetLayerWrapModeP
instance O.OverloadedMethodInfo MaterialGetLayerWrapModePMethodInfo Material where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Cogl.Structs.Material.materialGetLayerWrapModeP",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-cogl-1.0.3/docs/GI-Cogl-Structs-Material.html#v:materialGetLayerWrapModeP"
})
#endif
foreign import ccall "cogl_material_get_layer_wrap_mode_s" cogl_material_get_layer_wrap_mode_s ::
Ptr Material ->
Int32 ->
IO CUInt
{-# DEPRECATED materialGetLayerWrapModeS ["(Since version 1.16)","Use @/cogl_pipeline_get_layer_wrap_mode_s()/@ instead"] #-}
materialGetLayerWrapModeS ::
(B.CallStack.HasCallStack, MonadIO m) =>
Material
-> Int32
-> m Cogl.Enums.MaterialWrapMode
materialGetLayerWrapModeS :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Material -> Int32 -> m MaterialWrapMode
materialGetLayerWrapModeS Material
material Int32
layerIndex = IO MaterialWrapMode -> m MaterialWrapMode
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO MaterialWrapMode -> m MaterialWrapMode)
-> IO MaterialWrapMode -> m MaterialWrapMode
forall a b. (a -> b) -> a -> b
$ do
Ptr Material
material' <- Material -> IO (Ptr Material)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Material
material
CUInt
result <- Ptr Material -> Int32 -> IO CUInt
cogl_material_get_layer_wrap_mode_s Ptr Material
material' Int32
layerIndex
let result' :: MaterialWrapMode
result' = (Int -> MaterialWrapMode
forall a. Enum a => Int -> a
toEnum (Int -> MaterialWrapMode)
-> (CUInt -> Int) -> CUInt -> MaterialWrapMode
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
Material -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Material
material
MaterialWrapMode -> IO MaterialWrapMode
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return MaterialWrapMode
result'
#if defined(ENABLE_OVERLOADING)
data MaterialGetLayerWrapModeSMethodInfo
instance (signature ~ (Int32 -> m Cogl.Enums.MaterialWrapMode), MonadIO m) => O.OverloadedMethod MaterialGetLayerWrapModeSMethodInfo Material signature where
overloadedMethod = materialGetLayerWrapModeS
instance O.OverloadedMethodInfo MaterialGetLayerWrapModeSMethodInfo Material where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Cogl.Structs.Material.materialGetLayerWrapModeS",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-cogl-1.0.3/docs/GI-Cogl-Structs-Material.html#v:materialGetLayerWrapModeS"
})
#endif
foreign import ccall "cogl_material_get_layer_wrap_mode_t" cogl_material_get_layer_wrap_mode_t ::
Ptr Material ->
Int32 ->
IO CUInt
{-# DEPRECATED materialGetLayerWrapModeT ["(Since version 1.16)","Use @/cogl_pipeline_get_layer_wrap_mode_t()/@ instead"] #-}
materialGetLayerWrapModeT ::
(B.CallStack.HasCallStack, MonadIO m) =>
Material
-> Int32
-> m Cogl.Enums.MaterialWrapMode
materialGetLayerWrapModeT :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Material -> Int32 -> m MaterialWrapMode
materialGetLayerWrapModeT Material
material Int32
layerIndex = IO MaterialWrapMode -> m MaterialWrapMode
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO MaterialWrapMode -> m MaterialWrapMode)
-> IO MaterialWrapMode -> m MaterialWrapMode
forall a b. (a -> b) -> a -> b
$ do
Ptr Material
material' <- Material -> IO (Ptr Material)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Material
material
CUInt
result <- Ptr Material -> Int32 -> IO CUInt
cogl_material_get_layer_wrap_mode_t Ptr Material
material' Int32
layerIndex
let result' :: MaterialWrapMode
result' = (Int -> MaterialWrapMode
forall a. Enum a => Int -> a
toEnum (Int -> MaterialWrapMode)
-> (CUInt -> Int) -> CUInt -> MaterialWrapMode
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
Material -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Material
material
MaterialWrapMode -> IO MaterialWrapMode
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return MaterialWrapMode
result'
#if defined(ENABLE_OVERLOADING)
data MaterialGetLayerWrapModeTMethodInfo
instance (signature ~ (Int32 -> m Cogl.Enums.MaterialWrapMode), MonadIO m) => O.OverloadedMethod MaterialGetLayerWrapModeTMethodInfo Material signature where
overloadedMethod = materialGetLayerWrapModeT
instance O.OverloadedMethodInfo MaterialGetLayerWrapModeTMethodInfo Material where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Cogl.Structs.Material.materialGetLayerWrapModeT",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-cogl-1.0.3/docs/GI-Cogl-Structs-Material.html#v:materialGetLayerWrapModeT"
})
#endif
foreign import ccall "cogl_material_get_layers" cogl_material_get_layers ::
Ptr Material ->
IO (Ptr (GList (Ptr Cogl.MaterialLayer.MaterialLayer)))
materialGetLayers ::
(B.CallStack.HasCallStack, MonadIO m) =>
Material
-> m [Cogl.MaterialLayer.MaterialLayer]
materialGetLayers :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Material -> m [MaterialLayer]
materialGetLayers Material
material = IO [MaterialLayer] -> m [MaterialLayer]
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [MaterialLayer] -> m [MaterialLayer])
-> IO [MaterialLayer] -> m [MaterialLayer]
forall a b. (a -> b) -> a -> b
$ do
Ptr Material
material' <- Material -> IO (Ptr Material)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Material
material
Ptr (GList (Ptr MaterialLayer))
result <- Ptr Material -> IO (Ptr (GList (Ptr MaterialLayer)))
cogl_material_get_layers Ptr Material
material'
[Ptr MaterialLayer]
result' <- Ptr (GList (Ptr MaterialLayer)) -> IO [Ptr MaterialLayer]
forall a. Ptr (GList (Ptr a)) -> IO [Ptr a]
unpackGList Ptr (GList (Ptr MaterialLayer))
result
[MaterialLayer]
result'' <- (Ptr MaterialLayer -> IO MaterialLayer)
-> [Ptr MaterialLayer] -> IO [MaterialLayer]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM ((ManagedPtr MaterialLayer -> MaterialLayer)
-> Ptr MaterialLayer -> IO MaterialLayer
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr MaterialLayer -> MaterialLayer
Cogl.MaterialLayer.MaterialLayer) [Ptr MaterialLayer]
result'
Material -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Material
material
[MaterialLayer] -> IO [MaterialLayer]
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return [MaterialLayer]
result''
#if defined(ENABLE_OVERLOADING)
data MaterialGetLayersMethodInfo
instance (signature ~ (m [Cogl.MaterialLayer.MaterialLayer]), MonadIO m) => O.OverloadedMethod MaterialGetLayersMethodInfo Material signature where
overloadedMethod = materialGetLayers
instance O.OverloadedMethodInfo MaterialGetLayersMethodInfo Material where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Cogl.Structs.Material.materialGetLayers",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-cogl-1.0.3/docs/GI-Cogl-Structs-Material.html#v:materialGetLayers"
})
#endif
foreign import ccall "cogl_material_get_n_layers" cogl_material_get_n_layers ::
Ptr Material ->
IO Int32
{-# DEPRECATED materialGetNLayers ["(Since version 1.16)","Use @/cogl_pipeline_get_n_layers()/@ instead"] #-}
materialGetNLayers ::
(B.CallStack.HasCallStack, MonadIO m) =>
Material
-> m Int32
materialGetNLayers :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Material -> m Int32
materialGetNLayers Material
material = IO Int32 -> m Int32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
Ptr Material
material' <- Material -> IO (Ptr Material)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Material
material
Int32
result <- Ptr Material -> IO Int32
cogl_material_get_n_layers Ptr Material
material'
Material -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Material
material
Int32 -> IO Int32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
#if defined(ENABLE_OVERLOADING)
data MaterialGetNLayersMethodInfo
instance (signature ~ (m Int32), MonadIO m) => O.OverloadedMethod MaterialGetNLayersMethodInfo Material signature where
overloadedMethod = materialGetNLayers
instance O.OverloadedMethodInfo MaterialGetNLayersMethodInfo Material where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Cogl.Structs.Material.materialGetNLayers",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-cogl-1.0.3/docs/GI-Cogl-Structs-Material.html#v:materialGetNLayers"
})
#endif
foreign import ccall "cogl_material_get_point_size" cogl_material_get_point_size ::
Ptr Material ->
IO CFloat
{-# DEPRECATED materialGetPointSize ["(Since version 1.16)","Use @/cogl_pipeline_get_point_size()/@ instead"] #-}
materialGetPointSize ::
(B.CallStack.HasCallStack, MonadIO m) =>
Material
-> m Float
materialGetPointSize :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Material -> m Float
materialGetPointSize Material
material = IO Float -> m Float
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Float -> m Float) -> IO Float -> m Float
forall a b. (a -> b) -> a -> b
$ do
Ptr Material
material' <- Material -> IO (Ptr Material)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Material
material
CFloat
result <- Ptr Material -> IO CFloat
cogl_material_get_point_size Ptr Material
material'
let result' :: Float
result' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
result
Material -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Material
material
Float -> IO Float
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Float
result'
#if defined(ENABLE_OVERLOADING)
data MaterialGetPointSizeMethodInfo
instance (signature ~ (m Float), MonadIO m) => O.OverloadedMethod MaterialGetPointSizeMethodInfo Material signature where
overloadedMethod = materialGetPointSize
instance O.OverloadedMethodInfo MaterialGetPointSizeMethodInfo Material where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Cogl.Structs.Material.materialGetPointSize",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-cogl-1.0.3/docs/GI-Cogl-Structs-Material.html#v:materialGetPointSize"
})
#endif
foreign import ccall "cogl_material_get_shininess" cogl_material_get_shininess ::
Ptr Material ->
IO CFloat
{-# DEPRECATED materialGetShininess ["(Since version 1.16)","Use the @/CoglSnippet/@ shader api for lighting"] #-}
materialGetShininess ::
(B.CallStack.HasCallStack, MonadIO m) =>
Material
-> m Float
materialGetShininess :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Material -> m Float
materialGetShininess Material
material = IO Float -> m Float
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Float -> m Float) -> IO Float -> m Float
forall a b. (a -> b) -> a -> b
$ do
Ptr Material
material' <- Material -> IO (Ptr Material)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Material
material
CFloat
result <- Ptr Material -> IO CFloat
cogl_material_get_shininess Ptr Material
material'
let result' :: Float
result' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
result
Material -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Material
material
Float -> IO Float
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Float
result'
#if defined(ENABLE_OVERLOADING)
data MaterialGetShininessMethodInfo
instance (signature ~ (m Float), MonadIO m) => O.OverloadedMethod MaterialGetShininessMethodInfo Material signature where
overloadedMethod = materialGetShininess
instance O.OverloadedMethodInfo MaterialGetShininessMethodInfo Material where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Cogl.Structs.Material.materialGetShininess",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-cogl-1.0.3/docs/GI-Cogl-Structs-Material.html#v:materialGetShininess"
})
#endif
foreign import ccall "cogl_material_get_specular" cogl_material_get_specular ::
Ptr Material ->
Ptr Cogl.Color.Color ->
IO ()
{-# DEPRECATED materialGetSpecular ["(Since version 1.16)","Use the @/CoglSnippet/@ shader api for lighting"] #-}
materialGetSpecular ::
(B.CallStack.HasCallStack, MonadIO m) =>
Material
-> Cogl.Color.Color
-> m ()
materialGetSpecular :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Material -> Color -> m ()
materialGetSpecular Material
material Color
specular = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Material
material' <- Material -> IO (Ptr Material)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Material
material
Ptr Color
specular' <- Color -> IO (Ptr Color)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Color
specular
Ptr Material -> Ptr Color -> IO ()
cogl_material_get_specular Ptr Material
material' Ptr Color
specular'
Material -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Material
material
Color -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Color
specular
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data MaterialGetSpecularMethodInfo
instance (signature ~ (Cogl.Color.Color -> m ()), MonadIO m) => O.OverloadedMethod MaterialGetSpecularMethodInfo Material signature where
overloadedMethod = materialGetSpecular
instance O.OverloadedMethodInfo MaterialGetSpecularMethodInfo Material where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Cogl.Structs.Material.materialGetSpecular",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-cogl-1.0.3/docs/GI-Cogl-Structs-Material.html#v:materialGetSpecular"
})
#endif
foreign import ccall "cogl_material_get_user_program" cogl_material_get_user_program ::
Ptr Material ->
IO (Ptr ())
{-# DEPRECATED materialGetUserProgram ["(Since version 1.16)","Use @/CoglSnippet/@ api instead instead"] #-}
materialGetUserProgram ::
(B.CallStack.HasCallStack, MonadIO m) =>
Material
-> m (Ptr ())
materialGetUserProgram :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Material -> m (Ptr ())
materialGetUserProgram Material
material = IO (Ptr ()) -> m (Ptr ())
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Ptr ()) -> m (Ptr ())) -> IO (Ptr ()) -> m (Ptr ())
forall a b. (a -> b) -> a -> b
$ do
Ptr Material
material' <- Material -> IO (Ptr Material)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Material
material
Ptr ()
result <- Ptr Material -> IO (Ptr ())
cogl_material_get_user_program Ptr Material
material'
Material -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Material
material
Ptr () -> IO (Ptr ())
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr ()
result
#if defined(ENABLE_OVERLOADING)
data MaterialGetUserProgramMethodInfo
instance (signature ~ (m (Ptr ())), MonadIO m) => O.OverloadedMethod MaterialGetUserProgramMethodInfo Material signature where
overloadedMethod = materialGetUserProgram
instance O.OverloadedMethodInfo MaterialGetUserProgramMethodInfo Material where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Cogl.Structs.Material.materialGetUserProgram",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-cogl-1.0.3/docs/GI-Cogl-Structs-Material.html#v:materialGetUserProgram"
})
#endif
foreign import ccall "cogl_material_remove_layer" cogl_material_remove_layer ::
Ptr Material ->
Int32 ->
IO ()
{-# DEPRECATED materialRemoveLayer ["(Since version 1.16)","Use @/cogl_pipeline_remove_layer()/@ instead"] #-}
materialRemoveLayer ::
(B.CallStack.HasCallStack, MonadIO m) =>
Material
-> Int32
-> m ()
materialRemoveLayer :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Material -> Int32 -> m ()
materialRemoveLayer Material
material Int32
layerIndex = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Material
material' <- Material -> IO (Ptr Material)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Material
material
Ptr Material -> Int32 -> IO ()
cogl_material_remove_layer Ptr Material
material' Int32
layerIndex
Material -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Material
material
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data MaterialRemoveLayerMethodInfo
instance (signature ~ (Int32 -> m ()), MonadIO m) => O.OverloadedMethod MaterialRemoveLayerMethodInfo Material signature where
overloadedMethod = materialRemoveLayer
instance O.OverloadedMethodInfo MaterialRemoveLayerMethodInfo Material where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Cogl.Structs.Material.materialRemoveLayer",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-cogl-1.0.3/docs/GI-Cogl-Structs-Material.html#v:materialRemoveLayer"
})
#endif
foreign import ccall "cogl_material_set_alpha_test_function" cogl_material_set_alpha_test_function ::
Ptr Material ->
CUInt ->
CFloat ->
IO ()
{-# DEPRECATED materialSetAlphaTestFunction ["(Since version 1.16)","Use @/cogl_pipeline_set_alpha_test_function()/@ instead"] #-}
materialSetAlphaTestFunction ::
(B.CallStack.HasCallStack, MonadIO m) =>
Material
-> Cogl.Enums.MaterialAlphaFunc
-> Float
-> m ()
materialSetAlphaTestFunction :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Material -> MaterialAlphaFunc -> Float -> m ()
materialSetAlphaTestFunction Material
material MaterialAlphaFunc
alphaFunc Float
alphaReference = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Material
material' <- Material -> IO (Ptr Material)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Material
material
let alphaFunc' :: CUInt
alphaFunc' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt)
-> (MaterialAlphaFunc -> Int) -> MaterialAlphaFunc -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. MaterialAlphaFunc -> Int
forall a. Enum a => a -> Int
fromEnum) MaterialAlphaFunc
alphaFunc
let alphaReference' :: CFloat
alphaReference' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
alphaReference
Ptr Material -> CUInt -> CFloat -> IO ()
cogl_material_set_alpha_test_function Ptr Material
material' CUInt
alphaFunc' CFloat
alphaReference'
Material -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Material
material
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data MaterialSetAlphaTestFunctionMethodInfo
instance (signature ~ (Cogl.Enums.MaterialAlphaFunc -> Float -> m ()), MonadIO m) => O.OverloadedMethod MaterialSetAlphaTestFunctionMethodInfo Material signature where
overloadedMethod = materialSetAlphaTestFunction
instance O.OverloadedMethodInfo MaterialSetAlphaTestFunctionMethodInfo Material where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Cogl.Structs.Material.materialSetAlphaTestFunction",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-cogl-1.0.3/docs/GI-Cogl-Structs-Material.html#v:materialSetAlphaTestFunction"
})
#endif
foreign import ccall "cogl_material_set_ambient" cogl_material_set_ambient ::
Ptr Material ->
Ptr Cogl.Color.Color ->
IO ()
{-# DEPRECATED materialSetAmbient ["(Since version 1.16)","Use the @/CoglSnippet/@ shader api for lighting"] #-}
materialSetAmbient ::
(B.CallStack.HasCallStack, MonadIO m) =>
Material
-> Cogl.Color.Color
-> m ()
materialSetAmbient :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Material -> Color -> m ()
materialSetAmbient Material
material Color
ambient = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Material
material' <- Material -> IO (Ptr Material)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Material
material
Ptr Color
ambient' <- Color -> IO (Ptr Color)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Color
ambient
Ptr Material -> Ptr Color -> IO ()
cogl_material_set_ambient Ptr Material
material' Ptr Color
ambient'
Material -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Material
material
Color -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Color
ambient
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data MaterialSetAmbientMethodInfo
instance (signature ~ (Cogl.Color.Color -> m ()), MonadIO m) => O.OverloadedMethod MaterialSetAmbientMethodInfo Material signature where
overloadedMethod = materialSetAmbient
instance O.OverloadedMethodInfo MaterialSetAmbientMethodInfo Material where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Cogl.Structs.Material.materialSetAmbient",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-cogl-1.0.3/docs/GI-Cogl-Structs-Material.html#v:materialSetAmbient"
})
#endif
foreign import ccall "cogl_material_set_ambient_and_diffuse" cogl_material_set_ambient_and_diffuse ::
Ptr Material ->
Ptr Cogl.Color.Color ->
IO ()
{-# DEPRECATED materialSetAmbientAndDiffuse ["(Since version 1.16)","Use the @/CoglSnippet/@ shader api for lighting"] #-}
materialSetAmbientAndDiffuse ::
(B.CallStack.HasCallStack, MonadIO m) =>
Material
-> Cogl.Color.Color
-> m ()
materialSetAmbientAndDiffuse :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Material -> Color -> m ()
materialSetAmbientAndDiffuse Material
material Color
color = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Material
material' <- Material -> IO (Ptr Material)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Material
material
Ptr Color
color' <- Color -> IO (Ptr Color)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Color
color
Ptr Material -> Ptr Color -> IO ()
cogl_material_set_ambient_and_diffuse Ptr Material
material' Ptr Color
color'
Material -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Material
material
Color -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Color
color
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data MaterialSetAmbientAndDiffuseMethodInfo
instance (signature ~ (Cogl.Color.Color -> m ()), MonadIO m) => O.OverloadedMethod MaterialSetAmbientAndDiffuseMethodInfo Material signature where
overloadedMethod = materialSetAmbientAndDiffuse
instance O.OverloadedMethodInfo MaterialSetAmbientAndDiffuseMethodInfo Material where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Cogl.Structs.Material.materialSetAmbientAndDiffuse",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-cogl-1.0.3/docs/GI-Cogl-Structs-Material.html#v:materialSetAmbientAndDiffuse"
})
#endif
foreign import ccall "cogl_material_set_blend" cogl_material_set_blend ::
Ptr Material ->
CString ->
Ptr (Ptr GError) ->
IO Int32
{-# DEPRECATED materialSetBlend ["(Since version 1.16)","Use @/cogl_pipeline_set_blend()/@ instead"] #-}
materialSetBlend ::
(B.CallStack.HasCallStack, MonadIO m) =>
Material
-> T.Text
-> m Int32
materialSetBlend :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Material -> Text -> m Int32
materialSetBlend Material
material Text
blendString = IO Int32 -> m Int32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
Ptr Material
material' <- Material -> IO (Ptr Material)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Material
material
CString
blendString' <- Text -> IO CString
textToCString Text
blendString
IO Int32 -> IO () -> IO Int32
forall a b. IO a -> IO b -> IO a
onException (do
Int32
result <- (Ptr (Ptr GError) -> IO Int32) -> IO Int32
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO Int32) -> IO Int32)
-> (Ptr (Ptr GError) -> IO Int32) -> IO Int32
forall a b. (a -> b) -> a -> b
$ Ptr Material -> CString -> Ptr (Ptr GError) -> IO Int32
cogl_material_set_blend Ptr Material
material' CString
blendString'
Material -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Material
material
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
blendString'
Int32 -> IO Int32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
) (do
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
blendString'
)
#if defined(ENABLE_OVERLOADING)
data MaterialSetBlendMethodInfo
instance (signature ~ (T.Text -> m Int32), MonadIO m) => O.OverloadedMethod MaterialSetBlendMethodInfo Material signature where
overloadedMethod = materialSetBlend
instance O.OverloadedMethodInfo MaterialSetBlendMethodInfo Material where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Cogl.Structs.Material.materialSetBlend",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-cogl-1.0.3/docs/GI-Cogl-Structs-Material.html#v:materialSetBlend"
})
#endif
foreign import ccall "cogl_material_set_blend_constant" cogl_material_set_blend_constant ::
Ptr Material ->
Ptr Cogl.Color.Color ->
IO ()
{-# DEPRECATED materialSetBlendConstant ["(Since version 1.16)","Use @/cogl_pipeline_set_blend_constant()/@ instead"] #-}
materialSetBlendConstant ::
(B.CallStack.HasCallStack, MonadIO m) =>
Material
-> Cogl.Color.Color
-> m ()
materialSetBlendConstant :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Material -> Color -> m ()
materialSetBlendConstant Material
material Color
constantColor = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Material
material' <- Material -> IO (Ptr Material)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Material
material
Ptr Color
constantColor' <- Color -> IO (Ptr Color)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Color
constantColor
Ptr Material -> Ptr Color -> IO ()
cogl_material_set_blend_constant Ptr Material
material' Ptr Color
constantColor'
Material -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Material
material
Color -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Color
constantColor
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data MaterialSetBlendConstantMethodInfo
instance (signature ~ (Cogl.Color.Color -> m ()), MonadIO m) => O.OverloadedMethod MaterialSetBlendConstantMethodInfo Material signature where
overloadedMethod = materialSetBlendConstant
instance O.OverloadedMethodInfo MaterialSetBlendConstantMethodInfo Material where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Cogl.Structs.Material.materialSetBlendConstant",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-cogl-1.0.3/docs/GI-Cogl-Structs-Material.html#v:materialSetBlendConstant"
})
#endif
foreign import ccall "cogl_material_set_color" cogl_material_set_color ::
Ptr Material ->
Ptr Cogl.Color.Color ->
IO ()
{-# DEPRECATED materialSetColor ["(Since version 1.16)","Use @/cogl_pipeline_set_color()/@ instead"] #-}
materialSetColor ::
(B.CallStack.HasCallStack, MonadIO m) =>
Material
-> Cogl.Color.Color
-> m ()
materialSetColor :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Material -> Color -> m ()
materialSetColor Material
material Color
color = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Material
material' <- Material -> IO (Ptr Material)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Material
material
Ptr Color
color' <- Color -> IO (Ptr Color)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Color
color
Ptr Material -> Ptr Color -> IO ()
cogl_material_set_color Ptr Material
material' Ptr Color
color'
Material -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Material
material
Color -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Color
color
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data MaterialSetColorMethodInfo
instance (signature ~ (Cogl.Color.Color -> m ()), MonadIO m) => O.OverloadedMethod MaterialSetColorMethodInfo Material signature where
overloadedMethod = materialSetColor
instance O.OverloadedMethodInfo MaterialSetColorMethodInfo Material where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Cogl.Structs.Material.materialSetColor",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-cogl-1.0.3/docs/GI-Cogl-Structs-Material.html#v:materialSetColor"
})
#endif
foreign import ccall "cogl_material_set_color4f" cogl_material_set_color4f ::
Ptr Material ->
CFloat ->
CFloat ->
CFloat ->
CFloat ->
IO ()
{-# DEPRECATED materialSetColor4f ["(Since version 1.16)","Use @/cogl_pipeline_set_color4f()/@ instead"] #-}
materialSetColor4f ::
(B.CallStack.HasCallStack, MonadIO m) =>
Material
-> Float
-> Float
-> Float
-> Float
-> m ()
materialSetColor4f :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Material -> Float -> Float -> Float -> Float -> m ()
materialSetColor4f Material
material Float
red Float
green Float
blue Float
alpha = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Material
material' <- Material -> IO (Ptr Material)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Material
material
let red' :: CFloat
red' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
red
let green' :: CFloat
green' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
green
let blue' :: CFloat
blue' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
blue
let alpha' :: CFloat
alpha' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
alpha
Ptr Material -> CFloat -> CFloat -> CFloat -> CFloat -> IO ()
cogl_material_set_color4f Ptr Material
material' CFloat
red' CFloat
green' CFloat
blue' CFloat
alpha'
Material -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Material
material
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data MaterialSetColor4fMethodInfo
instance (signature ~ (Float -> Float -> Float -> Float -> m ()), MonadIO m) => O.OverloadedMethod MaterialSetColor4fMethodInfo Material signature where
overloadedMethod = materialSetColor4f
instance O.OverloadedMethodInfo MaterialSetColor4fMethodInfo Material where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Cogl.Structs.Material.materialSetColor4f",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-cogl-1.0.3/docs/GI-Cogl-Structs-Material.html#v:materialSetColor4f"
})
#endif
foreign import ccall "cogl_material_set_color4ub" cogl_material_set_color4ub ::
Ptr Material ->
Word8 ->
Word8 ->
Word8 ->
Word8 ->
IO ()
{-# DEPRECATED materialSetColor4ub ["(Since version 1.16)","Use @/cogl_pipeline_set_color4ub()/@ instead"] #-}
materialSetColor4ub ::
(B.CallStack.HasCallStack, MonadIO m) =>
Material
-> Word8
-> Word8
-> Word8
-> Word8
-> m ()
materialSetColor4ub :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Material -> Word8 -> Word8 -> Word8 -> Word8 -> m ()
materialSetColor4ub Material
material Word8
red Word8
green Word8
blue Word8
alpha = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Material
material' <- Material -> IO (Ptr Material)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Material
material
Ptr Material -> Word8 -> Word8 -> Word8 -> Word8 -> IO ()
cogl_material_set_color4ub Ptr Material
material' Word8
red Word8
green Word8
blue Word8
alpha
Material -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Material
material
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data MaterialSetColor4ubMethodInfo
instance (signature ~ (Word8 -> Word8 -> Word8 -> Word8 -> m ()), MonadIO m) => O.OverloadedMethod MaterialSetColor4ubMethodInfo Material signature where
overloadedMethod = materialSetColor4ub
instance O.OverloadedMethodInfo MaterialSetColor4ubMethodInfo Material where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Cogl.Structs.Material.materialSetColor4ub",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-cogl-1.0.3/docs/GI-Cogl-Structs-Material.html#v:materialSetColor4ub"
})
#endif
foreign import ccall "cogl_material_set_diffuse" cogl_material_set_diffuse ::
Ptr Material ->
Ptr Cogl.Color.Color ->
IO ()
{-# DEPRECATED materialSetDiffuse ["(Since version 1.16)","Use the @/CoglSnippet/@ shader api for lighting"] #-}
materialSetDiffuse ::
(B.CallStack.HasCallStack, MonadIO m) =>
Material
-> Cogl.Color.Color
-> m ()
materialSetDiffuse :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Material -> Color -> m ()
materialSetDiffuse Material
material Color
diffuse = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Material
material' <- Material -> IO (Ptr Material)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Material
material
Ptr Color
diffuse' <- Color -> IO (Ptr Color)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Color
diffuse
Ptr Material -> Ptr Color -> IO ()
cogl_material_set_diffuse Ptr Material
material' Ptr Color
diffuse'
Material -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Material
material
Color -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Color
diffuse
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data MaterialSetDiffuseMethodInfo
instance (signature ~ (Cogl.Color.Color -> m ()), MonadIO m) => O.OverloadedMethod MaterialSetDiffuseMethodInfo Material signature where
overloadedMethod = materialSetDiffuse
instance O.OverloadedMethodInfo MaterialSetDiffuseMethodInfo Material where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Cogl.Structs.Material.materialSetDiffuse",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-cogl-1.0.3/docs/GI-Cogl-Structs-Material.html#v:materialSetDiffuse"
})
#endif
foreign import ccall "cogl_material_set_emission" cogl_material_set_emission ::
Ptr Material ->
Ptr Cogl.Color.Color ->
IO ()
{-# DEPRECATED materialSetEmission ["(Since version 1.16)","Use the @/CoglSnippet/@ shader api for lighting"] #-}
materialSetEmission ::
(B.CallStack.HasCallStack, MonadIO m) =>
Material
-> Cogl.Color.Color
-> m ()
materialSetEmission :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Material -> Color -> m ()
materialSetEmission Material
material Color
emission = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Material
material' <- Material -> IO (Ptr Material)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Material
material
Ptr Color
emission' <- Color -> IO (Ptr Color)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Color
emission
Ptr Material -> Ptr Color -> IO ()
cogl_material_set_emission Ptr Material
material' Ptr Color
emission'
Material -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Material
material
Color -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Color
emission
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data MaterialSetEmissionMethodInfo
instance (signature ~ (Cogl.Color.Color -> m ()), MonadIO m) => O.OverloadedMethod MaterialSetEmissionMethodInfo Material signature where
overloadedMethod = materialSetEmission
instance O.OverloadedMethodInfo MaterialSetEmissionMethodInfo Material where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Cogl.Structs.Material.materialSetEmission",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-cogl-1.0.3/docs/GI-Cogl-Structs-Material.html#v:materialSetEmission"
})
#endif
foreign import ccall "cogl_material_set_layer" cogl_material_set_layer ::
Ptr Material ->
Int32 ->
Ptr () ->
IO ()
{-# DEPRECATED materialSetLayer ["(Since version 1.16)","Use @/cogl_pipeline_set_layer()/@ instead"] #-}
materialSetLayer ::
(B.CallStack.HasCallStack, MonadIO m) =>
Material
-> Int32
-> Ptr ()
-> m ()
materialSetLayer :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Material -> Int32 -> Ptr () -> m ()
materialSetLayer Material
material Int32
layerIndex Ptr ()
texture = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Material
material' <- Material -> IO (Ptr Material)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Material
material
Ptr Material -> Int32 -> Ptr () -> IO ()
cogl_material_set_layer Ptr Material
material' Int32
layerIndex Ptr ()
texture
Material -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Material
material
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data MaterialSetLayerMethodInfo
instance (signature ~ (Int32 -> Ptr () -> m ()), MonadIO m) => O.OverloadedMethod MaterialSetLayerMethodInfo Material signature where
overloadedMethod = materialSetLayer
instance O.OverloadedMethodInfo MaterialSetLayerMethodInfo Material where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Cogl.Structs.Material.materialSetLayer",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-cogl-1.0.3/docs/GI-Cogl-Structs-Material.html#v:materialSetLayer"
})
#endif
foreign import ccall "cogl_material_set_layer_combine" cogl_material_set_layer_combine ::
Ptr Material ->
Int32 ->
CString ->
Ptr (Ptr GError) ->
IO Int32
{-# DEPRECATED materialSetLayerCombine ["(Since version 1.16)","Use @/cogl_pipeline_set_layer_combine()/@ instead"] #-}
materialSetLayerCombine ::
(B.CallStack.HasCallStack, MonadIO m) =>
Material
-> Int32
-> T.Text
-> m Int32
materialSetLayerCombine :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Material -> Int32 -> Text -> m Int32
materialSetLayerCombine Material
material Int32
layerIndex Text
blendString = IO Int32 -> m Int32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
Ptr Material
material' <- Material -> IO (Ptr Material)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Material
material
CString
blendString' <- Text -> IO CString
textToCString Text
blendString
IO Int32 -> IO () -> IO Int32
forall a b. IO a -> IO b -> IO a
onException (do
Int32
result <- (Ptr (Ptr GError) -> IO Int32) -> IO Int32
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO Int32) -> IO Int32)
-> (Ptr (Ptr GError) -> IO Int32) -> IO Int32
forall a b. (a -> b) -> a -> b
$ Ptr Material -> Int32 -> CString -> Ptr (Ptr GError) -> IO Int32
cogl_material_set_layer_combine Ptr Material
material' Int32
layerIndex CString
blendString'
Material -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Material
material
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
blendString'
Int32 -> IO Int32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
) (do
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
blendString'
)
#if defined(ENABLE_OVERLOADING)
data MaterialSetLayerCombineMethodInfo
instance (signature ~ (Int32 -> T.Text -> m Int32), MonadIO m) => O.OverloadedMethod MaterialSetLayerCombineMethodInfo Material signature where
overloadedMethod = materialSetLayerCombine
instance O.OverloadedMethodInfo MaterialSetLayerCombineMethodInfo Material where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Cogl.Structs.Material.materialSetLayerCombine",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-cogl-1.0.3/docs/GI-Cogl-Structs-Material.html#v:materialSetLayerCombine"
})
#endif
foreign import ccall "cogl_material_set_layer_combine_constant" cogl_material_set_layer_combine_constant ::
Ptr Material ->
Int32 ->
Ptr Cogl.Color.Color ->
IO ()
{-# DEPRECATED materialSetLayerCombineConstant ["(Since version 1.16)","Use @/cogl_pipeline_set_layer_combine_constant()/@","instead"] #-}
materialSetLayerCombineConstant ::
(B.CallStack.HasCallStack, MonadIO m) =>
Material
-> Int32
-> Cogl.Color.Color
-> m ()
materialSetLayerCombineConstant :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Material -> Int32 -> Color -> m ()
materialSetLayerCombineConstant Material
material Int32
layerIndex Color
constant = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Material
material' <- Material -> IO (Ptr Material)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Material
material
Ptr Color
constant' <- Color -> IO (Ptr Color)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Color
constant
Ptr Material -> Int32 -> Ptr Color -> IO ()
cogl_material_set_layer_combine_constant Ptr Material
material' Int32
layerIndex Ptr Color
constant'
Material -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Material
material
Color -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Color
constant
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data MaterialSetLayerCombineConstantMethodInfo
instance (signature ~ (Int32 -> Cogl.Color.Color -> m ()), MonadIO m) => O.OverloadedMethod MaterialSetLayerCombineConstantMethodInfo Material signature where
overloadedMethod = materialSetLayerCombineConstant
instance O.OverloadedMethodInfo MaterialSetLayerCombineConstantMethodInfo Material where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Cogl.Structs.Material.materialSetLayerCombineConstant",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-cogl-1.0.3/docs/GI-Cogl-Structs-Material.html#v:materialSetLayerCombineConstant"
})
#endif
foreign import ccall "cogl_material_set_layer_filters" cogl_material_set_layer_filters ::
Ptr Material ->
Int32 ->
CUInt ->
CUInt ->
IO ()
{-# DEPRECATED materialSetLayerFilters ["(Since version 1.16)","Use @/cogl_pipeline_set_layer_filters()/@ instead"] #-}
materialSetLayerFilters ::
(B.CallStack.HasCallStack, MonadIO m) =>
Material
-> Int32
-> Cogl.Enums.MaterialFilter
-> Cogl.Enums.MaterialFilter
-> m ()
materialSetLayerFilters :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Material -> Int32 -> MaterialFilter -> MaterialFilter -> m ()
materialSetLayerFilters Material
material Int32
layerIndex MaterialFilter
minFilter MaterialFilter
magFilter = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Material
material' <- Material -> IO (Ptr Material)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Material
material
let minFilter' :: CUInt
minFilter' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt)
-> (MaterialFilter -> Int) -> MaterialFilter -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. MaterialFilter -> Int
forall a. Enum a => a -> Int
fromEnum) MaterialFilter
minFilter
let magFilter' :: CUInt
magFilter' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt)
-> (MaterialFilter -> Int) -> MaterialFilter -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. MaterialFilter -> Int
forall a. Enum a => a -> Int
fromEnum) MaterialFilter
magFilter
Ptr Material -> Int32 -> CUInt -> CUInt -> IO ()
cogl_material_set_layer_filters Ptr Material
material' Int32
layerIndex CUInt
minFilter' CUInt
magFilter'
Material -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Material
material
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data MaterialSetLayerFiltersMethodInfo
instance (signature ~ (Int32 -> Cogl.Enums.MaterialFilter -> Cogl.Enums.MaterialFilter -> m ()), MonadIO m) => O.OverloadedMethod MaterialSetLayerFiltersMethodInfo Material signature where
overloadedMethod = materialSetLayerFilters
instance O.OverloadedMethodInfo MaterialSetLayerFiltersMethodInfo Material where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Cogl.Structs.Material.materialSetLayerFilters",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-cogl-1.0.3/docs/GI-Cogl-Structs-Material.html#v:materialSetLayerFilters"
})
#endif
foreign import ccall "cogl_material_set_layer_matrix" cogl_material_set_layer_matrix ::
Ptr Material ->
Int32 ->
Ptr Cogl.Matrix.Matrix ->
IO ()
{-# DEPRECATED materialSetLayerMatrix ["(Since version 1.16)","Use @/cogl_pipeline_set_layer_matrix()/@ instead"] #-}
materialSetLayerMatrix ::
(B.CallStack.HasCallStack, MonadIO m) =>
Material
-> Int32
-> Cogl.Matrix.Matrix
-> m ()
materialSetLayerMatrix :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Material -> Int32 -> Matrix -> m ()
materialSetLayerMatrix Material
material Int32
layerIndex Matrix
matrix = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Material
material' <- Material -> IO (Ptr Material)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Material
material
Ptr Matrix
matrix' <- Matrix -> IO (Ptr Matrix)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Matrix
matrix
Ptr Material -> Int32 -> Ptr Matrix -> IO ()
cogl_material_set_layer_matrix Ptr Material
material' Int32
layerIndex Ptr Matrix
matrix'
Material -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Material
material
Matrix -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Matrix
matrix
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data MaterialSetLayerMatrixMethodInfo
instance (signature ~ (Int32 -> Cogl.Matrix.Matrix -> m ()), MonadIO m) => O.OverloadedMethod MaterialSetLayerMatrixMethodInfo Material signature where
overloadedMethod = materialSetLayerMatrix
instance O.OverloadedMethodInfo MaterialSetLayerMatrixMethodInfo Material where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Cogl.Structs.Material.materialSetLayerMatrix",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-cogl-1.0.3/docs/GI-Cogl-Structs-Material.html#v:materialSetLayerMatrix"
})
#endif
foreign import ccall "cogl_material_set_layer_point_sprite_coords_enabled" cogl_material_set_layer_point_sprite_coords_enabled ::
Ptr Material ->
Int32 ->
Int32 ->
Ptr (Ptr GError) ->
IO Int32
{-# DEPRECATED materialSetLayerPointSpriteCoordsEnabled ["(Since version 1.16)","Use @/cogl_pipeline_set_layer_point_sprite_coords_enabled()/@"," instead"] #-}
materialSetLayerPointSpriteCoordsEnabled ::
(B.CallStack.HasCallStack, MonadIO m) =>
Material
-> Int32
-> Int32
-> m Int32
materialSetLayerPointSpriteCoordsEnabled :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Material -> Int32 -> Int32 -> m Int32
materialSetLayerPointSpriteCoordsEnabled Material
material Int32
layerIndex Int32
enable = IO Int32 -> m Int32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
Ptr Material
material' <- Material -> IO (Ptr Material)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Material
material
IO Int32 -> IO () -> IO Int32
forall a b. IO a -> IO b -> IO a
onException (do
Int32
result <- (Ptr (Ptr GError) -> IO Int32) -> IO Int32
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO Int32) -> IO Int32)
-> (Ptr (Ptr GError) -> IO Int32) -> IO Int32
forall a b. (a -> b) -> a -> b
$ Ptr Material -> Int32 -> Int32 -> Ptr (Ptr GError) -> IO Int32
cogl_material_set_layer_point_sprite_coords_enabled Ptr Material
material' Int32
layerIndex Int32
enable
Material -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Material
material
Int32 -> IO Int32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
) (do
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
)
#if defined(ENABLE_OVERLOADING)
data MaterialSetLayerPointSpriteCoordsEnabledMethodInfo
instance (signature ~ (Int32 -> Int32 -> m Int32), MonadIO m) => O.OverloadedMethod MaterialSetLayerPointSpriteCoordsEnabledMethodInfo Material signature where
overloadedMethod = materialSetLayerPointSpriteCoordsEnabled
instance O.OverloadedMethodInfo MaterialSetLayerPointSpriteCoordsEnabledMethodInfo Material where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Cogl.Structs.Material.materialSetLayerPointSpriteCoordsEnabled",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-cogl-1.0.3/docs/GI-Cogl-Structs-Material.html#v:materialSetLayerPointSpriteCoordsEnabled"
})
#endif
foreign import ccall "cogl_material_set_layer_wrap_mode" cogl_material_set_layer_wrap_mode ::
Ptr Material ->
Int32 ->
CUInt ->
IO ()
{-# DEPRECATED materialSetLayerWrapMode ["(Since version 1.16)","Use @/cogl_pipeline_set_layer_wrap_mode()/@ instead"] #-}
materialSetLayerWrapMode ::
(B.CallStack.HasCallStack, MonadIO m) =>
Material
-> Int32
-> Cogl.Enums.MaterialWrapMode
-> m ()
materialSetLayerWrapMode :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Material -> Int32 -> MaterialWrapMode -> m ()
materialSetLayerWrapMode Material
material Int32
layerIndex MaterialWrapMode
mode = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Material
material' <- Material -> IO (Ptr Material)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Material
material
let mode' :: CUInt
mode' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt)
-> (MaterialWrapMode -> Int) -> MaterialWrapMode -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. MaterialWrapMode -> Int
forall a. Enum a => a -> Int
fromEnum) MaterialWrapMode
mode
Ptr Material -> Int32 -> CUInt -> IO ()
cogl_material_set_layer_wrap_mode Ptr Material
material' Int32
layerIndex CUInt
mode'
Material -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Material
material
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data MaterialSetLayerWrapModeMethodInfo
instance (signature ~ (Int32 -> Cogl.Enums.MaterialWrapMode -> m ()), MonadIO m) => O.OverloadedMethod MaterialSetLayerWrapModeMethodInfo Material signature where
overloadedMethod = materialSetLayerWrapMode
instance O.OverloadedMethodInfo MaterialSetLayerWrapModeMethodInfo Material where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Cogl.Structs.Material.materialSetLayerWrapMode",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-cogl-1.0.3/docs/GI-Cogl-Structs-Material.html#v:materialSetLayerWrapMode"
})
#endif
foreign import ccall "cogl_material_set_layer_wrap_mode_p" cogl_material_set_layer_wrap_mode_p ::
Ptr Material ->
Int32 ->
CUInt ->
IO ()
{-# DEPRECATED materialSetLayerWrapModeP ["(Since version 1.16)","Use @/cogl_pipeline_set_layer_wrap_mode_p()/@ instead"] #-}
materialSetLayerWrapModeP ::
(B.CallStack.HasCallStack, MonadIO m) =>
Material
-> Int32
-> Cogl.Enums.MaterialWrapMode
-> m ()
materialSetLayerWrapModeP :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Material -> Int32 -> MaterialWrapMode -> m ()
materialSetLayerWrapModeP Material
material Int32
layerIndex MaterialWrapMode
mode = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Material
material' <- Material -> IO (Ptr Material)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Material
material
let mode' :: CUInt
mode' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt)
-> (MaterialWrapMode -> Int) -> MaterialWrapMode -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. MaterialWrapMode -> Int
forall a. Enum a => a -> Int
fromEnum) MaterialWrapMode
mode
Ptr Material -> Int32 -> CUInt -> IO ()
cogl_material_set_layer_wrap_mode_p Ptr Material
material' Int32
layerIndex CUInt
mode'
Material -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Material
material
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data MaterialSetLayerWrapModePMethodInfo
instance (signature ~ (Int32 -> Cogl.Enums.MaterialWrapMode -> m ()), MonadIO m) => O.OverloadedMethod MaterialSetLayerWrapModePMethodInfo Material signature where
overloadedMethod = materialSetLayerWrapModeP
instance O.OverloadedMethodInfo MaterialSetLayerWrapModePMethodInfo Material where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Cogl.Structs.Material.materialSetLayerWrapModeP",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-cogl-1.0.3/docs/GI-Cogl-Structs-Material.html#v:materialSetLayerWrapModeP"
})
#endif
foreign import ccall "cogl_material_set_layer_wrap_mode_s" cogl_material_set_layer_wrap_mode_s ::
Ptr Material ->
Int32 ->
CUInt ->
IO ()
{-# DEPRECATED materialSetLayerWrapModeS ["(Since version 1.16)","Use @/cogl_pipeline_set_layer_wrap_mode_s()/@ instead"] #-}
materialSetLayerWrapModeS ::
(B.CallStack.HasCallStack, MonadIO m) =>
Material
-> Int32
-> Cogl.Enums.MaterialWrapMode
-> m ()
materialSetLayerWrapModeS :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Material -> Int32 -> MaterialWrapMode -> m ()
materialSetLayerWrapModeS Material
material Int32
layerIndex MaterialWrapMode
mode = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Material
material' <- Material -> IO (Ptr Material)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Material
material
let mode' :: CUInt
mode' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt)
-> (MaterialWrapMode -> Int) -> MaterialWrapMode -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. MaterialWrapMode -> Int
forall a. Enum a => a -> Int
fromEnum) MaterialWrapMode
mode
Ptr Material -> Int32 -> CUInt -> IO ()
cogl_material_set_layer_wrap_mode_s Ptr Material
material' Int32
layerIndex CUInt
mode'
Material -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Material
material
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data MaterialSetLayerWrapModeSMethodInfo
instance (signature ~ (Int32 -> Cogl.Enums.MaterialWrapMode -> m ()), MonadIO m) => O.OverloadedMethod MaterialSetLayerWrapModeSMethodInfo Material signature where
overloadedMethod = materialSetLayerWrapModeS
instance O.OverloadedMethodInfo MaterialSetLayerWrapModeSMethodInfo Material where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Cogl.Structs.Material.materialSetLayerWrapModeS",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-cogl-1.0.3/docs/GI-Cogl-Structs-Material.html#v:materialSetLayerWrapModeS"
})
#endif
foreign import ccall "cogl_material_set_layer_wrap_mode_t" cogl_material_set_layer_wrap_mode_t ::
Ptr Material ->
Int32 ->
CUInt ->
IO ()
{-# DEPRECATED materialSetLayerWrapModeT ["(Since version 1.16)","Use @/cogl_pipeline_set_layer_wrap_mode_t()/@ instead"] #-}
materialSetLayerWrapModeT ::
(B.CallStack.HasCallStack, MonadIO m) =>
Material
-> Int32
-> Cogl.Enums.MaterialWrapMode
-> m ()
materialSetLayerWrapModeT :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Material -> Int32 -> MaterialWrapMode -> m ()
materialSetLayerWrapModeT Material
material Int32
layerIndex MaterialWrapMode
mode = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Material
material' <- Material -> IO (Ptr Material)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Material
material
let mode' :: CUInt
mode' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt)
-> (MaterialWrapMode -> Int) -> MaterialWrapMode -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. MaterialWrapMode -> Int
forall a. Enum a => a -> Int
fromEnum) MaterialWrapMode
mode
Ptr Material -> Int32 -> CUInt -> IO ()
cogl_material_set_layer_wrap_mode_t Ptr Material
material' Int32
layerIndex CUInt
mode'
Material -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Material
material
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data MaterialSetLayerWrapModeTMethodInfo
instance (signature ~ (Int32 -> Cogl.Enums.MaterialWrapMode -> m ()), MonadIO m) => O.OverloadedMethod MaterialSetLayerWrapModeTMethodInfo Material signature where
overloadedMethod = materialSetLayerWrapModeT
instance O.OverloadedMethodInfo MaterialSetLayerWrapModeTMethodInfo Material where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Cogl.Structs.Material.materialSetLayerWrapModeT",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-cogl-1.0.3/docs/GI-Cogl-Structs-Material.html#v:materialSetLayerWrapModeT"
})
#endif
foreign import ccall "cogl_material_set_point_size" cogl_material_set_point_size ::
Ptr Material ->
CFloat ->
IO ()
{-# DEPRECATED materialSetPointSize ["(Since version 1.16)","Use @/cogl_pipeline_set_point_size()/@ instead"] #-}
materialSetPointSize ::
(B.CallStack.HasCallStack, MonadIO m) =>
Material
-> Float
-> m ()
materialSetPointSize :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Material -> Float -> m ()
materialSetPointSize Material
material Float
pointSize = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Material
material' <- Material -> IO (Ptr Material)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Material
material
let pointSize' :: CFloat
pointSize' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
pointSize
Ptr Material -> CFloat -> IO ()
cogl_material_set_point_size Ptr Material
material' CFloat
pointSize'
Material -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Material
material
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data MaterialSetPointSizeMethodInfo
instance (signature ~ (Float -> m ()), MonadIO m) => O.OverloadedMethod MaterialSetPointSizeMethodInfo Material signature where
overloadedMethod = materialSetPointSize
instance O.OverloadedMethodInfo MaterialSetPointSizeMethodInfo Material where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Cogl.Structs.Material.materialSetPointSize",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-cogl-1.0.3/docs/GI-Cogl-Structs-Material.html#v:materialSetPointSize"
})
#endif
foreign import ccall "cogl_material_set_shininess" cogl_material_set_shininess ::
Ptr Material ->
CFloat ->
IO ()
{-# DEPRECATED materialSetShininess ["(Since version 1.16)","Use the @/CoglSnippet/@ shader api for lighting"] #-}
materialSetShininess ::
(B.CallStack.HasCallStack, MonadIO m) =>
Material
-> Float
-> m ()
materialSetShininess :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Material -> Float -> m ()
materialSetShininess Material
material Float
shininess = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Material
material' <- Material -> IO (Ptr Material)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Material
material
let shininess' :: CFloat
shininess' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
shininess
Ptr Material -> CFloat -> IO ()
cogl_material_set_shininess Ptr Material
material' CFloat
shininess'
Material -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Material
material
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data MaterialSetShininessMethodInfo
instance (signature ~ (Float -> m ()), MonadIO m) => O.OverloadedMethod MaterialSetShininessMethodInfo Material signature where
overloadedMethod = materialSetShininess
instance O.OverloadedMethodInfo MaterialSetShininessMethodInfo Material where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Cogl.Structs.Material.materialSetShininess",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-cogl-1.0.3/docs/GI-Cogl-Structs-Material.html#v:materialSetShininess"
})
#endif
foreign import ccall "cogl_material_set_specular" cogl_material_set_specular ::
Ptr Material ->
Ptr Cogl.Color.Color ->
IO ()
{-# DEPRECATED materialSetSpecular ["(Since version 1.16)","Use the @/CoglSnippet/@ shader api for lighting"] #-}
materialSetSpecular ::
(B.CallStack.HasCallStack, MonadIO m) =>
Material
-> Cogl.Color.Color
-> m ()
materialSetSpecular :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Material -> Color -> m ()
materialSetSpecular Material
material Color
specular = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Material
material' <- Material -> IO (Ptr Material)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Material
material
Ptr Color
specular' <- Color -> IO (Ptr Color)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Color
specular
Ptr Material -> Ptr Color -> IO ()
cogl_material_set_specular Ptr Material
material' Ptr Color
specular'
Material -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Material
material
Color -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Color
specular
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data MaterialSetSpecularMethodInfo
instance (signature ~ (Cogl.Color.Color -> m ()), MonadIO m) => O.OverloadedMethod MaterialSetSpecularMethodInfo Material signature where
overloadedMethod = materialSetSpecular
instance O.OverloadedMethodInfo MaterialSetSpecularMethodInfo Material where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Cogl.Structs.Material.materialSetSpecular",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-cogl-1.0.3/docs/GI-Cogl-Structs-Material.html#v:materialSetSpecular"
})
#endif
foreign import ccall "cogl_material_set_user_program" cogl_material_set_user_program ::
Ptr Material ->
Ptr () ->
IO ()
{-# DEPRECATED materialSetUserProgram ["(Since version 1.16)","Use @/CoglSnippet/@ api instead instead"] #-}
materialSetUserProgram ::
(B.CallStack.HasCallStack, MonadIO m) =>
Material
-> Ptr ()
-> m ()
materialSetUserProgram :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Material -> Ptr () -> m ()
materialSetUserProgram Material
material Ptr ()
program = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Material
material' <- Material -> IO (Ptr Material)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Material
material
Ptr Material -> Ptr () -> IO ()
cogl_material_set_user_program Ptr Material
material' Ptr ()
program
Material -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Material
material
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data MaterialSetUserProgramMethodInfo
instance (signature ~ (Ptr () -> m ()), MonadIO m) => O.OverloadedMethod MaterialSetUserProgramMethodInfo Material signature where
overloadedMethod = materialSetUserProgram
instance O.OverloadedMethodInfo MaterialSetUserProgramMethodInfo Material where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Cogl.Structs.Material.materialSetUserProgram",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-cogl-1.0.3/docs/GI-Cogl-Structs-Material.html#v:materialSetUserProgram"
})
#endif
foreign import ccall "cogl_material_ref" cogl_material_ref ::
Ptr () ->
IO (Ptr ())
{-# DEPRECATED materialRef ["(Since version 1.2)","Use @/cogl_object_ref()/@ instead"] #-}
materialRef ::
(B.CallStack.HasCallStack, MonadIO m) =>
Ptr ()
-> m (Ptr ())
materialRef :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Ptr () -> m (Ptr ())
materialRef Ptr ()
material = IO (Ptr ()) -> m (Ptr ())
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Ptr ()) -> m (Ptr ())) -> IO (Ptr ()) -> m (Ptr ())
forall a b. (a -> b) -> a -> b
$ do
Ptr ()
result <- Ptr () -> IO (Ptr ())
cogl_material_ref Ptr ()
material
Ptr () -> IO (Ptr ())
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr ()
result
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "cogl_material_unref" cogl_material_unref ::
Ptr () ->
IO ()
{-# DEPRECATED materialUnref ["(Since version 1.2)","Use @/cogl_object_unref()/@ instead"] #-}
materialUnref ::
(B.CallStack.HasCallStack, MonadIO m) =>
Ptr ()
-> m ()
materialUnref :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Ptr () -> m ()
materialUnref Ptr ()
material = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr () -> IO ()
cogl_material_unref Ptr ()
material
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveMaterialMethod (t :: Symbol) (o :: *) :: * where
ResolveMaterialMethod "removeLayer" o = MaterialRemoveLayerMethodInfo
ResolveMaterialMethod "getAmbient" o = MaterialGetAmbientMethodInfo
ResolveMaterialMethod "getColor" o = MaterialGetColorMethodInfo
ResolveMaterialMethod "getDiffuse" o = MaterialGetDiffuseMethodInfo
ResolveMaterialMethod "getEmission" o = MaterialGetEmissionMethodInfo
ResolveMaterialMethod "getLayerPointSpriteCoordsEnabled" o = MaterialGetLayerPointSpriteCoordsEnabledMethodInfo
ResolveMaterialMethod "getLayerWrapModeP" o = MaterialGetLayerWrapModePMethodInfo
ResolveMaterialMethod "getLayerWrapModeS" o = MaterialGetLayerWrapModeSMethodInfo
ResolveMaterialMethod "getLayerWrapModeT" o = MaterialGetLayerWrapModeTMethodInfo
ResolveMaterialMethod "getLayers" o = MaterialGetLayersMethodInfo
ResolveMaterialMethod "getNLayers" o = MaterialGetNLayersMethodInfo
ResolveMaterialMethod "getPointSize" o = MaterialGetPointSizeMethodInfo
ResolveMaterialMethod "getShininess" o = MaterialGetShininessMethodInfo
ResolveMaterialMethod "getSpecular" o = MaterialGetSpecularMethodInfo
ResolveMaterialMethod "getUserProgram" o = MaterialGetUserProgramMethodInfo
ResolveMaterialMethod "setAlphaTestFunction" o = MaterialSetAlphaTestFunctionMethodInfo
ResolveMaterialMethod "setAmbient" o = MaterialSetAmbientMethodInfo
ResolveMaterialMethod "setAmbientAndDiffuse" o = MaterialSetAmbientAndDiffuseMethodInfo
ResolveMaterialMethod "setBlend" o = MaterialSetBlendMethodInfo
ResolveMaterialMethod "setBlendConstant" o = MaterialSetBlendConstantMethodInfo
ResolveMaterialMethod "setColor" o = MaterialSetColorMethodInfo
ResolveMaterialMethod "setColor4f" o = MaterialSetColor4fMethodInfo
ResolveMaterialMethod "setColor4ub" o = MaterialSetColor4ubMethodInfo
ResolveMaterialMethod "setDiffuse" o = MaterialSetDiffuseMethodInfo
ResolveMaterialMethod "setEmission" o = MaterialSetEmissionMethodInfo
ResolveMaterialMethod "setLayer" o = MaterialSetLayerMethodInfo
ResolveMaterialMethod "setLayerCombine" o = MaterialSetLayerCombineMethodInfo
ResolveMaterialMethod "setLayerCombineConstant" o = MaterialSetLayerCombineConstantMethodInfo
ResolveMaterialMethod "setLayerFilters" o = MaterialSetLayerFiltersMethodInfo
ResolveMaterialMethod "setLayerMatrix" o = MaterialSetLayerMatrixMethodInfo
ResolveMaterialMethod "setLayerPointSpriteCoordsEnabled" o = MaterialSetLayerPointSpriteCoordsEnabledMethodInfo
ResolveMaterialMethod "setLayerWrapMode" o = MaterialSetLayerWrapModeMethodInfo
ResolveMaterialMethod "setLayerWrapModeP" o = MaterialSetLayerWrapModePMethodInfo
ResolveMaterialMethod "setLayerWrapModeS" o = MaterialSetLayerWrapModeSMethodInfo
ResolveMaterialMethod "setLayerWrapModeT" o = MaterialSetLayerWrapModeTMethodInfo
ResolveMaterialMethod "setPointSize" o = MaterialSetPointSizeMethodInfo
ResolveMaterialMethod "setShininess" o = MaterialSetShininessMethodInfo
ResolveMaterialMethod "setSpecular" o = MaterialSetSpecularMethodInfo
ResolveMaterialMethod "setUserProgram" o = MaterialSetUserProgramMethodInfo
ResolveMaterialMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveMaterialMethod t Material, O.OverloadedMethod info Material p) => OL.IsLabel t (Material -> p) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.overloadedMethod @info
#else
fromLabel _ = O.overloadedMethod @info
#endif
#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolveMaterialMethod t Material, O.OverloadedMethod info Material p, R.HasField t Material p) => R.HasField t Material p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveMaterialMethod t Material, O.OverloadedMethodInfo info Material) => OL.IsLabel t (O.MethodProxy info Material) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif