{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- A triangle.
-- 
-- /Since: 1.2/

#if !defined(__HADDOCK_VERSION__)
#define ENABLE_OVERLOADING
#endif

module GI.Graphene.Structs.Triangle
    ( 

-- * Exported types
    Triangle(..)                            ,
    newZeroTriangle                         ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [containsPoint]("GI.Graphene.Structs.Triangle#g:method:containsPoint"), [equal]("GI.Graphene.Structs.Triangle#g:method:equal"), [free]("GI.Graphene.Structs.Triangle#g:method:free"), [initFromFloat]("GI.Graphene.Structs.Triangle#g:method:initFromFloat"), [initFromPoint3d]("GI.Graphene.Structs.Triangle#g:method:initFromPoint3d"), [initFromVec3]("GI.Graphene.Structs.Triangle#g:method:initFromVec3").
-- 
-- ==== Getters
-- [getArea]("GI.Graphene.Structs.Triangle#g:method:getArea"), [getBarycoords]("GI.Graphene.Structs.Triangle#g:method:getBarycoords"), [getBoundingBox]("GI.Graphene.Structs.Triangle#g:method:getBoundingBox"), [getMidpoint]("GI.Graphene.Structs.Triangle#g:method:getMidpoint"), [getNormal]("GI.Graphene.Structs.Triangle#g:method:getNormal"), [getPlane]("GI.Graphene.Structs.Triangle#g:method:getPlane"), [getPoints]("GI.Graphene.Structs.Triangle#g:method:getPoints"), [getUv]("GI.Graphene.Structs.Triangle#g:method:getUv"), [getVertices]("GI.Graphene.Structs.Triangle#g:method:getVertices").
-- 
-- ==== Setters
-- /None/.

#if defined(ENABLE_OVERLOADING)
    ResolveTriangleMethod                   ,
#endif

-- ** alloc #method:alloc#

    triangleAlloc                           ,


-- ** containsPoint #method:containsPoint#

#if defined(ENABLE_OVERLOADING)
    TriangleContainsPointMethodInfo         ,
#endif
    triangleContainsPoint                   ,


-- ** equal #method:equal#

#if defined(ENABLE_OVERLOADING)
    TriangleEqualMethodInfo                 ,
#endif
    triangleEqual                           ,


-- ** free #method:free#

#if defined(ENABLE_OVERLOADING)
    TriangleFreeMethodInfo                  ,
#endif
    triangleFree                            ,


-- ** getArea #method:getArea#

#if defined(ENABLE_OVERLOADING)
    TriangleGetAreaMethodInfo               ,
#endif
    triangleGetArea                         ,


-- ** getBarycoords #method:getBarycoords#

#if defined(ENABLE_OVERLOADING)
    TriangleGetBarycoordsMethodInfo         ,
#endif
    triangleGetBarycoords                   ,


-- ** getBoundingBox #method:getBoundingBox#

#if defined(ENABLE_OVERLOADING)
    TriangleGetBoundingBoxMethodInfo        ,
#endif
    triangleGetBoundingBox                  ,


-- ** getMidpoint #method:getMidpoint#

#if defined(ENABLE_OVERLOADING)
    TriangleGetMidpointMethodInfo           ,
#endif
    triangleGetMidpoint                     ,


-- ** getNormal #method:getNormal#

#if defined(ENABLE_OVERLOADING)
    TriangleGetNormalMethodInfo             ,
#endif
    triangleGetNormal                       ,


-- ** getPlane #method:getPlane#

#if defined(ENABLE_OVERLOADING)
    TriangleGetPlaneMethodInfo              ,
#endif
    triangleGetPlane                        ,


-- ** getPoints #method:getPoints#

#if defined(ENABLE_OVERLOADING)
    TriangleGetPointsMethodInfo             ,
#endif
    triangleGetPoints                       ,


-- ** getUv #method:getUv#

#if defined(ENABLE_OVERLOADING)
    TriangleGetUvMethodInfo                 ,
#endif
    triangleGetUv                           ,


-- ** getVertices #method:getVertices#

#if defined(ENABLE_OVERLOADING)
    TriangleGetVerticesMethodInfo           ,
#endif
    triangleGetVertices                     ,


-- ** initFromFloat #method:initFromFloat#

#if defined(ENABLE_OVERLOADING)
    TriangleInitFromFloatMethodInfo         ,
#endif
    triangleInitFromFloat                   ,


-- ** initFromPoint3d #method:initFromPoint3d#

#if defined(ENABLE_OVERLOADING)
    TriangleInitFromPoint3dMethodInfo       ,
#endif
    triangleInitFromPoint3d                 ,


-- ** initFromVec3 #method:initFromVec3#

#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.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GHashTable as B.GHT
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Coerce as Coerce
import qualified Data.Text as T
import qualified Data.Kind as DK
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GHC.Records as R
import qualified Data.Word as DW
import qualified Data.Int as DI
import qualified System.Posix.Types as SPT
import qualified Foreign.C.Types as FCT

-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392
#if MIN_VERSION_base(4,18,0)
import {-# SOURCE #-} qualified GI.Graphene.Enums as Graphene.Enums
import {-# SOURCE #-} qualified GI.Graphene.Structs.Box as Graphene.Box
import {-# SOURCE #-} qualified GI.Graphene.Structs.Euler as Graphene.Euler
import {-# SOURCE #-} qualified GI.Graphene.Structs.Matrix as Graphene.Matrix
import {-# SOURCE #-} qualified GI.Graphene.Structs.Plane as Graphene.Plane
import {-# SOURCE #-} qualified GI.Graphene.Structs.Point as Graphene.Point
import {-# SOURCE #-} qualified GI.Graphene.Structs.Point3D as Graphene.Point3D
import {-# SOURCE #-} qualified GI.Graphene.Structs.Quad as Graphene.Quad
import {-# SOURCE #-} qualified GI.Graphene.Structs.Quaternion as Graphene.Quaternion
import {-# SOURCE #-} qualified GI.Graphene.Structs.Ray as Graphene.Ray
import {-# SOURCE #-} qualified GI.Graphene.Structs.Rect as Graphene.Rect
import {-# SOURCE #-} qualified GI.Graphene.Structs.Size as Graphene.Size
import {-# SOURCE #-} qualified GI.Graphene.Structs.Sphere as Graphene.Sphere
import {-# SOURCE #-} qualified GI.Graphene.Structs.Vec2 as Graphene.Vec2
import {-# SOURCE #-} qualified GI.Graphene.Structs.Vec3 as Graphene.Vec3
import {-# SOURCE #-} qualified GI.Graphene.Structs.Vec4 as Graphene.Vec4

#else
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

#endif

-- | Memory-managed wrapper type.
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
$c== :: Triangle -> Triangle -> Bool
== :: Triangle -> Triangle -> Bool
$c/= :: Triangle -> Triangle -> Bool
/= :: 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

-- | Convert t'Triangle' to and from 'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue (Maybe Triangle) where
    gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_graphene_triangle_get_type
    gvalueSet_ :: Ptr GValue -> Maybe Triangle -> IO ()
gvalueSet_ Ptr GValue
gv Maybe Triangle
P.Nothing = Ptr GValue -> Ptr Triangle -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv (Ptr Triangle
forall a. Ptr a
FP.nullPtr :: FP.Ptr Triangle)
    gvalueSet_ Ptr GValue
gv (P.Just Triangle
obj) = Triangle -> (Ptr Triangle -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr Triangle
obj (Ptr GValue -> Ptr Triangle -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv)
    gvalueGet_ :: Ptr GValue -> IO (Maybe Triangle)
gvalueGet_ Ptr GValue
gv = do
        ptr <- Ptr GValue -> IO (Ptr Triangle)
forall b. Ptr GValue -> IO (Ptr b)
B.GValue.get_boxed Ptr GValue
gv :: IO (Ptr Triangle)
        if ptr /= FP.nullPtr
        then P.Just <$> B.ManagedPtr.newBoxed Triangle ptr
        else return P.Nothing
        
    

-- | Construct a t'Triangle' struct initialized to zero.
newZeroTriangle :: MonadIO m => m Triangle
newZeroTriangle :: forall (m :: * -> *). MonadIO m => m Triangle
newZeroTriangle = IO Triangle -> m Triangle
forall a. IO a -> m a
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 a b. IO a -> (a -> IO b) -> IO b
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 :: forall (m :: * -> *).
MonadIO m =>
(ManagedPtr Triangle -> Triangle)
-> [AttrOp Triangle tag] -> m Triangle
new ManagedPtr Triangle -> Triangle
_ [AttrOp Triangle tag]
attrs = do
        o <- m Triangle
forall (m :: * -> *). MonadIO m => m Triangle
newZeroTriangle
        GI.Attributes.set o attrs
        return o



#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Triangle
type instance O.AttributeList Triangle = TriangleAttributeList
type TriangleAttributeList = ('[ ] :: [(Symbol, DK.Type)])
#endif

-- method Triangle::alloc
-- method type : Constructor
-- Args: []
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "Graphene" , name = "Triangle" })
-- throws : False
-- Skip return : False

foreign import ccall "graphene_triangle_alloc" graphene_triangle_alloc :: 
    IO (Ptr Triangle)

-- | Allocates a new t'GI.Graphene.Structs.Triangle.Triangle'.
-- 
-- The contents of the returned structure are undefined.
-- 
-- /Since: 1.2/
triangleAlloc ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m Triangle
    -- ^ __Returns:__ the newly allocated t'GI.Graphene.Structs.Triangle.Triangle'
    --   structure. Use 'GI.Graphene.Structs.Triangle.triangleFree' to free the resources
    --   allocated by this function
triangleAlloc :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m Triangle
triangleAlloc  = IO Triangle -> m Triangle
forall a. IO a -> m a
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
    result <- IO (Ptr Triangle)
graphene_triangle_alloc
    checkUnexpectedReturnNULL "triangleAlloc" result
    result' <- (wrapBoxed Triangle) result
    return result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method Triangle::contains_point
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "t"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Triangle" }
--           , argCType = Just "const graphene_triangle_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_triangle_t"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "p"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Point3D" }
--           , argCType = Just "const graphene_point3d_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_point3d_t"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "graphene_triangle_contains_point" graphene_triangle_contains_point :: 
    Ptr Triangle ->                         -- t : TInterface (Name {namespace = "Graphene", name = "Triangle"})
    Ptr Graphene.Point3D.Point3D ->         -- p : TInterface (Name {namespace = "Graphene", name = "Point3D"})
    IO CInt

-- | Checks whether the given triangle /@t@/ contains the point /@p@/.
-- 
-- /Since: 1.2/
triangleContainsPoint ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Triangle
    -- ^ /@t@/: a t'GI.Graphene.Structs.Triangle.Triangle'
    -> Graphene.Point3D.Point3D
    -- ^ /@p@/: a t'GI.Graphene.Structs.Point3D.Point3D'
    -> m Bool
    -- ^ __Returns:__ @true@ if the point is inside the triangle
triangleContainsPoint :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Triangle -> Point3D -> m Bool
triangleContainsPoint Triangle
t Point3D
p = 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
    t' <- Triangle -> IO (Ptr Triangle)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Triangle
t
    p' <- unsafeManagedPtrGetPtr p
    result <- graphene_triangle_contains_point t' p'
    let result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    touchManagedPtr t
    touchManagedPtr p
    return result'

#if defined(ENABLE_OVERLOADING)
data TriangleContainsPointMethodInfo
instance (signature ~ (Graphene.Point3D.Point3D -> m Bool), MonadIO m) => O.OverloadedMethod TriangleContainsPointMethodInfo Triangle signature where
    overloadedMethod = triangleContainsPoint

instance O.OverloadedMethodInfo TriangleContainsPointMethodInfo Triangle where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Graphene.Structs.Triangle.triangleContainsPoint",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-graphene-1.0.8/docs/GI-Graphene-Structs-Triangle.html#v:triangleContainsPoint"
        })


#endif

-- method Triangle::equal
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "a"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Triangle" }
--           , argCType = Just "const graphene_triangle_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_triangle_t"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "b"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Triangle" }
--           , argCType = Just "const graphene_triangle_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_triangle_t"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "graphene_triangle_equal" graphene_triangle_equal :: 
    Ptr Triangle ->                         -- a : TInterface (Name {namespace = "Graphene", name = "Triangle"})
    Ptr Triangle ->                         -- b : TInterface (Name {namespace = "Graphene", name = "Triangle"})
    IO CInt

-- | Checks whether the two given t'GI.Graphene.Structs.Triangle.Triangle' are equal.
-- 
-- /Since: 1.2/
triangleEqual ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Triangle
    -- ^ /@a@/: a t'GI.Graphene.Structs.Triangle.Triangle'
    -> Triangle
    -- ^ /@b@/: a t'GI.Graphene.Structs.Triangle.Triangle'
    -> m Bool
    -- ^ __Returns:__ @true@ if the triangles are equal
triangleEqual :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Triangle -> Triangle -> m Bool
triangleEqual Triangle
a Triangle
b = 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
    a' <- Triangle -> IO (Ptr Triangle)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Triangle
a
    b' <- unsafeManagedPtrGetPtr b
    result <- graphene_triangle_equal a' b'
    let result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    touchManagedPtr a
    touchManagedPtr b
    return result'

#if defined(ENABLE_OVERLOADING)
data TriangleEqualMethodInfo
instance (signature ~ (Triangle -> m Bool), MonadIO m) => O.OverloadedMethod TriangleEqualMethodInfo Triangle signature where
    overloadedMethod = triangleEqual

instance O.OverloadedMethodInfo TriangleEqualMethodInfo Triangle where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Graphene.Structs.Triangle.triangleEqual",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-graphene-1.0.8/docs/GI-Graphene-Structs-Triangle.html#v:triangleEqual"
        })


#endif

-- method Triangle::free
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "t"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Triangle" }
--           , argCType = Just "graphene_triangle_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_triangle_t"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "graphene_triangle_free" graphene_triangle_free :: 
    Ptr Triangle ->                         -- t : TInterface (Name {namespace = "Graphene", name = "Triangle"})
    IO ()

-- | Frees the resources allocated by 'GI.Graphene.Structs.Triangle.triangleAlloc'.
-- 
-- /Since: 1.2/
triangleFree ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Triangle
    -- ^ /@t@/: a t'GI.Graphene.Structs.Triangle.Triangle'
    -> m ()
triangleFree :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Triangle -> m ()
triangleFree Triangle
t = 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
    t' <- Triangle -> IO (Ptr Triangle)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Triangle
t
    graphene_triangle_free t'
    touchManagedPtr t
    return ()

#if defined(ENABLE_OVERLOADING)
data TriangleFreeMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod TriangleFreeMethodInfo Triangle signature where
    overloadedMethod = triangleFree

instance O.OverloadedMethodInfo TriangleFreeMethodInfo Triangle where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Graphene.Structs.Triangle.triangleFree",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-graphene-1.0.8/docs/GI-Graphene-Structs-Triangle.html#v:triangleFree"
        })


#endif

-- method Triangle::get_area
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "t"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Triangle" }
--           , argCType = Just "const graphene_triangle_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_triangle_t"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TFloat)
-- throws : False
-- Skip return : False

foreign import ccall "graphene_triangle_get_area" graphene_triangle_get_area :: 
    Ptr Triangle ->                         -- t : TInterface (Name {namespace = "Graphene", name = "Triangle"})
    IO CFloat

-- | Computes the area of the given t'GI.Graphene.Structs.Triangle.Triangle'.
-- 
-- /Since: 1.2/
triangleGetArea ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Triangle
    -- ^ /@t@/: a t'GI.Graphene.Structs.Triangle.Triangle'
    -> m Float
    -- ^ __Returns:__ the area of the triangle
triangleGetArea :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Triangle -> m Float
triangleGetArea Triangle
t = IO Float -> m Float
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Float -> m Float) -> IO Float -> m Float
forall a b. (a -> b) -> a -> b
$ do
    t' <- Triangle -> IO (Ptr Triangle)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Triangle
t
    result <- graphene_triangle_get_area t'
    let result' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
result
    touchManagedPtr t
    return result'

#if defined(ENABLE_OVERLOADING)
data TriangleGetAreaMethodInfo
instance (signature ~ (m Float), MonadIO m) => O.OverloadedMethod TriangleGetAreaMethodInfo Triangle signature where
    overloadedMethod = triangleGetArea

instance O.OverloadedMethodInfo TriangleGetAreaMethodInfo Triangle where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Graphene.Structs.Triangle.triangleGetArea",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-graphene-1.0.8/docs/GI-Graphene-Structs-Triangle.html#v:triangleGetArea"
        })


#endif

-- method Triangle::get_barycoords
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "t"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Triangle" }
--           , argCType = Just "const graphene_triangle_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_triangle_t"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "p"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Point3D" }
--           , argCType = Just "const graphene_point3d_t*"
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_point3d_t"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "res"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Vec2" }
--           , argCType = Just "graphene_vec2_t*"
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "return location for the vector\n  with the barycentric coordinates"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = True
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "graphene_triangle_get_barycoords" graphene_triangle_get_barycoords :: 
    Ptr Triangle ->                         -- t : TInterface (Name {namespace = "Graphene", name = "Triangle"})
    Ptr Graphene.Point3D.Point3D ->         -- p : TInterface (Name {namespace = "Graphene", name = "Point3D"})
    Ptr Graphene.Vec2.Vec2 ->               -- res : TInterface (Name {namespace = "Graphene", name = "Vec2"})
    IO CInt

-- | Computes the <http://en.wikipedia.org/wiki/Barycentric_coordinate_system barycentric coordinates>
-- of the given point /@p@/.
-- 
-- The point /@p@/ must lie on the same plane as the triangle /@t@/; if the
-- point is not coplanar, the result of this function is undefined.
-- 
-- If we place the origin in the coordinates of the triangle\'s A point,
-- the barycentric coordinates are @u@, which is on the AC vector; and @v@
-- which is on the AB vector:
-- 
-- <<http://developer.gnome.org/graphene/stable/triangle-barycentric.png>>
-- 
-- The returned t'GI.Graphene.Structs.Vec2.Vec2' contains the following values, in order:
-- 
-- * @res.x = u@
-- * @res.y = v@
-- 
-- 
-- /Since: 1.2/
triangleGetBarycoords ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Triangle
    -- ^ /@t@/: a t'GI.Graphene.Structs.Triangle.Triangle'
    -> Maybe (Graphene.Point3D.Point3D)
    -- ^ /@p@/: a t'GI.Graphene.Structs.Point3D.Point3D'
    -> m ((Bool, Graphene.Vec2.Vec2))
    -- ^ __Returns:__ @true@ if the barycentric coordinates are valid
triangleGetBarycoords :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Triangle -> Maybe Point3D -> m (Bool, Vec2)
triangleGetBarycoords Triangle
t Maybe Point3D
p = IO (Bool, Vec2) -> m (Bool, Vec2)
forall a. IO a -> m a
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
    t' <- Triangle -> IO (Ptr Triangle)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Triangle
t
    maybeP <- case p of
        Maybe Point3D
Nothing -> Ptr Point3D -> IO (Ptr Point3D)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Point3D
forall a. Ptr a
FP.nullPtr
        Just Point3D
jP -> do
            jP' <- Point3D -> IO (Ptr Point3D)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Point3D
jP
            return jP'
    res <- SP.callocBoxedBytes 16 :: IO (Ptr Graphene.Vec2.Vec2)
    result <- graphene_triangle_get_barycoords t' maybeP res
    let result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    res' <- (wrapBoxed Graphene.Vec2.Vec2) res
    touchManagedPtr t
    whenJust p touchManagedPtr
    return (result', res')

#if defined(ENABLE_OVERLOADING)
data TriangleGetBarycoordsMethodInfo
instance (signature ~ (Maybe (Graphene.Point3D.Point3D) -> m ((Bool, Graphene.Vec2.Vec2))), MonadIO m) => O.OverloadedMethod TriangleGetBarycoordsMethodInfo Triangle signature where
    overloadedMethod = triangleGetBarycoords

instance O.OverloadedMethodInfo TriangleGetBarycoordsMethodInfo Triangle where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Graphene.Structs.Triangle.triangleGetBarycoords",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-graphene-1.0.8/docs/GI-Graphene-Structs-Triangle.html#v:triangleGetBarycoords"
        })


#endif

-- method Triangle::get_bounding_box
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "t"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Triangle" }
--           , argCType = Just "const graphene_triangle_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_triangle_t"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "res"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Box" }
--           , argCType = Just "graphene_box_t*"
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "return location for the box"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = True
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "graphene_triangle_get_bounding_box" graphene_triangle_get_bounding_box :: 
    Ptr Triangle ->                         -- t : TInterface (Name {namespace = "Graphene", name = "Triangle"})
    Ptr Graphene.Box.Box ->                 -- res : TInterface (Name {namespace = "Graphene", name = "Box"})
    IO ()

-- | Computes the bounding box of the given t'GI.Graphene.Structs.Triangle.Triangle'.
-- 
-- /Since: 1.2/
triangleGetBoundingBox ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Triangle
    -- ^ /@t@/: a t'GI.Graphene.Structs.Triangle.Triangle'
    -> m (Graphene.Box.Box)
triangleGetBoundingBox :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Triangle -> m Box
triangleGetBoundingBox Triangle
t = IO Box -> m Box
forall a. IO a -> m a
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
    t' <- Triangle -> IO (Ptr Triangle)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Triangle
t
    res <- SP.callocBoxedBytes 32 :: IO (Ptr Graphene.Box.Box)
    graphene_triangle_get_bounding_box t' res
    res' <- (wrapBoxed Graphene.Box.Box) res
    touchManagedPtr t
    return res'

#if defined(ENABLE_OVERLOADING)
data TriangleGetBoundingBoxMethodInfo
instance (signature ~ (m (Graphene.Box.Box)), MonadIO m) => O.OverloadedMethod TriangleGetBoundingBoxMethodInfo Triangle signature where
    overloadedMethod = triangleGetBoundingBox

instance O.OverloadedMethodInfo TriangleGetBoundingBoxMethodInfo Triangle where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Graphene.Structs.Triangle.triangleGetBoundingBox",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-graphene-1.0.8/docs/GI-Graphene-Structs-Triangle.html#v:triangleGetBoundingBox"
        })


#endif

-- method Triangle::get_midpoint
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "t"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Triangle" }
--           , argCType = Just "const graphene_triangle_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_triangle_t"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "res"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Point3D" }
--           , argCType = Just "graphene_point3d_t*"
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "return location for the coordinates of\n  the midpoint"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = True
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "graphene_triangle_get_midpoint" graphene_triangle_get_midpoint :: 
    Ptr Triangle ->                         -- t : TInterface (Name {namespace = "Graphene", name = "Triangle"})
    Ptr Graphene.Point3D.Point3D ->         -- res : TInterface (Name {namespace = "Graphene", name = "Point3D"})
    IO ()

-- | Computes the coordinates of the midpoint of the given t'GI.Graphene.Structs.Triangle.Triangle'.
-- 
-- The midpoint G is the <https://en.wikipedia.org/wiki/Centroid#Triangle_centroid centroid>
-- of the triangle, i.e. the intersection of its medians.
-- 
-- /Since: 1.2/
triangleGetMidpoint ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Triangle
    -- ^ /@t@/: a t'GI.Graphene.Structs.Triangle.Triangle'
    -> m (Graphene.Point3D.Point3D)
triangleGetMidpoint :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Triangle -> m Point3D
triangleGetMidpoint Triangle
t = IO Point3D -> m Point3D
forall a. IO a -> m a
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
    t' <- Triangle -> IO (Ptr Triangle)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Triangle
t
    res <- SP.callocBoxedBytes 12 :: IO (Ptr Graphene.Point3D.Point3D)
    graphene_triangle_get_midpoint t' res
    res' <- (wrapBoxed Graphene.Point3D.Point3D) res
    touchManagedPtr t
    return res'

#if defined(ENABLE_OVERLOADING)
data TriangleGetMidpointMethodInfo
instance (signature ~ (m (Graphene.Point3D.Point3D)), MonadIO m) => O.OverloadedMethod TriangleGetMidpointMethodInfo Triangle signature where
    overloadedMethod = triangleGetMidpoint

instance O.OverloadedMethodInfo TriangleGetMidpointMethodInfo Triangle where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Graphene.Structs.Triangle.triangleGetMidpoint",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-graphene-1.0.8/docs/GI-Graphene-Structs-Triangle.html#v:triangleGetMidpoint"
        })


#endif

-- method Triangle::get_normal
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "t"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Triangle" }
--           , argCType = Just "const graphene_triangle_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_triangle_t"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "res"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Vec3" }
--           , argCType = Just "graphene_vec3_t*"
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "return location for the normal vector"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = True
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "graphene_triangle_get_normal" graphene_triangle_get_normal :: 
    Ptr Triangle ->                         -- t : TInterface (Name {namespace = "Graphene", name = "Triangle"})
    Ptr Graphene.Vec3.Vec3 ->               -- res : TInterface (Name {namespace = "Graphene", name = "Vec3"})
    IO ()

-- | Computes the normal vector of the given t'GI.Graphene.Structs.Triangle.Triangle'.
-- 
-- /Since: 1.2/
triangleGetNormal ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Triangle
    -- ^ /@t@/: a t'GI.Graphene.Structs.Triangle.Triangle'
    -> m (Graphene.Vec3.Vec3)
triangleGetNormal :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Triangle -> m Vec3
triangleGetNormal Triangle
t = IO Vec3 -> m Vec3
forall a. IO a -> m a
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
    t' <- Triangle -> IO (Ptr Triangle)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Triangle
t
    res <- SP.callocBoxedBytes 16 :: IO (Ptr Graphene.Vec3.Vec3)
    graphene_triangle_get_normal t' res
    res' <- (wrapBoxed Graphene.Vec3.Vec3) res
    touchManagedPtr t
    return res'

#if defined(ENABLE_OVERLOADING)
data TriangleGetNormalMethodInfo
instance (signature ~ (m (Graphene.Vec3.Vec3)), MonadIO m) => O.OverloadedMethod TriangleGetNormalMethodInfo Triangle signature where
    overloadedMethod = triangleGetNormal

instance O.OverloadedMethodInfo TriangleGetNormalMethodInfo Triangle where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Graphene.Structs.Triangle.triangleGetNormal",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-graphene-1.0.8/docs/GI-Graphene-Structs-Triangle.html#v:triangleGetNormal"
        })


#endif

-- method Triangle::get_plane
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "t"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Triangle" }
--           , argCType = Just "const graphene_triangle_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_triangle_t"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "res"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Plane" }
--           , argCType = Just "graphene_plane_t*"
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "return location for the plane"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = True
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "graphene_triangle_get_plane" graphene_triangle_get_plane :: 
    Ptr Triangle ->                         -- t : TInterface (Name {namespace = "Graphene", name = "Triangle"})
    Ptr Graphene.Plane.Plane ->             -- res : TInterface (Name {namespace = "Graphene", name = "Plane"})
    IO ()

-- | Computes the plane based on the vertices of the given t'GI.Graphene.Structs.Triangle.Triangle'.
-- 
-- /Since: 1.2/
triangleGetPlane ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Triangle
    -- ^ /@t@/: a t'GI.Graphene.Structs.Triangle.Triangle'
    -> m (Graphene.Plane.Plane)
triangleGetPlane :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Triangle -> m Plane
triangleGetPlane Triangle
t = IO Plane -> m Plane
forall a. IO a -> m a
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
    t' <- Triangle -> IO (Ptr Triangle)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Triangle
t
    res <- SP.callocBoxedBytes 20 :: IO (Ptr Graphene.Plane.Plane)
    graphene_triangle_get_plane t' res
    res' <- (wrapBoxed Graphene.Plane.Plane) res
    touchManagedPtr t
    return res'

#if defined(ENABLE_OVERLOADING)
data TriangleGetPlaneMethodInfo
instance (signature ~ (m (Graphene.Plane.Plane)), MonadIO m) => O.OverloadedMethod TriangleGetPlaneMethodInfo Triangle signature where
    overloadedMethod = triangleGetPlane

instance O.OverloadedMethodInfo TriangleGetPlaneMethodInfo Triangle where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Graphene.Structs.Triangle.triangleGetPlane",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-graphene-1.0.8/docs/GI-Graphene-Structs-Triangle.html#v:triangleGetPlane"
        })


#endif

-- method Triangle::get_points
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "t"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Triangle" }
--           , argCType = Just "const graphene_triangle_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_triangle_t"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "a"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Point3D" }
--           , argCType = Just "graphene_point3d_t*"
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "return location for the coordinates\n  of the first vertex"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = True
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "b"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Point3D" }
--           , argCType = Just "graphene_point3d_t*"
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "return location for the coordinates\n  of the second vertex"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = True
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "c"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Point3D" }
--           , argCType = Just "graphene_point3d_t*"
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "return location for the coordinates\n  of the third vertex"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = True
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "graphene_triangle_get_points" graphene_triangle_get_points :: 
    Ptr Triangle ->                         -- t : TInterface (Name {namespace = "Graphene", name = "Triangle"})
    Ptr Graphene.Point3D.Point3D ->         -- a : TInterface (Name {namespace = "Graphene", name = "Point3D"})
    Ptr Graphene.Point3D.Point3D ->         -- b : TInterface (Name {namespace = "Graphene", name = "Point3D"})
    Ptr Graphene.Point3D.Point3D ->         -- c : TInterface (Name {namespace = "Graphene", name = "Point3D"})
    IO ()

-- | Retrieves the three vertices of the given t'GI.Graphene.Structs.Triangle.Triangle' and returns
-- their coordinates as t'GI.Graphene.Structs.Point3D.Point3D'.
-- 
-- /Since: 1.2/
triangleGetPoints ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Triangle
    -- ^ /@t@/: a t'GI.Graphene.Structs.Triangle.Triangle'
    -> m ((Graphene.Point3D.Point3D, Graphene.Point3D.Point3D, Graphene.Point3D.Point3D))
triangleGetPoints :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Triangle -> m (Point3D, Point3D, Point3D)
triangleGetPoints Triangle
t = IO (Point3D, Point3D, Point3D) -> m (Point3D, Point3D, Point3D)
forall a. IO a -> m a
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
    t' <- Triangle -> IO (Ptr Triangle)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Triangle
t
    a <- SP.callocBoxedBytes 12 :: IO (Ptr Graphene.Point3D.Point3D)
    b <- SP.callocBoxedBytes 12 :: IO (Ptr Graphene.Point3D.Point3D)
    c <- SP.callocBoxedBytes 12 :: IO (Ptr Graphene.Point3D.Point3D)
    graphene_triangle_get_points t' a b c
    a' <- (wrapBoxed Graphene.Point3D.Point3D) a
    b' <- (wrapBoxed Graphene.Point3D.Point3D) b
    c' <- (wrapBoxed Graphene.Point3D.Point3D) c
    touchManagedPtr t
    return (a', b', c')

#if defined(ENABLE_OVERLOADING)
data TriangleGetPointsMethodInfo
instance (signature ~ (m ((Graphene.Point3D.Point3D, Graphene.Point3D.Point3D, Graphene.Point3D.Point3D))), MonadIO m) => O.OverloadedMethod TriangleGetPointsMethodInfo Triangle signature where
    overloadedMethod = triangleGetPoints

instance O.OverloadedMethodInfo TriangleGetPointsMethodInfo Triangle where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Graphene.Structs.Triangle.triangleGetPoints",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-graphene-1.0.8/docs/GI-Graphene-Structs-Triangle.html#v:triangleGetPoints"
        })


#endif

-- method Triangle::get_uv
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "t"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Triangle" }
--           , argCType = Just "const graphene_triangle_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_triangle_t"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "p"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Point3D" }
--           , argCType = Just "const graphene_point3d_t*"
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_point3d_t"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "uv_a"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Vec2" }
--           , argCType = Just "const graphene_vec2_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the UV coordinates of the first point"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "uv_b"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Vec2" }
--           , argCType = Just "const graphene_vec2_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the UV coordinates of the second point"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "uv_c"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Vec2" }
--           , argCType = Just "const graphene_vec2_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the UV coordinates of the third point"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "res"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Vec2" }
--           , argCType = Just "graphene_vec2_t*"
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "a vector containing the UV coordinates\n  of the given point @p"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = True
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "graphene_triangle_get_uv" graphene_triangle_get_uv :: 
    Ptr Triangle ->                         -- t : TInterface (Name {namespace = "Graphene", name = "Triangle"})
    Ptr Graphene.Point3D.Point3D ->         -- p : TInterface (Name {namespace = "Graphene", name = "Point3D"})
    Ptr Graphene.Vec2.Vec2 ->               -- uv_a : TInterface (Name {namespace = "Graphene", name = "Vec2"})
    Ptr Graphene.Vec2.Vec2 ->               -- uv_b : TInterface (Name {namespace = "Graphene", name = "Vec2"})
    Ptr Graphene.Vec2.Vec2 ->               -- uv_c : TInterface (Name {namespace = "Graphene", name = "Vec2"})
    Ptr Graphene.Vec2.Vec2 ->               -- res : TInterface (Name {namespace = "Graphene", name = "Vec2"})
    IO CInt

-- | Computes the UV coordinates of the given point /@p@/.
-- 
-- The point /@p@/ must lie on the same plane as the triangle /@t@/; if the point
-- is not coplanar, the result of this function is undefined. If /@p@/ is 'P.Nothing',
-- the point will be set in (0, 0, 0).
-- 
-- The UV coordinates will be placed in the /@res@/ vector:
-- 
-- * @res.x = u@
-- * @res.y = v@
-- 
-- 
-- See also: 'GI.Graphene.Structs.Triangle.triangleGetBarycoords'
-- 
-- /Since: 1.10/
triangleGetUv ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Triangle
    -- ^ /@t@/: a t'GI.Graphene.Structs.Triangle.Triangle'
    -> Maybe (Graphene.Point3D.Point3D)
    -- ^ /@p@/: a t'GI.Graphene.Structs.Point3D.Point3D'
    -> Graphene.Vec2.Vec2
    -- ^ /@uvA@/: the UV coordinates of the first point
    -> Graphene.Vec2.Vec2
    -- ^ /@uvB@/: the UV coordinates of the second point
    -> Graphene.Vec2.Vec2
    -- ^ /@uvC@/: the UV coordinates of the third point
    -> m ((Bool, Graphene.Vec2.Vec2))
    -- ^ __Returns:__ @true@ if the coordinates are valid
triangleGetUv :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
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 a. IO a -> m a
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
    t' <- Triangle -> IO (Ptr Triangle)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Triangle
t
    maybeP <- case p of
        Maybe Point3D
Nothing -> Ptr Point3D -> IO (Ptr Point3D)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Point3D
forall a. Ptr a
FP.nullPtr
        Just Point3D
jP -> do
            jP' <- Point3D -> IO (Ptr Point3D)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Point3D
jP
            return jP'
    uvA' <- unsafeManagedPtrGetPtr uvA
    uvB' <- unsafeManagedPtrGetPtr uvB
    uvC' <- unsafeManagedPtrGetPtr uvC
    res <- SP.callocBoxedBytes 16 :: IO (Ptr Graphene.Vec2.Vec2)
    result <- graphene_triangle_get_uv t' maybeP uvA' uvB' uvC' res
    let result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    res' <- (wrapBoxed Graphene.Vec2.Vec2) res
    touchManagedPtr t
    whenJust p touchManagedPtr
    touchManagedPtr uvA
    touchManagedPtr uvB
    touchManagedPtr uvC
    return (result', 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.OverloadedMethod TriangleGetUvMethodInfo Triangle signature where
    overloadedMethod = triangleGetUv

instance O.OverloadedMethodInfo TriangleGetUvMethodInfo Triangle where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Graphene.Structs.Triangle.triangleGetUv",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-graphene-1.0.8/docs/GI-Graphene-Structs-Triangle.html#v:triangleGetUv"
        })


#endif

-- method Triangle::get_vertices
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "t"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Triangle" }
--           , argCType = Just "const graphene_triangle_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_triangle_t"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "a"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Vec3" }
--           , argCType = Just "graphene_vec3_t*"
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "return location for the first vertex"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = True
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "b"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Vec3" }
--           , argCType = Just "graphene_vec3_t*"
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "return location for the second vertex"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = True
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "c"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Vec3" }
--           , argCType = Just "graphene_vec3_t*"
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "return location for the third vertex"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = True
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "graphene_triangle_get_vertices" graphene_triangle_get_vertices :: 
    Ptr Triangle ->                         -- t : TInterface (Name {namespace = "Graphene", name = "Triangle"})
    Ptr Graphene.Vec3.Vec3 ->               -- a : TInterface (Name {namespace = "Graphene", name = "Vec3"})
    Ptr Graphene.Vec3.Vec3 ->               -- b : TInterface (Name {namespace = "Graphene", name = "Vec3"})
    Ptr Graphene.Vec3.Vec3 ->               -- c : TInterface (Name {namespace = "Graphene", name = "Vec3"})
    IO ()

-- | Retrieves the three vertices of the given t'GI.Graphene.Structs.Triangle.Triangle'.
-- 
-- /Since: 1.2/
triangleGetVertices ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Triangle
    -- ^ /@t@/: a t'GI.Graphene.Structs.Triangle.Triangle'
    -> m ((Graphene.Vec3.Vec3, Graphene.Vec3.Vec3, Graphene.Vec3.Vec3))
triangleGetVertices :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Triangle -> m (Vec3, Vec3, Vec3)
triangleGetVertices Triangle
t = IO (Vec3, Vec3, Vec3) -> m (Vec3, Vec3, Vec3)
forall a. IO a -> m a
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
    t' <- Triangle -> IO (Ptr Triangle)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Triangle
t
    a <- SP.callocBoxedBytes 16 :: IO (Ptr Graphene.Vec3.Vec3)
    b <- SP.callocBoxedBytes 16 :: IO (Ptr Graphene.Vec3.Vec3)
    c <- SP.callocBoxedBytes 16 :: IO (Ptr Graphene.Vec3.Vec3)
    graphene_triangle_get_vertices t' a b c
    a' <- (wrapBoxed Graphene.Vec3.Vec3) a
    b' <- (wrapBoxed Graphene.Vec3.Vec3) b
    c' <- (wrapBoxed Graphene.Vec3.Vec3) c
    touchManagedPtr t
    return (a', b', c')

#if defined(ENABLE_OVERLOADING)
data TriangleGetVerticesMethodInfo
instance (signature ~ (m ((Graphene.Vec3.Vec3, Graphene.Vec3.Vec3, Graphene.Vec3.Vec3))), MonadIO m) => O.OverloadedMethod TriangleGetVerticesMethodInfo Triangle signature where
    overloadedMethod = triangleGetVertices

instance O.OverloadedMethodInfo TriangleGetVerticesMethodInfo Triangle where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Graphene.Structs.Triangle.triangleGetVertices",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-graphene-1.0.8/docs/GI-Graphene-Structs-Triangle.html#v:triangleGetVertices"
        })


#endif

-- method Triangle::init_from_float
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "t"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Triangle" }
--           , argCType = Just "graphene_triangle_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #graphene_triangle_t to initialize"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "a"
--           , argType = TCArray False 3 (-1) (TBasicType TFloat)
--           , argCType = Just "const float*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an array of 3 floating point values"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "b"
--           , argType = TCArray False 3 (-1) (TBasicType TFloat)
--           , argCType = Just "const float*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an array of 3 floating point values"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "c"
--           , argType = TCArray False 3 (-1) (TBasicType TFloat)
--           , argCType = Just "const float*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an array of 3 floating point values"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "Graphene" , name = "Triangle" })
-- throws : False
-- Skip return : False

foreign import ccall "graphene_triangle_init_from_float" graphene_triangle_init_from_float :: 
    Ptr Triangle ->                         -- t : TInterface (Name {namespace = "Graphene", name = "Triangle"})
    Ptr CFloat ->                           -- a : TCArray False 3 (-1) (TBasicType TFloat)
    Ptr CFloat ->                           -- b : TCArray False 3 (-1) (TBasicType TFloat)
    Ptr CFloat ->                           -- c : TCArray False 3 (-1) (TBasicType TFloat)
    IO (Ptr Triangle)

-- | Initializes a t'GI.Graphene.Structs.Triangle.Triangle' using the three given arrays
-- of floating point values, each representing the coordinates of
-- a point in 3D space.
-- 
-- /Since: 1.10/
triangleInitFromFloat ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Triangle
    -- ^ /@t@/: the t'GI.Graphene.Structs.Triangle.Triangle' to initialize
    -> [Float]
    -- ^ /@a@/: an array of 3 floating point values
    -> [Float]
    -- ^ /@b@/: an array of 3 floating point values
    -> [Float]
    -- ^ /@c@/: an array of 3 floating point values
    -> m Triangle
    -- ^ __Returns:__ the initialized t'GI.Graphene.Structs.Triangle.Triangle'
triangleInitFromFloat :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Triangle -> [Float] -> [Float] -> [Float] -> m Triangle
triangleInitFromFloat Triangle
t [Float]
a [Float]
b [Float]
c = IO Triangle -> m Triangle
forall a. IO a -> m a
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
    t' <- Triangle -> IO (Ptr Triangle)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Triangle
t
    a' <- (packMapStorableArray realToFrac) a
    b' <- (packMapStorableArray realToFrac) b
    c' <- (packMapStorableArray realToFrac) c
    result <- graphene_triangle_init_from_float t' a' b' c'
    checkUnexpectedReturnNULL "triangleInitFromFloat" result
    result' <- (newBoxed Triangle) result
    touchManagedPtr t
    freeMem a'
    freeMem b'
    freeMem c'
    return result'

#if defined(ENABLE_OVERLOADING)
data TriangleInitFromFloatMethodInfo
instance (signature ~ ([Float] -> [Float] -> [Float] -> m Triangle), MonadIO m) => O.OverloadedMethod TriangleInitFromFloatMethodInfo Triangle signature where
    overloadedMethod = triangleInitFromFloat

instance O.OverloadedMethodInfo TriangleInitFromFloatMethodInfo Triangle where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Graphene.Structs.Triangle.triangleInitFromFloat",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-graphene-1.0.8/docs/GI-Graphene-Structs-Triangle.html#v:triangleInitFromFloat"
        })


#endif

-- method Triangle::init_from_point3d
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "t"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Triangle" }
--           , argCType = Just "graphene_triangle_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #graphene_triangle_t to initialize"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "a"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Point3D" }
--           , argCType = Just "const graphene_point3d_t*"
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_point3d_t"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "b"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Point3D" }
--           , argCType = Just "const graphene_point3d_t*"
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_point3d_t"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "c"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Point3D" }
--           , argCType = Just "const graphene_point3d_t*"
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_point3d_t"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "Graphene" , name = "Triangle" })
-- throws : False
-- Skip return : False

foreign import ccall "graphene_triangle_init_from_point3d" graphene_triangle_init_from_point3d :: 
    Ptr Triangle ->                         -- t : TInterface (Name {namespace = "Graphene", name = "Triangle"})
    Ptr Graphene.Point3D.Point3D ->         -- a : TInterface (Name {namespace = "Graphene", name = "Point3D"})
    Ptr Graphene.Point3D.Point3D ->         -- b : TInterface (Name {namespace = "Graphene", name = "Point3D"})
    Ptr Graphene.Point3D.Point3D ->         -- c : TInterface (Name {namespace = "Graphene", name = "Point3D"})
    IO (Ptr Triangle)

-- | Initializes a t'GI.Graphene.Structs.Triangle.Triangle' using the three given 3D points.
-- 
-- /Since: 1.2/
triangleInitFromPoint3d ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Triangle
    -- ^ /@t@/: the t'GI.Graphene.Structs.Triangle.Triangle' to initialize
    -> Maybe (Graphene.Point3D.Point3D)
    -- ^ /@a@/: a t'GI.Graphene.Structs.Point3D.Point3D'
    -> Maybe (Graphene.Point3D.Point3D)
    -- ^ /@b@/: a t'GI.Graphene.Structs.Point3D.Point3D'
    -> Maybe (Graphene.Point3D.Point3D)
    -- ^ /@c@/: a t'GI.Graphene.Structs.Point3D.Point3D'
    -> m Triangle
    -- ^ __Returns:__ the initialized t'GI.Graphene.Structs.Triangle.Triangle'
triangleInitFromPoint3d :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
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 a. IO a -> m a
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
    t' <- Triangle -> IO (Ptr Triangle)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Triangle
t
    maybeA <- case a of
        Maybe Point3D
Nothing -> Ptr Point3D -> IO (Ptr Point3D)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Point3D
forall a. Ptr a
FP.nullPtr
        Just Point3D
jA -> do
            jA' <- Point3D -> IO (Ptr Point3D)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Point3D
jA
            return jA'
    maybeB <- case b of
        Maybe Point3D
Nothing -> Ptr Point3D -> IO (Ptr Point3D)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Point3D
forall a. Ptr a
FP.nullPtr
        Just Point3D
jB -> do
            jB' <- Point3D -> IO (Ptr Point3D)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Point3D
jB
            return jB'
    maybeC <- case c of
        Maybe Point3D
Nothing -> Ptr Point3D -> IO (Ptr Point3D)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Point3D
forall a. Ptr a
FP.nullPtr
        Just Point3D
jC -> do
            jC' <- Point3D -> IO (Ptr Point3D)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Point3D
jC
            return jC'
    result <- graphene_triangle_init_from_point3d t' maybeA maybeB maybeC
    checkUnexpectedReturnNULL "triangleInitFromPoint3d" result
    result' <- (newBoxed Triangle) result
    touchManagedPtr t
    whenJust a touchManagedPtr
    whenJust b touchManagedPtr
    whenJust c touchManagedPtr
    return 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.OverloadedMethod TriangleInitFromPoint3dMethodInfo Triangle signature where
    overloadedMethod = triangleInitFromPoint3d

instance O.OverloadedMethodInfo TriangleInitFromPoint3dMethodInfo Triangle where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Graphene.Structs.Triangle.triangleInitFromPoint3d",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-graphene-1.0.8/docs/GI-Graphene-Structs-Triangle.html#v:triangleInitFromPoint3d"
        })


#endif

-- method Triangle::init_from_vec3
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "t"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Triangle" }
--           , argCType = Just "graphene_triangle_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #graphene_triangle_t to initialize"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "a"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Vec3" }
--           , argCType = Just "const graphene_vec3_t*"
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_vec3_t" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "b"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Vec3" }
--           , argCType = Just "const graphene_vec3_t*"
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_vec3_t" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "c"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Vec3" }
--           , argCType = Just "const graphene_vec3_t*"
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_vec3_t" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "Graphene" , name = "Triangle" })
-- throws : False
-- Skip return : False

foreign import ccall "graphene_triangle_init_from_vec3" graphene_triangle_init_from_vec3 :: 
    Ptr Triangle ->                         -- t : TInterface (Name {namespace = "Graphene", name = "Triangle"})
    Ptr Graphene.Vec3.Vec3 ->               -- a : TInterface (Name {namespace = "Graphene", name = "Vec3"})
    Ptr Graphene.Vec3.Vec3 ->               -- b : TInterface (Name {namespace = "Graphene", name = "Vec3"})
    Ptr Graphene.Vec3.Vec3 ->               -- c : TInterface (Name {namespace = "Graphene", name = "Vec3"})
    IO (Ptr Triangle)

-- | Initializes a t'GI.Graphene.Structs.Triangle.Triangle' using the three given vectors.
-- 
-- /Since: 1.2/
triangleInitFromVec3 ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Triangle
    -- ^ /@t@/: the t'GI.Graphene.Structs.Triangle.Triangle' to initialize
    -> Maybe (Graphene.Vec3.Vec3)
    -- ^ /@a@/: a t'GI.Graphene.Structs.Vec3.Vec3'
    -> Maybe (Graphene.Vec3.Vec3)
    -- ^ /@b@/: a t'GI.Graphene.Structs.Vec3.Vec3'
    -> Maybe (Graphene.Vec3.Vec3)
    -- ^ /@c@/: a t'GI.Graphene.Structs.Vec3.Vec3'
    -> m Triangle
    -- ^ __Returns:__ the initialized t'GI.Graphene.Structs.Triangle.Triangle'
triangleInitFromVec3 :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
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 a. IO a -> m a
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
    t' <- Triangle -> IO (Ptr Triangle)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Triangle
t
    maybeA <- case a of
        Maybe Vec3
Nothing -> Ptr Vec3 -> IO (Ptr Vec3)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Vec3
forall a. Ptr a
FP.nullPtr
        Just Vec3
jA -> do
            jA' <- Vec3 -> IO (Ptr Vec3)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Vec3
jA
            return jA'
    maybeB <- case b of
        Maybe Vec3
Nothing -> Ptr Vec3 -> IO (Ptr Vec3)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Vec3
forall a. Ptr a
FP.nullPtr
        Just Vec3
jB -> do
            jB' <- Vec3 -> IO (Ptr Vec3)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Vec3
jB
            return jB'
    maybeC <- case c of
        Maybe Vec3
Nothing -> Ptr Vec3 -> IO (Ptr Vec3)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Vec3
forall a. Ptr a
FP.nullPtr
        Just Vec3
jC -> do
            jC' <- Vec3 -> IO (Ptr Vec3)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Vec3
jC
            return jC'
    result <- graphene_triangle_init_from_vec3 t' maybeA maybeB maybeC
    checkUnexpectedReturnNULL "triangleInitFromVec3" result
    result' <- (newBoxed Triangle) result
    touchManagedPtr t
    whenJust a touchManagedPtr
    whenJust b touchManagedPtr
    whenJust c touchManagedPtr
    return 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.OverloadedMethod TriangleInitFromVec3MethodInfo Triangle signature where
    overloadedMethod = triangleInitFromVec3

instance O.OverloadedMethodInfo TriangleInitFromVec3MethodInfo Triangle where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Graphene.Structs.Triangle.triangleInitFromVec3",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-graphene-1.0.8/docs/GI-Graphene-Structs-Triangle.html#v:triangleInitFromVec3"
        })


#endif

#if defined(ENABLE_OVERLOADING)
type family ResolveTriangleMethod (t :: Symbol) (o :: DK.Type) :: DK.Type 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.OverloadedMethod 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

#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolveTriangleMethod t Triangle, O.OverloadedMethod info Triangle p, R.HasField t Triangle p) => R.HasField t Triangle p where
    getField = O.overloadedMethod @info

#endif

instance (info ~ ResolveTriangleMethod t Triangle, O.OverloadedMethodInfo info Triangle) => OL.IsLabel t (O.MethodProxy info Triangle) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.MethodProxy
#else
    fromLabel _ = O.MethodProxy
#endif

#endif