-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/

-- | Graphene bindings
--   
--   Bindings for Graphene, autogenerated by haskell-gi.
@package gi-graphene
@version 1.0.8

-- | Build time configuration used during code generation.
module GI.Graphene.Config

-- | Overrides used when generating these bindings.
overrides :: Text

-- | Modules in this package
modules :: [Text]

module GI.Graphene.Constants

-- | Evaluates to the number of components of a Vec4.
--   
--   This symbol is useful when declaring a C array of floating point
--   values to be used with vec4InitFromFloat and
--   vec4ToFloat, e.g.
--   
--   
--   float v[GRAPHENE_VEC4_LEN];
--   
--   // vec is defined elsewhere
--   graphene_vec4_to_float (&vec, v);
--   
--   for (int i = 0; i < GRAPHENE_VEC4_LEN; i++)
--     fprintf (stdout, "component %d: %g\n", i, v[i]);
--   
--   
--   Since: 1.0
pattern VEC4_LEN :: Int32

-- | Evaluates to the number of components of a Vec3.
--   
--   This symbol is useful when declaring a C array of floating point
--   values to be used with vec3InitFromFloat and
--   vec3ToFloat, e.g.
--   
--   
--   float v[GRAPHENE_VEC3_LEN];
--   
--   // vec is defined elsewhere
--   graphene_vec3_to_float (&vec, v);
--   
--   for (int i = 0; i < GRAPHENE_VEC2_LEN; i++)
--     fprintf (stdout, "component %d: %g\n", i, v[i]);
--   
--   
--   Since: 1.0
pattern VEC3_LEN :: Int32

-- | Evaluates to the number of components of a Vec2.
--   
--   This symbol is useful when declaring a C array of floating point
--   values to be used with vec2InitFromFloat and
--   vec2ToFloat, e.g.
--   
--   
--   float v[GRAPHENE_VEC2_LEN];
--   
--   // vec is defined elsewhere
--   graphene_vec2_to_float (&vec, v);
--   
--   for (int i = 0; i < GRAPHENE_VEC2_LEN; i++)
--     fprintf (stdout, "component %d: %g\n", i, v[i]);
--   
--   
--   Since: 1.0
pattern VEC2_LEN :: Int32

-- | No description available in the introspection data.
pattern PI_2 :: Double

-- | No description available in the introspection data.
pattern PI :: Double

module GI.Graphene.Enums

-- | Specify the order of the rotations on each axis.
--   
--   The EulerOrderDefault value is special, and is used as an alias
--   for one of the other orders.
--   
--   Since: 1.2
data EulerOrder

-- | Rotate in the default order; the default order is one of the following
--   enumeration values
EulerOrderDefault :: EulerOrder

-- | Rotate in the X, Y, and Z order. Deprecated in Graphene 1.10, it's an
--   alias for EulerOrderSxyz
EulerOrderXyz :: EulerOrder

-- | Rotate in the Y, Z, and X order. Deprecated in Graphene 1.10, it's an
--   alias for EulerOrderSyzx
EulerOrderYzx :: EulerOrder

-- | Rotate in the Z, X, and Y order. Deprecated in Graphene 1.10, it's an
--   alias for EulerOrderSzxy
EulerOrderZxy :: EulerOrder

-- | Rotate in the X, Z, and Y order. Deprecated in Graphene 1.10, it's an
--   alias for EulerOrderSxzy
EulerOrderXzy :: EulerOrder

-- | Rotate in the Y, X, and Z order. Deprecated in Graphene 1.10, it's an
--   alias for EulerOrderSyxz
EulerOrderYxz :: EulerOrder

-- | Rotate in the Z, Y, and X order. Deprecated in Graphene 1.10, it's an
--   alias for EulerOrderSzyx
EulerOrderZyx :: EulerOrder

-- | Defines a static rotation along the X, Y, and Z axes (Since: 1.10)
EulerOrderSxyz :: EulerOrder

-- | Defines a static rotation along the X, Y, and X axes (Since: 1.10)
EulerOrderSxyx :: EulerOrder

-- | Defines a static rotation along the X, Z, and Y axes (Since: 1.10)
EulerOrderSxzy :: EulerOrder

-- | Defines a static rotation along the X, Z, and X axes (Since: 1.10)
EulerOrderSxzx :: EulerOrder

-- | Defines a static rotation along the Y, Z, and X axes (Since: 1.10)
EulerOrderSyzx :: EulerOrder

-- | Defines a static rotation along the Y, Z, and Y axes (Since: 1.10)
EulerOrderSyzy :: EulerOrder

-- | Defines a static rotation along the Y, X, and Z axes (Since: 1.10)
EulerOrderSyxz :: EulerOrder

-- | Defines a static rotation along the Y, X, and Y axes (Since: 1.10)
EulerOrderSyxy :: EulerOrder

-- | Defines a static rotation along the Z, X, and Y axes (Since: 1.10)
EulerOrderSzxy :: EulerOrder

-- | Defines a static rotation along the Z, X, and Z axes (Since: 1.10)
EulerOrderSzxz :: EulerOrder

-- | Defines a static rotation along the Z, Y, and X axes (Since: 1.10)
EulerOrderSzyx :: EulerOrder

-- | Defines a static rotation along the Z, Y, and Z axes (Since: 1.10)
EulerOrderSzyz :: EulerOrder

-- | Defines a relative rotation along the Z, Y, and X axes (Since: 1.10)
EulerOrderRzyx :: EulerOrder

-- | Defines a relative rotation along the X, Y, and X axes (Since: 1.10)
EulerOrderRxyx :: EulerOrder

-- | Defines a relative rotation along the Y, Z, and X axes (Since: 1.10)
EulerOrderRyzx :: EulerOrder

-- | Defines a relative rotation along the X, Z, and X axes (Since: 1.10)
EulerOrderRxzx :: EulerOrder

-- | Defines a relative rotation along the X, Z, and Y axes (Since: 1.10)
EulerOrderRxzy :: EulerOrder

-- | Defines a relative rotation along the Y, Z, and Y axes (Since: 1.10)
EulerOrderRyzy :: EulerOrder

-- | Defines a relative rotation along the Z, X, and Y axes (Since: 1.10)
EulerOrderRzxy :: EulerOrder

-- | Defines a relative rotation along the Y, X, and Y axes (Since: 1.10)
EulerOrderRyxy :: EulerOrder

-- | Defines a relative rotation along the Y, X, and Z axes (Since: 1.10)
EulerOrderRyxz :: EulerOrder

-- | Defines a relative rotation along the Z, X, and Z axes (Since: 1.10)
EulerOrderRzxz :: EulerOrder

-- | Defines a relative rotation along the X, Y, and Z axes (Since: 1.10)
EulerOrderRxyz :: EulerOrder

-- | Defines a relative rotation along the Z, Y, and Z axes (Since: 1.10)
EulerOrderRzyz :: EulerOrder

-- | Catch-all for unknown values
AnotherEulerOrder :: Int -> EulerOrder

-- | The type of intersection.
--   
--   Since: 1.10
data RayIntersectionKind

-- | No intersection
RayIntersectionKindNone :: RayIntersectionKind

-- | The ray is entering the intersected object
RayIntersectionKindEnter :: RayIntersectionKind

-- | The ray is leaving the intersected object
RayIntersectionKindLeave :: RayIntersectionKind

-- | Catch-all for unknown values
AnotherRayIntersectionKind :: Int -> RayIntersectionKind
instance GHC.Internal.Enum.Enum GI.Graphene.Enums.EulerOrder
instance GHC.Internal.Enum.Enum GI.Graphene.Enums.RayIntersectionKind
instance GHC.Classes.Eq GI.Graphene.Enums.EulerOrder
instance GHC.Classes.Eq GI.Graphene.Enums.RayIntersectionKind
instance GHC.Classes.Ord GI.Graphene.Enums.EulerOrder
instance GHC.Classes.Ord GI.Graphene.Enums.RayIntersectionKind
instance GHC.Internal.Show.Show GI.Graphene.Enums.EulerOrder
instance GHC.Internal.Show.Show GI.Graphene.Enums.RayIntersectionKind

-- | No description available in the introspection data.
module GI.Graphene.Structs.Simd4F

-- | Memory-managed wrapper type.
newtype Simd4F
Simd4F :: ManagedPtr Simd4F -> Simd4F

-- | Construct a Simd4F struct initialized to zero.
newZeroSimd4F :: MonadIO m => m Simd4F
instance Data.GI.Base.BasicTypes.BoxedPtr GI.Graphene.Structs.Simd4F.Simd4F
instance Data.GI.Base.BasicTypes.CallocPtr GI.Graphene.Structs.Simd4F.Simd4F
instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Graphene.Structs.Simd4F.Simd4F tag
instance GHC.Classes.Eq GI.Graphene.Structs.Simd4F.Simd4F
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Graphene.Structs.Simd4F.Simd4F

-- | No description available in the introspection data.
module GI.Graphene.Structs.Simd4X4F

-- | Memory-managed wrapper type.
newtype Simd4X4F
Simd4X4F :: ManagedPtr Simd4X4F -> Simd4X4F

-- | Construct a Simd4X4F struct initialized to zero.
newZeroSimd4X4F :: MonadIO m => m Simd4X4F
instance Data.GI.Base.BasicTypes.BoxedPtr GI.Graphene.Structs.Simd4X4F.Simd4X4F
instance Data.GI.Base.BasicTypes.CallocPtr GI.Graphene.Structs.Simd4X4F.Simd4X4F
instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Graphene.Structs.Simd4X4F.Simd4X4F tag
instance GHC.Classes.Eq GI.Graphene.Structs.Simd4X4F.Simd4X4F
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Graphene.Structs.Simd4X4F.Simd4X4F

-- | A size.
--   
--   Since: 1.0
module GI.Graphene.Structs.Size

-- | Memory-managed wrapper type.
newtype Size
Size :: ManagedPtr Size -> Size

-- | Construct a Size struct initialized to zero.
newZeroSize :: MonadIO m => m Size

-- | Allocates a new Size.
--   
--   The contents of the returned value are undefined.
--   
--   Since: 1.0
sizeAlloc :: (HasCallStack, MonadIO m) => m Size

-- | Checks whether the two give Size are equal.
--   
--   Since: 1.0
sizeEqual :: (HasCallStack, MonadIO m) => Size -> Size -> m Bool

-- | Frees the resources allocated by sizeAlloc.
--   
--   Since: 1.0
sizeFree :: (HasCallStack, MonadIO m) => Size -> m ()

-- | Initializes a Size using the given width and
--   height.
--   
--   Since: 1.0
sizeInit :: (HasCallStack, MonadIO m) => Size -> Float -> Float -> m Size

-- | Initializes a Size using the width and height of the given
--   src.
--   
--   Since: 1.0
sizeInitFromSize :: (HasCallStack, MonadIO m) => Size -> Size -> m Size

-- | Linearly interpolates the two given Size using the given
--   interpolation factor.
--   
--   Since: 1.0
sizeInterpolate :: (HasCallStack, MonadIO m) => Size -> Size -> Double -> m Size

-- | Scales the components of a Size using the given
--   factor.
--   
--   Since: 1.0
sizeScale :: (HasCallStack, MonadIO m) => Size -> Float -> m Size

-- | A constant pointer to a zero Size, useful for equality checks
--   and interpolations.
--   
--   Since: 1.0
sizeZero :: (HasCallStack, MonadIO m) => m Size

-- | Get the value of the “height” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get size #height
--   
getSizeHeight :: MonadIO m => Size -> m Float

-- | Set the value of the “height” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   set size [ #height := value ]
--   
setSizeHeight :: MonadIO m => Size -> Float -> m ()

-- | Get the value of the “width” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get size #width
--   
getSizeWidth :: MonadIO m => Size -> m Float

-- | Set the value of the “width” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   set size [ #width := value ]
--   
setSizeWidth :: MonadIO m => Size -> Float -> m ()
instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Graphene.Structs.Size.Size tag
instance GHC.Classes.Eq GI.Graphene.Structs.Size.Size
instance Data.GI.Base.BasicTypes.GBoxed GI.Graphene.Structs.Size.Size
instance Data.GI.Base.Overloading.HasParentTypes GI.Graphene.Structs.Size.Size
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Graphene.Structs.Size.Size)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Graphene.Structs.Size.Size
instance Data.GI.Base.BasicTypes.TypedObject GI.Graphene.Structs.Size.Size

-- | A structure capable of holding a vector with two dimensions, x and y.
--   
--   The contents of the Vec2 structure are private and should never
--   be accessed directly.
module GI.Graphene.Structs.Vec2

-- | Memory-managed wrapper type.
newtype Vec2
Vec2 :: ManagedPtr Vec2 -> Vec2

-- | Construct a Vec2 struct initialized to zero.
newZeroVec2 :: MonadIO m => m Vec2

-- | Adds each component of the two passed vectors and places each result
--   into the components of res.
--   
--   Since: 1.0
vec2Add :: (HasCallStack, MonadIO m) => Vec2 -> Vec2 -> m Vec2

-- | Allocates a new Vec2 structure.
--   
--   The contents of the returned structure are undefined.
--   
--   Use vec2Init to initialize the vector.
--   
--   Since: 1.0
vec2Alloc :: (HasCallStack, MonadIO m) => m Vec2

-- | Divides each component of the first operand a by the
--   corresponding component of the second operand b, and
--   places the results into the vector res.
--   
--   Since: 1.0
vec2Divide :: (HasCallStack, MonadIO m) => Vec2 -> Vec2 -> m Vec2

-- | Computes the dot product of the two given vectors.
--   
--   Since: 1.0
vec2Dot :: (HasCallStack, MonadIO m) => Vec2 -> Vec2 -> m Float

-- | Checks whether the two given Vec2 are equal.
--   
--   Since: 1.2
vec2Equal :: (HasCallStack, MonadIO m) => Vec2 -> Vec2 -> m Bool

-- | Frees the resources allocated by v
--   
--   Since: 1.0
vec2Free :: (HasCallStack, MonadIO m) => Vec2 -> m ()

-- | Retrieves the X component of the Vec2.
--   
--   Since: 1.0
vec2GetX :: (HasCallStack, MonadIO m) => Vec2 -> m Float

-- | Retrieves the Y component of the Vec2.
--   
--   Since: 1.0
vec2GetY :: (HasCallStack, MonadIO m) => Vec2 -> m Float

-- | Initializes a Vec2 using the given values.
--   
--   This function can be called multiple times.
--   
--   Since: 1.0
vec2Init :: (HasCallStack, MonadIO m) => Vec2 -> Float -> Float -> m Vec2

-- | Initializes v with the contents of the given array.
--   
--   Since: 1.0
vec2InitFromFloat :: (HasCallStack, MonadIO m) => Vec2 -> [Float] -> m Vec2

-- | Copies the contents of src into v.
--   
--   Since: 1.0
vec2InitFromVec2 :: (HasCallStack, MonadIO m) => Vec2 -> Vec2 -> m Vec2

-- | Linearly interpolates v1 and v2 using
--   the given factor.
--   
--   Since: 1.10
vec2Interpolate :: (HasCallStack, MonadIO m) => Vec2 -> Vec2 -> Double -> m Vec2

-- | Computes the length of the given vector.
--   
--   Since: 1.0
vec2Length :: (HasCallStack, MonadIO m) => Vec2 -> m Float

-- | Compares the two given vectors and places the maximum values of each
--   component into res.
--   
--   Since: 1.0
vec2Max :: (HasCallStack, MonadIO m) => Vec2 -> Vec2 -> m Vec2

-- | Compares the two given vectors and places the minimum values of each
--   component into res.
--   
--   Since: 1.0
vec2Min :: (HasCallStack, MonadIO m) => Vec2 -> Vec2 -> m Vec2

-- | Multiplies each component of the two passed vectors and places each
--   result into the components of res.
--   
--   Since: 1.0
vec2Multiply :: (HasCallStack, MonadIO m) => Vec2 -> Vec2 -> m Vec2

-- | Compares the two given Vec2 vectors and checks whether their
--   values are within the given epsilon.
--   
--   Since: 1.2
vec2Near :: (HasCallStack, MonadIO m) => Vec2 -> Vec2 -> Float -> m Bool

-- | Negates the given Vec2.
--   
--   Since: 1.2
vec2Negate :: (HasCallStack, MonadIO m) => Vec2 -> m Vec2

-- | Computes the normalized vector for the given vector v.
--   
--   Since: 1.0
vec2Normalize :: (HasCallStack, MonadIO m) => Vec2 -> m Vec2

-- | Retrieves a constant vector with (1, 1) components.
--   
--   Since: 1.0
vec2One :: (HasCallStack, MonadIO m) => m Vec2

-- | Multiplies all components of the given vector with the given scalar
--   factor.
--   
--   Since: 1.2
vec2Scale :: (HasCallStack, MonadIO m) => Vec2 -> Float -> m Vec2

-- | Subtracts from each component of the first operand a
--   the corresponding component of the second operand b
--   and places each result into the components of res.
--   
--   Since: 1.0
vec2Subtract :: (HasCallStack, MonadIO m) => Vec2 -> Vec2 -> m Vec2

-- | Retrieves a constant vector with (1, 0) components.
--   
--   Since: 1.0
vec2XAxis :: (HasCallStack, MonadIO m) => m Vec2

-- | Retrieves a constant vector with (0, 1) components.
--   
--   Since: 1.0
vec2YAxis :: (HasCallStack, MonadIO m) => m Vec2

-- | Retrieves a constant vector with (0, 0) components.
--   
--   Since: 1.0
vec2Zero :: (HasCallStack, MonadIO m) => m Vec2
instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Graphene.Structs.Vec2.Vec2 tag
instance GHC.Classes.Eq GI.Graphene.Structs.Vec2.Vec2
instance Data.GI.Base.BasicTypes.GBoxed GI.Graphene.Structs.Vec2.Vec2
instance Data.GI.Base.Overloading.HasParentTypes GI.Graphene.Structs.Vec2.Vec2
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Graphene.Structs.Vec2.Vec2)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Graphene.Structs.Vec2.Vec2
instance Data.GI.Base.BasicTypes.TypedObject GI.Graphene.Structs.Vec2.Vec2

-- | The location and size of a rectangle region.
--   
--   The width and height of a Rect can be negative; for instance, a
--   Rect with an origin of [ 0, 0 ] and a size of [ 10, 10 ] is
--   equivalent to a Rect with an origin of [ 10, 10 ] and a size of
--   [ -10, -10 ].
--   
--   Application code can normalize rectangles using rectNormalize;
--   this function will ensure that the width and height of a rectangle are
--   positive values. All functions taking a Rect as an argument
--   will internally operate on a normalized copy; all functions returning
--   a Rect will always return a normalized rectangle.
--   
--   Since: 1.0
module GI.Graphene.Structs.Rect

-- | Memory-managed wrapper type.
newtype Rect
Rect :: ManagedPtr Rect -> Rect

-- | Construct a Rect struct initialized to zero.
newZeroRect :: MonadIO m => m Rect

-- | Allocates a new Rect.
--   
--   The contents of the returned rectangle are undefined.
--   
--   Since: 1.0
rectAlloc :: (HasCallStack, MonadIO m) => m Rect

-- | Checks whether a Rect contains the given coordinates.
--   
--   Since: 1.0
rectContainsPoint :: (HasCallStack, MonadIO m) => Rect -> Point -> m Bool

-- | Checks whether a Rect fully contains the given rectangle.
--   
--   Since: 1.0
rectContainsRect :: (HasCallStack, MonadIO m) => Rect -> Rect -> m Bool

-- | Checks whether the two given rectangle are equal.
--   
--   Since: 1.0
rectEqual :: (HasCallStack, MonadIO m) => Rect -> Rect -> m Bool

-- | Expands a Rect to contain the given Point.
--   
--   Since: 1.4
rectExpand :: (HasCallStack, MonadIO m) => Rect -> Point -> m Rect

-- | Frees the resources allocated by rectAlloc.
--   
--   Since: 1.0
rectFree :: (HasCallStack, MonadIO m) => Rect -> m ()

-- | Compute the area of given normalized rectangle.
--   
--   Since: 1.10
rectGetArea :: (HasCallStack, MonadIO m) => Rect -> m Float

-- | Retrieves the coordinates of the bottom-left corner of the given
--   rectangle.
--   
--   Since: 1.0
rectGetBottomLeft :: (HasCallStack, MonadIO m) => Rect -> m Point

-- | Retrieves the coordinates of the bottom-right corner of the given
--   rectangle.
--   
--   Since: 1.0
rectGetBottomRight :: (HasCallStack, MonadIO m) => Rect -> m Point

-- | Retrieves the coordinates of the center of the given rectangle.
--   
--   Since: 1.0
rectGetCenter :: (HasCallStack, MonadIO m) => Rect -> m Point

-- | Retrieves the normalized height of the given rectangle.
--   
--   Since: 1.0
rectGetHeight :: (HasCallStack, MonadIO m) => Rect -> m Float

-- | Retrieves the coordinates of the top-left corner of the given
--   rectangle.
--   
--   Since: 1.0
rectGetTopLeft :: (HasCallStack, MonadIO m) => Rect -> m Point

-- | Retrieves the coordinates of the top-right corner of the given
--   rectangle.
--   
--   Since: 1.0
rectGetTopRight :: (HasCallStack, MonadIO m) => Rect -> m Point

-- | Retrieves the normalized width of the given rectangle.
--   
--   Since: 1.0
rectGetWidth :: (HasCallStack, MonadIO m) => Rect -> m Float

-- | Retrieves the normalized X coordinate of the origin of the given
--   rectangle.
--   
--   Since: 1.0
rectGetX :: (HasCallStack, MonadIO m) => Rect -> m Float

-- | Retrieves the normalized Y coordinate of the origin of the given
--   rectangle.
--   
--   Since: 1.0
rectGetY :: (HasCallStack, MonadIO m) => Rect -> m Float

-- | Initializes the given Rect with the given values.
--   
--   This function will implicitly normalize the Rect before
--   returning.
--   
--   Since: 1.0
rectInit :: (HasCallStack, MonadIO m) => Rect -> Float -> Float -> Float -> Float -> m Rect

-- | Initializes r using the given src
--   rectangle.
--   
--   This function will implicitly normalize the Rect before
--   returning.
--   
--   Since: 1.0
rectInitFromRect :: (HasCallStack, MonadIO m) => Rect -> Rect -> m Rect

-- | Changes the given rectangle to be smaller, or larger depending on the
--   given inset parameters.
--   
--   To create an inset rectangle, use positive dX or
--   dY values; to create a larger, encompassing rectangle,
--   use negative dX or dY values.
--   
--   The origin of the rectangle is offset by dX and
--   dY, while the size is adjusted by (2 * @d_x, 2 *
--   @d_y). If dX and dY are positive
--   values, the size of the rectangle is decreased; if dX
--   and dY are negative values, the size of the rectangle
--   is increased.
--   
--   If the size of the resulting inset rectangle has a negative width or
--   height then the size will be set to zero.
--   
--   Since: 1.0
rectInset :: (HasCallStack, MonadIO m) => Rect -> Float -> Float -> m Rect

-- | Changes the given rectangle to be smaller, or larger depending on the
--   given inset parameters.
--   
--   To create an inset rectangle, use positive dX or
--   dY values; to create a larger, encompassing rectangle,
--   use negative dX or dY values.
--   
--   The origin of the rectangle is offset by dX and
--   dY, while the size is adjusted by (2 * @d_x, 2 *
--   @d_y). If dX and dY are positive
--   values, the size of the rectangle is decreased; if dX
--   and dY are negative values, the size of the rectangle
--   is increased.
--   
--   If the size of the resulting inset rectangle has a negative width or
--   height then the size will be set to zero.
--   
--   Since: 1.4
rectInsetR :: (HasCallStack, MonadIO m) => Rect -> Float -> Float -> m Rect

-- | Linearly interpolates the origin and size of the two given rectangles.
--   
--   Since: 1.0
rectInterpolate :: (HasCallStack, MonadIO m) => Rect -> Rect -> Double -> m Rect

-- | Computes the intersection of the two given rectangles.
--   
--   
--   The intersection in the image above is the blue outline.
--   
--   If the two rectangles do not intersect, res will
--   contain a degenerate rectangle with origin in (0, 0) and a size of 0.
--   
--   Since: 1.0
rectIntersection :: (HasCallStack, MonadIO m) => Rect -> Rect -> m (Bool, Rect)

-- | Normalizes the passed rectangle.
--   
--   This function ensures that the size of the rectangle is made of
--   positive values, and that the origin is the top-left corner of the
--   rectangle.
--   
--   Since: 1.0
rectNormalize :: (HasCallStack, MonadIO m) => Rect -> m Rect

-- | Normalizes the passed rectangle.
--   
--   This function ensures that the size of the rectangle is made of
--   positive values, and that the origin is in the top-left corner of the
--   rectangle.
--   
--   Since: 1.4
rectNormalizeR :: (HasCallStack, MonadIO m) => Rect -> m Rect

-- | Offsets the origin by dX and dY.
--   
--   The size of the rectangle is unchanged.
--   
--   Since: 1.0
rectOffset :: (HasCallStack, MonadIO m) => Rect -> Float -> Float -> m Rect

-- | Offsets the origin of the given rectangle by dX and
--   dY.
--   
--   The size of the rectangle is left unchanged.
--   
--   Since: 1.4
rectOffsetR :: (HasCallStack, MonadIO m) => Rect -> Float -> Float -> m Rect

-- | Rounds the origin and size of the given rectangle to their nearest
--   integer values; the rounding is guaranteed to be large enough to have
--   an area bigger or equal to the original rectangle, but might not fully
--   contain its extents. Use rectRoundExtents in case you need to
--   round to a rectangle that covers fully the original one.
--   
--   This function is the equivalent of calling floor on the
--   coordinates of the origin, and ceil on the size.
--   
--   Since: 1.4

-- | Deprecated: (Since version 1.10)Use rectRoundExtents
--   instead
rectRound :: (HasCallStack, MonadIO m) => Rect -> m Rect

-- | Rounds the origin of the given rectangle to its nearest integer value
--   and and recompute the size so that the rectangle is large enough to
--   contain all the conrners of the original rectangle.
--   
--   This function is the equivalent of calling floor on the
--   coordinates of the origin, and recomputing the size calling
--   ceil on the bottom-right coordinates.
--   
--   If you want to be sure that the rounded rectangle completely covers
--   the area that was covered by the original rectangle — i.e. you want to
--   cover the area including all its corners — this function will make
--   sure that the size is recomputed taking into account the ceiling of
--   the coordinates of the bottom-right corner. If the difference between
--   the original coordinates and the coordinates of the rounded rectangle
--   is greater than the difference between the original size and and the
--   rounded size, then the move of the origin would not be compensated by
--   a move in the anti-origin, leaving the corners of the original
--   rectangle outside the rounded one.
--   
--   Since: 1.10
rectRoundExtents :: (HasCallStack, MonadIO m) => Rect -> m Rect

-- | Rounds the origin and the size of the given rectangle to their nearest
--   integer values; the rounding is guaranteed to be large enough to
--   contain the original rectangle.
--   
--   Since: 1.0

-- | Deprecated: (Since version 1.4)Use rectRound instead
rectRoundToPixel :: (HasCallStack, MonadIO m) => Rect -> m Rect

-- | Scales the size and origin of a rectangle horizontaly by
--   sH, and vertically by sV. The result
--   res is normalized.
--   
--   Since: 1.10
rectScale :: (HasCallStack, MonadIO m) => Rect -> Float -> Float -> m Rect

-- | Computes the union of the two given rectangles.
--   
--   
--   The union in the image above is the blue outline.
--   
--   Since: 1.0
rectUnion :: (HasCallStack, MonadIO m) => Rect -> Rect -> m Rect

-- | Returns a degenerate rectangle with origin fixed at (0, 0) and a size
--   of 0, 0.
--   
--   Since: 1.4
rectZero :: (HasCallStack, MonadIO m) => m Rect

-- | Get the value of the “origin” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get rect #origin
--   
getRectOrigin :: MonadIO m => Rect -> m Point

-- | Get the value of the “size” field. When overloading is
--   enabled, this is equivalent to
--   
--   
--   get rect #size
--   
getRectSize :: MonadIO m => Rect -> m Size
instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Graphene.Structs.Rect.Rect tag
instance GHC.Classes.Eq GI.Graphene.Structs.Rect.Rect
instance Data.GI.Base.BasicTypes.GBoxed GI.Graphene.Structs.Rect.Rect
instance Data.GI.Base.Overloading.HasParentTypes GI.Graphene.Structs.Rect.Rect
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Graphene.Structs.Rect.Rect)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Graphene.Structs.Rect.Rect
instance Data.GI.Base.BasicTypes.TypedObject GI.Graphene.Structs.Rect.Rect

-- | A 4 vertex quadrilateral, as represented by four Point.
--   
--   The contents of a Quad are private and should never be accessed
--   directly.
--   
--   Since: 1.0
module GI.Graphene.Structs.Quad

-- | Memory-managed wrapper type.
newtype Quad
Quad :: ManagedPtr Quad -> Quad

-- | Construct a Quad struct initialized to zero.
newZeroQuad :: MonadIO m => m Quad

-- | Allocates a new Quad instance.
--   
--   The contents of the returned instance are undefined.
--   
--   Since: 1.0
quadAlloc :: (HasCallStack, MonadIO m) => m Quad

-- | Computes the bounding rectangle of q and places it
--   into r.
--   
--   Since: 1.0
quadBounds :: (HasCallStack, MonadIO m) => Quad -> m Rect

-- | Checks if the given Quad contains the given Point.
--   
--   Since: 1.0
quadContains :: (HasCallStack, MonadIO m) => Quad -> Point -> m Bool

-- | Frees the resources allocated by quadAlloc
--   
--   Since: 1.0
quadFree :: (HasCallStack, MonadIO m) => Quad -> m ()

-- | Retrieves the point of a Quad at the given index.
--   
--   Since: 1.0
quadGetPoint :: (HasCallStack, MonadIO m) => Quad -> Word32 -> m Point

-- | Initializes a Quad with the given points.
--   
--   Since: 1.0
quadInit :: (HasCallStack, MonadIO m) => Quad -> Point -> Point -> Point -> Point -> m Quad

-- | Initializes a Quad using an array of points.
--   
--   Since: 1.2
quadInitFromPoints :: (HasCallStack, MonadIO m) => Quad -> [Point] -> m Quad

-- | Initializes a Quad using the four corners of the given
--   Rect.
--   
--   Since: 1.0
quadInitFromRect :: (HasCallStack, MonadIO m) => Quad -> Rect -> m Quad
instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Graphene.Structs.Quad.Quad tag
instance GHC.Classes.Eq GI.Graphene.Structs.Quad.Quad
instance Data.GI.Base.BasicTypes.GBoxed GI.Graphene.Structs.Quad.Quad
instance Data.GI.Base.Overloading.HasParentTypes GI.Graphene.Structs.Quad.Quad
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Graphene.Structs.Quad.Quad)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Graphene.Structs.Quad.Quad
instance Data.GI.Base.BasicTypes.TypedObject GI.Graphene.Structs.Quad.Quad

-- | A point with two coordinates.
--   
--   Since: 1.0
module GI.Graphene.Structs.Point

-- | Memory-managed wrapper type.
newtype Point
Point :: ManagedPtr Point -> Point

-- | Construct a Point struct initialized to zero.
newZeroPoint :: MonadIO m => m Point

-- | Allocates a new Point structure.
--   
--   The coordinates of the returned point are (0, 0).
--   
--   It's possible to chain this function with pointInit or
--   pointInitFromPoint, e.g.:
--   
--   
C code
--   
--   
--   graphene_point_t *
--   point_new (float x, float y)
--   {
--     return graphene_point_init (graphene_point_alloc (), x, y);
--   }
--   
--   graphene_point_t *
--   point_copy (const graphene_point_t *p)
--   {
--     return graphene_point_init_from_point (graphene_point_alloc (), p);
--   }
--   
--   
--   Since: 1.0
pointAlloc :: (HasCallStack, MonadIO m) => m Point

-- | Computes the distance between a and b.
--   
--   Since: 1.0
pointDistance :: (HasCallStack, MonadIO m) => Point -> Point -> m (Float, Float, Float)

-- | Checks if the two points a and b point
--   to the same coordinates.
--   
--   This function accounts for floating point fluctuations; if you want to
--   control the fuzziness of the match, you can use pointNear
--   instead.
--   
--   Since: 1.0
pointEqual :: (HasCallStack, MonadIO m) => Point -> Point -> m Bool

-- | Frees the resources allocated by pointAlloc.
--   
--   Since: 1.0
pointFree :: (HasCallStack, MonadIO m) => Point -> m ()

-- | Initializes p to the given x and
--   y coordinates.
--   
--   It's safe to call this function multiple times.
--   
--   Since: 1.0
pointInit :: (HasCallStack, MonadIO m) => Point -> Float -> Float -> m Point

-- | Initializes p with the same coordinates of
--   src.
--   
--   Since: 1.0
pointInitFromPoint :: (HasCallStack, MonadIO m) => Point -> Point -> m Point

-- | Initializes p with the coordinates inside the given
--   Vec2.
--   
--   Since: 1.4
pointInitFromVec2 :: (HasCallStack, MonadIO m) => Point -> Vec2 -> m Point

-- | Linearly interpolates the coordinates of a and
--   b using the given factor.
--   
--   Since: 1.0
pointInterpolate :: (HasCallStack, MonadIO m) => Point -> Point -> Double -> m Point

-- | Checks whether the two points a and b
--   are within the threshold of epsilon.
--   
--   Since: 1.0
pointNear :: (HasCallStack, MonadIO m) => Point -> Point -> Float -> m Bool

-- | Stores the coordinates of the given Point into a Vec2.
--   
--   Since: 1.4
pointToVec2 :: (HasCallStack, MonadIO m) => Point -> m Vec2

-- | Returns a point fixed at (0, 0).
--   
--   Since: 1.0
pointZero :: (HasCallStack, MonadIO m) => m Point

-- | Get the value of the “x” field. When overloading is
--   enabled, this is equivalent to
--   
--   
--   get point #x
--   
getPointX :: MonadIO m => Point -> m Float

-- | Set the value of the “x” field. When overloading is
--   enabled, this is equivalent to
--   
--   
--   set point [ #x := value ]
--   
setPointX :: MonadIO m => Point -> Float -> m ()

-- | Get the value of the “y” field. When overloading is
--   enabled, this is equivalent to
--   
--   
--   get point #y
--   
getPointY :: MonadIO m => Point -> m Float

-- | Set the value of the “y” field. When overloading is
--   enabled, this is equivalent to
--   
--   
--   set point [ #y := value ]
--   
setPointY :: MonadIO m => Point -> Float -> m ()
instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Graphene.Structs.Point.Point tag
instance GHC.Classes.Eq GI.Graphene.Structs.Point.Point
instance Data.GI.Base.BasicTypes.GBoxed GI.Graphene.Structs.Point.Point
instance Data.GI.Base.Overloading.HasParentTypes GI.Graphene.Structs.Point.Point
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Graphene.Structs.Point.Point)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Graphene.Structs.Point.Point
instance Data.GI.Base.BasicTypes.TypedObject GI.Graphene.Structs.Point.Point

-- | A structure capable of holding a vector with four dimensions: x, y, z,
--   and w.
--   
--   The contents of the Vec4 structure are private and should never
--   be accessed directly.
module GI.Graphene.Structs.Vec4

-- | Memory-managed wrapper type.
newtype Vec4
Vec4 :: ManagedPtr Vec4 -> Vec4

-- | Construct a Vec4 struct initialized to zero.
newZeroVec4 :: MonadIO m => m Vec4

-- | Adds each component of the two given vectors.
--   
--   Since: 1.0
vec4Add :: (HasCallStack, MonadIO m) => Vec4 -> Vec4 -> m Vec4

-- | Allocates a new Vec4 structure.
--   
--   The contents of the returned structure are undefined.
--   
--   Use vec4Init to initialize the vector.
--   
--   Since: 1.0
vec4Alloc :: (HasCallStack, MonadIO m) => m Vec4

-- | Divides each component of the first operand a by the
--   corresponding component of the second operand b, and
--   places the results into the vector res.
--   
--   Since: 1.0
vec4Divide :: (HasCallStack, MonadIO m) => Vec4 -> Vec4 -> m Vec4

-- | Computes the dot product of the two given vectors.
--   
--   Since: 1.0
vec4Dot :: (HasCallStack, MonadIO m) => Vec4 -> Vec4 -> m Float

-- | Checks whether the two given Vec4 are equal.
--   
--   Since: 1.2
vec4Equal :: (HasCallStack, MonadIO m) => Vec4 -> Vec4 -> m Bool

-- | Frees the resources allocated by v
--   
--   Since: 1.0
vec4Free :: (HasCallStack, MonadIO m) => Vec4 -> m ()

-- | Retrieves the value of the fourth component of the given Vec4.
--   
--   Since: 1.0
vec4GetW :: (HasCallStack, MonadIO m) => Vec4 -> m Float

-- | Retrieves the value of the first component of the given Vec4.
--   
--   Since: 1.0
vec4GetX :: (HasCallStack, MonadIO m) => Vec4 -> m Float

-- | Creates a Vec2 that contains the first two components of the
--   given Vec4.
--   
--   Since: 1.0
vec4GetXy :: (HasCallStack, MonadIO m) => Vec4 -> m Vec2

-- | Creates a Vec3 that contains the first three components of the
--   given Vec4.
--   
--   Since: 1.0
vec4GetXyz :: (HasCallStack, MonadIO m) => Vec4 -> m Vec3

-- | Retrieves the value of the second component of the given Vec4.
--   
--   Since: 1.0
vec4GetY :: (HasCallStack, MonadIO m) => Vec4 -> m Float

-- | Retrieves the value of the third component of the given Vec4.
--   
--   Since: 1.0
vec4GetZ :: (HasCallStack, MonadIO m) => Vec4 -> m Float

-- | Initializes a Vec4 using the given values.
--   
--   This function can be called multiple times.
--   
--   Since: 1.0
vec4Init :: (HasCallStack, MonadIO m) => Vec4 -> Float -> Float -> Float -> Float -> m Vec4

-- | Initializes a Vec4 with the values inside the given array.
--   
--   Since: 1.0
vec4InitFromFloat :: (HasCallStack, MonadIO m) => Vec4 -> [Float] -> m Vec4

-- | Initializes a Vec4 using the components of a Vec2 and
--   the values of z and w.
--   
--   Since: 1.0
vec4InitFromVec2 :: (HasCallStack, MonadIO m) => Vec4 -> Vec2 -> Float -> Float -> m Vec4

-- | Initializes a Vec4 using the components of a Vec3 and
--   the value of w.
--   
--   Since: 1.0
vec4InitFromVec3 :: (HasCallStack, MonadIO m) => Vec4 -> Vec3 -> Float -> m Vec4

-- | Initializes a Vec4 using the components of another Vec4.
--   
--   Since: 1.0
vec4InitFromVec4 :: (HasCallStack, MonadIO m) => Vec4 -> Vec4 -> m Vec4

-- | Linearly interpolates v1 and v2 using
--   the given factor.
--   
--   Since: 1.10
vec4Interpolate :: (HasCallStack, MonadIO m) => Vec4 -> Vec4 -> Double -> m Vec4

-- | Computes the length of the given Vec4.
--   
--   Since: 1.0
vec4Length :: (HasCallStack, MonadIO m) => Vec4 -> m Float

-- | Compares each component of the two given vectors and creates a vector
--   that contains the maximum values.
--   
--   Since: 1.0
vec4Max :: (HasCallStack, MonadIO m) => Vec4 -> Vec4 -> m Vec4

-- | Compares each component of the two given vectors and creates a vector
--   that contains the minimum values.
--   
--   Since: 1.0
vec4Min :: (HasCallStack, MonadIO m) => Vec4 -> Vec4 -> m Vec4

-- | Multiplies each component of the two given vectors.
--   
--   Since: 1.0
vec4Multiply :: (HasCallStack, MonadIO m) => Vec4 -> Vec4 -> m Vec4

-- | Compares the two given Vec4 vectors and checks whether their
--   values are within the given epsilon.
--   
--   Since: 1.2
vec4Near :: (HasCallStack, MonadIO m) => Vec4 -> Vec4 -> Float -> m Bool

-- | Negates the given Vec4.
--   
--   Since: 1.2
vec4Negate :: (HasCallStack, MonadIO m) => Vec4 -> m Vec4

-- | Normalizes the given Vec4.
--   
--   Since: 1.0
vec4Normalize :: (HasCallStack, MonadIO m) => Vec4 -> m Vec4

-- | Retrieves a pointer to a Vec4 with all its components set to 1.
--   
--   Since: 1.0
vec4One :: (HasCallStack, MonadIO m) => m Vec4

-- | Multiplies all components of the given vector with the given scalar
--   factor.
--   
--   Since: 1.2
vec4Scale :: (HasCallStack, MonadIO m) => Vec4 -> Float -> m Vec4

-- | Subtracts from each component of the first operand a
--   the corresponding component of the second operand b
--   and places each result into the components of res.
--   
--   Since: 1.0
vec4Subtract :: (HasCallStack, MonadIO m) => Vec4 -> Vec4 -> m Vec4

-- | Retrieves a pointer to a Vec4 with its components set to (0, 0,
--   0, 1).
--   
--   Since: 1.0
vec4WAxis :: (HasCallStack, MonadIO m) => m Vec4

-- | Retrieves a pointer to a Vec4 with its components set to (1, 0,
--   0, 0).
--   
--   Since: 1.0
vec4XAxis :: (HasCallStack, MonadIO m) => m Vec4

-- | Retrieves a pointer to a Vec4 with its components set to (0, 1,
--   0, 0).
--   
--   Since: 1.0
vec4YAxis :: (HasCallStack, MonadIO m) => m Vec4

-- | Retrieves a pointer to a Vec4 with its components set to (0, 0,
--   1, 0).
--   
--   Since: 1.0
vec4ZAxis :: (HasCallStack, MonadIO m) => m Vec4

-- | Retrieves a pointer to a Vec4 with all its components set to 0.
--   
--   Since: 1.0
vec4Zero :: (HasCallStack, MonadIO m) => m Vec4
instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Graphene.Structs.Vec4.Vec4 tag
instance GHC.Classes.Eq GI.Graphene.Structs.Vec4.Vec4
instance Data.GI.Base.BasicTypes.GBoxed GI.Graphene.Structs.Vec4.Vec4
instance Data.GI.Base.Overloading.HasParentTypes GI.Graphene.Structs.Vec4.Vec4
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Graphene.Structs.Vec4.Vec4)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Graphene.Structs.Vec4.Vec4
instance Data.GI.Base.BasicTypes.TypedObject GI.Graphene.Structs.Vec4.Vec4

-- | A structure capable of holding a vector with three dimensions: x, y,
--   and z.
--   
--   The contents of the Vec3 structure are private and should never
--   be accessed directly.
module GI.Graphene.Structs.Vec3

-- | Memory-managed wrapper type.
newtype Vec3
Vec3 :: ManagedPtr Vec3 -> Vec3

-- | Construct a Vec3 struct initialized to zero.
newZeroVec3 :: MonadIO m => m Vec3

-- | Adds each component of the two given vectors.
--   
--   Since: 1.0
vec3Add :: (HasCallStack, MonadIO m) => Vec3 -> Vec3 -> m Vec3

-- | Allocates a new Vec3 structure.
--   
--   The contents of the returned structure are undefined.
--   
--   Use vec3Init to initialize the vector.
--   
--   Since: 1.0
vec3Alloc :: (HasCallStack, MonadIO m) => m Vec3

-- | Computes the cross product of the two given vectors.
--   
--   Since: 1.0
vec3Cross :: (HasCallStack, MonadIO m) => Vec3 -> Vec3 -> m Vec3

-- | Divides each component of the first operand a by the
--   corresponding component of the second operand b, and
--   places the results into the vector res.
--   
--   Since: 1.0
vec3Divide :: (HasCallStack, MonadIO m) => Vec3 -> Vec3 -> m Vec3

-- | Computes the dot product of the two given vectors.
--   
--   Since: 1.0
vec3Dot :: (HasCallStack, MonadIO m) => Vec3 -> Vec3 -> m Float

-- | Checks whether the two given Vec3 are equal.
--   
--   Since: 1.2
vec3Equal :: (HasCallStack, MonadIO m) => Vec3 -> Vec3 -> m Bool

-- | Frees the resources allocated by v
--   
--   Since: 1.0
vec3Free :: (HasCallStack, MonadIO m) => Vec3 -> m ()

-- | Retrieves the first component of the given vector v.
--   
--   Since: 1.0
vec3GetX :: (HasCallStack, MonadIO m) => Vec3 -> m Float

-- | Creates a Vec2 that contains the first and second components of
--   the given Vec3.
--   
--   Since: 1.0
vec3GetXy :: (HasCallStack, MonadIO m) => Vec3 -> m Vec2

-- | Creates a Vec3 that contains the first two components of the
--   given Vec3, and the third component set to 0.
--   
--   Since: 1.0
vec3GetXy0 :: (HasCallStack, MonadIO m) => Vec3 -> m Vec3

-- | Converts a Vec3 in a Vec4 using 0.0 as the value for the
--   fourth component of the resulting vector.
--   
--   Since: 1.0
vec3GetXyz0 :: (HasCallStack, MonadIO m) => Vec3 -> m Vec4

-- | Converts a Vec3 in a Vec4 using 1.0 as the value for the
--   fourth component of the resulting vector.
--   
--   Since: 1.0
vec3GetXyz1 :: (HasCallStack, MonadIO m) => Vec3 -> m Vec4

-- | Converts a Vec3 in a Vec4 using w as the
--   value of the fourth component of the resulting vector.
--   
--   Since: 1.0
vec3GetXyzw :: (HasCallStack, MonadIO m) => Vec3 -> Float -> m Vec4

-- | Retrieves the second component of the given vector v.
--   
--   Since: 1.0
vec3GetY :: (HasCallStack, MonadIO m) => Vec3 -> m Float

-- | Retrieves the third component of the given vector v.
--   
--   Since: 1.0
vec3GetZ :: (HasCallStack, MonadIO m) => Vec3 -> m Float

-- | Initializes a Vec3 using the given values.
--   
--   This function can be called multiple times.
--   
--   Since: 1.0
vec3Init :: (HasCallStack, MonadIO m) => Vec3 -> Float -> Float -> Float -> m Vec3

-- | Initializes a Vec3 with the values from an array.
--   
--   Since: 1.0
vec3InitFromFloat :: (HasCallStack, MonadIO m) => Vec3 -> [Float] -> m Vec3

-- | Initializes a Vec3 with the values of another Vec3.
--   
--   Since: 1.0
vec3InitFromVec3 :: (HasCallStack, MonadIO m) => Vec3 -> Vec3 -> m Vec3

-- | Linearly interpolates v1 and v2 using
--   the given factor.
--   
--   Since: 1.10
vec3Interpolate :: (HasCallStack, MonadIO m) => Vec3 -> Vec3 -> Double -> m Vec3

-- | Retrieves the length of the given vector v.
--   
--   Since: 1.0
vec3Length :: (HasCallStack, MonadIO m) => Vec3 -> m Float

-- | Compares each component of the two given vectors and creates a vector
--   that contains the maximum values.
--   
--   Since: 1.0
vec3Max :: (HasCallStack, MonadIO m) => Vec3 -> Vec3 -> m Vec3

-- | Compares each component of the two given vectors and creates a vector
--   that contains the minimum values.
--   
--   Since: 1.0
vec3Min :: (HasCallStack, MonadIO m) => Vec3 -> Vec3 -> m Vec3

-- | Multiplies each component of the two given vectors.
--   
--   Since: 1.0
vec3Multiply :: (HasCallStack, MonadIO m) => Vec3 -> Vec3 -> m Vec3

-- | Compares the two given Vec3 vectors and checks whether their
--   values are within the given epsilon.
--   
--   Since: 1.2
vec3Near :: (HasCallStack, MonadIO m) => Vec3 -> Vec3 -> Float -> m Bool

-- | Negates the given Vec3.
--   
--   Since: 1.2
vec3Negate :: (HasCallStack, MonadIO m) => Vec3 -> m Vec3

-- | Normalizes the given Vec3.
--   
--   Since: 1.0
vec3Normalize :: (HasCallStack, MonadIO m) => Vec3 -> m Vec3

-- | Provides a constant pointer to a vector with three components, all
--   sets to 1.
--   
--   Since: 1.0
vec3One :: (HasCallStack, MonadIO m) => m Vec3

-- | Multiplies all components of the given vector with the given scalar
--   factor.
--   
--   Since: 1.2
vec3Scale :: (HasCallStack, MonadIO m) => Vec3 -> Float -> m Vec3

-- | Subtracts from each component of the first operand a
--   the corresponding component of the second operand b
--   and places each result into the components of res.
--   
--   Since: 1.0
vec3Subtract :: (HasCallStack, MonadIO m) => Vec3 -> Vec3 -> m Vec3

-- | Provides a constant pointer to a vector with three components with
--   values set to (1, 0, 0).
--   
--   Since: 1.0
vec3XAxis :: (HasCallStack, MonadIO m) => m Vec3

-- | Provides a constant pointer to a vector with three components with
--   values set to (0, 1, 0).
--   
--   Since: 1.0
vec3YAxis :: (HasCallStack, MonadIO m) => m Vec3

-- | Provides a constant pointer to a vector with three components with
--   values set to (0, 0, 1).
--   
--   Since: 1.0
vec3ZAxis :: (HasCallStack, MonadIO m) => m Vec3

-- | Provides a constant pointer to a vector with three components, all
--   sets to 0.
--   
--   Since: 1.0
vec3Zero :: (HasCallStack, MonadIO m) => m Vec3
instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Graphene.Structs.Vec3.Vec3 tag
instance GHC.Classes.Eq GI.Graphene.Structs.Vec3.Vec3
instance Data.GI.Base.BasicTypes.GBoxed GI.Graphene.Structs.Vec3.Vec3
instance Data.GI.Base.Overloading.HasParentTypes GI.Graphene.Structs.Vec3.Vec3
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Graphene.Structs.Vec3.Vec3)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Graphene.Structs.Vec3.Vec3
instance Data.GI.Base.BasicTypes.TypedObject GI.Graphene.Structs.Vec3.Vec3

-- | A triangle.
--   
--   Since: 1.2
module GI.Graphene.Structs.Triangle

-- | Memory-managed wrapper type.
newtype Triangle
Triangle :: ManagedPtr Triangle -> Triangle

-- | Construct a Triangle struct initialized to zero.
newZeroTriangle :: MonadIO m => m Triangle

-- | Allocates a new Triangle.
--   
--   The contents of the returned structure are undefined.
--   
--   Since: 1.2
triangleAlloc :: (HasCallStack, MonadIO m) => m Triangle

-- | Checks whether the given triangle t contains the point
--   p.
--   
--   Since: 1.2
triangleContainsPoint :: (HasCallStack, MonadIO m) => Triangle -> Point3D -> m Bool

-- | Checks whether the two given Triangle are equal.
--   
--   Since: 1.2
triangleEqual :: (HasCallStack, MonadIO m) => Triangle -> Triangle -> m Bool

-- | Frees the resources allocated by triangleAlloc.
--   
--   Since: 1.2
triangleFree :: (HasCallStack, MonadIO m) => Triangle -> m ()

-- | Computes the area of the given Triangle.
--   
--   Since: 1.2
triangleGetArea :: (HasCallStack, MonadIO m) => Triangle -> m Float

-- | Computes the barycentric coordinates of the given point
--   p.
--   
--   The point p must lie on the same plane as the triangle
--   t; if the point is not coplanar, the result of this
--   function is undefined.
--   
--   If we place the origin in the coordinates of the triangle's A point,
--   the barycentric coordinates are u, which is on the AC vector;
--   and v which is on the AB vector:
--   
--   
--   The returned Vec2 contains the following values, in order:
--   
--   
--   
- 
res.x = u

--   
- 
res.y = v

--   
--   
--   Since: 1.2
triangleGetBarycoords :: (HasCallStack, MonadIO m) => Triangle -> Maybe Point3D -> m (Bool, Vec2)

-- | Computes the bounding box of the given Triangle.
--   
--   Since: 1.2
triangleGetBoundingBox :: (HasCallStack, MonadIO m) => Triangle -> m Box

-- | Computes the coordinates of the midpoint of the given Triangle.
--   
--   The midpoint G is the centroid of the triangle, i.e. the
--   intersection of its medians.
--   
--   Since: 1.2
triangleGetMidpoint :: (HasCallStack, MonadIO m) => Triangle -> m Point3D

-- | Computes the normal vector of the given Triangle.
--   
--   Since: 1.2
triangleGetNormal :: (HasCallStack, MonadIO m) => Triangle -> m Vec3

-- | Computes the plane based on the vertices of the given Triangle.
--   
--   Since: 1.2
triangleGetPlane :: (HasCallStack, MonadIO m) => Triangle -> m Plane

-- | Retrieves the three vertices of the given Triangle and returns
--   their coordinates as Point3D.
--   
--   Since: 1.2
triangleGetPoints :: (HasCallStack, MonadIO m) => Triangle -> m (Point3D, Point3D, Point3D)

-- | Computes the UV coordinates of the given point p.
--   
--   The point p must lie on the same plane as the triangle
--   t; if the point is not coplanar, the result of this
--   function is undefined. If p is Nothing, the
--   point will be set in (0, 0, 0).
--   
--   The UV coordinates will be placed in the res vector:
--   
--   
--   
- 
res.x = u

--   
- 
res.y = v

--   
--   
--   See also: triangleGetBarycoords
--   
--   Since: 1.10
triangleGetUv :: (HasCallStack, MonadIO m) => Triangle -> Maybe Point3D -> Vec2 -> Vec2 -> Vec2 -> m (Bool, Vec2)

-- | Retrieves the three vertices of the given Triangle.
--   
--   Since: 1.2
triangleGetVertices :: (HasCallStack, MonadIO m) => Triangle -> m (Vec3, Vec3, Vec3)

-- | Initializes a Triangle using the three given arrays of floating
--   point values, each representing the coordinates of a point in 3D
--   space.
--   
--   Since: 1.10
triangleInitFromFloat :: (HasCallStack, MonadIO m) => Triangle -> [Float] -> [Float] -> [Float] -> m Triangle

-- | Initializes a Triangle using the three given 3D points.
--   
--   Since: 1.2
triangleInitFromPoint3d :: (HasCallStack, MonadIO m) => Triangle -> Maybe Point3D -> Maybe Point3D -> Maybe Point3D -> m Triangle

-- | Initializes a Triangle using the three given vectors.
--   
--   Since: 1.2
triangleInitFromVec3 :: (HasCallStack, MonadIO m) => Triangle -> Maybe Vec3 -> Maybe Vec3 -> Maybe Vec3 -> m Triangle
instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Graphene.Structs.Triangle.Triangle tag
instance GHC.Classes.Eq GI.Graphene.Structs.Triangle.Triangle
instance Data.GI.Base.BasicTypes.GBoxed GI.Graphene.Structs.Triangle.Triangle
instance Data.GI.Base.Overloading.HasParentTypes GI.Graphene.Structs.Triangle.Triangle
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Graphene.Structs.Triangle.Triangle)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Graphene.Structs.Triangle.Triangle
instance Data.GI.Base.BasicTypes.TypedObject GI.Graphene.Structs.Triangle.Triangle

-- | A sphere, represented by its center and radius.
--   
--   Since: 1.2
module GI.Graphene.Structs.Sphere

-- | Memory-managed wrapper type.
newtype Sphere
Sphere :: ManagedPtr Sphere -> Sphere

-- | Construct a Sphere struct initialized to zero.
newZeroSphere :: MonadIO m => m Sphere

-- | Allocates a new Sphere.
--   
--   The contents of the newly allocated structure are undefined.
--   
--   Since: 1.2
sphereAlloc :: (HasCallStack, MonadIO m) => m Sphere

-- | Checks whether the given point is contained in the
--   volume of a Sphere.
--   
--   Since: 1.2
sphereContainsPoint :: (HasCallStack, MonadIO m) => Sphere -> Point3D -> m Bool

-- | Computes the distance of the given point from the
--   surface of a Sphere.
--   
--   Since: 1.2
sphereDistance :: (HasCallStack, MonadIO m) => Sphere -> Point3D -> m Float

-- | Checks whether two Sphere are equal.
--   
--   Since: 1.2
sphereEqual :: (HasCallStack, MonadIO m) => Sphere -> Sphere -> m Bool

-- | Frees the resources allocated by sphereAlloc.
--   
--   Since: 1.2
sphereFree :: (HasCallStack, MonadIO m) => Sphere -> m ()

-- | Computes the bounding box capable of containing the given
--   Sphere.
--   
--   Since: 1.2
sphereGetBoundingBox :: (HasCallStack, MonadIO m) => Sphere -> m Box

-- | Retrieves the coordinates of the center of a Sphere.
--   
--   Since: 1.2
sphereGetCenter :: (HasCallStack, MonadIO m) => Sphere -> m Point3D

-- | Retrieves the radius of a Sphere.
--   
--   Since: 1.2
sphereGetRadius :: (HasCallStack, MonadIO m) => Sphere -> m Float

-- | Initializes the given Sphere with the given
--   center and radius.
--   
--   Since: 1.2
sphereInit :: (HasCallStack, MonadIO m) => Sphere -> Maybe Point3D -> Float -> m Sphere

-- | Initializes the given Sphere using the given array of 3D
--   coordinates so that the sphere includes them.
--   
--   The center of the sphere can either be specified, or will be center of
--   the 3D volume that encompasses all points.
--   
--   Since: 1.2
sphereInitFromPoints :: (HasCallStack, MonadIO m) => Sphere -> [Point3D] -> Maybe Point3D -> m Sphere

-- | Initializes the given Sphere using the given array of 3D
--   coordinates so that the sphere includes them.
--   
--   The center of the sphere can either be specified, or will be center of
--   the 3D volume that encompasses all vectors.
--   
--   Since: 1.2
sphereInitFromVectors :: (HasCallStack, MonadIO m) => Sphere -> [Vec3] -> Maybe Point3D -> m Sphere

-- | Checks whether the sphere has a zero radius.
--   
--   Since: 1.2
sphereIsEmpty :: (HasCallStack, MonadIO m) => Sphere -> m Bool

-- | Translates the center of the given Sphere using the
--   point coordinates as the delta of the translation.
--   
--   Since: 1.2
sphereTranslate :: (HasCallStack, MonadIO m) => Sphere -> Point3D -> m Sphere
instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Graphene.Structs.Sphere.Sphere tag
instance GHC.Classes.Eq GI.Graphene.Structs.Sphere.Sphere
instance Data.GI.Base.BasicTypes.GBoxed GI.Graphene.Structs.Sphere.Sphere
instance Data.GI.Base.Overloading.HasParentTypes GI.Graphene.Structs.Sphere.Sphere
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Graphene.Structs.Sphere.Sphere)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Graphene.Structs.Sphere.Sphere
instance Data.GI.Base.BasicTypes.TypedObject GI.Graphene.Structs.Sphere.Sphere

-- | A ray emitted from an origin in a given direction.
--   
--   The contents of the graphene_ray_t structure are private, and
--   should not be modified directly.
--   
--   Since: 1.4
module GI.Graphene.Structs.Ray

-- | Memory-managed wrapper type.
newtype Ray
Ray :: ManagedPtr Ray -> Ray

-- | Construct a Ray struct initialized to zero.
newZeroRay :: MonadIO m => m Ray

-- | Allocates a new Ray structure.
--   
--   The contents of the returned structure are undefined.
--   
--   Since: 1.4
rayAlloc :: (HasCallStack, MonadIO m) => m Ray

-- | Checks whether the two given Ray are equal.
--   
--   Since: 1.4
rayEqual :: (HasCallStack, MonadIO m) => Ray -> Ray -> m Bool

-- | Frees the resources allocated by rayAlloc.
--   
--   Since: 1.4
rayFree :: (HasCallStack, MonadIO m) => Ray -> m ()

-- | Computes the point on the given Ray that is closest to the
--   given point p.
--   
--   Since: 1.4
rayGetClosestPointToPoint :: (HasCallStack, MonadIO m) => Ray -> Point3D -> m Point3D

-- | Retrieves the direction of the given Ray.
--   
--   Since: 1.4
rayGetDirection :: (HasCallStack, MonadIO m) => Ray -> m Vec3

-- | Computes the distance of the origin of the given Ray from the
--   given plane.
--   
--   If the ray does not intersect the plane, this function returns
--   INFINITY.
--   
--   Since: 1.4
rayGetDistanceToPlane :: (HasCallStack, MonadIO m) => Ray -> Plane -> m Float

-- | Computes the distance of the closest approach between the given
--   Ray r and the point p.
--   
--   The closest approach to a ray from a point is the distance between the
--   point and the projection of the point on the ray itself.
--   
--   Since: 1.4
rayGetDistanceToPoint :: (HasCallStack, MonadIO m) => Ray -> Point3D -> m Float

-- | Retrieves the origin of the given Ray.
--   
--   Since: 1.4
rayGetOrigin :: (HasCallStack, MonadIO m) => Ray -> m Point3D

-- | Retrieves the coordinates of a point at the distance t
--   along the given Ray.
--   
--   Since: 1.4
rayGetPositionAt :: (HasCallStack, MonadIO m) => Ray -> Float -> m Point3D

-- | Initializes the given Ray using the given
--   origin and direction values.
--   
--   Since: 1.4
rayInit :: (HasCallStack, MonadIO m) => Ray -> Maybe Point3D -> Maybe Vec3 -> m Ray

-- | Initializes the given Ray using the origin and direction values
--   of another Ray.
--   
--   Since: 1.4
rayInitFromRay :: (HasCallStack, MonadIO m) => Ray -> Ray -> m Ray

-- | Initializes the given Ray using the given vectors.
--   
--   Since: 1.4
rayInitFromVec3 :: (HasCallStack, MonadIO m) => Ray -> Maybe Vec3 -> Maybe Vec3 -> m Ray

-- | Intersects the given Ray r with the given
--   Box b.
--   
--   Since: 1.10
rayIntersectBox :: (HasCallStack, MonadIO m) => Ray -> Box -> m (RayIntersectionKind, Float)

-- | Intersects the given Ray r with the given
--   Sphere s.
--   
--   Since: 1.10
rayIntersectSphere :: (HasCallStack, MonadIO m) => Ray -> Sphere -> m (RayIntersectionKind, Float)

-- | Intersects the given Ray r with the given
--   Triangle t.
--   
--   Since: 1.10
rayIntersectTriangle :: (HasCallStack, MonadIO m) => Ray -> Triangle -> m (RayIntersectionKind, Float)

-- | Checks whether the given Ray r intersects the
--   given Box b.
--   
--   See also: rayIntersectBox
--   
--   Since: 1.10
rayIntersectsBox :: (HasCallStack, MonadIO m) => Ray -> Box -> m Bool

-- | Checks if the given Ray r intersects the given
--   Sphere s.
--   
--   See also: rayIntersectSphere
--   
--   Since: 1.10
rayIntersectsSphere :: (HasCallStack, MonadIO m) => Ray -> Sphere -> m Bool

-- | Checks whether the given Ray r intersects the
--   given Triangle b.
--   
--   See also: rayIntersectTriangle
--   
--   Since: 1.10
rayIntersectsTriangle :: (HasCallStack, MonadIO m) => Ray -> Triangle -> m Bool
instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Graphene.Structs.Ray.Ray tag
instance GHC.Classes.Eq GI.Graphene.Structs.Ray.Ray
instance Data.GI.Base.BasicTypes.GBoxed GI.Graphene.Structs.Ray.Ray
instance Data.GI.Base.Overloading.HasParentTypes GI.Graphene.Structs.Ray.Ray
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Graphene.Structs.Ray.Ray)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Graphene.Structs.Ray.Ray
instance Data.GI.Base.BasicTypes.TypedObject GI.Graphene.Structs.Ray.Ray

-- | A quaternion.
--   
--   The contents of the Quaternion structure are private and should
--   never be accessed directly.
--   
--   Since: 1.0
module GI.Graphene.Structs.Quaternion

-- | Memory-managed wrapper type.
newtype Quaternion
Quaternion :: ManagedPtr Quaternion -> Quaternion

-- | Construct a Quaternion struct initialized to zero.
newZeroQuaternion :: MonadIO m => m Quaternion

-- | Adds two Quaternion a and b.
--   
--   Since: 1.10
quaternionAdd :: (HasCallStack, MonadIO m) => Quaternion -> Quaternion -> m Quaternion

-- | Allocates a new Quaternion.
--   
--   The contents of the returned value are undefined.
--   
--   Since: 1.0
quaternionAlloc :: (HasCallStack, MonadIO m) => m Quaternion

-- | Computes the dot product of two Quaternion.
--   
--   Since: 1.0
quaternionDot :: (HasCallStack, MonadIO m) => Quaternion -> Quaternion -> m Float

-- | Checks whether the given quaternions are equal.
--   
--   Since: 1.0
quaternionEqual :: (HasCallStack, MonadIO m) => Quaternion -> Quaternion -> m Bool

-- | Releases the resources allocated by quaternionAlloc.
--   
--   Since: 1.0
quaternionFree :: (HasCallStack, MonadIO m) => Quaternion -> m ()

-- | Initializes a Quaternion using the given four values.
--   
--   Since: 1.0
quaternionInit :: (HasCallStack, MonadIO m) => Quaternion -> Float -> Float -> Float -> Float -> m Quaternion

-- | Initializes a Quaternion using an angle on a
--   specific axis.
--   
--   Since: 1.0
quaternionInitFromAngleVec3 :: (HasCallStack, MonadIO m) => Quaternion -> Float -> Vec3 -> m Quaternion

-- | Initializes a Quaternion using the values of the Euler
--   angles on each axis.
--   
--   See also: quaternionInitFromEuler
--   
--   Since: 1.0
quaternionInitFromAngles :: (HasCallStack, MonadIO m) => Quaternion -> Float -> Float -> Float -> m Quaternion

-- | Initializes a Quaternion using the given Euler.
--   
--   Since: 1.2
quaternionInitFromEuler :: (HasCallStack, MonadIO m) => Quaternion -> Euler -> m Quaternion

-- | Initializes a Quaternion using the rotation components of a
--   transformation matrix.
--   
--   Since: 1.0
quaternionInitFromMatrix :: (HasCallStack, MonadIO m) => Quaternion -> Matrix -> m Quaternion

-- | Initializes a Quaternion with the values from
--   src.
--   
--   Since: 1.0
quaternionInitFromQuaternion :: (HasCallStack, MonadIO m) => Quaternion -> Quaternion -> m Quaternion

-- | Initializes a Quaternion using the values of the Euler
--   angles on each axis.
--   
--   See also: quaternionInitFromEuler
--   
--   Since: 1.0
quaternionInitFromRadians :: (HasCallStack, MonadIO m) => Quaternion -> Float -> Float -> Float -> m Quaternion

-- | Initializes a Quaternion with the values from
--   src.
--   
--   Since: 1.0
quaternionInitFromVec4 :: (HasCallStack, MonadIO m) => Quaternion -> Vec4 -> m Quaternion

-- | Initializes a Quaternion using the identity transformation.
--   
--   Since: 1.0
quaternionInitIdentity :: (HasCallStack, MonadIO m) => Quaternion -> m Quaternion

-- | Inverts a Quaternion, and returns the conjugate quaternion of
--   q.
--   
--   Since: 1.0
quaternionInvert :: (HasCallStack, MonadIO m) => Quaternion -> m Quaternion

-- | Multiplies two Quaternion a and
--   b.
--   
--   Since: 1.10
quaternionMultiply :: (HasCallStack, MonadIO m) => Quaternion -> Quaternion -> m Quaternion

-- | Normalizes a Quaternion.
--   
--   Since: 1.0
quaternionNormalize :: (HasCallStack, MonadIO m) => Quaternion -> m Quaternion

-- | Scales all the elements of a Quaternion q using
--   the given scalar factor.
--   
--   Since: 1.10
quaternionScale :: (HasCallStack, MonadIO m) => Quaternion -> Float -> m Quaternion

-- | Interpolates between the two given quaternions using a spherical
--   linear interpolation, or SLERP, using the given interpolation
--   factor.
--   
--   Since: 1.0
quaternionSlerp :: (HasCallStack, MonadIO m) => Quaternion -> Quaternion -> Float -> m Quaternion

-- | Converts a quaternion into an angle,
--   axis pair.
--   
--   Since: 1.0
quaternionToAngleVec3 :: (HasCallStack, MonadIO m) => Quaternion -> m (Float, Vec3)

-- | Converts a Quaternion to its corresponding rotations on the
--   Euler angles on each axis.
--   
--   Since: 1.2
quaternionToAngles :: (HasCallStack, MonadIO m) => Quaternion -> m (Float, Float, Float)

-- | Converts a quaternion into a transformation matrix expressing the
--   rotation defined by the Quaternion.
--   
--   Since: 1.0
quaternionToMatrix :: (HasCallStack, MonadIO m) => Quaternion -> m Matrix

-- | Converts a Quaternion to its corresponding rotations on the
--   Euler angles on each axis.
--   
--   Since: 1.2
quaternionToRadians :: (HasCallStack, MonadIO m) => Quaternion -> m (Float, Float, Float)

-- | Copies the components of a Quaternion into a Vec4.
--   
--   Since: 1.0
quaternionToVec4 :: (HasCallStack, MonadIO m) => Quaternion -> m Vec4
instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Graphene.Structs.Quaternion.Quaternion tag
instance GHC.Classes.Eq GI.Graphene.Structs.Quaternion.Quaternion
instance Data.GI.Base.BasicTypes.GBoxed GI.Graphene.Structs.Quaternion.Quaternion
instance Data.GI.Base.Overloading.HasParentTypes GI.Graphene.Structs.Quaternion.Quaternion
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Graphene.Structs.Quaternion.Quaternion)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Graphene.Structs.Quaternion.Quaternion
instance Data.GI.Base.BasicTypes.TypedObject GI.Graphene.Structs.Quaternion.Quaternion

-- | A point with three components: X, Y, and Z.
--   
--   Since: 1.0
module GI.Graphene.Structs.Point3D

-- | Memory-managed wrapper type.
newtype Point3D
Point3D :: ManagedPtr Point3D -> Point3D

-- | Construct a Point3D struct initialized to zero.
newZeroPoint3D :: MonadIO m => m Point3D

-- | Allocates a Point3D structure.
--   
--   Since: 1.0
point3DAlloc :: (HasCallStack, MonadIO m) => m Point3D

-- | Computes the cross product of the two given Point3D.
--   
--   Since: 1.0
point3DCross :: (HasCallStack, MonadIO m) => Point3D -> Point3D -> m Point3D

-- | Computes the distance between the two given Point3D.
--   
--   Since: 1.4
point3DDistance :: (HasCallStack, MonadIO m) => Point3D -> Point3D -> m (Float, Vec3)

-- | Computes the dot product of the two given Point3D.
--   
--   Since: 1.0
point3DDot :: (HasCallStack, MonadIO m) => Point3D -> Point3D -> m Float

-- | Checks whether two given points are equal.
--   
--   Since: 1.0
point3DEqual :: (HasCallStack, MonadIO m) => Point3D -> Point3D -> m Bool

-- | Frees the resources allocated via point3DAlloc.
--   
--   Since: 1.0
point3DFree :: (HasCallStack, MonadIO m) => Point3D -> m ()

-- | Initializes a Point3D with the given coordinates.
--   
--   Since: 1.0
point3DInit :: (HasCallStack, MonadIO m) => Point3D -> Float -> Float -> Float -> m Point3D

-- | Initializes a Point3D using the coordinates of another
--   Point3D.
--   
--   Since: 1.0
point3DInitFromPoint :: (HasCallStack, MonadIO m) => Point3D -> Point3D -> m Point3D

-- | Initializes a Point3D using the components of a Vec3.
--   
--   Since: 1.0
point3DInitFromVec3 :: (HasCallStack, MonadIO m) => Point3D -> Vec3 -> m Point3D

-- | Linearly interpolates each component of a and
--   b using the provided factor, and
--   places the result in res.
--   
--   Since: 1.0
point3DInterpolate :: (HasCallStack, MonadIO m) => Point3D -> Point3D -> Double -> m Point3D

-- | Computes the length of the vector represented by the coordinates of
--   the given Point3D.
--   
--   Since: 1.0
point3DLength :: (HasCallStack, MonadIO m) => Point3D -> m Float

-- | Checks whether the two points are near each other, within an
--   epsilon factor.
--   
--   Since: 1.0
point3DNear :: (HasCallStack, MonadIO m) => Point3D -> Point3D -> Float -> m Bool

-- | Computes the normalization of the vector represented by the
--   coordinates of the given Point3D.
--   
--   Since: 1.0
point3DNormalize :: (HasCallStack, MonadIO m) => Point3D -> m Point3D

-- | Normalizes the coordinates of a Point3D using the given
--   viewport and clipping planes.
--   
--   The coordinates of the resulting Point3D will be in the [ -1, 1
--   ] range.
--   
--   Since: 1.4
point3DNormalizeViewport :: (HasCallStack, MonadIO m) => Point3D -> Rect -> Float -> Float -> m Point3D

-- | Scales the coordinates of the given Point3D by the given
--   factor.
--   
--   Since: 1.0
point3DScale :: (HasCallStack, MonadIO m) => Point3D -> Float -> m Point3D

-- | Stores the coordinates of a Point3D into a Vec3.
--   
--   Since: 1.0
point3DToVec3 :: (HasCallStack, MonadIO m) => Point3D -> m Vec3

-- | Retrieves a constant point with all three coordinates set to 0.
--   
--   Since: 1.0
point3DZero :: (HasCallStack, MonadIO m) => m Point3D

-- | Get the value of the “x” field. When overloading is
--   enabled, this is equivalent to
--   
--   
--   get point3D #x
--   
getPoint3DX :: MonadIO m => Point3D -> m Float

-- | Set the value of the “x” field. When overloading is
--   enabled, this is equivalent to
--   
--   
--   set point3D [ #x := value ]
--   
setPoint3DX :: MonadIO m => Point3D -> Float -> m ()

-- | Get the value of the “y” field. When overloading is
--   enabled, this is equivalent to
--   
--   
--   get point3D #y
--   
getPoint3DY :: MonadIO m => Point3D -> m Float

-- | Set the value of the “y” field. When overloading is
--   enabled, this is equivalent to
--   
--   
--   set point3D [ #y := value ]
--   
setPoint3DY :: MonadIO m => Point3D -> Float -> m ()

-- | Get the value of the “z” field. When overloading is
--   enabled, this is equivalent to
--   
--   
--   get point3D #z
--   
getPoint3DZ :: MonadIO m => Point3D -> m Float

-- | Set the value of the “z” field. When overloading is
--   enabled, this is equivalent to
--   
--   
--   set point3D [ #z := value ]
--   
setPoint3DZ :: MonadIO m => Point3D -> Float -> m ()
instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Graphene.Structs.Point3D.Point3D tag
instance GHC.Classes.Eq GI.Graphene.Structs.Point3D.Point3D
instance Data.GI.Base.BasicTypes.GBoxed GI.Graphene.Structs.Point3D.Point3D
instance Data.GI.Base.Overloading.HasParentTypes GI.Graphene.Structs.Point3D.Point3D
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Graphene.Structs.Point3D.Point3D)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Graphene.Structs.Point3D.Point3D
instance Data.GI.Base.BasicTypes.TypedObject GI.Graphene.Structs.Point3D.Point3D

-- | A 2D plane that extends infinitely in a 3D volume.
--   
--   The contents of the graphene_plane_t are private, and should
--   not be modified directly.
--   
--   Since: 1.2
module GI.Graphene.Structs.Plane

-- | Memory-managed wrapper type.
newtype Plane
Plane :: ManagedPtr Plane -> Plane

-- | Construct a Plane struct initialized to zero.
newZeroPlane :: MonadIO m => m Plane

-- | Allocates a new Plane structure.
--   
--   The contents of the returned structure are undefined.
--   
--   Since: 1.2
planeAlloc :: (HasCallStack, MonadIO m) => m Plane

-- | Computes the distance of point from a Plane.
--   
--   Since: 1.2
planeDistance :: (HasCallStack, MonadIO m) => Plane -> Point3D -> m Float

-- | Checks whether the two given Plane are equal.
--   
--   Since: 1.2
planeEqual :: (HasCallStack, MonadIO m) => Plane -> Plane -> m Bool

-- | Frees the resources allocated by planeAlloc.
--   
--   Since: 1.2
planeFree :: (HasCallStack, MonadIO m) => Plane -> m ()

-- | Retrieves the distance along the normal vector of the given
--   Plane from the origin.
--   
--   Since: 1.2
planeGetConstant :: (HasCallStack, MonadIO m) => Plane -> m Float

-- | Retrieves the normal vector pointing towards the origin of the given
--   Plane.
--   
--   Since: 1.2
planeGetNormal :: (HasCallStack, MonadIO m) => Plane -> m Vec3

-- | Initializes the given Plane using the given
--   normal vector and constant values.
--   
--   Since: 1.2
planeInit :: (HasCallStack, MonadIO m) => Plane -> Maybe Vec3 -> Float -> m Plane

-- | Initializes the given Plane using the normal vector and
--   constant of another Plane.
--   
--   Since: 1.2
planeInitFromPlane :: (HasCallStack, MonadIO m) => Plane -> Plane -> m Plane

-- | Initializes the given Plane using the given normal vector and
--   an arbitrary co-planar point.
--   
--   Since: 1.2
planeInitFromPoint :: (HasCallStack, MonadIO m) => Plane -> Vec3 -> Point3D -> m Plane

-- | Initializes the given Plane using the 3 provided co-planar
--   points.
--   
--   The winding order is counter-clockwise, and determines which direction
--   the normal vector will point.
--   
--   Since: 1.2
planeInitFromPoints :: (HasCallStack, MonadIO m) => Plane -> Point3D -> Point3D -> Point3D -> m Plane

-- | Initializes the given Plane using the components of the given
--   Vec4 vector.
--   
--   Since: 1.2
planeInitFromVec4 :: (HasCallStack, MonadIO m) => Plane -> Vec4 -> m Plane

-- | Negates the normal vector and constant of a Plane, effectively
--   mirroring the plane across the origin.
--   
--   Since: 1.2
planeNegate :: (HasCallStack, MonadIO m) => Plane -> m Plane

-- | Normalizes the vector of the given Plane, and adjusts the
--   constant accordingly.
--   
--   Since: 1.2
planeNormalize :: (HasCallStack, MonadIO m) => Plane -> m Plane

-- | Transforms a Plane p using the given
--   matrix and normalMatrix.
--   
--   If normalMatrix is Nothing, a transformation
--   matrix for the plane normal will be computed from
--   matrix. If you are transforming multiple planes using
--   the same matrix it's recommended to compute the normal
--   matrix beforehand to avoid incurring in the cost of recomputing it
--   every time.
--   
--   Since: 1.10
planeTransform :: (HasCallStack, MonadIO m) => Plane -> Matrix -> Maybe Matrix -> m Plane
instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Graphene.Structs.Plane.Plane tag
instance GHC.Classes.Eq GI.Graphene.Structs.Plane.Plane
instance Data.GI.Base.BasicTypes.GBoxed GI.Graphene.Structs.Plane.Plane
instance Data.GI.Base.Overloading.HasParentTypes GI.Graphene.Structs.Plane.Plane
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Graphene.Structs.Plane.Plane)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Graphene.Structs.Plane.Plane
instance Data.GI.Base.BasicTypes.TypedObject GI.Graphene.Structs.Plane.Plane

-- | A structure capable of holding a 4x4 matrix.
--   
--   The contents of the Matrix structure are private and should
--   never be accessed directly.
module GI.Graphene.Structs.Matrix

-- | Memory-managed wrapper type.
newtype Matrix
Matrix :: ManagedPtr Matrix -> Matrix

-- | Construct a Matrix struct initialized to zero.
newZeroMatrix :: MonadIO m => m Matrix

-- | Allocates a new Matrix.
--   
--   Since: 1.0
matrixAlloc :: (HasCallStack, MonadIO m) => m Matrix

-- | Decomposes a transformation matrix into its component transformations.
--   
--   The algorithm for decomposing a matrix is taken from the CSS3
--   Transforms specification; specifically, the decomposition code is
--   based on the equivalent code published in "Graphics Gems II", edited
--   by Jim Arvo, and available online.
matrixDecompose :: (HasCallStack, MonadIO m) => Matrix -> m (Bool, Vec3, Vec3, Quaternion, Vec3, Vec4)

-- | Computes the determinant of the given matrix.
--   
--   Since: 1.0
matrixDeterminant :: (HasCallStack, MonadIO m) => Matrix -> m Float

-- | Checks whether the two given Matrix matrices are equal.
--   
--   Since: 1.10
matrixEqual :: (HasCallStack, MonadIO m) => Matrix -> Matrix -> m Bool

-- | Checks whether the two given Matrix matrices are byte-by-byte
--   equal.
--   
--   While this function is faster than matrixEqual, it can also
--   return false negatives, so it should be used in conjuction with either
--   matrixEqual or 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 :: (HasCallStack, MonadIO m) => Matrix -> Matrix -> m Bool

-- | Frees the resources allocated by matrixAlloc.
--   
--   Since: 1.0
matrixFree :: (HasCallStack, MonadIO m) => Matrix -> m ()

-- | Retrieves the given row vector at index_ inside a
--   matrix.
--   
--   Since: 1.0
matrixGetRow :: (HasCallStack, MonadIO m) => Matrix -> Word32 -> m Vec4

-- | Retrieves the value at the given row and
--   col index.
--   
--   Since: 1.0
matrixGetValue :: (HasCallStack, MonadIO m) => Matrix -> Word32 -> Word32 -> m Float

-- | Retrieves the scaling factor on the X axis in m.
--   
--   Since: 1.0
matrixGetXScale :: (HasCallStack, MonadIO m) => Matrix -> m Float

-- | Retrieves the translation component on the X axis from
--   m.
--   
--   Since: 1.10
matrixGetXTranslation :: (HasCallStack, MonadIO m) => Matrix -> m Float

-- | Retrieves the scaling factor on the Y axis in m.
--   
--   Since: 1.0
matrixGetYScale :: (HasCallStack, MonadIO m) => Matrix -> m Float

-- | Retrieves the translation component on the Y axis from
--   m.
--   
--   Since: 1.10
matrixGetYTranslation :: (HasCallStack, MonadIO m) => Matrix -> m Float

-- | Retrieves the scaling factor on the Z axis in m.
--   
--   Since: 1.0
matrixGetZScale :: (HasCallStack, MonadIO m) => Matrix -> m Float

-- | Retrieves the translation component on the Z axis from
--   m.
--   
--   Since: 1.10
matrixGetZTranslation :: (HasCallStack, MonadIO m) => Matrix -> m Float

-- | Initializes a 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 Matrix.
--   
--   Since: 1.0
matrixInitFrom2d :: (HasCallStack, MonadIO m) => Matrix -> Double -> Double -> Double -> Double -> Double -> Double -> m Matrix

-- | Initializes a Matrix with the given array of floating point
--   values.
--   
--   Since: 1.0
matrixInitFromFloat :: (HasCallStack, MonadIO m) => Matrix -> [Float] -> m Matrix

-- | Initializes a Matrix using the values of the given matrix.
--   
--   Since: 1.0
matrixInitFromMatrix :: (HasCallStack, MonadIO m) => Matrix -> Matrix -> m Matrix

-- | Initializes a Matrix with the given four row vectors.
--   
--   Since: 1.0
matrixInitFromVec4 :: (HasCallStack, MonadIO m) => Matrix -> Vec4 -> Vec4 -> Vec4 -> Vec4 -> m Matrix

-- | Initializes a Matrix compatible with Frustum.
--   
--   See also: frustumInitFromMatrix
--   
--   Since: 1.2
matrixInitFrustum :: (HasCallStack, MonadIO m) => Matrix -> Float -> Float -> Float -> Float -> Float -> Float -> m Matrix

-- | Initializes a Matrix with the identity matrix.
--   
--   Since: 1.0
matrixInitIdentity :: (HasCallStack, MonadIO m) => Matrix -> m Matrix

-- | Initializes a 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 :: (HasCallStack, MonadIO m) => Matrix -> Vec3 -> Vec3 -> Vec3 -> m Matrix

-- | Initializes a Matrix with an orthographic projection.
--   
--   Since: 1.0
matrixInitOrtho :: (HasCallStack, MonadIO m) => Matrix -> Float -> Float -> Float -> Float -> Float -> Float -> m Matrix

-- | Initializes a Matrix with a perspective projection.
--   
--   Since: 1.0
matrixInitPerspective :: (HasCallStack, MonadIO m) => Matrix -> Float -> Float -> Float -> Float -> m Matrix

-- | Initializes m to represent a rotation of
--   angle degrees on the axis represented by the
--   axis vector.
--   
--   Since: 1.0
matrixInitRotate :: (HasCallStack, MonadIO m) => Matrix -> Float -> Vec3 -> m Matrix

-- | Initializes a Matrix with the given scaling factors.
--   
--   Since: 1.0
matrixInitScale :: (HasCallStack, MonadIO m) => Matrix -> Float -> Float -> Float -> m Matrix

-- | Initializes a Matrix with a skew transformation with the given
--   factors.
--   
--   Since: 1.0
matrixInitSkew :: (HasCallStack, MonadIO m) => Matrix -> Float -> Float -> m Matrix

-- | Initializes a Matrix with a translation to the given
--   coordinates.
--   
--   Since: 1.0
matrixInitTranslate :: (HasCallStack, MonadIO m) => Matrix -> Point3D -> m Matrix

-- | Linearly interpolates the two given 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 :: (HasCallStack, MonadIO m) => Matrix -> Matrix -> Double -> m Matrix

-- | Inverts the given matrix.
--   
--   Since: 1.0
matrixInverse :: (HasCallStack, MonadIO m) => Matrix -> m (Bool, Matrix)

-- | Checks whether the given Matrix is compatible with an a 2D
--   affine transformation matrix.
--   
--   Since: 1.0
matrixIs2d :: (HasCallStack, MonadIO m) => Matrix -> m Bool

-- | Checks whether a Matrix has a visible back face.
--   
--   Since: 1.0
matrixIsBackfaceVisible :: (HasCallStack, MonadIO m) => Matrix -> m Bool

-- | Checks whether the given Matrix is the identity matrix.
--   
--   Since: 1.0
matrixIsIdentity :: (HasCallStack, MonadIO m) => Matrix -> m Bool

-- | Checks whether a matrix is singular.
--   
--   Since: 1.0
matrixIsSingular :: (HasCallStack, MonadIO m) => Matrix -> m Bool

-- | Multiplies two 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 :: (HasCallStack, MonadIO m) => Matrix -> Matrix -> m Matrix

-- | Compares the two given Matrix matrices and checks whether their
--   values are within the given epsilon of each other.
--   
--   Since: 1.10
matrixNear :: (HasCallStack, MonadIO m) => Matrix -> Matrix -> Float -> m Bool

-- | Normalizes the given Matrix.
--   
--   Since: 1.0
matrixNormalize :: (HasCallStack, MonadIO m) => Matrix -> m Matrix

-- | Applies a perspective of depth to the matrix.
--   
--   Since: 1.0
matrixPerspective :: (HasCallStack, MonadIO m) => Matrix -> Float -> m Matrix

-- | 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 :: (HasCallStack, MonadIO m) => Matrix -> m ()

-- | Projects a Point using the matrix m.
--   
--   Since: 1.0
matrixProjectPoint :: (HasCallStack, MonadIO m) => Matrix -> Point -> m Point

-- | Projects all corners of a Rect using the given matrix.
--   
--   See also: matrixProjectPoint
--   
--   Since: 1.2
matrixProjectRect :: (HasCallStack, MonadIO m) => Matrix -> Rect -> m Quad

-- | Projects a 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 :: (HasCallStack, MonadIO m) => Matrix -> Rect -> m Rect

-- | Adds a rotation transformation to m, using the given
--   angle and axis vector.
--   
--   This is the equivalent of calling matrixInitRotate and then
--   multiplying the matrix m with the rotation matrix.
--   
--   Since: 1.0
matrixRotate :: (HasCallStack, MonadIO m) => Matrix -> Float -> Vec3 -> m ()

-- | Adds a rotation transformation to m, using the given
--   Euler.
--   
--   Since: 1.2
matrixRotateEuler :: (HasCallStack, MonadIO m) => Matrix -> Euler -> m ()

-- | Adds a rotation transformation to m, using the given
--   Quaternion.
--   
--   This is the equivalent of calling quaternionToMatrix and then
--   multiplying m with the rotation matrix.
--   
--   Since: 1.2
matrixRotateQuaternion :: (HasCallStack, MonadIO m) => Matrix -> Quaternion -> m ()

-- | Adds a rotation transformation around the X axis to m,
--   using the given angle.
--   
--   See also: matrixRotate
--   
--   Since: 1.0
matrixRotateX :: (HasCallStack, MonadIO m) => Matrix -> Float -> m ()

-- | Adds a rotation transformation around the Y axis to m,
--   using the given angle.
--   
--   See also: matrixRotate
--   
--   Since: 1.0
matrixRotateY :: (HasCallStack, MonadIO m) => Matrix -> Float -> m ()

-- | Adds a rotation transformation around the Z axis to m,
--   using the given angle.
--   
--   See also: matrixRotate
--   
--   Since: 1.0
matrixRotateZ :: (HasCallStack, MonadIO m) => Matrix -> Float -> m ()

-- | Adds a scaling transformation to m, using the three
--   given factors.
--   
--   This is the equivalent of calling matrixInitScale and then
--   multiplying the matrix m with the scale matrix.
--   
--   Since: 1.0
matrixScale :: (HasCallStack, MonadIO m) => Matrix -> Float -> Float -> Float -> m ()

-- | Adds a skew of factor on the X and Y axis to the given
--   matrix.
--   
--   Since: 1.0
matrixSkewXy :: (HasCallStack, MonadIO m) => Matrix -> Float -> m ()

-- | Adds a skew of factor on the X and Z axis to the given
--   matrix.
--   
--   Since: 1.0
matrixSkewXz :: (HasCallStack, MonadIO m) => Matrix -> Float -> m ()

-- | Adds a skew of factor on the Y and Z axis to the given
--   matrix.
--   
--   Since: 1.0
matrixSkewYz :: (HasCallStack, MonadIO m) => Matrix -> Float -> m ()

-- | Converts a 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 Matrix and an
--   affine matrix type from other libraries.
--   
--   Since: 1.0
matrixTo2d :: (HasCallStack, MonadIO m) => Matrix -> m (Bool, Double, Double, Double, Double, Double, Double)

-- | Transforms each corner of a Rect using the given matrix
--   m.
--   
--   The result is the axis aligned bounding rectangle containing the
--   coplanar quadrilateral.
--   
--   See also: matrixTransformPoint
--   
--   Since: 1.0
matrixTransformBounds :: (HasCallStack, MonadIO m) => Matrix -> Rect -> m Rect

-- | Transforms the vertices of a Box using the given matrix
--   m.
--   
--   The result is the axis aligned bounding box containing the transformed
--   vertices.
--   
--   Since: 1.2
matrixTransformBox :: (HasCallStack, MonadIO m) => Matrix -> Box -> m Box

-- | Transforms the given Point using the matrix m.
--   
--   Unlike matrixTransformVec3, this function will take into
--   account the fourth row vector of the Matrix when computing the
--   dot product of each row vector of the matrix.
--   
--   See also: graphene_simd4x4f_point3_mul()
--   
--   Since: 1.0
matrixTransformPoint :: (HasCallStack, MonadIO m) => Matrix -> Point -> m Point

-- | Transforms the given Point3D using the matrix
--   m.
--   
--   Unlike matrixTransformVec3, this function will take into
--   account the fourth row vector of the Matrix when computing the
--   dot product of each row vector of the matrix.
--   
--   See also: graphene_simd4x4f_point3_mul()
--   
--   Since: 1.2
matrixTransformPoint3d :: (HasCallStack, MonadIO m) => Matrix -> Point3D -> m Point3D

-- | Transform a Ray using the given matrix m.
--   
--   Since: 1.4
matrixTransformRay :: (HasCallStack, MonadIO m) => Matrix -> Ray -> m Ray

-- | Transforms each corner of a Rect using the given matrix
--   m.
--   
--   The result is a coplanar quadrilateral.
--   
--   See also: matrixTransformPoint
--   
--   Since: 1.0
matrixTransformRect :: (HasCallStack, MonadIO m) => Matrix -> Rect -> m Quad

-- | Transforms a Sphere using the given matrix m.
--   The result is the bounding sphere containing the transformed sphere.
--   
--   Since: 1.2
matrixTransformSphere :: (HasCallStack, MonadIO m) => Matrix -> Sphere -> m Sphere

-- | Transforms the given 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 :: (HasCallStack, MonadIO m) => Matrix -> Vec3 -> m Vec3

-- | Transforms the given Vec4 using the matrix m.
--   
--   See also: graphene_simd4x4f_vec4_mul()
--   
--   Since: 1.0
matrixTransformVec4 :: (HasCallStack, MonadIO m) => Matrix -> Vec4 -> m Vec4

-- | Adds a translation transformation to m using the
--   coordinates of the given Point3D.
--   
--   This is the equivalent of calling matrixInitTranslate and then
--   multiplying m with the translation matrix.
--   
--   Since: 1.0
matrixTranslate :: (HasCallStack, MonadIO m) => Matrix -> Point3D -> m ()

-- | Transposes the given matrix.
--   
--   Since: 1.0
matrixTranspose :: (HasCallStack, MonadIO m) => Matrix -> m Matrix

-- | Unprojects the given point using the
--   projection matrix and a modelview
--   matrix.
--   
--   Since: 1.2
matrixUnprojectPoint3d :: (HasCallStack, MonadIO m) => Matrix -> Matrix -> Point3D -> m Point3D

-- | Undoes the transformation on the corners of a Rect using the
--   given matrix, within the given axis aligned rectangular
--   bounds.
--   
--   Since: 1.0
matrixUntransformBounds :: (HasCallStack, MonadIO m) => Matrix -> Rect -> Rect -> m Rect

-- | Undoes the transformation of a Point using the given matrix,
--   within the given axis aligned rectangular bounds.
--   
--   Since: 1.0
matrixUntransformPoint :: (HasCallStack, MonadIO m) => Matrix -> Point -> Rect -> m (Bool, Point)
instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Graphene.Structs.Matrix.Matrix tag
instance GHC.Classes.Eq GI.Graphene.Structs.Matrix.Matrix
instance Data.GI.Base.BasicTypes.GBoxed GI.Graphene.Structs.Matrix.Matrix
instance Data.GI.Base.Overloading.HasParentTypes GI.Graphene.Structs.Matrix.Matrix
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Graphene.Structs.Matrix.Matrix)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Graphene.Structs.Matrix.Matrix
instance Data.GI.Base.BasicTypes.TypedObject GI.Graphene.Structs.Matrix.Matrix

-- | A 3D volume delimited by 2D clip planes.
--   
--   The contents of the graphene_frustum_t are private, and
--   should not be modified directly.
--   
--   Since: 1.2
module GI.Graphene.Structs.Frustum

-- | Memory-managed wrapper type.
newtype Frustum
Frustum :: ManagedPtr Frustum -> Frustum

-- | Construct a Frustum struct initialized to zero.
newZeroFrustum :: MonadIO m => m Frustum

-- | Allocates a new Frustum structure.
--   
--   The contents of the returned structure are undefined.
--   
--   Since: 1.2
frustumAlloc :: (HasCallStack, MonadIO m) => m Frustum

-- | Checks whether a point is inside the volume defined by the given
--   Frustum.
--   
--   Since: 1.2
frustumContainsPoint :: (HasCallStack, MonadIO m) => Frustum -> Point3D -> m Bool

-- | Checks whether the two given Frustum are equal.
--   
--   Since: 1.6
frustumEqual :: (HasCallStack, MonadIO m) => Frustum -> Frustum -> m Bool

-- | Frees the resources allocated by frustumAlloc.
--   
--   Since: 1.2
frustumFree :: (HasCallStack, MonadIO m) => Frustum -> m ()

-- | Initializes the given Frustum using the provided clipping
--   planes.
--   
--   Since: 1.2
frustumInit :: (HasCallStack, MonadIO m) => Frustum -> Plane -> Plane -> Plane -> Plane -> Plane -> Plane -> m Frustum

-- | Initializes the given Frustum using the clipping planes of
--   another Frustum.
--   
--   Since: 1.2
frustumInitFromFrustum :: (HasCallStack, MonadIO m) => Frustum -> Frustum -> m Frustum

-- | Initializes a Frustum using the given matrix.
--   
--   Since: 1.2
frustumInitFromMatrix :: (HasCallStack, MonadIO m) => Frustum -> Matrix -> m Frustum

-- | Checks whether the given box intersects a plane of a
--   Frustum.
--   
--   Since: 1.2
frustumIntersectsBox :: (HasCallStack, MonadIO m) => Frustum -> Box -> m Bool

-- | Checks whether the given sphere intersects a plane of
--   a Frustum.
--   
--   Since: 1.2
frustumIntersectsSphere :: (HasCallStack, MonadIO m) => Frustum -> Sphere -> m Bool
instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Graphene.Structs.Frustum.Frustum tag
instance GHC.Classes.Eq GI.Graphene.Structs.Frustum.Frustum
instance Data.GI.Base.BasicTypes.GBoxed GI.Graphene.Structs.Frustum.Frustum
instance Data.GI.Base.Overloading.HasParentTypes GI.Graphene.Structs.Frustum.Frustum
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Graphene.Structs.Frustum.Frustum)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Graphene.Structs.Frustum.Frustum
instance Data.GI.Base.BasicTypes.TypedObject GI.Graphene.Structs.Frustum.Frustum

-- | Describe a rotation using Euler angles.
--   
--   The contents of the Euler structure are private and should
--   never be accessed directly.
--   
--   Since: 1.2
module GI.Graphene.Structs.Euler

-- | Memory-managed wrapper type.
newtype Euler
Euler :: ManagedPtr Euler -> Euler

-- | Construct a Euler struct initialized to zero.
newZeroEuler :: MonadIO m => m Euler

-- | Allocates a new Euler.
--   
--   The contents of the returned structure are undefined.
--   
--   Since: 1.2
eulerAlloc :: (HasCallStack, MonadIO m) => m Euler

-- | Checks if two Euler are equal.
--   
--   Since: 1.2
eulerEqual :: (HasCallStack, MonadIO m) => Euler -> Euler -> m Bool

-- | Frees the resources allocated by eulerAlloc.
--   
--   Since: 1.2
eulerFree :: (HasCallStack, MonadIO m) => Euler -> m ()

-- | Retrieves the first component of the Euler angle vector, depending on
--   the order of rotation.
--   
--   See also: eulerGetX
--   
--   Since: 1.10
eulerGetAlpha :: (HasCallStack, MonadIO m) => Euler -> m Float

-- | Retrieves the second component of the Euler angle vector, depending on
--   the order of rotation.
--   
--   See also: eulerGetY
--   
--   Since: 1.10
eulerGetBeta :: (HasCallStack, MonadIO m) => Euler -> m Float

-- | Retrieves the third component of the Euler angle vector, depending on
--   the order of rotation.
--   
--   See also: eulerGetZ
--   
--   Since: 1.10
eulerGetGamma :: (HasCallStack, MonadIO m) => Euler -> m Float

-- | Retrieves the order used to apply the rotations described in the
--   Euler structure, when converting to and from other structures,
--   like Quaternion and Matrix.
--   
--   This function does not return the EulerOrderDefault enumeration
--   value; it will return the effective order of rotation instead.
--   
--   Since: 1.2
eulerGetOrder :: (HasCallStack, MonadIO m) => Euler -> m EulerOrder

-- | Retrieves the rotation angle on the X axis, in degrees.
--   
--   Since: 1.2
eulerGetX :: (HasCallStack, MonadIO m) => Euler -> m Float

-- | Retrieves the rotation angle on the Y axis, in degrees.
--   
--   Since: 1.2
eulerGetY :: (HasCallStack, MonadIO m) => Euler -> m Float

-- | Retrieves the rotation angle on the Z axis, in degrees.
--   
--   Since: 1.2
eulerGetZ :: (HasCallStack, MonadIO m) => Euler -> m Float

-- | Initializes a Euler using the given angles.
--   
--   The order of the rotations is EulerOrderDefault.
--   
--   Since: 1.2
eulerInit :: (HasCallStack, MonadIO m) => Euler -> Float -> Float -> Float -> m Euler

-- | Initializes a Euler using the angles and order of another
--   Euler.
--   
--   If the Euler src is Nothing, this
--   function is equivalent to calling eulerInit with all angles set
--   to 0.
--   
--   Since: 1.2
eulerInitFromEuler :: (HasCallStack, MonadIO m) => Euler -> Maybe Euler -> m Euler

-- | Initializes a Euler using the given rotation matrix.
--   
--   If the Matrix m is Nothing, the
--   Euler will be initialized with all angles set to 0.
--   
--   Since: 1.2
eulerInitFromMatrix :: (HasCallStack, MonadIO m) => Euler -> Maybe Matrix -> EulerOrder -> m Euler

-- | Initializes a Euler using the given normalized quaternion.
--   
--   If the Quaternion q is Nothing, the
--   Euler will be initialized with all angles set to 0.
--   
--   Since: 1.2
eulerInitFromQuaternion :: (HasCallStack, MonadIO m) => Euler -> Maybe Quaternion -> EulerOrder -> m Euler

-- | Initializes a Euler using the given angles and order of
--   rotation.
--   
--   Since: 1.10
eulerInitFromRadians :: (HasCallStack, MonadIO m) => Euler -> Float -> Float -> Float -> EulerOrder -> m Euler

-- | Initializes a Euler using the angles contained in a
--   Vec3.
--   
--   If the Vec3 v is Nothing, the
--   Euler will be initialized with all angles set to 0.
--   
--   Since: 1.2
eulerInitFromVec3 :: (HasCallStack, MonadIO m) => Euler -> Maybe Vec3 -> EulerOrder -> m Euler

-- | Initializes a Euler with the given angles and
--   order.
--   
--   Since: 1.2
eulerInitWithOrder :: (HasCallStack, MonadIO m) => Euler -> Float -> Float -> Float -> EulerOrder -> m Euler

-- | Reorders a Euler using order.
--   
--   This function is equivalent to creating a Quaternion from the
--   given Euler, and then converting the quaternion into another
--   Euler.
--   
--   Since: 1.2
eulerReorder :: (HasCallStack, MonadIO m) => Euler -> EulerOrder -> m Euler

-- | Converts a Euler into a transformation matrix expressing the
--   extrinsic composition of rotations described by the Euler angles.
--   
--   The rotations are applied over the reference frame axes in the order
--   associated with the Euler; for instance, if the order used to
--   initialize e is EulerOrderXyz:
--   
--   
--   
- the first rotation moves the body around the X axis with an angle
--   φ
--   
- the second rotation moves the body around the Y axis with an angle
--   of ϑ
--   
- the third rotation moves the body around the Z axis with an angle
--   of ψ
--   
--   
--   The rotation sign convention is right-handed, to preserve
--   compatibility between Euler-based, quaternion-based, and
--   angle-axis-based rotations.
--   
--   Since: 1.2
eulerToMatrix :: (HasCallStack, MonadIO m) => Euler -> m Matrix

-- | Converts a Euler into a Quaternion.
--   
--   Since: 1.10
eulerToQuaternion :: (HasCallStack, MonadIO m) => Euler -> m Quaternion

-- | Retrieves the angles of a Euler and initializes a Vec3
--   with them.
--   
--   Since: 1.2
eulerToVec3 :: (HasCallStack, MonadIO m) => Euler -> m Vec3
instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Graphene.Structs.Euler.Euler tag
instance GHC.Classes.Eq GI.Graphene.Structs.Euler.Euler
instance Data.GI.Base.BasicTypes.GBoxed GI.Graphene.Structs.Euler.Euler
instance Data.GI.Base.Overloading.HasParentTypes GI.Graphene.Structs.Euler.Euler
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Graphene.Structs.Euler.Euler)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Graphene.Structs.Euler.Euler
instance Data.GI.Base.BasicTypes.TypedObject GI.Graphene.Structs.Euler.Euler

-- | A 3D box, described as the volume between a minimum and a maximum
--   vertices.
--   
--   Since: 1.2
module GI.Graphene.Structs.Box

-- | Memory-managed wrapper type.
newtype Box
Box :: ManagedPtr Box -> Box

-- | Construct a Box struct initialized to zero.
newZeroBox :: MonadIO m => m Box

-- | Allocates a new Box.
--   
--   The contents of the returned structure are undefined.
--   
--   Since: 1.2
boxAlloc :: (HasCallStack, MonadIO m) => m Box

-- | Checks whether the Box a contains the given
--   Box b.
--   
--   Since: 1.2
boxContainsBox :: (HasCallStack, MonadIO m) => Box -> Box -> m Bool

-- | Checks whether box contains the given
--   point.
--   
--   Since: 1.2
boxContainsPoint :: (HasCallStack, MonadIO m) => Box -> Point3D -> m Bool

-- | A degenerate Box that can only be expanded.
--   
--   The returned value is owned by Graphene and should not be modified or
--   freed.
--   
--   Since: 1.2
boxEmpty :: (HasCallStack, MonadIO m) => m Box

-- | Checks whether the two given boxes are equal.
--   
--   Since: 1.2
boxEqual :: (HasCallStack, MonadIO m) => Box -> Box -> m Bool

-- | Expands the dimensions of box to include the
--   coordinates at point.
--   
--   Since: 1.2
boxExpand :: (HasCallStack, MonadIO m) => Box -> Point3D -> m Box

-- | Expands the dimensions of box by the given
--   scalar value.
--   
--   If scalar is positive, the Box will grow; if
--   scalar is negative, the Box will shrink.
--   
--   Since: 1.2
boxExpandScalar :: (HasCallStack, MonadIO m) => Box -> Float -> m Box

-- | Expands the dimensions of box to include the
--   coordinates of the given vector.
--   
--   Since: 1.2
boxExpandVec3 :: (HasCallStack, MonadIO m) => Box -> Vec3 -> m Box

-- | Frees the resources allocated by boxAlloc.
--   
--   Since: 1.2
boxFree :: (HasCallStack, MonadIO m) => Box -> m ()

-- | Computes the bounding Sphere capable of containing the given
--   Box.
--   
--   Since: 1.2
boxGetBoundingSphere :: (HasCallStack, MonadIO m) => Box -> m Sphere

-- | Retrieves the coordinates of the center of a Box.
--   
--   Since: 1.2
boxGetCenter :: (HasCallStack, MonadIO m) => Box -> m Point3D

-- | Retrieves the size of the box on the Z axis.
--   
--   Since: 1.2
boxGetDepth :: (HasCallStack, MonadIO m) => Box -> m Float

-- | Retrieves the size of the box on the Y axis.
--   
--   Since: 1.2
boxGetHeight :: (HasCallStack, MonadIO m) => Box -> m Float

-- | Retrieves the coordinates of the maximum point of the given
--   Box.
--   
--   Since: 1.2
boxGetMax :: (HasCallStack, MonadIO m) => Box -> m Point3D

-- | Retrieves the coordinates of the minimum point of the given
--   Box.
--   
--   Since: 1.2
boxGetMin :: (HasCallStack, MonadIO m) => Box -> m Point3D

-- | Retrieves the size of the box on all three axes, and stores it into
--   the given size vector.
--   
--   Since: 1.2
boxGetSize :: (HasCallStack, MonadIO m) => Box -> m Vec3

-- | Retrieves the size of the box on the X axis.
--   
--   Since: 1.2
boxGetWidth :: (HasCallStack, MonadIO m) => Box -> m Float

-- | A degenerate Box that cannot be expanded.
--   
--   The returned value is owned by Graphene and should not be modified or
--   freed.
--   
--   Since: 1.2
boxInfinite :: (HasCallStack, MonadIO m) => m Box

-- | Initializes the given Box with two vertices.
--   
--   Since: 1.2
boxInit :: (HasCallStack, MonadIO m) => Box -> Maybe Point3D -> Maybe Point3D -> m Box

-- | Initializes the given Box with the vertices of another
--   Box.
--   
--   Since: 1.2
boxInitFromBox :: (HasCallStack, MonadIO m) => Box -> Box -> m Box

-- | Initializes the given Box with the given array of vertices.
--   
--   If nPoints is 0, the returned box is initialized with
--   boxEmpty.
--   
--   Since: 1.2
boxInitFromPoints :: (HasCallStack, MonadIO m) => Box -> [Point3D] -> m Box

-- | Initializes the given Box with two vertices stored inside
--   Vec3.
--   
--   Since: 1.2
boxInitFromVec3 :: (HasCallStack, MonadIO m) => Box -> Maybe Vec3 -> Maybe Vec3 -> m Box

-- | Initializes the given Box with the given array of vertices.
--   
--   If nVectors is 0, the returned box is initialized with
--   boxEmpty.
--   
--   Since: 1.2
boxInitFromVectors :: (HasCallStack, MonadIO m) => Box -> [Vec3] -> m Box

-- | Intersects the two given Box.
--   
--   If the two boxes do not intersect, res will contain a
--   degenerate box initialized with boxEmpty.
--   
--   Since: 1.2
boxIntersection :: (HasCallStack, MonadIO m) => Box -> Box -> m (Bool, Box)

-- | A Box with the minimum vertex set at (-1, -1, -1) and the
--   maximum vertex set at (0, 0, 0).
--   
--   The returned value is owned by Graphene and should not be modified or
--   freed.
--   
--   Since: 1.2
boxMinusOne :: (HasCallStack, MonadIO m) => m Box

-- | A Box with the minimum vertex set at (0, 0, 0) and the maximum
--   vertex set at (1, 1, 1).
--   
--   The returned value is owned by Graphene and should not be modified or
--   freed.
--   
--   Since: 1.2
boxOne :: (HasCallStack, MonadIO m) => m Box

-- | A Box with the minimum vertex set at (-1, -1, -1) and the
--   maximum vertex set at (1, 1, 1).
--   
--   The returned value is owned by Graphene and should not be modified or
--   freed.
--   
--   Since: 1.2
boxOneMinusOne :: (HasCallStack, MonadIO m) => m Box

-- | Unions the two given Box.
--   
--   Since: 1.2
boxUnion :: (HasCallStack, MonadIO m) => Box -> Box -> m Box

-- | A Box with both the minimum and maximum vertices set at (0, 0,
--   0).
--   
--   The returned value is owned by Graphene and should not be modified or
--   freed.
--   
--   Since: 1.2
boxZero :: (HasCallStack, MonadIO m) => m Box
instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Graphene.Structs.Box.Box tag
instance GHC.Classes.Eq GI.Graphene.Structs.Box.Box
instance Data.GI.Base.BasicTypes.GBoxed GI.Graphene.Structs.Box.Box
instance Data.GI.Base.Overloading.HasParentTypes GI.Graphene.Structs.Box.Box
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Graphene.Structs.Box.Box)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Graphene.Structs.Box.Box
instance Data.GI.Base.BasicTypes.TypedObject GI.Graphene.Structs.Box.Box

module GI.Graphene.Structs

module GI.Graphene
