{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Clutter.Objects.ShaderEffect
(
ShaderEffect(..) ,
IsShaderEffect ,
toShaderEffect ,
#if defined(ENABLE_OVERLOADING)
ResolveShaderEffectMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
ShaderEffectGetProgramMethodInfo ,
#endif
shaderEffectGetProgram ,
#if defined(ENABLE_OVERLOADING)
ShaderEffectGetShaderMethodInfo ,
#endif
shaderEffectGetShader ,
shaderEffectNew ,
#if defined(ENABLE_OVERLOADING)
ShaderEffectSetShaderSourceMethodInfo ,
#endif
shaderEffectSetShaderSource ,
#if defined(ENABLE_OVERLOADING)
ShaderEffectSetUniformValueMethodInfo ,
#endif
shaderEffectSetUniformValue ,
#if defined(ENABLE_OVERLOADING)
ShaderEffectShaderTypePropertyInfo ,
#endif
constructShaderEffectShaderType ,
#if defined(ENABLE_OVERLOADING)
shaderEffectShaderType ,
#endif
) 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.Kind as DK
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.Clutter.Enums as Clutter.Enums
import {-# SOURCE #-} qualified GI.Clutter.Objects.ActorMeta as Clutter.ActorMeta
import {-# SOURCE #-} qualified GI.Clutter.Objects.Effect as Clutter.Effect
import {-# SOURCE #-} qualified GI.Clutter.Objects.OffscreenEffect as Clutter.OffscreenEffect
import qualified GI.GObject.Objects.Object as GObject.Object
newtype ShaderEffect = ShaderEffect (SP.ManagedPtr ShaderEffect)
deriving (ShaderEffect -> ShaderEffect -> Bool
(ShaderEffect -> ShaderEffect -> Bool)
-> (ShaderEffect -> ShaderEffect -> Bool) -> Eq ShaderEffect
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ShaderEffect -> ShaderEffect -> Bool
== :: ShaderEffect -> ShaderEffect -> Bool
$c/= :: ShaderEffect -> ShaderEffect -> Bool
/= :: ShaderEffect -> ShaderEffect -> Bool
Eq)
instance SP.ManagedPtrNewtype ShaderEffect where
toManagedPtr :: ShaderEffect -> ManagedPtr ShaderEffect
toManagedPtr (ShaderEffect ManagedPtr ShaderEffect
p) = ManagedPtr ShaderEffect
p
foreign import ccall "clutter_shader_effect_get_type"
c_clutter_shader_effect_get_type :: IO B.Types.GType
instance B.Types.TypedObject ShaderEffect where
glibType :: IO GType
glibType = IO GType
c_clutter_shader_effect_get_type
instance B.Types.GObject ShaderEffect
class (SP.GObject o, O.IsDescendantOf ShaderEffect o) => IsShaderEffect o
instance (SP.GObject o, O.IsDescendantOf ShaderEffect o) => IsShaderEffect o
instance O.HasParentTypes ShaderEffect
type instance O.ParentTypes ShaderEffect = '[Clutter.OffscreenEffect.OffscreenEffect, Clutter.Effect.Effect, Clutter.ActorMeta.ActorMeta, GObject.Object.Object]
toShaderEffect :: (MIO.MonadIO m, IsShaderEffect o) => o -> m ShaderEffect
toShaderEffect :: forall (m :: * -> *) o.
(MonadIO m, IsShaderEffect o) =>
o -> m ShaderEffect
toShaderEffect = IO ShaderEffect -> m ShaderEffect
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO ShaderEffect -> m ShaderEffect)
-> (o -> IO ShaderEffect) -> o -> m ShaderEffect
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr ShaderEffect -> ShaderEffect) -> o -> IO ShaderEffect
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr ShaderEffect -> ShaderEffect
ShaderEffect
instance B.GValue.IsGValue (Maybe ShaderEffect) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_clutter_shader_effect_get_type
gvalueSet_ :: Ptr GValue -> Maybe ShaderEffect -> IO ()
gvalueSet_ Ptr GValue
gv Maybe ShaderEffect
P.Nothing = Ptr GValue -> Ptr ShaderEffect -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr ShaderEffect
forall a. Ptr a
FP.nullPtr :: FP.Ptr ShaderEffect)
gvalueSet_ Ptr GValue
gv (P.Just ShaderEffect
obj) = ShaderEffect -> (Ptr ShaderEffect -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr ShaderEffect
obj (Ptr GValue -> Ptr ShaderEffect -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe ShaderEffect)
gvalueGet_ Ptr GValue
gv = do
Ptr ShaderEffect
ptr <- Ptr GValue -> IO (Ptr ShaderEffect)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr ShaderEffect)
if Ptr ShaderEffect
ptr Ptr ShaderEffect -> Ptr ShaderEffect -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr ShaderEffect
forall a. Ptr a
FP.nullPtr
then ShaderEffect -> Maybe ShaderEffect
forall a. a -> Maybe a
P.Just (ShaderEffect -> Maybe ShaderEffect)
-> IO ShaderEffect -> IO (Maybe ShaderEffect)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr ShaderEffect -> ShaderEffect)
-> Ptr ShaderEffect -> IO ShaderEffect
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr ShaderEffect -> ShaderEffect
ShaderEffect Ptr ShaderEffect
ptr
else Maybe ShaderEffect -> IO (Maybe ShaderEffect)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe ShaderEffect
forall a. Maybe a
P.Nothing
#if defined(ENABLE_OVERLOADING)
type family ResolveShaderEffectMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
ResolveShaderEffectMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
ResolveShaderEffectMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
ResolveShaderEffectMethod "createTexture" o = Clutter.OffscreenEffect.OffscreenEffectCreateTextureMethodInfo
ResolveShaderEffectMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
ResolveShaderEffectMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
ResolveShaderEffectMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
ResolveShaderEffectMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
ResolveShaderEffectMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
ResolveShaderEffectMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
ResolveShaderEffectMethod "paintTarget" o = Clutter.OffscreenEffect.OffscreenEffectPaintTargetMethodInfo
ResolveShaderEffectMethod "queueRepaint" o = Clutter.Effect.EffectQueueRepaintMethodInfo
ResolveShaderEffectMethod "ref" o = GObject.Object.ObjectRefMethodInfo
ResolveShaderEffectMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
ResolveShaderEffectMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
ResolveShaderEffectMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
ResolveShaderEffectMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
ResolveShaderEffectMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
ResolveShaderEffectMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
ResolveShaderEffectMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
ResolveShaderEffectMethod "getActor" o = Clutter.ActorMeta.ActorMetaGetActorMethodInfo
ResolveShaderEffectMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
ResolveShaderEffectMethod "getEnabled" o = Clutter.ActorMeta.ActorMetaGetEnabledMethodInfo
ResolveShaderEffectMethod "getName" o = Clutter.ActorMeta.ActorMetaGetNameMethodInfo
ResolveShaderEffectMethod "getProgram" o = ShaderEffectGetProgramMethodInfo
ResolveShaderEffectMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
ResolveShaderEffectMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
ResolveShaderEffectMethod "getShader" o = ShaderEffectGetShaderMethodInfo
ResolveShaderEffectMethod "getTarget" o = Clutter.OffscreenEffect.OffscreenEffectGetTargetMethodInfo
ResolveShaderEffectMethod "getTargetRect" o = Clutter.OffscreenEffect.OffscreenEffectGetTargetRectMethodInfo
ResolveShaderEffectMethod "getTargetSize" o = Clutter.OffscreenEffect.OffscreenEffectGetTargetSizeMethodInfo
ResolveShaderEffectMethod "getTexture" o = Clutter.OffscreenEffect.OffscreenEffectGetTextureMethodInfo
ResolveShaderEffectMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
ResolveShaderEffectMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
ResolveShaderEffectMethod "setEnabled" o = Clutter.ActorMeta.ActorMetaSetEnabledMethodInfo
ResolveShaderEffectMethod "setName" o = Clutter.ActorMeta.ActorMetaSetNameMethodInfo
ResolveShaderEffectMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
ResolveShaderEffectMethod "setShaderSource" o = ShaderEffectSetShaderSourceMethodInfo
ResolveShaderEffectMethod "setUniformValue" o = ShaderEffectSetUniformValueMethodInfo
ResolveShaderEffectMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveShaderEffectMethod t ShaderEffect, O.OverloadedMethod info ShaderEffect p) => OL.IsLabel t (ShaderEffect -> 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 ~ ResolveShaderEffectMethod t ShaderEffect, O.OverloadedMethod info ShaderEffect p, R.HasField t ShaderEffect p) => R.HasField t ShaderEffect p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveShaderEffectMethod t ShaderEffect, O.OverloadedMethodInfo info ShaderEffect) => OL.IsLabel t (O.MethodProxy info ShaderEffect) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif
constructShaderEffectShaderType :: (IsShaderEffect o, MIO.MonadIO m) => Clutter.Enums.ShaderType -> m (GValueConstruct o)
constructShaderEffectShaderType :: forall o (m :: * -> *).
(IsShaderEffect o, MonadIO m) =>
ShaderType -> m (GValueConstruct o)
constructShaderEffectShaderType ShaderType
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> ShaderType -> IO (GValueConstruct o)
forall a o.
(Enum a, BoxedEnum a) =>
String -> a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyEnum String
"shader-type" ShaderType
val
#if defined(ENABLE_OVERLOADING)
data ShaderEffectShaderTypePropertyInfo
instance AttrInfo ShaderEffectShaderTypePropertyInfo where
type AttrAllowedOps ShaderEffectShaderTypePropertyInfo = '[ 'AttrConstruct]
type AttrBaseTypeConstraint ShaderEffectShaderTypePropertyInfo = IsShaderEffect
type AttrSetTypeConstraint ShaderEffectShaderTypePropertyInfo = (~) Clutter.Enums.ShaderType
type AttrTransferTypeConstraint ShaderEffectShaderTypePropertyInfo = (~) Clutter.Enums.ShaderType
type AttrTransferType ShaderEffectShaderTypePropertyInfo = Clutter.Enums.ShaderType
type AttrGetType ShaderEffectShaderTypePropertyInfo = ()
type AttrLabel ShaderEffectShaderTypePropertyInfo = "shader-type"
type AttrOrigin ShaderEffectShaderTypePropertyInfo = ShaderEffect
attrGet = undefined
attrSet = undefined
attrTransfer _ v = do
return v
attrConstruct = constructShaderEffectShaderType
attrClear = undefined
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Objects.ShaderEffect.shaderType"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.5/docs/GI-Clutter-Objects-ShaderEffect.html#g:attr:shaderType"
})
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList ShaderEffect
type instance O.AttributeList ShaderEffect = ShaderEffectAttributeList
type ShaderEffectAttributeList = ('[ '("actor", Clutter.ActorMeta.ActorMetaActorPropertyInfo), '("enabled", Clutter.ActorMeta.ActorMetaEnabledPropertyInfo), '("name", Clutter.ActorMeta.ActorMetaNamePropertyInfo), '("shaderType", ShaderEffectShaderTypePropertyInfo)] :: [(Symbol, DK.Type)])
#endif
#if defined(ENABLE_OVERLOADING)
shaderEffectShaderType :: AttrLabelProxy "shaderType"
shaderEffectShaderType = AttrLabelProxy
#endif
#if defined(ENABLE_OVERLOADING)
type instance O.SignalList ShaderEffect = ShaderEffectSignalList
type ShaderEffectSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, DK.Type)])
#endif
foreign import ccall "clutter_shader_effect_new" clutter_shader_effect_new ::
CUInt ->
IO (Ptr ShaderEffect)
shaderEffectNew ::
(B.CallStack.HasCallStack, MonadIO m) =>
Clutter.Enums.ShaderType
-> m ShaderEffect
shaderEffectNew :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
ShaderType -> m ShaderEffect
shaderEffectNew ShaderType
shaderType = IO ShaderEffect -> m ShaderEffect
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO ShaderEffect -> m ShaderEffect)
-> IO ShaderEffect -> m ShaderEffect
forall a b. (a -> b) -> a -> b
$ do
let shaderType' :: CUInt
shaderType' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (ShaderType -> Int) -> ShaderType -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ShaderType -> Int
forall a. Enum a => a -> Int
fromEnum) ShaderType
shaderType
Ptr ShaderEffect
result <- CUInt -> IO (Ptr ShaderEffect)
clutter_shader_effect_new CUInt
shaderType'
Text -> Ptr ShaderEffect -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"shaderEffectNew" Ptr ShaderEffect
result
ShaderEffect
result' <- ((ManagedPtr ShaderEffect -> ShaderEffect)
-> Ptr ShaderEffect -> IO ShaderEffect
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr ShaderEffect -> ShaderEffect
ShaderEffect) Ptr ShaderEffect
result
ShaderEffect -> IO ShaderEffect
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ShaderEffect
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "clutter_shader_effect_get_program" clutter_shader_effect_get_program ::
Ptr ShaderEffect ->
IO (Ptr ())
shaderEffectGetProgram ::
(B.CallStack.HasCallStack, MonadIO m, IsShaderEffect a) =>
a
-> m (Ptr ())
shaderEffectGetProgram :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsShaderEffect a) =>
a -> m (Ptr ())
shaderEffectGetProgram a
effect = 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 ShaderEffect
effect' <- a -> IO (Ptr ShaderEffect)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
effect
Ptr ()
result <- Ptr ShaderEffect -> IO (Ptr ())
clutter_shader_effect_get_program Ptr ShaderEffect
effect'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
effect
Ptr () -> IO (Ptr ())
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr ()
result
#if defined(ENABLE_OVERLOADING)
data ShaderEffectGetProgramMethodInfo
instance (signature ~ (m (Ptr ())), MonadIO m, IsShaderEffect a) => O.OverloadedMethod ShaderEffectGetProgramMethodInfo a signature where
overloadedMethod = shaderEffectGetProgram
instance O.OverloadedMethodInfo ShaderEffectGetProgramMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Objects.ShaderEffect.shaderEffectGetProgram",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.5/docs/GI-Clutter-Objects-ShaderEffect.html#v:shaderEffectGetProgram"
})
#endif
foreign import ccall "clutter_shader_effect_get_shader" clutter_shader_effect_get_shader ::
Ptr ShaderEffect ->
IO (Ptr ())
shaderEffectGetShader ::
(B.CallStack.HasCallStack, MonadIO m, IsShaderEffect a) =>
a
-> m (Ptr ())
shaderEffectGetShader :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsShaderEffect a) =>
a -> m (Ptr ())
shaderEffectGetShader a
effect = 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 ShaderEffect
effect' <- a -> IO (Ptr ShaderEffect)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
effect
Ptr ()
result <- Ptr ShaderEffect -> IO (Ptr ())
clutter_shader_effect_get_shader Ptr ShaderEffect
effect'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
effect
Ptr () -> IO (Ptr ())
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr ()
result
#if defined(ENABLE_OVERLOADING)
data ShaderEffectGetShaderMethodInfo
instance (signature ~ (m (Ptr ())), MonadIO m, IsShaderEffect a) => O.OverloadedMethod ShaderEffectGetShaderMethodInfo a signature where
overloadedMethod = shaderEffectGetShader
instance O.OverloadedMethodInfo ShaderEffectGetShaderMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Objects.ShaderEffect.shaderEffectGetShader",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.5/docs/GI-Clutter-Objects-ShaderEffect.html#v:shaderEffectGetShader"
})
#endif
foreign import ccall "clutter_shader_effect_set_shader_source" clutter_shader_effect_set_shader_source ::
Ptr ShaderEffect ->
CString ->
IO CInt
shaderEffectSetShaderSource ::
(B.CallStack.HasCallStack, MonadIO m, IsShaderEffect a) =>
a
-> T.Text
-> m Bool
shaderEffectSetShaderSource :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsShaderEffect a) =>
a -> Text -> m Bool
shaderEffectSetShaderSource a
effect Text
source = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr ShaderEffect
effect' <- a -> IO (Ptr ShaderEffect)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
effect
CString
source' <- Text -> IO CString
textToCString Text
source
CInt
result <- Ptr ShaderEffect -> CString -> IO CInt
clutter_shader_effect_set_shader_source Ptr ShaderEffect
effect' CString
source'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
effect
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
source'
Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data ShaderEffectSetShaderSourceMethodInfo
instance (signature ~ (T.Text -> m Bool), MonadIO m, IsShaderEffect a) => O.OverloadedMethod ShaderEffectSetShaderSourceMethodInfo a signature where
overloadedMethod = shaderEffectSetShaderSource
instance O.OverloadedMethodInfo ShaderEffectSetShaderSourceMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Objects.ShaderEffect.shaderEffectSetShaderSource",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.5/docs/GI-Clutter-Objects-ShaderEffect.html#v:shaderEffectSetShaderSource"
})
#endif
foreign import ccall "clutter_shader_effect_set_uniform_value" clutter_shader_effect_set_uniform_value ::
Ptr ShaderEffect ->
CString ->
Ptr GValue ->
IO ()
shaderEffectSetUniformValue ::
(B.CallStack.HasCallStack, MonadIO m, IsShaderEffect a) =>
a
-> T.Text
-> GValue
-> m ()
shaderEffectSetUniformValue :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsShaderEffect a) =>
a -> Text -> GValue -> m ()
shaderEffectSetUniformValue a
effect Text
name GValue
value = 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 ShaderEffect
effect' <- a -> IO (Ptr ShaderEffect)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
effect
CString
name' <- Text -> IO CString
textToCString Text
name
Ptr GValue
value' <- GValue -> IO (Ptr GValue)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GValue
value
Ptr ShaderEffect -> CString -> Ptr GValue -> IO ()
clutter_shader_effect_set_uniform_value Ptr ShaderEffect
effect' CString
name' Ptr GValue
value'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
effect
GValue -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GValue
value
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
name'
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data ShaderEffectSetUniformValueMethodInfo
instance (signature ~ (T.Text -> GValue -> m ()), MonadIO m, IsShaderEffect a) => O.OverloadedMethod ShaderEffectSetUniformValueMethodInfo a signature where
overloadedMethod = shaderEffectSetUniformValue
instance O.OverloadedMethodInfo ShaderEffectSetUniformValueMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Objects.ShaderEffect.shaderEffectSetUniformValue",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.5/docs/GI-Clutter-Objects-ShaderEffect.html#v:shaderEffectSetUniformValue"
})
#endif