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

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

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

-- | <i>No description available in the introspection data.</i>
pattern PI_2 :: Double

-- | <i>No description available in the introspection data.</i>
pattern PI :: Double


module GI.Graphene.Enums

-- | Specify the order of the rotations on each axis.
--   
--   The <a>EulerOrderDefault</a> value is special, and is used as an alias
--   for one of the other orders.
--   
--   <i>Since: 1.2</i>
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 <a>EulerOrderSxyz</a>
EulerOrderXyz :: EulerOrder

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

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

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

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

-- | Rotate in the Z, Y, and X order. Deprecated in Graphene 1.10, it's an
--   alias for <a>EulerOrderSzyx</a>
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.
--   
--   <i>Since: 1.10</i>
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


-- | <i>No description available in the introspection data.</i>
module GI.Graphene.Structs.Simd4F

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

-- | Construct a <a>Simd4F</a> 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


-- | <i>No description available in the introspection data.</i>
module GI.Graphene.Structs.Simd4X4F

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

-- | Construct a <a>Simd4X4F</a> 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.
--   
--   <i>Since: 1.0</i>
module GI.Graphene.Structs.Size

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

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

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

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

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

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

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

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

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

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

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

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

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

-- | Set the value of the “<tt>width</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> size [ #width <a>:=</a> value ]
--   </pre>
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 <a>Vec2</a> 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 <a>Vec2</a> 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 <i><tt>res</tt></i>.
--   
--   <i>Since: 1.0</i>
vec2Add :: (HasCallStack, MonadIO m) => Vec2 -> Vec2 -> m Vec2

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-- | Retrieves a constant vector with (0, 0) components.
--   
--   <i>Since: 1.0</i>
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 <a>Rect</a> can be negative; for instance, a
--   <a>Rect</a> with an origin of [ 0, 0 ] and a size of [ 10, 10 ] is
--   equivalent to a <a>Rect</a> with an origin of [ 10, 10 ] and a size of
--   [ -10, -10 ].
--   
--   Application code can normalize rectangles using <a>rectNormalize</a>;
--   this function will ensure that the width and height of a rectangle are
--   positive values. All functions taking a <a>Rect</a> as an argument
--   will internally operate on a normalized copy; all functions returning
--   a <a>Rect</a> will always return a normalized rectangle.
--   
--   <i>Since: 1.0</i>
module GI.Graphene.Structs.Rect

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-- | Initializes <i><tt>r</tt></i> using the given <i><tt>src</tt></i>
--   rectangle.
--   
--   This function will implicitly normalize the <a>Rect</a> before
--   returning.
--   
--   <i>Since: 1.0</i>
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 <i><tt>dX</tt></i> or
--   <i><tt>dY</tt></i> values; to create a larger, encompassing rectangle,
--   use negative <i><tt>dX</tt></i> or <i><tt>dY</tt></i> values.
--   
--   The origin of the rectangle is offset by <i><tt>dX</tt></i> and
--   <i><tt>dY</tt></i>, while the size is adjusted by <tt>(2 * @d_x, 2 *
--   @d_y)</tt>. If <i><tt>dX</tt></i> and <i><tt>dY</tt></i> are positive
--   values, the size of the rectangle is decreased; if <i><tt>dX</tt></i>
--   and <i><tt>dY</tt></i> 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.
--   
--   <i>Since: 1.0</i>
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 <i><tt>dX</tt></i> or
--   <i><tt>dY</tt></i> values; to create a larger, encompassing rectangle,
--   use negative <i><tt>dX</tt></i> or <i><tt>dY</tt></i> values.
--   
--   The origin of the rectangle is offset by <i><tt>dX</tt></i> and
--   <i><tt>dY</tt></i>, while the size is adjusted by <tt>(2 * @d_x, 2 *
--   @d_y)</tt>. If <i><tt>dX</tt></i> and <i><tt>dY</tt></i> are positive
--   values, the size of the rectangle is decreased; if <i><tt>dX</tt></i>
--   and <i><tt>dY</tt></i> 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.
--   
--   <i>Since: 1.4</i>
rectInsetR :: (HasCallStack, MonadIO m) => Rect -> Float -> Float -> m Rect

-- | Linearly interpolates the origin and size of the two given rectangles.
--   
--   <i>Since: 1.0</i>
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, <i><tt>res</tt></i> will
--   contain a degenerate rectangle with origin in (0, 0) and a size of 0.
--   
--   <i>Since: 1.0</i>
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.
--   
--   <i>Since: 1.0</i>
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.
--   
--   <i>Since: 1.4</i>
rectNormalizeR :: (HasCallStack, MonadIO m) => Rect -> m Rect

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

-- | Offsets the origin of the given rectangle by <i><tt>dX</tt></i> and
--   <i><tt>dY</tt></i>.
--   
--   The size of the rectangle is left unchanged.
--   
--   <i>Since: 1.4</i>
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 <a>rectRoundExtents</a> in case you need to
--   round to a rectangle that covers fully the original one.
--   
--   This function is the equivalent of calling <tt>floor</tt> on the
--   coordinates of the origin, and <tt>ceil</tt> on the size.
--   
--   <i>Since: 1.4</i>

-- | <i>Deprecated: (Since version 1.10)Use <a>rectRoundExtents</a>
--   instead</i>
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 <tt>floor</tt> on the
--   coordinates of the origin, and recomputing the size calling
--   <tt>ceil</tt> 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.
--   
--   <i>Since: 1.10</i>
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.
--   
--   <i>Since: 1.0</i>

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

-- | Scales the size and origin of a rectangle horizontaly by
--   <i><tt>sH</tt></i>, and vertically by <i><tt>sV</tt></i>. The result
--   <i><tt>res</tt></i> is normalized.
--   
--   <i>Since: 1.10</i>
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.
--   
--   <i>Since: 1.0</i>
rectUnion :: (HasCallStack, MonadIO m) => Rect -> Rect -> m Rect

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

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

-- | Get the value of the “<tt>size</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> rect #size
--   </pre>
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 <a>Point</a>.
--   
--   The contents of a <a>Quad</a> are private and should never be accessed
--   directly.
--   
--   <i>Since: 1.0</i>
module GI.Graphene.Structs.Quad

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

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

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

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

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

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

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

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

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

-- | Initializes a <a>Quad</a> using the four corners of the given
--   <a>Rect</a>.
--   
--   <i>Since: 1.0</i>
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.
--   
--   <i>Since: 1.0</i>
module GI.Graphene.Structs.Point

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

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

-- | Allocates a new <a>Point</a> structure.
--   
--   The coordinates of the returned point are (0, 0).
--   
--   It's possible to chain this function with <a>pointInit</a> or
--   <a>pointInitFromPoint</a>, e.g.:
--   
--   <h3><i>C code</i></h3>
--   
--   <pre>
--   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);
--   }
--   </pre>
--   
--   <i>Since: 1.0</i>
pointAlloc :: (HasCallStack, MonadIO m) => m Point

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

-- | Checks if the two points <i><tt>a</tt></i> and <i><tt>b</tt></i> 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 <a>pointNear</a>
--   instead.
--   
--   <i>Since: 1.0</i>
pointEqual :: (HasCallStack, MonadIO m) => Point -> Point -> m Bool

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

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

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

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

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

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

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

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

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

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

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

-- | Set the value of the “<tt>y</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> point [ #y <a>:=</a> value ]
--   </pre>
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 <a>Vec4</a> 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 <a>Vec4</a> struct initialized to zero.
newZeroVec4 :: MonadIO m => m Vec4

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-- | Compares each component of the two given vectors and creates a vector
--   that contains the maximum values.
--   
--   <i>Since: 1.0</i>
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.
--   
--   <i>Since: 1.0</i>
vec4Min :: (HasCallStack, MonadIO m) => Vec4 -> Vec4 -> m Vec4

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

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

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

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

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

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

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

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

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

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

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

-- | Retrieves a pointer to a <a>Vec4</a> with all its components set to 0.
--   
--   <i>Since: 1.0</i>
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 <a>Vec3</a> 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 <a>Vec3</a> struct initialized to zero.
newZeroVec3 :: MonadIO m => m Vec3

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-- | Compares each component of the two given vectors and creates a vector
--   that contains the maximum values.
--   
--   <i>Since: 1.0</i>
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.
--   
--   <i>Since: 1.0</i>
vec3Min :: (HasCallStack, MonadIO m) => Vec3 -> Vec3 -> m Vec3

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

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

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

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

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

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

-- | Subtracts from each component of the first operand <i><tt>a</tt></i>
--   the corresponding component of the second operand <i><tt>b</tt></i>
--   and places each result into the components of <i><tt>res</tt></i>.
--   
--   <i>Since: 1.0</i>
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).
--   
--   <i>Since: 1.0</i>
vec3XAxis :: (HasCallStack, MonadIO m) => m Vec3

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

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

-- | Provides a constant pointer to a vector with three components, all
--   sets to 0.
--   
--   <i>Since: 1.0</i>
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.
--   
--   <i>Since: 1.2</i>
module GI.Graphene.Structs.Triangle

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

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

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

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

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

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

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

-- | Computes the <a>barycentric coordinates</a> of the given point
--   <i><tt>p</tt></i>.
--   
--   The point <i><tt>p</tt></i> must lie on the same plane as the triangle
--   <i><tt>t</tt></i>; 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 <tt>u</tt>, which is on the AC vector;
--   and <tt>v</tt> which is on the AB vector:
--   
--   
--   The returned <a>Vec2</a> contains the following values, in order:
--   
--   <ul>
--   <li><pre>res.x = u</pre></li>
--   <li><pre>res.y = v</pre></li>
--   </ul>
--   
--   <i>Since: 1.2</i>
triangleGetBarycoords :: (HasCallStack, MonadIO m) => Triangle -> Maybe Point3D -> m (Bool, Vec2)

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

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

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

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

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

-- | Computes the UV coordinates of the given point <i><tt>p</tt></i>.
--   
--   The point <i><tt>p</tt></i> must lie on the same plane as the triangle
--   <i><tt>t</tt></i>; if the point is not coplanar, the result of this
--   function is undefined. If <i><tt>p</tt></i> is <a>Nothing</a>, the
--   point will be set in (0, 0, 0).
--   
--   The UV coordinates will be placed in the <i><tt>res</tt></i> vector:
--   
--   <ul>
--   <li><pre>res.x = u</pre></li>
--   <li><pre>res.y = v</pre></li>
--   </ul>
--   
--   See also: <a>triangleGetBarycoords</a>
--   
--   <i>Since: 1.10</i>
triangleGetUv :: (HasCallStack, MonadIO m) => Triangle -> Maybe Point3D -> Vec2 -> Vec2 -> Vec2 -> m (Bool, Vec2)

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

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

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

-- | Initializes a <a>Triangle</a> using the three given vectors.
--   
--   <i>Since: 1.2</i>
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.
--   
--   <i>Since: 1.2</i>
module GI.Graphene.Structs.Sphere

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

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

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

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

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

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

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

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

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

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

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

-- | Initializes the given <a>Sphere</a> 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 <i><tt>points</tt></i>.
--   
--   <i>Since: 1.2</i>
sphereInitFromPoints :: (HasCallStack, MonadIO m) => Sphere -> [Point3D] -> Maybe Point3D -> m Sphere

-- | Initializes the given <a>Sphere</a> 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 <i><tt>vectors</tt></i>.
--   
--   <i>Since: 1.2</i>
sphereInitFromVectors :: (HasCallStack, MonadIO m) => Sphere -> [Vec3] -> Maybe Point3D -> m Sphere

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

-- | Translates the center of the given <a>Sphere</a> using the
--   <i><tt>point</tt></i> coordinates as the delta of the translation.
--   
--   <i>Since: 1.2</i>
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 <tt>graphene_ray_t</tt> structure are private, and
--   should not be modified directly.
--   
--   <i>Since: 1.4</i>
module GI.Graphene.Structs.Ray

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

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

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

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

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

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

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

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

-- | Computes the distance of the closest approach between the given
--   <a>Ray</a> <i><tt>r</tt></i> and the point <i><tt>p</tt></i>.
--   
--   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.
--   
--   <i>Since: 1.4</i>
rayGetDistanceToPoint :: (HasCallStack, MonadIO m) => Ray -> Point3D -> m Float

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

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

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

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

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

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

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

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

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

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

-- | Checks whether the given <a>Ray</a> <i><tt>r</tt></i> intersects the
--   given <a>Triangle</a> <i><tt>b</tt></i>.
--   
--   See also: <a>rayIntersectTriangle</a>
--   
--   <i>Since: 1.10</i>
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 <a>Quaternion</a> structure are private and should
--   never be accessed directly.
--   
--   <i>Since: 1.0</i>
module GI.Graphene.Structs.Quaternion

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-- | Copies the components of a <a>Quaternion</a> into a <a>Vec4</a>.
--   
--   <i>Since: 1.0</i>
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.
--   
--   <i>Since: 1.0</i>
module GI.Graphene.Structs.Point3D

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-- | Set the value of the “<tt>z</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> point3D [ #z <a>:=</a> value ]
--   </pre>
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 <tt>graphene_plane_t</tt> are private, and should
--   not be modified directly.
--   
--   <i>Since: 1.2</i>
module GI.Graphene.Structs.Plane

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-- | Transforms a <a>Plane</a> <i><tt>p</tt></i> using the given
--   <i><tt>matrix</tt></i> and <i><tt>normalMatrix</tt></i>.
--   
--   If <i><tt>normalMatrix</tt></i> is <a>Nothing</a>, a transformation
--   matrix for the plane normal will be computed from
--   <i><tt>matrix</tt></i>. If you are transforming multiple planes using
--   the same <i><tt>matrix</tt></i> it's recommended to compute the normal
--   matrix beforehand to avoid incurring in the cost of recomputing it
--   every time.
--   
--   <i>Since: 1.10</i>
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 <a>Matrix</a> 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 <a>Matrix</a> struct initialized to zero.
newZeroMatrix :: MonadIO m => m Matrix

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

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

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

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

-- | Checks whether the two given <a>Matrix</a> matrices are byte-by-byte
--   equal.
--   
--   While this function is faster than <a>matrixEqual</a>, it can also
--   return false negatives, so it should be used in conjuction with either
--   <a>matrixEqual</a> or <a>matrixNear</a>. For instance:
--   
--   <h3><i>C code</i></h3>
--   
--   <pre>
--   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
--     }
--   </pre>
--   
--   <i>Since: 1.10</i>
matrixEqualFast :: (HasCallStack, MonadIO m) => Matrix -> Matrix -> m Bool

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

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

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

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

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

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

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

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

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

-- | Initializes a <a>Matrix</a> from the values of an affine
--   transformation matrix.
--   
--   The arguments map to the following matrix layout:
--   
--   <h3><i>plain code</i></h3>
--   
--   <pre>
--   ⎛ xx  yx ⎞   ⎛  a   b  0 ⎞
--   ⎜ xy  yy ⎟ = ⎜  c   d  0 ⎟
--   ⎝ x0  y0 ⎠   ⎝ tx  ty  1 ⎠
--   </pre>
--   
--   This function can be used to convert between an affine matrix type
--   from other libraries and a <a>Matrix</a>.
--   
--   <i>Since: 1.0</i>
matrixInitFrom2d :: (HasCallStack, MonadIO m) => Matrix -> Double -> Double -> Double -> Double -> Double -> Double -> m Matrix

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

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

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

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

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

-- | Initializes a <a>Matrix</a> so that it positions the "camera" at the
--   given <i><tt>eye</tt></i> coordinates towards an object at the
--   <i><tt>center</tt></i> coordinates. The top of the camera is aligned
--   to the direction of the <i><tt>up</tt></i> 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 <i><tt>m</tt></i> to transform a model of
--   such a camera into world-space. However, it is more common to use the
--   inverse of <i><tt>m</tt></i> 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.
--   
--   <i>Since: 1.0</i>
matrixInitLookAt :: (HasCallStack, MonadIO m) => Matrix -> Vec3 -> Vec3 -> Vec3 -> m Matrix

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

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

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

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

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

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

-- | Linearly interpolates the two given <a>Matrix</a> 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.
--   
--   <i>Since: 1.0</i>
matrixInterpolate :: (HasCallStack, MonadIO m) => Matrix -> Matrix -> Double -> m Matrix

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

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

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

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

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

-- | Multiplies two <a>Matrix</a>.
--   
--   Matrix multiplication is not commutative in general; the order of the
--   factors matters. The product of this multiplication is
--   (<i><tt>a</tt></i> × <i><tt>b</tt></i>)
--   
--   <i>Since: 1.0</i>
matrixMultiply :: (HasCallStack, MonadIO m) => Matrix -> Matrix -> m Matrix

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

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

-- | Applies a perspective of <i><tt>depth</tt></i> to the matrix.
--   
--   <i>Since: 1.0</i>
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.
--   
--   <i>Since: 1.0</i>
matrixPrint :: (HasCallStack, MonadIO m) => Matrix -> m ()

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

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

-- | Projects a <a>Rect</a> using the given matrix.
--   
--   The resulting rectangle is the axis aligned bounding rectangle capable
--   of fully containing the projected rectangle.
--   
--   <i>Since: 1.0</i>
matrixProjectRectBounds :: (HasCallStack, MonadIO m) => Matrix -> Rect -> m Rect

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

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

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

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

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

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

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

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

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

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

-- | Converts a <a>Matrix</a> to an affine transformation matrix, if the
--   given matrix is compatible.
--   
--   The returned values have the following layout:
--   
--   <h3><i>plain code</i></h3>
--   
--   <pre>
--   ⎛ xx  yx ⎞   ⎛  a   b  0 ⎞
--   ⎜ xy  yy ⎟ = ⎜  c   d  0 ⎟
--   ⎝ x0  y0 ⎠   ⎝ tx  ty  1 ⎠
--   </pre>
--   
--   This function can be used to convert between a <a>Matrix</a> and an
--   affine matrix type from other libraries.
--   
--   <i>Since: 1.0</i>
matrixTo2d :: (HasCallStack, MonadIO m) => Matrix -> m (Bool, Double, Double, Double, Double, Double, Double)

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

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

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

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

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

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

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

-- | Transforms the given <a>Vec3</a> using the matrix <i><tt>m</tt></i>.
--   
--   This function will multiply the X, Y, and Z row vectors of the matrix
--   <i><tt>m</tt></i> with the corresponding components of the vector
--   <i><tt>v</tt></i>. The W row vector will be ignored.
--   
--   See also: <tt><i>graphene_simd4x4f_vec3_mul()</i></tt>
--   
--   <i>Since: 1.0</i>
matrixTransformVec3 :: (HasCallStack, MonadIO m) => Matrix -> Vec3 -> m Vec3

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

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

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

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

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

-- | Undoes the transformation of a <a>Point</a> using the given matrix,
--   within the given axis aligned rectangular <i><tt>bounds</tt></i>.
--   
--   <i>Since: 1.0</i>
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 <tt>graphene_frustum_t</tt> are private, and
--   should not be modified directly.
--   
--   <i>Since: 1.2</i>
module GI.Graphene.Structs.Frustum

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

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

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

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

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

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

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

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

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

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

-- | Checks whether the given <i><tt>sphere</tt></i> intersects a plane of
--   a <a>Frustum</a>.
--   
--   <i>Since: 1.2</i>
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 <a>Euler</a> structure are private and should
--   never be accessed directly.
--   
--   <i>Since: 1.2</i>
module GI.Graphene.Structs.Euler

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-- | Converts a <a>Euler</a> 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 <a>Euler</a>; for instance, if the order used to
--   initialize <i><tt>e</tt></i> is <a>EulerOrderXyz</a>:
--   
--   <ul>
--   <li>the first rotation moves the body around the X axis with an angle
--   φ</li>
--   <li>the second rotation moves the body around the Y axis with an angle
--   of ϑ</li>
--   <li>the third rotation moves the body around the Z axis with an angle
--   of ψ</li>
--   </ul>
--   
--   The rotation sign convention is right-handed, to preserve
--   compatibility between Euler-based, quaternion-based, and
--   angle-axis-based rotations.
--   
--   <i>Since: 1.2</i>
eulerToMatrix :: (HasCallStack, MonadIO m) => Euler -> m Matrix

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

-- | Retrieves the angles of a <a>Euler</a> and initializes a <a>Vec3</a>
--   with them.
--   
--   <i>Since: 1.2</i>
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.
--   
--   <i>Since: 1.2</i>
module GI.Graphene.Structs.Box

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-- | A <a>Box</a> 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.
--   
--   <i>Since: 1.2</i>
boxMinusOne :: (HasCallStack, MonadIO m) => m Box

-- | A <a>Box</a> 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.
--   
--   <i>Since: 1.2</i>
boxOne :: (HasCallStack, MonadIO m) => m Box

-- | A <a>Box</a> 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.
--   
--   <i>Since: 1.2</i>
boxOneMinusOne :: (HasCallStack, MonadIO m) => m Box

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

-- | A <a>Box</a> 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.
--   
--   <i>Since: 1.2</i>
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
