{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- A point with three components: X, Y, and Z.
-- 
-- /Since: 1.0/

#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif

module GI.Graphene.Structs.Point3D
    ( 

-- * Exported types
    Point3D(..)                             ,
    newZeroPoint3D                          ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [cross]("GI.Graphene.Structs.Point3D#g:method:cross"), [distance]("GI.Graphene.Structs.Point3D#g:method:distance"), [dot]("GI.Graphene.Structs.Point3D#g:method:dot"), [equal]("GI.Graphene.Structs.Point3D#g:method:equal"), [free]("GI.Graphene.Structs.Point3D#g:method:free"), [init]("GI.Graphene.Structs.Point3D#g:method:init"), [initFromPoint]("GI.Graphene.Structs.Point3D#g:method:initFromPoint"), [initFromVec3]("GI.Graphene.Structs.Point3D#g:method:initFromVec3"), [interpolate]("GI.Graphene.Structs.Point3D#g:method:interpolate"), [length]("GI.Graphene.Structs.Point3D#g:method:length"), [near]("GI.Graphene.Structs.Point3D#g:method:near"), [normalize]("GI.Graphene.Structs.Point3D#g:method:normalize"), [normalizeViewport]("GI.Graphene.Structs.Point3D#g:method:normalizeViewport"), [scale]("GI.Graphene.Structs.Point3D#g:method:scale"), [toVec3]("GI.Graphene.Structs.Point3D#g:method:toVec3").
-- 
-- ==== Getters
-- /None/.
-- 
-- ==== Setters
-- /None/.

#if defined(ENABLE_OVERLOADING)
    ResolvePoint3DMethod                    ,
#endif

-- ** alloc #method:alloc#

    point3DAlloc                            ,


-- ** cross #method:cross#

#if defined(ENABLE_OVERLOADING)
    Point3DCrossMethodInfo                  ,
#endif
    point3DCross                            ,


-- ** distance #method:distance#

#if defined(ENABLE_OVERLOADING)
    Point3DDistanceMethodInfo               ,
#endif
    point3DDistance                         ,


-- ** dot #method:dot#

#if defined(ENABLE_OVERLOADING)
    Point3DDotMethodInfo                    ,
#endif
    point3DDot                              ,


-- ** equal #method:equal#

#if defined(ENABLE_OVERLOADING)
    Point3DEqualMethodInfo                  ,
#endif
    point3DEqual                            ,


-- ** free #method:free#

#if defined(ENABLE_OVERLOADING)
    Point3DFreeMethodInfo                   ,
#endif
    point3DFree                             ,


-- ** init #method:init#

#if defined(ENABLE_OVERLOADING)
    Point3DInitMethodInfo                   ,
#endif
    point3DInit                             ,


-- ** initFromPoint #method:initFromPoint#

#if defined(ENABLE_OVERLOADING)
    Point3DInitFromPointMethodInfo          ,
#endif
    point3DInitFromPoint                    ,


-- ** initFromVec3 #method:initFromVec3#

#if defined(ENABLE_OVERLOADING)
    Point3DInitFromVec3MethodInfo           ,
#endif
    point3DInitFromVec3                     ,


-- ** interpolate #method:interpolate#

#if defined(ENABLE_OVERLOADING)
    Point3DInterpolateMethodInfo            ,
#endif
    point3DInterpolate                      ,


-- ** length #method:length#

#if defined(ENABLE_OVERLOADING)
    Point3DLengthMethodInfo                 ,
#endif
    point3DLength                           ,


-- ** near #method:near#

#if defined(ENABLE_OVERLOADING)
    Point3DNearMethodInfo                   ,
#endif
    point3DNear                             ,


-- ** normalize #method:normalize#

#if defined(ENABLE_OVERLOADING)
    Point3DNormalizeMethodInfo              ,
#endif
    point3DNormalize                        ,


-- ** normalizeViewport #method:normalizeViewport#

#if defined(ENABLE_OVERLOADING)
    Point3DNormalizeViewportMethodInfo      ,
#endif
    point3DNormalizeViewport                ,


-- ** scale #method:scale#

#if defined(ENABLE_OVERLOADING)
    Point3DScaleMethodInfo                  ,
#endif
    point3DScale                            ,


-- ** toVec3 #method:toVec3#

#if defined(ENABLE_OVERLOADING)
    Point3DToVec3MethodInfo                 ,
#endif
    point3DToVec3                           ,


-- ** zero #method:zero#

    point3DZero                             ,




 -- * Properties


-- ** x #attr:x#
-- | the X coordinate

    getPoint3DX                             ,
#if defined(ENABLE_OVERLOADING)
    point3D_x                               ,
#endif
    setPoint3DX                             ,


-- ** y #attr:y#
-- | the Y coordinate

    getPoint3DY                             ,
#if defined(ENABLE_OVERLOADING)
    point3D_y                               ,
#endif
    setPoint3DY                             ,


-- ** z #attr:z#
-- | the Z coordinate

    getPoint3DZ                             ,
#if defined(ENABLE_OVERLOADING)
    point3D_z                               ,
#endif
    setPoint3DZ                             ,




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

#endif

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

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

foreign import ccall "graphene_point3d_get_type" c_graphene_point3d_get_type :: 
    IO GType

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

instance B.Types.TypedObject Point3D where
    glibType :: IO GType
glibType = IO GType
c_graphene_point3d_get_type

instance B.Types.GBoxed Point3D

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

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

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


-- | Get the value of the “@x@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' point3D #x
-- @
getPoint3DX :: MonadIO m => Point3D -> m Float
getPoint3DX :: forall (m :: * -> *). MonadIO m => Point3D -> m Float
getPoint3DX Point3D
s = 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
$ Point3D -> (Ptr Point3D -> IO Float) -> IO Float
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Point3D
s ((Ptr Point3D -> IO Float) -> IO Float)
-> (Ptr Point3D -> IO Float) -> IO Float
forall a b. (a -> b) -> a -> b
$ \Ptr Point3D
ptr -> do
    val <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek (Ptr Point3D
ptr Ptr Point3D -> Int -> Ptr CFloat
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) :: IO CFloat
    let val' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
val
    return val'

-- | Set the value of the “@x@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' point3D [ #x 'Data.GI.Base.Attributes.:=' value ]
-- @
setPoint3DX :: MonadIO m => Point3D -> Float -> m ()
setPoint3DX :: forall (m :: * -> *). MonadIO m => Point3D -> Float -> m ()
setPoint3DX Point3D
s Float
val = 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
$ Point3D -> (Ptr Point3D -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Point3D
s ((Ptr Point3D -> IO ()) -> IO ())
-> (Ptr Point3D -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr Point3D
ptr -> do
    let val' :: CFloat
val' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
val
    Ptr CFloat -> CFloat -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Point3D
ptr Ptr Point3D -> Int -> Ptr CFloat
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) (CFloat
val' :: CFloat)

#if defined(ENABLE_OVERLOADING)
data Point3DXFieldInfo
instance AttrInfo Point3DXFieldInfo where
    type AttrBaseTypeConstraint Point3DXFieldInfo = (~) Point3D
    type AttrAllowedOps Point3DXFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint Point3DXFieldInfo = (~) Float
    type AttrTransferTypeConstraint Point3DXFieldInfo = (~)Float
    type AttrTransferType Point3DXFieldInfo = Float
    type AttrGetType Point3DXFieldInfo = Float
    type AttrLabel Point3DXFieldInfo = "x"
    type AttrOrigin Point3DXFieldInfo = Point3D
    attrGet = getPoint3DX
    attrSet = setPoint3DX
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Graphene.Structs.Point3D.x"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-graphene-1.0.8/docs/GI-Graphene-Structs-Point3D.html#g:attr:x"
        })

point3D_x :: AttrLabelProxy "x"
point3D_x = AttrLabelProxy

#endif


-- | Get the value of the “@y@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' point3D #y
-- @
getPoint3DY :: MonadIO m => Point3D -> m Float
getPoint3DY :: forall (m :: * -> *). MonadIO m => Point3D -> m Float
getPoint3DY Point3D
s = 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
$ Point3D -> (Ptr Point3D -> IO Float) -> IO Float
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Point3D
s ((Ptr Point3D -> IO Float) -> IO Float)
-> (Ptr Point3D -> IO Float) -> IO Float
forall a b. (a -> b) -> a -> b
$ \Ptr Point3D
ptr -> do
    val <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek (Ptr Point3D
ptr Ptr Point3D -> Int -> Ptr CFloat
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
4) :: IO CFloat
    let val' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
val
    return val'

-- | Set the value of the “@y@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' point3D [ #y 'Data.GI.Base.Attributes.:=' value ]
-- @
setPoint3DY :: MonadIO m => Point3D -> Float -> m ()
setPoint3DY :: forall (m :: * -> *). MonadIO m => Point3D -> Float -> m ()
setPoint3DY Point3D
s Float
val = 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
$ Point3D -> (Ptr Point3D -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Point3D
s ((Ptr Point3D -> IO ()) -> IO ())
-> (Ptr Point3D -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr Point3D
ptr -> do
    let val' :: CFloat
val' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
val
    Ptr CFloat -> CFloat -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Point3D
ptr Ptr Point3D -> Int -> Ptr CFloat
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
4) (CFloat
val' :: CFloat)

#if defined(ENABLE_OVERLOADING)
data Point3DYFieldInfo
instance AttrInfo Point3DYFieldInfo where
    type AttrBaseTypeConstraint Point3DYFieldInfo = (~) Point3D
    type AttrAllowedOps Point3DYFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint Point3DYFieldInfo = (~) Float
    type AttrTransferTypeConstraint Point3DYFieldInfo = (~)Float
    type AttrTransferType Point3DYFieldInfo = Float
    type AttrGetType Point3DYFieldInfo = Float
    type AttrLabel Point3DYFieldInfo = "y"
    type AttrOrigin Point3DYFieldInfo = Point3D
    attrGet = getPoint3DY
    attrSet = setPoint3DY
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Graphene.Structs.Point3D.y"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-graphene-1.0.8/docs/GI-Graphene-Structs-Point3D.html#g:attr:y"
        })

point3D_y :: AttrLabelProxy "y"
point3D_y = AttrLabelProxy

#endif


-- | Get the value of the “@z@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' point3D #z
-- @
getPoint3DZ :: MonadIO m => Point3D -> m Float
getPoint3DZ :: forall (m :: * -> *). MonadIO m => Point3D -> m Float
getPoint3DZ Point3D
s = 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
$ Point3D -> (Ptr Point3D -> IO Float) -> IO Float
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Point3D
s ((Ptr Point3D -> IO Float) -> IO Float)
-> (Ptr Point3D -> IO Float) -> IO Float
forall a b. (a -> b) -> a -> b
$ \Ptr Point3D
ptr -> do
    val <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek (Ptr Point3D
ptr Ptr Point3D -> Int -> Ptr CFloat
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) :: IO CFloat
    let val' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
val
    return val'

-- | Set the value of the “@z@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' point3D [ #z 'Data.GI.Base.Attributes.:=' value ]
-- @
setPoint3DZ :: MonadIO m => Point3D -> Float -> m ()
setPoint3DZ :: forall (m :: * -> *). MonadIO m => Point3D -> Float -> m ()
setPoint3DZ Point3D
s Float
val = 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
$ Point3D -> (Ptr Point3D -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Point3D
s ((Ptr Point3D -> IO ()) -> IO ())
-> (Ptr Point3D -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr Point3D
ptr -> do
    let val' :: CFloat
val' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
val
    Ptr CFloat -> CFloat -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Point3D
ptr Ptr Point3D -> Int -> Ptr CFloat
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) (CFloat
val' :: CFloat)

#if defined(ENABLE_OVERLOADING)
data Point3DZFieldInfo
instance AttrInfo Point3DZFieldInfo where
    type AttrBaseTypeConstraint Point3DZFieldInfo = (~) Point3D
    type AttrAllowedOps Point3DZFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint Point3DZFieldInfo = (~) Float
    type AttrTransferTypeConstraint Point3DZFieldInfo = (~)Float
    type AttrTransferType Point3DZFieldInfo = Float
    type AttrGetType Point3DZFieldInfo = Float
    type AttrLabel Point3DZFieldInfo = "z"
    type AttrOrigin Point3DZFieldInfo = Point3D
    attrGet = getPoint3DZ
    attrSet = setPoint3DZ
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Graphene.Structs.Point3D.z"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-graphene-1.0.8/docs/GI-Graphene-Structs-Point3D.html#g:attr:z"
        })

point3D_z :: AttrLabelProxy "z"
point3D_z = AttrLabelProxy

#endif



#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Point3D
type instance O.AttributeList Point3D = Point3DAttributeList
type Point3DAttributeList = ('[ '("x", Point3DXFieldInfo), '("y", Point3DYFieldInfo), '("z", Point3DZFieldInfo)] :: [(Symbol, DK.Type)])
#endif

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

foreign import ccall "graphene_point3d_alloc" graphene_point3d_alloc :: 
    IO (Ptr Point3D)

-- | Allocates a t'GI.Graphene.Structs.Point3D.Point3D' structure.
-- 
-- /Since: 1.0/
point3DAlloc ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m Point3D
    -- ^ __Returns:__ the newly allocated structure.
    --   Use 'GI.Graphene.Structs.Point3D.point3DFree' to free the resources
    --   allocated by this function.
point3DAlloc :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m Point3D
point3DAlloc  = 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
    result <- IO (Ptr Point3D)
graphene_point3d_alloc
    checkUnexpectedReturnNULL "point3DAlloc" result
    result' <- (wrapBoxed Point3D) result
    return result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method Point3D::cross
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "a"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Point3D" }
--           , argCType = Just "const graphene_point3d_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_point3d_t"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "b"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Point3D" }
--           , argCType = Just "const graphene_point3d_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_point3d_t"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "res"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Point3D" }
--           , argCType = Just "graphene_point3d_t*"
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "return location for the cross\n  product"
--                 , 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_point3d_cross" graphene_point3d_cross :: 
    Ptr Point3D ->                          -- a : TInterface (Name {namespace = "Graphene", name = "Point3D"})
    Ptr Point3D ->                          -- b : TInterface (Name {namespace = "Graphene", name = "Point3D"})
    Ptr Point3D ->                          -- res : TInterface (Name {namespace = "Graphene", name = "Point3D"})
    IO ()

-- | Computes the cross product of the two given t'GI.Graphene.Structs.Point3D.Point3D'.
-- 
-- /Since: 1.0/
point3DCross ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Point3D
    -- ^ /@a@/: a t'GI.Graphene.Structs.Point3D.Point3D'
    -> Point3D
    -- ^ /@b@/: a t'GI.Graphene.Structs.Point3D.Point3D'
    -> m (Point3D)
point3DCross :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Point3D -> Point3D -> m Point3D
point3DCross Point3D
a Point3D
b = 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
    a' <- Point3D -> IO (Ptr Point3D)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Point3D
a
    b' <- unsafeManagedPtrGetPtr b
    res <- SP.callocBoxedBytes 12 :: IO (Ptr Point3D)
    graphene_point3d_cross a' b' res
    res' <- (wrapBoxed Point3D) res
    touchManagedPtr a
    touchManagedPtr b
    return res'

#if defined(ENABLE_OVERLOADING)
data Point3DCrossMethodInfo
instance (signature ~ (Point3D -> m (Point3D)), MonadIO m) => O.OverloadedMethod Point3DCrossMethodInfo Point3D signature where
    overloadedMethod = point3DCross

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


#endif

-- method Point3D::distance
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "a"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Point3D" }
--           , argCType = Just "const graphene_point3d_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_point3d_t"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "b"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Point3D" }
--           , argCType = Just "const graphene_point3d_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_point3d_t"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "delta"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Vec3" }
--           , argCType = Just "graphene_vec3_t*"
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "return location for the distance\n  components on the X, Y, and Z axis"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = True
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TFloat)
-- throws : False
-- Skip return : False

foreign import ccall "graphene_point3d_distance" graphene_point3d_distance :: 
    Ptr Point3D ->                          -- a : TInterface (Name {namespace = "Graphene", name = "Point3D"})
    Ptr Point3D ->                          -- b : TInterface (Name {namespace = "Graphene", name = "Point3D"})
    Ptr Graphene.Vec3.Vec3 ->               -- delta : TInterface (Name {namespace = "Graphene", name = "Vec3"})
    IO CFloat

-- | Computes the distance between the two given t'GI.Graphene.Structs.Point3D.Point3D'.
-- 
-- /Since: 1.4/
point3DDistance ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Point3D
    -- ^ /@a@/: a t'GI.Graphene.Structs.Point3D.Point3D'
    -> Point3D
    -- ^ /@b@/: a t'GI.Graphene.Structs.Point3D.Point3D'
    -> m ((Float, Graphene.Vec3.Vec3))
    -- ^ __Returns:__ the distance between two points
point3DDistance :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Point3D -> Point3D -> m (Float, Vec3)
point3DDistance Point3D
a Point3D
b = IO (Float, Vec3) -> m (Float, Vec3)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Float, Vec3) -> m (Float, Vec3))
-> IO (Float, Vec3) -> m (Float, Vec3)
forall a b. (a -> b) -> a -> b
$ do
    a' <- Point3D -> IO (Ptr Point3D)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Point3D
a
    b' <- unsafeManagedPtrGetPtr b
    delta <- SP.callocBoxedBytes 16 :: IO (Ptr Graphene.Vec3.Vec3)
    result <- graphene_point3d_distance a' b' delta
    let result' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
result
    delta' <- (wrapBoxed Graphene.Vec3.Vec3) delta
    touchManagedPtr a
    touchManagedPtr b
    return (result', delta')

#if defined(ENABLE_OVERLOADING)
data Point3DDistanceMethodInfo
instance (signature ~ (Point3D -> m ((Float, Graphene.Vec3.Vec3))), MonadIO m) => O.OverloadedMethod Point3DDistanceMethodInfo Point3D signature where
    overloadedMethod = point3DDistance

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


#endif

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

foreign import ccall "graphene_point3d_dot" graphene_point3d_dot :: 
    Ptr Point3D ->                          -- a : TInterface (Name {namespace = "Graphene", name = "Point3D"})
    Ptr Point3D ->                          -- b : TInterface (Name {namespace = "Graphene", name = "Point3D"})
    IO CFloat

-- | Computes the dot product of the two given t'GI.Graphene.Structs.Point3D.Point3D'.
-- 
-- /Since: 1.0/
point3DDot ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Point3D
    -- ^ /@a@/: a t'GI.Graphene.Structs.Point3D.Point3D'
    -> Point3D
    -- ^ /@b@/: a t'GI.Graphene.Structs.Point3D.Point3D'
    -> m Float
    -- ^ __Returns:__ the value of the dot product
point3DDot :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Point3D -> Point3D -> m Float
point3DDot Point3D
a Point3D
b = 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
    a' <- Point3D -> IO (Ptr Point3D)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Point3D
a
    b' <- unsafeManagedPtrGetPtr b
    result <- graphene_point3d_dot a' b'
    let result' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
result
    touchManagedPtr a
    touchManagedPtr b
    return result'

#if defined(ENABLE_OVERLOADING)
data Point3DDotMethodInfo
instance (signature ~ (Point3D -> m Float), MonadIO m) => O.OverloadedMethod Point3DDotMethodInfo Point3D signature where
    overloadedMethod = point3DDot

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


#endif

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

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

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

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


#endif

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

foreign import ccall "graphene_point3d_free" graphene_point3d_free :: 
    Ptr Point3D ->                          -- p : TInterface (Name {namespace = "Graphene", name = "Point3D"})
    IO ()

-- | Frees the resources allocated via 'GI.Graphene.Structs.Point3D.point3DAlloc'.
-- 
-- /Since: 1.0/
point3DFree ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Point3D
    -- ^ /@p@/: a t'GI.Graphene.Structs.Point3D.Point3D'
    -> m ()
point3DFree :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Point3D -> m ()
point3DFree Point3D
p = 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
    p' <- Point3D -> IO (Ptr Point3D)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Point3D
p
    graphene_point3d_free p'
    touchManagedPtr p
    return ()

#if defined(ENABLE_OVERLOADING)
data Point3DFreeMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod Point3DFreeMethodInfo Point3D signature where
    overloadedMethod = point3DFree

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


#endif

-- method Point3D::init
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "p"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Point3D" }
--           , argCType = Just "graphene_point3d_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #graphene_point3d_t to initialize"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "x"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the X coordinate of the point"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "y"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the Y coordinate of the point"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "z"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the Z coordinate of the point"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "Graphene" , name = "Point3D" })
-- throws : False
-- Skip return : False

foreign import ccall "graphene_point3d_init" graphene_point3d_init :: 
    Ptr Point3D ->                          -- p : TInterface (Name {namespace = "Graphene", name = "Point3D"})
    CFloat ->                               -- x : TBasicType TFloat
    CFloat ->                               -- y : TBasicType TFloat
    CFloat ->                               -- z : TBasicType TFloat
    IO (Ptr Point3D)

-- | Initializes a t'GI.Graphene.Structs.Point3D.Point3D' with the given coordinates.
-- 
-- /Since: 1.0/
point3DInit ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Point3D
    -- ^ /@p@/: the t'GI.Graphene.Structs.Point3D.Point3D' to initialize
    -> Float
    -- ^ /@x@/: the X coordinate of the point
    -> Float
    -- ^ /@y@/: the Y coordinate of the point
    -> Float
    -- ^ /@z@/: the Z coordinate of the point
    -> m Point3D
    -- ^ __Returns:__ the initialized t'GI.Graphene.Structs.Point3D.Point3D'
point3DInit :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Point3D -> Float -> Float -> Float -> m Point3D
point3DInit Point3D
p Float
x Float
y Float
z = 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
    p' <- Point3D -> IO (Ptr Point3D)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Point3D
p
    let x' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
x
    let y' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
y
    let z' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
z
    result <- graphene_point3d_init p' x' y' z'
    checkUnexpectedReturnNULL "point3DInit" result
    result' <- (newBoxed Point3D) result
    touchManagedPtr p
    return result'

#if defined(ENABLE_OVERLOADING)
data Point3DInitMethodInfo
instance (signature ~ (Float -> Float -> Float -> m Point3D), MonadIO m) => O.OverloadedMethod Point3DInitMethodInfo Point3D signature where
    overloadedMethod = point3DInit

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


#endif

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

foreign import ccall "graphene_point3d_init_from_point" graphene_point3d_init_from_point :: 
    Ptr Point3D ->                          -- p : TInterface (Name {namespace = "Graphene", name = "Point3D"})
    Ptr Point3D ->                          -- src : TInterface (Name {namespace = "Graphene", name = "Point3D"})
    IO (Ptr Point3D)

-- | Initializes a t'GI.Graphene.Structs.Point3D.Point3D' using the coordinates of
-- another t'GI.Graphene.Structs.Point3D.Point3D'.
-- 
-- /Since: 1.0/
point3DInitFromPoint ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Point3D
    -- ^ /@p@/: a t'GI.Graphene.Structs.Point3D.Point3D'
    -> Point3D
    -- ^ /@src@/: a t'GI.Graphene.Structs.Point3D.Point3D'
    -> m Point3D
    -- ^ __Returns:__ the initialized point
point3DInitFromPoint :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Point3D -> Point3D -> m Point3D
point3DInitFromPoint Point3D
p Point3D
src = 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
    p' <- Point3D -> IO (Ptr Point3D)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Point3D
p
    src' <- unsafeManagedPtrGetPtr src
    result <- graphene_point3d_init_from_point p' src'
    checkUnexpectedReturnNULL "point3DInitFromPoint" result
    result' <- (newBoxed Point3D) result
    touchManagedPtr p
    touchManagedPtr src
    return result'

#if defined(ENABLE_OVERLOADING)
data Point3DInitFromPointMethodInfo
instance (signature ~ (Point3D -> m Point3D), MonadIO m) => O.OverloadedMethod Point3DInitFromPointMethodInfo Point3D signature where
    overloadedMethod = point3DInitFromPoint

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


#endif

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

foreign import ccall "graphene_point3d_init_from_vec3" graphene_point3d_init_from_vec3 :: 
    Ptr Point3D ->                          -- p : TInterface (Name {namespace = "Graphene", name = "Point3D"})
    Ptr Graphene.Vec3.Vec3 ->               -- v : TInterface (Name {namespace = "Graphene", name = "Vec3"})
    IO (Ptr Point3D)

-- | Initializes a t'GI.Graphene.Structs.Point3D.Point3D' using the components
-- of a t'GI.Graphene.Structs.Vec3.Vec3'.
-- 
-- /Since: 1.0/
point3DInitFromVec3 ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Point3D
    -- ^ /@p@/: a t'GI.Graphene.Structs.Point3D.Point3D'
    -> Graphene.Vec3.Vec3
    -- ^ /@v@/: a t'GI.Graphene.Structs.Vec3.Vec3'
    -> m Point3D
    -- ^ __Returns:__ the initialized t'GI.Graphene.Structs.Point3D.Point3D'
point3DInitFromVec3 :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Point3D -> Vec3 -> m Point3D
point3DInitFromVec3 Point3D
p Vec3
v = 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
    p' <- Point3D -> IO (Ptr Point3D)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Point3D
p
    v' <- unsafeManagedPtrGetPtr v
    result <- graphene_point3d_init_from_vec3 p' v'
    checkUnexpectedReturnNULL "point3DInitFromVec3" result
    result' <- (newBoxed Point3D) result
    touchManagedPtr p
    touchManagedPtr v
    return result'

#if defined(ENABLE_OVERLOADING)
data Point3DInitFromVec3MethodInfo
instance (signature ~ (Graphene.Vec3.Vec3 -> m Point3D), MonadIO m) => O.OverloadedMethod Point3DInitFromVec3MethodInfo Point3D signature where
    overloadedMethod = point3DInitFromVec3

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


#endif

-- method Point3D::interpolate
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "a"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Point3D" }
--           , argCType = Just "const graphene_point3d_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_point3d_t"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "b"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Point3D" }
--           , argCType = Just "const graphene_point3d_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_point3d_t"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "factor"
--           , argType = TBasicType TDouble
--           , argCType = Just "double"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the interpolation factor"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "res"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Point3D" }
--           , argCType = Just "graphene_point3d_t*"
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "the return location for the\n  interpolated #graphene_point3d_t"
--                 , 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_point3d_interpolate" graphene_point3d_interpolate :: 
    Ptr Point3D ->                          -- a : TInterface (Name {namespace = "Graphene", name = "Point3D"})
    Ptr Point3D ->                          -- b : TInterface (Name {namespace = "Graphene", name = "Point3D"})
    CDouble ->                              -- factor : TBasicType TDouble
    Ptr Point3D ->                          -- res : TInterface (Name {namespace = "Graphene", name = "Point3D"})
    IO ()

-- | Linearly interpolates each component of /@a@/ and /@b@/ using the
-- provided /@factor@/, and places the result in /@res@/.
-- 
-- /Since: 1.0/
point3DInterpolate ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Point3D
    -- ^ /@a@/: a t'GI.Graphene.Structs.Point3D.Point3D'
    -> Point3D
    -- ^ /@b@/: a t'GI.Graphene.Structs.Point3D.Point3D'
    -> Double
    -- ^ /@factor@/: the interpolation factor
    -> m (Point3D)
point3DInterpolate :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Point3D -> Point3D -> Double -> m Point3D
point3DInterpolate Point3D
a Point3D
b Double
factor = 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
    a' <- Point3D -> IO (Ptr Point3D)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Point3D
a
    b' <- unsafeManagedPtrGetPtr b
    let factor' = Double -> CDouble
forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
factor
    res <- SP.callocBoxedBytes 12 :: IO (Ptr Point3D)
    graphene_point3d_interpolate a' b' factor' res
    res' <- (wrapBoxed Point3D) res
    touchManagedPtr a
    touchManagedPtr b
    return res'

#if defined(ENABLE_OVERLOADING)
data Point3DInterpolateMethodInfo
instance (signature ~ (Point3D -> Double -> m (Point3D)), MonadIO m) => O.OverloadedMethod Point3DInterpolateMethodInfo Point3D signature where
    overloadedMethod = point3DInterpolate

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


#endif

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

foreign import ccall "graphene_point3d_length" graphene_point3d_length :: 
    Ptr Point3D ->                          -- p : TInterface (Name {namespace = "Graphene", name = "Point3D"})
    IO CFloat

-- | Computes the length of the vector represented by the
-- coordinates of the given t'GI.Graphene.Structs.Point3D.Point3D'.
-- 
-- /Since: 1.0/
point3DLength ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Point3D
    -- ^ /@p@/: a t'GI.Graphene.Structs.Point3D.Point3D'
    -> m Float
    -- ^ __Returns:__ the length of the vector represented by the point
point3DLength :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Point3D -> m Float
point3DLength Point3D
p = 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
    p' <- Point3D -> IO (Ptr Point3D)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Point3D
p
    result <- graphene_point3d_length p'
    let result' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
result
    touchManagedPtr p
    return result'

#if defined(ENABLE_OVERLOADING)
data Point3DLengthMethodInfo
instance (signature ~ (m Float), MonadIO m) => O.OverloadedMethod Point3DLengthMethodInfo Point3D signature where
    overloadedMethod = point3DLength

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


#endif

-- method Point3D::near
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "a"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Point3D" }
--           , argCType = Just "const graphene_point3d_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_point3d_t"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "b"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Point3D" }
--           , argCType = Just "const graphene_point3d_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_point3d_t"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "epsilon"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "fuzzyness factor" , 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_point3d_near" graphene_point3d_near :: 
    Ptr Point3D ->                          -- a : TInterface (Name {namespace = "Graphene", name = "Point3D"})
    Ptr Point3D ->                          -- b : TInterface (Name {namespace = "Graphene", name = "Point3D"})
    CFloat ->                               -- epsilon : TBasicType TFloat
    IO CInt

-- | Checks whether the two points are near each other, within
-- an /@epsilon@/ factor.
-- 
-- /Since: 1.0/
point3DNear ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Point3D
    -- ^ /@a@/: a t'GI.Graphene.Structs.Point3D.Point3D'
    -> Point3D
    -- ^ /@b@/: a t'GI.Graphene.Structs.Point3D.Point3D'
    -> Float
    -- ^ /@epsilon@/: fuzzyness factor
    -> m Bool
    -- ^ __Returns:__ @true@ if the points are near each other
point3DNear :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Point3D -> Point3D -> Float -> m Bool
point3DNear Point3D
a Point3D
b Float
epsilon = 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' <- Point3D -> IO (Ptr Point3D)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Point3D
a
    b' <- unsafeManagedPtrGetPtr b
    let epsilon' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
epsilon
    result <- graphene_point3d_near a' b' epsilon'
    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 Point3DNearMethodInfo
instance (signature ~ (Point3D -> Float -> m Bool), MonadIO m) => O.OverloadedMethod Point3DNearMethodInfo Point3D signature where
    overloadedMethod = point3DNear

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


#endif

-- method Point3D::normalize
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "p"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Point3D" }
--           , argCType = Just "const graphene_point3d_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_point3d_t"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "res"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Point3D" }
--           , argCType = Just "graphene_point3d_t*"
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "return location for the normalized\n  #graphene_point3d_t"
--                 , 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_point3d_normalize" graphene_point3d_normalize :: 
    Ptr Point3D ->                          -- p : TInterface (Name {namespace = "Graphene", name = "Point3D"})
    Ptr Point3D ->                          -- res : TInterface (Name {namespace = "Graphene", name = "Point3D"})
    IO ()

-- | Computes the normalization of the vector represented by the
-- coordinates of the given t'GI.Graphene.Structs.Point3D.Point3D'.
-- 
-- /Since: 1.0/
point3DNormalize ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Point3D
    -- ^ /@p@/: a t'GI.Graphene.Structs.Point3D.Point3D'
    -> m (Point3D)
point3DNormalize :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Point3D -> m Point3D
point3DNormalize Point3D
p = 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
    p' <- Point3D -> IO (Ptr Point3D)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Point3D
p
    res <- SP.callocBoxedBytes 12 :: IO (Ptr Point3D)
    graphene_point3d_normalize p' res
    res' <- (wrapBoxed Point3D) res
    touchManagedPtr p
    return res'

#if defined(ENABLE_OVERLOADING)
data Point3DNormalizeMethodInfo
instance (signature ~ (m (Point3D)), MonadIO m) => O.OverloadedMethod Point3DNormalizeMethodInfo Point3D signature where
    overloadedMethod = point3DNormalize

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


#endif

-- method Point3D::normalize_viewport
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "p"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Point3D" }
--           , argCType = Just "const graphene_point3d_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_point3d_t"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "viewport"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Rect" }
--           , argCType = Just "const graphene_rect_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_rect_t representing a viewport"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "z_near"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "the coordinate of the near clipping plane, or 0 for\n  the default near clipping plane"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "z_far"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "the coordinate of the far clipping plane, or 1 for the\n  default far clipping plane"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "res"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Point3D" }
--           , argCType = Just "graphene_point3d_t*"
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "the return location for the\n  normalized #graphene_point3d_t"
--                 , 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_point3d_normalize_viewport" graphene_point3d_normalize_viewport :: 
    Ptr Point3D ->                          -- p : TInterface (Name {namespace = "Graphene", name = "Point3D"})
    Ptr Graphene.Rect.Rect ->               -- viewport : TInterface (Name {namespace = "Graphene", name = "Rect"})
    CFloat ->                               -- z_near : TBasicType TFloat
    CFloat ->                               -- z_far : TBasicType TFloat
    Ptr Point3D ->                          -- res : TInterface (Name {namespace = "Graphene", name = "Point3D"})
    IO ()

-- | Normalizes the coordinates of a t'GI.Graphene.Structs.Point3D.Point3D' using the
-- given viewport and clipping planes.
-- 
-- The coordinates of the resulting t'GI.Graphene.Structs.Point3D.Point3D' will be
-- in the [ -1, 1 ] range.
-- 
-- /Since: 1.4/
point3DNormalizeViewport ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Point3D
    -- ^ /@p@/: a t'GI.Graphene.Structs.Point3D.Point3D'
    -> Graphene.Rect.Rect
    -- ^ /@viewport@/: a t'GI.Graphene.Structs.Rect.Rect' representing a viewport
    -> Float
    -- ^ /@zNear@/: the coordinate of the near clipping plane, or 0 for
    --   the default near clipping plane
    -> Float
    -- ^ /@zFar@/: the coordinate of the far clipping plane, or 1 for the
    --   default far clipping plane
    -> m (Point3D)
point3DNormalizeViewport :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Point3D -> Rect -> Float -> Float -> m Point3D
point3DNormalizeViewport Point3D
p Rect
viewport Float
zNear Float
zFar = 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
    p' <- Point3D -> IO (Ptr Point3D)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Point3D
p
    viewport' <- unsafeManagedPtrGetPtr viewport
    let zNear' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
zNear
    let zFar' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
zFar
    res <- SP.callocBoxedBytes 12 :: IO (Ptr Point3D)
    graphene_point3d_normalize_viewport p' viewport' zNear' zFar' res
    res' <- (wrapBoxed Point3D) res
    touchManagedPtr p
    touchManagedPtr viewport
    return res'

#if defined(ENABLE_OVERLOADING)
data Point3DNormalizeViewportMethodInfo
instance (signature ~ (Graphene.Rect.Rect -> Float -> Float -> m (Point3D)), MonadIO m) => O.OverloadedMethod Point3DNormalizeViewportMethodInfo Point3D signature where
    overloadedMethod = point3DNormalizeViewport

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


#endif

-- method Point3D::scale
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "p"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Point3D" }
--           , argCType = Just "const graphene_point3d_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_point3d_t"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "factor"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the scaling factor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "res"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Point3D" }
--           , argCType = Just "graphene_point3d_t*"
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "return location for the scaled 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_point3d_scale" graphene_point3d_scale :: 
    Ptr Point3D ->                          -- p : TInterface (Name {namespace = "Graphene", name = "Point3D"})
    CFloat ->                               -- factor : TBasicType TFloat
    Ptr Point3D ->                          -- res : TInterface (Name {namespace = "Graphene", name = "Point3D"})
    IO ()

-- | Scales the coordinates of the given t'GI.Graphene.Structs.Point3D.Point3D' by
-- the given /@factor@/.
-- 
-- /Since: 1.0/
point3DScale ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Point3D
    -- ^ /@p@/: a t'GI.Graphene.Structs.Point3D.Point3D'
    -> Float
    -- ^ /@factor@/: the scaling factor
    -> m (Point3D)
point3DScale :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Point3D -> Float -> m Point3D
point3DScale Point3D
p Float
factor = 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
    p' <- Point3D -> IO (Ptr Point3D)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Point3D
p
    let factor' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
factor
    res <- SP.callocBoxedBytes 12 :: IO (Ptr Point3D)
    graphene_point3d_scale p' factor' res
    res' <- (wrapBoxed Point3D) res
    touchManagedPtr p
    return res'

#if defined(ENABLE_OVERLOADING)
data Point3DScaleMethodInfo
instance (signature ~ (Float -> m (Point3D)), MonadIO m) => O.OverloadedMethod Point3DScaleMethodInfo Point3D signature where
    overloadedMethod = point3DScale

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


#endif

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

-- | Stores the coordinates of a t'GI.Graphene.Structs.Point3D.Point3D' into a
-- t'GI.Graphene.Structs.Vec3.Vec3'.
-- 
-- /Since: 1.0/
point3DToVec3 ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Point3D
    -- ^ /@p@/: a t'GI.Graphene.Structs.Point3D.Point3D'
    -> m (Graphene.Vec3.Vec3)
point3DToVec3 :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Point3D -> m Vec3
point3DToVec3 Point3D
p = 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
    p' <- Point3D -> IO (Ptr Point3D)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Point3D
p
    v <- SP.callocBoxedBytes 16 :: IO (Ptr Graphene.Vec3.Vec3)
    graphene_point3d_to_vec3 p' v
    v' <- (wrapBoxed Graphene.Vec3.Vec3) v
    touchManagedPtr p
    return v'

#if defined(ENABLE_OVERLOADING)
data Point3DToVec3MethodInfo
instance (signature ~ (m (Graphene.Vec3.Vec3)), MonadIO m) => O.OverloadedMethod Point3DToVec3MethodInfo Point3D signature where
    overloadedMethod = point3DToVec3

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


#endif

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

foreign import ccall "graphene_point3d_zero" graphene_point3d_zero :: 
    IO (Ptr Point3D)

-- | Retrieves a constant point with all three coordinates set to 0.
-- 
-- /Since: 1.0/
point3DZero ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m Point3D
    -- ^ __Returns:__ a zero point
point3DZero :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m Point3D
point3DZero  = 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
    result <- IO (Ptr Point3D)
graphene_point3d_zero
    checkUnexpectedReturnNULL "point3DZero" result
    result' <- (newBoxed Point3D) result
    return result'

#if defined(ENABLE_OVERLOADING)
#endif

#if defined(ENABLE_OVERLOADING)
type family ResolvePoint3DMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
    ResolvePoint3DMethod "cross" o = Point3DCrossMethodInfo
    ResolvePoint3DMethod "distance" o = Point3DDistanceMethodInfo
    ResolvePoint3DMethod "dot" o = Point3DDotMethodInfo
    ResolvePoint3DMethod "equal" o = Point3DEqualMethodInfo
    ResolvePoint3DMethod "free" o = Point3DFreeMethodInfo
    ResolvePoint3DMethod "init" o = Point3DInitMethodInfo
    ResolvePoint3DMethod "initFromPoint" o = Point3DInitFromPointMethodInfo
    ResolvePoint3DMethod "initFromVec3" o = Point3DInitFromVec3MethodInfo
    ResolvePoint3DMethod "interpolate" o = Point3DInterpolateMethodInfo
    ResolvePoint3DMethod "length" o = Point3DLengthMethodInfo
    ResolvePoint3DMethod "near" o = Point3DNearMethodInfo
    ResolvePoint3DMethod "normalize" o = Point3DNormalizeMethodInfo
    ResolvePoint3DMethod "normalizeViewport" o = Point3DNormalizeViewportMethodInfo
    ResolvePoint3DMethod "scale" o = Point3DScaleMethodInfo
    ResolvePoint3DMethod "toVec3" o = Point3DToVec3MethodInfo
    ResolvePoint3DMethod l o = O.MethodResolutionFailed l o

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

#endif

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

#endif