{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Clutter.Objects.Shader
(
Shader(..) ,
IsShader ,
toShader ,
#if defined(ENABLE_OVERLOADING)
ResolveShaderMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
ShaderCompileMethodInfo ,
#endif
shaderCompile ,
#if defined(ENABLE_OVERLOADING)
ShaderGetCoglFragmentShaderMethodInfo ,
#endif
shaderGetCoglFragmentShader ,
#if defined(ENABLE_OVERLOADING)
ShaderGetCoglProgramMethodInfo ,
#endif
shaderGetCoglProgram ,
#if defined(ENABLE_OVERLOADING)
ShaderGetCoglVertexShaderMethodInfo ,
#endif
shaderGetCoglVertexShader ,
#if defined(ENABLE_OVERLOADING)
ShaderGetFragmentSourceMethodInfo ,
#endif
shaderGetFragmentSource ,
#if defined(ENABLE_OVERLOADING)
ShaderGetIsEnabledMethodInfo ,
#endif
shaderGetIsEnabled ,
#if defined(ENABLE_OVERLOADING)
ShaderGetVertexSourceMethodInfo ,
#endif
shaderGetVertexSource ,
#if defined(ENABLE_OVERLOADING)
ShaderIsCompiledMethodInfo ,
#endif
shaderIsCompiled ,
shaderNew ,
#if defined(ENABLE_OVERLOADING)
ShaderReleaseMethodInfo ,
#endif
shaderRelease ,
#if defined(ENABLE_OVERLOADING)
ShaderSetFragmentSourceMethodInfo ,
#endif
shaderSetFragmentSource ,
#if defined(ENABLE_OVERLOADING)
ShaderSetIsEnabledMethodInfo ,
#endif
shaderSetIsEnabled ,
#if defined(ENABLE_OVERLOADING)
ShaderSetUniformMethodInfo ,
#endif
shaderSetUniform ,
#if defined(ENABLE_OVERLOADING)
ShaderSetVertexSourceMethodInfo ,
#endif
shaderSetVertexSource ,
#if defined(ENABLE_OVERLOADING)
ShaderCompiledPropertyInfo ,
#endif
getShaderCompiled ,
#if defined(ENABLE_OVERLOADING)
shaderCompiled ,
#endif
#if defined(ENABLE_OVERLOADING)
ShaderEnabledPropertyInfo ,
#endif
constructShaderEnabled ,
getShaderEnabled ,
setShaderEnabled ,
#if defined(ENABLE_OVERLOADING)
shaderEnabled ,
#endif
#if defined(ENABLE_OVERLOADING)
ShaderFragmentSourcePropertyInfo ,
#endif
clearShaderFragmentSource ,
constructShaderFragmentSource ,
getShaderFragmentSource ,
setShaderFragmentSource ,
#if defined(ENABLE_OVERLOADING)
shaderFragmentSource ,
#endif
#if defined(ENABLE_OVERLOADING)
ShaderVertexSourcePropertyInfo ,
#endif
clearShaderVertexSource ,
constructShaderVertexSource ,
getShaderVertexSource ,
setShaderVertexSource ,
#if defined(ENABLE_OVERLOADING)
shaderVertexSource ,
#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.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 qualified GI.GObject.Objects.Object as GObject.Object
newtype Shader = Shader (SP.ManagedPtr Shader)
deriving (Shader -> Shader -> Bool
(Shader -> Shader -> Bool)
-> (Shader -> Shader -> Bool) -> Eq Shader
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Shader -> Shader -> Bool
== :: Shader -> Shader -> Bool
$c/= :: Shader -> Shader -> Bool
/= :: Shader -> Shader -> Bool
Eq)
instance SP.ManagedPtrNewtype Shader where
toManagedPtr :: Shader -> ManagedPtr Shader
toManagedPtr (Shader ManagedPtr Shader
p) = ManagedPtr Shader
p
foreign import ccall "clutter_shader_get_type"
c_clutter_shader_get_type :: IO B.Types.GType
instance B.Types.TypedObject Shader where
glibType :: IO GType
glibType = IO GType
c_clutter_shader_get_type
instance B.Types.GObject Shader
class (SP.GObject o, O.IsDescendantOf Shader o) => IsShader o
instance (SP.GObject o, O.IsDescendantOf Shader o) => IsShader o
instance O.HasParentTypes Shader
type instance O.ParentTypes Shader = '[GObject.Object.Object]
toShader :: (MIO.MonadIO m, IsShader o) => o -> m Shader
toShader :: forall (m :: * -> *) o. (MonadIO m, IsShader o) => o -> m Shader
toShader = IO Shader -> m Shader
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Shader -> m Shader) -> (o -> IO Shader) -> o -> m Shader
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr Shader -> Shader) -> o -> IO Shader
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr Shader -> Shader
Shader
instance B.GValue.IsGValue (Maybe Shader) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_clutter_shader_get_type
gvalueSet_ :: Ptr GValue -> Maybe Shader -> IO ()
gvalueSet_ Ptr GValue
gv Maybe Shader
P.Nothing = Ptr GValue -> Ptr Shader -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr Shader
forall a. Ptr a
FP.nullPtr :: FP.Ptr Shader)
gvalueSet_ Ptr GValue
gv (P.Just Shader
obj) = Shader -> (Ptr Shader -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr Shader
obj (Ptr GValue -> Ptr Shader -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe Shader)
gvalueGet_ Ptr GValue
gv = do
Ptr Shader
ptr <- Ptr GValue -> IO (Ptr Shader)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr Shader)
if Ptr Shader
ptr Ptr Shader -> Ptr Shader -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr Shader
forall a. Ptr a
FP.nullPtr
then Shader -> Maybe Shader
forall a. a -> Maybe a
P.Just (Shader -> Maybe Shader) -> IO Shader -> IO (Maybe Shader)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr Shader -> Shader) -> Ptr Shader -> IO Shader
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr Shader -> Shader
Shader Ptr Shader
ptr
else Maybe Shader -> IO (Maybe Shader)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Shader
forall a. Maybe a
P.Nothing
#if defined(ENABLE_OVERLOADING)
type family ResolveShaderMethod (t :: Symbol) (o :: *) :: * where
ResolveShaderMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
ResolveShaderMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
ResolveShaderMethod "compile" o = ShaderCompileMethodInfo
ResolveShaderMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
ResolveShaderMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
ResolveShaderMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
ResolveShaderMethod "isCompiled" o = ShaderIsCompiledMethodInfo
ResolveShaderMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
ResolveShaderMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
ResolveShaderMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
ResolveShaderMethod "ref" o = GObject.Object.ObjectRefMethodInfo
ResolveShaderMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
ResolveShaderMethod "release" o = ShaderReleaseMethodInfo
ResolveShaderMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
ResolveShaderMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
ResolveShaderMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
ResolveShaderMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
ResolveShaderMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
ResolveShaderMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
ResolveShaderMethod "getCoglFragmentShader" o = ShaderGetCoglFragmentShaderMethodInfo
ResolveShaderMethod "getCoglProgram" o = ShaderGetCoglProgramMethodInfo
ResolveShaderMethod "getCoglVertexShader" o = ShaderGetCoglVertexShaderMethodInfo
ResolveShaderMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
ResolveShaderMethod "getFragmentSource" o = ShaderGetFragmentSourceMethodInfo
ResolveShaderMethod "getIsEnabled" o = ShaderGetIsEnabledMethodInfo
ResolveShaderMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
ResolveShaderMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
ResolveShaderMethod "getVertexSource" o = ShaderGetVertexSourceMethodInfo
ResolveShaderMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
ResolveShaderMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
ResolveShaderMethod "setFragmentSource" o = ShaderSetFragmentSourceMethodInfo
ResolveShaderMethod "setIsEnabled" o = ShaderSetIsEnabledMethodInfo
ResolveShaderMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
ResolveShaderMethod "setUniform" o = ShaderSetUniformMethodInfo
ResolveShaderMethod "setVertexSource" o = ShaderSetVertexSourceMethodInfo
ResolveShaderMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveShaderMethod t Shader, O.OverloadedMethod info Shader p) => OL.IsLabel t (Shader -> 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 ~ ResolveShaderMethod t Shader, O.OverloadedMethod info Shader p, R.HasField t Shader p) => R.HasField t Shader p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveShaderMethod t Shader, O.OverloadedMethodInfo info Shader) => OL.IsLabel t (O.MethodProxy info Shader) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif
getShaderCompiled :: (MonadIO m, IsShader o) => o -> m Bool
getShaderCompiled :: forall (m :: * -> *) o. (MonadIO m, IsShader o) => o -> m Bool
getShaderCompiled o
obj = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj String
"compiled"
#if defined(ENABLE_OVERLOADING)
data ShaderCompiledPropertyInfo
instance AttrInfo ShaderCompiledPropertyInfo where
type AttrAllowedOps ShaderCompiledPropertyInfo = '[ 'AttrGet]
type AttrBaseTypeConstraint ShaderCompiledPropertyInfo = IsShader
type AttrSetTypeConstraint ShaderCompiledPropertyInfo = (~) ()
type AttrTransferTypeConstraint ShaderCompiledPropertyInfo = (~) ()
type AttrTransferType ShaderCompiledPropertyInfo = ()
type AttrGetType ShaderCompiledPropertyInfo = Bool
type AttrLabel ShaderCompiledPropertyInfo = "compiled"
type AttrOrigin ShaderCompiledPropertyInfo = Shader
attrGet = getShaderCompiled
attrSet = undefined
attrTransfer _ = undefined
attrConstruct = undefined
attrClear = undefined
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Objects.Shader.compiled"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Objects-Shader.html#g:attr:compiled"
})
#endif
getShaderEnabled :: (MonadIO m, IsShader o) => o -> m Bool
getShaderEnabled :: forall (m :: * -> *) o. (MonadIO m, IsShader o) => o -> m Bool
getShaderEnabled o
obj = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj String
"enabled"
setShaderEnabled :: (MonadIO m, IsShader o) => o -> Bool -> m ()
setShaderEnabled :: forall (m :: * -> *) o.
(MonadIO m, IsShader o) =>
o -> Bool -> m ()
setShaderEnabled o
obj Bool
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
o -> String -> Bool -> IO ()
forall a. GObject a => a -> String -> Bool -> IO ()
B.Properties.setObjectPropertyBool o
obj String
"enabled" Bool
val
constructShaderEnabled :: (IsShader o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructShaderEnabled :: forall o (m :: * -> *).
(IsShader o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructShaderEnabled Bool
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 -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"enabled" Bool
val
#if defined(ENABLE_OVERLOADING)
data ShaderEnabledPropertyInfo
instance AttrInfo ShaderEnabledPropertyInfo where
type AttrAllowedOps ShaderEnabledPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
type AttrBaseTypeConstraint ShaderEnabledPropertyInfo = IsShader
type AttrSetTypeConstraint ShaderEnabledPropertyInfo = (~) Bool
type AttrTransferTypeConstraint ShaderEnabledPropertyInfo = (~) Bool
type AttrTransferType ShaderEnabledPropertyInfo = Bool
type AttrGetType ShaderEnabledPropertyInfo = Bool
type AttrLabel ShaderEnabledPropertyInfo = "enabled"
type AttrOrigin ShaderEnabledPropertyInfo = Shader
attrGet = getShaderEnabled
attrSet = setShaderEnabled
attrTransfer _ v = do
return v
attrConstruct = constructShaderEnabled
attrClear = undefined
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Objects.Shader.enabled"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Objects-Shader.html#g:attr:enabled"
})
#endif
getShaderFragmentSource :: (MonadIO m, IsShader o) => o -> m T.Text
getShaderFragmentSource :: forall (m :: * -> *) o. (MonadIO m, IsShader o) => o -> m Text
getShaderFragmentSource o
obj = IO Text -> m Text
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ Text -> IO (Maybe Text) -> IO Text
forall a. HasCallStack => Text -> IO (Maybe a) -> IO a
checkUnexpectedNothing Text
"getShaderFragmentSource" (IO (Maybe Text) -> IO Text) -> IO (Maybe Text) -> IO Text
forall a b. (a -> b) -> a -> b
$ o -> String -> IO (Maybe Text)
forall a. GObject a => a -> String -> IO (Maybe Text)
B.Properties.getObjectPropertyString o
obj String
"fragment-source"
setShaderFragmentSource :: (MonadIO m, IsShader o) => o -> T.Text -> m ()
setShaderFragmentSource :: forall (m :: * -> *) o.
(MonadIO m, IsShader o) =>
o -> Text -> m ()
setShaderFragmentSource o
obj Text
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
o -> String -> Maybe Text -> IO ()
forall a. GObject a => a -> String -> Maybe Text -> IO ()
B.Properties.setObjectPropertyString o
obj String
"fragment-source" (Text -> Maybe Text
forall a. a -> Maybe a
Just Text
val)
constructShaderFragmentSource :: (IsShader o, MIO.MonadIO m) => T.Text -> m (GValueConstruct o)
constructShaderFragmentSource :: forall o (m :: * -> *).
(IsShader o, MonadIO m) =>
Text -> m (GValueConstruct o)
constructShaderFragmentSource Text
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 -> Maybe Text -> IO (GValueConstruct o)
forall o. String -> Maybe Text -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyString String
"fragment-source" (Text -> Maybe Text
forall a. a -> Maybe a
P.Just Text
val)
clearShaderFragmentSource :: (MonadIO m, IsShader o) => o -> m ()
clearShaderFragmentSource :: forall (m :: * -> *) o. (MonadIO m, IsShader o) => o -> m ()
clearShaderFragmentSource o
obj = 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
$ o -> String -> Maybe Text -> IO ()
forall a. GObject a => a -> String -> Maybe Text -> IO ()
B.Properties.setObjectPropertyString o
obj String
"fragment-source" (Maybe Text
forall a. Maybe a
Nothing :: Maybe T.Text)
#if defined(ENABLE_OVERLOADING)
data ShaderFragmentSourcePropertyInfo
instance AttrInfo ShaderFragmentSourcePropertyInfo where
type AttrAllowedOps ShaderFragmentSourcePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
type AttrBaseTypeConstraint ShaderFragmentSourcePropertyInfo = IsShader
type AttrSetTypeConstraint ShaderFragmentSourcePropertyInfo = (~) T.Text
type AttrTransferTypeConstraint ShaderFragmentSourcePropertyInfo = (~) T.Text
type AttrTransferType ShaderFragmentSourcePropertyInfo = T.Text
type AttrGetType ShaderFragmentSourcePropertyInfo = T.Text
type AttrLabel ShaderFragmentSourcePropertyInfo = "fragment-source"
type AttrOrigin ShaderFragmentSourcePropertyInfo = Shader
attrGet = getShaderFragmentSource
attrSet = setShaderFragmentSource
attrTransfer _ v = do
return v
attrConstruct = constructShaderFragmentSource
attrClear = clearShaderFragmentSource
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Objects.Shader.fragmentSource"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Objects-Shader.html#g:attr:fragmentSource"
})
#endif
getShaderVertexSource :: (MonadIO m, IsShader o) => o -> m T.Text
getShaderVertexSource :: forall (m :: * -> *) o. (MonadIO m, IsShader o) => o -> m Text
getShaderVertexSource o
obj = IO Text -> m Text
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ Text -> IO (Maybe Text) -> IO Text
forall a. HasCallStack => Text -> IO (Maybe a) -> IO a
checkUnexpectedNothing Text
"getShaderVertexSource" (IO (Maybe Text) -> IO Text) -> IO (Maybe Text) -> IO Text
forall a b. (a -> b) -> a -> b
$ o -> String -> IO (Maybe Text)
forall a. GObject a => a -> String -> IO (Maybe Text)
B.Properties.getObjectPropertyString o
obj String
"vertex-source"
setShaderVertexSource :: (MonadIO m, IsShader o) => o -> T.Text -> m ()
setShaderVertexSource :: forall (m :: * -> *) o.
(MonadIO m, IsShader o) =>
o -> Text -> m ()
setShaderVertexSource o
obj Text
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
o -> String -> Maybe Text -> IO ()
forall a. GObject a => a -> String -> Maybe Text -> IO ()
B.Properties.setObjectPropertyString o
obj String
"vertex-source" (Text -> Maybe Text
forall a. a -> Maybe a
Just Text
val)
constructShaderVertexSource :: (IsShader o, MIO.MonadIO m) => T.Text -> m (GValueConstruct o)
constructShaderVertexSource :: forall o (m :: * -> *).
(IsShader o, MonadIO m) =>
Text -> m (GValueConstruct o)
constructShaderVertexSource Text
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 -> Maybe Text -> IO (GValueConstruct o)
forall o. String -> Maybe Text -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyString String
"vertex-source" (Text -> Maybe Text
forall a. a -> Maybe a
P.Just Text
val)
clearShaderVertexSource :: (MonadIO m, IsShader o) => o -> m ()
clearShaderVertexSource :: forall (m :: * -> *) o. (MonadIO m, IsShader o) => o -> m ()
clearShaderVertexSource o
obj = 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
$ o -> String -> Maybe Text -> IO ()
forall a. GObject a => a -> String -> Maybe Text -> IO ()
B.Properties.setObjectPropertyString o
obj String
"vertex-source" (Maybe Text
forall a. Maybe a
Nothing :: Maybe T.Text)
#if defined(ENABLE_OVERLOADING)
data ShaderVertexSourcePropertyInfo
instance AttrInfo ShaderVertexSourcePropertyInfo where
type AttrAllowedOps ShaderVertexSourcePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
type AttrBaseTypeConstraint ShaderVertexSourcePropertyInfo = IsShader
type AttrSetTypeConstraint ShaderVertexSourcePropertyInfo = (~) T.Text
type AttrTransferTypeConstraint ShaderVertexSourcePropertyInfo = (~) T.Text
type AttrTransferType ShaderVertexSourcePropertyInfo = T.Text
type AttrGetType ShaderVertexSourcePropertyInfo = T.Text
type AttrLabel ShaderVertexSourcePropertyInfo = "vertex-source"
type AttrOrigin ShaderVertexSourcePropertyInfo = Shader
attrGet = getShaderVertexSource
attrSet = setShaderVertexSource
attrTransfer _ v = do
return v
attrConstruct = constructShaderVertexSource
attrClear = clearShaderVertexSource
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Objects.Shader.vertexSource"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Objects-Shader.html#g:attr:vertexSource"
})
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Shader
type instance O.AttributeList Shader = ShaderAttributeList
type ShaderAttributeList = ('[ '("compiled", ShaderCompiledPropertyInfo), '("enabled", ShaderEnabledPropertyInfo), '("fragmentSource", ShaderFragmentSourcePropertyInfo), '("vertexSource", ShaderVertexSourcePropertyInfo)] :: [(Symbol, *)])
#endif
#if defined(ENABLE_OVERLOADING)
shaderCompiled :: AttrLabelProxy "compiled"
shaderCompiled = AttrLabelProxy
shaderEnabled :: AttrLabelProxy "enabled"
shaderEnabled = AttrLabelProxy
shaderFragmentSource :: AttrLabelProxy "fragmentSource"
shaderFragmentSource = AttrLabelProxy
shaderVertexSource :: AttrLabelProxy "vertexSource"
shaderVertexSource = AttrLabelProxy
#endif
#if defined(ENABLE_OVERLOADING)
type instance O.SignalList Shader = ShaderSignalList
type ShaderSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])
#endif
foreign import ccall "clutter_shader_new" clutter_shader_new ::
IO (Ptr Shader)
{-# DEPRECATED shaderNew ["(Since version 1.8)","Use t'GI.Clutter.Objects.ShaderEffect.ShaderEffect' instead."] #-}
shaderNew ::
(B.CallStack.HasCallStack, MonadIO m) =>
m Shader
shaderNew :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m Shader
shaderNew = IO Shader -> m Shader
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Shader -> m Shader) -> IO Shader -> m Shader
forall a b. (a -> b) -> a -> b
$ do
Ptr Shader
result <- IO (Ptr Shader)
clutter_shader_new
Text -> Ptr Shader -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"shaderNew" Ptr Shader
result
Shader
result' <- ((ManagedPtr Shader -> Shader) -> Ptr Shader -> IO Shader
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Shader -> Shader
Shader) Ptr Shader
result
Shader -> IO Shader
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Shader
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "clutter_shader_compile" clutter_shader_compile ::
Ptr Shader ->
Ptr (Ptr GError) ->
IO CInt
{-# DEPRECATED shaderCompile ["(Since version 1.8)","Use t'GI.Clutter.Objects.ShaderEffect.ShaderEffect' instead."] #-}
shaderCompile ::
(B.CallStack.HasCallStack, MonadIO m, IsShader a) =>
a
-> m ()
shaderCompile :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsShader a) =>
a -> m ()
shaderCompile a
shader = 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 Shader
shader' <- a -> IO (Ptr Shader)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
shader
IO () -> IO () -> IO ()
forall a b. IO a -> IO b -> IO a
onException (do
CInt
_ <- (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO CInt) -> IO CInt)
-> (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ Ptr Shader -> Ptr (Ptr GError) -> IO CInt
clutter_shader_compile Ptr Shader
shader'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
shader
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
) (do
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
)
#if defined(ENABLE_OVERLOADING)
data ShaderCompileMethodInfo
instance (signature ~ (m ()), MonadIO m, IsShader a) => O.OverloadedMethod ShaderCompileMethodInfo a signature where
overloadedMethod = shaderCompile
instance O.OverloadedMethodInfo ShaderCompileMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Objects.Shader.shaderCompile",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Objects-Shader.html#v:shaderCompile"
})
#endif
foreign import ccall "clutter_shader_get_cogl_fragment_shader" clutter_shader_get_cogl_fragment_shader ::
Ptr Shader ->
IO (Ptr ())
{-# DEPRECATED shaderGetCoglFragmentShader ["(Since version 1.8)","Use t'GI.Clutter.Objects.ShaderEffect.ShaderEffect' instead."] #-}
shaderGetCoglFragmentShader ::
(B.CallStack.HasCallStack, MonadIO m, IsShader a) =>
a
-> m (Ptr ())
shaderGetCoglFragmentShader :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsShader a) =>
a -> m (Ptr ())
shaderGetCoglFragmentShader a
shader = 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 Shader
shader' <- a -> IO (Ptr Shader)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
shader
Ptr ()
result <- Ptr Shader -> IO (Ptr ())
clutter_shader_get_cogl_fragment_shader Ptr Shader
shader'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
shader
Ptr () -> IO (Ptr ())
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr ()
result
#if defined(ENABLE_OVERLOADING)
data ShaderGetCoglFragmentShaderMethodInfo
instance (signature ~ (m (Ptr ())), MonadIO m, IsShader a) => O.OverloadedMethod ShaderGetCoglFragmentShaderMethodInfo a signature where
overloadedMethod = shaderGetCoglFragmentShader
instance O.OverloadedMethodInfo ShaderGetCoglFragmentShaderMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Objects.Shader.shaderGetCoglFragmentShader",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Objects-Shader.html#v:shaderGetCoglFragmentShader"
})
#endif
foreign import ccall "clutter_shader_get_cogl_program" clutter_shader_get_cogl_program ::
Ptr Shader ->
IO (Ptr ())
{-# DEPRECATED shaderGetCoglProgram ["(Since version 1.8)","Use t'GI.Clutter.Objects.ShaderEffect.ShaderEffect' instead."] #-}
shaderGetCoglProgram ::
(B.CallStack.HasCallStack, MonadIO m, IsShader a) =>
a
-> m (Ptr ())
shaderGetCoglProgram :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsShader a) =>
a -> m (Ptr ())
shaderGetCoglProgram a
shader = 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 Shader
shader' <- a -> IO (Ptr Shader)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
shader
Ptr ()
result <- Ptr Shader -> IO (Ptr ())
clutter_shader_get_cogl_program Ptr Shader
shader'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
shader
Ptr () -> IO (Ptr ())
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr ()
result
#if defined(ENABLE_OVERLOADING)
data ShaderGetCoglProgramMethodInfo
instance (signature ~ (m (Ptr ())), MonadIO m, IsShader a) => O.OverloadedMethod ShaderGetCoglProgramMethodInfo a signature where
overloadedMethod = shaderGetCoglProgram
instance O.OverloadedMethodInfo ShaderGetCoglProgramMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Objects.Shader.shaderGetCoglProgram",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Objects-Shader.html#v:shaderGetCoglProgram"
})
#endif
foreign import ccall "clutter_shader_get_cogl_vertex_shader" clutter_shader_get_cogl_vertex_shader ::
Ptr Shader ->
IO (Ptr ())
{-# DEPRECATED shaderGetCoglVertexShader ["(Since version 1.8)","Use t'GI.Clutter.Objects.ShaderEffect.ShaderEffect' instead."] #-}
shaderGetCoglVertexShader ::
(B.CallStack.HasCallStack, MonadIO m, IsShader a) =>
a
-> m (Ptr ())
shaderGetCoglVertexShader :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsShader a) =>
a -> m (Ptr ())
shaderGetCoglVertexShader a
shader = 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 Shader
shader' <- a -> IO (Ptr Shader)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
shader
Ptr ()
result <- Ptr Shader -> IO (Ptr ())
clutter_shader_get_cogl_vertex_shader Ptr Shader
shader'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
shader
Ptr () -> IO (Ptr ())
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr ()
result
#if defined(ENABLE_OVERLOADING)
data ShaderGetCoglVertexShaderMethodInfo
instance (signature ~ (m (Ptr ())), MonadIO m, IsShader a) => O.OverloadedMethod ShaderGetCoglVertexShaderMethodInfo a signature where
overloadedMethod = shaderGetCoglVertexShader
instance O.OverloadedMethodInfo ShaderGetCoglVertexShaderMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Objects.Shader.shaderGetCoglVertexShader",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Objects-Shader.html#v:shaderGetCoglVertexShader"
})
#endif
foreign import ccall "clutter_shader_get_fragment_source" clutter_shader_get_fragment_source ::
Ptr Shader ->
IO CString
{-# DEPRECATED shaderGetFragmentSource ["(Since version 1.8)","Use t'GI.Clutter.Objects.ShaderEffect.ShaderEffect' instead."] #-}
shaderGetFragmentSource ::
(B.CallStack.HasCallStack, MonadIO m, IsShader a) =>
a
-> m T.Text
shaderGetFragmentSource :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsShader a) =>
a -> m Text
shaderGetFragmentSource a
shader = IO Text -> m Text
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
Ptr Shader
shader' <- a -> IO (Ptr Shader)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
shader
CString
result <- Ptr Shader -> IO CString
clutter_shader_get_fragment_source Ptr Shader
shader'
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"shaderGetFragmentSource" CString
result
Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
shader
Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
#if defined(ENABLE_OVERLOADING)
data ShaderGetFragmentSourceMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsShader a) => O.OverloadedMethod ShaderGetFragmentSourceMethodInfo a signature where
overloadedMethod = shaderGetFragmentSource
instance O.OverloadedMethodInfo ShaderGetFragmentSourceMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Objects.Shader.shaderGetFragmentSource",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Objects-Shader.html#v:shaderGetFragmentSource"
})
#endif
foreign import ccall "clutter_shader_get_is_enabled" clutter_shader_get_is_enabled ::
Ptr Shader ->
IO CInt
{-# DEPRECATED shaderGetIsEnabled ["(Since version 1.8)","Use t'GI.Clutter.Objects.ShaderEffect.ShaderEffect' instead."] #-}
shaderGetIsEnabled ::
(B.CallStack.HasCallStack, MonadIO m, IsShader a) =>
a
-> m Bool
shaderGetIsEnabled :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsShader a) =>
a -> m Bool
shaderGetIsEnabled a
shader = 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 Shader
shader' <- a -> IO (Ptr Shader)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
shader
CInt
result <- Ptr Shader -> IO CInt
clutter_shader_get_is_enabled Ptr Shader
shader'
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
shader
Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data ShaderGetIsEnabledMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsShader a) => O.OverloadedMethod ShaderGetIsEnabledMethodInfo a signature where
overloadedMethod = shaderGetIsEnabled
instance O.OverloadedMethodInfo ShaderGetIsEnabledMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Objects.Shader.shaderGetIsEnabled",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Objects-Shader.html#v:shaderGetIsEnabled"
})
#endif
foreign import ccall "clutter_shader_get_vertex_source" clutter_shader_get_vertex_source ::
Ptr Shader ->
IO CString
{-# DEPRECATED shaderGetVertexSource ["(Since version 1.8)","Use t'GI.Clutter.Objects.ShaderEffect.ShaderEffect' instead."] #-}
shaderGetVertexSource ::
(B.CallStack.HasCallStack, MonadIO m, IsShader a) =>
a
-> m T.Text
shaderGetVertexSource :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsShader a) =>
a -> m Text
shaderGetVertexSource a
shader = IO Text -> m Text
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
Ptr Shader
shader' <- a -> IO (Ptr Shader)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
shader
CString
result <- Ptr Shader -> IO CString
clutter_shader_get_vertex_source Ptr Shader
shader'
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"shaderGetVertexSource" CString
result
Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
shader
Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
#if defined(ENABLE_OVERLOADING)
data ShaderGetVertexSourceMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsShader a) => O.OverloadedMethod ShaderGetVertexSourceMethodInfo a signature where
overloadedMethod = shaderGetVertexSource
instance O.OverloadedMethodInfo ShaderGetVertexSourceMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Objects.Shader.shaderGetVertexSource",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Objects-Shader.html#v:shaderGetVertexSource"
})
#endif
foreign import ccall "clutter_shader_is_compiled" clutter_shader_is_compiled ::
Ptr Shader ->
IO CInt
{-# DEPRECATED shaderIsCompiled ["(Since version 1.8)","Use t'GI.Clutter.Objects.ShaderEffect.ShaderEffect' instead."] #-}
shaderIsCompiled ::
(B.CallStack.HasCallStack, MonadIO m, IsShader a) =>
a
-> m Bool
shaderIsCompiled :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsShader a) =>
a -> m Bool
shaderIsCompiled a
shader = 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 Shader
shader' <- a -> IO (Ptr Shader)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
shader
CInt
result <- Ptr Shader -> IO CInt
clutter_shader_is_compiled Ptr Shader
shader'
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
shader
Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data ShaderIsCompiledMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsShader a) => O.OverloadedMethod ShaderIsCompiledMethodInfo a signature where
overloadedMethod = shaderIsCompiled
instance O.OverloadedMethodInfo ShaderIsCompiledMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Objects.Shader.shaderIsCompiled",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Objects-Shader.html#v:shaderIsCompiled"
})
#endif
foreign import ccall "clutter_shader_release" clutter_shader_release ::
Ptr Shader ->
IO ()
{-# DEPRECATED shaderRelease ["(Since version 1.8)","Use t'GI.Clutter.Objects.ShaderEffect.ShaderEffect' instead."] #-}
shaderRelease ::
(B.CallStack.HasCallStack, MonadIO m, IsShader a) =>
a
-> m ()
shaderRelease :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsShader a) =>
a -> m ()
shaderRelease a
shader = 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 Shader
shader' <- a -> IO (Ptr Shader)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
shader
Ptr Shader -> IO ()
clutter_shader_release Ptr Shader
shader'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
shader
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data ShaderReleaseMethodInfo
instance (signature ~ (m ()), MonadIO m, IsShader a) => O.OverloadedMethod ShaderReleaseMethodInfo a signature where
overloadedMethod = shaderRelease
instance O.OverloadedMethodInfo ShaderReleaseMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Objects.Shader.shaderRelease",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Objects-Shader.html#v:shaderRelease"
})
#endif
foreign import ccall "clutter_shader_set_fragment_source" clutter_shader_set_fragment_source ::
Ptr Shader ->
CString ->
Int64 ->
IO ()
{-# DEPRECATED shaderSetFragmentSource ["(Since version 1.8)","Use t'GI.Clutter.Objects.ShaderEffect.ShaderEffect' instead."] #-}
shaderSetFragmentSource ::
(B.CallStack.HasCallStack, MonadIO m, IsShader a) =>
a
-> T.Text
-> Int64
-> m ()
shaderSetFragmentSource :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsShader a) =>
a -> Text -> Int64 -> m ()
shaderSetFragmentSource a
shader Text
data_ Int64
length_ = 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 Shader
shader' <- a -> IO (Ptr Shader)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
shader
CString
data_' <- Text -> IO CString
textToCString Text
data_
Ptr Shader -> CString -> Int64 -> IO ()
clutter_shader_set_fragment_source Ptr Shader
shader' CString
data_' Int64
length_
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
shader
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
data_'
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data ShaderSetFragmentSourceMethodInfo
instance (signature ~ (T.Text -> Int64 -> m ()), MonadIO m, IsShader a) => O.OverloadedMethod ShaderSetFragmentSourceMethodInfo a signature where
overloadedMethod = shaderSetFragmentSource
instance O.OverloadedMethodInfo ShaderSetFragmentSourceMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Objects.Shader.shaderSetFragmentSource",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Objects-Shader.html#v:shaderSetFragmentSource"
})
#endif
foreign import ccall "clutter_shader_set_is_enabled" clutter_shader_set_is_enabled ::
Ptr Shader ->
CInt ->
IO ()
{-# DEPRECATED shaderSetIsEnabled ["(Since version 1.8)","Use t'GI.Clutter.Objects.ShaderEffect.ShaderEffect' instead."] #-}
shaderSetIsEnabled ::
(B.CallStack.HasCallStack, MonadIO m, IsShader a) =>
a
-> Bool
-> m ()
shaderSetIsEnabled :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsShader a) =>
a -> Bool -> m ()
shaderSetIsEnabled a
shader Bool
enabled = 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 Shader
shader' <- a -> IO (Ptr Shader)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
shader
let enabled' :: CInt
enabled' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
enabled
Ptr Shader -> CInt -> IO ()
clutter_shader_set_is_enabled Ptr Shader
shader' CInt
enabled'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
shader
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data ShaderSetIsEnabledMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsShader a) => O.OverloadedMethod ShaderSetIsEnabledMethodInfo a signature where
overloadedMethod = shaderSetIsEnabled
instance O.OverloadedMethodInfo ShaderSetIsEnabledMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Objects.Shader.shaderSetIsEnabled",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Objects-Shader.html#v:shaderSetIsEnabled"
})
#endif
foreign import ccall "clutter_shader_set_uniform" clutter_shader_set_uniform ::
Ptr Shader ->
CString ->
Ptr GValue ->
IO ()
{-# DEPRECATED shaderSetUniform ["(Since version 1.8)","Use t'GI.Clutter.Objects.ShaderEffect.ShaderEffect' instead."] #-}
shaderSetUniform ::
(B.CallStack.HasCallStack, MonadIO m, IsShader a) =>
a
-> T.Text
-> GValue
-> m ()
shaderSetUniform :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsShader a) =>
a -> Text -> GValue -> m ()
shaderSetUniform a
shader 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 Shader
shader' <- a -> IO (Ptr Shader)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
shader
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 Shader -> CString -> Ptr GValue -> IO ()
clutter_shader_set_uniform Ptr Shader
shader' CString
name' Ptr GValue
value'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
shader
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 ShaderSetUniformMethodInfo
instance (signature ~ (T.Text -> GValue -> m ()), MonadIO m, IsShader a) => O.OverloadedMethod ShaderSetUniformMethodInfo a signature where
overloadedMethod = shaderSetUniform
instance O.OverloadedMethodInfo ShaderSetUniformMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Objects.Shader.shaderSetUniform",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Objects-Shader.html#v:shaderSetUniform"
})
#endif
foreign import ccall "clutter_shader_set_vertex_source" clutter_shader_set_vertex_source ::
Ptr Shader ->
CString ->
Int64 ->
IO ()
{-# DEPRECATED shaderSetVertexSource ["(Since version 1.8)","Use t'GI.Clutter.Objects.ShaderEffect.ShaderEffect' instead."] #-}
shaderSetVertexSource ::
(B.CallStack.HasCallStack, MonadIO m, IsShader a) =>
a
-> T.Text
-> Int64
-> m ()
shaderSetVertexSource :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsShader a) =>
a -> Text -> Int64 -> m ()
shaderSetVertexSource a
shader Text
data_ Int64
length_ = 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 Shader
shader' <- a -> IO (Ptr Shader)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
shader
CString
data_' <- Text -> IO CString
textToCString Text
data_
Ptr Shader -> CString -> Int64 -> IO ()
clutter_shader_set_vertex_source Ptr Shader
shader' CString
data_' Int64
length_
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
shader
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
data_'
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data ShaderSetVertexSourceMethodInfo
instance (signature ~ (T.Text -> Int64 -> m ()), MonadIO m, IsShader a) => O.OverloadedMethod ShaderSetVertexSourceMethodInfo a signature where
overloadedMethod = shaderSetVertexSource
instance O.OverloadedMethodInfo ShaderSetVertexSourceMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Objects.Shader.shaderSetVertexSource",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Objects-Shader.html#v:shaderSetVertexSource"
})
#endif