{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- A 3D box, described as the volume between a minimum and
-- a maximum vertices.
-- 
-- /Since: 1.2/

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

module GI.Graphene.Structs.Box
    ( 

-- * Exported types
    Box(..)                                 ,
    newZeroBox                              ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [containsBox]("GI.Graphene.Structs.Box#g:method:containsBox"), [containsPoint]("GI.Graphene.Structs.Box#g:method:containsPoint"), [equal]("GI.Graphene.Structs.Box#g:method:equal"), [expand]("GI.Graphene.Structs.Box#g:method:expand"), [expandScalar]("GI.Graphene.Structs.Box#g:method:expandScalar"), [expandVec3]("GI.Graphene.Structs.Box#g:method:expandVec3"), [free]("GI.Graphene.Structs.Box#g:method:free"), [init]("GI.Graphene.Structs.Box#g:method:init"), [initFromBox]("GI.Graphene.Structs.Box#g:method:initFromBox"), [initFromPoints]("GI.Graphene.Structs.Box#g:method:initFromPoints"), [initFromVec3]("GI.Graphene.Structs.Box#g:method:initFromVec3"), [initFromVectors]("GI.Graphene.Structs.Box#g:method:initFromVectors"), [intersection]("GI.Graphene.Structs.Box#g:method:intersection"), [union]("GI.Graphene.Structs.Box#g:method:union").
-- 
-- ==== Getters
-- [getBoundingSphere]("GI.Graphene.Structs.Box#g:method:getBoundingSphere"), [getCenter]("GI.Graphene.Structs.Box#g:method:getCenter"), [getDepth]("GI.Graphene.Structs.Box#g:method:getDepth"), [getHeight]("GI.Graphene.Structs.Box#g:method:getHeight"), [getMax]("GI.Graphene.Structs.Box#g:method:getMax"), [getMin]("GI.Graphene.Structs.Box#g:method:getMin"), [getSize]("GI.Graphene.Structs.Box#g:method:getSize"), [getWidth]("GI.Graphene.Structs.Box#g:method:getWidth").
-- 
-- ==== Setters
-- /None/.

#if defined(ENABLE_OVERLOADING)
    ResolveBoxMethod                        ,
#endif

-- ** alloc #method:alloc#

    boxAlloc                                ,


-- ** containsBox #method:containsBox#

#if defined(ENABLE_OVERLOADING)
    BoxContainsBoxMethodInfo                ,
#endif
    boxContainsBox                          ,


-- ** containsPoint #method:containsPoint#

#if defined(ENABLE_OVERLOADING)
    BoxContainsPointMethodInfo              ,
#endif
    boxContainsPoint                        ,


-- ** empty #method:empty#

    boxEmpty                                ,


-- ** equal #method:equal#

#if defined(ENABLE_OVERLOADING)
    BoxEqualMethodInfo                      ,
#endif
    boxEqual                                ,


-- ** expand #method:expand#

#if defined(ENABLE_OVERLOADING)
    BoxExpandMethodInfo                     ,
#endif
    boxExpand                               ,


-- ** expandScalar #method:expandScalar#

#if defined(ENABLE_OVERLOADING)
    BoxExpandScalarMethodInfo               ,
#endif
    boxExpandScalar                         ,


-- ** expandVec3 #method:expandVec3#

#if defined(ENABLE_OVERLOADING)
    BoxExpandVec3MethodInfo                 ,
#endif
    boxExpandVec3                           ,


-- ** free #method:free#

#if defined(ENABLE_OVERLOADING)
    BoxFreeMethodInfo                       ,
#endif
    boxFree                                 ,


-- ** getBoundingSphere #method:getBoundingSphere#

#if defined(ENABLE_OVERLOADING)
    BoxGetBoundingSphereMethodInfo          ,
#endif
    boxGetBoundingSphere                    ,


-- ** getCenter #method:getCenter#

#if defined(ENABLE_OVERLOADING)
    BoxGetCenterMethodInfo                  ,
#endif
    boxGetCenter                            ,


-- ** getDepth #method:getDepth#

#if defined(ENABLE_OVERLOADING)
    BoxGetDepthMethodInfo                   ,
#endif
    boxGetDepth                             ,


-- ** getHeight #method:getHeight#

#if defined(ENABLE_OVERLOADING)
    BoxGetHeightMethodInfo                  ,
#endif
    boxGetHeight                            ,


-- ** getMax #method:getMax#

#if defined(ENABLE_OVERLOADING)
    BoxGetMaxMethodInfo                     ,
#endif
    boxGetMax                               ,


-- ** getMin #method:getMin#

#if defined(ENABLE_OVERLOADING)
    BoxGetMinMethodInfo                     ,
#endif
    boxGetMin                               ,


-- ** getSize #method:getSize#

#if defined(ENABLE_OVERLOADING)
    BoxGetSizeMethodInfo                    ,
#endif
    boxGetSize                              ,


-- ** getWidth #method:getWidth#

#if defined(ENABLE_OVERLOADING)
    BoxGetWidthMethodInfo                   ,
#endif
    boxGetWidth                             ,


-- ** infinite #method:infinite#

    boxInfinite                             ,


-- ** init #method:init#

#if defined(ENABLE_OVERLOADING)
    BoxInitMethodInfo                       ,
#endif
    boxInit                                 ,


-- ** initFromBox #method:initFromBox#

#if defined(ENABLE_OVERLOADING)
    BoxInitFromBoxMethodInfo                ,
#endif
    boxInitFromBox                          ,


-- ** initFromPoints #method:initFromPoints#

#if defined(ENABLE_OVERLOADING)
    BoxInitFromPointsMethodInfo             ,
#endif
    boxInitFromPoints                       ,


-- ** initFromVec3 #method:initFromVec3#

#if defined(ENABLE_OVERLOADING)
    BoxInitFromVec3MethodInfo               ,
#endif
    boxInitFromVec3                         ,


-- ** initFromVectors #method:initFromVectors#

#if defined(ENABLE_OVERLOADING)
    BoxInitFromVectorsMethodInfo            ,
#endif
    boxInitFromVectors                      ,


-- ** intersection #method:intersection#

#if defined(ENABLE_OVERLOADING)
    BoxIntersectionMethodInfo               ,
#endif
    boxIntersection                         ,


-- ** minusOne #method:minusOne#

    boxMinusOne                             ,


-- ** one #method:one#

    boxOne                                  ,


-- ** oneMinusOne #method:oneMinusOne#

    boxOneMinusOne                          ,


-- ** union #method:union#

#if defined(ENABLE_OVERLOADING)
    BoxUnionMethodInfo                      ,
#endif
    boxUnion                                ,


-- ** zero #method:zero#

    boxZero                                 ,




    ) 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.Structs.Point as Graphene.Point
import {-# SOURCE #-} qualified GI.Graphene.Structs.Point3D as Graphene.Point3D
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.Point3D as Graphene.Point3D
import {-# SOURCE #-} qualified GI.Graphene.Structs.Sphere as Graphene.Sphere
import {-# SOURCE #-} qualified GI.Graphene.Structs.Vec3 as Graphene.Vec3

#endif

-- | Memory-managed wrapper type.
newtype Box = Box (SP.ManagedPtr Box)
    deriving (Box -> Box -> Bool
(Box -> Box -> Bool) -> (Box -> Box -> Bool) -> Eq Box
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Box -> Box -> Bool
== :: Box -> Box -> Bool
$c/= :: Box -> Box -> Bool
/= :: Box -> Box -> Bool
Eq)

instance SP.ManagedPtrNewtype Box where
    toManagedPtr :: Box -> ManagedPtr Box
toManagedPtr (Box ManagedPtr Box
p) = ManagedPtr Box
p

foreign import ccall "graphene_box_get_type" c_graphene_box_get_type :: 
    IO GType

type instance O.ParentTypes Box = '[]
instance O.HasParentTypes Box

instance B.Types.TypedObject Box where
    glibType :: IO GType
glibType = IO GType
c_graphene_box_get_type

instance B.Types.GBoxed Box

-- | Convert t'Box' 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 Box) where
    gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_graphene_box_get_type
    gvalueSet_ :: Ptr GValue -> Maybe Box -> IO ()
gvalueSet_ Ptr GValue
gv Maybe Box
P.Nothing = Ptr GValue -> Ptr Box -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv (Ptr Box
forall a. Ptr a
FP.nullPtr :: FP.Ptr Box)
    gvalueSet_ Ptr GValue
gv (P.Just Box
obj) = Box -> (Ptr Box -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr Box
obj (Ptr GValue -> Ptr Box -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv)
    gvalueGet_ :: Ptr GValue -> IO (Maybe Box)
gvalueGet_ Ptr GValue
gv = do
        ptr <- Ptr GValue -> IO (Ptr Box)
forall b. Ptr GValue -> IO (Ptr b)
B.GValue.get_boxed Ptr GValue
gv :: IO (Ptr Box)
        if ptr /= FP.nullPtr
        then P.Just <$> B.ManagedPtr.newBoxed Box ptr
        else return P.Nothing
        
    

-- | Construct a t'Box' struct initialized to zero.
newZeroBox :: MonadIO m => m Box
newZeroBox :: forall (m :: * -> *). MonadIO m => m Box
newZeroBox = 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
$ Int -> IO (Ptr Box)
forall a. GBoxed a => Int -> IO (Ptr a)
callocBoxedBytes Int
32 IO (Ptr Box) -> (Ptr Box -> IO Box) -> IO Box
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (ManagedPtr Box -> Box) -> Ptr Box -> IO Box
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Box -> Box
Box

instance tag ~ 'AttrSet => Constructible Box tag where
    new :: forall (m :: * -> *).
MonadIO m =>
(ManagedPtr Box -> Box) -> [AttrOp Box tag] -> m Box
new ManagedPtr Box -> Box
_ [AttrOp Box tag]
attrs = do
        o <- m Box
forall (m :: * -> *). MonadIO m => m Box
newZeroBox
        GI.Attributes.set o attrs
        return o



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

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

foreign import ccall "graphene_box_alloc" graphene_box_alloc :: 
    IO (Ptr Box)

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

#if defined(ENABLE_OVERLOADING)
#endif

-- method Box::contains_box
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "a"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Box" }
--           , argCType = Just "const graphene_box_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_box_t" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "b"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Box" }
--           , argCType = Just "const graphene_box_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_box_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_box_contains_box" graphene_box_contains_box :: 
    Ptr Box ->                              -- a : TInterface (Name {namespace = "Graphene", name = "Box"})
    Ptr Box ->                              -- b : TInterface (Name {namespace = "Graphene", name = "Box"})
    IO CInt

-- | Checks whether the t'GI.Graphene.Structs.Box.Box' /@a@/ contains the given
-- t'GI.Graphene.Structs.Box.Box' /@b@/.
-- 
-- /Since: 1.2/
boxContainsBox ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Box
    -- ^ /@a@/: a t'GI.Graphene.Structs.Box.Box'
    -> Box
    -- ^ /@b@/: a t'GI.Graphene.Structs.Box.Box'
    -> m Bool
    -- ^ __Returns:__ @true@ if the box is contained in the given box
boxContainsBox :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Box -> Box -> m Bool
boxContainsBox Box
a Box
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' <- Box -> IO (Ptr Box)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Box
a
    b' <- unsafeManagedPtrGetPtr b
    result <- graphene_box_contains_box 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 BoxContainsBoxMethodInfo
instance (signature ~ (Box -> m Bool), MonadIO m) => O.OverloadedMethod BoxContainsBoxMethodInfo Box signature where
    overloadedMethod = boxContainsBox

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


#endif

-- method Box::contains_point
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "box"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Box" }
--           , argCType = Just "const graphene_box_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_box_t" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "point"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Point3D" }
--           , argCType = Just "const graphene_point3d_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the coordinates to check"
--                 , 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_box_contains_point" graphene_box_contains_point :: 
    Ptr Box ->                              -- box : TInterface (Name {namespace = "Graphene", name = "Box"})
    Ptr Graphene.Point3D.Point3D ->         -- point : TInterface (Name {namespace = "Graphene", name = "Point3D"})
    IO CInt

-- | Checks whether /@box@/ contains the given /@point@/.
-- 
-- /Since: 1.2/
boxContainsPoint ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Box
    -- ^ /@box@/: a t'GI.Graphene.Structs.Box.Box'
    -> Graphene.Point3D.Point3D
    -- ^ /@point@/: the coordinates to check
    -> m Bool
    -- ^ __Returns:__ @true@ if the point is contained in the given box
boxContainsPoint :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Box -> Point3D -> m Bool
boxContainsPoint Box
box Point3D
point = 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
    box' <- Box -> IO (Ptr Box)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Box
box
    point' <- unsafeManagedPtrGetPtr point
    result <- graphene_box_contains_point box' point'
    let result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    touchManagedPtr box
    touchManagedPtr point
    return result'

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

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


#endif

-- method Box::equal
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "a"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Box" }
--           , argCType = Just "const graphene_box_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_box_t" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "b"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Box" }
--           , argCType = Just "const graphene_box_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_box_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_box_equal" graphene_box_equal :: 
    Ptr Box ->                              -- a : TInterface (Name {namespace = "Graphene", name = "Box"})
    Ptr Box ->                              -- b : TInterface (Name {namespace = "Graphene", name = "Box"})
    IO CInt

-- | Checks whether the two given boxes are equal.
-- 
-- /Since: 1.2/
boxEqual ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Box
    -- ^ /@a@/: a t'GI.Graphene.Structs.Box.Box'
    -> Box
    -- ^ /@b@/: a t'GI.Graphene.Structs.Box.Box'
    -> m Bool
    -- ^ __Returns:__ @true@ if the boxes are equal
boxEqual :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Box -> Box -> m Bool
boxEqual Box
a Box
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' <- Box -> IO (Ptr Box)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Box
a
    b' <- unsafeManagedPtrGetPtr b
    result <- graphene_box_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 BoxEqualMethodInfo
instance (signature ~ (Box -> m Bool), MonadIO m) => O.OverloadedMethod BoxEqualMethodInfo Box signature where
    overloadedMethod = boxEqual

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


#endif

-- method Box::expand
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "box"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Box" }
--           , argCType = Just "const graphene_box_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_box_t" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "point"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Point3D" }
--           , argCType = Just "const graphene_point3d_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the coordinates of the point to include"
--                 , 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 expanded 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_box_expand" graphene_box_expand :: 
    Ptr Box ->                              -- box : TInterface (Name {namespace = "Graphene", name = "Box"})
    Ptr Graphene.Point3D.Point3D ->         -- point : TInterface (Name {namespace = "Graphene", name = "Point3D"})
    Ptr Box ->                              -- res : TInterface (Name {namespace = "Graphene", name = "Box"})
    IO ()

-- | Expands the dimensions of /@box@/ to include the coordinates at /@point@/.
-- 
-- /Since: 1.2/
boxExpand ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Box
    -- ^ /@box@/: a t'GI.Graphene.Structs.Box.Box'
    -> Graphene.Point3D.Point3D
    -- ^ /@point@/: the coordinates of the point to include
    -> m (Box)
boxExpand :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Box -> Point3D -> m Box
boxExpand Box
box Point3D
point = 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
    box' <- Box -> IO (Ptr Box)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Box
box
    point' <- unsafeManagedPtrGetPtr point
    res <- SP.callocBoxedBytes 32 :: IO (Ptr Box)
    graphene_box_expand box' point' res
    res' <- (wrapBoxed Box) res
    touchManagedPtr box
    touchManagedPtr point
    return res'

#if defined(ENABLE_OVERLOADING)
data BoxExpandMethodInfo
instance (signature ~ (Graphene.Point3D.Point3D -> m (Box)), MonadIO m) => O.OverloadedMethod BoxExpandMethodInfo Box signature where
    overloadedMethod = boxExpand

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


#endif

-- method Box::expand_scalar
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "box"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Box" }
--           , argCType = Just "const graphene_box_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_box_t" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "scalar"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a scalar value" , 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 expanded 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_box_expand_scalar" graphene_box_expand_scalar :: 
    Ptr Box ->                              -- box : TInterface (Name {namespace = "Graphene", name = "Box"})
    CFloat ->                               -- scalar : TBasicType TFloat
    Ptr Box ->                              -- res : TInterface (Name {namespace = "Graphene", name = "Box"})
    IO ()

-- | Expands the dimensions of /@box@/ by the given /@scalar@/ value.
-- 
-- If /@scalar@/ is positive, the t'GI.Graphene.Structs.Box.Box' will grow; if /@scalar@/ is
-- negative, the t'GI.Graphene.Structs.Box.Box' will shrink.
-- 
-- /Since: 1.2/
boxExpandScalar ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Box
    -- ^ /@box@/: a t'GI.Graphene.Structs.Box.Box'
    -> Float
    -- ^ /@scalar@/: a scalar value
    -> m (Box)
boxExpandScalar :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Box -> Float -> m Box
boxExpandScalar Box
box Float
scalar = 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
    box' <- Box -> IO (Ptr Box)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Box
box
    let scalar' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
scalar
    res <- SP.callocBoxedBytes 32 :: IO (Ptr Box)
    graphene_box_expand_scalar box' scalar' res
    res' <- (wrapBoxed Box) res
    touchManagedPtr box
    return res'

#if defined(ENABLE_OVERLOADING)
data BoxExpandScalarMethodInfo
instance (signature ~ (Float -> m (Box)), MonadIO m) => O.OverloadedMethod BoxExpandScalarMethodInfo Box signature where
    overloadedMethod = boxExpandScalar

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


#endif

-- method Box::expand_vec3
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "box"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Box" }
--           , argCType = Just "const graphene_box_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_box_t" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "vec"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Vec3" }
--           , argCType = Just "const graphene_vec3_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "the coordinates of the point to include, as a #graphene_vec3_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 expanded 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_box_expand_vec3" graphene_box_expand_vec3 :: 
    Ptr Box ->                              -- box : TInterface (Name {namespace = "Graphene", name = "Box"})
    Ptr Graphene.Vec3.Vec3 ->               -- vec : TInterface (Name {namespace = "Graphene", name = "Vec3"})
    Ptr Box ->                              -- res : TInterface (Name {namespace = "Graphene", name = "Box"})
    IO ()

-- | Expands the dimensions of /@box@/ to include the coordinates of the
-- given vector.
-- 
-- /Since: 1.2/
boxExpandVec3 ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Box
    -- ^ /@box@/: a t'GI.Graphene.Structs.Box.Box'
    -> Graphene.Vec3.Vec3
    -- ^ /@vec@/: the coordinates of the point to include, as a t'GI.Graphene.Structs.Vec3.Vec3'
    -> m (Box)
boxExpandVec3 :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Box -> Vec3 -> m Box
boxExpandVec3 Box
box Vec3
vec = 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
    box' <- Box -> IO (Ptr Box)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Box
box
    vec' <- unsafeManagedPtrGetPtr vec
    res <- SP.callocBoxedBytes 32 :: IO (Ptr Box)
    graphene_box_expand_vec3 box' vec' res
    res' <- (wrapBoxed Box) res
    touchManagedPtr box
    touchManagedPtr vec
    return res'

#if defined(ENABLE_OVERLOADING)
data BoxExpandVec3MethodInfo
instance (signature ~ (Graphene.Vec3.Vec3 -> m (Box)), MonadIO m) => O.OverloadedMethod BoxExpandVec3MethodInfo Box signature where
    overloadedMethod = boxExpandVec3

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


#endif

-- method Box::free
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "box"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Box" }
--           , argCType = Just "graphene_box_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_box_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_box_free" graphene_box_free :: 
    Ptr Box ->                              -- box : TInterface (Name {namespace = "Graphene", name = "Box"})
    IO ()

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

#if defined(ENABLE_OVERLOADING)
data BoxFreeMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod BoxFreeMethodInfo Box signature where
    overloadedMethod = boxFree

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


#endif

-- method Box::get_bounding_sphere
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "box"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Box" }
--           , argCType = Just "const graphene_box_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_box_t" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "sphere"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Sphere" }
--           , argCType = Just "graphene_sphere_t*"
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "return location for the bounding sphere"
--                 , 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_box_get_bounding_sphere" graphene_box_get_bounding_sphere :: 
    Ptr Box ->                              -- box : TInterface (Name {namespace = "Graphene", name = "Box"})
    Ptr Graphene.Sphere.Sphere ->           -- sphere : TInterface (Name {namespace = "Graphene", name = "Sphere"})
    IO ()

-- | Computes the bounding t'GI.Graphene.Structs.Sphere.Sphere' capable of containing the given
-- t'GI.Graphene.Structs.Box.Box'.
-- 
-- /Since: 1.2/
boxGetBoundingSphere ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Box
    -- ^ /@box@/: a t'GI.Graphene.Structs.Box.Box'
    -> m (Graphene.Sphere.Sphere)
boxGetBoundingSphere :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Box -> m Sphere
boxGetBoundingSphere Box
box = IO Sphere -> m Sphere
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Sphere -> m Sphere) -> IO Sphere -> m Sphere
forall a b. (a -> b) -> a -> b
$ do
    box' <- Box -> IO (Ptr Box)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Box
box
    sphere <- SP.callocBoxedBytes 20 :: IO (Ptr Graphene.Sphere.Sphere)
    graphene_box_get_bounding_sphere box' sphere
    sphere' <- (wrapBoxed Graphene.Sphere.Sphere) sphere
    touchManagedPtr box
    return sphere'

#if defined(ENABLE_OVERLOADING)
data BoxGetBoundingSphereMethodInfo
instance (signature ~ (m (Graphene.Sphere.Sphere)), MonadIO m) => O.OverloadedMethod BoxGetBoundingSphereMethodInfo Box signature where
    overloadedMethod = boxGetBoundingSphere

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


#endif

-- method Box::get_center
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "box"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Box" }
--           , argCType = Just "const graphene_box_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_box_t" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "center"
--           , 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 center"
--                 , 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_box_get_center" graphene_box_get_center :: 
    Ptr Box ->                              -- box : TInterface (Name {namespace = "Graphene", name = "Box"})
    Ptr Graphene.Point3D.Point3D ->         -- center : TInterface (Name {namespace = "Graphene", name = "Point3D"})
    IO ()

-- | Retrieves the coordinates of the center of a t'GI.Graphene.Structs.Box.Box'.
-- 
-- /Since: 1.2/
boxGetCenter ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Box
    -- ^ /@box@/: a t'GI.Graphene.Structs.Box.Box'
    -> m (Graphene.Point3D.Point3D)
boxGetCenter :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Box -> m Point3D
boxGetCenter Box
box = 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
    box' <- Box -> IO (Ptr Box)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Box
box
    center <- SP.callocBoxedBytes 12 :: IO (Ptr Graphene.Point3D.Point3D)
    graphene_box_get_center box' center
    center' <- (wrapBoxed Graphene.Point3D.Point3D) center
    touchManagedPtr box
    return center'

#if defined(ENABLE_OVERLOADING)
data BoxGetCenterMethodInfo
instance (signature ~ (m (Graphene.Point3D.Point3D)), MonadIO m) => O.OverloadedMethod BoxGetCenterMethodInfo Box signature where
    overloadedMethod = boxGetCenter

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


#endif

-- method Box::get_depth
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "box"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Box" }
--           , argCType = Just "const graphene_box_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_box_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_box_get_depth" graphene_box_get_depth :: 
    Ptr Box ->                              -- box : TInterface (Name {namespace = "Graphene", name = "Box"})
    IO CFloat

-- | Retrieves the size of the /@box@/ on the Z axis.
-- 
-- /Since: 1.2/
boxGetDepth ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Box
    -- ^ /@box@/: a t'GI.Graphene.Structs.Box.Box'
    -> m Float
    -- ^ __Returns:__ the depth of the box
boxGetDepth :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Box -> m Float
boxGetDepth Box
box = 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
    box' <- Box -> IO (Ptr Box)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Box
box
    result <- graphene_box_get_depth box'
    let result' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
result
    touchManagedPtr box
    return result'

#if defined(ENABLE_OVERLOADING)
data BoxGetDepthMethodInfo
instance (signature ~ (m Float), MonadIO m) => O.OverloadedMethod BoxGetDepthMethodInfo Box signature where
    overloadedMethod = boxGetDepth

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


#endif

-- method Box::get_height
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "box"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Box" }
--           , argCType = Just "const graphene_box_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_box_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_box_get_height" graphene_box_get_height :: 
    Ptr Box ->                              -- box : TInterface (Name {namespace = "Graphene", name = "Box"})
    IO CFloat

-- | Retrieves the size of the /@box@/ on the Y axis.
-- 
-- /Since: 1.2/
boxGetHeight ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Box
    -- ^ /@box@/: a t'GI.Graphene.Structs.Box.Box'
    -> m Float
    -- ^ __Returns:__ the height of the box
boxGetHeight :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Box -> m Float
boxGetHeight Box
box = 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
    box' <- Box -> IO (Ptr Box)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Box
box
    result <- graphene_box_get_height box'
    let result' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
result
    touchManagedPtr box
    return result'

#if defined(ENABLE_OVERLOADING)
data BoxGetHeightMethodInfo
instance (signature ~ (m Float), MonadIO m) => O.OverloadedMethod BoxGetHeightMethodInfo Box signature where
    overloadedMethod = boxGetHeight

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


#endif

-- method Box::get_max
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "box"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Box" }
--           , argCType = Just "const graphene_box_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_box_t" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "max"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Point3D" }
--           , argCType = Just "graphene_point3d_t*"
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "return location for the maximum point"
--                 , 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_box_get_max" graphene_box_get_max :: 
    Ptr Box ->                              -- box : TInterface (Name {namespace = "Graphene", name = "Box"})
    Ptr Graphene.Point3D.Point3D ->         -- max : TInterface (Name {namespace = "Graphene", name = "Point3D"})
    IO ()

-- | Retrieves the coordinates of the maximum point of the given
-- t'GI.Graphene.Structs.Box.Box'.
-- 
-- /Since: 1.2/
boxGetMax ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Box
    -- ^ /@box@/: a t'GI.Graphene.Structs.Box.Box'
    -> m (Graphene.Point3D.Point3D)
boxGetMax :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Box -> m Point3D
boxGetMax Box
box = 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
    box' <- Box -> IO (Ptr Box)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Box
box
    max <- SP.callocBoxedBytes 12 :: IO (Ptr Graphene.Point3D.Point3D)
    graphene_box_get_max box' max
    max' <- (wrapBoxed Graphene.Point3D.Point3D) max
    touchManagedPtr box
    return max'

#if defined(ENABLE_OVERLOADING)
data BoxGetMaxMethodInfo
instance (signature ~ (m (Graphene.Point3D.Point3D)), MonadIO m) => O.OverloadedMethod BoxGetMaxMethodInfo Box signature where
    overloadedMethod = boxGetMax

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


#endif

-- method Box::get_min
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "box"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Box" }
--           , argCType = Just "const graphene_box_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_box_t" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "min"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Point3D" }
--           , argCType = Just "graphene_point3d_t*"
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "return location for the minimum point"
--                 , 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_box_get_min" graphene_box_get_min :: 
    Ptr Box ->                              -- box : TInterface (Name {namespace = "Graphene", name = "Box"})
    Ptr Graphene.Point3D.Point3D ->         -- min : TInterface (Name {namespace = "Graphene", name = "Point3D"})
    IO ()

-- | Retrieves the coordinates of the minimum point of the given
-- t'GI.Graphene.Structs.Box.Box'.
-- 
-- /Since: 1.2/
boxGetMin ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Box
    -- ^ /@box@/: a t'GI.Graphene.Structs.Box.Box'
    -> m (Graphene.Point3D.Point3D)
boxGetMin :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Box -> m Point3D
boxGetMin Box
box = 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
    box' <- Box -> IO (Ptr Box)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Box
box
    min <- SP.callocBoxedBytes 12 :: IO (Ptr Graphene.Point3D.Point3D)
    graphene_box_get_min box' min
    min' <- (wrapBoxed Graphene.Point3D.Point3D) min
    touchManagedPtr box
    return min'

#if defined(ENABLE_OVERLOADING)
data BoxGetMinMethodInfo
instance (signature ~ (m (Graphene.Point3D.Point3D)), MonadIO m) => O.OverloadedMethod BoxGetMinMethodInfo Box signature where
    overloadedMethod = boxGetMin

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


#endif

-- method Box::get_size
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "box"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Box" }
--           , argCType = Just "const graphene_box_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_box_t" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "size"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Vec3" }
--           , argCType = Just "graphene_vec3_t*"
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "return location for the size"
--                 , 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_box_get_size" graphene_box_get_size :: 
    Ptr Box ->                              -- box : TInterface (Name {namespace = "Graphene", name = "Box"})
    Ptr Graphene.Vec3.Vec3 ->               -- size : TInterface (Name {namespace = "Graphene", name = "Vec3"})
    IO ()

-- | Retrieves the size of the box on all three axes, and stores
-- it into the given /@size@/ vector.
-- 
-- /Since: 1.2/
boxGetSize ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Box
    -- ^ /@box@/: a t'GI.Graphene.Structs.Box.Box'
    -> m (Graphene.Vec3.Vec3)
boxGetSize :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Box -> m Vec3
boxGetSize Box
box = 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
    box' <- Box -> IO (Ptr Box)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Box
box
    size <- SP.callocBoxedBytes 16 :: IO (Ptr Graphene.Vec3.Vec3)
    graphene_box_get_size box' size
    size' <- (wrapBoxed Graphene.Vec3.Vec3) size
    touchManagedPtr box
    return size'

#if defined(ENABLE_OVERLOADING)
data BoxGetSizeMethodInfo
instance (signature ~ (m (Graphene.Vec3.Vec3)), MonadIO m) => O.OverloadedMethod BoxGetSizeMethodInfo Box signature where
    overloadedMethod = boxGetSize

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


#endif

-- XXX Could not generate method Box::get_vertices
-- Not implemented: Don't know how to allocate "vertices" of type TCArray False 8 (-1) (TInterface (Name {namespace = "Graphene", name = "Vec3"}))
-- method Box::get_width
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "box"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Box" }
--           , argCType = Just "const graphene_box_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_box_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_box_get_width" graphene_box_get_width :: 
    Ptr Box ->                              -- box : TInterface (Name {namespace = "Graphene", name = "Box"})
    IO CFloat

-- | Retrieves the size of the /@box@/ on the X axis.
-- 
-- /Since: 1.2/
boxGetWidth ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Box
    -- ^ /@box@/: a t'GI.Graphene.Structs.Box.Box'
    -> m Float
    -- ^ __Returns:__ the width of the box
boxGetWidth :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Box -> m Float
boxGetWidth Box
box = 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
    box' <- Box -> IO (Ptr Box)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Box
box
    result <- graphene_box_get_width box'
    let result' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
result
    touchManagedPtr box
    return result'

#if defined(ENABLE_OVERLOADING)
data BoxGetWidthMethodInfo
instance (signature ~ (m Float), MonadIO m) => O.OverloadedMethod BoxGetWidthMethodInfo Box signature where
    overloadedMethod = boxGetWidth

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


#endif

-- method Box::init
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "box"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Box" }
--           , argCType = Just "graphene_box_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #graphene_box_t to initialize"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "min"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Point3D" }
--           , argCType = Just "const graphene_point3d_t*"
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the coordinates of the minimum vertex"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "max"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Point3D" }
--           , argCType = Just "const graphene_point3d_t*"
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the coordinates of the maximum vertex"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Graphene" , name = "Box" })
-- throws : False
-- Skip return : False

foreign import ccall "graphene_box_init" graphene_box_init :: 
    Ptr Box ->                              -- box : TInterface (Name {namespace = "Graphene", name = "Box"})
    Ptr Graphene.Point3D.Point3D ->         -- min : TInterface (Name {namespace = "Graphene", name = "Point3D"})
    Ptr Graphene.Point3D.Point3D ->         -- max : TInterface (Name {namespace = "Graphene", name = "Point3D"})
    IO (Ptr Box)

-- | Initializes the given t'GI.Graphene.Structs.Box.Box' with two vertices.
-- 
-- /Since: 1.2/
boxInit ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Box
    -- ^ /@box@/: the t'GI.Graphene.Structs.Box.Box' to initialize
    -> Maybe (Graphene.Point3D.Point3D)
    -- ^ /@min@/: the coordinates of the minimum vertex
    -> Maybe (Graphene.Point3D.Point3D)
    -- ^ /@max@/: the coordinates of the maximum vertex
    -> m Box
    -- ^ __Returns:__ the initialized t'GI.Graphene.Structs.Box.Box'
boxInit :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Box -> Maybe Point3D -> Maybe Point3D -> m Box
boxInit Box
box Maybe Point3D
min Maybe Point3D
max = 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
    box' <- Box -> IO (Ptr Box)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Box
box
    maybeMin <- case min 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
jMin -> do
            jMin' <- Point3D -> IO (Ptr Point3D)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Point3D
jMin
            return jMin'
    maybeMax <- case max 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
jMax -> do
            jMax' <- Point3D -> IO (Ptr Point3D)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Point3D
jMax
            return jMax'
    result <- graphene_box_init box' maybeMin maybeMax
    checkUnexpectedReturnNULL "boxInit" result
    result' <- (newBoxed Box) result
    touchManagedPtr box
    whenJust min touchManagedPtr
    whenJust max touchManagedPtr
    return result'

#if defined(ENABLE_OVERLOADING)
data BoxInitMethodInfo
instance (signature ~ (Maybe (Graphene.Point3D.Point3D) -> Maybe (Graphene.Point3D.Point3D) -> m Box), MonadIO m) => O.OverloadedMethod BoxInitMethodInfo Box signature where
    overloadedMethod = boxInit

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


#endif

-- method Box::init_from_box
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "box"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Box" }
--           , argCType = Just "graphene_box_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #graphene_box_t to initialize"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "src"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Box" }
--           , argCType = Just "const graphene_box_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_box_t" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Graphene" , name = "Box" })
-- throws : False
-- Skip return : False

foreign import ccall "graphene_box_init_from_box" graphene_box_init_from_box :: 
    Ptr Box ->                              -- box : TInterface (Name {namespace = "Graphene", name = "Box"})
    Ptr Box ->                              -- src : TInterface (Name {namespace = "Graphene", name = "Box"})
    IO (Ptr Box)

-- | Initializes the given t'GI.Graphene.Structs.Box.Box' with the vertices of
-- another t'GI.Graphene.Structs.Box.Box'.
-- 
-- /Since: 1.2/
boxInitFromBox ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Box
    -- ^ /@box@/: the t'GI.Graphene.Structs.Box.Box' to initialize
    -> Box
    -- ^ /@src@/: a t'GI.Graphene.Structs.Box.Box'
    -> m Box
    -- ^ __Returns:__ the initialized t'GI.Graphene.Structs.Box.Box'
boxInitFromBox :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Box -> Box -> m Box
boxInitFromBox Box
box Box
src = 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
    box' <- Box -> IO (Ptr Box)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Box
box
    src' <- unsafeManagedPtrGetPtr src
    result <- graphene_box_init_from_box box' src'
    checkUnexpectedReturnNULL "boxInitFromBox" result
    result' <- (newBoxed Box) result
    touchManagedPtr box
    touchManagedPtr src
    return result'

#if defined(ENABLE_OVERLOADING)
data BoxInitFromBoxMethodInfo
instance (signature ~ (Box -> m Box), MonadIO m) => O.OverloadedMethod BoxInitFromBoxMethodInfo Box signature where
    overloadedMethod = boxInitFromBox

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


#endif

-- method Box::init_from_points
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "box"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Box" }
--           , argCType = Just "graphene_box_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #graphene_box_t to initialize"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "n_points"
--           , argType = TBasicType TUInt
--           , argCType = Just "unsigned int"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the number #graphene_point3d_t in the @points array"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "points"
--           , argType =
--               TCArray
--                 False
--                 (-1)
--                 1
--                 (TInterface Name { namespace = "Graphene" , name = "Point3D" })
--           , argCType = Just "const graphene_point3d_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an array of #graphene_point3d_t"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: [ Arg
--              { argCName = "n_points"
--              , argType = TBasicType TUInt
--              , argCType = Just "unsigned int"
--              , direction = DirectionIn
--              , mayBeNull = False
--              , argDoc =
--                  Documentation
--                    { rawDocText =
--                        Just "the number #graphene_point3d_t in the @points array"
--                    , sinceVersion = Nothing
--                    }
--              , argScope = ScopeTypeInvalid
--              , argClosure = -1
--              , argDestroy = -1
--              , argCallerAllocates = False
--              , argCallbackUserData = False
--              , transfer = TransferNothing
--              }
--          ]
-- returnType: Just (TInterface Name { namespace = "Graphene" , name = "Box" })
-- throws : False
-- Skip return : False

foreign import ccall "graphene_box_init_from_points" graphene_box_init_from_points :: 
    Ptr Box ->                              -- box : TInterface (Name {namespace = "Graphene", name = "Box"})
    Word32 ->                               -- n_points : TBasicType TUInt
    Ptr Graphene.Point3D.Point3D ->         -- points : TCArray False (-1) 1 (TInterface (Name {namespace = "Graphene", name = "Point3D"}))
    IO (Ptr Box)

-- | Initializes the given t'GI.Graphene.Structs.Box.Box' with the given array
-- of vertices.
-- 
-- If /@nPoints@/ is 0, the returned box is initialized with
-- 'GI.Graphene.Functions.boxEmpty'.
-- 
-- /Since: 1.2/
boxInitFromPoints ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Box
    -- ^ /@box@/: the t'GI.Graphene.Structs.Box.Box' to initialize
    -> [Graphene.Point3D.Point3D]
    -- ^ /@points@/: an array of t'GI.Graphene.Structs.Point3D.Point3D'
    -> m Box
    -- ^ __Returns:__ the initialized t'GI.Graphene.Structs.Box.Box'
boxInitFromPoints :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Box -> [Point3D] -> m Box
boxInitFromPoints Box
box [Point3D]
points = 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
    let nPoints :: Word32
nPoints = Int -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Word32) -> Int -> Word32
forall a b. (a -> b) -> a -> b
$ [Point3D] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
P.length [Point3D]
points
    box' <- Box -> IO (Ptr Box)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Box
box
    points' <- mapM unsafeManagedPtrGetPtr points
    points'' <- packBlockArray 12 points'
    result <- graphene_box_init_from_points box' nPoints points''
    checkUnexpectedReturnNULL "boxInitFromPoints" result
    result' <- (newBoxed Box) result
    touchManagedPtr box
    mapM_ touchManagedPtr points
    freeMem points''
    return result'

#if defined(ENABLE_OVERLOADING)
data BoxInitFromPointsMethodInfo
instance (signature ~ ([Graphene.Point3D.Point3D] -> m Box), MonadIO m) => O.OverloadedMethod BoxInitFromPointsMethodInfo Box signature where
    overloadedMethod = boxInitFromPoints

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


#endif

-- method Box::init_from_vec3
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "box"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Box" }
--           , argCType = Just "graphene_box_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #graphene_box_t to initialize"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "min"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Vec3" }
--           , argCType = Just "const graphene_vec3_t*"
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the coordinates of the minimum vertex"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "max"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Vec3" }
--           , argCType = Just "const graphene_vec3_t*"
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the coordinates of the maximum vertex"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Graphene" , name = "Box" })
-- throws : False
-- Skip return : False

foreign import ccall "graphene_box_init_from_vec3" graphene_box_init_from_vec3 :: 
    Ptr Box ->                              -- box : TInterface (Name {namespace = "Graphene", name = "Box"})
    Ptr Graphene.Vec3.Vec3 ->               -- min : TInterface (Name {namespace = "Graphene", name = "Vec3"})
    Ptr Graphene.Vec3.Vec3 ->               -- max : TInterface (Name {namespace = "Graphene", name = "Vec3"})
    IO (Ptr Box)

-- | Initializes the given t'GI.Graphene.Structs.Box.Box' with two vertices
-- stored inside t'GI.Graphene.Structs.Vec3.Vec3'.
-- 
-- /Since: 1.2/
boxInitFromVec3 ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Box
    -- ^ /@box@/: the t'GI.Graphene.Structs.Box.Box' to initialize
    -> Maybe (Graphene.Vec3.Vec3)
    -- ^ /@min@/: the coordinates of the minimum vertex
    -> Maybe (Graphene.Vec3.Vec3)
    -- ^ /@max@/: the coordinates of the maximum vertex
    -> m Box
    -- ^ __Returns:__ the initialized t'GI.Graphene.Structs.Box.Box'
boxInitFromVec3 :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Box -> Maybe Vec3 -> Maybe Vec3 -> m Box
boxInitFromVec3 Box
box Maybe Vec3
min Maybe Vec3
max = 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
    box' <- Box -> IO (Ptr Box)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Box
box
    maybeMin <- case min 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
jMin -> do
            jMin' <- Vec3 -> IO (Ptr Vec3)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Vec3
jMin
            return jMin'
    maybeMax <- case max 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
jMax -> do
            jMax' <- Vec3 -> IO (Ptr Vec3)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Vec3
jMax
            return jMax'
    result <- graphene_box_init_from_vec3 box' maybeMin maybeMax
    checkUnexpectedReturnNULL "boxInitFromVec3" result
    result' <- (newBoxed Box) result
    touchManagedPtr box
    whenJust min touchManagedPtr
    whenJust max touchManagedPtr
    return result'

#if defined(ENABLE_OVERLOADING)
data BoxInitFromVec3MethodInfo
instance (signature ~ (Maybe (Graphene.Vec3.Vec3) -> Maybe (Graphene.Vec3.Vec3) -> m Box), MonadIO m) => O.OverloadedMethod BoxInitFromVec3MethodInfo Box signature where
    overloadedMethod = boxInitFromVec3

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


#endif

-- method Box::init_from_vectors
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "box"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Box" }
--           , argCType = Just "graphene_box_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #graphene_box_t to initialize"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "n_vectors"
--           , argType = TBasicType TUInt
--           , argCType = Just "unsigned int"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the number #graphene_point3d_t in the @vectors array"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "vectors"
--           , argType =
--               TCArray
--                 False
--                 (-1)
--                 1
--                 (TInterface Name { namespace = "Graphene" , name = "Vec3" })
--           , argCType = Just "const graphene_vec3_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an array of #graphene_vec3_t"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: [ Arg
--              { argCName = "n_vectors"
--              , argType = TBasicType TUInt
--              , argCType = Just "unsigned int"
--              , direction = DirectionIn
--              , mayBeNull = False
--              , argDoc =
--                  Documentation
--                    { rawDocText =
--                        Just "the number #graphene_point3d_t in the @vectors array"
--                    , sinceVersion = Nothing
--                    }
--              , argScope = ScopeTypeInvalid
--              , argClosure = -1
--              , argDestroy = -1
--              , argCallerAllocates = False
--              , argCallbackUserData = False
--              , transfer = TransferNothing
--              }
--          ]
-- returnType: Just (TInterface Name { namespace = "Graphene" , name = "Box" })
-- throws : False
-- Skip return : False

foreign import ccall "graphene_box_init_from_vectors" graphene_box_init_from_vectors :: 
    Ptr Box ->                              -- box : TInterface (Name {namespace = "Graphene", name = "Box"})
    Word32 ->                               -- n_vectors : TBasicType TUInt
    Ptr Graphene.Vec3.Vec3 ->               -- vectors : TCArray False (-1) 1 (TInterface (Name {namespace = "Graphene", name = "Vec3"}))
    IO (Ptr Box)

-- | Initializes the given t'GI.Graphene.Structs.Box.Box' with the given array
-- of vertices.
-- 
-- If /@nVectors@/ is 0, the returned box is initialized with
-- 'GI.Graphene.Functions.boxEmpty'.
-- 
-- /Since: 1.2/
boxInitFromVectors ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Box
    -- ^ /@box@/: the t'GI.Graphene.Structs.Box.Box' to initialize
    -> [Graphene.Vec3.Vec3]
    -- ^ /@vectors@/: an array of t'GI.Graphene.Structs.Vec3.Vec3'
    -> m Box
    -- ^ __Returns:__ the initialized t'GI.Graphene.Structs.Box.Box'
boxInitFromVectors :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Box -> [Vec3] -> m Box
boxInitFromVectors Box
box [Vec3]
vectors = 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
    let nVectors :: Word32
nVectors = Int -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Word32) -> Int -> Word32
forall a b. (a -> b) -> a -> b
$ [Vec3] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
P.length [Vec3]
vectors
    box' <- Box -> IO (Ptr Box)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Box
box
    vectors' <- mapM unsafeManagedPtrGetPtr vectors
    vectors'' <- packBlockArray 16 vectors'
    result <- graphene_box_init_from_vectors box' nVectors vectors''
    checkUnexpectedReturnNULL "boxInitFromVectors" result
    result' <- (newBoxed Box) result
    touchManagedPtr box
    mapM_ touchManagedPtr vectors
    freeMem vectors''
    return result'

#if defined(ENABLE_OVERLOADING)
data BoxInitFromVectorsMethodInfo
instance (signature ~ ([Graphene.Vec3.Vec3] -> m Box), MonadIO m) => O.OverloadedMethod BoxInitFromVectorsMethodInfo Box signature where
    overloadedMethod = boxInitFromVectors

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


#endif

-- method Box::intersection
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "a"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Box" }
--           , argCType = Just "const graphene_box_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_box_t" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "b"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Box" }
--           , argCType = Just "const graphene_box_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_box_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 result"
--                 , 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_box_intersection" graphene_box_intersection :: 
    Ptr Box ->                              -- a : TInterface (Name {namespace = "Graphene", name = "Box"})
    Ptr Box ->                              -- b : TInterface (Name {namespace = "Graphene", name = "Box"})
    Ptr Box ->                              -- res : TInterface (Name {namespace = "Graphene", name = "Box"})
    IO CInt

-- | Intersects the two given t'GI.Graphene.Structs.Box.Box'.
-- 
-- If the two boxes do not intersect, /@res@/ will contain a degenerate box
-- initialized with 'GI.Graphene.Functions.boxEmpty'.
-- 
-- /Since: 1.2/
boxIntersection ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Box
    -- ^ /@a@/: a t'GI.Graphene.Structs.Box.Box'
    -> Box
    -- ^ /@b@/: a t'GI.Graphene.Structs.Box.Box'
    -> m ((Bool, Box))
    -- ^ __Returns:__ true if the two boxes intersect
boxIntersection :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Box -> Box -> m (Bool, Box)
boxIntersection Box
a Box
b = IO (Bool, Box) -> m (Bool, Box)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Box) -> m (Bool, Box))
-> IO (Bool, Box) -> m (Bool, Box)
forall a b. (a -> b) -> a -> b
$ do
    a' <- Box -> IO (Ptr Box)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Box
a
    b' <- unsafeManagedPtrGetPtr b
    res <- SP.callocBoxedBytes 32 :: IO (Ptr Box)
    result <- graphene_box_intersection a' b' res
    let result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    res' <- (wrapBoxed Box) res
    touchManagedPtr a
    touchManagedPtr b
    return (result', res')

#if defined(ENABLE_OVERLOADING)
data BoxIntersectionMethodInfo
instance (signature ~ (Box -> m ((Bool, Box))), MonadIO m) => O.OverloadedMethod BoxIntersectionMethodInfo Box signature where
    overloadedMethod = boxIntersection

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


#endif

-- method Box::union
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "a"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Box" }
--           , argCType = Just "const graphene_box_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_box_t" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "b"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Box" }
--           , argCType = Just "const graphene_box_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the box to union to @a"
--                 , 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 result"
--                 , 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_box_union" graphene_box_union :: 
    Ptr Box ->                              -- a : TInterface (Name {namespace = "Graphene", name = "Box"})
    Ptr Box ->                              -- b : TInterface (Name {namespace = "Graphene", name = "Box"})
    Ptr Box ->                              -- res : TInterface (Name {namespace = "Graphene", name = "Box"})
    IO ()

-- | Unions the two given t'GI.Graphene.Structs.Box.Box'.
-- 
-- /Since: 1.2/
boxUnion ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Box
    -- ^ /@a@/: a t'GI.Graphene.Structs.Box.Box'
    -> Box
    -- ^ /@b@/: the box to union to /@a@/
    -> m (Box)
boxUnion :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Box -> Box -> m Box
boxUnion Box
a Box
b = 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
    a' <- Box -> IO (Ptr Box)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Box
a
    b' <- unsafeManagedPtrGetPtr b
    res <- SP.callocBoxedBytes 32 :: IO (Ptr Box)
    graphene_box_union a' b' res
    res' <- (wrapBoxed Box) res
    touchManagedPtr a
    touchManagedPtr b
    return res'

#if defined(ENABLE_OVERLOADING)
data BoxUnionMethodInfo
instance (signature ~ (Box -> m (Box)), MonadIO m) => O.OverloadedMethod BoxUnionMethodInfo Box signature where
    overloadedMethod = boxUnion

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


#endif

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

foreign import ccall "graphene_box_empty" graphene_box_empty :: 
    IO (Ptr Box)

-- | A degenerate t'GI.Graphene.Structs.Box.Box' that can only be expanded.
-- 
-- The returned value is owned by Graphene and should not be modified or freed.
-- 
-- /Since: 1.2/
boxEmpty ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m Box
    -- ^ __Returns:__ a t'GI.Graphene.Structs.Box.Box'
boxEmpty :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m Box
boxEmpty  = 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
    result <- IO (Ptr Box)
graphene_box_empty
    checkUnexpectedReturnNULL "boxEmpty" result
    result' <- (newBoxed Box) result
    return result'

#if defined(ENABLE_OVERLOADING)
#endif

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

foreign import ccall "graphene_box_infinite" graphene_box_infinite :: 
    IO (Ptr Box)

-- | A degenerate t'GI.Graphene.Structs.Box.Box' that cannot be expanded.
-- 
-- The returned value is owned by Graphene and should not be modified or freed.
-- 
-- /Since: 1.2/
boxInfinite ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m Box
    -- ^ __Returns:__ a t'GI.Graphene.Structs.Box.Box'
boxInfinite :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m Box
boxInfinite  = 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
    result <- IO (Ptr Box)
graphene_box_infinite
    checkUnexpectedReturnNULL "boxInfinite" result
    result' <- (newBoxed Box) result
    return result'

#if defined(ENABLE_OVERLOADING)
#endif

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

foreign import ccall "graphene_box_minus_one" graphene_box_minus_one :: 
    IO (Ptr Box)

-- | A t'GI.Graphene.Structs.Box.Box' with the minimum vertex set at (-1, -1, -1) and the
-- maximum vertex set at (0, 0, 0).
-- 
-- The returned value is owned by Graphene and should not be modified or freed.
-- 
-- /Since: 1.2/
boxMinusOne ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m Box
    -- ^ __Returns:__ a t'GI.Graphene.Structs.Box.Box'
boxMinusOne :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m Box
boxMinusOne  = 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
    result <- IO (Ptr Box)
graphene_box_minus_one
    checkUnexpectedReturnNULL "boxMinusOne" result
    result' <- (newBoxed Box) result
    return result'

#if defined(ENABLE_OVERLOADING)
#endif

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

foreign import ccall "graphene_box_one" graphene_box_one :: 
    IO (Ptr Box)

-- | A t'GI.Graphene.Structs.Box.Box' with the minimum vertex set at (0, 0, 0) and the
-- maximum vertex set at (1, 1, 1).
-- 
-- The returned value is owned by Graphene and should not be modified or freed.
-- 
-- /Since: 1.2/
boxOne ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m Box
    -- ^ __Returns:__ a t'GI.Graphene.Structs.Box.Box'
boxOne :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m Box
boxOne  = 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
    result <- IO (Ptr Box)
graphene_box_one
    checkUnexpectedReturnNULL "boxOne" result
    result' <- (newBoxed Box) result
    return result'

#if defined(ENABLE_OVERLOADING)
#endif

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

foreign import ccall "graphene_box_one_minus_one" graphene_box_one_minus_one :: 
    IO (Ptr Box)

-- | A t'GI.Graphene.Structs.Box.Box' with the minimum vertex set at (-1, -1, -1) and the
-- maximum vertex set at (1, 1, 1).
-- 
-- The returned value is owned by Graphene and should not be modified or freed.
-- 
-- /Since: 1.2/
boxOneMinusOne ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m Box
    -- ^ __Returns:__ a t'GI.Graphene.Structs.Box.Box'
boxOneMinusOne :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m Box
boxOneMinusOne  = 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
    result <- IO (Ptr Box)
graphene_box_one_minus_one
    checkUnexpectedReturnNULL "boxOneMinusOne" result
    result' <- (newBoxed Box) result
    return result'

#if defined(ENABLE_OVERLOADING)
#endif

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

foreign import ccall "graphene_box_zero" graphene_box_zero :: 
    IO (Ptr Box)

-- | A t'GI.Graphene.Structs.Box.Box' with both the minimum and maximum vertices set at (0, 0, 0).
-- 
-- The returned value is owned by Graphene and should not be modified or freed.
-- 
-- /Since: 1.2/
boxZero ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m Box
    -- ^ __Returns:__ a t'GI.Graphene.Structs.Box.Box'
boxZero :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m Box
boxZero  = 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
    result <- IO (Ptr Box)
graphene_box_zero
    checkUnexpectedReturnNULL "boxZero" result
    result' <- (newBoxed Box) result
    return result'

#if defined(ENABLE_OVERLOADING)
#endif

#if defined(ENABLE_OVERLOADING)
type family ResolveBoxMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
    ResolveBoxMethod "containsBox" o = BoxContainsBoxMethodInfo
    ResolveBoxMethod "containsPoint" o = BoxContainsPointMethodInfo
    ResolveBoxMethod "equal" o = BoxEqualMethodInfo
    ResolveBoxMethod "expand" o = BoxExpandMethodInfo
    ResolveBoxMethod "expandScalar" o = BoxExpandScalarMethodInfo
    ResolveBoxMethod "expandVec3" o = BoxExpandVec3MethodInfo
    ResolveBoxMethod "free" o = BoxFreeMethodInfo
    ResolveBoxMethod "init" o = BoxInitMethodInfo
    ResolveBoxMethod "initFromBox" o = BoxInitFromBoxMethodInfo
    ResolveBoxMethod "initFromPoints" o = BoxInitFromPointsMethodInfo
    ResolveBoxMethod "initFromVec3" o = BoxInitFromVec3MethodInfo
    ResolveBoxMethod "initFromVectors" o = BoxInitFromVectorsMethodInfo
    ResolveBoxMethod "intersection" o = BoxIntersectionMethodInfo
    ResolveBoxMethod "union" o = BoxUnionMethodInfo
    ResolveBoxMethod "getBoundingSphere" o = BoxGetBoundingSphereMethodInfo
    ResolveBoxMethod "getCenter" o = BoxGetCenterMethodInfo
    ResolveBoxMethod "getDepth" o = BoxGetDepthMethodInfo
    ResolveBoxMethod "getHeight" o = BoxGetHeightMethodInfo
    ResolveBoxMethod "getMax" o = BoxGetMaxMethodInfo
    ResolveBoxMethod "getMin" o = BoxGetMinMethodInfo
    ResolveBoxMethod "getSize" o = BoxGetSizeMethodInfo
    ResolveBoxMethod "getWidth" o = BoxGetWidthMethodInfo
    ResolveBoxMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveBoxMethod t Box, O.OverloadedMethod info Box p) => OL.IsLabel t (Box -> 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 ~ ResolveBoxMethod t Box, O.OverloadedMethod info Box p, R.HasField t Box p) => R.HasField t Box p where
    getField = O.overloadedMethod @info

#endif

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

#endif