-- Produced by boxnd-gen; edit the generator, not this file.

module Box2D.Collision
  ( saveRecordingToFile
  , loadRecordingFromFile
  , validateReplay
  , isValidRay
  , makePolygon
  , makeOffsetPolygon
  , makeOffsetRoundedPolygon
  , makeSquare
  , makeSquareInto
  , makeBox
  , makeBoxInto
  , makeRoundedBox
  , makeRoundedBoxInto
  , makeOffsetBox
  , makeOffsetRoundedBox
  , transformPolygon
  , computeCircleMass
  , computeCapsuleMass
  , computePolygonMass
  , computeCircleAABB
  , computeCapsuleAABB
  , computePolygonAABB
  , computeSegmentAABB
  , pointInCircle
  , pointInCapsule
  , pointInPolygon
  , rayCastCircle
  , rayCastCapsule
  , rayCastSegment
  , rayCastPolygon
  , shapeCastCircle
  , shapeCastCapsule
  , shapeCastSegment
  , shapeCastPolygon
  , computeHull
  , computeHullInto
  , validateHull
  , segmentDistance
  , shapeDistance
  , shapeCast
  , shapeCastInto
  , makeProxy
  , makeOffsetProxy
  , getSweepTransform
  , timeOfImpact
  , collideCircles
  , collideCapsuleAndCircle
  , collideSegmentAndCircle
  , collidePolygonAndCircle
  , collideCapsules
  , collideSegmentAndCapsule
  , collidePolygonAndCapsule
  , collidePolygons
  , collideSegmentAndPolygon
  , collideChainSegmentAndCircle
  , collideChainSegmentAndCapsule
  , collideChainSegmentAndPolygon
  , solvePlanes
  , clipVector
  )

  where

import Foreign
import Foreign.C.Types (CBool(..), CInt(..))
import Foreign.C.String (CString)
import Box2D.MathTypes (AABB, Rot, Transform, Vec2, WorldTransform)
import Box2D.Tags (ChainSegment, CollisionPlane, DistanceInput, DistanceOutput, LocalManifold, PlaneSolverResult, Recording, SegmentDistanceResult, ShapeCastInput, ShapeCastPairInput, ShapeProxy, Simplex, SimplexCache, TOIInput, TOIOutput)
import Box2D.Types (Capsule, CastOutput, Circle, Hull, MassData, Polygon, RayCastInput, Segment, Sweep)

foreign import ccall unsafe "b2SaveRecordingToFile"
  c_b2SaveRecordingToFile :: Ptr Recording -> CString -> IO CBool

foreign import ccall unsafe "b2LoadRecordingFromFile"
  c_b2LoadRecordingFromFile :: CString -> IO (Ptr Recording)

foreign import ccall unsafe "b2ValidateReplay"
  c_b2ValidateReplay :: Ptr () -> CInt -> CInt -> IO CBool

foreign import ccall unsafe "b2IsValidRay"
  c_b2IsValidRay :: Ptr RayCastInput -> IO CBool

foreign import ccall unsafe "hsg_b2MakePolygon"
  c_b2MakePolygon :: Ptr Hull -> Float -> Ptr Polygon -> IO ()

foreign import ccall unsafe "hsg_b2MakeOffsetPolygon"
  c_b2MakeOffsetPolygon :: Ptr Hull -> Ptr Vec2 -> Ptr Rot -> Ptr Polygon -> IO ()

foreign import ccall unsafe "hsg_b2MakeOffsetRoundedPolygon"
  c_b2MakeOffsetRoundedPolygon :: Ptr Hull -> Ptr Vec2 -> Ptr Rot -> Float -> Ptr Polygon -> IO ()

foreign import ccall unsafe "hsg_b2MakeSquare"
  c_b2MakeSquare :: Float -> Ptr Polygon -> IO ()

foreign import ccall unsafe "hsg_b2MakeBox"
  c_b2MakeBox :: Float -> Float -> Ptr Polygon -> IO ()

foreign import ccall unsafe "hsg_b2MakeRoundedBox"
  c_b2MakeRoundedBox :: Float -> Float -> Float -> Ptr Polygon -> IO ()

foreign import ccall unsafe "hsg_b2MakeOffsetBox"
  c_b2MakeOffsetBox :: Float -> Float -> Ptr Vec2 -> Ptr Rot -> Ptr Polygon -> IO ()

foreign import ccall unsafe "hsg_b2MakeOffsetRoundedBox"
  c_b2MakeOffsetRoundedBox :: Float -> Float -> Ptr Vec2 -> Ptr Rot -> Float -> Ptr Polygon -> IO ()

foreign import ccall unsafe "hsg_b2TransformPolygon"
  c_b2TransformPolygon :: Ptr Transform -> Ptr Polygon -> Ptr Polygon -> IO ()

foreign import ccall unsafe "hsg_b2ComputeCircleMass"
  c_b2ComputeCircleMass :: Ptr Circle -> Float -> Ptr MassData -> IO ()

foreign import ccall unsafe "hsg_b2ComputeCapsuleMass"
  c_b2ComputeCapsuleMass :: Ptr Capsule -> Float -> Ptr MassData -> IO ()

foreign import ccall unsafe "hsg_b2ComputePolygonMass"
  c_b2ComputePolygonMass :: Ptr Polygon -> Float -> Ptr MassData -> IO ()

foreign import ccall unsafe "hsg_b2ComputeCircleAABB"
  c_b2ComputeCircleAABB :: Ptr Circle -> Ptr WorldTransform -> Ptr AABB -> IO ()

foreign import ccall unsafe "hsg_b2ComputeCapsuleAABB"
  c_b2ComputeCapsuleAABB :: Ptr Capsule -> Ptr WorldTransform -> Ptr AABB -> IO ()

foreign import ccall unsafe "hsg_b2ComputePolygonAABB"
  c_b2ComputePolygonAABB :: Ptr Polygon -> Ptr WorldTransform -> Ptr AABB -> IO ()

foreign import ccall unsafe "hsg_b2ComputeSegmentAABB"
  c_b2ComputeSegmentAABB :: Ptr Segment -> Ptr WorldTransform -> Ptr AABB -> IO ()

foreign import ccall unsafe "hsg_b2PointInCircle"
  c_b2PointInCircle :: Ptr Circle -> Ptr Vec2 -> IO CBool

foreign import ccall unsafe "hsg_b2PointInCapsule"
  c_b2PointInCapsule :: Ptr Capsule -> Ptr Vec2 -> IO CBool

foreign import ccall unsafe "hsg_b2PointInPolygon"
  c_b2PointInPolygon :: Ptr Polygon -> Ptr Vec2 -> IO CBool

foreign import ccall unsafe "hsg_b2RayCastCircle"
  c_b2RayCastCircle :: Ptr Circle -> Ptr RayCastInput -> Ptr CastOutput -> IO ()

foreign import ccall unsafe "hsg_b2RayCastCapsule"
  c_b2RayCastCapsule :: Ptr Capsule -> Ptr RayCastInput -> Ptr CastOutput -> IO ()

foreign import ccall unsafe "hsg_b2RayCastSegment"
  c_b2RayCastSegment :: Ptr Segment -> Ptr RayCastInput -> CBool -> Ptr CastOutput -> IO ()

foreign import ccall unsafe "hsg_b2RayCastPolygon"
  c_b2RayCastPolygon :: Ptr Polygon -> Ptr RayCastInput -> Ptr CastOutput -> IO ()

foreign import ccall unsafe "hsg_b2ShapeCastCircle"
  c_b2ShapeCastCircle :: Ptr Circle -> Ptr ShapeCastInput -> Ptr CastOutput -> IO ()

foreign import ccall unsafe "hsg_b2ShapeCastCapsule"
  c_b2ShapeCastCapsule :: Ptr Capsule -> Ptr ShapeCastInput -> Ptr CastOutput -> IO ()

foreign import ccall unsafe "hsg_b2ShapeCastSegment"
  c_b2ShapeCastSegment :: Ptr Segment -> Ptr ShapeCastInput -> Ptr CastOutput -> IO ()

foreign import ccall unsafe "hsg_b2ShapeCastPolygon"
  c_b2ShapeCastPolygon :: Ptr Polygon -> Ptr ShapeCastInput -> Ptr CastOutput -> IO ()

foreign import ccall unsafe "hsg_b2ComputeHull"
  c_b2ComputeHull :: Ptr Vec2 -> CInt -> Ptr Hull -> IO ()

foreign import ccall unsafe "b2ValidateHull"
  c_b2ValidateHull :: Ptr Hull -> IO CBool

foreign import ccall unsafe "hsg_b2SegmentDistance"
  c_b2SegmentDistance :: Ptr Vec2 -> Ptr Vec2 -> Ptr Vec2 -> Ptr Vec2 -> Ptr SegmentDistanceResult -> IO ()

foreign import ccall unsafe "hsg_b2ShapeDistance"
  c_b2ShapeDistance :: Ptr DistanceInput -> Ptr SimplexCache -> Ptr Simplex -> CInt -> Ptr DistanceOutput -> IO ()

foreign import ccall unsafe "hsg_b2ShapeCast"
  c_b2ShapeCast :: Ptr ShapeCastPairInput -> Ptr CastOutput -> IO ()

foreign import ccall unsafe "hsg_b2MakeProxy"
  c_b2MakeProxy :: Ptr Vec2 -> CInt -> Float -> Ptr ShapeProxy -> IO ()

foreign import ccall unsafe "hsg_b2MakeOffsetProxy"
  c_b2MakeOffsetProxy :: Ptr Vec2 -> CInt -> Float -> Ptr Vec2 -> Ptr Rot -> Ptr ShapeProxy -> IO ()

foreign import ccall unsafe "hsg_b2GetSweepTransform"
  c_b2GetSweepTransform :: Ptr Sweep -> Float -> Ptr Transform -> IO ()

foreign import ccall unsafe "hsg_b2TimeOfImpact"
  c_b2TimeOfImpact :: Ptr TOIInput -> Ptr TOIOutput -> IO ()

foreign import ccall unsafe "hsg_b2CollideCircles"
  c_b2CollideCircles :: Ptr Circle -> Ptr Circle -> Ptr Transform -> Ptr LocalManifold -> IO ()

foreign import ccall unsafe "hsg_b2CollideCapsuleAndCircle"
  c_b2CollideCapsuleAndCircle :: Ptr Capsule -> Ptr Circle -> Ptr Transform -> Ptr LocalManifold -> IO ()

foreign import ccall unsafe "hsg_b2CollideSegmentAndCircle"
  c_b2CollideSegmentAndCircle :: Ptr Segment -> Ptr Circle -> Ptr Transform -> Ptr LocalManifold -> IO ()

foreign import ccall unsafe "hsg_b2CollidePolygonAndCircle"
  c_b2CollidePolygonAndCircle :: Ptr Polygon -> Ptr Circle -> Ptr Transform -> Ptr LocalManifold -> IO ()

foreign import ccall unsafe "hsg_b2CollideCapsules"
  c_b2CollideCapsules :: Ptr Capsule -> Ptr Capsule -> Ptr Transform -> Ptr LocalManifold -> IO ()

foreign import ccall unsafe "hsg_b2CollideSegmentAndCapsule"
  c_b2CollideSegmentAndCapsule :: Ptr Segment -> Ptr Capsule -> Ptr Transform -> Ptr LocalManifold -> IO ()

foreign import ccall unsafe "hsg_b2CollidePolygonAndCapsule"
  c_b2CollidePolygonAndCapsule :: Ptr Polygon -> Ptr Capsule -> Ptr Transform -> Ptr LocalManifold -> IO ()

foreign import ccall unsafe "hsg_b2CollidePolygons"
  c_b2CollidePolygons :: Ptr Polygon -> Ptr Polygon -> Ptr Transform -> Ptr LocalManifold -> IO ()

foreign import ccall unsafe "hsg_b2CollideSegmentAndPolygon"
  c_b2CollideSegmentAndPolygon :: Ptr Segment -> Ptr Polygon -> Ptr Transform -> Ptr LocalManifold -> IO ()

foreign import ccall unsafe "hsg_b2CollideChainSegmentAndCircle"
  c_b2CollideChainSegmentAndCircle :: Ptr ChainSegment -> Ptr Circle -> Ptr Transform -> Ptr LocalManifold -> IO ()

foreign import ccall unsafe "hsg_b2CollideChainSegmentAndCapsule"
  c_b2CollideChainSegmentAndCapsule :: Ptr ChainSegment -> Ptr Capsule -> Ptr Transform -> Ptr SimplexCache -> Ptr LocalManifold -> IO ()

foreign import ccall unsafe "hsg_b2CollideChainSegmentAndPolygon"
  c_b2CollideChainSegmentAndPolygon :: Ptr ChainSegment -> Ptr Polygon -> Ptr Transform -> Ptr SimplexCache -> Ptr LocalManifold -> IO ()

foreign import ccall unsafe "hsg_b2SolvePlanes"
  c_b2SolvePlanes :: Ptr Vec2 -> Ptr CollisionPlane -> CInt -> Ptr PlaneSolverResult -> IO ()

foreign import ccall unsafe "hsg_b2ClipVector"
  c_b2ClipVector :: Ptr Vec2 -> Ptr CollisionPlane -> CInt -> Ptr Vec2 -> IO ()

{- | Save a recording buffer to a file. Convenience wrapper over your own file I\/O.

Returns: false if the file could not be written

Binds @b2SaveRecordingToFile@.
-}
saveRecordingToFile
  :: Ptr Recording
  -> CString
  -- ^ @path@
  -> IO Bool
saveRecordingToFile :: Ptr Recording -> CString -> IO Bool
saveRecordingToFile Ptr Recording
a0 CString
a1 =
  CBool -> Bool
forall a. (Eq a, Num a) => a -> Bool
toBool (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Ptr Recording -> CString -> IO CBool
c_b2SaveRecordingToFile Ptr Recording
a0 CString
a1)

{- | Load a recording from a file into a new recording buffer. Convenience wrapper over your own
file I\/O. Destroy the result with b2DestroyRecording.

Returns: NULL if the file is missing or unreadable

Binds @b2LoadRecordingFromFile@.
-}
loadRecordingFromFile
  :: CString
  -- ^ @path@
  -> IO (Ptr Recording)
loadRecordingFromFile :: CString -> IO (Ptr Recording)
loadRecordingFromFile CString
a0 =
  CString -> IO (Ptr Recording)
c_b2LoadRecordingFromFile CString
a0

{- | Replay a recording by re-running the engine and asserting recorded ids and state match.

Returns: true if replay completed without divergence, false on any mismatch

Binds @b2ValidateReplay@.
-}
validateReplay
  :: Ptr ()
  -- ^ @data@: Recorded bytes, e.g. from b2Recording_GetData or a loaded file
  -> Int
  -- ^ @size@: Number of recorded bytes
  -> Int
  -- ^ @workerCount@: Worker count to use for replay. 0 uses the serial single-worker fallback.
  -> IO Bool
validateReplay :: Ptr () -> Int -> Int -> IO Bool
validateReplay Ptr ()
a0 Int
a1 Int
a2 =
  CBool -> Bool
forall a. (Eq a, Num a) => a -> Bool
toBool (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Ptr () -> CInt -> CInt -> IO CBool
c_b2ValidateReplay Ptr ()
a0 (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
a1) (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
a2))

{- | Validate ray cast input data (NaN, etc)

Binds @b2IsValidRay@.
-}
isValidRay
  :: RayCastInput
  -> IO Bool
isValidRay :: RayCastInput -> IO Bool
isValidRay RayCastInput
a0 =
  RayCastInput -> (Ptr RayCastInput -> IO Bool) -> IO Bool
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with RayCastInput
a0 ((Ptr RayCastInput -> IO Bool) -> IO Bool)
-> (Ptr RayCastInput -> IO Bool) -> IO Bool
forall a b. (a -> b) -> a -> b
$ \Ptr RayCastInput
p0 ->
  CBool -> Bool
forall a. (Eq a, Num a) => a -> Bool
toBool (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Ptr RayCastInput -> IO CBool
c_b2IsValidRay Ptr RayCastInput
p0)

{- | Make a convex polygon from a convex hull. This will assert if the hull is not valid.
Warning: Do not manually fill in the hull data, it must come directly from b2ComputeHull

Binds @b2MakePolygon@.
-}
makePolygon
  :: Hull
  -> Float
  -- ^ @radius@
  -> IO Polygon
makePolygon :: Hull -> Float -> IO Polygon
makePolygon Hull
a0 Float
a1 =
  Hull -> (Ptr Hull -> IO Polygon) -> IO Polygon
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with Hull
a0 ((Ptr Hull -> IO Polygon) -> IO Polygon)
-> (Ptr Hull -> IO Polygon) -> IO Polygon
forall a b. (a -> b) -> a -> b
$ \Ptr Hull
p0 ->
  (Ptr Polygon -> IO Polygon) -> IO Polygon
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr Polygon -> IO Polygon) -> IO Polygon)
-> (Ptr Polygon -> IO Polygon) -> IO Polygon
forall a b. (a -> b) -> a -> b
$ \Ptr Polygon
pOut -> Ptr Hull -> Float -> Ptr Polygon -> IO ()
c_b2MakePolygon Ptr Hull
p0 Float
a1 Ptr Polygon
pOut IO () -> IO Polygon -> IO Polygon
forall a b. IO a -> IO b -> IO b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Ptr Polygon -> IO Polygon
forall a. Storable a => Ptr a -> IO a
peek Ptr Polygon
pOut

{- | Make an offset convex polygon from a convex hull. This will assert if the hull is not valid.
Warning: Do not manually fill in the hull data, it must come directly from b2ComputeHull

Binds @b2MakeOffsetPolygon@.
-}
makeOffsetPolygon
  :: Hull
  -> Vec2
  -- ^ @position@
  -> Rot
  -- ^ @rotation@
  -> IO Polygon
makeOffsetPolygon :: Hull -> Vec2 -> Rot -> IO Polygon
makeOffsetPolygon Hull
a0 Vec2
a1 Rot
a2 =
  Hull -> (Ptr Hull -> IO Polygon) -> IO Polygon
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with Hull
a0 ((Ptr Hull -> IO Polygon) -> IO Polygon)
-> (Ptr Hull -> IO Polygon) -> IO Polygon
forall a b. (a -> b) -> a -> b
$ \Ptr Hull
p0 ->
  Vec2 -> (Ptr Vec2 -> IO Polygon) -> IO Polygon
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with Vec2
a1 ((Ptr Vec2 -> IO Polygon) -> IO Polygon)
-> (Ptr Vec2 -> IO Polygon) -> IO Polygon
forall a b. (a -> b) -> a -> b
$ \Ptr Vec2
p1 ->
  Rot -> (Ptr Rot -> IO Polygon) -> IO Polygon
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with Rot
a2 ((Ptr Rot -> IO Polygon) -> IO Polygon)
-> (Ptr Rot -> IO Polygon) -> IO Polygon
forall a b. (a -> b) -> a -> b
$ \Ptr Rot
p2 ->
  (Ptr Polygon -> IO Polygon) -> IO Polygon
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr Polygon -> IO Polygon) -> IO Polygon)
-> (Ptr Polygon -> IO Polygon) -> IO Polygon
forall a b. (a -> b) -> a -> b
$ \Ptr Polygon
pOut -> Ptr Hull -> Ptr Vec2 -> Ptr Rot -> Ptr Polygon -> IO ()
c_b2MakeOffsetPolygon Ptr Hull
p0 Ptr Vec2
p1 Ptr Rot
p2 Ptr Polygon
pOut IO () -> IO Polygon -> IO Polygon
forall a b. IO a -> IO b -> IO b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Ptr Polygon -> IO Polygon
forall a. Storable a => Ptr a -> IO a
peek Ptr Polygon
pOut

{- | Make an offset convex polygon from a convex hull. This will assert if the hull is not valid.
Warning: Do not manually fill in the hull data, it must come directly from b2ComputeHull

Binds @b2MakeOffsetRoundedPolygon@.
-}
makeOffsetRoundedPolygon
  :: Hull
  -> Vec2
  -- ^ @position@
  -> Rot
  -- ^ @rotation@
  -> Float
  -- ^ @radius@
  -> IO Polygon
makeOffsetRoundedPolygon :: Hull -> Vec2 -> Rot -> Float -> IO Polygon
makeOffsetRoundedPolygon Hull
a0 Vec2
a1 Rot
a2 Float
a3 =
  Hull -> (Ptr Hull -> IO Polygon) -> IO Polygon
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with Hull
a0 ((Ptr Hull -> IO Polygon) -> IO Polygon)
-> (Ptr Hull -> IO Polygon) -> IO Polygon
forall a b. (a -> b) -> a -> b
$ \Ptr Hull
p0 ->
  Vec2 -> (Ptr Vec2 -> IO Polygon) -> IO Polygon
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with Vec2
a1 ((Ptr Vec2 -> IO Polygon) -> IO Polygon)
-> (Ptr Vec2 -> IO Polygon) -> IO Polygon
forall a b. (a -> b) -> a -> b
$ \Ptr Vec2
p1 ->
  Rot -> (Ptr Rot -> IO Polygon) -> IO Polygon
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with Rot
a2 ((Ptr Rot -> IO Polygon) -> IO Polygon)
-> (Ptr Rot -> IO Polygon) -> IO Polygon
forall a b. (a -> b) -> a -> b
$ \Ptr Rot
p2 ->
  (Ptr Polygon -> IO Polygon) -> IO Polygon
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr Polygon -> IO Polygon) -> IO Polygon)
-> (Ptr Polygon -> IO Polygon) -> IO Polygon
forall a b. (a -> b) -> a -> b
$ \Ptr Polygon
pOut -> Ptr Hull -> Ptr Vec2 -> Ptr Rot -> Float -> Ptr Polygon -> IO ()
c_b2MakeOffsetRoundedPolygon Ptr Hull
p0 Ptr Vec2
p1 Ptr Rot
p2 Float
a3 Ptr Polygon
pOut IO () -> IO Polygon -> IO Polygon
forall a b. IO a -> IO b -> IO b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Ptr Polygon -> IO Polygon
forall a. Storable a => Ptr a -> IO a
peek Ptr Polygon
pOut

{- | Make a square polygon, bypassing the need for a convex hull.

Binds @b2MakeSquare@.
-}
makeSquare
  :: Float
  -- ^ @halfWidth@: the half-width
  -> IO Polygon
makeSquare :: Float -> IO Polygon
makeSquare Float
a0 =
  (Ptr Polygon -> IO Polygon) -> IO Polygon
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr Polygon -> IO Polygon) -> IO Polygon)
-> (Ptr Polygon -> IO Polygon) -> IO Polygon
forall a b. (a -> b) -> a -> b
$ \Ptr Polygon
pOut -> Float -> Ptr Polygon -> IO ()
c_b2MakeSquare Float
a0 Ptr Polygon
pOut IO () -> IO Polygon -> IO Polygon
forall a b. IO a -> IO b -> IO b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Ptr Polygon -> IO Polygon
forall a. Storable a => Ptr a -> IO a
peek Ptr Polygon
pOut

-- | Like 'makeSquare', but the result is written into a caller-supplied buffer.
makeSquareInto
  :: Float
  -- ^ @halfWidth@: the half-width
  -> Ptr Polygon
  -- ^ Result buffer.
  -> IO ()
makeSquareInto :: Float -> Ptr Polygon -> IO ()
makeSquareInto Float
a0 Ptr Polygon
out =
  Float -> Ptr Polygon -> IO ()
c_b2MakeSquare Float
a0 Ptr Polygon
out

{- | Make a box (rectangle) polygon, bypassing the need for a convex hull.

Binds @b2MakeBox@.
-}
makeBox
  :: Float
  -- ^ @halfWidth@: the half-width (x-axis)
  -> Float
  -- ^ @halfHeight@: the half-height (y-axis)
  -> IO Polygon
makeBox :: Float -> Float -> IO Polygon
makeBox Float
a0 Float
a1 =
  (Ptr Polygon -> IO Polygon) -> IO Polygon
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr Polygon -> IO Polygon) -> IO Polygon)
-> (Ptr Polygon -> IO Polygon) -> IO Polygon
forall a b. (a -> b) -> a -> b
$ \Ptr Polygon
pOut -> Float -> Float -> Ptr Polygon -> IO ()
c_b2MakeBox Float
a0 Float
a1 Ptr Polygon
pOut IO () -> IO Polygon -> IO Polygon
forall a b. IO a -> IO b -> IO b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Ptr Polygon -> IO Polygon
forall a. Storable a => Ptr a -> IO a
peek Ptr Polygon
pOut

-- | Like 'makeBox', but the result is written into a caller-supplied buffer.
makeBoxInto
  :: Float
  -- ^ @halfWidth@: the half-width (x-axis)
  -> Float
  -- ^ @halfHeight@: the half-height (y-axis)
  -> Ptr Polygon
  -- ^ Result buffer.
  -> IO ()
makeBoxInto :: Float -> Float -> Ptr Polygon -> IO ()
makeBoxInto Float
a0 Float
a1 Ptr Polygon
out =
  Float -> Float -> Ptr Polygon -> IO ()
c_b2MakeBox Float
a0 Float
a1 Ptr Polygon
out

{- | Make a rounded box, bypassing the need for a convex hull.

Binds @b2MakeRoundedBox@.
-}
makeRoundedBox
  :: Float
  -- ^ @halfWidth@: the half-width (x-axis)
  -> Float
  -- ^ @halfHeight@: the half-height (y-axis)
  -> Float
  -- ^ @radius@: the radius of the rounded extension
  -> IO Polygon
makeRoundedBox :: Float -> Float -> Float -> IO Polygon
makeRoundedBox Float
a0 Float
a1 Float
a2 =
  (Ptr Polygon -> IO Polygon) -> IO Polygon
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr Polygon -> IO Polygon) -> IO Polygon)
-> (Ptr Polygon -> IO Polygon) -> IO Polygon
forall a b. (a -> b) -> a -> b
$ \Ptr Polygon
pOut -> Float -> Float -> Float -> Ptr Polygon -> IO ()
c_b2MakeRoundedBox Float
a0 Float
a1 Float
a2 Ptr Polygon
pOut IO () -> IO Polygon -> IO Polygon
forall a b. IO a -> IO b -> IO b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Ptr Polygon -> IO Polygon
forall a. Storable a => Ptr a -> IO a
peek Ptr Polygon
pOut

-- | Like 'makeRoundedBox', but the result is written into a caller-supplied buffer.
makeRoundedBoxInto
  :: Float
  -- ^ @halfWidth@: the half-width (x-axis)
  -> Float
  -- ^ @halfHeight@: the half-height (y-axis)
  -> Float
  -- ^ @radius@: the radius of the rounded extension
  -> Ptr Polygon
  -- ^ Result buffer.
  -> IO ()
makeRoundedBoxInto :: Float -> Float -> Float -> Ptr Polygon -> IO ()
makeRoundedBoxInto Float
a0 Float
a1 Float
a2 Ptr Polygon
out =
  Float -> Float -> Float -> Ptr Polygon -> IO ()
c_b2MakeRoundedBox Float
a0 Float
a1 Float
a2 Ptr Polygon
out

{- | Make an offset box, bypassing the need for a convex hull.

Binds @b2MakeOffsetBox@.
-}
makeOffsetBox
  :: Float
  -- ^ @halfWidth@: the half-width (x-axis)
  -> Float
  -- ^ @halfHeight@: the half-height (y-axis)
  -> Vec2
  -- ^ @center@: the local center of the box
  -> Rot
  -- ^ @rotation@: the local rotation of the box
  -> IO Polygon
makeOffsetBox :: Float -> Float -> Vec2 -> Rot -> IO Polygon
makeOffsetBox Float
a0 Float
a1 Vec2
a2 Rot
a3 =
  Vec2 -> (Ptr Vec2 -> IO Polygon) -> IO Polygon
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with Vec2
a2 ((Ptr Vec2 -> IO Polygon) -> IO Polygon)
-> (Ptr Vec2 -> IO Polygon) -> IO Polygon
forall a b. (a -> b) -> a -> b
$ \Ptr Vec2
p2 ->
  Rot -> (Ptr Rot -> IO Polygon) -> IO Polygon
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with Rot
a3 ((Ptr Rot -> IO Polygon) -> IO Polygon)
-> (Ptr Rot -> IO Polygon) -> IO Polygon
forall a b. (a -> b) -> a -> b
$ \Ptr Rot
p3 ->
  (Ptr Polygon -> IO Polygon) -> IO Polygon
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr Polygon -> IO Polygon) -> IO Polygon)
-> (Ptr Polygon -> IO Polygon) -> IO Polygon
forall a b. (a -> b) -> a -> b
$ \Ptr Polygon
pOut -> Float -> Float -> Ptr Vec2 -> Ptr Rot -> Ptr Polygon -> IO ()
c_b2MakeOffsetBox Float
a0 Float
a1 Ptr Vec2
p2 Ptr Rot
p3 Ptr Polygon
pOut IO () -> IO Polygon -> IO Polygon
forall a b. IO a -> IO b -> IO b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Ptr Polygon -> IO Polygon
forall a. Storable a => Ptr a -> IO a
peek Ptr Polygon
pOut

{- | Make an offset rounded box, bypassing the need for a convex hull.

Binds @b2MakeOffsetRoundedBox@.
-}
makeOffsetRoundedBox
  :: Float
  -- ^ @halfWidth@: the half-width (x-axis)
  -> Float
  -- ^ @halfHeight@: the half-height (y-axis)
  -> Vec2
  -- ^ @center@: the local center of the box
  -> Rot
  -- ^ @rotation@: the local rotation of the box
  -> Float
  -- ^ @radius@: the radius of the rounded extension
  -> IO Polygon
makeOffsetRoundedBox :: Float -> Float -> Vec2 -> Rot -> Float -> IO Polygon
makeOffsetRoundedBox Float
a0 Float
a1 Vec2
a2 Rot
a3 Float
a4 =
  Vec2 -> (Ptr Vec2 -> IO Polygon) -> IO Polygon
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with Vec2
a2 ((Ptr Vec2 -> IO Polygon) -> IO Polygon)
-> (Ptr Vec2 -> IO Polygon) -> IO Polygon
forall a b. (a -> b) -> a -> b
$ \Ptr Vec2
p2 ->
  Rot -> (Ptr Rot -> IO Polygon) -> IO Polygon
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with Rot
a3 ((Ptr Rot -> IO Polygon) -> IO Polygon)
-> (Ptr Rot -> IO Polygon) -> IO Polygon
forall a b. (a -> b) -> a -> b
$ \Ptr Rot
p3 ->
  (Ptr Polygon -> IO Polygon) -> IO Polygon
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr Polygon -> IO Polygon) -> IO Polygon)
-> (Ptr Polygon -> IO Polygon) -> IO Polygon
forall a b. (a -> b) -> a -> b
$ \Ptr Polygon
pOut -> Float
-> Float -> Ptr Vec2 -> Ptr Rot -> Float -> Ptr Polygon -> IO ()
c_b2MakeOffsetRoundedBox Float
a0 Float
a1 Ptr Vec2
p2 Ptr Rot
p3 Float
a4 Ptr Polygon
pOut IO () -> IO Polygon -> IO Polygon
forall a b. IO a -> IO b -> IO b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Ptr Polygon -> IO Polygon
forall a. Storable a => Ptr a -> IO a
peek Ptr Polygon
pOut

{- | Transform a polygon. This is useful for transferring a shape from one body to another.

Binds @b2TransformPolygon@.
-}
transformPolygon
  :: Transform
  -> Polygon
  -> IO Polygon
transformPolygon :: Transform -> Polygon -> IO Polygon
transformPolygon Transform
a0 Polygon
a1 =
  Transform -> (Ptr Transform -> IO Polygon) -> IO Polygon
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with Transform
a0 ((Ptr Transform -> IO Polygon) -> IO Polygon)
-> (Ptr Transform -> IO Polygon) -> IO Polygon
forall a b. (a -> b) -> a -> b
$ \Ptr Transform
p0 ->
  Polygon -> (Ptr Polygon -> IO Polygon) -> IO Polygon
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with Polygon
a1 ((Ptr Polygon -> IO Polygon) -> IO Polygon)
-> (Ptr Polygon -> IO Polygon) -> IO Polygon
forall a b. (a -> b) -> a -> b
$ \Ptr Polygon
p1 ->
  (Ptr Polygon -> IO Polygon) -> IO Polygon
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr Polygon -> IO Polygon) -> IO Polygon)
-> (Ptr Polygon -> IO Polygon) -> IO Polygon
forall a b. (a -> b) -> a -> b
$ \Ptr Polygon
pOut -> Ptr Transform -> Ptr Polygon -> Ptr Polygon -> IO ()
c_b2TransformPolygon Ptr Transform
p0 Ptr Polygon
p1 Ptr Polygon
pOut IO () -> IO Polygon -> IO Polygon
forall a b. IO a -> IO b -> IO b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Ptr Polygon -> IO Polygon
forall a. Storable a => Ptr a -> IO a
peek Ptr Polygon
pOut

{- | Compute mass properties of a circle

Binds @b2ComputeCircleMass@.
-}
computeCircleMass
  :: Circle
  -- ^ @shape@
  -> Float
  -- ^ @density@
  -> IO MassData
computeCircleMass :: Circle -> Float -> IO MassData
computeCircleMass Circle
a0 Float
a1 =
  Circle -> (Ptr Circle -> IO MassData) -> IO MassData
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with Circle
a0 ((Ptr Circle -> IO MassData) -> IO MassData)
-> (Ptr Circle -> IO MassData) -> IO MassData
forall a b. (a -> b) -> a -> b
$ \Ptr Circle
p0 ->
  (Ptr MassData -> IO MassData) -> IO MassData
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr MassData -> IO MassData) -> IO MassData)
-> (Ptr MassData -> IO MassData) -> IO MassData
forall a b. (a -> b) -> a -> b
$ \Ptr MassData
pOut -> Ptr Circle -> Float -> Ptr MassData -> IO ()
c_b2ComputeCircleMass Ptr Circle
p0 Float
a1 Ptr MassData
pOut IO () -> IO MassData -> IO MassData
forall a b. IO a -> IO b -> IO b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Ptr MassData -> IO MassData
forall a. Storable a => Ptr a -> IO a
peek Ptr MassData
pOut

{- | Compute mass properties of a capsule

Binds @b2ComputeCapsuleMass@.
-}
computeCapsuleMass
  :: Capsule
  -- ^ @shape@
  -> Float
  -- ^ @density@
  -> IO MassData
computeCapsuleMass :: Capsule -> Float -> IO MassData
computeCapsuleMass Capsule
a0 Float
a1 =
  Capsule -> (Ptr Capsule -> IO MassData) -> IO MassData
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with Capsule
a0 ((Ptr Capsule -> IO MassData) -> IO MassData)
-> (Ptr Capsule -> IO MassData) -> IO MassData
forall a b. (a -> b) -> a -> b
$ \Ptr Capsule
p0 ->
  (Ptr MassData -> IO MassData) -> IO MassData
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr MassData -> IO MassData) -> IO MassData)
-> (Ptr MassData -> IO MassData) -> IO MassData
forall a b. (a -> b) -> a -> b
$ \Ptr MassData
pOut -> Ptr Capsule -> Float -> Ptr MassData -> IO ()
c_b2ComputeCapsuleMass Ptr Capsule
p0 Float
a1 Ptr MassData
pOut IO () -> IO MassData -> IO MassData
forall a b. IO a -> IO b -> IO b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Ptr MassData -> IO MassData
forall a. Storable a => Ptr a -> IO a
peek Ptr MassData
pOut

{- | Compute mass properties of a polygon

Binds @b2ComputePolygonMass@.
-}
computePolygonMass
  :: Polygon
  -- ^ @shape@
  -> Float
  -- ^ @density@
  -> IO MassData
computePolygonMass :: Polygon -> Float -> IO MassData
computePolygonMass Polygon
a0 Float
a1 =
  Polygon -> (Ptr Polygon -> IO MassData) -> IO MassData
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with Polygon
a0 ((Ptr Polygon -> IO MassData) -> IO MassData)
-> (Ptr Polygon -> IO MassData) -> IO MassData
forall a b. (a -> b) -> a -> b
$ \Ptr Polygon
p0 ->
  (Ptr MassData -> IO MassData) -> IO MassData
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr MassData -> IO MassData) -> IO MassData)
-> (Ptr MassData -> IO MassData) -> IO MassData
forall a b. (a -> b) -> a -> b
$ \Ptr MassData
pOut -> Ptr Polygon -> Float -> Ptr MassData -> IO ()
c_b2ComputePolygonMass Ptr Polygon
p0 Float
a1 Ptr MassData
pOut IO () -> IO MassData -> IO MassData
forall a b. IO a -> IO b -> IO b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Ptr MassData -> IO MassData
forall a. Storable a => Ptr a -> IO a
peek Ptr MassData
pOut

{- | Compute the bounding box of a transformed circle

Binds @b2ComputeCircleAABB@.
-}
computeCircleAABB
  :: Circle
  -- ^ @shape@
  -> WorldTransform
  -> IO AABB
computeCircleAABB :: Circle -> Transform -> IO AABB
computeCircleAABB Circle
a0 Transform
a1 =
  Circle -> (Ptr Circle -> IO AABB) -> IO AABB
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with Circle
a0 ((Ptr Circle -> IO AABB) -> IO AABB)
-> (Ptr Circle -> IO AABB) -> IO AABB
forall a b. (a -> b) -> a -> b
$ \Ptr Circle
p0 ->
  Transform -> (Ptr Transform -> IO AABB) -> IO AABB
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with Transform
a1 ((Ptr Transform -> IO AABB) -> IO AABB)
-> (Ptr Transform -> IO AABB) -> IO AABB
forall a b. (a -> b) -> a -> b
$ \Ptr Transform
p1 ->
  (Ptr AABB -> IO AABB) -> IO AABB
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr AABB -> IO AABB) -> IO AABB)
-> (Ptr AABB -> IO AABB) -> IO AABB
forall a b. (a -> b) -> a -> b
$ \Ptr AABB
pOut -> Ptr Circle -> Ptr Transform -> Ptr AABB -> IO ()
c_b2ComputeCircleAABB Ptr Circle
p0 Ptr Transform
p1 Ptr AABB
pOut IO () -> IO AABB -> IO AABB
forall a b. IO a -> IO b -> IO b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Ptr AABB -> IO AABB
forall a. Storable a => Ptr a -> IO a
peek Ptr AABB
pOut

{- | Compute the bounding box of a transformed capsule

Binds @b2ComputeCapsuleAABB@.
-}
computeCapsuleAABB
  :: Capsule
  -- ^ @shape@
  -> WorldTransform
  -> IO AABB
computeCapsuleAABB :: Capsule -> Transform -> IO AABB
computeCapsuleAABB Capsule
a0 Transform
a1 =
  Capsule -> (Ptr Capsule -> IO AABB) -> IO AABB
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with Capsule
a0 ((Ptr Capsule -> IO AABB) -> IO AABB)
-> (Ptr Capsule -> IO AABB) -> IO AABB
forall a b. (a -> b) -> a -> b
$ \Ptr Capsule
p0 ->
  Transform -> (Ptr Transform -> IO AABB) -> IO AABB
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with Transform
a1 ((Ptr Transform -> IO AABB) -> IO AABB)
-> (Ptr Transform -> IO AABB) -> IO AABB
forall a b. (a -> b) -> a -> b
$ \Ptr Transform
p1 ->
  (Ptr AABB -> IO AABB) -> IO AABB
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr AABB -> IO AABB) -> IO AABB)
-> (Ptr AABB -> IO AABB) -> IO AABB
forall a b. (a -> b) -> a -> b
$ \Ptr AABB
pOut -> Ptr Capsule -> Ptr Transform -> Ptr AABB -> IO ()
c_b2ComputeCapsuleAABB Ptr Capsule
p0 Ptr Transform
p1 Ptr AABB
pOut IO () -> IO AABB -> IO AABB
forall a b. IO a -> IO b -> IO b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Ptr AABB -> IO AABB
forall a. Storable a => Ptr a -> IO a
peek Ptr AABB
pOut

{- | Compute the bounding box of a transformed polygon

Binds @b2ComputePolygonAABB@.
-}
computePolygonAABB
  :: Polygon
  -- ^ @shape@
  -> WorldTransform
  -> IO AABB
computePolygonAABB :: Polygon -> Transform -> IO AABB
computePolygonAABB Polygon
a0 Transform
a1 =
  Polygon -> (Ptr Polygon -> IO AABB) -> IO AABB
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with Polygon
a0 ((Ptr Polygon -> IO AABB) -> IO AABB)
-> (Ptr Polygon -> IO AABB) -> IO AABB
forall a b. (a -> b) -> a -> b
$ \Ptr Polygon
p0 ->
  Transform -> (Ptr Transform -> IO AABB) -> IO AABB
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with Transform
a1 ((Ptr Transform -> IO AABB) -> IO AABB)
-> (Ptr Transform -> IO AABB) -> IO AABB
forall a b. (a -> b) -> a -> b
$ \Ptr Transform
p1 ->
  (Ptr AABB -> IO AABB) -> IO AABB
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr AABB -> IO AABB) -> IO AABB)
-> (Ptr AABB -> IO AABB) -> IO AABB
forall a b. (a -> b) -> a -> b
$ \Ptr AABB
pOut -> Ptr Polygon -> Ptr Transform -> Ptr AABB -> IO ()
c_b2ComputePolygonAABB Ptr Polygon
p0 Ptr Transform
p1 Ptr AABB
pOut IO () -> IO AABB -> IO AABB
forall a b. IO a -> IO b -> IO b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Ptr AABB -> IO AABB
forall a. Storable a => Ptr a -> IO a
peek Ptr AABB
pOut

{- | Compute the bounding box of a transformed line segment

Binds @b2ComputeSegmentAABB@.
-}
computeSegmentAABB
  :: Segment
  -- ^ @shape@
  -> WorldTransform
  -> IO AABB
computeSegmentAABB :: Segment -> Transform -> IO AABB
computeSegmentAABB Segment
a0 Transform
a1 =
  Segment -> (Ptr Segment -> IO AABB) -> IO AABB
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with Segment
a0 ((Ptr Segment -> IO AABB) -> IO AABB)
-> (Ptr Segment -> IO AABB) -> IO AABB
forall a b. (a -> b) -> a -> b
$ \Ptr Segment
p0 ->
  Transform -> (Ptr Transform -> IO AABB) -> IO AABB
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with Transform
a1 ((Ptr Transform -> IO AABB) -> IO AABB)
-> (Ptr Transform -> IO AABB) -> IO AABB
forall a b. (a -> b) -> a -> b
$ \Ptr Transform
p1 ->
  (Ptr AABB -> IO AABB) -> IO AABB
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr AABB -> IO AABB) -> IO AABB)
-> (Ptr AABB -> IO AABB) -> IO AABB
forall a b. (a -> b) -> a -> b
$ \Ptr AABB
pOut -> Ptr Segment -> Ptr Transform -> Ptr AABB -> IO ()
c_b2ComputeSegmentAABB Ptr Segment
p0 Ptr Transform
p1 Ptr AABB
pOut IO () -> IO AABB -> IO AABB
forall a b. IO a -> IO b -> IO b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Ptr AABB -> IO AABB
forall a. Storable a => Ptr a -> IO a
peek Ptr AABB
pOut

{- | Test a point for overlap with a circle in local space

Binds @b2PointInCircle@.
-}
pointInCircle
  :: Circle
  -- ^ @shape@
  -> Vec2
  -- ^ @point@
  -> IO Bool
pointInCircle :: Circle -> Vec2 -> IO Bool
pointInCircle Circle
a0 Vec2
a1 =
  Circle -> (Ptr Circle -> IO Bool) -> IO Bool
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with Circle
a0 ((Ptr Circle -> IO Bool) -> IO Bool)
-> (Ptr Circle -> IO Bool) -> IO Bool
forall a b. (a -> b) -> a -> b
$ \Ptr Circle
p0 ->
  Vec2 -> (Ptr Vec2 -> IO Bool) -> IO Bool
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with Vec2
a1 ((Ptr Vec2 -> IO Bool) -> IO Bool)
-> (Ptr Vec2 -> IO Bool) -> IO Bool
forall a b. (a -> b) -> a -> b
$ \Ptr Vec2
p1 ->
  CBool -> Bool
forall a. (Eq a, Num a) => a -> Bool
toBool (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Ptr Circle -> Ptr Vec2 -> IO CBool
c_b2PointInCircle Ptr Circle
p0 Ptr Vec2
p1)

{- | Test a point for overlap with a capsule in local space

Binds @b2PointInCapsule@.
-}
pointInCapsule
  :: Capsule
  -- ^ @shape@
  -> Vec2
  -- ^ @point@
  -> IO Bool
pointInCapsule :: Capsule -> Vec2 -> IO Bool
pointInCapsule Capsule
a0 Vec2
a1 =
  Capsule -> (Ptr Capsule -> IO Bool) -> IO Bool
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with Capsule
a0 ((Ptr Capsule -> IO Bool) -> IO Bool)
-> (Ptr Capsule -> IO Bool) -> IO Bool
forall a b. (a -> b) -> a -> b
$ \Ptr Capsule
p0 ->
  Vec2 -> (Ptr Vec2 -> IO Bool) -> IO Bool
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with Vec2
a1 ((Ptr Vec2 -> IO Bool) -> IO Bool)
-> (Ptr Vec2 -> IO Bool) -> IO Bool
forall a b. (a -> b) -> a -> b
$ \Ptr Vec2
p1 ->
  CBool -> Bool
forall a. (Eq a, Num a) => a -> Bool
toBool (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Ptr Capsule -> Ptr Vec2 -> IO CBool
c_b2PointInCapsule Ptr Capsule
p0 Ptr Vec2
p1)

{- | Test a point for overlap with a convex polygon in local space

Binds @b2PointInPolygon@.
-}
pointInPolygon
  :: Polygon
  -- ^ @shape@
  -> Vec2
  -- ^ @point@
  -> IO Bool
pointInPolygon :: Polygon -> Vec2 -> IO Bool
pointInPolygon Polygon
a0 Vec2
a1 =
  Polygon -> (Ptr Polygon -> IO Bool) -> IO Bool
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with Polygon
a0 ((Ptr Polygon -> IO Bool) -> IO Bool)
-> (Ptr Polygon -> IO Bool) -> IO Bool
forall a b. (a -> b) -> a -> b
$ \Ptr Polygon
p0 ->
  Vec2 -> (Ptr Vec2 -> IO Bool) -> IO Bool
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with Vec2
a1 ((Ptr Vec2 -> IO Bool) -> IO Bool)
-> (Ptr Vec2 -> IO Bool) -> IO Bool
forall a b. (a -> b) -> a -> b
$ \Ptr Vec2
p1 ->
  CBool -> Bool
forall a. (Eq a, Num a) => a -> Bool
toBool (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Ptr Polygon -> Ptr Vec2 -> IO CBool
c_b2PointInPolygon Ptr Polygon
p0 Ptr Vec2
p1)

{- | Ray cast versus circle shape in local space.

Binds @b2RayCastCircle@.
-}
rayCastCircle
  :: Circle
  -- ^ @shape@
  -> RayCastInput
  -> IO CastOutput
rayCastCircle :: Circle -> RayCastInput -> IO CastOutput
rayCastCircle Circle
a0 RayCastInput
a1 =
  Circle -> (Ptr Circle -> IO CastOutput) -> IO CastOutput
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with Circle
a0 ((Ptr Circle -> IO CastOutput) -> IO CastOutput)
-> (Ptr Circle -> IO CastOutput) -> IO CastOutput
forall a b. (a -> b) -> a -> b
$ \Ptr Circle
p0 ->
  RayCastInput
-> (Ptr RayCastInput -> IO CastOutput) -> IO CastOutput
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with RayCastInput
a1 ((Ptr RayCastInput -> IO CastOutput) -> IO CastOutput)
-> (Ptr RayCastInput -> IO CastOutput) -> IO CastOutput
forall a b. (a -> b) -> a -> b
$ \Ptr RayCastInput
p1 ->
  (Ptr CastOutput -> IO CastOutput) -> IO CastOutput
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr CastOutput -> IO CastOutput) -> IO CastOutput)
-> (Ptr CastOutput -> IO CastOutput) -> IO CastOutput
forall a b. (a -> b) -> a -> b
$ \Ptr CastOutput
pOut -> Ptr Circle -> Ptr RayCastInput -> Ptr CastOutput -> IO ()
c_b2RayCastCircle Ptr Circle
p0 Ptr RayCastInput
p1 Ptr CastOutput
pOut IO () -> IO CastOutput -> IO CastOutput
forall a b. IO a -> IO b -> IO b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Ptr CastOutput -> IO CastOutput
forall a. Storable a => Ptr a -> IO a
peek Ptr CastOutput
pOut

{- | Ray cast versus capsule shape in local space.

Binds @b2RayCastCapsule@.
-}
rayCastCapsule
  :: Capsule
  -- ^ @shape@
  -> RayCastInput
  -> IO CastOutput
rayCastCapsule :: Capsule -> RayCastInput -> IO CastOutput
rayCastCapsule Capsule
a0 RayCastInput
a1 =
  Capsule -> (Ptr Capsule -> IO CastOutput) -> IO CastOutput
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with Capsule
a0 ((Ptr Capsule -> IO CastOutput) -> IO CastOutput)
-> (Ptr Capsule -> IO CastOutput) -> IO CastOutput
forall a b. (a -> b) -> a -> b
$ \Ptr Capsule
p0 ->
  RayCastInput
-> (Ptr RayCastInput -> IO CastOutput) -> IO CastOutput
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with RayCastInput
a1 ((Ptr RayCastInput -> IO CastOutput) -> IO CastOutput)
-> (Ptr RayCastInput -> IO CastOutput) -> IO CastOutput
forall a b. (a -> b) -> a -> b
$ \Ptr RayCastInput
p1 ->
  (Ptr CastOutput -> IO CastOutput) -> IO CastOutput
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr CastOutput -> IO CastOutput) -> IO CastOutput)
-> (Ptr CastOutput -> IO CastOutput) -> IO CastOutput
forall a b. (a -> b) -> a -> b
$ \Ptr CastOutput
pOut -> Ptr Capsule -> Ptr RayCastInput -> Ptr CastOutput -> IO ()
c_b2RayCastCapsule Ptr Capsule
p0 Ptr RayCastInput
p1 Ptr CastOutput
pOut IO () -> IO CastOutput -> IO CastOutput
forall a b. IO a -> IO b -> IO b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Ptr CastOutput -> IO CastOutput
forall a. Storable a => Ptr a -> IO a
peek Ptr CastOutput
pOut

{- | Ray cast versus segment shape in local space. Optionally treat the segment as one-sided with hits from
the left side being treated as a miss.

Binds @b2RayCastSegment@.
-}
rayCastSegment
  :: Segment
  -- ^ @shape@
  -> RayCastInput
  -> Bool
  -- ^ @oneSided@
  -> IO CastOutput
rayCastSegment :: Segment -> RayCastInput -> Bool -> IO CastOutput
rayCastSegment Segment
a0 RayCastInput
a1 Bool
a2 =
  Segment -> (Ptr Segment -> IO CastOutput) -> IO CastOutput
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with Segment
a0 ((Ptr Segment -> IO CastOutput) -> IO CastOutput)
-> (Ptr Segment -> IO CastOutput) -> IO CastOutput
forall a b. (a -> b) -> a -> b
$ \Ptr Segment
p0 ->
  RayCastInput
-> (Ptr RayCastInput -> IO CastOutput) -> IO CastOutput
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with RayCastInput
a1 ((Ptr RayCastInput -> IO CastOutput) -> IO CastOutput)
-> (Ptr RayCastInput -> IO CastOutput) -> IO CastOutput
forall a b. (a -> b) -> a -> b
$ \Ptr RayCastInput
p1 ->
  (Ptr CastOutput -> IO CastOutput) -> IO CastOutput
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr CastOutput -> IO CastOutput) -> IO CastOutput)
-> (Ptr CastOutput -> IO CastOutput) -> IO CastOutput
forall a b. (a -> b) -> a -> b
$ \Ptr CastOutput
pOut -> Ptr Segment -> Ptr RayCastInput -> CBool -> Ptr CastOutput -> IO ()
c_b2RayCastSegment Ptr Segment
p0 Ptr RayCastInput
p1 (Bool -> CBool
forall a. Num a => Bool -> a
fromBool Bool
a2) Ptr CastOutput
pOut IO () -> IO CastOutput -> IO CastOutput
forall a b. IO a -> IO b -> IO b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Ptr CastOutput -> IO CastOutput
forall a. Storable a => Ptr a -> IO a
peek Ptr CastOutput
pOut

{- | Ray cast versus polygon shape in local space.

Binds @b2RayCastPolygon@.
-}
rayCastPolygon
  :: Polygon
  -- ^ @shape@
  -> RayCastInput
  -> IO CastOutput
rayCastPolygon :: Polygon -> RayCastInput -> IO CastOutput
rayCastPolygon Polygon
a0 RayCastInput
a1 =
  Polygon -> (Ptr Polygon -> IO CastOutput) -> IO CastOutput
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with Polygon
a0 ((Ptr Polygon -> IO CastOutput) -> IO CastOutput)
-> (Ptr Polygon -> IO CastOutput) -> IO CastOutput
forall a b. (a -> b) -> a -> b
$ \Ptr Polygon
p0 ->
  RayCastInput
-> (Ptr RayCastInput -> IO CastOutput) -> IO CastOutput
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with RayCastInput
a1 ((Ptr RayCastInput -> IO CastOutput) -> IO CastOutput)
-> (Ptr RayCastInput -> IO CastOutput) -> IO CastOutput
forall a b. (a -> b) -> a -> b
$ \Ptr RayCastInput
p1 ->
  (Ptr CastOutput -> IO CastOutput) -> IO CastOutput
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr CastOutput -> IO CastOutput) -> IO CastOutput)
-> (Ptr CastOutput -> IO CastOutput) -> IO CastOutput
forall a b. (a -> b) -> a -> b
$ \Ptr CastOutput
pOut -> Ptr Polygon -> Ptr RayCastInput -> Ptr CastOutput -> IO ()
c_b2RayCastPolygon Ptr Polygon
p0 Ptr RayCastInput
p1 Ptr CastOutput
pOut IO () -> IO CastOutput -> IO CastOutput
forall a b. IO a -> IO b -> IO b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Ptr CastOutput -> IO CastOutput
forall a. Storable a => Ptr a -> IO a
peek Ptr CastOutput
pOut

{- | Shape cast versus a circle.

Binds @b2ShapeCastCircle@.
-}
shapeCastCircle
  :: Circle
  -- ^ @shape@
  -> Ptr ShapeCastInput
  -> IO CastOutput
shapeCastCircle :: Circle -> Ptr ShapeCastInput -> IO CastOutput
shapeCastCircle Circle
a0 Ptr ShapeCastInput
a1 =
  Circle -> (Ptr Circle -> IO CastOutput) -> IO CastOutput
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with Circle
a0 ((Ptr Circle -> IO CastOutput) -> IO CastOutput)
-> (Ptr Circle -> IO CastOutput) -> IO CastOutput
forall a b. (a -> b) -> a -> b
$ \Ptr Circle
p0 ->
  (Ptr CastOutput -> IO CastOutput) -> IO CastOutput
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr CastOutput -> IO CastOutput) -> IO CastOutput)
-> (Ptr CastOutput -> IO CastOutput) -> IO CastOutput
forall a b. (a -> b) -> a -> b
$ \Ptr CastOutput
pOut -> Ptr Circle -> Ptr ShapeCastInput -> Ptr CastOutput -> IO ()
c_b2ShapeCastCircle Ptr Circle
p0 Ptr ShapeCastInput
a1 Ptr CastOutput
pOut IO () -> IO CastOutput -> IO CastOutput
forall a b. IO a -> IO b -> IO b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Ptr CastOutput -> IO CastOutput
forall a. Storable a => Ptr a -> IO a
peek Ptr CastOutput
pOut

{- | Shape cast versus a capsule.

Binds @b2ShapeCastCapsule@.
-}
shapeCastCapsule
  :: Capsule
  -- ^ @shape@
  -> Ptr ShapeCastInput
  -> IO CastOutput
shapeCastCapsule :: Capsule -> Ptr ShapeCastInput -> IO CastOutput
shapeCastCapsule Capsule
a0 Ptr ShapeCastInput
a1 =
  Capsule -> (Ptr Capsule -> IO CastOutput) -> IO CastOutput
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with Capsule
a0 ((Ptr Capsule -> IO CastOutput) -> IO CastOutput)
-> (Ptr Capsule -> IO CastOutput) -> IO CastOutput
forall a b. (a -> b) -> a -> b
$ \Ptr Capsule
p0 ->
  (Ptr CastOutput -> IO CastOutput) -> IO CastOutput
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr CastOutput -> IO CastOutput) -> IO CastOutput)
-> (Ptr CastOutput -> IO CastOutput) -> IO CastOutput
forall a b. (a -> b) -> a -> b
$ \Ptr CastOutput
pOut -> Ptr Capsule -> Ptr ShapeCastInput -> Ptr CastOutput -> IO ()
c_b2ShapeCastCapsule Ptr Capsule
p0 Ptr ShapeCastInput
a1 Ptr CastOutput
pOut IO () -> IO CastOutput -> IO CastOutput
forall a b. IO a -> IO b -> IO b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Ptr CastOutput -> IO CastOutput
forall a. Storable a => Ptr a -> IO a
peek Ptr CastOutput
pOut

{- | Shape cast versus a line segment.

Binds @b2ShapeCastSegment@.
-}
shapeCastSegment
  :: Segment
  -- ^ @shape@
  -> Ptr ShapeCastInput
  -> IO CastOutput
shapeCastSegment :: Segment -> Ptr ShapeCastInput -> IO CastOutput
shapeCastSegment Segment
a0 Ptr ShapeCastInput
a1 =
  Segment -> (Ptr Segment -> IO CastOutput) -> IO CastOutput
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with Segment
a0 ((Ptr Segment -> IO CastOutput) -> IO CastOutput)
-> (Ptr Segment -> IO CastOutput) -> IO CastOutput
forall a b. (a -> b) -> a -> b
$ \Ptr Segment
p0 ->
  (Ptr CastOutput -> IO CastOutput) -> IO CastOutput
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr CastOutput -> IO CastOutput) -> IO CastOutput)
-> (Ptr CastOutput -> IO CastOutput) -> IO CastOutput
forall a b. (a -> b) -> a -> b
$ \Ptr CastOutput
pOut -> Ptr Segment -> Ptr ShapeCastInput -> Ptr CastOutput -> IO ()
c_b2ShapeCastSegment Ptr Segment
p0 Ptr ShapeCastInput
a1 Ptr CastOutput
pOut IO () -> IO CastOutput -> IO CastOutput
forall a b. IO a -> IO b -> IO b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Ptr CastOutput -> IO CastOutput
forall a. Storable a => Ptr a -> IO a
peek Ptr CastOutput
pOut

{- | Shape cast versus a convex polygon.

Binds @b2ShapeCastPolygon@.
-}
shapeCastPolygon
  :: Polygon
  -- ^ @shape@
  -> Ptr ShapeCastInput
  -> IO CastOutput
shapeCastPolygon :: Polygon -> Ptr ShapeCastInput -> IO CastOutput
shapeCastPolygon Polygon
a0 Ptr ShapeCastInput
a1 =
  Polygon -> (Ptr Polygon -> IO CastOutput) -> IO CastOutput
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with Polygon
a0 ((Ptr Polygon -> IO CastOutput) -> IO CastOutput)
-> (Ptr Polygon -> IO CastOutput) -> IO CastOutput
forall a b. (a -> b) -> a -> b
$ \Ptr Polygon
p0 ->
  (Ptr CastOutput -> IO CastOutput) -> IO CastOutput
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr CastOutput -> IO CastOutput) -> IO CastOutput)
-> (Ptr CastOutput -> IO CastOutput) -> IO CastOutput
forall a b. (a -> b) -> a -> b
$ \Ptr CastOutput
pOut -> Ptr Polygon -> Ptr ShapeCastInput -> Ptr CastOutput -> IO ()
c_b2ShapeCastPolygon Ptr Polygon
p0 Ptr ShapeCastInput
a1 Ptr CastOutput
pOut IO () -> IO CastOutput -> IO CastOutput
forall a b. IO a -> IO b -> IO b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Ptr CastOutput -> IO CastOutput
forall a. Storable a => Ptr a -> IO a
peek Ptr CastOutput
pOut

{- | Compute the convex hull of a set of points. Returns an empty hull if it fails.
Some failure cases:
- all points very close together
- all points on a line
- less than 3 points
- more than B2_MAX_POLYGON_VERTICES points
This welds close points and removes collinear points.
Warning: Do not modify a hull once it has been computed

Binds @b2ComputeHull@.
-}
computeHull
  :: Ptr Vec2
  -- ^ @points@
  -> Int
  -- ^ @count@
  -> IO Hull
computeHull :: Ptr Vec2 -> Int -> IO Hull
computeHull Ptr Vec2
a0 Int
a1 =
  (Ptr Hull -> IO Hull) -> IO Hull
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr Hull -> IO Hull) -> IO Hull)
-> (Ptr Hull -> IO Hull) -> IO Hull
forall a b. (a -> b) -> a -> b
$ \Ptr Hull
pOut -> Ptr Vec2 -> CInt -> Ptr Hull -> IO ()
c_b2ComputeHull Ptr Vec2
a0 (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
a1) Ptr Hull
pOut IO () -> IO Hull -> IO Hull
forall a b. IO a -> IO b -> IO b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Ptr Hull -> IO Hull
forall a. Storable a => Ptr a -> IO a
peek Ptr Hull
pOut

-- | Like 'computeHull', but the result is written into a caller-supplied buffer.
computeHullInto
  :: Ptr Vec2
  -- ^ @points@
  -> Int
  -- ^ @count@
  -> Ptr Hull
  -- ^ Result buffer.
  -> IO ()
computeHullInto :: Ptr Vec2 -> Int -> Ptr Hull -> IO ()
computeHullInto Ptr Vec2
a0 Int
a1 Ptr Hull
out =
  Ptr Vec2 -> CInt -> Ptr Hull -> IO ()
c_b2ComputeHull Ptr Vec2
a0 (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
a1) Ptr Hull
out

{- | This determines if a hull is valid. Checks for:
- convexity
- collinear points
This is expensive and should not be called at runtime.

Binds @b2ValidateHull@.
-}
validateHull
  :: Hull
  -> IO Bool
validateHull :: Hull -> IO Bool
validateHull Hull
a0 =
  Hull -> (Ptr Hull -> IO Bool) -> IO Bool
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with Hull
a0 ((Ptr Hull -> IO Bool) -> IO Bool)
-> (Ptr Hull -> IO Bool) -> IO Bool
forall a b. (a -> b) -> a -> b
$ \Ptr Hull
p0 ->
  CBool -> Bool
forall a. (Eq a, Num a) => a -> Bool
toBool (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Ptr Hull -> IO CBool
c_b2ValidateHull Ptr Hull
p0)

{- | Compute the distance between two line segments, clamping at the end points if needed.

Binds @b2SegmentDistance@.
-}
segmentDistance
  :: Vec2
  -- ^ @p1@
  -> Vec2
  -- ^ @q1@
  -> Vec2
  -- ^ @p2@
  -> Vec2
  -- ^ @q2@
  -> Ptr SegmentDistanceResult
  -- ^ Result buffer.
  -> IO ()
segmentDistance :: Vec2 -> Vec2 -> Vec2 -> Vec2 -> Ptr SegmentDistanceResult -> IO ()
segmentDistance Vec2
a0 Vec2
a1 Vec2
a2 Vec2
a3 Ptr SegmentDistanceResult
out =
  Vec2 -> (Ptr Vec2 -> IO ()) -> IO ()
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with Vec2
a0 ((Ptr Vec2 -> IO ()) -> IO ()) -> (Ptr Vec2 -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr Vec2
p0 ->
  Vec2 -> (Ptr Vec2 -> IO ()) -> IO ()
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with Vec2
a1 ((Ptr Vec2 -> IO ()) -> IO ()) -> (Ptr Vec2 -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr Vec2
p1 ->
  Vec2 -> (Ptr Vec2 -> IO ()) -> IO ()
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with Vec2
a2 ((Ptr Vec2 -> IO ()) -> IO ()) -> (Ptr Vec2 -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr Vec2
p2 ->
  Vec2 -> (Ptr Vec2 -> IO ()) -> IO ()
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with Vec2
a3 ((Ptr Vec2 -> IO ()) -> IO ()) -> (Ptr Vec2 -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr Vec2
p3 ->
  Ptr Vec2
-> Ptr Vec2
-> Ptr Vec2
-> Ptr Vec2
-> Ptr SegmentDistanceResult
-> IO ()
c_b2SegmentDistance Ptr Vec2
p0 Ptr Vec2
p1 Ptr Vec2
p2 Ptr Vec2
p3 Ptr SegmentDistanceResult
out

{- | Compute the closest points between two shapes represented as point clouds.
b2SimplexCache cache is input\/output. On the first call set b2SimplexCache.count to zero.
The underlying GJK algorithm may be debugged by passing in debug simplexes and capacity. You may pass in NULL and 0 for these.

Binds @b2ShapeDistance@.
-}
shapeDistance
  :: Ptr DistanceInput
  -> Ptr SimplexCache
  -> Ptr Simplex
  -- ^ @simplexes@
  -> Int
  -- ^ @simplexCapacity@
  -> Ptr DistanceOutput
  -- ^ Result buffer.
  -> IO ()
shapeDistance :: Ptr DistanceInput
-> Ptr SimplexCache
-> Ptr Simplex
-> Int
-> Ptr DistanceOutput
-> IO ()
shapeDistance Ptr DistanceInput
a0 Ptr SimplexCache
a1 Ptr Simplex
a2 Int
a3 Ptr DistanceOutput
out =
  Ptr DistanceInput
-> Ptr SimplexCache
-> Ptr Simplex
-> CInt
-> Ptr DistanceOutput
-> IO ()
c_b2ShapeDistance Ptr DistanceInput
a0 Ptr SimplexCache
a1 Ptr Simplex
a2 (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
a3) Ptr DistanceOutput
out

{- | Perform a linear shape cast of shape B moving and shape A fixed. Determines the hit point, normal, and translation fraction.
The query runs in frame A, so the hit point and normal are returned in frame A. Initially touching shapes are a miss.

Binds @b2ShapeCast@.
-}
shapeCast
  :: Ptr ShapeCastPairInput
  -> IO CastOutput
shapeCast :: Ptr ShapeCastPairInput -> IO CastOutput
shapeCast Ptr ShapeCastPairInput
a0 =
  (Ptr CastOutput -> IO CastOutput) -> IO CastOutput
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr CastOutput -> IO CastOutput) -> IO CastOutput)
-> (Ptr CastOutput -> IO CastOutput) -> IO CastOutput
forall a b. (a -> b) -> a -> b
$ \Ptr CastOutput
pOut -> Ptr ShapeCastPairInput -> Ptr CastOutput -> IO ()
c_b2ShapeCast Ptr ShapeCastPairInput
a0 Ptr CastOutput
pOut IO () -> IO CastOutput -> IO CastOutput
forall a b. IO a -> IO b -> IO b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Ptr CastOutput -> IO CastOutput
forall a. Storable a => Ptr a -> IO a
peek Ptr CastOutput
pOut

-- | Like 'shapeCast', but the result is written into a caller-supplied buffer.
shapeCastInto
  :: Ptr ShapeCastPairInput
  -> Ptr CastOutput
  -- ^ Result buffer.
  -> IO ()
shapeCastInto :: Ptr ShapeCastPairInput -> Ptr CastOutput -> IO ()
shapeCastInto Ptr ShapeCastPairInput
a0 Ptr CastOutput
out =
  Ptr ShapeCastPairInput -> Ptr CastOutput -> IO ()
c_b2ShapeCast Ptr ShapeCastPairInput
a0 Ptr CastOutput
out

{- | Make a proxy for use in overlap, shape cast, and related functions. This is a deep copy of the points.

Binds @b2MakeProxy@.
-}
makeProxy
  :: Ptr Vec2
  -- ^ @points@
  -> Int
  -- ^ @count@
  -> Float
  -- ^ @radius@
  -> Ptr ShapeProxy
  -- ^ Result buffer.
  -> IO ()
makeProxy :: Ptr Vec2 -> Int -> Float -> Ptr ShapeProxy -> IO ()
makeProxy Ptr Vec2
a0 Int
a1 Float
a2 Ptr ShapeProxy
out =
  Ptr Vec2 -> CInt -> Float -> Ptr ShapeProxy -> IO ()
c_b2MakeProxy Ptr Vec2
a0 (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
a1) Float
a2 Ptr ShapeProxy
out

{- | Make a proxy with a transform. This is a deep copy of the points.

Binds @b2MakeOffsetProxy@.
-}
makeOffsetProxy
  :: Ptr Vec2
  -- ^ @points@
  -> Int
  -- ^ @count@
  -> Float
  -- ^ @radius@
  -> Vec2
  -- ^ @position@
  -> Rot
  -- ^ @rotation@
  -> Ptr ShapeProxy
  -- ^ Result buffer.
  -> IO ()
makeOffsetProxy :: Ptr Vec2 -> Int -> Float -> Vec2 -> Rot -> Ptr ShapeProxy -> IO ()
makeOffsetProxy Ptr Vec2
a0 Int
a1 Float
a2 Vec2
a3 Rot
a4 Ptr ShapeProxy
out =
  Vec2 -> (Ptr Vec2 -> IO ()) -> IO ()
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with Vec2
a3 ((Ptr Vec2 -> IO ()) -> IO ()) -> (Ptr Vec2 -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr Vec2
p3 ->
  Rot -> (Ptr Rot -> IO ()) -> IO ()
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with Rot
a4 ((Ptr Rot -> IO ()) -> IO ()) -> (Ptr Rot -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr Rot
p4 ->
  Ptr Vec2
-> CInt -> Float -> Ptr Vec2 -> Ptr Rot -> Ptr ShapeProxy -> IO ()
c_b2MakeOffsetProxy Ptr Vec2
a0 (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
a1) Float
a2 Ptr Vec2
p3 Ptr Rot
p4 Ptr ShapeProxy
out

{- | Evaluate the transform sweep at a specific time.

Binds @b2GetSweepTransform@.
-}
getSweepTransform
  :: Sweep
  -> Float
  -- ^ @time@
  -> IO Transform
getSweepTransform :: Sweep -> Float -> IO Transform
getSweepTransform Sweep
a0 Float
a1 =
  Sweep -> (Ptr Sweep -> IO Transform) -> IO Transform
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with Sweep
a0 ((Ptr Sweep -> IO Transform) -> IO Transform)
-> (Ptr Sweep -> IO Transform) -> IO Transform
forall a b. (a -> b) -> a -> b
$ \Ptr Sweep
p0 ->
  (Ptr Transform -> IO Transform) -> IO Transform
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr Transform -> IO Transform) -> IO Transform)
-> (Ptr Transform -> IO Transform) -> IO Transform
forall a b. (a -> b) -> a -> b
$ \Ptr Transform
pOut -> Ptr Sweep -> Float -> Ptr Transform -> IO ()
c_b2GetSweepTransform Ptr Sweep
p0 Float
a1 Ptr Transform
pOut IO () -> IO Transform -> IO Transform
forall a b. IO a -> IO b -> IO b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Ptr Transform -> IO Transform
forall a. Storable a => Ptr a -> IO a
peek Ptr Transform
pOut

{- | Compute the upper bound on time before two shapes penetrate. Time is represented as
a fraction between \[0,tMax\]. This uses a swept separating axis and may miss some intermediate,
non-tunneling collisions. If you change the time interval, you should call this function
again.

Binds @b2TimeOfImpact@.
-}
timeOfImpact
  :: Ptr TOIInput
  -> Ptr TOIOutput
  -- ^ Result buffer.
  -> IO ()
timeOfImpact :: Ptr TOIInput -> Ptr TOIOutput -> IO ()
timeOfImpact Ptr TOIInput
a0 Ptr TOIOutput
out =
  Ptr TOIInput -> Ptr TOIOutput -> IO ()
c_b2TimeOfImpact Ptr TOIInput
a0 Ptr TOIOutput
out

{- | Compute the contact manifold between two circles

Binds @b2CollideCircles@.
-}
collideCircles
  :: Circle
  -- ^ @circleA@
  -> Circle
  -- ^ @circleB@
  -> Transform
  -- ^ @xf@
  -> Ptr LocalManifold
  -- ^ Result buffer.
  -> IO ()
collideCircles :: Circle -> Circle -> Transform -> Ptr LocalManifold -> IO ()
collideCircles Circle
a0 Circle
a1 Transform
a2 Ptr LocalManifold
out =
  Circle -> (Ptr Circle -> IO ()) -> IO ()
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with Circle
a0 ((Ptr Circle -> IO ()) -> IO ()) -> (Ptr Circle -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr Circle
p0 ->
  Circle -> (Ptr Circle -> IO ()) -> IO ()
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with Circle
a1 ((Ptr Circle -> IO ()) -> IO ()) -> (Ptr Circle -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr Circle
p1 ->
  Transform -> (Ptr Transform -> IO ()) -> IO ()
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with Transform
a2 ((Ptr Transform -> IO ()) -> IO ())
-> (Ptr Transform -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr Transform
p2 ->
  Ptr Circle
-> Ptr Circle -> Ptr Transform -> Ptr LocalManifold -> IO ()
c_b2CollideCircles Ptr Circle
p0 Ptr Circle
p1 Ptr Transform
p2 Ptr LocalManifold
out

{- | Compute the contact manifold between a capsule and circle

Binds @b2CollideCapsuleAndCircle@.
-}
collideCapsuleAndCircle
  :: Capsule
  -- ^ @capsuleA@
  -> Circle
  -- ^ @circleB@
  -> Transform
  -- ^ @xf@
  -> Ptr LocalManifold
  -- ^ Result buffer.
  -> IO ()
collideCapsuleAndCircle :: Capsule -> Circle -> Transform -> Ptr LocalManifold -> IO ()
collideCapsuleAndCircle Capsule
a0 Circle
a1 Transform
a2 Ptr LocalManifold
out =
  Capsule -> (Ptr Capsule -> IO ()) -> IO ()
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with Capsule
a0 ((Ptr Capsule -> IO ()) -> IO ())
-> (Ptr Capsule -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr Capsule
p0 ->
  Circle -> (Ptr Circle -> IO ()) -> IO ()
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with Circle
a1 ((Ptr Circle -> IO ()) -> IO ()) -> (Ptr Circle -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr Circle
p1 ->
  Transform -> (Ptr Transform -> IO ()) -> IO ()
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with Transform
a2 ((Ptr Transform -> IO ()) -> IO ())
-> (Ptr Transform -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr Transform
p2 ->
  Ptr Capsule
-> Ptr Circle -> Ptr Transform -> Ptr LocalManifold -> IO ()
c_b2CollideCapsuleAndCircle Ptr Capsule
p0 Ptr Circle
p1 Ptr Transform
p2 Ptr LocalManifold
out

{- | Compute the contact manifold between an segment and a circle

Binds @b2CollideSegmentAndCircle@.
-}
collideSegmentAndCircle
  :: Segment
  -- ^ @segmentA@
  -> Circle
  -- ^ @circleB@
  -> Transform
  -- ^ @xf@
  -> Ptr LocalManifold
  -- ^ Result buffer.
  -> IO ()
collideSegmentAndCircle :: Segment -> Circle -> Transform -> Ptr LocalManifold -> IO ()
collideSegmentAndCircle Segment
a0 Circle
a1 Transform
a2 Ptr LocalManifold
out =
  Segment -> (Ptr Segment -> IO ()) -> IO ()
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with Segment
a0 ((Ptr Segment -> IO ()) -> IO ())
-> (Ptr Segment -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr Segment
p0 ->
  Circle -> (Ptr Circle -> IO ()) -> IO ()
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with Circle
a1 ((Ptr Circle -> IO ()) -> IO ()) -> (Ptr Circle -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr Circle
p1 ->
  Transform -> (Ptr Transform -> IO ()) -> IO ()
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with Transform
a2 ((Ptr Transform -> IO ()) -> IO ())
-> (Ptr Transform -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr Transform
p2 ->
  Ptr Segment
-> Ptr Circle -> Ptr Transform -> Ptr LocalManifold -> IO ()
c_b2CollideSegmentAndCircle Ptr Segment
p0 Ptr Circle
p1 Ptr Transform
p2 Ptr LocalManifold
out

{- | Compute the contact manifold between a polygon and a circle

Binds @b2CollidePolygonAndCircle@.
-}
collidePolygonAndCircle
  :: Polygon
  -- ^ @polygonA@
  -> Circle
  -- ^ @circleB@
  -> Transform
  -- ^ @xf@
  -> Ptr LocalManifold
  -- ^ Result buffer.
  -> IO ()
collidePolygonAndCircle :: Polygon -> Circle -> Transform -> Ptr LocalManifold -> IO ()
collidePolygonAndCircle Polygon
a0 Circle
a1 Transform
a2 Ptr LocalManifold
out =
  Polygon -> (Ptr Polygon -> IO ()) -> IO ()
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with Polygon
a0 ((Ptr Polygon -> IO ()) -> IO ())
-> (Ptr Polygon -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr Polygon
p0 ->
  Circle -> (Ptr Circle -> IO ()) -> IO ()
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with Circle
a1 ((Ptr Circle -> IO ()) -> IO ()) -> (Ptr Circle -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr Circle
p1 ->
  Transform -> (Ptr Transform -> IO ()) -> IO ()
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with Transform
a2 ((Ptr Transform -> IO ()) -> IO ())
-> (Ptr Transform -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr Transform
p2 ->
  Ptr Polygon
-> Ptr Circle -> Ptr Transform -> Ptr LocalManifold -> IO ()
c_b2CollidePolygonAndCircle Ptr Polygon
p0 Ptr Circle
p1 Ptr Transform
p2 Ptr LocalManifold
out

{- | Compute the contact manifold between a capsule and circle

Binds @b2CollideCapsules@.
-}
collideCapsules
  :: Capsule
  -- ^ @capsuleA@
  -> Capsule
  -- ^ @capsuleB@
  -> Transform
  -- ^ @xf@
  -> Ptr LocalManifold
  -- ^ Result buffer.
  -> IO ()
collideCapsules :: Capsule -> Capsule -> Transform -> Ptr LocalManifold -> IO ()
collideCapsules Capsule
a0 Capsule
a1 Transform
a2 Ptr LocalManifold
out =
  Capsule -> (Ptr Capsule -> IO ()) -> IO ()
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with Capsule
a0 ((Ptr Capsule -> IO ()) -> IO ())
-> (Ptr Capsule -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr Capsule
p0 ->
  Capsule -> (Ptr Capsule -> IO ()) -> IO ()
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with Capsule
a1 ((Ptr Capsule -> IO ()) -> IO ())
-> (Ptr Capsule -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr Capsule
p1 ->
  Transform -> (Ptr Transform -> IO ()) -> IO ()
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with Transform
a2 ((Ptr Transform -> IO ()) -> IO ())
-> (Ptr Transform -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr Transform
p2 ->
  Ptr Capsule
-> Ptr Capsule -> Ptr Transform -> Ptr LocalManifold -> IO ()
c_b2CollideCapsules Ptr Capsule
p0 Ptr Capsule
p1 Ptr Transform
p2 Ptr LocalManifold
out

{- | Compute the contact manifold between an segment and a capsule

Binds @b2CollideSegmentAndCapsule@.
-}
collideSegmentAndCapsule
  :: Segment
  -- ^ @segmentA@
  -> Capsule
  -- ^ @capsuleB@
  -> Transform
  -- ^ @xf@
  -> Ptr LocalManifold
  -- ^ Result buffer.
  -> IO ()
collideSegmentAndCapsule :: Segment -> Capsule -> Transform -> Ptr LocalManifold -> IO ()
collideSegmentAndCapsule Segment
a0 Capsule
a1 Transform
a2 Ptr LocalManifold
out =
  Segment -> (Ptr Segment -> IO ()) -> IO ()
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with Segment
a0 ((Ptr Segment -> IO ()) -> IO ())
-> (Ptr Segment -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr Segment
p0 ->
  Capsule -> (Ptr Capsule -> IO ()) -> IO ()
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with Capsule
a1 ((Ptr Capsule -> IO ()) -> IO ())
-> (Ptr Capsule -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr Capsule
p1 ->
  Transform -> (Ptr Transform -> IO ()) -> IO ()
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with Transform
a2 ((Ptr Transform -> IO ()) -> IO ())
-> (Ptr Transform -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr Transform
p2 ->
  Ptr Segment
-> Ptr Capsule -> Ptr Transform -> Ptr LocalManifold -> IO ()
c_b2CollideSegmentAndCapsule Ptr Segment
p0 Ptr Capsule
p1 Ptr Transform
p2 Ptr LocalManifold
out

{- | Compute the contact manifold between a polygon and capsule

Binds @b2CollidePolygonAndCapsule@.
-}
collidePolygonAndCapsule
  :: Polygon
  -- ^ @polygonA@
  -> Capsule
  -- ^ @capsuleB@
  -> Transform
  -- ^ @xf@
  -> Ptr LocalManifold
  -- ^ Result buffer.
  -> IO ()
collidePolygonAndCapsule :: Polygon -> Capsule -> Transform -> Ptr LocalManifold -> IO ()
collidePolygonAndCapsule Polygon
a0 Capsule
a1 Transform
a2 Ptr LocalManifold
out =
  Polygon -> (Ptr Polygon -> IO ()) -> IO ()
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with Polygon
a0 ((Ptr Polygon -> IO ()) -> IO ())
-> (Ptr Polygon -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr Polygon
p0 ->
  Capsule -> (Ptr Capsule -> IO ()) -> IO ()
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with Capsule
a1 ((Ptr Capsule -> IO ()) -> IO ())
-> (Ptr Capsule -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr Capsule
p1 ->
  Transform -> (Ptr Transform -> IO ()) -> IO ()
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with Transform
a2 ((Ptr Transform -> IO ()) -> IO ())
-> (Ptr Transform -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr Transform
p2 ->
  Ptr Polygon
-> Ptr Capsule -> Ptr Transform -> Ptr LocalManifold -> IO ()
c_b2CollidePolygonAndCapsule Ptr Polygon
p0 Ptr Capsule
p1 Ptr Transform
p2 Ptr LocalManifold
out

{- | Compute the contact manifold between two polygons

Binds @b2CollidePolygons@.
-}
collidePolygons
  :: Polygon
  -- ^ @polygonA@
  -> Polygon
  -- ^ @polygonB@
  -> Transform
  -- ^ @xf@
  -> Ptr LocalManifold
  -- ^ Result buffer.
  -> IO ()
collidePolygons :: Polygon -> Polygon -> Transform -> Ptr LocalManifold -> IO ()
collidePolygons Polygon
a0 Polygon
a1 Transform
a2 Ptr LocalManifold
out =
  Polygon -> (Ptr Polygon -> IO ()) -> IO ()
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with Polygon
a0 ((Ptr Polygon -> IO ()) -> IO ())
-> (Ptr Polygon -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr Polygon
p0 ->
  Polygon -> (Ptr Polygon -> IO ()) -> IO ()
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with Polygon
a1 ((Ptr Polygon -> IO ()) -> IO ())
-> (Ptr Polygon -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr Polygon
p1 ->
  Transform -> (Ptr Transform -> IO ()) -> IO ()
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with Transform
a2 ((Ptr Transform -> IO ()) -> IO ())
-> (Ptr Transform -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr Transform
p2 ->
  Ptr Polygon
-> Ptr Polygon -> Ptr Transform -> Ptr LocalManifold -> IO ()
c_b2CollidePolygons Ptr Polygon
p0 Ptr Polygon
p1 Ptr Transform
p2 Ptr LocalManifold
out

{- | Compute the contact manifold between an segment and a polygon

Binds @b2CollideSegmentAndPolygon@.
-}
collideSegmentAndPolygon
  :: Segment
  -- ^ @segmentA@
  -> Polygon
  -- ^ @polygonB@
  -> Transform
  -- ^ @xf@
  -> Ptr LocalManifold
  -- ^ Result buffer.
  -> IO ()
collideSegmentAndPolygon :: Segment -> Polygon -> Transform -> Ptr LocalManifold -> IO ()
collideSegmentAndPolygon Segment
a0 Polygon
a1 Transform
a2 Ptr LocalManifold
out =
  Segment -> (Ptr Segment -> IO ()) -> IO ()
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with Segment
a0 ((Ptr Segment -> IO ()) -> IO ())
-> (Ptr Segment -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr Segment
p0 ->
  Polygon -> (Ptr Polygon -> IO ()) -> IO ()
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with Polygon
a1 ((Ptr Polygon -> IO ()) -> IO ())
-> (Ptr Polygon -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr Polygon
p1 ->
  Transform -> (Ptr Transform -> IO ()) -> IO ()
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with Transform
a2 ((Ptr Transform -> IO ()) -> IO ())
-> (Ptr Transform -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr Transform
p2 ->
  Ptr Segment
-> Ptr Polygon -> Ptr Transform -> Ptr LocalManifold -> IO ()
c_b2CollideSegmentAndPolygon Ptr Segment
p0 Ptr Polygon
p1 Ptr Transform
p2 Ptr LocalManifold
out

{- | Compute the contact manifold between a chain segment and a circle

Binds @b2CollideChainSegmentAndCircle@.
-}
collideChainSegmentAndCircle
  :: Ptr ChainSegment
  -- ^ @segmentA@
  -> Circle
  -- ^ @circleB@
  -> Transform
  -- ^ @xf@
  -> Ptr LocalManifold
  -- ^ Result buffer.
  -> IO ()
collideChainSegmentAndCircle :: Ptr ChainSegment
-> Circle -> Transform -> Ptr LocalManifold -> IO ()
collideChainSegmentAndCircle Ptr ChainSegment
a0 Circle
a1 Transform
a2 Ptr LocalManifold
out =
  Circle -> (Ptr Circle -> IO ()) -> IO ()
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with Circle
a1 ((Ptr Circle -> IO ()) -> IO ()) -> (Ptr Circle -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr Circle
p1 ->
  Transform -> (Ptr Transform -> IO ()) -> IO ()
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with Transform
a2 ((Ptr Transform -> IO ()) -> IO ())
-> (Ptr Transform -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr Transform
p2 ->
  Ptr ChainSegment
-> Ptr Circle -> Ptr Transform -> Ptr LocalManifold -> IO ()
c_b2CollideChainSegmentAndCircle Ptr ChainSegment
a0 Ptr Circle
p1 Ptr Transform
p2 Ptr LocalManifold
out

{- | Compute the contact manifold between a chain segment and a capsule

Binds @b2CollideChainSegmentAndCapsule@.
-}
collideChainSegmentAndCapsule
  :: Ptr ChainSegment
  -- ^ @segmentA@
  -> Capsule
  -- ^ @capsuleB@
  -> Transform
  -- ^ @xf@
  -> Ptr SimplexCache
  -> Ptr LocalManifold
  -- ^ Result buffer.
  -> IO ()
collideChainSegmentAndCapsule :: Ptr ChainSegment
-> Capsule
-> Transform
-> Ptr SimplexCache
-> Ptr LocalManifold
-> IO ()
collideChainSegmentAndCapsule Ptr ChainSegment
a0 Capsule
a1 Transform
a2 Ptr SimplexCache
a3 Ptr LocalManifold
out =
  Capsule -> (Ptr Capsule -> IO ()) -> IO ()
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with Capsule
a1 ((Ptr Capsule -> IO ()) -> IO ())
-> (Ptr Capsule -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr Capsule
p1 ->
  Transform -> (Ptr Transform -> IO ()) -> IO ()
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with Transform
a2 ((Ptr Transform -> IO ()) -> IO ())
-> (Ptr Transform -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr Transform
p2 ->
  Ptr ChainSegment
-> Ptr Capsule
-> Ptr Transform
-> Ptr SimplexCache
-> Ptr LocalManifold
-> IO ()
c_b2CollideChainSegmentAndCapsule Ptr ChainSegment
a0 Ptr Capsule
p1 Ptr Transform
p2 Ptr SimplexCache
a3 Ptr LocalManifold
out

{- | Compute the contact manifold between a chain segment and a rounded polygon

Binds @b2CollideChainSegmentAndPolygon@.
-}
collideChainSegmentAndPolygon
  :: Ptr ChainSegment
  -- ^ @segmentA@
  -> Polygon
  -- ^ @polygonB@
  -> Transform
  -- ^ @xf@
  -> Ptr SimplexCache
  -> Ptr LocalManifold
  -- ^ Result buffer.
  -> IO ()
collideChainSegmentAndPolygon :: Ptr ChainSegment
-> Polygon
-> Transform
-> Ptr SimplexCache
-> Ptr LocalManifold
-> IO ()
collideChainSegmentAndPolygon Ptr ChainSegment
a0 Polygon
a1 Transform
a2 Ptr SimplexCache
a3 Ptr LocalManifold
out =
  Polygon -> (Ptr Polygon -> IO ()) -> IO ()
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with Polygon
a1 ((Ptr Polygon -> IO ()) -> IO ())
-> (Ptr Polygon -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr Polygon
p1 ->
  Transform -> (Ptr Transform -> IO ()) -> IO ()
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with Transform
a2 ((Ptr Transform -> IO ()) -> IO ())
-> (Ptr Transform -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr Transform
p2 ->
  Ptr ChainSegment
-> Ptr Polygon
-> Ptr Transform
-> Ptr SimplexCache
-> Ptr LocalManifold
-> IO ()
c_b2CollideChainSegmentAndPolygon Ptr ChainSegment
a0 Ptr Polygon
p1 Ptr Transform
p2 Ptr SimplexCache
a3 Ptr LocalManifold
out

{- | Solves the position of a mover that satisfies the given collision planes.

Binds @b2SolvePlanes@.
-}
solvePlanes
  :: Vec2
  -- ^ @targetDelta@: the desired movement from the position used to generate the collision planes
  -> Ptr CollisionPlane
  -- ^ @planes@: the collision planes
  -> Int
  -- ^ @count@: the number of collision planes
  -> Ptr PlaneSolverResult
  -- ^ Result buffer.
  -> IO ()
solvePlanes :: Vec2 -> Ptr CollisionPlane -> Int -> Ptr PlaneSolverResult -> IO ()
solvePlanes Vec2
a0 Ptr CollisionPlane
a1 Int
a2 Ptr PlaneSolverResult
out =
  Vec2 -> (Ptr Vec2 -> IO ()) -> IO ()
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with Vec2
a0 ((Ptr Vec2 -> IO ()) -> IO ()) -> (Ptr Vec2 -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr Vec2
p0 ->
  Ptr Vec2
-> Ptr CollisionPlane -> CInt -> Ptr PlaneSolverResult -> IO ()
c_b2SolvePlanes Ptr Vec2
p0 Ptr CollisionPlane
a1 (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
a2) Ptr PlaneSolverResult
out

{- | Clips the velocity against the given collision planes. Planes with zero push or clipVelocity
set to false are skipped.

Binds @b2ClipVector@.
-}
clipVector
  :: Vec2
  -- ^ @vector@
  -> Ptr CollisionPlane
  -- ^ @planes@
  -> Int
  -- ^ @count@
  -> IO Vec2
clipVector :: Vec2 -> Ptr CollisionPlane -> Int -> IO Vec2
clipVector Vec2
a0 Ptr CollisionPlane
a1 Int
a2 =
  Vec2 -> (Ptr Vec2 -> IO Vec2) -> IO Vec2
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with Vec2
a0 ((Ptr Vec2 -> IO Vec2) -> IO Vec2)
-> (Ptr Vec2 -> IO Vec2) -> IO Vec2
forall a b. (a -> b) -> a -> b
$ \Ptr Vec2
p0 ->
  (Ptr Vec2 -> IO Vec2) -> IO Vec2
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr Vec2 -> IO Vec2) -> IO Vec2)
-> (Ptr Vec2 -> IO Vec2) -> IO Vec2
forall a b. (a -> b) -> a -> b
$ \Ptr Vec2
pOut -> Ptr Vec2 -> Ptr CollisionPlane -> CInt -> Ptr Vec2 -> IO ()
c_b2ClipVector Ptr Vec2
p0 Ptr CollisionPlane
a1 (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
a2) Ptr Vec2
pOut IO () -> IO Vec2 -> IO Vec2
forall a b. IO a -> IO b -> IO b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Ptr Vec2 -> IO Vec2
forall a. Storable a => Ptr a -> IO a
peek Ptr Vec2
pOut