{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- A structure capable of holding a 4x4 matrix.
-- 
-- The contents of the t'GI.Graphene.Structs.Matrix.Matrix' structure are private and
-- should never be accessed directly.

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

module GI.Graphene.Structs.Matrix
    ( 

-- * Exported types
    Matrix(..)                              ,
    newZeroMatrix                           ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [decompose]("GI.Graphene.Structs.Matrix#g:method:decompose"), [determinant]("GI.Graphene.Structs.Matrix#g:method:determinant"), [equal]("GI.Graphene.Structs.Matrix#g:method:equal"), [equalFast]("GI.Graphene.Structs.Matrix#g:method:equalFast"), [free]("GI.Graphene.Structs.Matrix#g:method:free"), [initFrom2d]("GI.Graphene.Structs.Matrix#g:method:initFrom2d"), [initFromFloat]("GI.Graphene.Structs.Matrix#g:method:initFromFloat"), [initFromMatrix]("GI.Graphene.Structs.Matrix#g:method:initFromMatrix"), [initFromVec4]("GI.Graphene.Structs.Matrix#g:method:initFromVec4"), [initFrustum]("GI.Graphene.Structs.Matrix#g:method:initFrustum"), [initIdentity]("GI.Graphene.Structs.Matrix#g:method:initIdentity"), [initLookAt]("GI.Graphene.Structs.Matrix#g:method:initLookAt"), [initOrtho]("GI.Graphene.Structs.Matrix#g:method:initOrtho"), [initPerspective]("GI.Graphene.Structs.Matrix#g:method:initPerspective"), [initRotate]("GI.Graphene.Structs.Matrix#g:method:initRotate"), [initScale]("GI.Graphene.Structs.Matrix#g:method:initScale"), [initSkew]("GI.Graphene.Structs.Matrix#g:method:initSkew"), [initTranslate]("GI.Graphene.Structs.Matrix#g:method:initTranslate"), [interpolate]("GI.Graphene.Structs.Matrix#g:method:interpolate"), [inverse]("GI.Graphene.Structs.Matrix#g:method:inverse"), [is2d]("GI.Graphene.Structs.Matrix#g:method:is2d"), [isBackfaceVisible]("GI.Graphene.Structs.Matrix#g:method:isBackfaceVisible"), [isIdentity]("GI.Graphene.Structs.Matrix#g:method:isIdentity"), [isSingular]("GI.Graphene.Structs.Matrix#g:method:isSingular"), [multiply]("GI.Graphene.Structs.Matrix#g:method:multiply"), [near]("GI.Graphene.Structs.Matrix#g:method:near"), [normalize]("GI.Graphene.Structs.Matrix#g:method:normalize"), [perspective]("GI.Graphene.Structs.Matrix#g:method:perspective"), [print]("GI.Graphene.Structs.Matrix#g:method:print"), [projectPoint]("GI.Graphene.Structs.Matrix#g:method:projectPoint"), [projectRect]("GI.Graphene.Structs.Matrix#g:method:projectRect"), [projectRectBounds]("GI.Graphene.Structs.Matrix#g:method:projectRectBounds"), [rotate]("GI.Graphene.Structs.Matrix#g:method:rotate"), [rotateEuler]("GI.Graphene.Structs.Matrix#g:method:rotateEuler"), [rotateQuaternion]("GI.Graphene.Structs.Matrix#g:method:rotateQuaternion"), [rotateX]("GI.Graphene.Structs.Matrix#g:method:rotateX"), [rotateY]("GI.Graphene.Structs.Matrix#g:method:rotateY"), [rotateZ]("GI.Graphene.Structs.Matrix#g:method:rotateZ"), [scale]("GI.Graphene.Structs.Matrix#g:method:scale"), [skewXy]("GI.Graphene.Structs.Matrix#g:method:skewXy"), [skewXz]("GI.Graphene.Structs.Matrix#g:method:skewXz"), [skewYz]("GI.Graphene.Structs.Matrix#g:method:skewYz"), [to2d]("GI.Graphene.Structs.Matrix#g:method:to2d"), [transformBounds]("GI.Graphene.Structs.Matrix#g:method:transformBounds"), [transformBox]("GI.Graphene.Structs.Matrix#g:method:transformBox"), [transformPoint]("GI.Graphene.Structs.Matrix#g:method:transformPoint"), [transformPoint3d]("GI.Graphene.Structs.Matrix#g:method:transformPoint3d"), [transformRay]("GI.Graphene.Structs.Matrix#g:method:transformRay"), [transformRect]("GI.Graphene.Structs.Matrix#g:method:transformRect"), [transformSphere]("GI.Graphene.Structs.Matrix#g:method:transformSphere"), [transformVec3]("GI.Graphene.Structs.Matrix#g:method:transformVec3"), [transformVec4]("GI.Graphene.Structs.Matrix#g:method:transformVec4"), [translate]("GI.Graphene.Structs.Matrix#g:method:translate"), [transpose]("GI.Graphene.Structs.Matrix#g:method:transpose"), [unprojectPoint3d]("GI.Graphene.Structs.Matrix#g:method:unprojectPoint3d"), [untransformBounds]("GI.Graphene.Structs.Matrix#g:method:untransformBounds"), [untransformPoint]("GI.Graphene.Structs.Matrix#g:method:untransformPoint").
-- 
-- ==== Getters
-- [getRow]("GI.Graphene.Structs.Matrix#g:method:getRow"), [getValue]("GI.Graphene.Structs.Matrix#g:method:getValue"), [getXScale]("GI.Graphene.Structs.Matrix#g:method:getXScale"), [getXTranslation]("GI.Graphene.Structs.Matrix#g:method:getXTranslation"), [getYScale]("GI.Graphene.Structs.Matrix#g:method:getYScale"), [getYTranslation]("GI.Graphene.Structs.Matrix#g:method:getYTranslation"), [getZScale]("GI.Graphene.Structs.Matrix#g:method:getZScale"), [getZTranslation]("GI.Graphene.Structs.Matrix#g:method:getZTranslation").
-- 
-- ==== Setters
-- /None/.

#if defined(ENABLE_OVERLOADING)
    ResolveMatrixMethod                     ,
#endif

-- ** alloc #method:alloc#

    matrixAlloc                             ,


-- ** decompose #method:decompose#

#if defined(ENABLE_OVERLOADING)
    MatrixDecomposeMethodInfo               ,
#endif
    matrixDecompose                         ,


-- ** determinant #method:determinant#

#if defined(ENABLE_OVERLOADING)
    MatrixDeterminantMethodInfo             ,
#endif
    matrixDeterminant                       ,


-- ** equal #method:equal#

#if defined(ENABLE_OVERLOADING)
    MatrixEqualMethodInfo                   ,
#endif
    matrixEqual                             ,


-- ** equalFast #method:equalFast#

#if defined(ENABLE_OVERLOADING)
    MatrixEqualFastMethodInfo               ,
#endif
    matrixEqualFast                         ,


-- ** free #method:free#

#if defined(ENABLE_OVERLOADING)
    MatrixFreeMethodInfo                    ,
#endif
    matrixFree                              ,


-- ** getRow #method:getRow#

#if defined(ENABLE_OVERLOADING)
    MatrixGetRowMethodInfo                  ,
#endif
    matrixGetRow                            ,


-- ** getValue #method:getValue#

#if defined(ENABLE_OVERLOADING)
    MatrixGetValueMethodInfo                ,
#endif
    matrixGetValue                          ,


-- ** getXScale #method:getXScale#

#if defined(ENABLE_OVERLOADING)
    MatrixGetXScaleMethodInfo               ,
#endif
    matrixGetXScale                         ,


-- ** getXTranslation #method:getXTranslation#

#if defined(ENABLE_OVERLOADING)
    MatrixGetXTranslationMethodInfo         ,
#endif
    matrixGetXTranslation                   ,


-- ** getYScale #method:getYScale#

#if defined(ENABLE_OVERLOADING)
    MatrixGetYScaleMethodInfo               ,
#endif
    matrixGetYScale                         ,


-- ** getYTranslation #method:getYTranslation#

#if defined(ENABLE_OVERLOADING)
    MatrixGetYTranslationMethodInfo         ,
#endif
    matrixGetYTranslation                   ,


-- ** getZScale #method:getZScale#

#if defined(ENABLE_OVERLOADING)
    MatrixGetZScaleMethodInfo               ,
#endif
    matrixGetZScale                         ,


-- ** getZTranslation #method:getZTranslation#

#if defined(ENABLE_OVERLOADING)
    MatrixGetZTranslationMethodInfo         ,
#endif
    matrixGetZTranslation                   ,


-- ** initFrom2d #method:initFrom2d#

#if defined(ENABLE_OVERLOADING)
    MatrixInitFrom2dMethodInfo              ,
#endif
    matrixInitFrom2d                        ,


-- ** initFromFloat #method:initFromFloat#

#if defined(ENABLE_OVERLOADING)
    MatrixInitFromFloatMethodInfo           ,
#endif
    matrixInitFromFloat                     ,


-- ** initFromMatrix #method:initFromMatrix#

#if defined(ENABLE_OVERLOADING)
    MatrixInitFromMatrixMethodInfo          ,
#endif
    matrixInitFromMatrix                    ,


-- ** initFromVec4 #method:initFromVec4#

#if defined(ENABLE_OVERLOADING)
    MatrixInitFromVec4MethodInfo            ,
#endif
    matrixInitFromVec4                      ,


-- ** initFrustum #method:initFrustum#

#if defined(ENABLE_OVERLOADING)
    MatrixInitFrustumMethodInfo             ,
#endif
    matrixInitFrustum                       ,


-- ** initIdentity #method:initIdentity#

#if defined(ENABLE_OVERLOADING)
    MatrixInitIdentityMethodInfo            ,
#endif
    matrixInitIdentity                      ,


-- ** initLookAt #method:initLookAt#

#if defined(ENABLE_OVERLOADING)
    MatrixInitLookAtMethodInfo              ,
#endif
    matrixInitLookAt                        ,


-- ** initOrtho #method:initOrtho#

#if defined(ENABLE_OVERLOADING)
    MatrixInitOrthoMethodInfo               ,
#endif
    matrixInitOrtho                         ,


-- ** initPerspective #method:initPerspective#

#if defined(ENABLE_OVERLOADING)
    MatrixInitPerspectiveMethodInfo         ,
#endif
    matrixInitPerspective                   ,


-- ** initRotate #method:initRotate#

#if defined(ENABLE_OVERLOADING)
    MatrixInitRotateMethodInfo              ,
#endif
    matrixInitRotate                        ,


-- ** initScale #method:initScale#

#if defined(ENABLE_OVERLOADING)
    MatrixInitScaleMethodInfo               ,
#endif
    matrixInitScale                         ,


-- ** initSkew #method:initSkew#

#if defined(ENABLE_OVERLOADING)
    MatrixInitSkewMethodInfo                ,
#endif
    matrixInitSkew                          ,


-- ** initTranslate #method:initTranslate#

#if defined(ENABLE_OVERLOADING)
    MatrixInitTranslateMethodInfo           ,
#endif
    matrixInitTranslate                     ,


-- ** interpolate #method:interpolate#

#if defined(ENABLE_OVERLOADING)
    MatrixInterpolateMethodInfo             ,
#endif
    matrixInterpolate                       ,


-- ** inverse #method:inverse#

#if defined(ENABLE_OVERLOADING)
    MatrixInverseMethodInfo                 ,
#endif
    matrixInverse                           ,


-- ** is2d #method:is2d#

#if defined(ENABLE_OVERLOADING)
    MatrixIs2dMethodInfo                    ,
#endif
    matrixIs2d                              ,


-- ** isBackfaceVisible #method:isBackfaceVisible#

#if defined(ENABLE_OVERLOADING)
    MatrixIsBackfaceVisibleMethodInfo       ,
#endif
    matrixIsBackfaceVisible                 ,


-- ** isIdentity #method:isIdentity#

#if defined(ENABLE_OVERLOADING)
    MatrixIsIdentityMethodInfo              ,
#endif
    matrixIsIdentity                        ,


-- ** isSingular #method:isSingular#

#if defined(ENABLE_OVERLOADING)
    MatrixIsSingularMethodInfo              ,
#endif
    matrixIsSingular                        ,


-- ** multiply #method:multiply#

#if defined(ENABLE_OVERLOADING)
    MatrixMultiplyMethodInfo                ,
#endif
    matrixMultiply                          ,


-- ** near #method:near#

#if defined(ENABLE_OVERLOADING)
    MatrixNearMethodInfo                    ,
#endif
    matrixNear                              ,


-- ** normalize #method:normalize#

#if defined(ENABLE_OVERLOADING)
    MatrixNormalizeMethodInfo               ,
#endif
    matrixNormalize                         ,


-- ** perspective #method:perspective#

#if defined(ENABLE_OVERLOADING)
    MatrixPerspectiveMethodInfo             ,
#endif
    matrixPerspective                       ,


-- ** print #method:print#

#if defined(ENABLE_OVERLOADING)
    MatrixPrintMethodInfo                   ,
#endif
    matrixPrint                             ,


-- ** projectPoint #method:projectPoint#

#if defined(ENABLE_OVERLOADING)
    MatrixProjectPointMethodInfo            ,
#endif
    matrixProjectPoint                      ,


-- ** projectRect #method:projectRect#

#if defined(ENABLE_OVERLOADING)
    MatrixProjectRectMethodInfo             ,
#endif
    matrixProjectRect                       ,


-- ** projectRectBounds #method:projectRectBounds#

#if defined(ENABLE_OVERLOADING)
    MatrixProjectRectBoundsMethodInfo       ,
#endif
    matrixProjectRectBounds                 ,


-- ** rotate #method:rotate#

#if defined(ENABLE_OVERLOADING)
    MatrixRotateMethodInfo                  ,
#endif
    matrixRotate                            ,


-- ** rotateEuler #method:rotateEuler#

#if defined(ENABLE_OVERLOADING)
    MatrixRotateEulerMethodInfo             ,
#endif
    matrixRotateEuler                       ,


-- ** rotateQuaternion #method:rotateQuaternion#

#if defined(ENABLE_OVERLOADING)
    MatrixRotateQuaternionMethodInfo        ,
#endif
    matrixRotateQuaternion                  ,


-- ** rotateX #method:rotateX#

#if defined(ENABLE_OVERLOADING)
    MatrixRotateXMethodInfo                 ,
#endif
    matrixRotateX                           ,


-- ** rotateY #method:rotateY#

#if defined(ENABLE_OVERLOADING)
    MatrixRotateYMethodInfo                 ,
#endif
    matrixRotateY                           ,


-- ** rotateZ #method:rotateZ#

#if defined(ENABLE_OVERLOADING)
    MatrixRotateZMethodInfo                 ,
#endif
    matrixRotateZ                           ,


-- ** scale #method:scale#

#if defined(ENABLE_OVERLOADING)
    MatrixScaleMethodInfo                   ,
#endif
    matrixScale                             ,


-- ** skewXy #method:skewXy#

#if defined(ENABLE_OVERLOADING)
    MatrixSkewXyMethodInfo                  ,
#endif
    matrixSkewXy                            ,


-- ** skewXz #method:skewXz#

#if defined(ENABLE_OVERLOADING)
    MatrixSkewXzMethodInfo                  ,
#endif
    matrixSkewXz                            ,


-- ** skewYz #method:skewYz#

#if defined(ENABLE_OVERLOADING)
    MatrixSkewYzMethodInfo                  ,
#endif
    matrixSkewYz                            ,


-- ** to2d #method:to2d#

#if defined(ENABLE_OVERLOADING)
    MatrixTo2dMethodInfo                    ,
#endif
    matrixTo2d                              ,


-- ** transformBounds #method:transformBounds#

#if defined(ENABLE_OVERLOADING)
    MatrixTransformBoundsMethodInfo         ,
#endif
    matrixTransformBounds                   ,


-- ** transformBox #method:transformBox#

#if defined(ENABLE_OVERLOADING)
    MatrixTransformBoxMethodInfo            ,
#endif
    matrixTransformBox                      ,


-- ** transformPoint #method:transformPoint#

#if defined(ENABLE_OVERLOADING)
    MatrixTransformPointMethodInfo          ,
#endif
    matrixTransformPoint                    ,


-- ** transformPoint3d #method:transformPoint3d#

#if defined(ENABLE_OVERLOADING)
    MatrixTransformPoint3dMethodInfo        ,
#endif
    matrixTransformPoint3d                  ,


-- ** transformRay #method:transformRay#

#if defined(ENABLE_OVERLOADING)
    MatrixTransformRayMethodInfo            ,
#endif
    matrixTransformRay                      ,


-- ** transformRect #method:transformRect#

#if defined(ENABLE_OVERLOADING)
    MatrixTransformRectMethodInfo           ,
#endif
    matrixTransformRect                     ,


-- ** transformSphere #method:transformSphere#

#if defined(ENABLE_OVERLOADING)
    MatrixTransformSphereMethodInfo         ,
#endif
    matrixTransformSphere                   ,


-- ** transformVec3 #method:transformVec3#

#if defined(ENABLE_OVERLOADING)
    MatrixTransformVec3MethodInfo           ,
#endif
    matrixTransformVec3                     ,


-- ** transformVec4 #method:transformVec4#

#if defined(ENABLE_OVERLOADING)
    MatrixTransformVec4MethodInfo           ,
#endif
    matrixTransformVec4                     ,


-- ** translate #method:translate#

#if defined(ENABLE_OVERLOADING)
    MatrixTranslateMethodInfo               ,
#endif
    matrixTranslate                         ,


-- ** transpose #method:transpose#

#if defined(ENABLE_OVERLOADING)
    MatrixTransposeMethodInfo               ,
#endif
    matrixTranspose                         ,


-- ** unprojectPoint3d #method:unprojectPoint3d#

#if defined(ENABLE_OVERLOADING)
    MatrixUnprojectPoint3dMethodInfo        ,
#endif
    matrixUnprojectPoint3d                  ,


-- ** untransformBounds #method:untransformBounds#

#if defined(ENABLE_OVERLOADING)
    MatrixUntransformBoundsMethodInfo       ,
#endif
    matrixUntransformBounds                 ,


-- ** untransformPoint #method:untransformPoint#

#if defined(ENABLE_OVERLOADING)
    MatrixUntransformPointMethodInfo        ,
#endif
    matrixUntransformPoint                  ,




    ) where

import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P

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

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

#else
import {-# SOURCE #-} qualified GI.Graphene.Structs.Box as Graphene.Box
import {-# SOURCE #-} qualified GI.Graphene.Structs.Euler as Graphene.Euler
import {-# SOURCE #-} qualified GI.Graphene.Structs.Point as Graphene.Point
import {-# SOURCE #-} qualified GI.Graphene.Structs.Point3D as Graphene.Point3D
import {-# SOURCE #-} qualified GI.Graphene.Structs.Quad as Graphene.Quad
import {-# SOURCE #-} qualified GI.Graphene.Structs.Quaternion as Graphene.Quaternion
import {-# SOURCE #-} qualified GI.Graphene.Structs.Ray as Graphene.Ray
import {-# SOURCE #-} qualified GI.Graphene.Structs.Rect as Graphene.Rect
import {-# SOURCE #-} qualified GI.Graphene.Structs.Sphere as Graphene.Sphere
import {-# SOURCE #-} qualified GI.Graphene.Structs.Vec3 as Graphene.Vec3
import {-# SOURCE #-} qualified GI.Graphene.Structs.Vec4 as Graphene.Vec4

#endif

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

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

foreign import ccall "graphene_matrix_get_type" c_graphene_matrix_get_type :: 
    IO GType

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

instance B.Types.TypedObject Matrix where
    glibType :: IO GType
glibType = IO GType
c_graphene_matrix_get_type

instance B.Types.GBoxed Matrix

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

-- | Construct a t'Matrix' struct initialized to zero.
newZeroMatrix :: MonadIO m => m Matrix
newZeroMatrix :: forall (m :: * -> *). MonadIO m => m Matrix
newZeroMatrix = IO Matrix -> m Matrix
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Matrix -> m Matrix) -> IO Matrix -> m Matrix
forall a b. (a -> b) -> a -> b
$ Int -> IO (Ptr Matrix)
forall a. GBoxed a => Int -> IO (Ptr a)
callocBoxedBytes Int
64 IO (Ptr Matrix) -> (Ptr Matrix -> IO Matrix) -> IO Matrix
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (ManagedPtr Matrix -> Matrix) -> Ptr Matrix -> IO Matrix
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Matrix -> Matrix
Matrix

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



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

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

foreign import ccall "graphene_matrix_alloc" graphene_matrix_alloc :: 
    IO (Ptr Matrix)

-- | Allocates a new t'GI.Graphene.Structs.Matrix.Matrix'.
-- 
-- /Since: 1.0/
matrixAlloc ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m Matrix
    -- ^ __Returns:__ the newly allocated matrix
matrixAlloc :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m Matrix
matrixAlloc  = IO Matrix -> m Matrix
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Matrix -> m Matrix) -> IO Matrix -> m Matrix
forall a b. (a -> b) -> a -> b
$ do
    result <- IO (Ptr Matrix)
graphene_matrix_alloc
    checkUnexpectedReturnNULL "matrixAlloc" result
    result' <- (wrapBoxed Matrix) result
    return result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method Matrix::decompose
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "m"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Matrix" }
--           , argCType = Just "const graphene_matrix_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_matrix_t"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "translate"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Vec3" }
--           , argCType = Just "graphene_vec3_t*"
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the translation vector"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = True
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "scale"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Vec3" }
--           , argCType = Just "graphene_vec3_t*"
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the scale vector" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = True
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "rotate"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Quaternion" }
--           , argCType = Just "graphene_quaternion_t*"
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the rotation quaternion"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = True
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "shear"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Vec3" }
--           , argCType = Just "graphene_vec3_t*"
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the shear vector" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = True
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "perspective"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Vec4" }
--           , argCType = Just "graphene_vec4_t*"
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the perspective vector"
--                 , 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_matrix_decompose" graphene_matrix_decompose :: 
    Ptr Matrix ->                           -- m : TInterface (Name {namespace = "Graphene", name = "Matrix"})
    Ptr Graphene.Vec3.Vec3 ->               -- translate : TInterface (Name {namespace = "Graphene", name = "Vec3"})
    Ptr Graphene.Vec3.Vec3 ->               -- scale : TInterface (Name {namespace = "Graphene", name = "Vec3"})
    Ptr Graphene.Quaternion.Quaternion ->   -- rotate : TInterface (Name {namespace = "Graphene", name = "Quaternion"})
    Ptr Graphene.Vec3.Vec3 ->               -- shear : TInterface (Name {namespace = "Graphene", name = "Vec3"})
    Ptr Graphene.Vec4.Vec4 ->               -- perspective : TInterface (Name {namespace = "Graphene", name = "Vec4"})
    IO CInt

-- | Decomposes a transformation matrix into its component transformations.
-- 
-- The algorithm for decomposing a matrix is taken from the
-- <http://dev.w3.org/csswg/css-transforms/ CSS3 Transforms specification>;
-- specifically, the decomposition code is based on the equivalent code
-- published in \"Graphics Gems II\", edited by Jim Arvo, and
-- <http://web.archive.org/web/20150512160205/http://tog.acm.org/resources/GraphicsGems/gemsii/unmatrix.c available online>.
matrixDecompose ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Matrix
    -- ^ /@m@/: a t'GI.Graphene.Structs.Matrix.Matrix'
    -> m ((Bool, Graphene.Vec3.Vec3, Graphene.Vec3.Vec3, Graphene.Quaternion.Quaternion, Graphene.Vec3.Vec3, Graphene.Vec4.Vec4))
    -- ^ __Returns:__ @true@ if the matrix could be decomposed
matrixDecompose :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Matrix -> m (Bool, Vec3, Vec3, Quaternion, Vec3, Vec4)
matrixDecompose Matrix
m = IO (Bool, Vec3, Vec3, Quaternion, Vec3, Vec4)
-> m (Bool, Vec3, Vec3, Quaternion, Vec3, Vec4)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Vec3, Vec3, Quaternion, Vec3, Vec4)
 -> m (Bool, Vec3, Vec3, Quaternion, Vec3, Vec4))
-> IO (Bool, Vec3, Vec3, Quaternion, Vec3, Vec4)
-> m (Bool, Vec3, Vec3, Quaternion, Vec3, Vec4)
forall a b. (a -> b) -> a -> b
$ do
    m' <- Matrix -> IO (Ptr Matrix)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Matrix
m
    translate <- SP.callocBoxedBytes 16 :: IO (Ptr Graphene.Vec3.Vec3)
    scale <- SP.callocBoxedBytes 16 :: IO (Ptr Graphene.Vec3.Vec3)
    rotate <- SP.callocBoxedBytes 16 :: IO (Ptr Graphene.Quaternion.Quaternion)
    shear <- SP.callocBoxedBytes 16 :: IO (Ptr Graphene.Vec3.Vec3)
    perspective <- SP.callocBoxedBytes 16 :: IO (Ptr Graphene.Vec4.Vec4)
    result <- graphene_matrix_decompose m' translate scale rotate shear perspective
    let result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    translate' <- (wrapBoxed Graphene.Vec3.Vec3) translate
    scale' <- (wrapBoxed Graphene.Vec3.Vec3) scale
    rotate' <- (wrapBoxed Graphene.Quaternion.Quaternion) rotate
    shear' <- (wrapBoxed Graphene.Vec3.Vec3) shear
    perspective' <- (wrapBoxed Graphene.Vec4.Vec4) perspective
    touchManagedPtr m
    return (result', translate', scale', rotate', shear', perspective')

#if defined(ENABLE_OVERLOADING)
data MatrixDecomposeMethodInfo
instance (signature ~ (m ((Bool, Graphene.Vec3.Vec3, Graphene.Vec3.Vec3, Graphene.Quaternion.Quaternion, Graphene.Vec3.Vec3, Graphene.Vec4.Vec4))), MonadIO m) => O.OverloadedMethod MatrixDecomposeMethodInfo Matrix signature where
    overloadedMethod = matrixDecompose

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


#endif

-- method Matrix::determinant
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "m"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Matrix" }
--           , argCType = Just "const graphene_matrix_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_matrix_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_matrix_determinant" graphene_matrix_determinant :: 
    Ptr Matrix ->                           -- m : TInterface (Name {namespace = "Graphene", name = "Matrix"})
    IO CFloat

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

#if defined(ENABLE_OVERLOADING)
data MatrixDeterminantMethodInfo
instance (signature ~ (m Float), MonadIO m) => O.OverloadedMethod MatrixDeterminantMethodInfo Matrix signature where
    overloadedMethod = matrixDeterminant

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


#endif

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

-- | Checks whether the two given t'GI.Graphene.Structs.Matrix.Matrix' matrices are equal.
-- 
-- /Since: 1.10/
matrixEqual ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Matrix
    -- ^ /@a@/: a t'GI.Graphene.Structs.Matrix.Matrix'
    -> Matrix
    -- ^ /@b@/: a t'GI.Graphene.Structs.Matrix.Matrix'
    -> m Bool
    -- ^ __Returns:__ @true@ if the two matrices are equal, and @false@ otherwise
matrixEqual :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Matrix -> Matrix -> m Bool
matrixEqual Matrix
a Matrix
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' <- Matrix -> IO (Ptr Matrix)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Matrix
a
    b' <- unsafeManagedPtrGetPtr b
    result <- graphene_matrix_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 MatrixEqualMethodInfo
instance (signature ~ (Matrix -> m Bool), MonadIO m) => O.OverloadedMethod MatrixEqualMethodInfo Matrix signature where
    overloadedMethod = matrixEqual

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


#endif

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

-- | Checks whether the two given t'GI.Graphene.Structs.Matrix.Matrix' matrices are
-- byte-by-byte equal.
-- 
-- While this function is faster than 'GI.Graphene.Structs.Matrix.matrixEqual', it
-- can also return false negatives, so it should be used in
-- conjuction with either 'GI.Graphene.Structs.Matrix.matrixEqual' or
-- 'GI.Graphene.Structs.Matrix.matrixNear'. For instance:
-- 
-- 
-- === /C code/
-- >
-- >  if (graphene_matrix_equal_fast (a, b))
-- >    {
-- >      // matrices are definitely the same
-- >    }
-- >  else
-- >    {
-- >      if (graphene_matrix_equal (a, b))
-- >        // matrices contain the same values within an epsilon of FLT_EPSILON
-- >      else if (graphene_matrix_near (a, b, 0.0001))
-- >        // matrices contain the same values within an epsilon of 0.0001
-- >      else
-- >        // matrices are not equal
-- >    }
-- 
-- 
-- /Since: 1.10/
matrixEqualFast ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Matrix
    -- ^ /@a@/: a t'GI.Graphene.Structs.Matrix.Matrix'
    -> Matrix
    -- ^ /@b@/: a t'GI.Graphene.Structs.Matrix.Matrix'
    -> m Bool
    -- ^ __Returns:__ @true@ if the matrices are equal. and @false@ otherwise
matrixEqualFast :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Matrix -> Matrix -> m Bool
matrixEqualFast Matrix
a Matrix
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' <- Matrix -> IO (Ptr Matrix)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Matrix
a
    b' <- unsafeManagedPtrGetPtr b
    result <- graphene_matrix_equal_fast 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 MatrixEqualFastMethodInfo
instance (signature ~ (Matrix -> m Bool), MonadIO m) => O.OverloadedMethod MatrixEqualFastMethodInfo Matrix signature where
    overloadedMethod = matrixEqualFast

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


#endif

-- method Matrix::free
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "m"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Matrix" }
--           , argCType = Just "graphene_matrix_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_matrix_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_matrix_free" graphene_matrix_free :: 
    Ptr Matrix ->                           -- m : TInterface (Name {namespace = "Graphene", name = "Matrix"})
    IO ()

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

#if defined(ENABLE_OVERLOADING)
data MatrixFreeMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod MatrixFreeMethodInfo Matrix signature where
    overloadedMethod = matrixFree

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


#endif

-- method Matrix::get_row
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "m"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Matrix" }
--           , argCType = Just "const graphene_matrix_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_matrix_t"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "index_"
--           , argType = TBasicType TUInt
--           , argCType = Just "unsigned int"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the index of the row vector, between 0 and 3"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "res"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Vec4" }
--           , argCType = Just "graphene_vec4_t*"
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "return location for the #graphene_vec4_t\n  that is used to store the row vector"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = True
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "graphene_matrix_get_row" graphene_matrix_get_row :: 
    Ptr Matrix ->                           -- m : TInterface (Name {namespace = "Graphene", name = "Matrix"})
    Word32 ->                               -- index_ : TBasicType TUInt
    Ptr Graphene.Vec4.Vec4 ->               -- res : TInterface (Name {namespace = "Graphene", name = "Vec4"})
    IO ()

-- | Retrieves the given row vector at /@index_@/ inside a matrix.
-- 
-- /Since: 1.0/
matrixGetRow ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Matrix
    -- ^ /@m@/: a t'GI.Graphene.Structs.Matrix.Matrix'
    -> Word32
    -- ^ /@index_@/: the index of the row vector, between 0 and 3
    -> m (Graphene.Vec4.Vec4)
matrixGetRow :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Matrix -> Word32 -> m Vec4
matrixGetRow Matrix
m Word32
index_ = IO Vec4 -> m Vec4
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Vec4 -> m Vec4) -> IO Vec4 -> m Vec4
forall a b. (a -> b) -> a -> b
$ do
    m' <- Matrix -> IO (Ptr Matrix)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Matrix
m
    res <- SP.callocBoxedBytes 16 :: IO (Ptr Graphene.Vec4.Vec4)
    graphene_matrix_get_row m' index_ res
    res' <- (wrapBoxed Graphene.Vec4.Vec4) res
    touchManagedPtr m
    return res'

#if defined(ENABLE_OVERLOADING)
data MatrixGetRowMethodInfo
instance (signature ~ (Word32 -> m (Graphene.Vec4.Vec4)), MonadIO m) => O.OverloadedMethod MatrixGetRowMethodInfo Matrix signature where
    overloadedMethod = matrixGetRow

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


#endif

-- method Matrix::get_value
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "m"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Matrix" }
--           , argCType = Just "const graphene_matrix_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_matrix_t"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "row"
--           , argType = TBasicType TUInt
--           , argCType = Just "unsigned int"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the row index" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "col"
--           , argType = TBasicType TUInt
--           , argCType = Just "unsigned int"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the column index" , 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_matrix_get_value" graphene_matrix_get_value :: 
    Ptr Matrix ->                           -- m : TInterface (Name {namespace = "Graphene", name = "Matrix"})
    Word32 ->                               -- row : TBasicType TUInt
    Word32 ->                               -- col : TBasicType TUInt
    IO CFloat

-- | Retrieves the value at the given /@row@/ and /@col@/ index.
-- 
-- /Since: 1.0/
matrixGetValue ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Matrix
    -- ^ /@m@/: a t'GI.Graphene.Structs.Matrix.Matrix'
    -> Word32
    -- ^ /@row@/: the row index
    -> Word32
    -- ^ /@col@/: the column index
    -> m Float
    -- ^ __Returns:__ the value at the given indices
matrixGetValue :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Matrix -> Word32 -> Word32 -> m Float
matrixGetValue Matrix
m Word32
row Word32
col = 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
    m' <- Matrix -> IO (Ptr Matrix)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Matrix
m
    result <- graphene_matrix_get_value m' row col
    let result' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
result
    touchManagedPtr m
    return result'

#if defined(ENABLE_OVERLOADING)
data MatrixGetValueMethodInfo
instance (signature ~ (Word32 -> Word32 -> m Float), MonadIO m) => O.OverloadedMethod MatrixGetValueMethodInfo Matrix signature where
    overloadedMethod = matrixGetValue

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


#endif

-- method Matrix::get_x_scale
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "m"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Matrix" }
--           , argCType = Just "const graphene_matrix_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_matrix_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_matrix_get_x_scale" graphene_matrix_get_x_scale :: 
    Ptr Matrix ->                           -- m : TInterface (Name {namespace = "Graphene", name = "Matrix"})
    IO CFloat

-- | Retrieves the scaling factor on the X axis in /@m@/.
-- 
-- /Since: 1.0/
matrixGetXScale ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Matrix
    -- ^ /@m@/: a t'GI.Graphene.Structs.Matrix.Matrix'
    -> m Float
    -- ^ __Returns:__ the value of the scaling factor
matrixGetXScale :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Matrix -> m Float
matrixGetXScale Matrix
m = 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
    m' <- Matrix -> IO (Ptr Matrix)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Matrix
m
    result <- graphene_matrix_get_x_scale m'
    let result' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
result
    touchManagedPtr m
    return result'

#if defined(ENABLE_OVERLOADING)
data MatrixGetXScaleMethodInfo
instance (signature ~ (m Float), MonadIO m) => O.OverloadedMethod MatrixGetXScaleMethodInfo Matrix signature where
    overloadedMethod = matrixGetXScale

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


#endif

-- method Matrix::get_x_translation
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "m"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Matrix" }
--           , argCType = Just "const graphene_matrix_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_matrix_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_matrix_get_x_translation" graphene_matrix_get_x_translation :: 
    Ptr Matrix ->                           -- m : TInterface (Name {namespace = "Graphene", name = "Matrix"})
    IO CFloat

-- | Retrieves the translation component on the X axis from /@m@/.
-- 
-- /Since: 1.10/
matrixGetXTranslation ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Matrix
    -- ^ /@m@/: a t'GI.Graphene.Structs.Matrix.Matrix'
    -> m Float
    -- ^ __Returns:__ the translation component
matrixGetXTranslation :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Matrix -> m Float
matrixGetXTranslation Matrix
m = 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
    m' <- Matrix -> IO (Ptr Matrix)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Matrix
m
    result <- graphene_matrix_get_x_translation m'
    let result' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
result
    touchManagedPtr m
    return result'

#if defined(ENABLE_OVERLOADING)
data MatrixGetXTranslationMethodInfo
instance (signature ~ (m Float), MonadIO m) => O.OverloadedMethod MatrixGetXTranslationMethodInfo Matrix signature where
    overloadedMethod = matrixGetXTranslation

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


#endif

-- method Matrix::get_y_scale
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "m"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Matrix" }
--           , argCType = Just "const graphene_matrix_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_matrix_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_matrix_get_y_scale" graphene_matrix_get_y_scale :: 
    Ptr Matrix ->                           -- m : TInterface (Name {namespace = "Graphene", name = "Matrix"})
    IO CFloat

-- | Retrieves the scaling factor on the Y axis in /@m@/.
-- 
-- /Since: 1.0/
matrixGetYScale ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Matrix
    -- ^ /@m@/: a t'GI.Graphene.Structs.Matrix.Matrix'
    -> m Float
    -- ^ __Returns:__ the value of the scaling factor
matrixGetYScale :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Matrix -> m Float
matrixGetYScale Matrix
m = 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
    m' <- Matrix -> IO (Ptr Matrix)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Matrix
m
    result <- graphene_matrix_get_y_scale m'
    let result' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
result
    touchManagedPtr m
    return result'

#if defined(ENABLE_OVERLOADING)
data MatrixGetYScaleMethodInfo
instance (signature ~ (m Float), MonadIO m) => O.OverloadedMethod MatrixGetYScaleMethodInfo Matrix signature where
    overloadedMethod = matrixGetYScale

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


#endif

-- method Matrix::get_y_translation
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "m"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Matrix" }
--           , argCType = Just "const graphene_matrix_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_matrix_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_matrix_get_y_translation" graphene_matrix_get_y_translation :: 
    Ptr Matrix ->                           -- m : TInterface (Name {namespace = "Graphene", name = "Matrix"})
    IO CFloat

-- | Retrieves the translation component on the Y axis from /@m@/.
-- 
-- /Since: 1.10/
matrixGetYTranslation ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Matrix
    -- ^ /@m@/: a t'GI.Graphene.Structs.Matrix.Matrix'
    -> m Float
    -- ^ __Returns:__ the translation component
matrixGetYTranslation :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Matrix -> m Float
matrixGetYTranslation Matrix
m = 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
    m' <- Matrix -> IO (Ptr Matrix)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Matrix
m
    result <- graphene_matrix_get_y_translation m'
    let result' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
result
    touchManagedPtr m
    return result'

#if defined(ENABLE_OVERLOADING)
data MatrixGetYTranslationMethodInfo
instance (signature ~ (m Float), MonadIO m) => O.OverloadedMethod MatrixGetYTranslationMethodInfo Matrix signature where
    overloadedMethod = matrixGetYTranslation

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


#endif

-- method Matrix::get_z_scale
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "m"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Matrix" }
--           , argCType = Just "const graphene_matrix_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_matrix_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_matrix_get_z_scale" graphene_matrix_get_z_scale :: 
    Ptr Matrix ->                           -- m : TInterface (Name {namespace = "Graphene", name = "Matrix"})
    IO CFloat

-- | Retrieves the scaling factor on the Z axis in /@m@/.
-- 
-- /Since: 1.0/
matrixGetZScale ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Matrix
    -- ^ /@m@/: a t'GI.Graphene.Structs.Matrix.Matrix'
    -> m Float
    -- ^ __Returns:__ the value of the scaling factor
matrixGetZScale :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Matrix -> m Float
matrixGetZScale Matrix
m = 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
    m' <- Matrix -> IO (Ptr Matrix)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Matrix
m
    result <- graphene_matrix_get_z_scale m'
    let result' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
result
    touchManagedPtr m
    return result'

#if defined(ENABLE_OVERLOADING)
data MatrixGetZScaleMethodInfo
instance (signature ~ (m Float), MonadIO m) => O.OverloadedMethod MatrixGetZScaleMethodInfo Matrix signature where
    overloadedMethod = matrixGetZScale

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


#endif

-- method Matrix::get_z_translation
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "m"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Matrix" }
--           , argCType = Just "const graphene_matrix_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_matrix_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_matrix_get_z_translation" graphene_matrix_get_z_translation :: 
    Ptr Matrix ->                           -- m : TInterface (Name {namespace = "Graphene", name = "Matrix"})
    IO CFloat

-- | Retrieves the translation component on the Z axis from /@m@/.
-- 
-- /Since: 1.10/
matrixGetZTranslation ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Matrix
    -- ^ /@m@/: a t'GI.Graphene.Structs.Matrix.Matrix'
    -> m Float
    -- ^ __Returns:__ the translation component
matrixGetZTranslation :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Matrix -> m Float
matrixGetZTranslation Matrix
m = 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
    m' <- Matrix -> IO (Ptr Matrix)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Matrix
m
    result <- graphene_matrix_get_z_translation m'
    let result' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
result
    touchManagedPtr m
    return result'

#if defined(ENABLE_OVERLOADING)
data MatrixGetZTranslationMethodInfo
instance (signature ~ (m Float), MonadIO m) => O.OverloadedMethod MatrixGetZTranslationMethodInfo Matrix signature where
    overloadedMethod = matrixGetZTranslation

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


#endif

-- method Matrix::init_from_2d
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "m"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Matrix" }
--           , argCType = Just "graphene_matrix_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_matrix_t"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "xx"
--           , argType = TBasicType TDouble
--           , argCType = Just "double"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the xx member" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "yx"
--           , argType = TBasicType TDouble
--           , argCType = Just "double"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the yx member" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "xy"
--           , argType = TBasicType TDouble
--           , argCType = Just "double"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the xy member" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "yy"
--           , argType = TBasicType TDouble
--           , argCType = Just "double"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the yy member" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "x_0"
--           , argType = TBasicType TDouble
--           , argCType = Just "double"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the x0 member" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "y_0"
--           , argType = TBasicType TDouble
--           , argCType = Just "double"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the y0 member" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Graphene" , name = "Matrix" })
-- throws : False
-- Skip return : False

foreign import ccall "graphene_matrix_init_from_2d" graphene_matrix_init_from_2d :: 
    Ptr Matrix ->                           -- m : TInterface (Name {namespace = "Graphene", name = "Matrix"})
    CDouble ->                              -- xx : TBasicType TDouble
    CDouble ->                              -- yx : TBasicType TDouble
    CDouble ->                              -- xy : TBasicType TDouble
    CDouble ->                              -- yy : TBasicType TDouble
    CDouble ->                              -- x_0 : TBasicType TDouble
    CDouble ->                              -- y_0 : TBasicType TDouble
    IO (Ptr Matrix)

-- | Initializes a t'GI.Graphene.Structs.Matrix.Matrix' from the values of an affine
-- transformation matrix.
-- 
-- The arguments map to the following matrix layout:
-- 
-- 
-- === /plain code/
-- >
-- >  ⎛ xx  yx ⎞   ⎛  a   b  0 ⎞
-- >  ⎜ xy  yy ⎟ = ⎜  c   d  0 ⎟
-- >  ⎝ x0  y0 ⎠   ⎝ tx  ty  1 ⎠
-- 
-- 
-- This function can be used to convert between an affine matrix type
-- from other libraries and a t'GI.Graphene.Structs.Matrix.Matrix'.
-- 
-- /Since: 1.0/
matrixInitFrom2d ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Matrix
    -- ^ /@m@/: a t'GI.Graphene.Structs.Matrix.Matrix'
    -> Double
    -- ^ /@xx@/: the xx member
    -> Double
    -- ^ /@yx@/: the yx member
    -> Double
    -- ^ /@xy@/: the xy member
    -> Double
    -- ^ /@yy@/: the yy member
    -> Double
    -- ^ /@x0@/: the x0 member
    -> Double
    -- ^ /@y0@/: the y0 member
    -> m Matrix
    -- ^ __Returns:__ the initialized matrix
matrixInitFrom2d :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Matrix
-> Double
-> Double
-> Double
-> Double
-> Double
-> Double
-> m Matrix
matrixInitFrom2d Matrix
m Double
xx Double
yx Double
xy Double
yy Double
x0 Double
y0 = IO Matrix -> m Matrix
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Matrix -> m Matrix) -> IO Matrix -> m Matrix
forall a b. (a -> b) -> a -> b
$ do
    m' <- Matrix -> IO (Ptr Matrix)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Matrix
m
    let xx' = Double -> CDouble
forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
xx
    let yx' = Double -> CDouble
forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
yx
    let xy' = Double -> CDouble
forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
xy
    let yy' = Double -> CDouble
forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
yy
    let x0' = Double -> CDouble
forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
x0
    let y0' = Double -> CDouble
forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
y0
    result <- graphene_matrix_init_from_2d m' xx' yx' xy' yy' x0' y0'
    checkUnexpectedReturnNULL "matrixInitFrom2d" result
    result' <- (newBoxed Matrix) result
    touchManagedPtr m
    return result'

#if defined(ENABLE_OVERLOADING)
data MatrixInitFrom2dMethodInfo
instance (signature ~ (Double -> Double -> Double -> Double -> Double -> Double -> m Matrix), MonadIO m) => O.OverloadedMethod MatrixInitFrom2dMethodInfo Matrix signature where
    overloadedMethod = matrixInitFrom2d

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


#endif

-- method Matrix::init_from_float
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "m"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Matrix" }
--           , argCType = Just "graphene_matrix_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_matrix_t"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "v"
--           , argType = TCArray False 16 (-1) (TBasicType TFloat)
--           , argCType = Just "const float*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "an array of at least 16 floating\n  point values"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Graphene" , name = "Matrix" })
-- throws : False
-- Skip return : False

foreign import ccall "graphene_matrix_init_from_float" graphene_matrix_init_from_float :: 
    Ptr Matrix ->                           -- m : TInterface (Name {namespace = "Graphene", name = "Matrix"})
    Ptr CFloat ->                           -- v : TCArray False 16 (-1) (TBasicType TFloat)
    IO (Ptr Matrix)

-- | Initializes a t'GI.Graphene.Structs.Matrix.Matrix' with the given array of floating
-- point values.
-- 
-- /Since: 1.0/
matrixInitFromFloat ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Matrix
    -- ^ /@m@/: a t'GI.Graphene.Structs.Matrix.Matrix'
    -> [Float]
    -- ^ /@v@/: an array of at least 16 floating
    --   point values
    -> m Matrix
    -- ^ __Returns:__ the initialized matrix
matrixInitFromFloat :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Matrix -> [Float] -> m Matrix
matrixInitFromFloat Matrix
m [Float]
v = IO Matrix -> m Matrix
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Matrix -> m Matrix) -> IO Matrix -> m Matrix
forall a b. (a -> b) -> a -> b
$ do
    m' <- Matrix -> IO (Ptr Matrix)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Matrix
m
    v' <- (packMapStorableArray realToFrac) v
    result <- graphene_matrix_init_from_float m' v'
    checkUnexpectedReturnNULL "matrixInitFromFloat" result
    result' <- (newBoxed Matrix) result
    touchManagedPtr m
    freeMem v'
    return result'

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

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


#endif

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

foreign import ccall "graphene_matrix_init_from_matrix" graphene_matrix_init_from_matrix :: 
    Ptr Matrix ->                           -- m : TInterface (Name {namespace = "Graphene", name = "Matrix"})
    Ptr Matrix ->                           -- src : TInterface (Name {namespace = "Graphene", name = "Matrix"})
    IO (Ptr Matrix)

-- | Initializes a t'GI.Graphene.Structs.Matrix.Matrix' using the values of the
-- given matrix.
-- 
-- /Since: 1.0/
matrixInitFromMatrix ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Matrix
    -- ^ /@m@/: a t'GI.Graphene.Structs.Matrix.Matrix'
    -> Matrix
    -- ^ /@src@/: a t'GI.Graphene.Structs.Matrix.Matrix'
    -> m Matrix
    -- ^ __Returns:__ the initialized matrix
matrixInitFromMatrix :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Matrix -> Matrix -> m Matrix
matrixInitFromMatrix Matrix
m Matrix
src = IO Matrix -> m Matrix
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Matrix -> m Matrix) -> IO Matrix -> m Matrix
forall a b. (a -> b) -> a -> b
$ do
    m' <- Matrix -> IO (Ptr Matrix)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Matrix
m
    src' <- unsafeManagedPtrGetPtr src
    result <- graphene_matrix_init_from_matrix m' src'
    checkUnexpectedReturnNULL "matrixInitFromMatrix" result
    result' <- (newBoxed Matrix) result
    touchManagedPtr m
    touchManagedPtr src
    return result'

#if defined(ENABLE_OVERLOADING)
data MatrixInitFromMatrixMethodInfo
instance (signature ~ (Matrix -> m Matrix), MonadIO m) => O.OverloadedMethod MatrixInitFromMatrixMethodInfo Matrix signature where
    overloadedMethod = matrixInitFromMatrix

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


#endif

-- method Matrix::init_from_vec4
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "m"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Matrix" }
--           , argCType = Just "graphene_matrix_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_matrix_t"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "v0"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Vec4" }
--           , argCType = Just "const graphene_vec4_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the first row vector"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "v1"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Vec4" }
--           , argCType = Just "const graphene_vec4_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the second row vector"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "v2"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Vec4" }
--           , argCType = Just "const graphene_vec4_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the third row vector"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "v3"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Vec4" }
--           , argCType = Just "const graphene_vec4_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the fourth row vector"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Graphene" , name = "Matrix" })
-- throws : False
-- Skip return : False

foreign import ccall "graphene_matrix_init_from_vec4" graphene_matrix_init_from_vec4 :: 
    Ptr Matrix ->                           -- m : TInterface (Name {namespace = "Graphene", name = "Matrix"})
    Ptr Graphene.Vec4.Vec4 ->               -- v0 : TInterface (Name {namespace = "Graphene", name = "Vec4"})
    Ptr Graphene.Vec4.Vec4 ->               -- v1 : TInterface (Name {namespace = "Graphene", name = "Vec4"})
    Ptr Graphene.Vec4.Vec4 ->               -- v2 : TInterface (Name {namespace = "Graphene", name = "Vec4"})
    Ptr Graphene.Vec4.Vec4 ->               -- v3 : TInterface (Name {namespace = "Graphene", name = "Vec4"})
    IO (Ptr Matrix)

-- | Initializes a t'GI.Graphene.Structs.Matrix.Matrix' with the given four row
-- vectors.
-- 
-- /Since: 1.0/
matrixInitFromVec4 ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Matrix
    -- ^ /@m@/: a t'GI.Graphene.Structs.Matrix.Matrix'
    -> Graphene.Vec4.Vec4
    -- ^ /@v0@/: the first row vector
    -> Graphene.Vec4.Vec4
    -- ^ /@v1@/: the second row vector
    -> Graphene.Vec4.Vec4
    -- ^ /@v2@/: the third row vector
    -> Graphene.Vec4.Vec4
    -- ^ /@v3@/: the fourth row vector
    -> m Matrix
    -- ^ __Returns:__ the initialized matrix
matrixInitFromVec4 :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Matrix -> Vec4 -> Vec4 -> Vec4 -> Vec4 -> m Matrix
matrixInitFromVec4 Matrix
m Vec4
v0 Vec4
v1 Vec4
v2 Vec4
v3 = IO Matrix -> m Matrix
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Matrix -> m Matrix) -> IO Matrix -> m Matrix
forall a b. (a -> b) -> a -> b
$ do
    m' <- Matrix -> IO (Ptr Matrix)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Matrix
m
    v0' <- unsafeManagedPtrGetPtr v0
    v1' <- unsafeManagedPtrGetPtr v1
    v2' <- unsafeManagedPtrGetPtr v2
    v3' <- unsafeManagedPtrGetPtr v3
    result <- graphene_matrix_init_from_vec4 m' v0' v1' v2' v3'
    checkUnexpectedReturnNULL "matrixInitFromVec4" result
    result' <- (newBoxed Matrix) result
    touchManagedPtr m
    touchManagedPtr v0
    touchManagedPtr v1
    touchManagedPtr v2
    touchManagedPtr v3
    return result'

#if defined(ENABLE_OVERLOADING)
data MatrixInitFromVec4MethodInfo
instance (signature ~ (Graphene.Vec4.Vec4 -> Graphene.Vec4.Vec4 -> Graphene.Vec4.Vec4 -> Graphene.Vec4.Vec4 -> m Matrix), MonadIO m) => O.OverloadedMethod MatrixInitFromVec4MethodInfo Matrix signature where
    overloadedMethod = matrixInitFromVec4

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


#endif

-- method Matrix::init_frustum
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "m"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Matrix" }
--           , argCType = Just "graphene_matrix_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_matrix_t"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "left"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "distance of the left clipping plane"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "right"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "distance of the right clipping plane"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "bottom"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "distance of the bottom clipping plane"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "top"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "distance of the top clipping plane"
--                 , 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 "distance of the 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 "distance of the far clipping plane"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Graphene" , name = "Matrix" })
-- throws : False
-- Skip return : False

foreign import ccall "graphene_matrix_init_frustum" graphene_matrix_init_frustum :: 
    Ptr Matrix ->                           -- m : TInterface (Name {namespace = "Graphene", name = "Matrix"})
    CFloat ->                               -- left : TBasicType TFloat
    CFloat ->                               -- right : TBasicType TFloat
    CFloat ->                               -- bottom : TBasicType TFloat
    CFloat ->                               -- top : TBasicType TFloat
    CFloat ->                               -- z_near : TBasicType TFloat
    CFloat ->                               -- z_far : TBasicType TFloat
    IO (Ptr Matrix)

-- | Initializes a t'GI.Graphene.Structs.Matrix.Matrix' compatible with t'GI.Graphene.Structs.Frustum.Frustum'.
-- 
-- See also: 'GI.Graphene.Structs.Frustum.frustumInitFromMatrix'
-- 
-- /Since: 1.2/
matrixInitFrustum ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Matrix
    -- ^ /@m@/: a t'GI.Graphene.Structs.Matrix.Matrix'
    -> Float
    -- ^ /@left@/: distance of the left clipping plane
    -> Float
    -- ^ /@right@/: distance of the right clipping plane
    -> Float
    -- ^ /@bottom@/: distance of the bottom clipping plane
    -> Float
    -- ^ /@top@/: distance of the top clipping plane
    -> Float
    -- ^ /@zNear@/: distance of the near clipping plane
    -> Float
    -- ^ /@zFar@/: distance of the far clipping plane
    -> m Matrix
    -- ^ __Returns:__ the initialized matrix
matrixInitFrustum :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Matrix
-> Float -> Float -> Float -> Float -> Float -> Float -> m Matrix
matrixInitFrustum Matrix
m Float
left Float
right Float
bottom Float
top Float
zNear Float
zFar = IO Matrix -> m Matrix
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Matrix -> m Matrix) -> IO Matrix -> m Matrix
forall a b. (a -> b) -> a -> b
$ do
    m' <- Matrix -> IO (Ptr Matrix)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Matrix
m
    let left' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
left
    let right' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
right
    let bottom' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
bottom
    let top' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
top
    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
    result <- graphene_matrix_init_frustum m' left' right' bottom' top' zNear' zFar'
    checkUnexpectedReturnNULL "matrixInitFrustum" result
    result' <- (newBoxed Matrix) result
    touchManagedPtr m
    return result'

#if defined(ENABLE_OVERLOADING)
data MatrixInitFrustumMethodInfo
instance (signature ~ (Float -> Float -> Float -> Float -> Float -> Float -> m Matrix), MonadIO m) => O.OverloadedMethod MatrixInitFrustumMethodInfo Matrix signature where
    overloadedMethod = matrixInitFrustum

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


#endif

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

foreign import ccall "graphene_matrix_init_identity" graphene_matrix_init_identity :: 
    Ptr Matrix ->                           -- m : TInterface (Name {namespace = "Graphene", name = "Matrix"})
    IO (Ptr Matrix)

-- | Initializes a t'GI.Graphene.Structs.Matrix.Matrix' with the identity matrix.
-- 
-- /Since: 1.0/
matrixInitIdentity ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Matrix
    -- ^ /@m@/: a t'GI.Graphene.Structs.Matrix.Matrix'
    -> m Matrix
    -- ^ __Returns:__ the initialized matrix
matrixInitIdentity :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Matrix -> m Matrix
matrixInitIdentity Matrix
m = IO Matrix -> m Matrix
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Matrix -> m Matrix) -> IO Matrix -> m Matrix
forall a b. (a -> b) -> a -> b
$ do
    m' <- Matrix -> IO (Ptr Matrix)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Matrix
m
    result <- graphene_matrix_init_identity m'
    checkUnexpectedReturnNULL "matrixInitIdentity" result
    result' <- (newBoxed Matrix) result
    touchManagedPtr m
    return result'

#if defined(ENABLE_OVERLOADING)
data MatrixInitIdentityMethodInfo
instance (signature ~ (m Matrix), MonadIO m) => O.OverloadedMethod MatrixInitIdentityMethodInfo Matrix signature where
    overloadedMethod = matrixInitIdentity

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


#endif

-- method Matrix::init_look_at
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "m"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Matrix" }
--           , argCType = Just "graphene_matrix_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_matrix_t"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "eye"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Vec3" }
--           , argCType = Just "const graphene_vec3_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the vector describing the position to look from"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "center"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Vec3" }
--           , argCType = Just "const graphene_vec3_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the vector describing the position to look at"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "up"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Vec3" }
--           , argCType = Just "const graphene_vec3_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "the vector describing the world's upward direction; usually,\n  this is the graphene_vec3_y_axis() vector"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Graphene" , name = "Matrix" })
-- throws : False
-- Skip return : False

foreign import ccall "graphene_matrix_init_look_at" graphene_matrix_init_look_at :: 
    Ptr Matrix ->                           -- m : TInterface (Name {namespace = "Graphene", name = "Matrix"})
    Ptr Graphene.Vec3.Vec3 ->               -- eye : TInterface (Name {namespace = "Graphene", name = "Vec3"})
    Ptr Graphene.Vec3.Vec3 ->               -- center : TInterface (Name {namespace = "Graphene", name = "Vec3"})
    Ptr Graphene.Vec3.Vec3 ->               -- up : TInterface (Name {namespace = "Graphene", name = "Vec3"})
    IO (Ptr Matrix)

-- | Initializes a t'GI.Graphene.Structs.Matrix.Matrix' so that it positions the \"camera\"
-- at the given /@eye@/ coordinates towards an object at the /@center@/
-- coordinates. The top of the camera is aligned to the direction
-- of the /@up@/ vector.
-- 
-- Before the transform, the camera is assumed to be placed at the
-- origin, looking towards the negative Z axis, with the top side of
-- the camera facing in the direction of the Y axis and the right
-- side in the direction of the X axis.
-- 
-- In theory, one could use /@m@/ to transform a model of such a camera
-- into world-space. However, it is more common to use the inverse of
-- /@m@/ to transform another object from world coordinates to the view
-- coordinates of the camera. Typically you would then apply the
-- camera projection transform to get from view to screen
-- coordinates.
-- 
-- /Since: 1.0/
matrixInitLookAt ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Matrix
    -- ^ /@m@/: a t'GI.Graphene.Structs.Matrix.Matrix'
    -> Graphene.Vec3.Vec3
    -- ^ /@eye@/: the vector describing the position to look from
    -> Graphene.Vec3.Vec3
    -- ^ /@center@/: the vector describing the position to look at
    -> Graphene.Vec3.Vec3
    -- ^ /@up@/: the vector describing the world\'s upward direction; usually,
    --   this is the 'GI.Graphene.Functions.vec3YAxis' vector
    -> m Matrix
    -- ^ __Returns:__ the initialized matrix
matrixInitLookAt :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Matrix -> Vec3 -> Vec3 -> Vec3 -> m Matrix
matrixInitLookAt Matrix
m Vec3
eye Vec3
center Vec3
up = IO Matrix -> m Matrix
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Matrix -> m Matrix) -> IO Matrix -> m Matrix
forall a b. (a -> b) -> a -> b
$ do
    m' <- Matrix -> IO (Ptr Matrix)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Matrix
m
    eye' <- unsafeManagedPtrGetPtr eye
    center' <- unsafeManagedPtrGetPtr center
    up' <- unsafeManagedPtrGetPtr up
    result <- graphene_matrix_init_look_at m' eye' center' up'
    checkUnexpectedReturnNULL "matrixInitLookAt" result
    result' <- (newBoxed Matrix) result
    touchManagedPtr m
    touchManagedPtr eye
    touchManagedPtr center
    touchManagedPtr up
    return result'

#if defined(ENABLE_OVERLOADING)
data MatrixInitLookAtMethodInfo
instance (signature ~ (Graphene.Vec3.Vec3 -> Graphene.Vec3.Vec3 -> Graphene.Vec3.Vec3 -> m Matrix), MonadIO m) => O.OverloadedMethod MatrixInitLookAtMethodInfo Matrix signature where
    overloadedMethod = matrixInitLookAt

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


#endif

-- method Matrix::init_ortho
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "m"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Matrix" }
--           , argCType = Just "graphene_matrix_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_matrix_t"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "left"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the left edge of the clipping plane"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "right"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the right edge of the clipping plane"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "top"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the top edge of the clipping plane"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "bottom"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the bottom edge of the clipping plane"
--                 , 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 distance of the 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 distance of the far clipping plane"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Graphene" , name = "Matrix" })
-- throws : False
-- Skip return : False

foreign import ccall "graphene_matrix_init_ortho" graphene_matrix_init_ortho :: 
    Ptr Matrix ->                           -- m : TInterface (Name {namespace = "Graphene", name = "Matrix"})
    CFloat ->                               -- left : TBasicType TFloat
    CFloat ->                               -- right : TBasicType TFloat
    CFloat ->                               -- top : TBasicType TFloat
    CFloat ->                               -- bottom : TBasicType TFloat
    CFloat ->                               -- z_near : TBasicType TFloat
    CFloat ->                               -- z_far : TBasicType TFloat
    IO (Ptr Matrix)

-- | Initializes a t'GI.Graphene.Structs.Matrix.Matrix' with an orthographic projection.
-- 
-- /Since: 1.0/
matrixInitOrtho ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Matrix
    -- ^ /@m@/: a t'GI.Graphene.Structs.Matrix.Matrix'
    -> Float
    -- ^ /@left@/: the left edge of the clipping plane
    -> Float
    -- ^ /@right@/: the right edge of the clipping plane
    -> Float
    -- ^ /@top@/: the top edge of the clipping plane
    -> Float
    -- ^ /@bottom@/: the bottom edge of the clipping plane
    -> Float
    -- ^ /@zNear@/: the distance of the near clipping plane
    -> Float
    -- ^ /@zFar@/: the distance of the far clipping plane
    -> m Matrix
    -- ^ __Returns:__ the initialized matrix
matrixInitOrtho :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Matrix
-> Float -> Float -> Float -> Float -> Float -> Float -> m Matrix
matrixInitOrtho Matrix
m Float
left Float
right Float
top Float
bottom Float
zNear Float
zFar = IO Matrix -> m Matrix
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Matrix -> m Matrix) -> IO Matrix -> m Matrix
forall a b. (a -> b) -> a -> b
$ do
    m' <- Matrix -> IO (Ptr Matrix)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Matrix
m
    let left' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
left
    let right' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
right
    let top' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
top
    let bottom' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
bottom
    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
    result <- graphene_matrix_init_ortho m' left' right' top' bottom' zNear' zFar'
    checkUnexpectedReturnNULL "matrixInitOrtho" result
    result' <- (newBoxed Matrix) result
    touchManagedPtr m
    return result'

#if defined(ENABLE_OVERLOADING)
data MatrixInitOrthoMethodInfo
instance (signature ~ (Float -> Float -> Float -> Float -> Float -> Float -> m Matrix), MonadIO m) => O.OverloadedMethod MatrixInitOrthoMethodInfo Matrix signature where
    overloadedMethod = matrixInitOrtho

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


#endif

-- method Matrix::init_perspective
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "m"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Matrix" }
--           , argCType = Just "graphene_matrix_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_matrix_t"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "fovy"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the field of view angle, in degrees"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "aspect"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the aspect value" , 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 near Z 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 far Z plane" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Graphene" , name = "Matrix" })
-- throws : False
-- Skip return : False

foreign import ccall "graphene_matrix_init_perspective" graphene_matrix_init_perspective :: 
    Ptr Matrix ->                           -- m : TInterface (Name {namespace = "Graphene", name = "Matrix"})
    CFloat ->                               -- fovy : TBasicType TFloat
    CFloat ->                               -- aspect : TBasicType TFloat
    CFloat ->                               -- z_near : TBasicType TFloat
    CFloat ->                               -- z_far : TBasicType TFloat
    IO (Ptr Matrix)

-- | Initializes a t'GI.Graphene.Structs.Matrix.Matrix' with a perspective projection.
-- 
-- /Since: 1.0/
matrixInitPerspective ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Matrix
    -- ^ /@m@/: a t'GI.Graphene.Structs.Matrix.Matrix'
    -> Float
    -- ^ /@fovy@/: the field of view angle, in degrees
    -> Float
    -- ^ /@aspect@/: the aspect value
    -> Float
    -- ^ /@zNear@/: the near Z plane
    -> Float
    -- ^ /@zFar@/: the far Z plane
    -> m Matrix
    -- ^ __Returns:__ the initialized matrix
matrixInitPerspective :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Matrix -> Float -> Float -> Float -> Float -> m Matrix
matrixInitPerspective Matrix
m Float
fovy Float
aspect Float
zNear Float
zFar = IO Matrix -> m Matrix
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Matrix -> m Matrix) -> IO Matrix -> m Matrix
forall a b. (a -> b) -> a -> b
$ do
    m' <- Matrix -> IO (Ptr Matrix)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Matrix
m
    let fovy' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
fovy
    let aspect' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
aspect
    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
    result <- graphene_matrix_init_perspective m' fovy' aspect' zNear' zFar'
    checkUnexpectedReturnNULL "matrixInitPerspective" result
    result' <- (newBoxed Matrix) result
    touchManagedPtr m
    return result'

#if defined(ENABLE_OVERLOADING)
data MatrixInitPerspectiveMethodInfo
instance (signature ~ (Float -> Float -> Float -> Float -> m Matrix), MonadIO m) => O.OverloadedMethod MatrixInitPerspectiveMethodInfo Matrix signature where
    overloadedMethod = matrixInitPerspective

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


#endif

-- method Matrix::init_rotate
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "m"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Matrix" }
--           , argCType = Just "graphene_matrix_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_matrix_t"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "angle"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the rotation angle, in degrees"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "axis"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Vec3" }
--           , argCType = Just "const graphene_vec3_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the axis vector as 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 = "Matrix" })
-- throws : False
-- Skip return : False

foreign import ccall "graphene_matrix_init_rotate" graphene_matrix_init_rotate :: 
    Ptr Matrix ->                           -- m : TInterface (Name {namespace = "Graphene", name = "Matrix"})
    CFloat ->                               -- angle : TBasicType TFloat
    Ptr Graphene.Vec3.Vec3 ->               -- axis : TInterface (Name {namespace = "Graphene", name = "Vec3"})
    IO (Ptr Matrix)

-- | Initializes /@m@/ to represent a rotation of /@angle@/ degrees on
-- the axis represented by the /@axis@/ vector.
-- 
-- /Since: 1.0/
matrixInitRotate ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Matrix
    -- ^ /@m@/: a t'GI.Graphene.Structs.Matrix.Matrix'
    -> Float
    -- ^ /@angle@/: the rotation angle, in degrees
    -> Graphene.Vec3.Vec3
    -- ^ /@axis@/: the axis vector as a t'GI.Graphene.Structs.Vec3.Vec3'
    -> m Matrix
    -- ^ __Returns:__ the initialized matrix
matrixInitRotate :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Matrix -> Float -> Vec3 -> m Matrix
matrixInitRotate Matrix
m Float
angle Vec3
axis = IO Matrix -> m Matrix
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Matrix -> m Matrix) -> IO Matrix -> m Matrix
forall a b. (a -> b) -> a -> b
$ do
    m' <- Matrix -> IO (Ptr Matrix)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Matrix
m
    let angle' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
angle
    axis' <- unsafeManagedPtrGetPtr axis
    result <- graphene_matrix_init_rotate m' angle' axis'
    checkUnexpectedReturnNULL "matrixInitRotate" result
    result' <- (newBoxed Matrix) result
    touchManagedPtr m
    touchManagedPtr axis
    return result'

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

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


#endif

-- method Matrix::init_scale
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "m"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Matrix" }
--           , argCType = Just "graphene_matrix_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_matrix_t"
--                 , 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 scale factor on the X axis"
--                 , 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 scale factor on the Y axis"
--                 , 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 scale factor on the Z axis"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Graphene" , name = "Matrix" })
-- throws : False
-- Skip return : False

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

-- | Initializes a t'GI.Graphene.Structs.Matrix.Matrix' with the given scaling factors.
-- 
-- /Since: 1.0/
matrixInitScale ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Matrix
    -- ^ /@m@/: a t'GI.Graphene.Structs.Matrix.Matrix'
    -> Float
    -- ^ /@x@/: the scale factor on the X axis
    -> Float
    -- ^ /@y@/: the scale factor on the Y axis
    -> Float
    -- ^ /@z@/: the scale factor on the Z axis
    -> m Matrix
    -- ^ __Returns:__ the initialized matrix
matrixInitScale :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Matrix -> Float -> Float -> Float -> m Matrix
matrixInitScale Matrix
m Float
x Float
y Float
z = IO Matrix -> m Matrix
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Matrix -> m Matrix) -> IO Matrix -> m Matrix
forall a b. (a -> b) -> a -> b
$ do
    m' <- Matrix -> IO (Ptr Matrix)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Matrix
m
    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_matrix_init_scale m' x' y' z'
    checkUnexpectedReturnNULL "matrixInitScale" result
    result' <- (newBoxed Matrix) result
    touchManagedPtr m
    return result'

#if defined(ENABLE_OVERLOADING)
data MatrixInitScaleMethodInfo
instance (signature ~ (Float -> Float -> Float -> m Matrix), MonadIO m) => O.OverloadedMethod MatrixInitScaleMethodInfo Matrix signature where
    overloadedMethod = matrixInitScale

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


#endif

-- method Matrix::init_skew
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "m"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Matrix" }
--           , argCType = Just "graphene_matrix_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_matrix_t"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "x_skew"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "skew factor, in radians, on the X axis"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "y_skew"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "skew factor, in radians, on the Y axis"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Graphene" , name = "Matrix" })
-- throws : False
-- Skip return : False

foreign import ccall "graphene_matrix_init_skew" graphene_matrix_init_skew :: 
    Ptr Matrix ->                           -- m : TInterface (Name {namespace = "Graphene", name = "Matrix"})
    CFloat ->                               -- x_skew : TBasicType TFloat
    CFloat ->                               -- y_skew : TBasicType TFloat
    IO (Ptr Matrix)

-- | Initializes a t'GI.Graphene.Structs.Matrix.Matrix' with a skew transformation
-- with the given factors.
-- 
-- /Since: 1.0/
matrixInitSkew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Matrix
    -- ^ /@m@/: a t'GI.Graphene.Structs.Matrix.Matrix'
    -> Float
    -- ^ /@xSkew@/: skew factor, in radians, on the X axis
    -> Float
    -- ^ /@ySkew@/: skew factor, in radians, on the Y axis
    -> m Matrix
    -- ^ __Returns:__ the initialized matrix
matrixInitSkew :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Matrix -> Float -> Float -> m Matrix
matrixInitSkew Matrix
m Float
xSkew Float
ySkew = IO Matrix -> m Matrix
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Matrix -> m Matrix) -> IO Matrix -> m Matrix
forall a b. (a -> b) -> a -> b
$ do
    m' <- Matrix -> IO (Ptr Matrix)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Matrix
m
    let xSkew' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
xSkew
    let ySkew' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
ySkew
    result <- graphene_matrix_init_skew m' xSkew' ySkew'
    checkUnexpectedReturnNULL "matrixInitSkew" result
    result' <- (newBoxed Matrix) result
    touchManagedPtr m
    return result'

#if defined(ENABLE_OVERLOADING)
data MatrixInitSkewMethodInfo
instance (signature ~ (Float -> Float -> m Matrix), MonadIO m) => O.OverloadedMethod MatrixInitSkewMethodInfo Matrix signature where
    overloadedMethod = matrixInitSkew

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


#endif

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

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

-- | Initializes a t'GI.Graphene.Structs.Matrix.Matrix' with a translation to the
-- given coordinates.
-- 
-- /Since: 1.0/
matrixInitTranslate ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Matrix
    -- ^ /@m@/: a t'GI.Graphene.Structs.Matrix.Matrix'
    -> Graphene.Point3D.Point3D
    -- ^ /@p@/: the translation coordinates
    -> m Matrix
    -- ^ __Returns:__ the initialized matrix
matrixInitTranslate :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Matrix -> Point3D -> m Matrix
matrixInitTranslate Matrix
m Point3D
p = IO Matrix -> m Matrix
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Matrix -> m Matrix) -> IO Matrix -> m Matrix
forall a b. (a -> b) -> a -> b
$ do
    m' <- Matrix -> IO (Ptr Matrix)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Matrix
m
    p' <- unsafeManagedPtrGetPtr p
    result <- graphene_matrix_init_translate m' p'
    checkUnexpectedReturnNULL "matrixInitTranslate" result
    result' <- (newBoxed Matrix) result
    touchManagedPtr m
    touchManagedPtr p
    return result'

#if defined(ENABLE_OVERLOADING)
data MatrixInitTranslateMethodInfo
instance (signature ~ (Graphene.Point3D.Point3D -> m Matrix), MonadIO m) => O.OverloadedMethod MatrixInitTranslateMethodInfo Matrix signature where
    overloadedMethod = matrixInitTranslate

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


#endif

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

-- | Linearly interpolates the two given t'GI.Graphene.Structs.Matrix.Matrix' by
-- interpolating the decomposed transformations separately.
-- 
-- If either matrix cannot be reduced to their transformations
-- then the interpolation cannot be performed, and this function
-- will return an identity matrix.
-- 
-- /Since: 1.0/
matrixInterpolate ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Matrix
    -- ^ /@a@/: a t'GI.Graphene.Structs.Matrix.Matrix'
    -> Matrix
    -- ^ /@b@/: a t'GI.Graphene.Structs.Matrix.Matrix'
    -> Double
    -- ^ /@factor@/: the linear interpolation factor
    -> m (Matrix)
matrixInterpolate :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Matrix -> Matrix -> Double -> m Matrix
matrixInterpolate Matrix
a Matrix
b Double
factor = IO Matrix -> m Matrix
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Matrix -> m Matrix) -> IO Matrix -> m Matrix
forall a b. (a -> b) -> a -> b
$ do
    a' <- Matrix -> IO (Ptr Matrix)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Matrix
a
    b' <- unsafeManagedPtrGetPtr b
    let factor' = Double -> CDouble
forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
factor
    res <- SP.callocBoxedBytes 64 :: IO (Ptr Matrix)
    graphene_matrix_interpolate a' b' factor' res
    res' <- (wrapBoxed Matrix) res
    touchManagedPtr a
    touchManagedPtr b
    return res'

#if defined(ENABLE_OVERLOADING)
data MatrixInterpolateMethodInfo
instance (signature ~ (Matrix -> Double -> m (Matrix)), MonadIO m) => O.OverloadedMethod MatrixInterpolateMethodInfo Matrix signature where
    overloadedMethod = matrixInterpolate

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


#endif

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

-- | Inverts the given matrix.
-- 
-- /Since: 1.0/
matrixInverse ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Matrix
    -- ^ /@m@/: a t'GI.Graphene.Structs.Matrix.Matrix'
    -> m ((Bool, Matrix))
    -- ^ __Returns:__ @true@ if the matrix is invertible
matrixInverse :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Matrix -> m (Bool, Matrix)
matrixInverse Matrix
m = IO (Bool, Matrix) -> m (Bool, Matrix)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Matrix) -> m (Bool, Matrix))
-> IO (Bool, Matrix) -> m (Bool, Matrix)
forall a b. (a -> b) -> a -> b
$ do
    m' <- Matrix -> IO (Ptr Matrix)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Matrix
m
    res <- SP.callocBoxedBytes 64 :: IO (Ptr Matrix)
    result <- graphene_matrix_inverse m' res
    let result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    res' <- (wrapBoxed Matrix) res
    touchManagedPtr m
    return (result', res')

#if defined(ENABLE_OVERLOADING)
data MatrixInverseMethodInfo
instance (signature ~ (m ((Bool, Matrix))), MonadIO m) => O.OverloadedMethod MatrixInverseMethodInfo Matrix signature where
    overloadedMethod = matrixInverse

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


#endif

-- method Matrix::is_2d
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "m"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Matrix" }
--           , argCType = Just "const graphene_matrix_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_matrix_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_matrix_is_2d" graphene_matrix_is_2d :: 
    Ptr Matrix ->                           -- m : TInterface (Name {namespace = "Graphene", name = "Matrix"})
    IO CInt

-- | Checks whether the given t'GI.Graphene.Structs.Matrix.Matrix' is compatible with an
-- a 2D affine transformation matrix.
-- 
-- /Since: 1.0/
matrixIs2d ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Matrix
    -- ^ /@m@/: a t'GI.Graphene.Structs.Matrix.Matrix'
    -> m Bool
    -- ^ __Returns:__ @true@ if the matrix is compatible with an affine
    --   transformation matrix
matrixIs2d :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Matrix -> m Bool
matrixIs2d Matrix
m = 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
    m' <- Matrix -> IO (Ptr Matrix)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Matrix
m
    result <- graphene_matrix_is_2d m'
    let result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    touchManagedPtr m
    return result'

#if defined(ENABLE_OVERLOADING)
data MatrixIs2dMethodInfo
instance (signature ~ (m Bool), MonadIO m) => O.OverloadedMethod MatrixIs2dMethodInfo Matrix signature where
    overloadedMethod = matrixIs2d

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


#endif

-- method Matrix::is_backface_visible
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "m"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Matrix" }
--           , argCType = Just "const graphene_matrix_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_matrix_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_matrix_is_backface_visible" graphene_matrix_is_backface_visible :: 
    Ptr Matrix ->                           -- m : TInterface (Name {namespace = "Graphene", name = "Matrix"})
    IO CInt

-- | Checks whether a t'GI.Graphene.Structs.Matrix.Matrix' has a visible back face.
-- 
-- /Since: 1.0/
matrixIsBackfaceVisible ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Matrix
    -- ^ /@m@/: a t'GI.Graphene.Structs.Matrix.Matrix'
    -> m Bool
    -- ^ __Returns:__ @true@ if the back face of the matrix is visible
matrixIsBackfaceVisible :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Matrix -> m Bool
matrixIsBackfaceVisible Matrix
m = 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
    m' <- Matrix -> IO (Ptr Matrix)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Matrix
m
    result <- graphene_matrix_is_backface_visible m'
    let result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    touchManagedPtr m
    return result'

#if defined(ENABLE_OVERLOADING)
data MatrixIsBackfaceVisibleMethodInfo
instance (signature ~ (m Bool), MonadIO m) => O.OverloadedMethod MatrixIsBackfaceVisibleMethodInfo Matrix signature where
    overloadedMethod = matrixIsBackfaceVisible

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


#endif

-- method Matrix::is_identity
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "m"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Matrix" }
--           , argCType = Just "const graphene_matrix_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_matrix_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_matrix_is_identity" graphene_matrix_is_identity :: 
    Ptr Matrix ->                           -- m : TInterface (Name {namespace = "Graphene", name = "Matrix"})
    IO CInt

-- | Checks whether the given t'GI.Graphene.Structs.Matrix.Matrix' is the identity matrix.
-- 
-- /Since: 1.0/
matrixIsIdentity ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Matrix
    -- ^ /@m@/: a t'GI.Graphene.Structs.Matrix.Matrix'
    -> m Bool
    -- ^ __Returns:__ @true@ if the matrix is the identity matrix
matrixIsIdentity :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Matrix -> m Bool
matrixIsIdentity Matrix
m = 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
    m' <- Matrix -> IO (Ptr Matrix)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Matrix
m
    result <- graphene_matrix_is_identity m'
    let result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    touchManagedPtr m
    return result'

#if defined(ENABLE_OVERLOADING)
data MatrixIsIdentityMethodInfo
instance (signature ~ (m Bool), MonadIO m) => O.OverloadedMethod MatrixIsIdentityMethodInfo Matrix signature where
    overloadedMethod = matrixIsIdentity

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


#endif

-- method Matrix::is_singular
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "m"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Matrix" }
--           , argCType = Just "const graphene_matrix_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_matrix_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_matrix_is_singular" graphene_matrix_is_singular :: 
    Ptr Matrix ->                           -- m : TInterface (Name {namespace = "Graphene", name = "Matrix"})
    IO CInt

-- | Checks whether a matrix is singular.
-- 
-- /Since: 1.0/
matrixIsSingular ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Matrix
    -- ^ /@m@/: a t'GI.Graphene.Structs.Matrix.Matrix'
    -> m Bool
    -- ^ __Returns:__ @true@ if the matrix is singular
matrixIsSingular :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Matrix -> m Bool
matrixIsSingular Matrix
m = 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
    m' <- Matrix -> IO (Ptr Matrix)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Matrix
m
    result <- graphene_matrix_is_singular m'
    let result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    touchManagedPtr m
    return result'

#if defined(ENABLE_OVERLOADING)
data MatrixIsSingularMethodInfo
instance (signature ~ (m Bool), MonadIO m) => O.OverloadedMethod MatrixIsSingularMethodInfo Matrix signature where
    overloadedMethod = matrixIsSingular

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


#endif

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

-- | Multiplies two t'GI.Graphene.Structs.Matrix.Matrix'.
-- 
-- Matrix multiplication is not commutative in general; the order of the factors matters.
-- The product of this multiplication is (/@a@/ × /@b@/)
-- 
-- /Since: 1.0/
matrixMultiply ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Matrix
    -- ^ /@a@/: a t'GI.Graphene.Structs.Matrix.Matrix'
    -> Matrix
    -- ^ /@b@/: a t'GI.Graphene.Structs.Matrix.Matrix'
    -> m (Matrix)
matrixMultiply :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Matrix -> Matrix -> m Matrix
matrixMultiply Matrix
a Matrix
b = IO Matrix -> m Matrix
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Matrix -> m Matrix) -> IO Matrix -> m Matrix
forall a b. (a -> b) -> a -> b
$ do
    a' <- Matrix -> IO (Ptr Matrix)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Matrix
a
    b' <- unsafeManagedPtrGetPtr b
    res <- SP.callocBoxedBytes 64 :: IO (Ptr Matrix)
    graphene_matrix_multiply a' b' res
    res' <- (wrapBoxed Matrix) res
    touchManagedPtr a
    touchManagedPtr b
    return res'

#if defined(ENABLE_OVERLOADING)
data MatrixMultiplyMethodInfo
instance (signature ~ (Matrix -> m (Matrix)), MonadIO m) => O.OverloadedMethod MatrixMultiplyMethodInfo Matrix signature where
    overloadedMethod = matrixMultiply

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


#endif

-- method Matrix::near
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "a"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Matrix" }
--           , argCType = Just "const graphene_matrix_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_matrix_t"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "b"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Matrix" }
--           , argCType = Just "const graphene_matrix_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_matrix_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 "the threshold between the two matrices"
--                 , 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_matrix_near" graphene_matrix_near :: 
    Ptr Matrix ->                           -- a : TInterface (Name {namespace = "Graphene", name = "Matrix"})
    Ptr Matrix ->                           -- b : TInterface (Name {namespace = "Graphene", name = "Matrix"})
    CFloat ->                               -- epsilon : TBasicType TFloat
    IO CInt

-- | Compares the two given t'GI.Graphene.Structs.Matrix.Matrix' matrices and checks
-- whether their values are within the given /@epsilon@/ of each
-- other.
-- 
-- /Since: 1.10/
matrixNear ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Matrix
    -- ^ /@a@/: a t'GI.Graphene.Structs.Matrix.Matrix'
    -> Matrix
    -- ^ /@b@/: a t'GI.Graphene.Structs.Matrix.Matrix'
    -> Float
    -- ^ /@epsilon@/: the threshold between the two matrices
    -> m Bool
    -- ^ __Returns:__ @true@ if the two matrices are near each other, and
    --   @false@ otherwise
matrixNear :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Matrix -> Matrix -> Float -> m Bool
matrixNear Matrix
a Matrix
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' <- Matrix -> IO (Ptr Matrix)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Matrix
a
    b' <- unsafeManagedPtrGetPtr b
    let epsilon' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
epsilon
    result <- graphene_matrix_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 MatrixNearMethodInfo
instance (signature ~ (Matrix -> Float -> m Bool), MonadIO m) => O.OverloadedMethod MatrixNearMethodInfo Matrix signature where
    overloadedMethod = matrixNear

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


#endif

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

-- | Normalizes the given t'GI.Graphene.Structs.Matrix.Matrix'.
-- 
-- /Since: 1.0/
matrixNormalize ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Matrix
    -- ^ /@m@/: a t'GI.Graphene.Structs.Matrix.Matrix'
    -> m (Matrix)
matrixNormalize :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Matrix -> m Matrix
matrixNormalize Matrix
m = IO Matrix -> m Matrix
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Matrix -> m Matrix) -> IO Matrix -> m Matrix
forall a b. (a -> b) -> a -> b
$ do
    m' <- Matrix -> IO (Ptr Matrix)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Matrix
m
    res <- SP.callocBoxedBytes 64 :: IO (Ptr Matrix)
    graphene_matrix_normalize m' res
    res' <- (wrapBoxed Matrix) res
    touchManagedPtr m
    return res'

#if defined(ENABLE_OVERLOADING)
data MatrixNormalizeMethodInfo
instance (signature ~ (m (Matrix)), MonadIO m) => O.OverloadedMethod MatrixNormalizeMethodInfo Matrix signature where
    overloadedMethod = matrixNormalize

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


#endif

-- method Matrix::perspective
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "m"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Matrix" }
--           , argCType = Just "const graphene_matrix_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_matrix_t"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "depth"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the depth of the perspective"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "res"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Matrix" }
--           , argCType = Just "graphene_matrix_t*"
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "return location for the\n  perspective matrix"
--                 , 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_matrix_perspective" graphene_matrix_perspective :: 
    Ptr Matrix ->                           -- m : TInterface (Name {namespace = "Graphene", name = "Matrix"})
    CFloat ->                               -- depth : TBasicType TFloat
    Ptr Matrix ->                           -- res : TInterface (Name {namespace = "Graphene", name = "Matrix"})
    IO ()

-- | Applies a perspective of /@depth@/ to the matrix.
-- 
-- /Since: 1.0/
matrixPerspective ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Matrix
    -- ^ /@m@/: a t'GI.Graphene.Structs.Matrix.Matrix'
    -> Float
    -- ^ /@depth@/: the depth of the perspective
    -> m (Matrix)
matrixPerspective :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Matrix -> Float -> m Matrix
matrixPerspective Matrix
m Float
depth = IO Matrix -> m Matrix
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Matrix -> m Matrix) -> IO Matrix -> m Matrix
forall a b. (a -> b) -> a -> b
$ do
    m' <- Matrix -> IO (Ptr Matrix)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Matrix
m
    let depth' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
depth
    res <- SP.callocBoxedBytes 64 :: IO (Ptr Matrix)
    graphene_matrix_perspective m' depth' res
    res' <- (wrapBoxed Matrix) res
    touchManagedPtr m
    return res'

#if defined(ENABLE_OVERLOADING)
data MatrixPerspectiveMethodInfo
instance (signature ~ (Float -> m (Matrix)), MonadIO m) => O.OverloadedMethod MatrixPerspectiveMethodInfo Matrix signature where
    overloadedMethod = matrixPerspective

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


#endif

-- method Matrix::print
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "m"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Matrix" }
--           , argCType = Just "const graphene_matrix_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The matrix to print"
--                 , 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_matrix_print" graphene_matrix_print :: 
    Ptr Matrix ->                           -- m : TInterface (Name {namespace = "Graphene", name = "Matrix"})
    IO ()

-- | Prints the contents of a matrix to the standard error stream.
-- 
-- This function is only useful for debugging; there are no guarantees
-- made on the format of the output.
-- 
-- /Since: 1.0/
matrixPrint ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Matrix
    -- ^ /@m@/: The matrix to print
    -> m ()
matrixPrint :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Matrix -> m ()
matrixPrint Matrix
m = 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
    m' <- Matrix -> IO (Ptr Matrix)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Matrix
m
    graphene_matrix_print m'
    touchManagedPtr m
    return ()

#if defined(ENABLE_OVERLOADING)
data MatrixPrintMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod MatrixPrintMethodInfo Matrix signature where
    overloadedMethod = matrixPrint

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


#endif

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

-- | Projects a t'GI.Graphene.Structs.Point.Point' using the matrix /@m@/.
-- 
-- /Since: 1.0/
matrixProjectPoint ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Matrix
    -- ^ /@m@/: a t'GI.Graphene.Structs.Matrix.Matrix'
    -> Graphene.Point.Point
    -- ^ /@p@/: a t'GI.Graphene.Structs.Point.Point'
    -> m (Graphene.Point.Point)
matrixProjectPoint :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Matrix -> Point -> m Point
matrixProjectPoint Matrix
m Point
p = IO Point -> m Point
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Point -> m Point) -> IO Point -> m Point
forall a b. (a -> b) -> a -> b
$ do
    m' <- Matrix -> IO (Ptr Matrix)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Matrix
m
    p' <- unsafeManagedPtrGetPtr p
    res <- SP.callocBoxedBytes 8 :: IO (Ptr Graphene.Point.Point)
    graphene_matrix_project_point m' p' res
    res' <- (wrapBoxed Graphene.Point.Point) res
    touchManagedPtr m
    touchManagedPtr p
    return res'

#if defined(ENABLE_OVERLOADING)
data MatrixProjectPointMethodInfo
instance (signature ~ (Graphene.Point.Point -> m (Graphene.Point.Point)), MonadIO m) => O.OverloadedMethod MatrixProjectPointMethodInfo Matrix signature where
    overloadedMethod = matrixProjectPoint

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


#endif

-- method Matrix::project_rect
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "m"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Matrix" }
--           , argCType = Just "const graphene_matrix_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_matrix_t"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "r"
--           , 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" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "res"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Quad" }
--           , argCType = Just "graphene_quad_t*"
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "return location for the projected\n  rectangle"
--                 , 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_matrix_project_rect" graphene_matrix_project_rect :: 
    Ptr Matrix ->                           -- m : TInterface (Name {namespace = "Graphene", name = "Matrix"})
    Ptr Graphene.Rect.Rect ->               -- r : TInterface (Name {namespace = "Graphene", name = "Rect"})
    Ptr Graphene.Quad.Quad ->               -- res : TInterface (Name {namespace = "Graphene", name = "Quad"})
    IO ()

-- | Projects all corners of a t'GI.Graphene.Structs.Rect.Rect' using the given matrix.
-- 
-- See also: 'GI.Graphene.Structs.Matrix.matrixProjectPoint'
-- 
-- /Since: 1.2/
matrixProjectRect ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Matrix
    -- ^ /@m@/: a t'GI.Graphene.Structs.Matrix.Matrix'
    -> Graphene.Rect.Rect
    -- ^ /@r@/: a t'GI.Graphene.Structs.Rect.Rect'
    -> m (Graphene.Quad.Quad)
matrixProjectRect :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Matrix -> Rect -> m Quad
matrixProjectRect Matrix
m Rect
r = IO Quad -> m Quad
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Quad -> m Quad) -> IO Quad -> m Quad
forall a b. (a -> b) -> a -> b
$ do
    m' <- Matrix -> IO (Ptr Matrix)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Matrix
m
    r' <- unsafeManagedPtrGetPtr r
    res <- SP.callocBoxedBytes 32 :: IO (Ptr Graphene.Quad.Quad)
    graphene_matrix_project_rect m' r' res
    res' <- (wrapBoxed Graphene.Quad.Quad) res
    touchManagedPtr m
    touchManagedPtr r
    return res'

#if defined(ENABLE_OVERLOADING)
data MatrixProjectRectMethodInfo
instance (signature ~ (Graphene.Rect.Rect -> m (Graphene.Quad.Quad)), MonadIO m) => O.OverloadedMethod MatrixProjectRectMethodInfo Matrix signature where
    overloadedMethod = matrixProjectRect

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


#endif

-- method Matrix::project_rect_bounds
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "m"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Matrix" }
--           , argCType = Just "const graphene_matrix_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_matrix_t"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "r"
--           , 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" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "res"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Rect" }
--           , argCType = Just "graphene_rect_t*"
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "return location for the projected\n  rectangle"
--                 , 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_matrix_project_rect_bounds" graphene_matrix_project_rect_bounds :: 
    Ptr Matrix ->                           -- m : TInterface (Name {namespace = "Graphene", name = "Matrix"})
    Ptr Graphene.Rect.Rect ->               -- r : TInterface (Name {namespace = "Graphene", name = "Rect"})
    Ptr Graphene.Rect.Rect ->               -- res : TInterface (Name {namespace = "Graphene", name = "Rect"})
    IO ()

-- | Projects a t'GI.Graphene.Structs.Rect.Rect' using the given matrix.
-- 
-- The resulting rectangle is the axis aligned bounding rectangle capable
-- of fully containing the projected rectangle.
-- 
-- /Since: 1.0/
matrixProjectRectBounds ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Matrix
    -- ^ /@m@/: a t'GI.Graphene.Structs.Matrix.Matrix'
    -> Graphene.Rect.Rect
    -- ^ /@r@/: a t'GI.Graphene.Structs.Rect.Rect'
    -> m (Graphene.Rect.Rect)
matrixProjectRectBounds :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Matrix -> Rect -> m Rect
matrixProjectRectBounds Matrix
m Rect
r = IO Rect -> m Rect
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Rect -> m Rect) -> IO Rect -> m Rect
forall a b. (a -> b) -> a -> b
$ do
    m' <- Matrix -> IO (Ptr Matrix)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Matrix
m
    r' <- unsafeManagedPtrGetPtr r
    res <- SP.callocBoxedBytes 16 :: IO (Ptr Graphene.Rect.Rect)
    graphene_matrix_project_rect_bounds m' r' res
    res' <- (wrapBoxed Graphene.Rect.Rect) res
    touchManagedPtr m
    touchManagedPtr r
    return res'

#if defined(ENABLE_OVERLOADING)
data MatrixProjectRectBoundsMethodInfo
instance (signature ~ (Graphene.Rect.Rect -> m (Graphene.Rect.Rect)), MonadIO m) => O.OverloadedMethod MatrixProjectRectBoundsMethodInfo Matrix signature where
    overloadedMethod = matrixProjectRectBounds

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


#endif

-- method Matrix::rotate
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "m"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Matrix" }
--           , argCType = Just "graphene_matrix_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_matrix_t"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "angle"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the rotation angle, in degrees"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "axis"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Vec3" }
--           , argCType = Just "const graphene_vec3_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the rotation axis, as a #graphene_vec3_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_matrix_rotate" graphene_matrix_rotate :: 
    Ptr Matrix ->                           -- m : TInterface (Name {namespace = "Graphene", name = "Matrix"})
    CFloat ->                               -- angle : TBasicType TFloat
    Ptr Graphene.Vec3.Vec3 ->               -- axis : TInterface (Name {namespace = "Graphene", name = "Vec3"})
    IO ()

-- | Adds a rotation transformation to /@m@/, using the given /@angle@/
-- and /@axis@/ vector.
-- 
-- This is the equivalent of calling 'GI.Graphene.Structs.Matrix.matrixInitRotate' and
-- then multiplying the matrix /@m@/ with the rotation matrix.
-- 
-- /Since: 1.0/
matrixRotate ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Matrix
    -- ^ /@m@/: a t'GI.Graphene.Structs.Matrix.Matrix'
    -> Float
    -- ^ /@angle@/: the rotation angle, in degrees
    -> Graphene.Vec3.Vec3
    -- ^ /@axis@/: the rotation axis, as a t'GI.Graphene.Structs.Vec3.Vec3'
    -> m ()
matrixRotate :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Matrix -> Float -> Vec3 -> m ()
matrixRotate Matrix
m Float
angle Vec3
axis = 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
    m' <- Matrix -> IO (Ptr Matrix)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Matrix
m
    let angle' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
angle
    axis' <- unsafeManagedPtrGetPtr axis
    graphene_matrix_rotate m' angle' axis'
    touchManagedPtr m
    touchManagedPtr axis
    return ()

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

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


#endif

-- method Matrix::rotate_euler
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "m"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Matrix" }
--           , argCType = Just "graphene_matrix_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_matrix_t"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "e"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Euler" }
--           , argCType = Just "const graphene_euler_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a rotation described by a #graphene_euler_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_matrix_rotate_euler" graphene_matrix_rotate_euler :: 
    Ptr Matrix ->                           -- m : TInterface (Name {namespace = "Graphene", name = "Matrix"})
    Ptr Graphene.Euler.Euler ->             -- e : TInterface (Name {namespace = "Graphene", name = "Euler"})
    IO ()

-- | Adds a rotation transformation to /@m@/, using the given
-- t'GI.Graphene.Structs.Euler.Euler'.
-- 
-- /Since: 1.2/
matrixRotateEuler ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Matrix
    -- ^ /@m@/: a t'GI.Graphene.Structs.Matrix.Matrix'
    -> Graphene.Euler.Euler
    -- ^ /@e@/: a rotation described by a t'GI.Graphene.Structs.Euler.Euler'
    -> m ()
matrixRotateEuler :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Matrix -> Euler -> m ()
matrixRotateEuler Matrix
m Euler
e = 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
    m' <- Matrix -> IO (Ptr Matrix)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Matrix
m
    e' <- unsafeManagedPtrGetPtr e
    graphene_matrix_rotate_euler m' e'
    touchManagedPtr m
    touchManagedPtr e
    return ()

#if defined(ENABLE_OVERLOADING)
data MatrixRotateEulerMethodInfo
instance (signature ~ (Graphene.Euler.Euler -> m ()), MonadIO m) => O.OverloadedMethod MatrixRotateEulerMethodInfo Matrix signature where
    overloadedMethod = matrixRotateEuler

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


#endif

-- method Matrix::rotate_quaternion
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "m"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Matrix" }
--           , argCType = Just "graphene_matrix_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_matrix_t"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "q"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Quaternion" }
--           , argCType = Just "const graphene_quaternion_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "a rotation described by a #graphene_quaternion_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_matrix_rotate_quaternion" graphene_matrix_rotate_quaternion :: 
    Ptr Matrix ->                           -- m : TInterface (Name {namespace = "Graphene", name = "Matrix"})
    Ptr Graphene.Quaternion.Quaternion ->   -- q : TInterface (Name {namespace = "Graphene", name = "Quaternion"})
    IO ()

-- | Adds a rotation transformation to /@m@/, using the given
-- t'GI.Graphene.Structs.Quaternion.Quaternion'.
-- 
-- This is the equivalent of calling 'GI.Graphene.Structs.Quaternion.quaternionToMatrix' and
-- then multiplying /@m@/ with the rotation matrix.
-- 
-- /Since: 1.2/
matrixRotateQuaternion ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Matrix
    -- ^ /@m@/: a t'GI.Graphene.Structs.Matrix.Matrix'
    -> Graphene.Quaternion.Quaternion
    -- ^ /@q@/: a rotation described by a t'GI.Graphene.Structs.Quaternion.Quaternion'
    -> m ()
matrixRotateQuaternion :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Matrix -> Quaternion -> m ()
matrixRotateQuaternion Matrix
m Quaternion
q = 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
    m' <- Matrix -> IO (Ptr Matrix)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Matrix
m
    q' <- unsafeManagedPtrGetPtr q
    graphene_matrix_rotate_quaternion m' q'
    touchManagedPtr m
    touchManagedPtr q
    return ()

#if defined(ENABLE_OVERLOADING)
data MatrixRotateQuaternionMethodInfo
instance (signature ~ (Graphene.Quaternion.Quaternion -> m ()), MonadIO m) => O.OverloadedMethod MatrixRotateQuaternionMethodInfo Matrix signature where
    overloadedMethod = matrixRotateQuaternion

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


#endif

-- method Matrix::rotate_x
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "m"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Matrix" }
--           , argCType = Just "graphene_matrix_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_matrix_t"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "angle"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the rotation angle, in degrees"
--                 , 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_matrix_rotate_x" graphene_matrix_rotate_x :: 
    Ptr Matrix ->                           -- m : TInterface (Name {namespace = "Graphene", name = "Matrix"})
    CFloat ->                               -- angle : TBasicType TFloat
    IO ()

-- | Adds a rotation transformation around the X axis to /@m@/, using
-- the given /@angle@/.
-- 
-- See also: 'GI.Graphene.Structs.Matrix.matrixRotate'
-- 
-- /Since: 1.0/
matrixRotateX ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Matrix
    -- ^ /@m@/: a t'GI.Graphene.Structs.Matrix.Matrix'
    -> Float
    -- ^ /@angle@/: the rotation angle, in degrees
    -> m ()
matrixRotateX :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Matrix -> Float -> m ()
matrixRotateX Matrix
m Float
angle = 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
    m' <- Matrix -> IO (Ptr Matrix)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Matrix
m
    let angle' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
angle
    graphene_matrix_rotate_x m' angle'
    touchManagedPtr m
    return ()

#if defined(ENABLE_OVERLOADING)
data MatrixRotateXMethodInfo
instance (signature ~ (Float -> m ()), MonadIO m) => O.OverloadedMethod MatrixRotateXMethodInfo Matrix signature where
    overloadedMethod = matrixRotateX

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


#endif

-- method Matrix::rotate_y
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "m"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Matrix" }
--           , argCType = Just "graphene_matrix_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_matrix_t"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "angle"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the rotation angle, in degrees"
--                 , 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_matrix_rotate_y" graphene_matrix_rotate_y :: 
    Ptr Matrix ->                           -- m : TInterface (Name {namespace = "Graphene", name = "Matrix"})
    CFloat ->                               -- angle : TBasicType TFloat
    IO ()

-- | Adds a rotation transformation around the Y axis to /@m@/, using
-- the given /@angle@/.
-- 
-- See also: 'GI.Graphene.Structs.Matrix.matrixRotate'
-- 
-- /Since: 1.0/
matrixRotateY ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Matrix
    -- ^ /@m@/: a t'GI.Graphene.Structs.Matrix.Matrix'
    -> Float
    -- ^ /@angle@/: the rotation angle, in degrees
    -> m ()
matrixRotateY :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Matrix -> Float -> m ()
matrixRotateY Matrix
m Float
angle = 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
    m' <- Matrix -> IO (Ptr Matrix)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Matrix
m
    let angle' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
angle
    graphene_matrix_rotate_y m' angle'
    touchManagedPtr m
    return ()

#if defined(ENABLE_OVERLOADING)
data MatrixRotateYMethodInfo
instance (signature ~ (Float -> m ()), MonadIO m) => O.OverloadedMethod MatrixRotateYMethodInfo Matrix signature where
    overloadedMethod = matrixRotateY

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


#endif

-- method Matrix::rotate_z
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "m"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Matrix" }
--           , argCType = Just "graphene_matrix_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_matrix_t"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "angle"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the rotation angle, in degrees"
--                 , 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_matrix_rotate_z" graphene_matrix_rotate_z :: 
    Ptr Matrix ->                           -- m : TInterface (Name {namespace = "Graphene", name = "Matrix"})
    CFloat ->                               -- angle : TBasicType TFloat
    IO ()

-- | Adds a rotation transformation around the Z axis to /@m@/, using
-- the given /@angle@/.
-- 
-- See also: 'GI.Graphene.Structs.Matrix.matrixRotate'
-- 
-- /Since: 1.0/
matrixRotateZ ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Matrix
    -- ^ /@m@/: a t'GI.Graphene.Structs.Matrix.Matrix'
    -> Float
    -- ^ /@angle@/: the rotation angle, in degrees
    -> m ()
matrixRotateZ :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Matrix -> Float -> m ()
matrixRotateZ Matrix
m Float
angle = 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
    m' <- Matrix -> IO (Ptr Matrix)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Matrix
m
    let angle' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
angle
    graphene_matrix_rotate_z m' angle'
    touchManagedPtr m
    return ()

#if defined(ENABLE_OVERLOADING)
data MatrixRotateZMethodInfo
instance (signature ~ (Float -> m ()), MonadIO m) => O.OverloadedMethod MatrixRotateZMethodInfo Matrix signature where
    overloadedMethod = matrixRotateZ

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


#endif

-- method Matrix::scale
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "m"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Matrix" }
--           , argCType = Just "graphene_matrix_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_matrix_t"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "factor_x"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "scaling factor on the X axis"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "factor_y"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "scaling factor on the Y axis"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "factor_z"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "scaling factor on the Z axis"
--                 , 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_matrix_scale" graphene_matrix_scale :: 
    Ptr Matrix ->                           -- m : TInterface (Name {namespace = "Graphene", name = "Matrix"})
    CFloat ->                               -- factor_x : TBasicType TFloat
    CFloat ->                               -- factor_y : TBasicType TFloat
    CFloat ->                               -- factor_z : TBasicType TFloat
    IO ()

-- | Adds a scaling transformation to /@m@/, using the three
-- given factors.
-- 
-- This is the equivalent of calling 'GI.Graphene.Structs.Matrix.matrixInitScale' and then
-- multiplying the matrix /@m@/ with the scale matrix.
-- 
-- /Since: 1.0/
matrixScale ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Matrix
    -- ^ /@m@/: a t'GI.Graphene.Structs.Matrix.Matrix'
    -> Float
    -- ^ /@factorX@/: scaling factor on the X axis
    -> Float
    -- ^ /@factorY@/: scaling factor on the Y axis
    -> Float
    -- ^ /@factorZ@/: scaling factor on the Z axis
    -> m ()
matrixScale :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Matrix -> Float -> Float -> Float -> m ()
matrixScale Matrix
m Float
factorX Float
factorY Float
factorZ = 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
    m' <- Matrix -> IO (Ptr Matrix)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Matrix
m
    let factorX' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
factorX
    let factorY' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
factorY
    let factorZ' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
factorZ
    graphene_matrix_scale m' factorX' factorY' factorZ'
    touchManagedPtr m
    return ()

#if defined(ENABLE_OVERLOADING)
data MatrixScaleMethodInfo
instance (signature ~ (Float -> Float -> Float -> m ()), MonadIO m) => O.OverloadedMethod MatrixScaleMethodInfo Matrix signature where
    overloadedMethod = matrixScale

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


#endif

-- method Matrix::skew_xy
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "m"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Matrix" }
--           , argCType = Just "graphene_matrix_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_matrix_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 "skew factor" , 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_matrix_skew_xy" graphene_matrix_skew_xy :: 
    Ptr Matrix ->                           -- m : TInterface (Name {namespace = "Graphene", name = "Matrix"})
    CFloat ->                               -- factor : TBasicType TFloat
    IO ()

-- | Adds a skew of /@factor@/ on the X and Y axis to the given matrix.
-- 
-- /Since: 1.0/
matrixSkewXy ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Matrix
    -- ^ /@m@/: a t'GI.Graphene.Structs.Matrix.Matrix'
    -> Float
    -- ^ /@factor@/: skew factor
    -> m ()
matrixSkewXy :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Matrix -> Float -> m ()
matrixSkewXy Matrix
m Float
factor = 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
    m' <- Matrix -> IO (Ptr Matrix)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Matrix
m
    let factor' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
factor
    graphene_matrix_skew_xy m' factor'
    touchManagedPtr m
    return ()

#if defined(ENABLE_OVERLOADING)
data MatrixSkewXyMethodInfo
instance (signature ~ (Float -> m ()), MonadIO m) => O.OverloadedMethod MatrixSkewXyMethodInfo Matrix signature where
    overloadedMethod = matrixSkewXy

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


#endif

-- method Matrix::skew_xz
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "m"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Matrix" }
--           , argCType = Just "graphene_matrix_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_matrix_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 "skew factor" , 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_matrix_skew_xz" graphene_matrix_skew_xz :: 
    Ptr Matrix ->                           -- m : TInterface (Name {namespace = "Graphene", name = "Matrix"})
    CFloat ->                               -- factor : TBasicType TFloat
    IO ()

-- | Adds a skew of /@factor@/ on the X and Z axis to the given matrix.
-- 
-- /Since: 1.0/
matrixSkewXz ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Matrix
    -- ^ /@m@/: a t'GI.Graphene.Structs.Matrix.Matrix'
    -> Float
    -- ^ /@factor@/: skew factor
    -> m ()
matrixSkewXz :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Matrix -> Float -> m ()
matrixSkewXz Matrix
m Float
factor = 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
    m' <- Matrix -> IO (Ptr Matrix)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Matrix
m
    let factor' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
factor
    graphene_matrix_skew_xz m' factor'
    touchManagedPtr m
    return ()

#if defined(ENABLE_OVERLOADING)
data MatrixSkewXzMethodInfo
instance (signature ~ (Float -> m ()), MonadIO m) => O.OverloadedMethod MatrixSkewXzMethodInfo Matrix signature where
    overloadedMethod = matrixSkewXz

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


#endif

-- method Matrix::skew_yz
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "m"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Matrix" }
--           , argCType = Just "graphene_matrix_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_matrix_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 "skew factor" , 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_matrix_skew_yz" graphene_matrix_skew_yz :: 
    Ptr Matrix ->                           -- m : TInterface (Name {namespace = "Graphene", name = "Matrix"})
    CFloat ->                               -- factor : TBasicType TFloat
    IO ()

-- | Adds a skew of /@factor@/ on the Y and Z axis to the given matrix.
-- 
-- /Since: 1.0/
matrixSkewYz ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Matrix
    -- ^ /@m@/: a t'GI.Graphene.Structs.Matrix.Matrix'
    -> Float
    -- ^ /@factor@/: skew factor
    -> m ()
matrixSkewYz :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Matrix -> Float -> m ()
matrixSkewYz Matrix
m Float
factor = 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
    m' <- Matrix -> IO (Ptr Matrix)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Matrix
m
    let factor' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
factor
    graphene_matrix_skew_yz m' factor'
    touchManagedPtr m
    return ()

#if defined(ENABLE_OVERLOADING)
data MatrixSkewYzMethodInfo
instance (signature ~ (Float -> m ()), MonadIO m) => O.OverloadedMethod MatrixSkewYzMethodInfo Matrix signature where
    overloadedMethod = matrixSkewYz

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


#endif

-- method Matrix::to_2d
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "m"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Matrix" }
--           , argCType = Just "const graphene_matrix_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_matrix_t"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "xx"
--           , argType = TBasicType TDouble
--           , argCType = Just "double*"
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "return location for the xx member"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "yx"
--           , argType = TBasicType TDouble
--           , argCType = Just "double*"
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "return location for the yx member"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "xy"
--           , argType = TBasicType TDouble
--           , argCType = Just "double*"
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "return location for the xy member"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "yy"
--           , argType = TBasicType TDouble
--           , argCType = Just "double*"
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "return location for the yy member"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "x_0"
--           , argType = TBasicType TDouble
--           , argCType = Just "double*"
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "return location for the x0 member"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "y_0"
--           , argType = TBasicType TDouble
--           , argCType = Just "double*"
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "return location for the y0 member"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "graphene_matrix_to_2d" graphene_matrix_to_2d :: 
    Ptr Matrix ->                           -- m : TInterface (Name {namespace = "Graphene", name = "Matrix"})
    Ptr CDouble ->                          -- xx : TBasicType TDouble
    Ptr CDouble ->                          -- yx : TBasicType TDouble
    Ptr CDouble ->                          -- xy : TBasicType TDouble
    Ptr CDouble ->                          -- yy : TBasicType TDouble
    Ptr CDouble ->                          -- x_0 : TBasicType TDouble
    Ptr CDouble ->                          -- y_0 : TBasicType TDouble
    IO CInt

-- | Converts a t'GI.Graphene.Structs.Matrix.Matrix' to an affine transformation
-- matrix, if the given matrix is compatible.
-- 
-- The returned values have the following layout:
-- 
-- 
-- === /plain code/
-- >
-- >  ⎛ xx  yx ⎞   ⎛  a   b  0 ⎞
-- >  ⎜ xy  yy ⎟ = ⎜  c   d  0 ⎟
-- >  ⎝ x0  y0 ⎠   ⎝ tx  ty  1 ⎠
-- 
-- 
-- This function can be used to convert between a t'GI.Graphene.Structs.Matrix.Matrix'
-- and an affine matrix type from other libraries.
-- 
-- /Since: 1.0/
matrixTo2d ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Matrix
    -- ^ /@m@/: a t'GI.Graphene.Structs.Matrix.Matrix'
    -> m ((Bool, Double, Double, Double, Double, Double, Double))
    -- ^ __Returns:__ @true@ if the matrix is compatible with an affine
    --   transformation matrix
matrixTo2d :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Matrix -> m (Bool, Double, Double, Double, Double, Double, Double)
matrixTo2d Matrix
m = IO (Bool, Double, Double, Double, Double, Double, Double)
-> m (Bool, Double, Double, Double, Double, Double, Double)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Double, Double, Double, Double, Double, Double)
 -> m (Bool, Double, Double, Double, Double, Double, Double))
-> IO (Bool, Double, Double, Double, Double, Double, Double)
-> m (Bool, Double, Double, Double, Double, Double, Double)
forall a b. (a -> b) -> a -> b
$ do
    m' <- Matrix -> IO (Ptr Matrix)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Matrix
m
    xx <- allocMem :: IO (Ptr CDouble)
    yx <- allocMem :: IO (Ptr CDouble)
    xy <- allocMem :: IO (Ptr CDouble)
    yy <- allocMem :: IO (Ptr CDouble)
    x0 <- allocMem :: IO (Ptr CDouble)
    y0 <- allocMem :: IO (Ptr CDouble)
    result <- graphene_matrix_to_2d m' xx yx xy yy x0 y0
    let result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    xx' <- peek xx
    let xx'' = CDouble -> Double
forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
xx'
    yx' <- peek yx
    let yx'' = CDouble -> Double
forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
yx'
    xy' <- peek xy
    let xy'' = CDouble -> Double
forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
xy'
    yy' <- peek yy
    let yy'' = CDouble -> Double
forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
yy'
    x0' <- peek x0
    let x0'' = CDouble -> Double
forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
x0'
    y0' <- peek y0
    let y0'' = CDouble -> Double
forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
y0'
    touchManagedPtr m
    freeMem xx
    freeMem yx
    freeMem xy
    freeMem yy
    freeMem x0
    freeMem y0
    return (result', xx'', yx'', xy'', yy'', x0'', y0'')

#if defined(ENABLE_OVERLOADING)
data MatrixTo2dMethodInfo
instance (signature ~ (m ((Bool, Double, Double, Double, Double, Double, Double))), MonadIO m) => O.OverloadedMethod MatrixTo2dMethodInfo Matrix signature where
    overloadedMethod = matrixTo2d

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


#endif

-- XXX Could not generate method Matrix::to_float
-- Not implemented: Don't know how to allocate "v" of type TCArray False 16 (-1) (TBasicType TFloat)
-- method Matrix::transform_bounds
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "m"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Matrix" }
--           , argCType = Just "const graphene_matrix_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_matrix_t"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "r"
--           , 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" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "res"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Rect" }
--           , argCType = Just "graphene_rect_t*"
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "return location for the bounds\n  of the transformed rectangle"
--                 , 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_matrix_transform_bounds" graphene_matrix_transform_bounds :: 
    Ptr Matrix ->                           -- m : TInterface (Name {namespace = "Graphene", name = "Matrix"})
    Ptr Graphene.Rect.Rect ->               -- r : TInterface (Name {namespace = "Graphene", name = "Rect"})
    Ptr Graphene.Rect.Rect ->               -- res : TInterface (Name {namespace = "Graphene", name = "Rect"})
    IO ()

-- | Transforms each corner of a t'GI.Graphene.Structs.Rect.Rect' using the given matrix /@m@/.
-- 
-- The result is the axis aligned bounding rectangle containing the coplanar
-- quadrilateral.
-- 
-- See also: 'GI.Graphene.Structs.Matrix.matrixTransformPoint'
-- 
-- /Since: 1.0/
matrixTransformBounds ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Matrix
    -- ^ /@m@/: a t'GI.Graphene.Structs.Matrix.Matrix'
    -> Graphene.Rect.Rect
    -- ^ /@r@/: a t'GI.Graphene.Structs.Rect.Rect'
    -> m (Graphene.Rect.Rect)
matrixTransformBounds :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Matrix -> Rect -> m Rect
matrixTransformBounds Matrix
m Rect
r = IO Rect -> m Rect
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Rect -> m Rect) -> IO Rect -> m Rect
forall a b. (a -> b) -> a -> b
$ do
    m' <- Matrix -> IO (Ptr Matrix)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Matrix
m
    r' <- unsafeManagedPtrGetPtr r
    res <- SP.callocBoxedBytes 16 :: IO (Ptr Graphene.Rect.Rect)
    graphene_matrix_transform_bounds m' r' res
    res' <- (wrapBoxed Graphene.Rect.Rect) res
    touchManagedPtr m
    touchManagedPtr r
    return res'

#if defined(ENABLE_OVERLOADING)
data MatrixTransformBoundsMethodInfo
instance (signature ~ (Graphene.Rect.Rect -> m (Graphene.Rect.Rect)), MonadIO m) => O.OverloadedMethod MatrixTransformBoundsMethodInfo Matrix signature where
    overloadedMethod = matrixTransformBounds

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


#endif

-- method Matrix::transform_box
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "m"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Matrix" }
--           , argCType = Just "const graphene_matrix_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_matrix_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 bounds\n  of the transformed 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_matrix_transform_box" graphene_matrix_transform_box :: 
    Ptr Matrix ->                           -- m : TInterface (Name {namespace = "Graphene", name = "Matrix"})
    Ptr Graphene.Box.Box ->                 -- b : TInterface (Name {namespace = "Graphene", name = "Box"})
    Ptr Graphene.Box.Box ->                 -- res : TInterface (Name {namespace = "Graphene", name = "Box"})
    IO ()

-- | Transforms the vertices of a t'GI.Graphene.Structs.Box.Box' using the given matrix /@m@/.
-- 
-- The result is the axis aligned bounding box containing the transformed
-- vertices.
-- 
-- /Since: 1.2/
matrixTransformBox ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Matrix
    -- ^ /@m@/: a t'GI.Graphene.Structs.Matrix.Matrix'
    -> Graphene.Box.Box
    -- ^ /@b@/: a t'GI.Graphene.Structs.Box.Box'
    -> m (Graphene.Box.Box)
matrixTransformBox :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Matrix -> Box -> m Box
matrixTransformBox Matrix
m 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
    m' <- Matrix -> IO (Ptr Matrix)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Matrix
m
    b' <- unsafeManagedPtrGetPtr b
    res <- SP.callocBoxedBytes 32 :: IO (Ptr Graphene.Box.Box)
    graphene_matrix_transform_box m' b' res
    res' <- (wrapBoxed Graphene.Box.Box) res
    touchManagedPtr m
    touchManagedPtr b
    return res'

#if defined(ENABLE_OVERLOADING)
data MatrixTransformBoxMethodInfo
instance (signature ~ (Graphene.Box.Box -> m (Graphene.Box.Box)), MonadIO m) => O.OverloadedMethod MatrixTransformBoxMethodInfo Matrix signature where
    overloadedMethod = matrixTransformBox

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


#endif

-- method Matrix::transform_point
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "m"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Matrix" }
--           , argCType = Just "const graphene_matrix_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_matrix_t"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "p"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Point" }
--           , argCType = Just "const graphene_point_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_point_t"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "res"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Point" }
--           , argCType = Just "graphene_point_t*"
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "return location for the\n  transformed #graphene_point_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_matrix_transform_point" graphene_matrix_transform_point :: 
    Ptr Matrix ->                           -- m : TInterface (Name {namespace = "Graphene", name = "Matrix"})
    Ptr Graphene.Point.Point ->             -- p : TInterface (Name {namespace = "Graphene", name = "Point"})
    Ptr Graphene.Point.Point ->             -- res : TInterface (Name {namespace = "Graphene", name = "Point"})
    IO ()

-- | Transforms the given t'GI.Graphene.Structs.Point.Point' using the matrix /@m@/.
-- 
-- Unlike 'GI.Graphene.Structs.Matrix.matrixTransformVec3', this function will take into
-- account the fourth row vector of the t'GI.Graphene.Structs.Matrix.Matrix' when computing
-- the dot product of each row vector of the matrix.
-- 
-- See also: @/graphene_simd4x4f_point3_mul()/@
-- 
-- /Since: 1.0/
matrixTransformPoint ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Matrix
    -- ^ /@m@/: a t'GI.Graphene.Structs.Matrix.Matrix'
    -> Graphene.Point.Point
    -- ^ /@p@/: a t'GI.Graphene.Structs.Point.Point'
    -> m (Graphene.Point.Point)
matrixTransformPoint :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Matrix -> Point -> m Point
matrixTransformPoint Matrix
m Point
p = IO Point -> m Point
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Point -> m Point) -> IO Point -> m Point
forall a b. (a -> b) -> a -> b
$ do
    m' <- Matrix -> IO (Ptr Matrix)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Matrix
m
    p' <- unsafeManagedPtrGetPtr p
    res <- SP.callocBoxedBytes 8 :: IO (Ptr Graphene.Point.Point)
    graphene_matrix_transform_point m' p' res
    res' <- (wrapBoxed Graphene.Point.Point) res
    touchManagedPtr m
    touchManagedPtr p
    return res'

#if defined(ENABLE_OVERLOADING)
data MatrixTransformPointMethodInfo
instance (signature ~ (Graphene.Point.Point -> m (Graphene.Point.Point)), MonadIO m) => O.OverloadedMethod MatrixTransformPointMethodInfo Matrix signature where
    overloadedMethod = matrixTransformPoint

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


#endif

-- method Matrix::transform_point3d
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "m"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Matrix" }
--           , argCType = Just "const graphene_matrix_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_matrix_t"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "p"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Point3D" }
--           , argCType = Just "const graphene_point3d_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_point3d_t"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , 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 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_matrix_transform_point3d" graphene_matrix_transform_point3d :: 
    Ptr Matrix ->                           -- m : TInterface (Name {namespace = "Graphene", name = "Matrix"})
    Ptr Graphene.Point3D.Point3D ->         -- p : TInterface (Name {namespace = "Graphene", name = "Point3D"})
    Ptr Graphene.Point3D.Point3D ->         -- res : TInterface (Name {namespace = "Graphene", name = "Point3D"})
    IO ()

-- | Transforms the given t'GI.Graphene.Structs.Point3D.Point3D' using the matrix /@m@/.
-- 
-- Unlike 'GI.Graphene.Structs.Matrix.matrixTransformVec3', this function will take into
-- account the fourth row vector of the t'GI.Graphene.Structs.Matrix.Matrix' when computing
-- the dot product of each row vector of the matrix.
-- 
-- See also: @/graphene_simd4x4f_point3_mul()/@
-- 
-- /Since: 1.2/
matrixTransformPoint3d ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Matrix
    -- ^ /@m@/: a t'GI.Graphene.Structs.Matrix.Matrix'
    -> Graphene.Point3D.Point3D
    -- ^ /@p@/: a t'GI.Graphene.Structs.Point3D.Point3D'
    -> m (Graphene.Point3D.Point3D)
matrixTransformPoint3d :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Matrix -> Point3D -> m Point3D
matrixTransformPoint3d Matrix
m 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
    m' <- Matrix -> IO (Ptr Matrix)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Matrix
m
    p' <- unsafeManagedPtrGetPtr p
    res <- SP.callocBoxedBytes 12 :: IO (Ptr Graphene.Point3D.Point3D)
    graphene_matrix_transform_point3d m' p' res
    res' <- (wrapBoxed Graphene.Point3D.Point3D) res
    touchManagedPtr m
    touchManagedPtr p
    return res'

#if defined(ENABLE_OVERLOADING)
data MatrixTransformPoint3dMethodInfo
instance (signature ~ (Graphene.Point3D.Point3D -> m (Graphene.Point3D.Point3D)), MonadIO m) => O.OverloadedMethod MatrixTransformPoint3dMethodInfo Matrix signature where
    overloadedMethod = matrixTransformPoint3d

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


#endif

-- method Matrix::transform_ray
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "m"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Matrix" }
--           , argCType = Just "const graphene_matrix_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_matrix_t"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "r"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Ray" }
--           , argCType = Just "const graphene_ray_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_ray_t" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "res"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Ray" }
--           , argCType = Just "graphene_ray_t*"
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "return location for the\n  transformed ray"
--                 , 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_matrix_transform_ray" graphene_matrix_transform_ray :: 
    Ptr Matrix ->                           -- m : TInterface (Name {namespace = "Graphene", name = "Matrix"})
    Ptr Graphene.Ray.Ray ->                 -- r : TInterface (Name {namespace = "Graphene", name = "Ray"})
    Ptr Graphene.Ray.Ray ->                 -- res : TInterface (Name {namespace = "Graphene", name = "Ray"})
    IO ()

-- | Transform a t'GI.Graphene.Structs.Ray.Ray' using the given matrix /@m@/.
-- 
-- /Since: 1.4/
matrixTransformRay ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Matrix
    -- ^ /@m@/: a t'GI.Graphene.Structs.Matrix.Matrix'
    -> Graphene.Ray.Ray
    -- ^ /@r@/: a t'GI.Graphene.Structs.Ray.Ray'
    -> m (Graphene.Ray.Ray)
matrixTransformRay :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Matrix -> Ray -> m Ray
matrixTransformRay Matrix
m Ray
r = IO Ray -> m Ray
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Ray -> m Ray) -> IO Ray -> m Ray
forall a b. (a -> b) -> a -> b
$ do
    m' <- Matrix -> IO (Ptr Matrix)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Matrix
m
    r' <- unsafeManagedPtrGetPtr r
    res <- SP.callocBoxedBytes 32 :: IO (Ptr Graphene.Ray.Ray)
    graphene_matrix_transform_ray m' r' res
    res' <- (wrapBoxed Graphene.Ray.Ray) res
    touchManagedPtr m
    touchManagedPtr r
    return res'

#if defined(ENABLE_OVERLOADING)
data MatrixTransformRayMethodInfo
instance (signature ~ (Graphene.Ray.Ray -> m (Graphene.Ray.Ray)), MonadIO m) => O.OverloadedMethod MatrixTransformRayMethodInfo Matrix signature where
    overloadedMethod = matrixTransformRay

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


#endif

-- method Matrix::transform_rect
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "m"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Matrix" }
--           , argCType = Just "const graphene_matrix_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_matrix_t"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "r"
--           , 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" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "res"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Quad" }
--           , argCType = Just "graphene_quad_t*"
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "return location for the\n  transformed quad"
--                 , 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_matrix_transform_rect" graphene_matrix_transform_rect :: 
    Ptr Matrix ->                           -- m : TInterface (Name {namespace = "Graphene", name = "Matrix"})
    Ptr Graphene.Rect.Rect ->               -- r : TInterface (Name {namespace = "Graphene", name = "Rect"})
    Ptr Graphene.Quad.Quad ->               -- res : TInterface (Name {namespace = "Graphene", name = "Quad"})
    IO ()

-- | Transforms each corner of a t'GI.Graphene.Structs.Rect.Rect' using the given matrix /@m@/.
-- 
-- The result is a coplanar quadrilateral.
-- 
-- See also: 'GI.Graphene.Structs.Matrix.matrixTransformPoint'
-- 
-- /Since: 1.0/
matrixTransformRect ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Matrix
    -- ^ /@m@/: a t'GI.Graphene.Structs.Matrix.Matrix'
    -> Graphene.Rect.Rect
    -- ^ /@r@/: a t'GI.Graphene.Structs.Rect.Rect'
    -> m (Graphene.Quad.Quad)
matrixTransformRect :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Matrix -> Rect -> m Quad
matrixTransformRect Matrix
m Rect
r = IO Quad -> m Quad
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Quad -> m Quad) -> IO Quad -> m Quad
forall a b. (a -> b) -> a -> b
$ do
    m' <- Matrix -> IO (Ptr Matrix)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Matrix
m
    r' <- unsafeManagedPtrGetPtr r
    res <- SP.callocBoxedBytes 32 :: IO (Ptr Graphene.Quad.Quad)
    graphene_matrix_transform_rect m' r' res
    res' <- (wrapBoxed Graphene.Quad.Quad) res
    touchManagedPtr m
    touchManagedPtr r
    return res'

#if defined(ENABLE_OVERLOADING)
data MatrixTransformRectMethodInfo
instance (signature ~ (Graphene.Rect.Rect -> m (Graphene.Quad.Quad)), MonadIO m) => O.OverloadedMethod MatrixTransformRectMethodInfo Matrix signature where
    overloadedMethod = matrixTransformRect

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


#endif

-- method Matrix::transform_sphere
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "m"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Matrix" }
--           , argCType = Just "const graphene_matrix_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_matrix_t"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "s"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Sphere" }
--           , argCType = Just "const graphene_sphere_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_sphere_t"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "res"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Sphere" }
--           , argCType = Just "graphene_sphere_t*"
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "return location for the bounds\n  of the transformed 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_matrix_transform_sphere" graphene_matrix_transform_sphere :: 
    Ptr Matrix ->                           -- m : TInterface (Name {namespace = "Graphene", name = "Matrix"})
    Ptr Graphene.Sphere.Sphere ->           -- s : TInterface (Name {namespace = "Graphene", name = "Sphere"})
    Ptr Graphene.Sphere.Sphere ->           -- res : TInterface (Name {namespace = "Graphene", name = "Sphere"})
    IO ()

-- | Transforms a t'GI.Graphene.Structs.Sphere.Sphere' using the given matrix /@m@/. The
-- result is the bounding sphere containing the transformed sphere.
-- 
-- /Since: 1.2/
matrixTransformSphere ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Matrix
    -- ^ /@m@/: a t'GI.Graphene.Structs.Matrix.Matrix'
    -> Graphene.Sphere.Sphere
    -- ^ /@s@/: a t'GI.Graphene.Structs.Sphere.Sphere'
    -> m (Graphene.Sphere.Sphere)
matrixTransformSphere :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Matrix -> Sphere -> m Sphere
matrixTransformSphere Matrix
m Sphere
s = 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
    m' <- Matrix -> IO (Ptr Matrix)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Matrix
m
    s' <- unsafeManagedPtrGetPtr s
    res <- SP.callocBoxedBytes 20 :: IO (Ptr Graphene.Sphere.Sphere)
    graphene_matrix_transform_sphere m' s' res
    res' <- (wrapBoxed Graphene.Sphere.Sphere) res
    touchManagedPtr m
    touchManagedPtr s
    return res'

#if defined(ENABLE_OVERLOADING)
data MatrixTransformSphereMethodInfo
instance (signature ~ (Graphene.Sphere.Sphere -> m (Graphene.Sphere.Sphere)), MonadIO m) => O.OverloadedMethod MatrixTransformSphereMethodInfo Matrix signature where
    overloadedMethod = matrixTransformSphere

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


#endif

-- method Matrix::transform_vec3
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "m"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Matrix" }
--           , argCType = Just "const graphene_matrix_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_matrix_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
--           }
--       , Arg
--           { argCName = "res"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Vec3" }
--           , argCType = Just "graphene_vec3_t*"
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "return location for 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_matrix_transform_vec3" graphene_matrix_transform_vec3 :: 
    Ptr Matrix ->                           -- m : TInterface (Name {namespace = "Graphene", name = "Matrix"})
    Ptr Graphene.Vec3.Vec3 ->               -- v : TInterface (Name {namespace = "Graphene", name = "Vec3"})
    Ptr Graphene.Vec3.Vec3 ->               -- res : TInterface (Name {namespace = "Graphene", name = "Vec3"})
    IO ()

-- | Transforms the given t'GI.Graphene.Structs.Vec3.Vec3' using the matrix /@m@/.
-- 
-- This function will multiply the X, Y, and Z row vectors of the matrix /@m@/
-- with the corresponding components of the vector /@v@/. The W row vector will
-- be ignored.
-- 
-- See also: @/graphene_simd4x4f_vec3_mul()/@
-- 
-- /Since: 1.0/
matrixTransformVec3 ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Matrix
    -- ^ /@m@/: a t'GI.Graphene.Structs.Matrix.Matrix'
    -> Graphene.Vec3.Vec3
    -- ^ /@v@/: a t'GI.Graphene.Structs.Vec3.Vec3'
    -> m (Graphene.Vec3.Vec3)
matrixTransformVec3 :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Matrix -> Vec3 -> m Vec3
matrixTransformVec3 Matrix
m Vec3
v = 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
    m' <- Matrix -> IO (Ptr Matrix)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Matrix
m
    v' <- unsafeManagedPtrGetPtr v
    res <- SP.callocBoxedBytes 16 :: IO (Ptr Graphene.Vec3.Vec3)
    graphene_matrix_transform_vec3 m' v' res
    res' <- (wrapBoxed Graphene.Vec3.Vec3) res
    touchManagedPtr m
    touchManagedPtr v
    return res'

#if defined(ENABLE_OVERLOADING)
data MatrixTransformVec3MethodInfo
instance (signature ~ (Graphene.Vec3.Vec3 -> m (Graphene.Vec3.Vec3)), MonadIO m) => O.OverloadedMethod MatrixTransformVec3MethodInfo Matrix signature where
    overloadedMethod = matrixTransformVec3

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


#endif

-- method Matrix::transform_vec4
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "m"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Matrix" }
--           , argCType = Just "const graphene_matrix_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_matrix_t"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "v"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Vec4" }
--           , argCType = Just "const graphene_vec4_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_vec4_t" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "res"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Vec4" }
--           , argCType = Just "graphene_vec4_t*"
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "return location for a #graphene_vec4_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_matrix_transform_vec4" graphene_matrix_transform_vec4 :: 
    Ptr Matrix ->                           -- m : TInterface (Name {namespace = "Graphene", name = "Matrix"})
    Ptr Graphene.Vec4.Vec4 ->               -- v : TInterface (Name {namespace = "Graphene", name = "Vec4"})
    Ptr Graphene.Vec4.Vec4 ->               -- res : TInterface (Name {namespace = "Graphene", name = "Vec4"})
    IO ()

-- | Transforms the given t'GI.Graphene.Structs.Vec4.Vec4' using the matrix /@m@/.
-- 
-- See also: @/graphene_simd4x4f_vec4_mul()/@
-- 
-- /Since: 1.0/
matrixTransformVec4 ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Matrix
    -- ^ /@m@/: a t'GI.Graphene.Structs.Matrix.Matrix'
    -> Graphene.Vec4.Vec4
    -- ^ /@v@/: a t'GI.Graphene.Structs.Vec4.Vec4'
    -> m (Graphene.Vec4.Vec4)
matrixTransformVec4 :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Matrix -> Vec4 -> m Vec4
matrixTransformVec4 Matrix
m Vec4
v = IO Vec4 -> m Vec4
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Vec4 -> m Vec4) -> IO Vec4 -> m Vec4
forall a b. (a -> b) -> a -> b
$ do
    m' <- Matrix -> IO (Ptr Matrix)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Matrix
m
    v' <- unsafeManagedPtrGetPtr v
    res <- SP.callocBoxedBytes 16 :: IO (Ptr Graphene.Vec4.Vec4)
    graphene_matrix_transform_vec4 m' v' res
    res' <- (wrapBoxed Graphene.Vec4.Vec4) res
    touchManagedPtr m
    touchManagedPtr v
    return res'

#if defined(ENABLE_OVERLOADING)
data MatrixTransformVec4MethodInfo
instance (signature ~ (Graphene.Vec4.Vec4 -> m (Graphene.Vec4.Vec4)), MonadIO m) => O.OverloadedMethod MatrixTransformVec4MethodInfo Matrix signature where
    overloadedMethod = matrixTransformVec4

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


#endif

-- method Matrix::translate
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "m"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Matrix" }
--           , argCType = Just "graphene_matrix_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_matrix_t"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "pos"
--           , 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: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "graphene_matrix_translate" graphene_matrix_translate :: 
    Ptr Matrix ->                           -- m : TInterface (Name {namespace = "Graphene", name = "Matrix"})
    Ptr Graphene.Point3D.Point3D ->         -- pos : TInterface (Name {namespace = "Graphene", name = "Point3D"})
    IO ()

-- | Adds a translation transformation to /@m@/ using the coordinates
-- of the given t'GI.Graphene.Structs.Point3D.Point3D'.
-- 
-- This is the equivalent of calling 'GI.Graphene.Structs.Matrix.matrixInitTranslate' and
-- then multiplying /@m@/ with the translation matrix.
-- 
-- /Since: 1.0/
matrixTranslate ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Matrix
    -- ^ /@m@/: a t'GI.Graphene.Structs.Matrix.Matrix'
    -> Graphene.Point3D.Point3D
    -- ^ /@pos@/: a t'GI.Graphene.Structs.Point3D.Point3D'
    -> m ()
matrixTranslate :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Matrix -> Point3D -> m ()
matrixTranslate Matrix
m Point3D
pos = 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
    m' <- Matrix -> IO (Ptr Matrix)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Matrix
m
    pos' <- unsafeManagedPtrGetPtr pos
    graphene_matrix_translate m' pos'
    touchManagedPtr m
    touchManagedPtr pos
    return ()

#if defined(ENABLE_OVERLOADING)
data MatrixTranslateMethodInfo
instance (signature ~ (Graphene.Point3D.Point3D -> m ()), MonadIO m) => O.OverloadedMethod MatrixTranslateMethodInfo Matrix signature where
    overloadedMethod = matrixTranslate

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


#endif

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

-- | Transposes the given matrix.
-- 
-- /Since: 1.0/
matrixTranspose ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Matrix
    -- ^ /@m@/: a t'GI.Graphene.Structs.Matrix.Matrix'
    -> m (Matrix)
matrixTranspose :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Matrix -> m Matrix
matrixTranspose Matrix
m = IO Matrix -> m Matrix
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Matrix -> m Matrix) -> IO Matrix -> m Matrix
forall a b. (a -> b) -> a -> b
$ do
    m' <- Matrix -> IO (Ptr Matrix)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Matrix
m
    res <- SP.callocBoxedBytes 64 :: IO (Ptr Matrix)
    graphene_matrix_transpose m' res
    res' <- (wrapBoxed Matrix) res
    touchManagedPtr m
    return res'

#if defined(ENABLE_OVERLOADING)
data MatrixTransposeMethodInfo
instance (signature ~ (m (Matrix)), MonadIO m) => O.OverloadedMethod MatrixTransposeMethodInfo Matrix signature where
    overloadedMethod = matrixTranspose

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


#endif

-- method Matrix::unproject_point3d
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "projection"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Matrix" }
--           , argCType = Just "const graphene_matrix_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "a #graphene_matrix_t for the projection matrix"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "modelview"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Matrix" }
--           , argCType = Just "const graphene_matrix_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "a #graphene_matrix_t for the modelview matrix; this is\n  the inverse of the modelview used when projecting the point"
--                 , 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 "a #graphene_point3d_t with the coordinates of the point"
--                 , 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 unprojected\n  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_matrix_unproject_point3d" graphene_matrix_unproject_point3d :: 
    Ptr Matrix ->                           -- projection : TInterface (Name {namespace = "Graphene", name = "Matrix"})
    Ptr Matrix ->                           -- modelview : TInterface (Name {namespace = "Graphene", name = "Matrix"})
    Ptr Graphene.Point3D.Point3D ->         -- point : TInterface (Name {namespace = "Graphene", name = "Point3D"})
    Ptr Graphene.Point3D.Point3D ->         -- res : TInterface (Name {namespace = "Graphene", name = "Point3D"})
    IO ()

-- | Unprojects the given /@point@/ using the /@projection@/ matrix and
-- a /@modelview@/ matrix.
-- 
-- /Since: 1.2/
matrixUnprojectPoint3d ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Matrix
    -- ^ /@projection@/: a t'GI.Graphene.Structs.Matrix.Matrix' for the projection matrix
    -> Matrix
    -- ^ /@modelview@/: a t'GI.Graphene.Structs.Matrix.Matrix' for the modelview matrix; this is
    --   the inverse of the modelview used when projecting the point
    -> Graphene.Point3D.Point3D
    -- ^ /@point@/: a t'GI.Graphene.Structs.Point3D.Point3D' with the coordinates of the point
    -> m (Graphene.Point3D.Point3D)
matrixUnprojectPoint3d :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Matrix -> Matrix -> Point3D -> m Point3D
matrixUnprojectPoint3d Matrix
projection Matrix
modelview Point3D
point = 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
    projection' <- Matrix -> IO (Ptr Matrix)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Matrix
projection
    modelview' <- unsafeManagedPtrGetPtr modelview
    point' <- unsafeManagedPtrGetPtr point
    res <- SP.callocBoxedBytes 12 :: IO (Ptr Graphene.Point3D.Point3D)
    graphene_matrix_unproject_point3d projection' modelview' point' res
    res' <- (wrapBoxed Graphene.Point3D.Point3D) res
    touchManagedPtr projection
    touchManagedPtr modelview
    touchManagedPtr point
    return res'

#if defined(ENABLE_OVERLOADING)
data MatrixUnprojectPoint3dMethodInfo
instance (signature ~ (Matrix -> Graphene.Point3D.Point3D -> m (Graphene.Point3D.Point3D)), MonadIO m) => O.OverloadedMethod MatrixUnprojectPoint3dMethodInfo Matrix signature where
    overloadedMethod = matrixUnprojectPoint3d

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


#endif

-- method Matrix::untransform_bounds
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "m"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Matrix" }
--           , argCType = Just "const graphene_matrix_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_matrix_t"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "r"
--           , 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" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "bounds"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Rect" }
--           , argCType = Just "const graphene_rect_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the bounds of the transformation"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "res"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Rect" }
--           , argCType = Just "graphene_rect_t*"
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "return location for the\n  untransformed rectangle"
--                 , 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_matrix_untransform_bounds" graphene_matrix_untransform_bounds :: 
    Ptr Matrix ->                           -- m : TInterface (Name {namespace = "Graphene", name = "Matrix"})
    Ptr Graphene.Rect.Rect ->               -- r : TInterface (Name {namespace = "Graphene", name = "Rect"})
    Ptr Graphene.Rect.Rect ->               -- bounds : TInterface (Name {namespace = "Graphene", name = "Rect"})
    Ptr Graphene.Rect.Rect ->               -- res : TInterface (Name {namespace = "Graphene", name = "Rect"})
    IO ()

-- | Undoes the transformation on the corners of a t'GI.Graphene.Structs.Rect.Rect' using the
-- given matrix, within the given axis aligned rectangular /@bounds@/.
-- 
-- /Since: 1.0/
matrixUntransformBounds ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Matrix
    -- ^ /@m@/: a t'GI.Graphene.Structs.Matrix.Matrix'
    -> Graphene.Rect.Rect
    -- ^ /@r@/: a t'GI.Graphene.Structs.Rect.Rect'
    -> Graphene.Rect.Rect
    -- ^ /@bounds@/: the bounds of the transformation
    -> m (Graphene.Rect.Rect)
matrixUntransformBounds :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Matrix -> Rect -> Rect -> m Rect
matrixUntransformBounds Matrix
m Rect
r Rect
bounds = IO Rect -> m Rect
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Rect -> m Rect) -> IO Rect -> m Rect
forall a b. (a -> b) -> a -> b
$ do
    m' <- Matrix -> IO (Ptr Matrix)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Matrix
m
    r' <- unsafeManagedPtrGetPtr r
    bounds' <- unsafeManagedPtrGetPtr bounds
    res <- SP.callocBoxedBytes 16 :: IO (Ptr Graphene.Rect.Rect)
    graphene_matrix_untransform_bounds m' r' bounds' res
    res' <- (wrapBoxed Graphene.Rect.Rect) res
    touchManagedPtr m
    touchManagedPtr r
    touchManagedPtr bounds
    return res'

#if defined(ENABLE_OVERLOADING)
data MatrixUntransformBoundsMethodInfo
instance (signature ~ (Graphene.Rect.Rect -> Graphene.Rect.Rect -> m (Graphene.Rect.Rect)), MonadIO m) => O.OverloadedMethod MatrixUntransformBoundsMethodInfo Matrix signature where
    overloadedMethod = matrixUntransformBounds

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


#endif

-- method Matrix::untransform_point
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "m"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Matrix" }
--           , argCType = Just "const graphene_matrix_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_matrix_t"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "p"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Point" }
--           , argCType = Just "const graphene_point_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #graphene_point_t"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "bounds"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Rect" }
--           , argCType = Just "const graphene_rect_t*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the bounds of the transformation"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "res"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Point" }
--           , argCType = Just "graphene_point_t*"
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "return location for the\n  untransformed point"
--                 , 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_matrix_untransform_point" graphene_matrix_untransform_point :: 
    Ptr Matrix ->                           -- m : TInterface (Name {namespace = "Graphene", name = "Matrix"})
    Ptr Graphene.Point.Point ->             -- p : TInterface (Name {namespace = "Graphene", name = "Point"})
    Ptr Graphene.Rect.Rect ->               -- bounds : TInterface (Name {namespace = "Graphene", name = "Rect"})
    Ptr Graphene.Point.Point ->             -- res : TInterface (Name {namespace = "Graphene", name = "Point"})
    IO CInt

-- | Undoes the transformation of a t'GI.Graphene.Structs.Point.Point' using the
-- given matrix, within the given axis aligned rectangular /@bounds@/.
-- 
-- /Since: 1.0/
matrixUntransformPoint ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Matrix
    -- ^ /@m@/: a t'GI.Graphene.Structs.Matrix.Matrix'
    -> Graphene.Point.Point
    -- ^ /@p@/: a t'GI.Graphene.Structs.Point.Point'
    -> Graphene.Rect.Rect
    -- ^ /@bounds@/: the bounds of the transformation
    -> m ((Bool, Graphene.Point.Point))
    -- ^ __Returns:__ @true@ if the point was successfully untransformed
matrixUntransformPoint :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Matrix -> Point -> Rect -> m (Bool, Point)
matrixUntransformPoint Matrix
m Point
p Rect
bounds = IO (Bool, Point) -> m (Bool, Point)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Point) -> m (Bool, Point))
-> IO (Bool, Point) -> m (Bool, Point)
forall a b. (a -> b) -> a -> b
$ do
    m' <- Matrix -> IO (Ptr Matrix)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Matrix
m
    p' <- unsafeManagedPtrGetPtr p
    bounds' <- unsafeManagedPtrGetPtr bounds
    res <- SP.callocBoxedBytes 8 :: IO (Ptr Graphene.Point.Point)
    result <- graphene_matrix_untransform_point m' p' bounds' res
    let result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    res' <- (wrapBoxed Graphene.Point.Point) res
    touchManagedPtr m
    touchManagedPtr p
    touchManagedPtr bounds
    return (result', res')

#if defined(ENABLE_OVERLOADING)
data MatrixUntransformPointMethodInfo
instance (signature ~ (Graphene.Point.Point -> Graphene.Rect.Rect -> m ((Bool, Graphene.Point.Point))), MonadIO m) => O.OverloadedMethod MatrixUntransformPointMethodInfo Matrix signature where
    overloadedMethod = matrixUntransformPoint

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


#endif

#if defined(ENABLE_OVERLOADING)
type family ResolveMatrixMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
    ResolveMatrixMethod "decompose" o = MatrixDecomposeMethodInfo
    ResolveMatrixMethod "determinant" o = MatrixDeterminantMethodInfo
    ResolveMatrixMethod "equal" o = MatrixEqualMethodInfo
    ResolveMatrixMethod "equalFast" o = MatrixEqualFastMethodInfo
    ResolveMatrixMethod "free" o = MatrixFreeMethodInfo
    ResolveMatrixMethod "initFrom2d" o = MatrixInitFrom2dMethodInfo
    ResolveMatrixMethod "initFromFloat" o = MatrixInitFromFloatMethodInfo
    ResolveMatrixMethod "initFromMatrix" o = MatrixInitFromMatrixMethodInfo
    ResolveMatrixMethod "initFromVec4" o = MatrixInitFromVec4MethodInfo
    ResolveMatrixMethod "initFrustum" o = MatrixInitFrustumMethodInfo
    ResolveMatrixMethod "initIdentity" o = MatrixInitIdentityMethodInfo
    ResolveMatrixMethod "initLookAt" o = MatrixInitLookAtMethodInfo
    ResolveMatrixMethod "initOrtho" o = MatrixInitOrthoMethodInfo
    ResolveMatrixMethod "initPerspective" o = MatrixInitPerspectiveMethodInfo
    ResolveMatrixMethod "initRotate" o = MatrixInitRotateMethodInfo
    ResolveMatrixMethod "initScale" o = MatrixInitScaleMethodInfo
    ResolveMatrixMethod "initSkew" o = MatrixInitSkewMethodInfo
    ResolveMatrixMethod "initTranslate" o = MatrixInitTranslateMethodInfo
    ResolveMatrixMethod "interpolate" o = MatrixInterpolateMethodInfo
    ResolveMatrixMethod "inverse" o = MatrixInverseMethodInfo
    ResolveMatrixMethod "is2d" o = MatrixIs2dMethodInfo
    ResolveMatrixMethod "isBackfaceVisible" o = MatrixIsBackfaceVisibleMethodInfo
    ResolveMatrixMethod "isIdentity" o = MatrixIsIdentityMethodInfo
    ResolveMatrixMethod "isSingular" o = MatrixIsSingularMethodInfo
    ResolveMatrixMethod "multiply" o = MatrixMultiplyMethodInfo
    ResolveMatrixMethod "near" o = MatrixNearMethodInfo
    ResolveMatrixMethod "normalize" o = MatrixNormalizeMethodInfo
    ResolveMatrixMethod "perspective" o = MatrixPerspectiveMethodInfo
    ResolveMatrixMethod "print" o = MatrixPrintMethodInfo
    ResolveMatrixMethod "projectPoint" o = MatrixProjectPointMethodInfo
    ResolveMatrixMethod "projectRect" o = MatrixProjectRectMethodInfo
    ResolveMatrixMethod "projectRectBounds" o = MatrixProjectRectBoundsMethodInfo
    ResolveMatrixMethod "rotate" o = MatrixRotateMethodInfo
    ResolveMatrixMethod "rotateEuler" o = MatrixRotateEulerMethodInfo
    ResolveMatrixMethod "rotateQuaternion" o = MatrixRotateQuaternionMethodInfo
    ResolveMatrixMethod "rotateX" o = MatrixRotateXMethodInfo
    ResolveMatrixMethod "rotateY" o = MatrixRotateYMethodInfo
    ResolveMatrixMethod "rotateZ" o = MatrixRotateZMethodInfo
    ResolveMatrixMethod "scale" o = MatrixScaleMethodInfo
    ResolveMatrixMethod "skewXy" o = MatrixSkewXyMethodInfo
    ResolveMatrixMethod "skewXz" o = MatrixSkewXzMethodInfo
    ResolveMatrixMethod "skewYz" o = MatrixSkewYzMethodInfo
    ResolveMatrixMethod "to2d" o = MatrixTo2dMethodInfo
    ResolveMatrixMethod "transformBounds" o = MatrixTransformBoundsMethodInfo
    ResolveMatrixMethod "transformBox" o = MatrixTransformBoxMethodInfo
    ResolveMatrixMethod "transformPoint" o = MatrixTransformPointMethodInfo
    ResolveMatrixMethod "transformPoint3d" o = MatrixTransformPoint3dMethodInfo
    ResolveMatrixMethod "transformRay" o = MatrixTransformRayMethodInfo
    ResolveMatrixMethod "transformRect" o = MatrixTransformRectMethodInfo
    ResolveMatrixMethod "transformSphere" o = MatrixTransformSphereMethodInfo
    ResolveMatrixMethod "transformVec3" o = MatrixTransformVec3MethodInfo
    ResolveMatrixMethod "transformVec4" o = MatrixTransformVec4MethodInfo
    ResolveMatrixMethod "translate" o = MatrixTranslateMethodInfo
    ResolveMatrixMethod "transpose" o = MatrixTransposeMethodInfo
    ResolveMatrixMethod "unprojectPoint3d" o = MatrixUnprojectPoint3dMethodInfo
    ResolveMatrixMethod "untransformBounds" o = MatrixUntransformBoundsMethodInfo
    ResolveMatrixMethod "untransformPoint" o = MatrixUntransformPointMethodInfo
    ResolveMatrixMethod "getRow" o = MatrixGetRowMethodInfo
    ResolveMatrixMethod "getValue" o = MatrixGetValueMethodInfo
    ResolveMatrixMethod "getXScale" o = MatrixGetXScaleMethodInfo
    ResolveMatrixMethod "getXTranslation" o = MatrixGetXTranslationMethodInfo
    ResolveMatrixMethod "getYScale" o = MatrixGetYScaleMethodInfo
    ResolveMatrixMethod "getYTranslation" o = MatrixGetYTranslationMethodInfo
    ResolveMatrixMethod "getZScale" o = MatrixGetZScaleMethodInfo
    ResolveMatrixMethod "getZTranslation" o = MatrixGetZTranslationMethodInfo
    ResolveMatrixMethod l o = O.MethodResolutionFailed l o

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

#endif

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

#endif