{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Graphene.Structs.Euler
(
Euler(..) ,
newZeroEuler ,
#if defined(ENABLE_OVERLOADING)
ResolveEulerMethod ,
#endif
eulerAlloc ,
#if defined(ENABLE_OVERLOADING)
EulerEqualMethodInfo ,
#endif
eulerEqual ,
#if defined(ENABLE_OVERLOADING)
EulerFreeMethodInfo ,
#endif
eulerFree ,
#if defined(ENABLE_OVERLOADING)
EulerGetAlphaMethodInfo ,
#endif
eulerGetAlpha ,
#if defined(ENABLE_OVERLOADING)
EulerGetBetaMethodInfo ,
#endif
eulerGetBeta ,
#if defined(ENABLE_OVERLOADING)
EulerGetGammaMethodInfo ,
#endif
eulerGetGamma ,
#if defined(ENABLE_OVERLOADING)
EulerGetOrderMethodInfo ,
#endif
eulerGetOrder ,
#if defined(ENABLE_OVERLOADING)
EulerGetXMethodInfo ,
#endif
eulerGetX ,
#if defined(ENABLE_OVERLOADING)
EulerGetYMethodInfo ,
#endif
eulerGetY ,
#if defined(ENABLE_OVERLOADING)
EulerGetZMethodInfo ,
#endif
eulerGetZ ,
#if defined(ENABLE_OVERLOADING)
EulerInitMethodInfo ,
#endif
eulerInit ,
#if defined(ENABLE_OVERLOADING)
EulerInitFromEulerMethodInfo ,
#endif
eulerInitFromEuler ,
#if defined(ENABLE_OVERLOADING)
EulerInitFromMatrixMethodInfo ,
#endif
eulerInitFromMatrix ,
#if defined(ENABLE_OVERLOADING)
EulerInitFromQuaternionMethodInfo ,
#endif
eulerInitFromQuaternion ,
#if defined(ENABLE_OVERLOADING)
EulerInitFromRadiansMethodInfo ,
#endif
eulerInitFromRadians ,
#if defined(ENABLE_OVERLOADING)
EulerInitFromVec3MethodInfo ,
#endif
eulerInitFromVec3 ,
#if defined(ENABLE_OVERLOADING)
EulerInitWithOrderMethodInfo ,
#endif
eulerInitWithOrder ,
#if defined(ENABLE_OVERLOADING)
EulerReorderMethodInfo ,
#endif
eulerReorder ,
#if defined(ENABLE_OVERLOADING)
EulerToMatrixMethodInfo ,
#endif
eulerToMatrix ,
#if defined(ENABLE_OVERLOADING)
EulerToQuaternionMethodInfo ,
#endif
eulerToQuaternion ,
#if defined(ENABLE_OVERLOADING)
EulerToVec3MethodInfo ,
#endif
eulerToVec3 ,
) 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.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.Graphene.Enums as Graphene.Enums
import {-# SOURCE #-} qualified GI.Graphene.Structs.Matrix as Graphene.Matrix
import {-# SOURCE #-} qualified GI.Graphene.Structs.Quaternion as Graphene.Quaternion
import {-# SOURCE #-} qualified GI.Graphene.Structs.Vec3 as Graphene.Vec3
newtype Euler = Euler (SP.ManagedPtr Euler)
deriving (Euler -> Euler -> Bool
(Euler -> Euler -> Bool) -> (Euler -> Euler -> Bool) -> Eq Euler
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Euler -> Euler -> Bool
$c/= :: Euler -> Euler -> Bool
== :: Euler -> Euler -> Bool
$c== :: Euler -> Euler -> Bool
Eq)
instance SP.ManagedPtrNewtype Euler where
toManagedPtr :: Euler -> ManagedPtr Euler
toManagedPtr (Euler ManagedPtr Euler
p) = ManagedPtr Euler
p
foreign import ccall "graphene_euler_get_type" c_graphene_euler_get_type ::
IO GType
type instance O.ParentTypes Euler = '[]
instance O.HasParentTypes Euler
instance B.Types.TypedObject Euler where
glibType :: IO GType
glibType = IO GType
c_graphene_euler_get_type
instance B.Types.GBoxed Euler
instance B.GValue.IsGValue (Maybe Euler) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_graphene_euler_get_type
gvalueSet_ :: Ptr GValue -> Maybe Euler -> IO ()
gvalueSet_ Ptr GValue
gv Maybe Euler
P.Nothing = Ptr GValue -> Ptr Euler -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv (Ptr Euler
forall a. Ptr a
FP.nullPtr :: FP.Ptr Euler)
gvalueSet_ Ptr GValue
gv (P.Just Euler
obj) = Euler -> (Ptr Euler -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr Euler
obj (Ptr GValue -> Ptr Euler -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe Euler)
gvalueGet_ Ptr GValue
gv = do
Ptr Euler
ptr <- Ptr GValue -> IO (Ptr Euler)
forall b. Ptr GValue -> IO (Ptr b)
B.GValue.get_boxed Ptr GValue
gv :: IO (Ptr Euler)
if Ptr Euler
ptr Ptr Euler -> Ptr Euler -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr Euler
forall a. Ptr a
FP.nullPtr
then Euler -> Maybe Euler
forall a. a -> Maybe a
P.Just (Euler -> Maybe Euler) -> IO Euler -> IO (Maybe Euler)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr Euler -> Euler) -> Ptr Euler -> IO Euler
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.newBoxed ManagedPtr Euler -> Euler
Euler Ptr Euler
ptr
else Maybe Euler -> IO (Maybe Euler)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Euler
forall a. Maybe a
P.Nothing
newZeroEuler :: MonadIO m => m Euler
newZeroEuler :: forall (m :: * -> *). MonadIO m => m Euler
newZeroEuler = IO Euler -> m Euler
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Euler -> m Euler) -> IO Euler -> m Euler
forall a b. (a -> b) -> a -> b
$ Int -> IO (Ptr Euler)
forall a. GBoxed a => Int -> IO (Ptr a)
callocBoxedBytes Int
20 IO (Ptr Euler) -> (Ptr Euler -> IO Euler) -> IO Euler
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (ManagedPtr Euler -> Euler) -> Ptr Euler -> IO Euler
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Euler -> Euler
Euler
instance tag ~ 'AttrSet => Constructible Euler tag where
new :: forall (m :: * -> *).
MonadIO m =>
(ManagedPtr Euler -> Euler) -> [AttrOp Euler tag] -> m Euler
new ManagedPtr Euler -> Euler
_ [AttrOp Euler tag]
attrs = do
Euler
o <- m Euler
forall (m :: * -> *). MonadIO m => m Euler
newZeroEuler
Euler -> [AttrOp Euler 'AttrSet] -> m ()
forall o (m :: * -> *).
MonadIO m =>
o -> [AttrOp o 'AttrSet] -> m ()
GI.Attributes.set Euler
o [AttrOp Euler tag]
[AttrOp Euler 'AttrSet]
attrs
Euler -> m Euler
forall (m :: * -> *) a. Monad m => a -> m a
return Euler
o
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Euler
type instance O.AttributeList Euler = EulerAttributeList
type EulerAttributeList = ('[ ] :: [(Symbol, *)])
#endif
foreign import ccall "graphene_euler_alloc" graphene_euler_alloc ::
IO (Ptr Euler)
eulerAlloc ::
(B.CallStack.HasCallStack, MonadIO m) =>
m Euler
eulerAlloc :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m Euler
eulerAlloc = IO Euler -> m Euler
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Euler -> m Euler) -> IO Euler -> m Euler
forall a b. (a -> b) -> a -> b
$ do
Ptr Euler
result <- IO (Ptr Euler)
graphene_euler_alloc
Text -> Ptr Euler -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"eulerAlloc" Ptr Euler
result
Euler
result' <- ((ManagedPtr Euler -> Euler) -> Ptr Euler -> IO Euler
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Euler -> Euler
Euler) Ptr Euler
result
Euler -> IO Euler
forall (m :: * -> *) a. Monad m => a -> m a
return Euler
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "graphene_euler_equal" graphene_euler_equal ::
Ptr Euler ->
Ptr Euler ->
IO CInt
eulerEqual ::
(B.CallStack.HasCallStack, MonadIO m) =>
Euler
-> Euler
-> m Bool
eulerEqual :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Euler -> Euler -> m Bool
eulerEqual Euler
a Euler
b = IO Bool -> m Bool
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 Euler
a' <- Euler -> IO (Ptr Euler)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Euler
a
Ptr Euler
b' <- Euler -> IO (Ptr Euler)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Euler
b
CInt
result <- Ptr Euler -> Ptr Euler -> IO CInt
graphene_euler_equal Ptr Euler
a' Ptr Euler
b'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
Euler -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Euler
a
Euler -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Euler
b
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data EulerEqualMethodInfo
instance (signature ~ (Euler -> m Bool), MonadIO m) => O.OverloadedMethod EulerEqualMethodInfo Euler signature where
overloadedMethod = eulerEqual
instance O.OverloadedMethodInfo EulerEqualMethodInfo Euler where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Graphene.Structs.Euler.eulerEqual",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-graphene-1.0.4/docs/GI-Graphene-Structs-Euler.html#v:eulerEqual"
})
#endif
foreign import ccall "graphene_euler_free" graphene_euler_free ::
Ptr Euler ->
IO ()
eulerFree ::
(B.CallStack.HasCallStack, MonadIO m) =>
Euler
-> m ()
eulerFree :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Euler -> m ()
eulerFree Euler
e = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Euler
e' <- Euler -> IO (Ptr Euler)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Euler
e
Ptr Euler -> IO ()
graphene_euler_free Ptr Euler
e'
Euler -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Euler
e
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data EulerFreeMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod EulerFreeMethodInfo Euler signature where
overloadedMethod = eulerFree
instance O.OverloadedMethodInfo EulerFreeMethodInfo Euler where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Graphene.Structs.Euler.eulerFree",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-graphene-1.0.4/docs/GI-Graphene-Structs-Euler.html#v:eulerFree"
})
#endif
foreign import ccall "graphene_euler_get_alpha" graphene_euler_get_alpha ::
Ptr Euler ->
IO CFloat
eulerGetAlpha ::
(B.CallStack.HasCallStack, MonadIO m) =>
Euler
-> m Float
eulerGetAlpha :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Euler -> m Float
eulerGetAlpha Euler
e = IO Float -> m Float
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 Euler
e' <- Euler -> IO (Ptr Euler)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Euler
e
CFloat
result <- Ptr Euler -> IO CFloat
graphene_euler_get_alpha Ptr Euler
e'
let result' :: Float
result' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
result
Euler -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Euler
e
Float -> IO Float
forall (m :: * -> *) a. Monad m => a -> m a
return Float
result'
#if defined(ENABLE_OVERLOADING)
data EulerGetAlphaMethodInfo
instance (signature ~ (m Float), MonadIO m) => O.OverloadedMethod EulerGetAlphaMethodInfo Euler signature where
overloadedMethod = eulerGetAlpha
instance O.OverloadedMethodInfo EulerGetAlphaMethodInfo Euler where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Graphene.Structs.Euler.eulerGetAlpha",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-graphene-1.0.4/docs/GI-Graphene-Structs-Euler.html#v:eulerGetAlpha"
})
#endif
foreign import ccall "graphene_euler_get_beta" graphene_euler_get_beta ::
Ptr Euler ->
IO CFloat
eulerGetBeta ::
(B.CallStack.HasCallStack, MonadIO m) =>
Euler
-> m Float
eulerGetBeta :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Euler -> m Float
eulerGetBeta Euler
e = IO Float -> m Float
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 Euler
e' <- Euler -> IO (Ptr Euler)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Euler
e
CFloat
result <- Ptr Euler -> IO CFloat
graphene_euler_get_beta Ptr Euler
e'
let result' :: Float
result' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
result
Euler -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Euler
e
Float -> IO Float
forall (m :: * -> *) a. Monad m => a -> m a
return Float
result'
#if defined(ENABLE_OVERLOADING)
data EulerGetBetaMethodInfo
instance (signature ~ (m Float), MonadIO m) => O.OverloadedMethod EulerGetBetaMethodInfo Euler signature where
overloadedMethod = eulerGetBeta
instance O.OverloadedMethodInfo EulerGetBetaMethodInfo Euler where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Graphene.Structs.Euler.eulerGetBeta",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-graphene-1.0.4/docs/GI-Graphene-Structs-Euler.html#v:eulerGetBeta"
})
#endif
foreign import ccall "graphene_euler_get_gamma" graphene_euler_get_gamma ::
Ptr Euler ->
IO CFloat
eulerGetGamma ::
(B.CallStack.HasCallStack, MonadIO m) =>
Euler
-> m Float
eulerGetGamma :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Euler -> m Float
eulerGetGamma Euler
e = IO Float -> m Float
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 Euler
e' <- Euler -> IO (Ptr Euler)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Euler
e
CFloat
result <- Ptr Euler -> IO CFloat
graphene_euler_get_gamma Ptr Euler
e'
let result' :: Float
result' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
result
Euler -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Euler
e
Float -> IO Float
forall (m :: * -> *) a. Monad m => a -> m a
return Float
result'
#if defined(ENABLE_OVERLOADING)
data EulerGetGammaMethodInfo
instance (signature ~ (m Float), MonadIO m) => O.OverloadedMethod EulerGetGammaMethodInfo Euler signature where
overloadedMethod = eulerGetGamma
instance O.OverloadedMethodInfo EulerGetGammaMethodInfo Euler where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Graphene.Structs.Euler.eulerGetGamma",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-graphene-1.0.4/docs/GI-Graphene-Structs-Euler.html#v:eulerGetGamma"
})
#endif
foreign import ccall "graphene_euler_get_order" graphene_euler_get_order ::
Ptr Euler ->
IO CInt
eulerGetOrder ::
(B.CallStack.HasCallStack, MonadIO m) =>
Euler
-> m Graphene.Enums.EulerOrder
eulerGetOrder :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Euler -> m EulerOrder
eulerGetOrder Euler
e = IO EulerOrder -> m EulerOrder
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO EulerOrder -> m EulerOrder) -> IO EulerOrder -> m EulerOrder
forall a b. (a -> b) -> a -> b
$ do
Ptr Euler
e' <- Euler -> IO (Ptr Euler)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Euler
e
CInt
result <- Ptr Euler -> IO CInt
graphene_euler_get_order Ptr Euler
e'
let result' :: EulerOrder
result' = (Int -> EulerOrder
forall a. Enum a => Int -> a
toEnum (Int -> EulerOrder) -> (CInt -> Int) -> CInt -> EulerOrder
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CInt
result
Euler -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Euler
e
EulerOrder -> IO EulerOrder
forall (m :: * -> *) a. Monad m => a -> m a
return EulerOrder
result'
#if defined(ENABLE_OVERLOADING)
data EulerGetOrderMethodInfo
instance (signature ~ (m Graphene.Enums.EulerOrder), MonadIO m) => O.OverloadedMethod EulerGetOrderMethodInfo Euler signature where
overloadedMethod = eulerGetOrder
instance O.OverloadedMethodInfo EulerGetOrderMethodInfo Euler where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Graphene.Structs.Euler.eulerGetOrder",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-graphene-1.0.4/docs/GI-Graphene-Structs-Euler.html#v:eulerGetOrder"
})
#endif
foreign import ccall "graphene_euler_get_x" graphene_euler_get_x ::
Ptr Euler ->
IO CFloat
eulerGetX ::
(B.CallStack.HasCallStack, MonadIO m) =>
Euler
-> m Float
eulerGetX :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Euler -> m Float
eulerGetX Euler
e = IO Float -> m Float
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 Euler
e' <- Euler -> IO (Ptr Euler)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Euler
e
CFloat
result <- Ptr Euler -> IO CFloat
graphene_euler_get_x Ptr Euler
e'
let result' :: Float
result' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
result
Euler -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Euler
e
Float -> IO Float
forall (m :: * -> *) a. Monad m => a -> m a
return Float
result'
#if defined(ENABLE_OVERLOADING)
data EulerGetXMethodInfo
instance (signature ~ (m Float), MonadIO m) => O.OverloadedMethod EulerGetXMethodInfo Euler signature where
overloadedMethod = eulerGetX
instance O.OverloadedMethodInfo EulerGetXMethodInfo Euler where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Graphene.Structs.Euler.eulerGetX",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-graphene-1.0.4/docs/GI-Graphene-Structs-Euler.html#v:eulerGetX"
})
#endif
foreign import ccall "graphene_euler_get_y" graphene_euler_get_y ::
Ptr Euler ->
IO CFloat
eulerGetY ::
(B.CallStack.HasCallStack, MonadIO m) =>
Euler
-> m Float
eulerGetY :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Euler -> m Float
eulerGetY Euler
e = IO Float -> m Float
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 Euler
e' <- Euler -> IO (Ptr Euler)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Euler
e
CFloat
result <- Ptr Euler -> IO CFloat
graphene_euler_get_y Ptr Euler
e'
let result' :: Float
result' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
result
Euler -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Euler
e
Float -> IO Float
forall (m :: * -> *) a. Monad m => a -> m a
return Float
result'
#if defined(ENABLE_OVERLOADING)
data EulerGetYMethodInfo
instance (signature ~ (m Float), MonadIO m) => O.OverloadedMethod EulerGetYMethodInfo Euler signature where
overloadedMethod = eulerGetY
instance O.OverloadedMethodInfo EulerGetYMethodInfo Euler where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Graphene.Structs.Euler.eulerGetY",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-graphene-1.0.4/docs/GI-Graphene-Structs-Euler.html#v:eulerGetY"
})
#endif
foreign import ccall "graphene_euler_get_z" graphene_euler_get_z ::
Ptr Euler ->
IO CFloat
eulerGetZ ::
(B.CallStack.HasCallStack, MonadIO m) =>
Euler
-> m Float
eulerGetZ :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Euler -> m Float
eulerGetZ Euler
e = IO Float -> m Float
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 Euler
e' <- Euler -> IO (Ptr Euler)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Euler
e
CFloat
result <- Ptr Euler -> IO CFloat
graphene_euler_get_z Ptr Euler
e'
let result' :: Float
result' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
result
Euler -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Euler
e
Float -> IO Float
forall (m :: * -> *) a. Monad m => a -> m a
return Float
result'
#if defined(ENABLE_OVERLOADING)
data EulerGetZMethodInfo
instance (signature ~ (m Float), MonadIO m) => O.OverloadedMethod EulerGetZMethodInfo Euler signature where
overloadedMethod = eulerGetZ
instance O.OverloadedMethodInfo EulerGetZMethodInfo Euler where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Graphene.Structs.Euler.eulerGetZ",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-graphene-1.0.4/docs/GI-Graphene-Structs-Euler.html#v:eulerGetZ"
})
#endif
foreign import ccall "graphene_euler_init" graphene_euler_init ::
Ptr Euler ->
CFloat ->
CFloat ->
CFloat ->
IO (Ptr Euler)
eulerInit ::
(B.CallStack.HasCallStack, MonadIO m) =>
Euler
-> Float
-> Float
-> Float
-> m Euler
eulerInit :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Euler -> Float -> Float -> Float -> m Euler
eulerInit Euler
e Float
x Float
y Float
z = IO Euler -> m Euler
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Euler -> m Euler) -> IO Euler -> m Euler
forall a b. (a -> b) -> a -> b
$ do
Ptr Euler
e' <- Euler -> IO (Ptr Euler)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Euler
e
let x' :: CFloat
x' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
x
let y' :: CFloat
y' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
y
let z' :: CFloat
z' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
z
Ptr Euler
result <- Ptr Euler -> CFloat -> CFloat -> CFloat -> IO (Ptr Euler)
graphene_euler_init Ptr Euler
e' CFloat
x' CFloat
y' CFloat
z'
Text -> Ptr Euler -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"eulerInit" Ptr Euler
result
Euler
result' <- ((ManagedPtr Euler -> Euler) -> Ptr Euler -> IO Euler
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr Euler -> Euler
Euler) Ptr Euler
result
Euler -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Euler
e
Euler -> IO Euler
forall (m :: * -> *) a. Monad m => a -> m a
return Euler
result'
#if defined(ENABLE_OVERLOADING)
data EulerInitMethodInfo
instance (signature ~ (Float -> Float -> Float -> m Euler), MonadIO m) => O.OverloadedMethod EulerInitMethodInfo Euler signature where
overloadedMethod = eulerInit
instance O.OverloadedMethodInfo EulerInitMethodInfo Euler where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Graphene.Structs.Euler.eulerInit",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-graphene-1.0.4/docs/GI-Graphene-Structs-Euler.html#v:eulerInit"
})
#endif
foreign import ccall "graphene_euler_init_from_euler" graphene_euler_init_from_euler ::
Ptr Euler ->
Ptr Euler ->
IO (Ptr Euler)
eulerInitFromEuler ::
(B.CallStack.HasCallStack, MonadIO m) =>
Euler
-> Maybe (Euler)
-> m Euler
eulerInitFromEuler :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Euler -> Maybe Euler -> m Euler
eulerInitFromEuler Euler
e Maybe Euler
src = IO Euler -> m Euler
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Euler -> m Euler) -> IO Euler -> m Euler
forall a b. (a -> b) -> a -> b
$ do
Ptr Euler
e' <- Euler -> IO (Ptr Euler)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Euler
e
Ptr Euler
maybeSrc <- case Maybe Euler
src of
Maybe Euler
Nothing -> Ptr Euler -> IO (Ptr Euler)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Euler
forall a. Ptr a
nullPtr
Just Euler
jSrc -> do
Ptr Euler
jSrc' <- Euler -> IO (Ptr Euler)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Euler
jSrc
Ptr Euler -> IO (Ptr Euler)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Euler
jSrc'
Ptr Euler
result <- Ptr Euler -> Ptr Euler -> IO (Ptr Euler)
graphene_euler_init_from_euler Ptr Euler
e' Ptr Euler
maybeSrc
Text -> Ptr Euler -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"eulerInitFromEuler" Ptr Euler
result
Euler
result' <- ((ManagedPtr Euler -> Euler) -> Ptr Euler -> IO Euler
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr Euler -> Euler
Euler) Ptr Euler
result
Euler -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Euler
e
Maybe Euler -> (Euler -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe Euler
src Euler -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
Euler -> IO Euler
forall (m :: * -> *) a. Monad m => a -> m a
return Euler
result'
#if defined(ENABLE_OVERLOADING)
data EulerInitFromEulerMethodInfo
instance (signature ~ (Maybe (Euler) -> m Euler), MonadIO m) => O.OverloadedMethod EulerInitFromEulerMethodInfo Euler signature where
overloadedMethod = eulerInitFromEuler
instance O.OverloadedMethodInfo EulerInitFromEulerMethodInfo Euler where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Graphene.Structs.Euler.eulerInitFromEuler",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-graphene-1.0.4/docs/GI-Graphene-Structs-Euler.html#v:eulerInitFromEuler"
})
#endif
foreign import ccall "graphene_euler_init_from_matrix" graphene_euler_init_from_matrix ::
Ptr Euler ->
Ptr Graphene.Matrix.Matrix ->
CInt ->
IO (Ptr Euler)
eulerInitFromMatrix ::
(B.CallStack.HasCallStack, MonadIO m) =>
Euler
-> Maybe (Graphene.Matrix.Matrix)
-> Graphene.Enums.EulerOrder
-> m Euler
eulerInitFromMatrix :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Euler -> Maybe Matrix -> EulerOrder -> m Euler
eulerInitFromMatrix Euler
e Maybe Matrix
m EulerOrder
order = IO Euler -> m Euler
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Euler -> m Euler) -> IO Euler -> m Euler
forall a b. (a -> b) -> a -> b
$ do
Ptr Euler
e' <- Euler -> IO (Ptr Euler)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Euler
e
Ptr Matrix
maybeM <- case Maybe Matrix
m of
Maybe Matrix
Nothing -> Ptr Matrix -> IO (Ptr Matrix)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Matrix
forall a. Ptr a
nullPtr
Just Matrix
jM -> do
Ptr Matrix
jM' <- Matrix -> IO (Ptr Matrix)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Matrix
jM
Ptr Matrix -> IO (Ptr Matrix)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Matrix
jM'
let order' :: CInt
order' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (EulerOrder -> Int) -> EulerOrder -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. EulerOrder -> Int
forall a. Enum a => a -> Int
fromEnum) EulerOrder
order
Ptr Euler
result <- Ptr Euler -> Ptr Matrix -> CInt -> IO (Ptr Euler)
graphene_euler_init_from_matrix Ptr Euler
e' Ptr Matrix
maybeM CInt
order'
Text -> Ptr Euler -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"eulerInitFromMatrix" Ptr Euler
result
Euler
result' <- ((ManagedPtr Euler -> Euler) -> Ptr Euler -> IO Euler
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr Euler -> Euler
Euler) Ptr Euler
result
Euler -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Euler
e
Maybe Matrix -> (Matrix -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe Matrix
m Matrix -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
Euler -> IO Euler
forall (m :: * -> *) a. Monad m => a -> m a
return Euler
result'
#if defined(ENABLE_OVERLOADING)
data EulerInitFromMatrixMethodInfo
instance (signature ~ (Maybe (Graphene.Matrix.Matrix) -> Graphene.Enums.EulerOrder -> m Euler), MonadIO m) => O.OverloadedMethod EulerInitFromMatrixMethodInfo Euler signature where
overloadedMethod = eulerInitFromMatrix
instance O.OverloadedMethodInfo EulerInitFromMatrixMethodInfo Euler where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Graphene.Structs.Euler.eulerInitFromMatrix",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-graphene-1.0.4/docs/GI-Graphene-Structs-Euler.html#v:eulerInitFromMatrix"
})
#endif
foreign import ccall "graphene_euler_init_from_quaternion" graphene_euler_init_from_quaternion ::
Ptr Euler ->
Ptr Graphene.Quaternion.Quaternion ->
CInt ->
IO (Ptr Euler)
eulerInitFromQuaternion ::
(B.CallStack.HasCallStack, MonadIO m) =>
Euler
-> Maybe (Graphene.Quaternion.Quaternion)
-> Graphene.Enums.EulerOrder
-> m Euler
eulerInitFromQuaternion :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Euler -> Maybe Quaternion -> EulerOrder -> m Euler
eulerInitFromQuaternion Euler
e Maybe Quaternion
q EulerOrder
order = IO Euler -> m Euler
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Euler -> m Euler) -> IO Euler -> m Euler
forall a b. (a -> b) -> a -> b
$ do
Ptr Euler
e' <- Euler -> IO (Ptr Euler)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Euler
e
Ptr Quaternion
maybeQ <- case Maybe Quaternion
q of
Maybe Quaternion
Nothing -> Ptr Quaternion -> IO (Ptr Quaternion)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Quaternion
forall a. Ptr a
nullPtr
Just Quaternion
jQ -> do
Ptr Quaternion
jQ' <- Quaternion -> IO (Ptr Quaternion)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Quaternion
jQ
Ptr Quaternion -> IO (Ptr Quaternion)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Quaternion
jQ'
let order' :: CInt
order' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (EulerOrder -> Int) -> EulerOrder -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. EulerOrder -> Int
forall a. Enum a => a -> Int
fromEnum) EulerOrder
order
Ptr Euler
result <- Ptr Euler -> Ptr Quaternion -> CInt -> IO (Ptr Euler)
graphene_euler_init_from_quaternion Ptr Euler
e' Ptr Quaternion
maybeQ CInt
order'
Text -> Ptr Euler -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"eulerInitFromQuaternion" Ptr Euler
result
Euler
result' <- ((ManagedPtr Euler -> Euler) -> Ptr Euler -> IO Euler
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr Euler -> Euler
Euler) Ptr Euler
result
Euler -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Euler
e
Maybe Quaternion -> (Quaternion -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe Quaternion
q Quaternion -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
Euler -> IO Euler
forall (m :: * -> *) a. Monad m => a -> m a
return Euler
result'
#if defined(ENABLE_OVERLOADING)
data EulerInitFromQuaternionMethodInfo
instance (signature ~ (Maybe (Graphene.Quaternion.Quaternion) -> Graphene.Enums.EulerOrder -> m Euler), MonadIO m) => O.OverloadedMethod EulerInitFromQuaternionMethodInfo Euler signature where
overloadedMethod = eulerInitFromQuaternion
instance O.OverloadedMethodInfo EulerInitFromQuaternionMethodInfo Euler where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Graphene.Structs.Euler.eulerInitFromQuaternion",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-graphene-1.0.4/docs/GI-Graphene-Structs-Euler.html#v:eulerInitFromQuaternion"
})
#endif
foreign import ccall "graphene_euler_init_from_radians" graphene_euler_init_from_radians ::
Ptr Euler ->
CFloat ->
CFloat ->
CFloat ->
CInt ->
IO (Ptr Euler)
eulerInitFromRadians ::
(B.CallStack.HasCallStack, MonadIO m) =>
Euler
-> Float
-> Float
-> Float
-> Graphene.Enums.EulerOrder
-> m Euler
eulerInitFromRadians :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Euler -> Float -> Float -> Float -> EulerOrder -> m Euler
eulerInitFromRadians Euler
e Float
x Float
y Float
z EulerOrder
order = IO Euler -> m Euler
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Euler -> m Euler) -> IO Euler -> m Euler
forall a b. (a -> b) -> a -> b
$ do
Ptr Euler
e' <- Euler -> IO (Ptr Euler)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Euler
e
let x' :: CFloat
x' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
x
let y' :: CFloat
y' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
y
let z' :: CFloat
z' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
z
let order' :: CInt
order' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (EulerOrder -> Int) -> EulerOrder -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. EulerOrder -> Int
forall a. Enum a => a -> Int
fromEnum) EulerOrder
order
Ptr Euler
result <- Ptr Euler -> CFloat -> CFloat -> CFloat -> CInt -> IO (Ptr Euler)
graphene_euler_init_from_radians Ptr Euler
e' CFloat
x' CFloat
y' CFloat
z' CInt
order'
Text -> Ptr Euler -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"eulerInitFromRadians" Ptr Euler
result
Euler
result' <- ((ManagedPtr Euler -> Euler) -> Ptr Euler -> IO Euler
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr Euler -> Euler
Euler) Ptr Euler
result
Euler -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Euler
e
Euler -> IO Euler
forall (m :: * -> *) a. Monad m => a -> m a
return Euler
result'
#if defined(ENABLE_OVERLOADING)
data EulerInitFromRadiansMethodInfo
instance (signature ~ (Float -> Float -> Float -> Graphene.Enums.EulerOrder -> m Euler), MonadIO m) => O.OverloadedMethod EulerInitFromRadiansMethodInfo Euler signature where
overloadedMethod = eulerInitFromRadians
instance O.OverloadedMethodInfo EulerInitFromRadiansMethodInfo Euler where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Graphene.Structs.Euler.eulerInitFromRadians",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-graphene-1.0.4/docs/GI-Graphene-Structs-Euler.html#v:eulerInitFromRadians"
})
#endif
foreign import ccall "graphene_euler_init_from_vec3" graphene_euler_init_from_vec3 ::
Ptr Euler ->
Ptr Graphene.Vec3.Vec3 ->
CInt ->
IO (Ptr Euler)
eulerInitFromVec3 ::
(B.CallStack.HasCallStack, MonadIO m) =>
Euler
-> Maybe (Graphene.Vec3.Vec3)
-> Graphene.Enums.EulerOrder
-> m Euler
eulerInitFromVec3 :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Euler -> Maybe Vec3 -> EulerOrder -> m Euler
eulerInitFromVec3 Euler
e Maybe Vec3
v EulerOrder
order = IO Euler -> m Euler
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Euler -> m Euler) -> IO Euler -> m Euler
forall a b. (a -> b) -> a -> b
$ do
Ptr Euler
e' <- Euler -> IO (Ptr Euler)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Euler
e
Ptr Vec3
maybeV <- case Maybe Vec3
v of
Maybe Vec3
Nothing -> Ptr Vec3 -> IO (Ptr Vec3)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Vec3
forall a. Ptr a
nullPtr
Just Vec3
jV -> do
Ptr Vec3
jV' <- Vec3 -> IO (Ptr Vec3)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Vec3
jV
Ptr Vec3 -> IO (Ptr Vec3)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Vec3
jV'
let order' :: CInt
order' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (EulerOrder -> Int) -> EulerOrder -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. EulerOrder -> Int
forall a. Enum a => a -> Int
fromEnum) EulerOrder
order
Ptr Euler
result <- Ptr Euler -> Ptr Vec3 -> CInt -> IO (Ptr Euler)
graphene_euler_init_from_vec3 Ptr Euler
e' Ptr Vec3
maybeV CInt
order'
Text -> Ptr Euler -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"eulerInitFromVec3" Ptr Euler
result
Euler
result' <- ((ManagedPtr Euler -> Euler) -> Ptr Euler -> IO Euler
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr Euler -> Euler
Euler) Ptr Euler
result
Euler -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Euler
e
Maybe Vec3 -> (Vec3 -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe Vec3
v Vec3 -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
Euler -> IO Euler
forall (m :: * -> *) a. Monad m => a -> m a
return Euler
result'
#if defined(ENABLE_OVERLOADING)
data EulerInitFromVec3MethodInfo
instance (signature ~ (Maybe (Graphene.Vec3.Vec3) -> Graphene.Enums.EulerOrder -> m Euler), MonadIO m) => O.OverloadedMethod EulerInitFromVec3MethodInfo Euler signature where
overloadedMethod = eulerInitFromVec3
instance O.OverloadedMethodInfo EulerInitFromVec3MethodInfo Euler where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Graphene.Structs.Euler.eulerInitFromVec3",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-graphene-1.0.4/docs/GI-Graphene-Structs-Euler.html#v:eulerInitFromVec3"
})
#endif
foreign import ccall "graphene_euler_init_with_order" graphene_euler_init_with_order ::
Ptr Euler ->
CFloat ->
CFloat ->
CFloat ->
CInt ->
IO (Ptr Euler)
eulerInitWithOrder ::
(B.CallStack.HasCallStack, MonadIO m) =>
Euler
-> Float
-> Float
-> Float
-> Graphene.Enums.EulerOrder
-> m Euler
eulerInitWithOrder :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Euler -> Float -> Float -> Float -> EulerOrder -> m Euler
eulerInitWithOrder Euler
e Float
x Float
y Float
z EulerOrder
order = IO Euler -> m Euler
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Euler -> m Euler) -> IO Euler -> m Euler
forall a b. (a -> b) -> a -> b
$ do
Ptr Euler
e' <- Euler -> IO (Ptr Euler)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Euler
e
let x' :: CFloat
x' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
x
let y' :: CFloat
y' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
y
let z' :: CFloat
z' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
z
let order' :: CInt
order' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (EulerOrder -> Int) -> EulerOrder -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. EulerOrder -> Int
forall a. Enum a => a -> Int
fromEnum) EulerOrder
order
Ptr Euler
result <- Ptr Euler -> CFloat -> CFloat -> CFloat -> CInt -> IO (Ptr Euler)
graphene_euler_init_with_order Ptr Euler
e' CFloat
x' CFloat
y' CFloat
z' CInt
order'
Text -> Ptr Euler -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"eulerInitWithOrder" Ptr Euler
result
Euler
result' <- ((ManagedPtr Euler -> Euler) -> Ptr Euler -> IO Euler
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr Euler -> Euler
Euler) Ptr Euler
result
Euler -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Euler
e
Euler -> IO Euler
forall (m :: * -> *) a. Monad m => a -> m a
return Euler
result'
#if defined(ENABLE_OVERLOADING)
data EulerInitWithOrderMethodInfo
instance (signature ~ (Float -> Float -> Float -> Graphene.Enums.EulerOrder -> m Euler), MonadIO m) => O.OverloadedMethod EulerInitWithOrderMethodInfo Euler signature where
overloadedMethod = eulerInitWithOrder
instance O.OverloadedMethodInfo EulerInitWithOrderMethodInfo Euler where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Graphene.Structs.Euler.eulerInitWithOrder",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-graphene-1.0.4/docs/GI-Graphene-Structs-Euler.html#v:eulerInitWithOrder"
})
#endif
foreign import ccall "graphene_euler_reorder" graphene_euler_reorder ::
Ptr Euler ->
CInt ->
Ptr Euler ->
IO ()
eulerReorder ::
(B.CallStack.HasCallStack, MonadIO m) =>
Euler
-> Graphene.Enums.EulerOrder
-> m (Euler)
eulerReorder :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Euler -> EulerOrder -> m Euler
eulerReorder Euler
e EulerOrder
order = IO Euler -> m Euler
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Euler -> m Euler) -> IO Euler -> m Euler
forall a b. (a -> b) -> a -> b
$ do
Ptr Euler
e' <- Euler -> IO (Ptr Euler)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Euler
e
let order' :: CInt
order' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (EulerOrder -> Int) -> EulerOrder -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. EulerOrder -> Int
forall a. Enum a => a -> Int
fromEnum) EulerOrder
order
Ptr Euler
res <- Int -> IO (Ptr Euler)
forall a. GBoxed a => Int -> IO (Ptr a)
SP.callocBoxedBytes Int
20 :: IO (Ptr Euler)
Ptr Euler -> CInt -> Ptr Euler -> IO ()
graphene_euler_reorder Ptr Euler
e' CInt
order' Ptr Euler
res
Euler
res' <- ((ManagedPtr Euler -> Euler) -> Ptr Euler -> IO Euler
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Euler -> Euler
Euler) Ptr Euler
res
Euler -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Euler
e
Euler -> IO Euler
forall (m :: * -> *) a. Monad m => a -> m a
return Euler
res'
#if defined(ENABLE_OVERLOADING)
data EulerReorderMethodInfo
instance (signature ~ (Graphene.Enums.EulerOrder -> m (Euler)), MonadIO m) => O.OverloadedMethod EulerReorderMethodInfo Euler signature where
overloadedMethod = eulerReorder
instance O.OverloadedMethodInfo EulerReorderMethodInfo Euler where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Graphene.Structs.Euler.eulerReorder",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-graphene-1.0.4/docs/GI-Graphene-Structs-Euler.html#v:eulerReorder"
})
#endif
foreign import ccall "graphene_euler_to_matrix" graphene_euler_to_matrix ::
Ptr Euler ->
Ptr Graphene.Matrix.Matrix ->
IO ()
eulerToMatrix ::
(B.CallStack.HasCallStack, MonadIO m) =>
Euler
-> m (Graphene.Matrix.Matrix)
eulerToMatrix :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Euler -> m Matrix
eulerToMatrix Euler
e = IO Matrix -> m Matrix
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Matrix -> m Matrix) -> IO Matrix -> m Matrix
forall a b. (a -> b) -> a -> b
$ do
Ptr Euler
e' <- Euler -> IO (Ptr Euler)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Euler
e
Ptr Matrix
res <- Int -> IO (Ptr Matrix)
forall a. GBoxed a => Int -> IO (Ptr a)
SP.callocBoxedBytes Int
64 :: IO (Ptr Graphene.Matrix.Matrix)
Ptr Euler -> Ptr Matrix -> IO ()
graphene_euler_to_matrix Ptr Euler
e' Ptr Matrix
res
Matrix
res' <- ((ManagedPtr Matrix -> Matrix) -> Ptr Matrix -> IO Matrix
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Matrix -> Matrix
Graphene.Matrix.Matrix) Ptr Matrix
res
Euler -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Euler
e
Matrix -> IO Matrix
forall (m :: * -> *) a. Monad m => a -> m a
return Matrix
res'
#if defined(ENABLE_OVERLOADING)
data EulerToMatrixMethodInfo
instance (signature ~ (m (Graphene.Matrix.Matrix)), MonadIO m) => O.OverloadedMethod EulerToMatrixMethodInfo Euler signature where
overloadedMethod = eulerToMatrix
instance O.OverloadedMethodInfo EulerToMatrixMethodInfo Euler where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Graphene.Structs.Euler.eulerToMatrix",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-graphene-1.0.4/docs/GI-Graphene-Structs-Euler.html#v:eulerToMatrix"
})
#endif
foreign import ccall "graphene_euler_to_quaternion" graphene_euler_to_quaternion ::
Ptr Euler ->
Ptr Graphene.Quaternion.Quaternion ->
IO ()
eulerToQuaternion ::
(B.CallStack.HasCallStack, MonadIO m) =>
Euler
-> m (Graphene.Quaternion.Quaternion)
eulerToQuaternion :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Euler -> m Quaternion
eulerToQuaternion Euler
e = IO Quaternion -> m Quaternion
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Quaternion -> m Quaternion) -> IO Quaternion -> m Quaternion
forall a b. (a -> b) -> a -> b
$ do
Ptr Euler
e' <- Euler -> IO (Ptr Euler)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Euler
e
Ptr Quaternion
res <- Int -> IO (Ptr Quaternion)
forall a. GBoxed a => Int -> IO (Ptr a)
SP.callocBoxedBytes Int
16 :: IO (Ptr Graphene.Quaternion.Quaternion)
Ptr Euler -> Ptr Quaternion -> IO ()
graphene_euler_to_quaternion Ptr Euler
e' Ptr Quaternion
res
Quaternion
res' <- ((ManagedPtr Quaternion -> Quaternion)
-> Ptr Quaternion -> IO Quaternion
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Quaternion -> Quaternion
Graphene.Quaternion.Quaternion) Ptr Quaternion
res
Euler -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Euler
e
Quaternion -> IO Quaternion
forall (m :: * -> *) a. Monad m => a -> m a
return Quaternion
res'
#if defined(ENABLE_OVERLOADING)
data EulerToQuaternionMethodInfo
instance (signature ~ (m (Graphene.Quaternion.Quaternion)), MonadIO m) => O.OverloadedMethod EulerToQuaternionMethodInfo Euler signature where
overloadedMethod = eulerToQuaternion
instance O.OverloadedMethodInfo EulerToQuaternionMethodInfo Euler where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Graphene.Structs.Euler.eulerToQuaternion",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-graphene-1.0.4/docs/GI-Graphene-Structs-Euler.html#v:eulerToQuaternion"
})
#endif
foreign import ccall "graphene_euler_to_vec3" graphene_euler_to_vec3 ::
Ptr Euler ->
Ptr Graphene.Vec3.Vec3 ->
IO ()
eulerToVec3 ::
(B.CallStack.HasCallStack, MonadIO m) =>
Euler
-> m (Graphene.Vec3.Vec3)
eulerToVec3 :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Euler -> m Vec3
eulerToVec3 Euler
e = IO Vec3 -> m Vec3
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Vec3 -> m Vec3) -> IO Vec3 -> m Vec3
forall a b. (a -> b) -> a -> b
$ do
Ptr Euler
e' <- Euler -> IO (Ptr Euler)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Euler
e
Ptr Vec3
res <- Int -> IO (Ptr Vec3)
forall a. GBoxed a => Int -> IO (Ptr a)
SP.callocBoxedBytes Int
16 :: IO (Ptr Graphene.Vec3.Vec3)
Ptr Euler -> Ptr Vec3 -> IO ()
graphene_euler_to_vec3 Ptr Euler
e' Ptr Vec3
res
Vec3
res' <- ((ManagedPtr Vec3 -> Vec3) -> Ptr Vec3 -> IO Vec3
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Vec3 -> Vec3
Graphene.Vec3.Vec3) Ptr Vec3
res
Euler -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Euler
e
Vec3 -> IO Vec3
forall (m :: * -> *) a. Monad m => a -> m a
return Vec3
res'
#if defined(ENABLE_OVERLOADING)
data EulerToVec3MethodInfo
instance (signature ~ (m (Graphene.Vec3.Vec3)), MonadIO m) => O.OverloadedMethod EulerToVec3MethodInfo Euler signature where
overloadedMethod = eulerToVec3
instance O.OverloadedMethodInfo EulerToVec3MethodInfo Euler where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Graphene.Structs.Euler.eulerToVec3",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-graphene-1.0.4/docs/GI-Graphene-Structs-Euler.html#v:eulerToVec3"
})
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveEulerMethod (t :: Symbol) (o :: *) :: * where
ResolveEulerMethod "equal" o = EulerEqualMethodInfo
ResolveEulerMethod "free" o = EulerFreeMethodInfo
ResolveEulerMethod "init" o = EulerInitMethodInfo
ResolveEulerMethod "initFromEuler" o = EulerInitFromEulerMethodInfo
ResolveEulerMethod "initFromMatrix" o = EulerInitFromMatrixMethodInfo
ResolveEulerMethod "initFromQuaternion" o = EulerInitFromQuaternionMethodInfo
ResolveEulerMethod "initFromRadians" o = EulerInitFromRadiansMethodInfo
ResolveEulerMethod "initFromVec3" o = EulerInitFromVec3MethodInfo
ResolveEulerMethod "initWithOrder" o = EulerInitWithOrderMethodInfo
ResolveEulerMethod "reorder" o = EulerReorderMethodInfo
ResolveEulerMethod "toMatrix" o = EulerToMatrixMethodInfo
ResolveEulerMethod "toQuaternion" o = EulerToQuaternionMethodInfo
ResolveEulerMethod "toVec3" o = EulerToVec3MethodInfo
ResolveEulerMethod "getAlpha" o = EulerGetAlphaMethodInfo
ResolveEulerMethod "getBeta" o = EulerGetBetaMethodInfo
ResolveEulerMethod "getGamma" o = EulerGetGammaMethodInfo
ResolveEulerMethod "getOrder" o = EulerGetOrderMethodInfo
ResolveEulerMethod "getX" o = EulerGetXMethodInfo
ResolveEulerMethod "getY" o = EulerGetYMethodInfo
ResolveEulerMethod "getZ" o = EulerGetZMethodInfo
ResolveEulerMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveEulerMethod t Euler, O.OverloadedMethod info Euler p) => OL.IsLabel t (Euler -> 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 ~ ResolveEulerMethod t Euler, O.OverloadedMethod info Euler p, R.HasField t Euler p) => R.HasField t Euler p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveEulerMethod t Euler, O.OverloadedMethodInfo info Euler) => OL.IsLabel t (O.MethodProxy info Euler) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif