{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Graphene.Structs.Triangle
(
Triangle(..) ,
newZeroTriangle ,
#if defined(ENABLE_OVERLOADING)
ResolveTriangleMethod ,
#endif
triangleAlloc ,
#if defined(ENABLE_OVERLOADING)
TriangleContainsPointMethodInfo ,
#endif
triangleContainsPoint ,
#if defined(ENABLE_OVERLOADING)
TriangleEqualMethodInfo ,
#endif
triangleEqual ,
#if defined(ENABLE_OVERLOADING)
TriangleFreeMethodInfo ,
#endif
triangleFree ,
#if defined(ENABLE_OVERLOADING)
TriangleGetAreaMethodInfo ,
#endif
triangleGetArea ,
#if defined(ENABLE_OVERLOADING)
TriangleGetBarycoordsMethodInfo ,
#endif
triangleGetBarycoords ,
#if defined(ENABLE_OVERLOADING)
TriangleGetBoundingBoxMethodInfo ,
#endif
triangleGetBoundingBox ,
#if defined(ENABLE_OVERLOADING)
TriangleGetMidpointMethodInfo ,
#endif
triangleGetMidpoint ,
#if defined(ENABLE_OVERLOADING)
TriangleGetNormalMethodInfo ,
#endif
triangleGetNormal ,
#if defined(ENABLE_OVERLOADING)
TriangleGetPlaneMethodInfo ,
#endif
triangleGetPlane ,
#if defined(ENABLE_OVERLOADING)
TriangleGetPointsMethodInfo ,
#endif
triangleGetPoints ,
#if defined(ENABLE_OVERLOADING)
TriangleGetUvMethodInfo ,
#endif
triangleGetUv ,
#if defined(ENABLE_OVERLOADING)
TriangleGetVerticesMethodInfo ,
#endif
triangleGetVertices ,
#if defined(ENABLE_OVERLOADING)
TriangleInitFromFloatMethodInfo ,
#endif
triangleInitFromFloat ,
#if defined(ENABLE_OVERLOADING)
TriangleInitFromPoint3dMethodInfo ,
#endif
triangleInitFromPoint3d ,
#if defined(ENABLE_OVERLOADING)
TriangleInitFromVec3MethodInfo ,
#endif
triangleInitFromVec3 ,
) 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.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.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 {-# SOURCE #-} qualified GI.Graphene.Structs.Box as Graphene.Box
import {-# SOURCE #-} qualified GI.Graphene.Structs.Plane as Graphene.Plane
import {-# SOURCE #-} qualified GI.Graphene.Structs.Point3D as Graphene.Point3D
import {-# SOURCE #-} qualified GI.Graphene.Structs.Vec2 as Graphene.Vec2
import {-# SOURCE #-} qualified GI.Graphene.Structs.Vec3 as Graphene.Vec3
newtype Triangle = Triangle (SP.ManagedPtr Triangle)
deriving (Triangle -> Triangle -> Bool
(Triangle -> Triangle -> Bool)
-> (Triangle -> Triangle -> Bool) -> Eq Triangle
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Triangle -> Triangle -> Bool
$c/= :: Triangle -> Triangle -> Bool
== :: Triangle -> Triangle -> Bool
$c== :: Triangle -> Triangle -> Bool
Eq)
instance SP.ManagedPtrNewtype Triangle where
toManagedPtr :: Triangle -> ManagedPtr Triangle
toManagedPtr (Triangle ManagedPtr Triangle
p) = ManagedPtr Triangle
p
foreign import ccall "graphene_triangle_get_type" c_graphene_triangle_get_type ::
IO GType
type instance O.ParentTypes Triangle = '[]
instance O.HasParentTypes Triangle
instance B.Types.TypedObject Triangle where
glibType :: IO GType
glibType = IO GType
c_graphene_triangle_get_type
instance B.Types.GBoxed Triangle
instance B.GValue.IsGValue Triangle where
toGValue :: Triangle -> IO GValue
toGValue Triangle
o = do
GType
gtype <- IO GType
c_graphene_triangle_get_type
Triangle -> (Ptr Triangle -> IO GValue) -> IO GValue
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr Triangle
o (GType
-> (GValue -> Ptr Triangle -> IO ()) -> Ptr Triangle -> IO GValue
forall a. GType -> (GValue -> a -> IO ()) -> a -> IO GValue
B.GValue.buildGValue GType
gtype GValue -> Ptr Triangle -> IO ()
forall a. GValue -> Ptr a -> IO ()
B.GValue.set_boxed)
fromGValue :: GValue -> IO Triangle
fromGValue GValue
gv = do
Ptr Triangle
ptr <- GValue -> IO (Ptr Triangle)
forall b. GValue -> IO (Ptr b)
B.GValue.get_boxed GValue
gv :: IO (Ptr Triangle)
(ManagedPtr Triangle -> Triangle) -> Ptr Triangle -> IO Triangle
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.newBoxed ManagedPtr Triangle -> Triangle
Triangle Ptr Triangle
ptr
newZeroTriangle :: MonadIO m => m Triangle
newZeroTriangle :: m Triangle
newZeroTriangle = IO Triangle -> m Triangle
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Triangle -> m Triangle) -> IO Triangle -> m Triangle
forall a b. (a -> b) -> a -> b
$ Int -> IO (Ptr Triangle)
forall a. GBoxed a => Int -> IO (Ptr a)
callocBoxedBytes Int
48 IO (Ptr Triangle) -> (Ptr Triangle -> IO Triangle) -> IO Triangle
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (ManagedPtr Triangle -> Triangle) -> Ptr Triangle -> IO Triangle
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Triangle -> Triangle
Triangle
instance tag ~ 'AttrSet => Constructible Triangle tag where
new :: (ManagedPtr Triangle -> Triangle)
-> [AttrOp Triangle tag] -> m Triangle
new ManagedPtr Triangle -> Triangle
_ [AttrOp Triangle tag]
attrs = do
Triangle
o <- m Triangle
forall (m :: * -> *). MonadIO m => m Triangle
newZeroTriangle
Triangle -> [AttrOp Triangle 'AttrSet] -> m ()
forall o (m :: * -> *).
MonadIO m =>
o -> [AttrOp o 'AttrSet] -> m ()
GI.Attributes.set Triangle
o [AttrOp Triangle tag]
[AttrOp Triangle 'AttrSet]
attrs
Triangle -> m Triangle
forall (m :: * -> *) a. Monad m => a -> m a
return Triangle
o
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Triangle
type instance O.AttributeList Triangle = TriangleAttributeList
type TriangleAttributeList = ('[ ] :: [(Symbol, *)])
#endif
foreign import ccall "graphene_triangle_alloc" graphene_triangle_alloc ::
IO (Ptr Triangle)
triangleAlloc ::
(B.CallStack.HasCallStack, MonadIO m) =>
m Triangle
triangleAlloc :: m Triangle
triangleAlloc = IO Triangle -> m Triangle
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Triangle -> m Triangle) -> IO Triangle -> m Triangle
forall a b. (a -> b) -> a -> b
$ do
Ptr Triangle
result <- IO (Ptr Triangle)
graphene_triangle_alloc
Text -> Ptr Triangle -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"triangleAlloc" Ptr Triangle
result
Triangle
result' <- ((ManagedPtr Triangle -> Triangle) -> Ptr Triangle -> IO Triangle
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Triangle -> Triangle
Triangle) Ptr Triangle
result
Triangle -> IO Triangle
forall (m :: * -> *) a. Monad m => a -> m a
return Triangle
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "graphene_triangle_contains_point" graphene_triangle_contains_point ::
Ptr Triangle ->
Ptr Graphene.Point3D.Point3D ->
IO CInt
triangleContainsPoint ::
(B.CallStack.HasCallStack, MonadIO m) =>
Triangle
-> Graphene.Point3D.Point3D
-> m Bool
triangleContainsPoint :: Triangle -> Point3D -> m Bool
triangleContainsPoint Triangle
t Point3D
p = 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 Triangle
t' <- Triangle -> IO (Ptr Triangle)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Triangle
t
Ptr Point3D
p' <- Point3D -> IO (Ptr Point3D)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Point3D
p
CInt
result <- Ptr Triangle -> Ptr Point3D -> IO CInt
graphene_triangle_contains_point Ptr Triangle
t' Ptr Point3D
p'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
Triangle -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Triangle
t
Point3D -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Point3D
p
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data TriangleContainsPointMethodInfo
instance (signature ~ (Graphene.Point3D.Point3D -> m Bool), MonadIO m) => O.MethodInfo TriangleContainsPointMethodInfo Triangle signature where
overloadedMethod = triangleContainsPoint
#endif
foreign import ccall "graphene_triangle_equal" graphene_triangle_equal ::
Ptr Triangle ->
Ptr Triangle ->
IO CInt
triangleEqual ::
(B.CallStack.HasCallStack, MonadIO m) =>
Triangle
-> Triangle
-> m Bool
triangleEqual :: Triangle -> Triangle -> m Bool
triangleEqual Triangle
a Triangle
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 Triangle
a' <- Triangle -> IO (Ptr Triangle)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Triangle
a
Ptr Triangle
b' <- Triangle -> IO (Ptr Triangle)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Triangle
b
CInt
result <- Ptr Triangle -> Ptr Triangle -> IO CInt
graphene_triangle_equal Ptr Triangle
a' Ptr Triangle
b'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
Triangle -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Triangle
a
Triangle -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Triangle
b
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data TriangleEqualMethodInfo
instance (signature ~ (Triangle -> m Bool), MonadIO m) => O.MethodInfo TriangleEqualMethodInfo Triangle signature where
overloadedMethod = triangleEqual
#endif
foreign import ccall "graphene_triangle_free" graphene_triangle_free ::
Ptr Triangle ->
IO ()
triangleFree ::
(B.CallStack.HasCallStack, MonadIO m) =>
Triangle
-> m ()
triangleFree :: Triangle -> m ()
triangleFree Triangle
t = 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 Triangle
t' <- Triangle -> IO (Ptr Triangle)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Triangle
t
Ptr Triangle -> IO ()
graphene_triangle_free Ptr Triangle
t'
Triangle -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Triangle
t
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data TriangleFreeMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.MethodInfo TriangleFreeMethodInfo Triangle signature where
overloadedMethod = triangleFree
#endif
foreign import ccall "graphene_triangle_get_area" graphene_triangle_get_area ::
Ptr Triangle ->
IO CFloat
triangleGetArea ::
(B.CallStack.HasCallStack, MonadIO m) =>
Triangle
-> m Float
triangleGetArea :: Triangle -> m Float
triangleGetArea Triangle
t = 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 Triangle
t' <- Triangle -> IO (Ptr Triangle)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Triangle
t
CFloat
result <- Ptr Triangle -> IO CFloat
graphene_triangle_get_area Ptr Triangle
t'
let result' :: Float
result' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
result
Triangle -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Triangle
t
Float -> IO Float
forall (m :: * -> *) a. Monad m => a -> m a
return Float
result'
#if defined(ENABLE_OVERLOADING)
data TriangleGetAreaMethodInfo
instance (signature ~ (m Float), MonadIO m) => O.MethodInfo TriangleGetAreaMethodInfo Triangle signature where
overloadedMethod = triangleGetArea
#endif
foreign import ccall "graphene_triangle_get_barycoords" graphene_triangle_get_barycoords ::
Ptr Triangle ->
Ptr Graphene.Point3D.Point3D ->
Ptr Graphene.Vec2.Vec2 ->
IO CInt
triangleGetBarycoords ::
(B.CallStack.HasCallStack, MonadIO m) =>
Triangle
-> Maybe (Graphene.Point3D.Point3D)
-> m ((Bool, Graphene.Vec2.Vec2))
triangleGetBarycoords :: Triangle -> Maybe Point3D -> m (Bool, Vec2)
triangleGetBarycoords Triangle
t Maybe Point3D
p = IO (Bool, Vec2) -> m (Bool, Vec2)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Vec2) -> m (Bool, Vec2))
-> IO (Bool, Vec2) -> m (Bool, Vec2)
forall a b. (a -> b) -> a -> b
$ do
Ptr Triangle
t' <- Triangle -> IO (Ptr Triangle)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Triangle
t
Ptr Point3D
maybeP <- case Maybe Point3D
p of
Maybe Point3D
Nothing -> Ptr Point3D -> IO (Ptr Point3D)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Point3D
forall a. Ptr a
nullPtr
Just Point3D
jP -> do
Ptr Point3D
jP' <- Point3D -> IO (Ptr Point3D)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Point3D
jP
Ptr Point3D -> IO (Ptr Point3D)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Point3D
jP'
Ptr Vec2
res <- Int -> IO (Ptr Vec2)
forall a. GBoxed a => Int -> IO (Ptr a)
SP.callocBoxedBytes Int
16 :: IO (Ptr Graphene.Vec2.Vec2)
CInt
result <- Ptr Triangle -> Ptr Point3D -> Ptr Vec2 -> IO CInt
graphene_triangle_get_barycoords Ptr Triangle
t' Ptr Point3D
maybeP Ptr Vec2
res
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
Vec2
res' <- ((ManagedPtr Vec2 -> Vec2) -> Ptr Vec2 -> IO Vec2
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Vec2 -> Vec2
Graphene.Vec2.Vec2) Ptr Vec2
res
Triangle -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Triangle
t
Maybe Point3D -> (Point3D -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe Point3D
p Point3D -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
(Bool, Vec2) -> IO (Bool, Vec2)
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', Vec2
res')
#if defined(ENABLE_OVERLOADING)
data TriangleGetBarycoordsMethodInfo
instance (signature ~ (Maybe (Graphene.Point3D.Point3D) -> m ((Bool, Graphene.Vec2.Vec2))), MonadIO m) => O.MethodInfo TriangleGetBarycoordsMethodInfo Triangle signature where
overloadedMethod = triangleGetBarycoords
#endif
foreign import ccall "graphene_triangle_get_bounding_box" graphene_triangle_get_bounding_box ::
Ptr Triangle ->
Ptr Graphene.Box.Box ->
IO ()
triangleGetBoundingBox ::
(B.CallStack.HasCallStack, MonadIO m) =>
Triangle
-> m (Graphene.Box.Box)
triangleGetBoundingBox :: Triangle -> m Box
triangleGetBoundingBox Triangle
t = IO Box -> m Box
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Box -> m Box) -> IO Box -> m Box
forall a b. (a -> b) -> a -> b
$ do
Ptr Triangle
t' <- Triangle -> IO (Ptr Triangle)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Triangle
t
Ptr Box
res <- Int -> IO (Ptr Box)
forall a. GBoxed a => Int -> IO (Ptr a)
SP.callocBoxedBytes Int
32 :: IO (Ptr Graphene.Box.Box)
Ptr Triangle -> Ptr Box -> IO ()
graphene_triangle_get_bounding_box Ptr Triangle
t' Ptr Box
res
Box
res' <- ((ManagedPtr Box -> Box) -> Ptr Box -> IO Box
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Box -> Box
Graphene.Box.Box) Ptr Box
res
Triangle -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Triangle
t
Box -> IO Box
forall (m :: * -> *) a. Monad m => a -> m a
return Box
res'
#if defined(ENABLE_OVERLOADING)
data TriangleGetBoundingBoxMethodInfo
instance (signature ~ (m (Graphene.Box.Box)), MonadIO m) => O.MethodInfo TriangleGetBoundingBoxMethodInfo Triangle signature where
overloadedMethod = triangleGetBoundingBox
#endif
foreign import ccall "graphene_triangle_get_midpoint" graphene_triangle_get_midpoint ::
Ptr Triangle ->
Ptr Graphene.Point3D.Point3D ->
IO ()
triangleGetMidpoint ::
(B.CallStack.HasCallStack, MonadIO m) =>
Triangle
-> m (Graphene.Point3D.Point3D)
triangleGetMidpoint :: Triangle -> m Point3D
triangleGetMidpoint Triangle
t = IO Point3D -> m Point3D
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Point3D -> m Point3D) -> IO Point3D -> m Point3D
forall a b. (a -> b) -> a -> b
$ do
Ptr Triangle
t' <- Triangle -> IO (Ptr Triangle)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Triangle
t
Ptr Point3D
res <- Int -> IO (Ptr Point3D)
forall a. GBoxed a => Int -> IO (Ptr a)
SP.callocBoxedBytes Int
12 :: IO (Ptr Graphene.Point3D.Point3D)
Ptr Triangle -> Ptr Point3D -> IO ()
graphene_triangle_get_midpoint Ptr Triangle
t' Ptr Point3D
res
Point3D
res' <- ((ManagedPtr Point3D -> Point3D) -> Ptr Point3D -> IO Point3D
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Point3D -> Point3D
Graphene.Point3D.Point3D) Ptr Point3D
res
Triangle -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Triangle
t
Point3D -> IO Point3D
forall (m :: * -> *) a. Monad m => a -> m a
return Point3D
res'
#if defined(ENABLE_OVERLOADING)
data TriangleGetMidpointMethodInfo
instance (signature ~ (m (Graphene.Point3D.Point3D)), MonadIO m) => O.MethodInfo TriangleGetMidpointMethodInfo Triangle signature where
overloadedMethod = triangleGetMidpoint
#endif
foreign import ccall "graphene_triangle_get_normal" graphene_triangle_get_normal ::
Ptr Triangle ->
Ptr Graphene.Vec3.Vec3 ->
IO ()
triangleGetNormal ::
(B.CallStack.HasCallStack, MonadIO m) =>
Triangle
-> m (Graphene.Vec3.Vec3)
triangleGetNormal :: Triangle -> m Vec3
triangleGetNormal Triangle
t = 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 Triangle
t' <- Triangle -> IO (Ptr Triangle)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Triangle
t
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 Triangle -> Ptr Vec3 -> IO ()
graphene_triangle_get_normal Ptr Triangle
t' 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
Triangle -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Triangle
t
Vec3 -> IO Vec3
forall (m :: * -> *) a. Monad m => a -> m a
return Vec3
res'
#if defined(ENABLE_OVERLOADING)
data TriangleGetNormalMethodInfo
instance (signature ~ (m (Graphene.Vec3.Vec3)), MonadIO m) => O.MethodInfo TriangleGetNormalMethodInfo Triangle signature where
overloadedMethod = triangleGetNormal
#endif
foreign import ccall "graphene_triangle_get_plane" graphene_triangle_get_plane ::
Ptr Triangle ->
Ptr Graphene.Plane.Plane ->
IO ()
triangleGetPlane ::
(B.CallStack.HasCallStack, MonadIO m) =>
Triangle
-> m (Graphene.Plane.Plane)
triangleGetPlane :: Triangle -> m Plane
triangleGetPlane Triangle
t = IO Plane -> m Plane
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Plane -> m Plane) -> IO Plane -> m Plane
forall a b. (a -> b) -> a -> b
$ do
Ptr Triangle
t' <- Triangle -> IO (Ptr Triangle)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Triangle
t
Ptr Plane
res <- Int -> IO (Ptr Plane)
forall a. GBoxed a => Int -> IO (Ptr a)
SP.callocBoxedBytes Int
20 :: IO (Ptr Graphene.Plane.Plane)
Ptr Triangle -> Ptr Plane -> IO ()
graphene_triangle_get_plane Ptr Triangle
t' Ptr Plane
res
Plane
res' <- ((ManagedPtr Plane -> Plane) -> Ptr Plane -> IO Plane
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Plane -> Plane
Graphene.Plane.Plane) Ptr Plane
res
Triangle -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Triangle
t
Plane -> IO Plane
forall (m :: * -> *) a. Monad m => a -> m a
return Plane
res'
#if defined(ENABLE_OVERLOADING)
data TriangleGetPlaneMethodInfo
instance (signature ~ (m (Graphene.Plane.Plane)), MonadIO m) => O.MethodInfo TriangleGetPlaneMethodInfo Triangle signature where
overloadedMethod = triangleGetPlane
#endif
foreign import ccall "graphene_triangle_get_points" graphene_triangle_get_points ::
Ptr Triangle ->
Ptr Graphene.Point3D.Point3D ->
Ptr Graphene.Point3D.Point3D ->
Ptr Graphene.Point3D.Point3D ->
IO ()
triangleGetPoints ::
(B.CallStack.HasCallStack, MonadIO m) =>
Triangle
-> m ((Graphene.Point3D.Point3D, Graphene.Point3D.Point3D, Graphene.Point3D.Point3D))
triangleGetPoints :: Triangle -> m (Point3D, Point3D, Point3D)
triangleGetPoints Triangle
t = IO (Point3D, Point3D, Point3D) -> m (Point3D, Point3D, Point3D)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Point3D, Point3D, Point3D) -> m (Point3D, Point3D, Point3D))
-> IO (Point3D, Point3D, Point3D) -> m (Point3D, Point3D, Point3D)
forall a b. (a -> b) -> a -> b
$ do
Ptr Triangle
t' <- Triangle -> IO (Ptr Triangle)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Triangle
t
Ptr Point3D
a <- Int -> IO (Ptr Point3D)
forall a. GBoxed a => Int -> IO (Ptr a)
SP.callocBoxedBytes Int
12 :: IO (Ptr Graphene.Point3D.Point3D)
Ptr Point3D
b <- Int -> IO (Ptr Point3D)
forall a. GBoxed a => Int -> IO (Ptr a)
SP.callocBoxedBytes Int
12 :: IO (Ptr Graphene.Point3D.Point3D)
Ptr Point3D
c <- Int -> IO (Ptr Point3D)
forall a. GBoxed a => Int -> IO (Ptr a)
SP.callocBoxedBytes Int
12 :: IO (Ptr Graphene.Point3D.Point3D)
Ptr Triangle -> Ptr Point3D -> Ptr Point3D -> Ptr Point3D -> IO ()
graphene_triangle_get_points Ptr Triangle
t' Ptr Point3D
a Ptr Point3D
b Ptr Point3D
c
Point3D
a' <- ((ManagedPtr Point3D -> Point3D) -> Ptr Point3D -> IO Point3D
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Point3D -> Point3D
Graphene.Point3D.Point3D) Ptr Point3D
a
Point3D
b' <- ((ManagedPtr Point3D -> Point3D) -> Ptr Point3D -> IO Point3D
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Point3D -> Point3D
Graphene.Point3D.Point3D) Ptr Point3D
b
Point3D
c' <- ((ManagedPtr Point3D -> Point3D) -> Ptr Point3D -> IO Point3D
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Point3D -> Point3D
Graphene.Point3D.Point3D) Ptr Point3D
c
Triangle -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Triangle
t
(Point3D, Point3D, Point3D) -> IO (Point3D, Point3D, Point3D)
forall (m :: * -> *) a. Monad m => a -> m a
return (Point3D
a', Point3D
b', Point3D
c')
#if defined(ENABLE_OVERLOADING)
data TriangleGetPointsMethodInfo
instance (signature ~ (m ((Graphene.Point3D.Point3D, Graphene.Point3D.Point3D, Graphene.Point3D.Point3D))), MonadIO m) => O.MethodInfo TriangleGetPointsMethodInfo Triangle signature where
overloadedMethod = triangleGetPoints
#endif
foreign import ccall "graphene_triangle_get_uv" graphene_triangle_get_uv ::
Ptr Triangle ->
Ptr Graphene.Point3D.Point3D ->
Ptr Graphene.Vec2.Vec2 ->
Ptr Graphene.Vec2.Vec2 ->
Ptr Graphene.Vec2.Vec2 ->
Ptr Graphene.Vec2.Vec2 ->
IO CInt
triangleGetUv ::
(B.CallStack.HasCallStack, MonadIO m) =>
Triangle
-> Maybe (Graphene.Point3D.Point3D)
-> Graphene.Vec2.Vec2
-> Graphene.Vec2.Vec2
-> Graphene.Vec2.Vec2
-> m ((Bool, Graphene.Vec2.Vec2))
triangleGetUv :: Triangle -> Maybe Point3D -> Vec2 -> Vec2 -> Vec2 -> m (Bool, Vec2)
triangleGetUv Triangle
t Maybe Point3D
p Vec2
uvA Vec2
uvB Vec2
uvC = IO (Bool, Vec2) -> m (Bool, Vec2)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Vec2) -> m (Bool, Vec2))
-> IO (Bool, Vec2) -> m (Bool, Vec2)
forall a b. (a -> b) -> a -> b
$ do
Ptr Triangle
t' <- Triangle -> IO (Ptr Triangle)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Triangle
t
Ptr Point3D
maybeP <- case Maybe Point3D
p of
Maybe Point3D
Nothing -> Ptr Point3D -> IO (Ptr Point3D)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Point3D
forall a. Ptr a
nullPtr
Just Point3D
jP -> do
Ptr Point3D
jP' <- Point3D -> IO (Ptr Point3D)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Point3D
jP
Ptr Point3D -> IO (Ptr Point3D)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Point3D
jP'
Ptr Vec2
uvA' <- Vec2 -> IO (Ptr Vec2)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Vec2
uvA
Ptr Vec2
uvB' <- Vec2 -> IO (Ptr Vec2)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Vec2
uvB
Ptr Vec2
uvC' <- Vec2 -> IO (Ptr Vec2)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Vec2
uvC
Ptr Vec2
res <- Int -> IO (Ptr Vec2)
forall a. GBoxed a => Int -> IO (Ptr a)
SP.callocBoxedBytes Int
16 :: IO (Ptr Graphene.Vec2.Vec2)
CInt
result <- Ptr Triangle
-> Ptr Point3D
-> Ptr Vec2
-> Ptr Vec2
-> Ptr Vec2
-> Ptr Vec2
-> IO CInt
graphene_triangle_get_uv Ptr Triangle
t' Ptr Point3D
maybeP Ptr Vec2
uvA' Ptr Vec2
uvB' Ptr Vec2
uvC' Ptr Vec2
res
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
Vec2
res' <- ((ManagedPtr Vec2 -> Vec2) -> Ptr Vec2 -> IO Vec2
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Vec2 -> Vec2
Graphene.Vec2.Vec2) Ptr Vec2
res
Triangle -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Triangle
t
Maybe Point3D -> (Point3D -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe Point3D
p Point3D -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
Vec2 -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Vec2
uvA
Vec2 -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Vec2
uvB
Vec2 -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Vec2
uvC
(Bool, Vec2) -> IO (Bool, Vec2)
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', Vec2
res')
#if defined(ENABLE_OVERLOADING)
data TriangleGetUvMethodInfo
instance (signature ~ (Maybe (Graphene.Point3D.Point3D) -> Graphene.Vec2.Vec2 -> Graphene.Vec2.Vec2 -> Graphene.Vec2.Vec2 -> m ((Bool, Graphene.Vec2.Vec2))), MonadIO m) => O.MethodInfo TriangleGetUvMethodInfo Triangle signature where
overloadedMethod = triangleGetUv
#endif
foreign import ccall "graphene_triangle_get_vertices" graphene_triangle_get_vertices ::
Ptr Triangle ->
Ptr Graphene.Vec3.Vec3 ->
Ptr Graphene.Vec3.Vec3 ->
Ptr Graphene.Vec3.Vec3 ->
IO ()
triangleGetVertices ::
(B.CallStack.HasCallStack, MonadIO m) =>
Triangle
-> m ((Graphene.Vec3.Vec3, Graphene.Vec3.Vec3, Graphene.Vec3.Vec3))
triangleGetVertices :: Triangle -> m (Vec3, Vec3, Vec3)
triangleGetVertices Triangle
t = IO (Vec3, Vec3, Vec3) -> m (Vec3, Vec3, Vec3)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Vec3, Vec3, Vec3) -> m (Vec3, Vec3, Vec3))
-> IO (Vec3, Vec3, Vec3) -> m (Vec3, Vec3, Vec3)
forall a b. (a -> b) -> a -> b
$ do
Ptr Triangle
t' <- Triangle -> IO (Ptr Triangle)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Triangle
t
Ptr Vec3
a <- Int -> IO (Ptr Vec3)
forall a. GBoxed a => Int -> IO (Ptr a)
SP.callocBoxedBytes Int
16 :: IO (Ptr Graphene.Vec3.Vec3)
Ptr Vec3
b <- Int -> IO (Ptr Vec3)
forall a. GBoxed a => Int -> IO (Ptr a)
SP.callocBoxedBytes Int
16 :: IO (Ptr Graphene.Vec3.Vec3)
Ptr Vec3
c <- Int -> IO (Ptr Vec3)
forall a. GBoxed a => Int -> IO (Ptr a)
SP.callocBoxedBytes Int
16 :: IO (Ptr Graphene.Vec3.Vec3)
Ptr Triangle -> Ptr Vec3 -> Ptr Vec3 -> Ptr Vec3 -> IO ()
graphene_triangle_get_vertices Ptr Triangle
t' Ptr Vec3
a Ptr Vec3
b Ptr Vec3
c
Vec3
a' <- ((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
a
Vec3
b' <- ((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
b
Vec3
c' <- ((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
c
Triangle -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Triangle
t
(Vec3, Vec3, Vec3) -> IO (Vec3, Vec3, Vec3)
forall (m :: * -> *) a. Monad m => a -> m a
return (Vec3
a', Vec3
b', Vec3
c')
#if defined(ENABLE_OVERLOADING)
data TriangleGetVerticesMethodInfo
instance (signature ~ (m ((Graphene.Vec3.Vec3, Graphene.Vec3.Vec3, Graphene.Vec3.Vec3))), MonadIO m) => O.MethodInfo TriangleGetVerticesMethodInfo Triangle signature where
overloadedMethod = triangleGetVertices
#endif
foreign import ccall "graphene_triangle_init_from_float" graphene_triangle_init_from_float ::
Ptr Triangle ->
Ptr CFloat ->
Ptr CFloat ->
Ptr CFloat ->
IO (Ptr Triangle)
triangleInitFromFloat ::
(B.CallStack.HasCallStack, MonadIO m) =>
Triangle
-> [Float]
-> [Float]
-> [Float]
-> m Triangle
triangleInitFromFloat :: Triangle -> [Float] -> [Float] -> [Float] -> m Triangle
triangleInitFromFloat Triangle
t [Float]
a [Float]
b [Float]
c = IO Triangle -> m Triangle
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Triangle -> m Triangle) -> IO Triangle -> m Triangle
forall a b. (a -> b) -> a -> b
$ do
Ptr Triangle
t' <- Triangle -> IO (Ptr Triangle)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Triangle
t
Ptr CFloat
a' <- ((Float -> CFloat) -> [Float] -> IO (Ptr CFloat)
forall a b. Storable b => (a -> b) -> [a] -> IO (Ptr b)
packMapStorableArray Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac) [Float]
a
Ptr CFloat
b' <- ((Float -> CFloat) -> [Float] -> IO (Ptr CFloat)
forall a b. Storable b => (a -> b) -> [a] -> IO (Ptr b)
packMapStorableArray Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac) [Float]
b
Ptr CFloat
c' <- ((Float -> CFloat) -> [Float] -> IO (Ptr CFloat)
forall a b. Storable b => (a -> b) -> [a] -> IO (Ptr b)
packMapStorableArray Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac) [Float]
c
Ptr Triangle
result <- Ptr Triangle
-> Ptr CFloat -> Ptr CFloat -> Ptr CFloat -> IO (Ptr Triangle)
graphene_triangle_init_from_float Ptr Triangle
t' Ptr CFloat
a' Ptr CFloat
b' Ptr CFloat
c'
Text -> Ptr Triangle -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"triangleInitFromFloat" Ptr Triangle
result
Triangle
result' <- ((ManagedPtr Triangle -> Triangle) -> Ptr Triangle -> IO Triangle
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr Triangle -> Triangle
Triangle) Ptr Triangle
result
Triangle -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Triangle
t
Ptr CFloat -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CFloat
a'
Ptr CFloat -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CFloat
b'
Ptr CFloat -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CFloat
c'
Triangle -> IO Triangle
forall (m :: * -> *) a. Monad m => a -> m a
return Triangle
result'
#if defined(ENABLE_OVERLOADING)
data TriangleInitFromFloatMethodInfo
instance (signature ~ ([Float] -> [Float] -> [Float] -> m Triangle), MonadIO m) => O.MethodInfo TriangleInitFromFloatMethodInfo Triangle signature where
overloadedMethod = triangleInitFromFloat
#endif
foreign import ccall "graphene_triangle_init_from_point3d" graphene_triangle_init_from_point3d ::
Ptr Triangle ->
Ptr Graphene.Point3D.Point3D ->
Ptr Graphene.Point3D.Point3D ->
Ptr Graphene.Point3D.Point3D ->
IO (Ptr Triangle)
triangleInitFromPoint3d ::
(B.CallStack.HasCallStack, MonadIO m) =>
Triangle
-> Maybe (Graphene.Point3D.Point3D)
-> Maybe (Graphene.Point3D.Point3D)
-> Maybe (Graphene.Point3D.Point3D)
-> m Triangle
triangleInitFromPoint3d :: Triangle
-> Maybe Point3D -> Maybe Point3D -> Maybe Point3D -> m Triangle
triangleInitFromPoint3d Triangle
t Maybe Point3D
a Maybe Point3D
b Maybe Point3D
c = IO Triangle -> m Triangle
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Triangle -> m Triangle) -> IO Triangle -> m Triangle
forall a b. (a -> b) -> a -> b
$ do
Ptr Triangle
t' <- Triangle -> IO (Ptr Triangle)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Triangle
t
Ptr Point3D
maybeA <- case Maybe Point3D
a of
Maybe Point3D
Nothing -> Ptr Point3D -> IO (Ptr Point3D)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Point3D
forall a. Ptr a
nullPtr
Just Point3D
jA -> do
Ptr Point3D
jA' <- Point3D -> IO (Ptr Point3D)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Point3D
jA
Ptr Point3D -> IO (Ptr Point3D)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Point3D
jA'
Ptr Point3D
maybeB <- case Maybe Point3D
b of
Maybe Point3D
Nothing -> Ptr Point3D -> IO (Ptr Point3D)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Point3D
forall a. Ptr a
nullPtr
Just Point3D
jB -> do
Ptr Point3D
jB' <- Point3D -> IO (Ptr Point3D)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Point3D
jB
Ptr Point3D -> IO (Ptr Point3D)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Point3D
jB'
Ptr Point3D
maybeC <- case Maybe Point3D
c of
Maybe Point3D
Nothing -> Ptr Point3D -> IO (Ptr Point3D)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Point3D
forall a. Ptr a
nullPtr
Just Point3D
jC -> do
Ptr Point3D
jC' <- Point3D -> IO (Ptr Point3D)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Point3D
jC
Ptr Point3D -> IO (Ptr Point3D)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Point3D
jC'
Ptr Triangle
result <- Ptr Triangle
-> Ptr Point3D -> Ptr Point3D -> Ptr Point3D -> IO (Ptr Triangle)
graphene_triangle_init_from_point3d Ptr Triangle
t' Ptr Point3D
maybeA Ptr Point3D
maybeB Ptr Point3D
maybeC
Text -> Ptr Triangle -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"triangleInitFromPoint3d" Ptr Triangle
result
Triangle
result' <- ((ManagedPtr Triangle -> Triangle) -> Ptr Triangle -> IO Triangle
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr Triangle -> Triangle
Triangle) Ptr Triangle
result
Triangle -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Triangle
t
Maybe Point3D -> (Point3D -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe Point3D
a Point3D -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
Maybe Point3D -> (Point3D -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe Point3D
b Point3D -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
Maybe Point3D -> (Point3D -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe Point3D
c Point3D -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
Triangle -> IO Triangle
forall (m :: * -> *) a. Monad m => a -> m a
return Triangle
result'
#if defined(ENABLE_OVERLOADING)
data TriangleInitFromPoint3dMethodInfo
instance (signature ~ (Maybe (Graphene.Point3D.Point3D) -> Maybe (Graphene.Point3D.Point3D) -> Maybe (Graphene.Point3D.Point3D) -> m Triangle), MonadIO m) => O.MethodInfo TriangleInitFromPoint3dMethodInfo Triangle signature where
overloadedMethod = triangleInitFromPoint3d
#endif
foreign import ccall "graphene_triangle_init_from_vec3" graphene_triangle_init_from_vec3 ::
Ptr Triangle ->
Ptr Graphene.Vec3.Vec3 ->
Ptr Graphene.Vec3.Vec3 ->
Ptr Graphene.Vec3.Vec3 ->
IO (Ptr Triangle)
triangleInitFromVec3 ::
(B.CallStack.HasCallStack, MonadIO m) =>
Triangle
-> Maybe (Graphene.Vec3.Vec3)
-> Maybe (Graphene.Vec3.Vec3)
-> Maybe (Graphene.Vec3.Vec3)
-> m Triangle
triangleInitFromVec3 :: Triangle -> Maybe Vec3 -> Maybe Vec3 -> Maybe Vec3 -> m Triangle
triangleInitFromVec3 Triangle
t Maybe Vec3
a Maybe Vec3
b Maybe Vec3
c = IO Triangle -> m Triangle
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Triangle -> m Triangle) -> IO Triangle -> m Triangle
forall a b. (a -> b) -> a -> b
$ do
Ptr Triangle
t' <- Triangle -> IO (Ptr Triangle)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Triangle
t
Ptr Vec3
maybeA <- case Maybe Vec3
a 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
jA -> do
Ptr Vec3
jA' <- Vec3 -> IO (Ptr Vec3)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Vec3
jA
Ptr Vec3 -> IO (Ptr Vec3)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Vec3
jA'
Ptr Vec3
maybeB <- case Maybe Vec3
b 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
jB -> do
Ptr Vec3
jB' <- Vec3 -> IO (Ptr Vec3)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Vec3
jB
Ptr Vec3 -> IO (Ptr Vec3)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Vec3
jB'
Ptr Vec3
maybeC <- case Maybe Vec3
c 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
jC -> do
Ptr Vec3
jC' <- Vec3 -> IO (Ptr Vec3)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Vec3
jC
Ptr Vec3 -> IO (Ptr Vec3)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Vec3
jC'
Ptr Triangle
result <- Ptr Triangle
-> Ptr Vec3 -> Ptr Vec3 -> Ptr Vec3 -> IO (Ptr Triangle)
graphene_triangle_init_from_vec3 Ptr Triangle
t' Ptr Vec3
maybeA Ptr Vec3
maybeB Ptr Vec3
maybeC
Text -> Ptr Triangle -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"triangleInitFromVec3" Ptr Triangle
result
Triangle
result' <- ((ManagedPtr Triangle -> Triangle) -> Ptr Triangle -> IO Triangle
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr Triangle -> Triangle
Triangle) Ptr Triangle
result
Triangle -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Triangle
t
Maybe Vec3 -> (Vec3 -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe Vec3
a Vec3 -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
Maybe Vec3 -> (Vec3 -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe Vec3
b Vec3 -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
Maybe Vec3 -> (Vec3 -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe Vec3
c Vec3 -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
Triangle -> IO Triangle
forall (m :: * -> *) a. Monad m => a -> m a
return Triangle
result'
#if defined(ENABLE_OVERLOADING)
data TriangleInitFromVec3MethodInfo
instance (signature ~ (Maybe (Graphene.Vec3.Vec3) -> Maybe (Graphene.Vec3.Vec3) -> Maybe (Graphene.Vec3.Vec3) -> m Triangle), MonadIO m) => O.MethodInfo TriangleInitFromVec3MethodInfo Triangle signature where
overloadedMethod = triangleInitFromVec3
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveTriangleMethod (t :: Symbol) (o :: *) :: * where
ResolveTriangleMethod "containsPoint" o = TriangleContainsPointMethodInfo
ResolveTriangleMethod "equal" o = TriangleEqualMethodInfo
ResolveTriangleMethod "free" o = TriangleFreeMethodInfo
ResolveTriangleMethod "initFromFloat" o = TriangleInitFromFloatMethodInfo
ResolveTriangleMethod "initFromPoint3d" o = TriangleInitFromPoint3dMethodInfo
ResolveTriangleMethod "initFromVec3" o = TriangleInitFromVec3MethodInfo
ResolveTriangleMethod "getArea" o = TriangleGetAreaMethodInfo
ResolveTriangleMethod "getBarycoords" o = TriangleGetBarycoordsMethodInfo
ResolveTriangleMethod "getBoundingBox" o = TriangleGetBoundingBoxMethodInfo
ResolveTriangleMethod "getMidpoint" o = TriangleGetMidpointMethodInfo
ResolveTriangleMethod "getNormal" o = TriangleGetNormalMethodInfo
ResolveTriangleMethod "getPlane" o = TriangleGetPlaneMethodInfo
ResolveTriangleMethod "getPoints" o = TriangleGetPointsMethodInfo
ResolveTriangleMethod "getUv" o = TriangleGetUvMethodInfo
ResolveTriangleMethod "getVertices" o = TriangleGetVerticesMethodInfo
ResolveTriangleMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveTriangleMethod t Triangle, O.MethodInfo info Triangle p) => OL.IsLabel t (Triangle -> p) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.overloadedMethod @info
#else
fromLabel _ = O.overloadedMethod @info
#endif
#endif