{-# LINE 1 "src/Box3D/Types.hsc" #-}
{-# LANGUAGE ForeignFunctionInterface #-}
{-# LANGUAGE PatternSynonyms #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}

-- | Low-level bindings to the enums and configuration structs of
-- @box3d/types.h@ needed to create and configure worlds, bodies and shapes.
--
-- The @*Def@ structs carry an @internalValue@ magic that Box3D uses to detect
-- an initialised definition, so always start from the matching
-- @default*@ constructor and tweak the fields you need before use. Every C
-- @bool@ maps to 'CBool' (one byte), and opaque callback / @userData@ pointers
-- are kept as @'Ptr' ()@ until the callback layer lands.
module Box3D.Types
  ( -- * Enums
    BodyType (..)
  , pattern StaticBody
  , pattern KinematicBody
  , pattern DynamicBody
  , ShapeType (..)
  , pattern CapsuleShape
  , pattern CompoundShape
  , pattern HeightShape
  , pattern HullShape
  , pattern MeshShape
  , pattern SphereShape
  , JointType (..)
  , pattern ParallelJoint
  , pattern DistanceJoint
  , pattern FilterJoint
  , pattern MotorJoint
  , pattern PrismaticJoint
  , pattern RevoluteJoint
  , pattern SphericalJoint
  , pattern WeldJoint
  , pattern WheelJoint

    -- * Small structs
  , Capacity (..)
  , MotionLocks (..)
  , Filter (..)
  , SurfaceMaterial (..)
  , Sphere (..)
  , Capsule (..)

    -- * Definitions
  , WorldDef (..)
  , EnqueueTaskCallback
  , FinishTaskCallback
  , BodyDef (..)
  , ShapeDef (..)
  , ExplosionDef (..)
  , defaultExplosionDef

    -- * Queries and casts
  , QueryFilter (..)
  , defaultQueryFilter
  , MassData (..)
  , RayCastInput (..)
  , CastOutput (..)
  , WorldCastOutput
  , RayResult (..)
  , TreeStats (..)
  , Sweep (..)
  , PlaneResult (..)
  , dynamicTreeByteCount

    -- * Events
  , BodyEvents (..)
  , BodyMoveEvent (..)
  , SensorEvents (..)
  , SensorBeginTouchEvent (..)
  , SensorEndTouchEvent (..)
  , ContactEvents (..)
  , ContactBeginTouchEvent (..)
  , ContactEndTouchEvent (..)
  , ContactHitEvent (..)
  , JointEvents (..)
  , JointEvent (..)

    -- * Default definitions
  , defaultWorldDef
  , defaultBodyDef
  , defaultShapeDef
  , defaultFilter
  , defaultSurfaceMaterial

    -- * Joint definitions
  , JointDef (..)
  , DistanceJointDef (..)
  , defaultDistanceJointDef
  , MotorJointDef (..)
  , defaultMotorJointDef
  , ParallelJointDef (..)
  , defaultParallelJointDef
  , PrismaticJointDef (..)
  , defaultPrismaticJointDef
  , RevoluteJointDef (..)
  , defaultRevoluteJointDef
  , SphericalJointDef (..)
  , defaultSphericalJointDef
  , WeldJointDef (..)
  , defaultWeldJointDef
  , WheelJointDef (..)
  , defaultWheelJointDef
  , FilterJointDef (..)
  , defaultFilterJointDef
  ) where

import Foreign
import Foreign.C.String (CString)
import Foreign.C.Types (CBool, CInt)

import Box3D.Id (BodyId, ContactId, JointId, ShapeId)
import Box3D.Internal (allocaOut)
import Box3D.MathTypes (Matrix3, Plane, Pos, Quat, Transform, Vec3)
import Box3D.Tags (CreateDebugShapeCallback, DestroyDebugShapeCallback, FrictionCallback, RestitutionCallback)



-- Enums -------------------------------------------------------------------

-- | The body simulation type.
newtype BodyType = BodyType CInt
  deriving (BodyType -> BodyType -> Bool
(BodyType -> BodyType -> Bool)
-> (BodyType -> BodyType -> Bool) -> Eq BodyType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: BodyType -> BodyType -> Bool
== :: BodyType -> BodyType -> Bool
$c/= :: BodyType -> BodyType -> Bool
/= :: BodyType -> BodyType -> Bool
Eq, Int -> BodyType -> ShowS
[BodyType] -> ShowS
BodyType -> String
(Int -> BodyType -> ShowS)
-> (BodyType -> String) -> ([BodyType] -> ShowS) -> Show BodyType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> BodyType -> ShowS
showsPrec :: Int -> BodyType -> ShowS
$cshow :: BodyType -> String
show :: BodyType -> String
$cshowList :: [BodyType] -> ShowS
showList :: [BodyType] -> ShowS
Show, Ptr BodyType -> IO BodyType
Ptr BodyType -> Int -> IO BodyType
Ptr BodyType -> Int -> BodyType -> IO ()
Ptr BodyType -> BodyType -> IO ()
BodyType -> Int
(BodyType -> Int)
-> (BodyType -> Int)
-> (Ptr BodyType -> Int -> IO BodyType)
-> (Ptr BodyType -> Int -> BodyType -> IO ())
-> (forall b. Ptr b -> Int -> IO BodyType)
-> (forall b. Ptr b -> Int -> BodyType -> IO ())
-> (Ptr BodyType -> IO BodyType)
-> (Ptr BodyType -> BodyType -> IO ())
-> Storable BodyType
forall b. Ptr b -> Int -> IO BodyType
forall b. Ptr b -> Int -> BodyType -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
$csizeOf :: BodyType -> Int
sizeOf :: BodyType -> Int
$calignment :: BodyType -> Int
alignment :: BodyType -> Int
$cpeekElemOff :: Ptr BodyType -> Int -> IO BodyType
peekElemOff :: Ptr BodyType -> Int -> IO BodyType
$cpokeElemOff :: Ptr BodyType -> Int -> BodyType -> IO ()
pokeElemOff :: Ptr BodyType -> Int -> BodyType -> IO ()
$cpeekByteOff :: forall b. Ptr b -> Int -> IO BodyType
peekByteOff :: forall b. Ptr b -> Int -> IO BodyType
$cpokeByteOff :: forall b. Ptr b -> Int -> BodyType -> IO ()
pokeByteOff :: forall b. Ptr b -> Int -> BodyType -> IO ()
$cpeek :: Ptr BodyType -> IO BodyType
peek :: Ptr BodyType -> IO BodyType
$cpoke :: Ptr BodyType -> BodyType -> IO ()
poke :: Ptr BodyType -> BodyType -> IO ()
Storable)

pattern StaticBody :: BodyType
pattern KinematicBody :: BodyType
pattern DynamicBody :: BodyType
pattern $mStaticBody :: forall {r}. BodyType -> ((# #) -> r) -> ((# #) -> r) -> r
$bStaticBody :: BodyType
StaticBody = BodyType 0
{-# LINE 130 "src/Box3D/Types.hsc" #-}
pattern KinematicBody = BodyType 1
{-# LINE 131 "src/Box3D/Types.hsc" #-}
pattern DynamicBody = BodyType 2
{-# LINE 132 "src/Box3D/Types.hsc" #-}

{-# COMPLETE StaticBody, KinematicBody, DynamicBody #-}

-- | Shape geometry type.
newtype ShapeType = ShapeType CInt
  deriving (ShapeType -> ShapeType -> Bool
(ShapeType -> ShapeType -> Bool)
-> (ShapeType -> ShapeType -> Bool) -> Eq ShapeType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ShapeType -> ShapeType -> Bool
== :: ShapeType -> ShapeType -> Bool
$c/= :: ShapeType -> ShapeType -> Bool
/= :: ShapeType -> ShapeType -> Bool
Eq, Int -> ShapeType -> ShowS
[ShapeType] -> ShowS
ShapeType -> String
(Int -> ShapeType -> ShowS)
-> (ShapeType -> String)
-> ([ShapeType] -> ShowS)
-> Show ShapeType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ShapeType -> ShowS
showsPrec :: Int -> ShapeType -> ShowS
$cshow :: ShapeType -> String
show :: ShapeType -> String
$cshowList :: [ShapeType] -> ShowS
showList :: [ShapeType] -> ShowS
Show, Ptr ShapeType -> IO ShapeType
Ptr ShapeType -> Int -> IO ShapeType
Ptr ShapeType -> Int -> ShapeType -> IO ()
Ptr ShapeType -> ShapeType -> IO ()
ShapeType -> Int
(ShapeType -> Int)
-> (ShapeType -> Int)
-> (Ptr ShapeType -> Int -> IO ShapeType)
-> (Ptr ShapeType -> Int -> ShapeType -> IO ())
-> (forall b. Ptr b -> Int -> IO ShapeType)
-> (forall b. Ptr b -> Int -> ShapeType -> IO ())
-> (Ptr ShapeType -> IO ShapeType)
-> (Ptr ShapeType -> ShapeType -> IO ())
-> Storable ShapeType
forall b. Ptr b -> Int -> IO ShapeType
forall b. Ptr b -> Int -> ShapeType -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
$csizeOf :: ShapeType -> Int
sizeOf :: ShapeType -> Int
$calignment :: ShapeType -> Int
alignment :: ShapeType -> Int
$cpeekElemOff :: Ptr ShapeType -> Int -> IO ShapeType
peekElemOff :: Ptr ShapeType -> Int -> IO ShapeType
$cpokeElemOff :: Ptr ShapeType -> Int -> ShapeType -> IO ()
pokeElemOff :: Ptr ShapeType -> Int -> ShapeType -> IO ()
$cpeekByteOff :: forall b. Ptr b -> Int -> IO ShapeType
peekByteOff :: forall b. Ptr b -> Int -> IO ShapeType
$cpokeByteOff :: forall b. Ptr b -> Int -> ShapeType -> IO ()
pokeByteOff :: forall b. Ptr b -> Int -> ShapeType -> IO ()
$cpeek :: Ptr ShapeType -> IO ShapeType
peek :: Ptr ShapeType -> IO ShapeType
$cpoke :: Ptr ShapeType -> ShapeType -> IO ()
poke :: Ptr ShapeType -> ShapeType -> IO ()
Storable)

pattern CapsuleShape :: ShapeType
pattern CompoundShape :: ShapeType
pattern HeightShape :: ShapeType
pattern HullShape :: ShapeType
pattern MeshShape :: ShapeType
pattern SphereShape :: ShapeType
pattern $mCapsuleShape :: forall {r}. ShapeType -> ((# #) -> r) -> ((# #) -> r) -> r
$bCapsuleShape :: ShapeType
CapsuleShape = ShapeType 0
{-# LINE 146 "src/Box3D/Types.hsc" #-}
pattern CompoundShape = ShapeType 1
{-# LINE 147 "src/Box3D/Types.hsc" #-}
pattern HeightShape = ShapeType 2
{-# LINE 148 "src/Box3D/Types.hsc" #-}
pattern HullShape = ShapeType 3
{-# LINE 149 "src/Box3D/Types.hsc" #-}
pattern MeshShape = ShapeType 4
{-# LINE 150 "src/Box3D/Types.hsc" #-}
pattern SphereShape = ShapeType 5
{-# LINE 151 "src/Box3D/Types.hsc" #-}

{-# COMPLETE CapsuleShape, CompoundShape, HeightShape, HullShape, MeshShape, SphereShape #-}

-- | Joint type.
newtype JointType = JointType CInt
  deriving (JointType -> JointType -> Bool
(JointType -> JointType -> Bool)
-> (JointType -> JointType -> Bool) -> Eq JointType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: JointType -> JointType -> Bool
== :: JointType -> JointType -> Bool
$c/= :: JointType -> JointType -> Bool
/= :: JointType -> JointType -> Bool
Eq, Int -> JointType -> ShowS
[JointType] -> ShowS
JointType -> String
(Int -> JointType -> ShowS)
-> (JointType -> String)
-> ([JointType] -> ShowS)
-> Show JointType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> JointType -> ShowS
showsPrec :: Int -> JointType -> ShowS
$cshow :: JointType -> String
show :: JointType -> String
$cshowList :: [JointType] -> ShowS
showList :: [JointType] -> ShowS
Show, Ptr JointType -> IO JointType
Ptr JointType -> Int -> IO JointType
Ptr JointType -> Int -> JointType -> IO ()
Ptr JointType -> JointType -> IO ()
JointType -> Int
(JointType -> Int)
-> (JointType -> Int)
-> (Ptr JointType -> Int -> IO JointType)
-> (Ptr JointType -> Int -> JointType -> IO ())
-> (forall b. Ptr b -> Int -> IO JointType)
-> (forall b. Ptr b -> Int -> JointType -> IO ())
-> (Ptr JointType -> IO JointType)
-> (Ptr JointType -> JointType -> IO ())
-> Storable JointType
forall b. Ptr b -> Int -> IO JointType
forall b. Ptr b -> Int -> JointType -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
$csizeOf :: JointType -> Int
sizeOf :: JointType -> Int
$calignment :: JointType -> Int
alignment :: JointType -> Int
$cpeekElemOff :: Ptr JointType -> Int -> IO JointType
peekElemOff :: Ptr JointType -> Int -> IO JointType
$cpokeElemOff :: Ptr JointType -> Int -> JointType -> IO ()
pokeElemOff :: Ptr JointType -> Int -> JointType -> IO ()
$cpeekByteOff :: forall b. Ptr b -> Int -> IO JointType
peekByteOff :: forall b. Ptr b -> Int -> IO JointType
$cpokeByteOff :: forall b. Ptr b -> Int -> JointType -> IO ()
pokeByteOff :: forall b. Ptr b -> Int -> JointType -> IO ()
$cpeek :: Ptr JointType -> IO JointType
peek :: Ptr JointType -> IO JointType
$cpoke :: Ptr JointType -> JointType -> IO ()
poke :: Ptr JointType -> JointType -> IO ()
Storable)

pattern ParallelJoint :: JointType
pattern DistanceJoint :: JointType
pattern FilterJoint :: JointType
pattern MotorJoint :: JointType
pattern PrismaticJoint :: JointType
pattern RevoluteJoint :: JointType
pattern SphericalJoint :: JointType
pattern WeldJoint :: JointType
pattern WheelJoint :: JointType
pattern $mParallelJoint :: forall {r}. JointType -> ((# #) -> r) -> ((# #) -> r) -> r
$bParallelJoint :: JointType
ParallelJoint = JointType 0
{-# LINE 168 "src/Box3D/Types.hsc" #-}
pattern DistanceJoint = JointType 1
{-# LINE 169 "src/Box3D/Types.hsc" #-}
pattern FilterJoint = JointType 2
{-# LINE 170 "src/Box3D/Types.hsc" #-}
pattern MotorJoint = JointType 3
{-# LINE 171 "src/Box3D/Types.hsc" #-}
pattern PrismaticJoint = JointType 4
{-# LINE 172 "src/Box3D/Types.hsc" #-}
pattern RevoluteJoint = JointType 5
{-# LINE 173 "src/Box3D/Types.hsc" #-}
pattern SphericalJoint = JointType 6
{-# LINE 174 "src/Box3D/Types.hsc" #-}
pattern WeldJoint = JointType 7
{-# LINE 175 "src/Box3D/Types.hsc" #-}
pattern WheelJoint = JointType 8
{-# LINE 176 "src/Box3D/Types.hsc" #-}

{-# COMPLETE ParallelJoint, DistanceJoint, FilterJoint, MotorJoint, PrismaticJoint, RevoluteJoint, SphericalJoint, WeldJoint, WheelJoint #-}

-- Small structs -----------------------------------------------------------

-- | Optional world capacities used to avoid run-time allocations.
data Capacity = Capacity
  { Capacity -> CInt
capacityStaticShapeCount  :: CInt
  , Capacity -> CInt
capacityDynamicShapeCount :: CInt
  , Capacity -> CInt
capacityStaticBodyCount   :: CInt
  , Capacity -> CInt
capacityDynamicBodyCount  :: CInt
  , Capacity -> CInt
capacityContactCount      :: CInt
  }
  deriving (Capacity -> Capacity -> Bool
(Capacity -> Capacity -> Bool)
-> (Capacity -> Capacity -> Bool) -> Eq Capacity
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Capacity -> Capacity -> Bool
== :: Capacity -> Capacity -> Bool
$c/= :: Capacity -> Capacity -> Bool
/= :: Capacity -> Capacity -> Bool
Eq, Int -> Capacity -> ShowS
[Capacity] -> ShowS
Capacity -> String
(Int -> Capacity -> ShowS)
-> (Capacity -> String) -> ([Capacity] -> ShowS) -> Show Capacity
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Capacity -> ShowS
showsPrec :: Int -> Capacity -> ShowS
$cshow :: Capacity -> String
show :: Capacity -> String
$cshowList :: [Capacity] -> ShowS
showList :: [Capacity] -> ShowS
Show)

instance Storable Capacity where
  sizeOf :: Capacity -> Int
sizeOf Capacity
_ = (Int
20)
{-# LINE 193 "src/Box3D/Types.hsc" #-}
  alignment _ = 4
{-# LINE 194 "src/Box3D/Types.hsc" #-}
  peek p =
    Capacity
      <$> (\hsc_ptr -> peekByteOff hsc_ptr 0) p
{-# LINE 197 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 4) p
{-# LINE 198 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 8) p
{-# LINE 199 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 12) p
{-# LINE 200 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 16) p
{-# LINE 201 "src/Box3D/Types.hsc" #-}
  poke p (Capacity ss ds sb db c) = do
    (\hsc_ptr -> pokeByteOff hsc_ptr 0) p ss
{-# LINE 203 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 4) p ds
{-# LINE 204 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 8) p sb
{-# LINE 205 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 12) p db
{-# LINE 206 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 16) p c
{-# LINE 207 "src/Box3D/Types.hsc" #-}

-- | Per-axis translation and rotation locks for a body.
data MotionLocks = MotionLocks
  { MotionLocks -> CBool
motionLocksLinearX  :: CBool
  , MotionLocks -> CBool
motionLocksLinearY  :: CBool
  , MotionLocks -> CBool
motionLocksLinearZ  :: CBool
  , MotionLocks -> CBool
motionLocksAngularX :: CBool
  , MotionLocks -> CBool
motionLocksAngularY :: CBool
  , MotionLocks -> CBool
motionLocksAngularZ :: CBool
  }
  deriving (MotionLocks -> MotionLocks -> Bool
(MotionLocks -> MotionLocks -> Bool)
-> (MotionLocks -> MotionLocks -> Bool) -> Eq MotionLocks
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MotionLocks -> MotionLocks -> Bool
== :: MotionLocks -> MotionLocks -> Bool
$c/= :: MotionLocks -> MotionLocks -> Bool
/= :: MotionLocks -> MotionLocks -> Bool
Eq, Int -> MotionLocks -> ShowS
[MotionLocks] -> ShowS
MotionLocks -> String
(Int -> MotionLocks -> ShowS)
-> (MotionLocks -> String)
-> ([MotionLocks] -> ShowS)
-> Show MotionLocks
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MotionLocks -> ShowS
showsPrec :: Int -> MotionLocks -> ShowS
$cshow :: MotionLocks -> String
show :: MotionLocks -> String
$cshowList :: [MotionLocks] -> ShowS
showList :: [MotionLocks] -> ShowS
Show)

instance Storable MotionLocks where
  sizeOf :: MotionLocks -> Int
sizeOf MotionLocks
_ = (Int
6)
{-# LINE 221 "src/Box3D/Types.hsc" #-}
  alignment _ = 1
{-# LINE 222 "src/Box3D/Types.hsc" #-}
  peek p =
    MotionLocks
      <$> (\hsc_ptr -> peekByteOff hsc_ptr 0) p
{-# LINE 225 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 1) p
{-# LINE 226 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 2) p
{-# LINE 227 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 3) p
{-# LINE 228 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 4) p
{-# LINE 229 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 5) p
{-# LINE 230 "src/Box3D/Types.hsc" #-}
  poke p (MotionLocks lx ly lz ax ay az) = do
    (\hsc_ptr -> pokeByteOff hsc_ptr 0) p lx
{-# LINE 232 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 1) p ly
{-# LINE 233 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 2) p lz
{-# LINE 234 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 3) p ax
{-# LINE 235 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 4) p ay
{-# LINE 236 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 5) p az
{-# LINE 237 "src/Box3D/Types.hsc" #-}

-- | Collision filtering data.
data Filter = Filter
  { Filter -> Word64
filterCategoryBits :: Word64
  , Filter -> Word64
filterMaskBits     :: Word64
  , Filter -> CInt
filterGroupIndex   :: CInt
  }
  deriving (Filter -> Filter -> Bool
(Filter -> Filter -> Bool)
-> (Filter -> Filter -> Bool) -> Eq Filter
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Filter -> Filter -> Bool
== :: Filter -> Filter -> Bool
$c/= :: Filter -> Filter -> Bool
/= :: Filter -> Filter -> Bool
Eq, Int -> Filter -> ShowS
[Filter] -> ShowS
Filter -> String
(Int -> Filter -> ShowS)
-> (Filter -> String) -> ([Filter] -> ShowS) -> Show Filter
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Filter -> ShowS
showsPrec :: Int -> Filter -> ShowS
$cshow :: Filter -> String
show :: Filter -> String
$cshowList :: [Filter] -> ShowS
showList :: [Filter] -> ShowS
Show)

instance Storable Filter where
  sizeOf :: Filter -> Int
sizeOf Filter
_ = (Int
24)
{-# LINE 248 "src/Box3D/Types.hsc" #-}
  alignment _ = 8
{-# LINE 249 "src/Box3D/Types.hsc" #-}
  peek p =
    Filter
      <$> (\hsc_ptr -> peekByteOff hsc_ptr 0) p
{-# LINE 252 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 8) p
{-# LINE 253 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 16) p
{-# LINE 254 "src/Box3D/Types.hsc" #-}
  poke p (Filter c m g) = do
    (\hsc_ptr -> pokeByteOff hsc_ptr 0) p c
{-# LINE 256 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 8) p m
{-# LINE 257 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 16) p g
{-# LINE 258 "src/Box3D/Types.hsc" #-}

-- | Per-surface material properties.
data SurfaceMaterial = SurfaceMaterial
  { SurfaceMaterial -> Float
surfaceMaterialFriction          :: Float
  , SurfaceMaterial -> Float
surfaceMaterialRestitution       :: Float
  , SurfaceMaterial -> Float
surfaceMaterialRollingResistance :: Float
  , SurfaceMaterial -> Vec3
surfaceMaterialTangentVelocity   :: Vec3
  , SurfaceMaterial -> Word64
surfaceMaterialUserMaterialId    :: Word64
  , SurfaceMaterial -> Word32
surfaceMaterialCustomColor       :: Word32
  }
  deriving (SurfaceMaterial -> SurfaceMaterial -> Bool
(SurfaceMaterial -> SurfaceMaterial -> Bool)
-> (SurfaceMaterial -> SurfaceMaterial -> Bool)
-> Eq SurfaceMaterial
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SurfaceMaterial -> SurfaceMaterial -> Bool
== :: SurfaceMaterial -> SurfaceMaterial -> Bool
$c/= :: SurfaceMaterial -> SurfaceMaterial -> Bool
/= :: SurfaceMaterial -> SurfaceMaterial -> Bool
Eq, Int -> SurfaceMaterial -> ShowS
[SurfaceMaterial] -> ShowS
SurfaceMaterial -> String
(Int -> SurfaceMaterial -> ShowS)
-> (SurfaceMaterial -> String)
-> ([SurfaceMaterial] -> ShowS)
-> Show SurfaceMaterial
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SurfaceMaterial -> ShowS
showsPrec :: Int -> SurfaceMaterial -> ShowS
$cshow :: SurfaceMaterial -> String
show :: SurfaceMaterial -> String
$cshowList :: [SurfaceMaterial] -> ShowS
showList :: [SurfaceMaterial] -> ShowS
Show)

instance Storable SurfaceMaterial where
  sizeOf :: SurfaceMaterial -> Int
sizeOf SurfaceMaterial
_ = (Int
40)
{-# LINE 272 "src/Box3D/Types.hsc" #-}
  alignment _ = 8
{-# LINE 273 "src/Box3D/Types.hsc" #-}
  peek p =
    SurfaceMaterial
      <$> (\hsc_ptr -> peekByteOff hsc_ptr 0) p
{-# LINE 276 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 4) p
{-# LINE 277 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 8) p
{-# LINE 278 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 12) p
{-# LINE 279 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 24) p
{-# LINE 280 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 32) p
{-# LINE 281 "src/Box3D/Types.hsc" #-}
  poke p (SurfaceMaterial f r rr tv umi cc) = do
    (\hsc_ptr -> pokeByteOff hsc_ptr 0) p f
{-# LINE 283 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 4) p r
{-# LINE 284 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 8) p rr
{-# LINE 285 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 12) p tv
{-# LINE 286 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 24) p umi
{-# LINE 287 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 32) p cc
{-# LINE 288 "src/Box3D/Types.hsc" #-}

-- | A sphere with a local center offset.
data Sphere = Sphere
  { Sphere -> Vec3
sphereCenter :: Vec3
  , Sphere -> Float
sphereRadius :: Float
  }
  deriving (Sphere -> Sphere -> Bool
(Sphere -> Sphere -> Bool)
-> (Sphere -> Sphere -> Bool) -> Eq Sphere
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Sphere -> Sphere -> Bool
== :: Sphere -> Sphere -> Bool
$c/= :: Sphere -> Sphere -> Bool
/= :: Sphere -> Sphere -> Bool
Eq, Int -> Sphere -> ShowS
[Sphere] -> ShowS
Sphere -> String
(Int -> Sphere -> ShowS)
-> (Sphere -> String) -> ([Sphere] -> ShowS) -> Show Sphere
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Sphere -> ShowS
showsPrec :: Int -> Sphere -> ShowS
$cshow :: Sphere -> String
show :: Sphere -> String
$cshowList :: [Sphere] -> ShowS
showList :: [Sphere] -> ShowS
Show)

instance Storable Sphere where
  sizeOf :: Sphere -> Int
sizeOf Sphere
_ = (Int
16)
{-# LINE 298 "src/Box3D/Types.hsc" #-}
  alignment _ = 4
{-# LINE 299 "src/Box3D/Types.hsc" #-}
  peek p = Sphere <$> (\hsc_ptr -> peekByteOff hsc_ptr 0) p <*> (\hsc_ptr -> peekByteOff hsc_ptr 12) p
{-# LINE 300 "src/Box3D/Types.hsc" #-}
  poke p (Sphere c r) = do
    (\hsc_ptr -> pokeByteOff hsc_ptr 0) p c
{-# LINE 302 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 12) p r
{-# LINE 303 "src/Box3D/Types.hsc" #-}

-- | A capsule: an extruded sphere between two hemisphere centers.
data Capsule = Capsule
  { Capsule -> Vec3
capsuleCenter1 :: Vec3
  , Capsule -> Vec3
capsuleCenter2 :: Vec3
  , Capsule -> Float
capsuleRadius  :: Float
  }
  deriving (Capsule -> Capsule -> Bool
(Capsule -> Capsule -> Bool)
-> (Capsule -> Capsule -> Bool) -> Eq Capsule
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Capsule -> Capsule -> Bool
== :: Capsule -> Capsule -> Bool
$c/= :: Capsule -> Capsule -> Bool
/= :: Capsule -> Capsule -> Bool
Eq, Int -> Capsule -> ShowS
[Capsule] -> ShowS
Capsule -> String
(Int -> Capsule -> ShowS)
-> (Capsule -> String) -> ([Capsule] -> ShowS) -> Show Capsule
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Capsule -> ShowS
showsPrec :: Int -> Capsule -> ShowS
$cshow :: Capsule -> String
show :: Capsule -> String
$cshowList :: [Capsule] -> ShowS
showList :: [Capsule] -> ShowS
Show)

instance Storable Capsule where
  sizeOf :: Capsule -> Int
sizeOf Capsule
_ = (Int
28)
{-# LINE 314 "src/Box3D/Types.hsc" #-}
  alignment _ = 4
{-# LINE 315 "src/Box3D/Types.hsc" #-}
  peek p =
    Capsule
      <$> (\hsc_ptr -> peekByteOff hsc_ptr 0) p
{-# LINE 318 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 12) p
{-# LINE 319 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 24) p
{-# LINE 320 "src/Box3D/Types.hsc" #-}
  poke p (Capsule c1 c2 r) = do
    (\hsc_ptr -> pokeByteOff hsc_ptr 0) p c1
{-# LINE 322 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 12) p c2
{-# LINE 323 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 24) p r
{-# LINE 324 "src/Box3D/Types.hsc" #-}

-- Definitions -------------------------------------------------------------

-- | Phantom tags for the task-system callbacks stored on 'WorldDef'. These
-- typedefs never appear in API signatures, so "Box3D.Tags" carries no tag for
-- them; produce values with 'Box3D.Callbacks.withThreadPoolTaskSystem'.
data EnqueueTaskCallback
data FinishTaskCallback

-- | World creation definition. Initialise with 'defaultWorldDef'.
data WorldDef = WorldDef
  { WorldDef -> Vec3
worldDefGravity              :: Vec3
  , WorldDef -> Float
worldDefRestitutionThreshold :: Float
  , WorldDef -> Float
worldDefHitEventThreshold    :: Float
  , WorldDef -> Float
worldDefContactHertz         :: Float
  , WorldDef -> Float
worldDefContactDampingRatio  :: Float
  , WorldDef -> Float
worldDefContactSpeed         :: Float
  , WorldDef -> Float
worldDefMaximumLinearSpeed   :: Float
  , WorldDef -> FunPtr FrictionCallback
worldDefFrictionCallback     :: FunPtr FrictionCallback
  , WorldDef -> FunPtr RestitutionCallback
worldDefRestitutionCallback  :: FunPtr RestitutionCallback
  , WorldDef -> CBool
worldDefEnableSleep          :: CBool
  , WorldDef -> CBool
worldDefEnableContinuous     :: CBool
  , WorldDef -> Word32
worldDefWorkerCount          :: Word32
  , WorldDef -> FunPtr EnqueueTaskCallback
worldDefEnqueueTask          :: FunPtr EnqueueTaskCallback
  , WorldDef -> FunPtr FinishTaskCallback
worldDefFinishTask           :: FunPtr FinishTaskCallback
  , WorldDef -> Ptr ()
worldDefUserTaskContext      :: Ptr ()
  , WorldDef -> Ptr ()
worldDefUserData             :: Ptr ()
  , WorldDef -> FunPtr CreateDebugShapeCallback
worldDefCreateDebugShape     :: FunPtr CreateDebugShapeCallback
  , WorldDef -> FunPtr DestroyDebugShapeCallback
worldDefDestroyDebugShape    :: FunPtr DestroyDebugShapeCallback
  , WorldDef -> Ptr ()
worldDefUserDebugShapeContext :: Ptr ()
  , WorldDef -> Capacity
worldDefCapacity             :: Capacity
  , WorldDef -> CInt
worldDefInternalValue        :: CInt
  }
  deriving (WorldDef -> WorldDef -> Bool
(WorldDef -> WorldDef -> Bool)
-> (WorldDef -> WorldDef -> Bool) -> Eq WorldDef
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: WorldDef -> WorldDef -> Bool
== :: WorldDef -> WorldDef -> Bool
$c/= :: WorldDef -> WorldDef -> Bool
/= :: WorldDef -> WorldDef -> Bool
Eq, Int -> WorldDef -> ShowS
[WorldDef] -> ShowS
WorldDef -> String
(Int -> WorldDef -> ShowS)
-> (WorldDef -> String) -> ([WorldDef] -> ShowS) -> Show WorldDef
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> WorldDef -> ShowS
showsPrec :: Int -> WorldDef -> ShowS
$cshow :: WorldDef -> String
show :: WorldDef -> String
$cshowList :: [WorldDef] -> ShowS
showList :: [WorldDef] -> ShowS
Show)

instance Storable WorldDef where
  sizeOf :: WorldDef -> Int
sizeOf WorldDef
_ = (Int
144)
{-# LINE 361 "src/Box3D/Types.hsc" #-}
  alignment _ = 8
{-# LINE 362 "src/Box3D/Types.hsc" #-}
  peek p =
    WorldDef
      <$> (\hsc_ptr -> peekByteOff hsc_ptr 0) p
{-# LINE 365 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 12) p
{-# LINE 366 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 16) p
{-# LINE 367 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 20) p
{-# LINE 368 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 24) p
{-# LINE 369 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 28) p
{-# LINE 370 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 32) p
{-# LINE 371 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 40) p
{-# LINE 372 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 48) p
{-# LINE 373 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 56) p
{-# LINE 374 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 57) p
{-# LINE 375 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 60) p
{-# LINE 376 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 64) p
{-# LINE 377 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 72) p
{-# LINE 378 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 80) p
{-# LINE 379 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 88) p
{-# LINE 380 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 96) p
{-# LINE 381 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 104) p
{-# LINE 382 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 112) p
{-# LINE 383 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 120) p
{-# LINE 384 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 140) p
{-# LINE 385 "src/Box3D/Types.hsc" #-}
  poke p d = do
    (\hsc_ptr -> pokeByteOff hsc_ptr 0) p (worldDefGravity d)
{-# LINE 387 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 12) p (worldDefRestitutionThreshold d)
{-# LINE 388 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 16) p (worldDefHitEventThreshold d)
{-# LINE 389 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 20) p (worldDefContactHertz d)
{-# LINE 390 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 24) p (worldDefContactDampingRatio d)
{-# LINE 391 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 28) p (worldDefContactSpeed d)
{-# LINE 392 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 32) p (worldDefMaximumLinearSpeed d)
{-# LINE 393 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 40) p (worldDefFrictionCallback d)
{-# LINE 394 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 48) p (worldDefRestitutionCallback d)
{-# LINE 395 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 56) p (worldDefEnableSleep d)
{-# LINE 396 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 57) p (worldDefEnableContinuous d)
{-# LINE 397 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 60) p (worldDefWorkerCount d)
{-# LINE 398 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 64) p (worldDefEnqueueTask d)
{-# LINE 399 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 72) p (worldDefFinishTask d)
{-# LINE 400 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 80) p (worldDefUserTaskContext d)
{-# LINE 401 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 88) p (worldDefUserData d)
{-# LINE 402 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 96) p (worldDefCreateDebugShape d)
{-# LINE 403 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 104) p (worldDefDestroyDebugShape d)
{-# LINE 404 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 112) p (worldDefUserDebugShapeContext d)
{-# LINE 405 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 120) p (worldDefCapacity d)
{-# LINE 406 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 140) p (worldDefInternalValue d)
{-# LINE 407 "src/Box3D/Types.hsc" #-}

-- | Rigid body creation definition. Initialise with 'defaultBodyDef'.
data BodyDef = BodyDef
  { BodyDef -> BodyType
bodyDefType                   :: BodyType
  , BodyDef -> Vec3
bodyDefPosition               :: Pos
  , BodyDef -> Quat
bodyDefRotation               :: Quat
  , BodyDef -> Vec3
bodyDefLinearVelocity         :: Vec3
  , BodyDef -> Vec3
bodyDefAngularVelocity        :: Vec3
  , BodyDef -> Float
bodyDefLinearDamping          :: Float
  , BodyDef -> Float
bodyDefAngularDamping         :: Float
  , BodyDef -> Float
bodyDefGravityScale           :: Float
  , BodyDef -> Float
bodyDefSleepThreshold         :: Float
  , BodyDef -> CString
bodyDefName                   :: CString
  , BodyDef -> Ptr ()
bodyDefUserData               :: Ptr ()
  , BodyDef -> MotionLocks
bodyDefMotionLocks            :: MotionLocks
  , BodyDef -> CBool
bodyDefEnableSleep            :: CBool
  , BodyDef -> CBool
bodyDefIsAwake                :: CBool
  , BodyDef -> CBool
bodyDefIsBullet               :: CBool
  , BodyDef -> CBool
bodyDefIsEnabled              :: CBool
  , BodyDef -> CBool
bodyDefAllowFastRotation      :: CBool
  , BodyDef -> CBool
bodyDefEnableContactRecycling :: CBool
  , BodyDef -> CInt
bodyDefInternalValue          :: CInt
  }
  deriving (BodyDef -> BodyDef -> Bool
(BodyDef -> BodyDef -> Bool)
-> (BodyDef -> BodyDef -> Bool) -> Eq BodyDef
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: BodyDef -> BodyDef -> Bool
== :: BodyDef -> BodyDef -> Bool
$c/= :: BodyDef -> BodyDef -> Bool
/= :: BodyDef -> BodyDef -> Bool
Eq, Int -> BodyDef -> ShowS
[BodyDef] -> ShowS
BodyDef -> String
(Int -> BodyDef -> ShowS)
-> (BodyDef -> String) -> ([BodyDef] -> ShowS) -> Show BodyDef
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> BodyDef -> ShowS
showsPrec :: Int -> BodyDef -> ShowS
$cshow :: BodyDef -> String
show :: BodyDef -> String
$cshowList :: [BodyDef] -> ShowS
showList :: [BodyDef] -> ShowS
Show)

instance Storable BodyDef where
  sizeOf :: BodyDef -> Int
sizeOf BodyDef
_ = (Int
104)
{-# LINE 434 "src/Box3D/Types.hsc" #-}
  alignment _ = 8
{-# LINE 435 "src/Box3D/Types.hsc" #-}
  peek p =
    BodyDef
      <$> (\hsc_ptr -> peekByteOff hsc_ptr 0) p
{-# LINE 438 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 4) p
{-# LINE 439 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 16) p
{-# LINE 440 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 32) p
{-# LINE 441 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 44) p
{-# LINE 442 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 56) p
{-# LINE 443 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 60) p
{-# LINE 444 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 64) p
{-# LINE 445 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 68) p
{-# LINE 446 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 72) p
{-# LINE 447 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 80) p
{-# LINE 448 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 88) p
{-# LINE 449 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 94) p
{-# LINE 450 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 95) p
{-# LINE 451 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 96) p
{-# LINE 452 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 97) p
{-# LINE 453 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 98) p
{-# LINE 454 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 99) p
{-# LINE 455 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 100) p
{-# LINE 456 "src/Box3D/Types.hsc" #-}
  poke p d = do
    (\hsc_ptr -> pokeByteOff hsc_ptr 0) p (bodyDefType d)
{-# LINE 458 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 4) p (bodyDefPosition d)
{-# LINE 459 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 16) p (bodyDefRotation d)
{-# LINE 460 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 32) p (bodyDefLinearVelocity d)
{-# LINE 461 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 44) p (bodyDefAngularVelocity d)
{-# LINE 462 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 56) p (bodyDefLinearDamping d)
{-# LINE 463 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 60) p (bodyDefAngularDamping d)
{-# LINE 464 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 64) p (bodyDefGravityScale d)
{-# LINE 465 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 68) p (bodyDefSleepThreshold d)
{-# LINE 466 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 72) p (bodyDefName d)
{-# LINE 467 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 80) p (bodyDefUserData d)
{-# LINE 468 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 88) p (bodyDefMotionLocks d)
{-# LINE 469 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 94) p (bodyDefEnableSleep d)
{-# LINE 470 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 95) p (bodyDefIsAwake d)
{-# LINE 471 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 96) p (bodyDefIsBullet d)
{-# LINE 472 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 97) p (bodyDefIsEnabled d)
{-# LINE 473 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 98) p (bodyDefAllowFastRotation d)
{-# LINE 474 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 99) p (bodyDefEnableContactRecycling d)
{-# LINE 475 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 100) p (bodyDefInternalValue d)
{-# LINE 476 "src/Box3D/Types.hsc" #-}

-- | Shape creation definition. Initialise with 'defaultShapeDef'.
data ShapeDef = ShapeDef
  { ShapeDef -> Ptr ()
shapeDefUserData              :: Ptr ()
  , ShapeDef -> Ptr SurfaceMaterial
shapeDefMaterials             :: Ptr SurfaceMaterial
  , ShapeDef -> CInt
shapeDefMaterialCount         :: CInt
  , ShapeDef -> SurfaceMaterial
shapeDefBaseMaterial          :: SurfaceMaterial
  , ShapeDef -> Float
shapeDefDensity               :: Float
  , ShapeDef -> Float
shapeDefExplosionScale        :: Float
  , ShapeDef -> Filter
shapeDefFilter                :: Filter
  , ShapeDef -> CBool
shapeDefEnableCustomFiltering :: CBool
  , ShapeDef -> CBool
shapeDefIsSensor              :: CBool
  -- ^ Create-time only: a shape cannot change sensor-ness after creation.
  , ShapeDef -> CBool
shapeDefEnableSensorEvents    :: CBool
  -- ^ Needed on the sensor /and/ the visiting shape for sensor events.
  , ShapeDef -> CBool
shapeDefEnableContactEvents   :: CBool
  -- ^ Contact events are opt-in per shape (both shapes of the pair).
  , ShapeDef -> CBool
shapeDefEnableHitEvents       :: CBool
  -- ^ Hit events additionally require exceeding @worldDefHitEventThreshold@.
  , ShapeDef -> CBool
shapeDefEnablePreSolveEvents  :: CBool
  , ShapeDef -> CBool
shapeDefInvokeContactCreation :: CBool
  , ShapeDef -> CBool
shapeDefUpdateBodyMass        :: CBool
  , ShapeDef -> CInt
shapeDefInternalValue         :: CInt
  }
  deriving (ShapeDef -> ShapeDef -> Bool
(ShapeDef -> ShapeDef -> Bool)
-> (ShapeDef -> ShapeDef -> Bool) -> Eq ShapeDef
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ShapeDef -> ShapeDef -> Bool
== :: ShapeDef -> ShapeDef -> Bool
$c/= :: ShapeDef -> ShapeDef -> Bool
/= :: ShapeDef -> ShapeDef -> Bool
Eq, Int -> ShapeDef -> ShowS
[ShapeDef] -> ShowS
ShapeDef -> String
(Int -> ShapeDef -> ShowS)
-> (ShapeDef -> String) -> ([ShapeDef] -> ShowS) -> Show ShapeDef
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ShapeDef -> ShowS
showsPrec :: Int -> ShapeDef -> ShowS
$cshow :: ShapeDef -> String
show :: ShapeDef -> String
$cshowList :: [ShapeDef] -> ShowS
showList :: [ShapeDef] -> ShowS
Show)

instance Storable ShapeDef where
  sizeOf :: ShapeDef -> Int
sizeOf ShapeDef
_ = (Int
112)
{-# LINE 504 "src/Box3D/Types.hsc" #-}
  alignment _ = 8
{-# LINE 505 "src/Box3D/Types.hsc" #-}
  peek p =
    ShapeDef
      <$> (\hsc_ptr -> peekByteOff hsc_ptr 0) p
{-# LINE 508 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 8) p
{-# LINE 509 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 16) p
{-# LINE 510 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 24) p
{-# LINE 511 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 64) p
{-# LINE 512 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 68) p
{-# LINE 513 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 72) p
{-# LINE 514 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 96) p
{-# LINE 515 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 97) p
{-# LINE 516 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 98) p
{-# LINE 517 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 99) p
{-# LINE 518 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 100) p
{-# LINE 519 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 101) p
{-# LINE 520 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 102) p
{-# LINE 521 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 103) p
{-# LINE 522 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 104) p
{-# LINE 523 "src/Box3D/Types.hsc" #-}
  poke p d = do
    (\hsc_ptr -> pokeByteOff hsc_ptr 0) p (shapeDefUserData d)
{-# LINE 525 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 8) p (shapeDefMaterials d)
{-# LINE 526 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 16) p (shapeDefMaterialCount d)
{-# LINE 527 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 24) p (shapeDefBaseMaterial d)
{-# LINE 528 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 64) p (shapeDefDensity d)
{-# LINE 529 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 68) p (shapeDefExplosionScale d)
{-# LINE 530 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 72) p (shapeDefFilter d)
{-# LINE 531 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 96) p (shapeDefEnableCustomFiltering d)
{-# LINE 532 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 97) p (shapeDefIsSensor d)
{-# LINE 533 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 98) p (shapeDefEnableSensorEvents d)
{-# LINE 534 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 99) p (shapeDefEnableContactEvents d)
{-# LINE 535 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 100) p (shapeDefEnableHitEvents d)
{-# LINE 536 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 101) p (shapeDefEnablePreSolveEvents d)
{-# LINE 537 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 102) p (shapeDefInvokeContactCreation d)
{-# LINE 538 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 103) p (shapeDefUpdateBodyMass d)
{-# LINE 539 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 104) p (shapeDefInternalValue d)
{-# LINE 540 "src/Box3D/Types.hsc" #-}

-- Default definitions -----------------------------------------------------

foreign import ccall unsafe "hs_b3DefaultWorldDef"
  c_b3DefaultWorldDef :: Ptr WorldDef -> IO ()

foreign import ccall unsafe "hs_b3DefaultBodyDef"
  c_b3DefaultBodyDef :: Ptr BodyDef -> IO ()

foreign import ccall unsafe "hs_b3DefaultShapeDef"
  c_b3DefaultShapeDef :: Ptr ShapeDef -> IO ()

foreign import ccall unsafe "hs_b3DefaultFilter"
  c_b3DefaultFilter :: Ptr Filter -> IO ()

foreign import ccall unsafe "hs_b3DefaultSurfaceMaterial"
  c_b3DefaultSurfaceMaterial :: Ptr SurfaceMaterial -> IO ()

-- | A fully-initialised world definition.
defaultWorldDef :: IO WorldDef
defaultWorldDef :: IO WorldDef
defaultWorldDef = (Ptr WorldDef -> IO ()) -> IO WorldDef
forall a. Storable a => (Ptr a -> IO ()) -> IO a
allocaOut Ptr WorldDef -> IO ()
c_b3DefaultWorldDef

-- | A fully-initialised body definition.
defaultBodyDef :: IO BodyDef
defaultBodyDef :: IO BodyDef
defaultBodyDef = (Ptr BodyDef -> IO ()) -> IO BodyDef
forall a. Storable a => (Ptr a -> IO ()) -> IO a
allocaOut Ptr BodyDef -> IO ()
c_b3DefaultBodyDef

-- | A fully-initialised shape definition.
defaultShapeDef :: IO ShapeDef
defaultShapeDef :: IO ShapeDef
defaultShapeDef = (Ptr ShapeDef -> IO ()) -> IO ShapeDef
forall a. Storable a => (Ptr a -> IO ()) -> IO a
allocaOut Ptr ShapeDef -> IO ()
c_b3DefaultShapeDef

-- | A fully-initialised collision filter.
defaultFilter :: IO Filter
defaultFilter :: IO Filter
defaultFilter = (Ptr Filter -> IO ()) -> IO Filter
forall a. Storable a => (Ptr a -> IO ()) -> IO a
allocaOut Ptr Filter -> IO ()
c_b3DefaultFilter

-- | A fully-initialised surface material.
defaultSurfaceMaterial :: IO SurfaceMaterial
defaultSurfaceMaterial :: IO SurfaceMaterial
defaultSurfaceMaterial = (Ptr SurfaceMaterial -> IO ()) -> IO SurfaceMaterial
forall a. Storable a => (Ptr a -> IO ()) -> IO a
allocaOut Ptr SurfaceMaterial -> IO ()
c_b3DefaultSurfaceMaterial

foreign import ccall unsafe "hs_b3DefaultExplosionDef"
  c_b3DefaultExplosionDef :: Ptr ExplosionDef -> IO ()

-- | Explosion parameters for 'Box3D.World.explode'. Initialise with
-- 'defaultExplosionDef'.
data ExplosionDef = ExplosionDef
  { ExplosionDef -> Word64
explosionDefMaskBits       :: Word64
  , ExplosionDef -> Vec3
explosionDefPosition       :: Pos
  , ExplosionDef -> Float
explosionDefRadius         :: Float
  , ExplosionDef -> Float
explosionDefFalloff        :: Float
  , ExplosionDef -> Float
explosionDefImpulsePerArea :: Float
  }
  deriving (ExplosionDef -> ExplosionDef -> Bool
(ExplosionDef -> ExplosionDef -> Bool)
-> (ExplosionDef -> ExplosionDef -> Bool) -> Eq ExplosionDef
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ExplosionDef -> ExplosionDef -> Bool
== :: ExplosionDef -> ExplosionDef -> Bool
$c/= :: ExplosionDef -> ExplosionDef -> Bool
/= :: ExplosionDef -> ExplosionDef -> Bool
Eq, Int -> ExplosionDef -> ShowS
[ExplosionDef] -> ShowS
ExplosionDef -> String
(Int -> ExplosionDef -> ShowS)
-> (ExplosionDef -> String)
-> ([ExplosionDef] -> ShowS)
-> Show ExplosionDef
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ExplosionDef -> ShowS
showsPrec :: Int -> ExplosionDef -> ShowS
$cshow :: ExplosionDef -> String
show :: ExplosionDef -> String
$cshowList :: [ExplosionDef] -> ShowS
showList :: [ExplosionDef] -> ShowS
Show)

instance Storable ExplosionDef where
  sizeOf :: ExplosionDef -> Int
sizeOf ExplosionDef
_ = (Int
32)
{-# LINE 594 "src/Box3D/Types.hsc" #-}
  alignment _ = 8
{-# LINE 595 "src/Box3D/Types.hsc" #-}
  peek p =
    ExplosionDef
      <$> (\hsc_ptr -> peekByteOff hsc_ptr 0) p
{-# LINE 598 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 8) p
{-# LINE 599 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 20) p
{-# LINE 600 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 24) p
{-# LINE 601 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 28) p
{-# LINE 602 "src/Box3D/Types.hsc" #-}
  poke p d = do
    (\hsc_ptr -> pokeByteOff hsc_ptr 0) p (explosionDefMaskBits d)
{-# LINE 604 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 8) p (explosionDefPosition d)
{-# LINE 605 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 20) p (explosionDefRadius d)
{-# LINE 606 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 24) p (explosionDefFalloff d)
{-# LINE 607 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 28) p (explosionDefImpulsePerArea d)
{-# LINE 608 "src/Box3D/Types.hsc" #-}

-- | A fully-initialised explosion definition.
defaultExplosionDef :: IO ExplosionDef
defaultExplosionDef :: IO ExplosionDef
defaultExplosionDef = (Ptr ExplosionDef -> IO ()) -> IO ExplosionDef
forall a. Storable a => (Ptr a -> IO ()) -> IO a
allocaOut Ptr ExplosionDef -> IO ()
c_b3DefaultExplosionDef

-- Joint definitions ------------------------------------------------------

-- | The shared base of every joint definition.
data JointDef = JointDef
  { JointDef -> Ptr ()
jointDefUserData :: Ptr ()
  , JointDef -> BodyId
jointDefBodyIdA :: BodyId
  , JointDef -> BodyId
jointDefBodyIdB :: BodyId
  , JointDef -> Transform
jointDefLocalFrameA :: Transform
  , JointDef -> Transform
jointDefLocalFrameB :: Transform
  , JointDef -> Float
jointDefForceThreshold :: Float
  , JointDef -> Float
jointDefTorqueThreshold :: Float
  , JointDef -> Float
jointDefConstraintHertz :: Float
  , JointDef -> Float
jointDefConstraintDampingRatio :: Float
  , JointDef -> Float
jointDefDrawScale :: Float
  , JointDef -> CBool
jointDefCollideConnected :: CBool
  , JointDef -> CInt
jointDefInternalValue :: CInt
  }
  deriving (JointDef -> JointDef -> Bool
(JointDef -> JointDef -> Bool)
-> (JointDef -> JointDef -> Bool) -> Eq JointDef
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: JointDef -> JointDef -> Bool
== :: JointDef -> JointDef -> Bool
$c/= :: JointDef -> JointDef -> Bool
/= :: JointDef -> JointDef -> Bool
Eq, Int -> JointDef -> ShowS
[JointDef] -> ShowS
JointDef -> String
(Int -> JointDef -> ShowS)
-> (JointDef -> String) -> ([JointDef] -> ShowS) -> Show JointDef
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> JointDef -> ShowS
showsPrec :: Int -> JointDef -> ShowS
$cshow :: JointDef -> String
show :: JointDef -> String
$cshowList :: [JointDef] -> ShowS
showList :: [JointDef] -> ShowS
Show)

instance Storable JointDef where
  sizeOf :: JointDef -> Int
sizeOf JointDef
_ = (Int
112)
{-# LINE 634 "src/Box3D/Types.hsc" #-}
  alignment _ = 8
{-# LINE 635 "src/Box3D/Types.hsc" #-}
  peek p =
    JointDef
      <$> (\hsc_ptr -> peekByteOff hsc_ptr 0) p
{-# LINE 638 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 8) p
{-# LINE 639 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 16) p
{-# LINE 640 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 24) p
{-# LINE 641 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 52) p
{-# LINE 642 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 80) p
{-# LINE 643 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 84) p
{-# LINE 644 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 88) p
{-# LINE 645 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 92) p
{-# LINE 646 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 96) p
{-# LINE 647 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 100) p
{-# LINE 648 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 104) p
{-# LINE 649 "src/Box3D/Types.hsc" #-}
  poke p x = do
    (\hsc_ptr -> pokeByteOff hsc_ptr 0) p (jointDefUserData x)
{-# LINE 651 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 8) p (jointDefBodyIdA x)
{-# LINE 652 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 16) p (jointDefBodyIdB x)
{-# LINE 653 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 24) p (jointDefLocalFrameA x)
{-# LINE 654 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 52) p (jointDefLocalFrameB x)
{-# LINE 655 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 80) p (jointDefForceThreshold x)
{-# LINE 656 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 84) p (jointDefTorqueThreshold x)
{-# LINE 657 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 88) p (jointDefConstraintHertz x)
{-# LINE 658 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 92) p (jointDefConstraintDampingRatio x)
{-# LINE 659 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 96) p (jointDefDrawScale x)
{-# LINE 660 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 100) p (jointDefCollideConnected x)
{-# LINE 661 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 104) p (jointDefInternalValue x)
{-# LINE 662 "src/Box3D/Types.hsc" #-}

-- | Distance joint definition. Initialise with 'defaultDistanceJointDef'.
data DistanceJointDef = DistanceJointDef
  { DistanceJointDef -> JointDef
distanceJointDefBase :: JointDef
  , DistanceJointDef -> Float
distanceJointDefLength :: Float
  , DistanceJointDef -> CBool
distanceJointDefEnableSpring :: CBool
  , DistanceJointDef -> Float
distanceJointDefLowerSpringForce :: Float
  , DistanceJointDef -> Float
distanceJointDefUpperSpringForce :: Float
  , DistanceJointDef -> Float
distanceJointDefHertz :: Float
  , DistanceJointDef -> Float
distanceJointDefDampingRatio :: Float
  , DistanceJointDef -> CBool
distanceJointDefEnableLimit :: CBool
  , DistanceJointDef -> Float
distanceJointDefMinLength :: Float
  , DistanceJointDef -> Float
distanceJointDefMaxLength :: Float
  , DistanceJointDef -> CBool
distanceJointDefEnableMotor :: CBool
  , DistanceJointDef -> Float
distanceJointDefMaxMotorForce :: Float
  , DistanceJointDef -> Float
distanceJointDefMotorSpeed :: Float
  }
  deriving (DistanceJointDef -> DistanceJointDef -> Bool
(DistanceJointDef -> DistanceJointDef -> Bool)
-> (DistanceJointDef -> DistanceJointDef -> Bool)
-> Eq DistanceJointDef
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DistanceJointDef -> DistanceJointDef -> Bool
== :: DistanceJointDef -> DistanceJointDef -> Bool
$c/= :: DistanceJointDef -> DistanceJointDef -> Bool
/= :: DistanceJointDef -> DistanceJointDef -> Bool
Eq, Int -> DistanceJointDef -> ShowS
[DistanceJointDef] -> ShowS
DistanceJointDef -> String
(Int -> DistanceJointDef -> ShowS)
-> (DistanceJointDef -> String)
-> ([DistanceJointDef] -> ShowS)
-> Show DistanceJointDef
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DistanceJointDef -> ShowS
showsPrec :: Int -> DistanceJointDef -> ShowS
$cshow :: DistanceJointDef -> String
show :: DistanceJointDef -> String
$cshowList :: [DistanceJointDef] -> ShowS
showList :: [DistanceJointDef] -> ShowS
Show)

instance Storable DistanceJointDef where
  sizeOf :: DistanceJointDef -> Int
sizeOf DistanceJointDef
_ = (Int
160)
{-# LINE 683 "src/Box3D/Types.hsc" #-}
  alignment _ = 8
{-# LINE 684 "src/Box3D/Types.hsc" #-}
  peek p =
    DistanceJointDef
      <$> (\hsc_ptr -> peekByteOff hsc_ptr 0) p
{-# LINE 687 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 112) p
{-# LINE 688 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 116) p
{-# LINE 689 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 120) p
{-# LINE 690 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 124) p
{-# LINE 691 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 128) p
{-# LINE 692 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 132) p
{-# LINE 693 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 136) p
{-# LINE 694 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 140) p
{-# LINE 695 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 144) p
{-# LINE 696 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 148) p
{-# LINE 697 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 152) p
{-# LINE 698 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 156) p
{-# LINE 699 "src/Box3D/Types.hsc" #-}
  poke p x = do
    (\hsc_ptr -> pokeByteOff hsc_ptr 0) p (distanceJointDefBase x)
{-# LINE 701 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 112) p (distanceJointDefLength x)
{-# LINE 702 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 116) p (distanceJointDefEnableSpring x)
{-# LINE 703 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 120) p (distanceJointDefLowerSpringForce x)
{-# LINE 704 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 124) p (distanceJointDefUpperSpringForce x)
{-# LINE 705 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 128) p (distanceJointDefHertz x)
{-# LINE 706 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 132) p (distanceJointDefDampingRatio x)
{-# LINE 707 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 136) p (distanceJointDefEnableLimit x)
{-# LINE 708 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 140) p (distanceJointDefMinLength x)
{-# LINE 709 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 144) p (distanceJointDefMaxLength x)
{-# LINE 710 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 148) p (distanceJointDefEnableMotor x)
{-# LINE 711 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 152) p (distanceJointDefMaxMotorForce x)
{-# LINE 712 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 156) p (distanceJointDefMotorSpeed x)
{-# LINE 713 "src/Box3D/Types.hsc" #-}

-- | Motor joint definition. Initialise with 'defaultMotorJointDef'.
data MotorJointDef = MotorJointDef
  { MotorJointDef -> JointDef
motorJointDefBase :: JointDef
  , MotorJointDef -> Vec3
motorJointDefLinearVelocity :: Vec3
  , MotorJointDef -> Float
motorJointDefMaxVelocityForce :: Float
  , MotorJointDef -> Vec3
motorJointDefAngularVelocity :: Vec3
  , MotorJointDef -> Float
motorJointDefMaxVelocityTorque :: Float
  , MotorJointDef -> Float
motorJointDefLinearHertz :: Float
  , MotorJointDef -> Float
motorJointDefLinearDampingRatio :: Float
  , MotorJointDef -> Float
motorJointDefMaxSpringForce :: Float
  , MotorJointDef -> Float
motorJointDefAngularHertz :: Float
  , MotorJointDef -> Float
motorJointDefAngularDampingRatio :: Float
  , MotorJointDef -> Float
motorJointDefMaxSpringTorque :: Float
  }
  deriving (MotorJointDef -> MotorJointDef -> Bool
(MotorJointDef -> MotorJointDef -> Bool)
-> (MotorJointDef -> MotorJointDef -> Bool) -> Eq MotorJointDef
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MotorJointDef -> MotorJointDef -> Bool
== :: MotorJointDef -> MotorJointDef -> Bool
$c/= :: MotorJointDef -> MotorJointDef -> Bool
/= :: MotorJointDef -> MotorJointDef -> Bool
Eq, Int -> MotorJointDef -> ShowS
[MotorJointDef] -> ShowS
MotorJointDef -> String
(Int -> MotorJointDef -> ShowS)
-> (MotorJointDef -> String)
-> ([MotorJointDef] -> ShowS)
-> Show MotorJointDef
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MotorJointDef -> ShowS
showsPrec :: Int -> MotorJointDef -> ShowS
$cshow :: MotorJointDef -> String
show :: MotorJointDef -> String
$cshowList :: [MotorJointDef] -> ShowS
showList :: [MotorJointDef] -> ShowS
Show)

instance Storable MotorJointDef where
  sizeOf :: MotorJointDef -> Int
sizeOf MotorJointDef
_ = (Int
168)
{-# LINE 732 "src/Box3D/Types.hsc" #-}
  alignment _ = 8
{-# LINE 733 "src/Box3D/Types.hsc" #-}
  peek p =
    MotorJointDef
      <$> (\hsc_ptr -> peekByteOff hsc_ptr 0) p
{-# LINE 736 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 112) p
{-# LINE 737 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 124) p
{-# LINE 738 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 128) p
{-# LINE 739 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 140) p
{-# LINE 740 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 144) p
{-# LINE 741 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 148) p
{-# LINE 742 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 152) p
{-# LINE 743 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 156) p
{-# LINE 744 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 160) p
{-# LINE 745 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 164) p
{-# LINE 746 "src/Box3D/Types.hsc" #-}
  poke p x = do
    (\hsc_ptr -> pokeByteOff hsc_ptr 0) p (motorJointDefBase x)
{-# LINE 748 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 112) p (motorJointDefLinearVelocity x)
{-# LINE 749 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 124) p (motorJointDefMaxVelocityForce x)
{-# LINE 750 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 128) p (motorJointDefAngularVelocity x)
{-# LINE 751 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 140) p (motorJointDefMaxVelocityTorque x)
{-# LINE 752 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 144) p (motorJointDefLinearHertz x)
{-# LINE 753 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 148) p (motorJointDefLinearDampingRatio x)
{-# LINE 754 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 152) p (motorJointDefMaxSpringForce x)
{-# LINE 755 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 156) p (motorJointDefAngularHertz x)
{-# LINE 756 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 160) p (motorJointDefAngularDampingRatio x)
{-# LINE 757 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 164) p (motorJointDefMaxSpringTorque x)
{-# LINE 758 "src/Box3D/Types.hsc" #-}

-- | Parallel joint definition. Initialise with 'defaultParallelJointDef'.
data ParallelJointDef = ParallelJointDef
  { ParallelJointDef -> JointDef
parallelJointDefBase :: JointDef
  , ParallelJointDef -> Float
parallelJointDefHertz :: Float
  , ParallelJointDef -> Float
parallelJointDefDampingRatio :: Float
  , ParallelJointDef -> Float
parallelJointDefMaxTorque :: Float
  }
  deriving (ParallelJointDef -> ParallelJointDef -> Bool
(ParallelJointDef -> ParallelJointDef -> Bool)
-> (ParallelJointDef -> ParallelJointDef -> Bool)
-> Eq ParallelJointDef
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ParallelJointDef -> ParallelJointDef -> Bool
== :: ParallelJointDef -> ParallelJointDef -> Bool
$c/= :: ParallelJointDef -> ParallelJointDef -> Bool
/= :: ParallelJointDef -> ParallelJointDef -> Bool
Eq, Int -> ParallelJointDef -> ShowS
[ParallelJointDef] -> ShowS
ParallelJointDef -> String
(Int -> ParallelJointDef -> ShowS)
-> (ParallelJointDef -> String)
-> ([ParallelJointDef] -> ShowS)
-> Show ParallelJointDef
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ParallelJointDef -> ShowS
showsPrec :: Int -> ParallelJointDef -> ShowS
$cshow :: ParallelJointDef -> String
show :: ParallelJointDef -> String
$cshowList :: [ParallelJointDef] -> ShowS
showList :: [ParallelJointDef] -> ShowS
Show)

instance Storable ParallelJointDef where
  sizeOf :: ParallelJointDef -> Int
sizeOf ParallelJointDef
_ = (Int
128)
{-# LINE 770 "src/Box3D/Types.hsc" #-}
  alignment _ = 8
{-# LINE 771 "src/Box3D/Types.hsc" #-}
  peek p =
    ParallelJointDef
      <$> (\hsc_ptr -> peekByteOff hsc_ptr 0) p
{-# LINE 774 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 112) p
{-# LINE 775 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 116) p
{-# LINE 776 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 120) p
{-# LINE 777 "src/Box3D/Types.hsc" #-}
  poke p x = do
    (\hsc_ptr -> pokeByteOff hsc_ptr 0) p (parallelJointDefBase x)
{-# LINE 779 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 112) p (parallelJointDefHertz x)
{-# LINE 780 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 116) p (parallelJointDefDampingRatio x)
{-# LINE 781 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 120) p (parallelJointDefMaxTorque x)
{-# LINE 782 "src/Box3D/Types.hsc" #-}

-- | Prismatic joint definition. Initialise with 'defaultPrismaticJointDef'.
data PrismaticJointDef = PrismaticJointDef
  { PrismaticJointDef -> JointDef
prismaticJointDefBase :: JointDef
  , PrismaticJointDef -> CBool
prismaticJointDefEnableSpring :: CBool
  , PrismaticJointDef -> Float
prismaticJointDefHertz :: Float
  , PrismaticJointDef -> Float
prismaticJointDefDampingRatio :: Float
  , PrismaticJointDef -> Float
prismaticJointDefTargetTranslation :: Float
  , PrismaticJointDef -> CBool
prismaticJointDefEnableLimit :: CBool
  , PrismaticJointDef -> Float
prismaticJointDefLowerTranslation :: Float
  , PrismaticJointDef -> Float
prismaticJointDefUpperTranslation :: Float
  , PrismaticJointDef -> CBool
prismaticJointDefEnableMotor :: CBool
  , PrismaticJointDef -> Float
prismaticJointDefMaxMotorForce :: Float
  , PrismaticJointDef -> Float
prismaticJointDefMotorSpeed :: Float
  }
  deriving (PrismaticJointDef -> PrismaticJointDef -> Bool
(PrismaticJointDef -> PrismaticJointDef -> Bool)
-> (PrismaticJointDef -> PrismaticJointDef -> Bool)
-> Eq PrismaticJointDef
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PrismaticJointDef -> PrismaticJointDef -> Bool
== :: PrismaticJointDef -> PrismaticJointDef -> Bool
$c/= :: PrismaticJointDef -> PrismaticJointDef -> Bool
/= :: PrismaticJointDef -> PrismaticJointDef -> Bool
Eq, Int -> PrismaticJointDef -> ShowS
[PrismaticJointDef] -> ShowS
PrismaticJointDef -> String
(Int -> PrismaticJointDef -> ShowS)
-> (PrismaticJointDef -> String)
-> ([PrismaticJointDef] -> ShowS)
-> Show PrismaticJointDef
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> PrismaticJointDef -> ShowS
showsPrec :: Int -> PrismaticJointDef -> ShowS
$cshow :: PrismaticJointDef -> String
show :: PrismaticJointDef -> String
$cshowList :: [PrismaticJointDef] -> ShowS
showList :: [PrismaticJointDef] -> ShowS
Show)

instance Storable PrismaticJointDef where
  sizeOf :: PrismaticJointDef -> Int
sizeOf PrismaticJointDef
_ = (Int
152)
{-# LINE 801 "src/Box3D/Types.hsc" #-}
  alignment _ = 8
{-# LINE 802 "src/Box3D/Types.hsc" #-}
  peek p =
    PrismaticJointDef
      <$> (\hsc_ptr -> peekByteOff hsc_ptr 0) p
{-# LINE 805 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 112) p
{-# LINE 806 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 116) p
{-# LINE 807 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 120) p
{-# LINE 808 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 124) p
{-# LINE 809 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 128) p
{-# LINE 810 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 132) p
{-# LINE 811 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 136) p
{-# LINE 812 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 140) p
{-# LINE 813 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 144) p
{-# LINE 814 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 148) p
{-# LINE 815 "src/Box3D/Types.hsc" #-}
  poke p x = do
    (\hsc_ptr -> pokeByteOff hsc_ptr 0) p (prismaticJointDefBase x)
{-# LINE 817 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 112) p (prismaticJointDefEnableSpring x)
{-# LINE 818 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 116) p (prismaticJointDefHertz x)
{-# LINE 819 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 120) p (prismaticJointDefDampingRatio x)
{-# LINE 820 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 124) p (prismaticJointDefTargetTranslation x)
{-# LINE 821 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 128) p (prismaticJointDefEnableLimit x)
{-# LINE 822 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 132) p (prismaticJointDefLowerTranslation x)
{-# LINE 823 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 136) p (prismaticJointDefUpperTranslation x)
{-# LINE 824 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 140) p (prismaticJointDefEnableMotor x)
{-# LINE 825 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 144) p (prismaticJointDefMaxMotorForce x)
{-# LINE 826 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 148) p (prismaticJointDefMotorSpeed x)
{-# LINE 827 "src/Box3D/Types.hsc" #-}

-- | Revolute joint definition. Initialise with 'defaultRevoluteJointDef'.
data RevoluteJointDef = RevoluteJointDef
  { RevoluteJointDef -> JointDef
revoluteJointDefBase :: JointDef
  , RevoluteJointDef -> Float
revoluteJointDefTargetAngle :: Float
  , RevoluteJointDef -> CBool
revoluteJointDefEnableSpring :: CBool
  , RevoluteJointDef -> Float
revoluteJointDefHertz :: Float
  , RevoluteJointDef -> Float
revoluteJointDefDampingRatio :: Float
  , RevoluteJointDef -> CBool
revoluteJointDefEnableLimit :: CBool
  , RevoluteJointDef -> Float
revoluteJointDefLowerAngle :: Float
  , RevoluteJointDef -> Float
revoluteJointDefUpperAngle :: Float
  , RevoluteJointDef -> CBool
revoluteJointDefEnableMotor :: CBool
  , RevoluteJointDef -> Float
revoluteJointDefMaxMotorTorque :: Float
  , RevoluteJointDef -> Float
revoluteJointDefMotorSpeed :: Float
  }
  deriving (RevoluteJointDef -> RevoluteJointDef -> Bool
(RevoluteJointDef -> RevoluteJointDef -> Bool)
-> (RevoluteJointDef -> RevoluteJointDef -> Bool)
-> Eq RevoluteJointDef
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RevoluteJointDef -> RevoluteJointDef -> Bool
== :: RevoluteJointDef -> RevoluteJointDef -> Bool
$c/= :: RevoluteJointDef -> RevoluteJointDef -> Bool
/= :: RevoluteJointDef -> RevoluteJointDef -> Bool
Eq, Int -> RevoluteJointDef -> ShowS
[RevoluteJointDef] -> ShowS
RevoluteJointDef -> String
(Int -> RevoluteJointDef -> ShowS)
-> (RevoluteJointDef -> String)
-> ([RevoluteJointDef] -> ShowS)
-> Show RevoluteJointDef
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> RevoluteJointDef -> ShowS
showsPrec :: Int -> RevoluteJointDef -> ShowS
$cshow :: RevoluteJointDef -> String
show :: RevoluteJointDef -> String
$cshowList :: [RevoluteJointDef] -> ShowS
showList :: [RevoluteJointDef] -> ShowS
Show)

instance Storable RevoluteJointDef where
  sizeOf :: RevoluteJointDef -> Int
sizeOf RevoluteJointDef
_ = (Int
152)
{-# LINE 846 "src/Box3D/Types.hsc" #-}
  alignment _ = 8
{-# LINE 847 "src/Box3D/Types.hsc" #-}
  peek p =
    RevoluteJointDef
      <$> (\hsc_ptr -> peekByteOff hsc_ptr 0) p
{-# LINE 850 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 112) p
{-# LINE 851 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 116) p
{-# LINE 852 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 120) p
{-# LINE 853 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 124) p
{-# LINE 854 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 128) p
{-# LINE 855 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 132) p
{-# LINE 856 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 136) p
{-# LINE 857 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 140) p
{-# LINE 858 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 144) p
{-# LINE 859 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 148) p
{-# LINE 860 "src/Box3D/Types.hsc" #-}
  poke p x = do
    (\hsc_ptr -> pokeByteOff hsc_ptr 0) p (revoluteJointDefBase x)
{-# LINE 862 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 112) p (revoluteJointDefTargetAngle x)
{-# LINE 863 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 116) p (revoluteJointDefEnableSpring x)
{-# LINE 864 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 120) p (revoluteJointDefHertz x)
{-# LINE 865 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 124) p (revoluteJointDefDampingRatio x)
{-# LINE 866 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 128) p (revoluteJointDefEnableLimit x)
{-# LINE 867 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 132) p (revoluteJointDefLowerAngle x)
{-# LINE 868 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 136) p (revoluteJointDefUpperAngle x)
{-# LINE 869 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 140) p (revoluteJointDefEnableMotor x)
{-# LINE 870 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 144) p (revoluteJointDefMaxMotorTorque x)
{-# LINE 871 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 148) p (revoluteJointDefMotorSpeed x)
{-# LINE 872 "src/Box3D/Types.hsc" #-}

-- | Spherical joint definition. Initialise with 'defaultSphericalJointDef'.
data SphericalJointDef = SphericalJointDef
  { SphericalJointDef -> JointDef
sphericalJointDefBase :: JointDef
  , SphericalJointDef -> CBool
sphericalJointDefEnableSpring :: CBool
  , SphericalJointDef -> Float
sphericalJointDefHertz :: Float
  , SphericalJointDef -> Float
sphericalJointDefDampingRatio :: Float
  , SphericalJointDef -> Quat
sphericalJointDefTargetRotation :: Quat
  , SphericalJointDef -> CBool
sphericalJointDefEnableConeLimit :: CBool
  , SphericalJointDef -> Float
sphericalJointDefConeAngle :: Float
  , SphericalJointDef -> CBool
sphericalJointDefEnableTwistLimit :: CBool
  , SphericalJointDef -> Float
sphericalJointDefLowerTwistAngle :: Float
  , SphericalJointDef -> Float
sphericalJointDefUpperTwistAngle :: Float
  , SphericalJointDef -> CBool
sphericalJointDefEnableMotor :: CBool
  , SphericalJointDef -> Float
sphericalJointDefMaxMotorTorque :: Float
  , SphericalJointDef -> Vec3
sphericalJointDefMotorVelocity :: Vec3
  }
  deriving (SphericalJointDef -> SphericalJointDef -> Bool
(SphericalJointDef -> SphericalJointDef -> Bool)
-> (SphericalJointDef -> SphericalJointDef -> Bool)
-> Eq SphericalJointDef
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SphericalJointDef -> SphericalJointDef -> Bool
== :: SphericalJointDef -> SphericalJointDef -> Bool
$c/= :: SphericalJointDef -> SphericalJointDef -> Bool
/= :: SphericalJointDef -> SphericalJointDef -> Bool
Eq, Int -> SphericalJointDef -> ShowS
[SphericalJointDef] -> ShowS
SphericalJointDef -> String
(Int -> SphericalJointDef -> ShowS)
-> (SphericalJointDef -> String)
-> ([SphericalJointDef] -> ShowS)
-> Show SphericalJointDef
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SphericalJointDef -> ShowS
showsPrec :: Int -> SphericalJointDef -> ShowS
$cshow :: SphericalJointDef -> String
show :: SphericalJointDef -> String
$cshowList :: [SphericalJointDef] -> ShowS
showList :: [SphericalJointDef] -> ShowS
Show)

instance Storable SphericalJointDef where
  sizeOf :: SphericalJointDef -> Int
sizeOf SphericalJointDef
_ = (Int
184)
{-# LINE 893 "src/Box3D/Types.hsc" #-}
  alignment _ = 8
{-# LINE 894 "src/Box3D/Types.hsc" #-}
  peek p =
    SphericalJointDef
      <$> (\hsc_ptr -> peekByteOff hsc_ptr 0) p
{-# LINE 897 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 112) p
{-# LINE 898 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 116) p
{-# LINE 899 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 120) p
{-# LINE 900 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 124) p
{-# LINE 901 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 140) p
{-# LINE 902 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 144) p
{-# LINE 903 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 148) p
{-# LINE 904 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 152) p
{-# LINE 905 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 156) p
{-# LINE 906 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 160) p
{-# LINE 907 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 164) p
{-# LINE 908 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 168) p
{-# LINE 909 "src/Box3D/Types.hsc" #-}
  poke p x = do
    (\hsc_ptr -> pokeByteOff hsc_ptr 0) p (sphericalJointDefBase x)
{-# LINE 911 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 112) p (sphericalJointDefEnableSpring x)
{-# LINE 912 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 116) p (sphericalJointDefHertz x)
{-# LINE 913 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 120) p (sphericalJointDefDampingRatio x)
{-# LINE 914 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 124) p (sphericalJointDefTargetRotation x)
{-# LINE 915 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 140) p (sphericalJointDefEnableConeLimit x)
{-# LINE 916 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 144) p (sphericalJointDefConeAngle x)
{-# LINE 917 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 148) p (sphericalJointDefEnableTwistLimit x)
{-# LINE 918 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 152) p (sphericalJointDefLowerTwistAngle x)
{-# LINE 919 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 156) p (sphericalJointDefUpperTwistAngle x)
{-# LINE 920 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 160) p (sphericalJointDefEnableMotor x)
{-# LINE 921 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 164) p (sphericalJointDefMaxMotorTorque x)
{-# LINE 922 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 168) p (sphericalJointDefMotorVelocity x)
{-# LINE 923 "src/Box3D/Types.hsc" #-}

-- | Weld joint definition. Initialise with 'defaultWeldJointDef'.
data WeldJointDef = WeldJointDef
  { WeldJointDef -> JointDef
weldJointDefBase :: JointDef
  , WeldJointDef -> Float
weldJointDefLinearHertz :: Float
  , WeldJointDef -> Float
weldJointDefAngularHertz :: Float
  , WeldJointDef -> Float
weldJointDefLinearDampingRatio :: Float
  , WeldJointDef -> Float
weldJointDefAngularDampingRatio :: Float
  }
  deriving (WeldJointDef -> WeldJointDef -> Bool
(WeldJointDef -> WeldJointDef -> Bool)
-> (WeldJointDef -> WeldJointDef -> Bool) -> Eq WeldJointDef
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: WeldJointDef -> WeldJointDef -> Bool
== :: WeldJointDef -> WeldJointDef -> Bool
$c/= :: WeldJointDef -> WeldJointDef -> Bool
/= :: WeldJointDef -> WeldJointDef -> Bool
Eq, Int -> WeldJointDef -> ShowS
[WeldJointDef] -> ShowS
WeldJointDef -> String
(Int -> WeldJointDef -> ShowS)
-> (WeldJointDef -> String)
-> ([WeldJointDef] -> ShowS)
-> Show WeldJointDef
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> WeldJointDef -> ShowS
showsPrec :: Int -> WeldJointDef -> ShowS
$cshow :: WeldJointDef -> String
show :: WeldJointDef -> String
$cshowList :: [WeldJointDef] -> ShowS
showList :: [WeldJointDef] -> ShowS
Show)

instance Storable WeldJointDef where
  sizeOf :: WeldJointDef -> Int
sizeOf WeldJointDef
_ = (Int
128)
{-# LINE 936 "src/Box3D/Types.hsc" #-}
  alignment _ = 8
{-# LINE 937 "src/Box3D/Types.hsc" #-}
  peek p =
    WeldJointDef
      <$> (\hsc_ptr -> peekByteOff hsc_ptr 0) p
{-# LINE 940 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 112) p
{-# LINE 941 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 116) p
{-# LINE 942 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 120) p
{-# LINE 943 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 124) p
{-# LINE 944 "src/Box3D/Types.hsc" #-}
  poke p x = do
    (\hsc_ptr -> pokeByteOff hsc_ptr 0) p (weldJointDefBase x)
{-# LINE 946 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 112) p (weldJointDefLinearHertz x)
{-# LINE 947 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 116) p (weldJointDefAngularHertz x)
{-# LINE 948 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 120) p (weldJointDefLinearDampingRatio x)
{-# LINE 949 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 124) p (weldJointDefAngularDampingRatio x)
{-# LINE 950 "src/Box3D/Types.hsc" #-}

-- | Wheel joint definition. Initialise with 'defaultWheelJointDef'.
data WheelJointDef = WheelJointDef
  { WheelJointDef -> JointDef
wheelJointDefBase :: JointDef
  , WheelJointDef -> CBool
wheelJointDefEnableSuspensionSpring :: CBool
  , WheelJointDef -> Float
wheelJointDefSuspensionHertz :: Float
  , WheelJointDef -> Float
wheelJointDefSuspensionDampingRatio :: Float
  , WheelJointDef -> CBool
wheelJointDefEnableSuspensionLimit :: CBool
  , WheelJointDef -> Float
wheelJointDefLowerSuspensionLimit :: Float
  , WheelJointDef -> Float
wheelJointDefUpperSuspensionLimit :: Float
  , WheelJointDef -> CBool
wheelJointDefEnableSpinMotor :: CBool
  , WheelJointDef -> Float
wheelJointDefMaxSpinTorque :: Float
  , WheelJointDef -> Float
wheelJointDefSpinSpeed :: Float
  , WheelJointDef -> CBool
wheelJointDefEnableSteering :: CBool
  , WheelJointDef -> Float
wheelJointDefSteeringHertz :: Float
  , WheelJointDef -> Float
wheelJointDefSteeringDampingRatio :: Float
  , WheelJointDef -> Float
wheelJointDefTargetSteeringAngle :: Float
  , WheelJointDef -> Float
wheelJointDefMaxSteeringTorque :: Float
  , WheelJointDef -> CBool
wheelJointDefEnableSteeringLimit :: CBool
  , WheelJointDef -> Float
wheelJointDefLowerSteeringLimit :: Float
  , WheelJointDef -> Float
wheelJointDefUpperSteeringLimit :: Float
  }
  deriving (WheelJointDef -> WheelJointDef -> Bool
(WheelJointDef -> WheelJointDef -> Bool)
-> (WheelJointDef -> WheelJointDef -> Bool) -> Eq WheelJointDef
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: WheelJointDef -> WheelJointDef -> Bool
== :: WheelJointDef -> WheelJointDef -> Bool
$c/= :: WheelJointDef -> WheelJointDef -> Bool
/= :: WheelJointDef -> WheelJointDef -> Bool
Eq, Int -> WheelJointDef -> ShowS
[WheelJointDef] -> ShowS
WheelJointDef -> String
(Int -> WheelJointDef -> ShowS)
-> (WheelJointDef -> String)
-> ([WheelJointDef] -> ShowS)
-> Show WheelJointDef
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> WheelJointDef -> ShowS
showsPrec :: Int -> WheelJointDef -> ShowS
$cshow :: WheelJointDef -> String
show :: WheelJointDef -> String
$cshowList :: [WheelJointDef] -> ShowS
showList :: [WheelJointDef] -> ShowS
Show)

instance Storable WheelJointDef where
  sizeOf :: WheelJointDef -> Int
sizeOf WheelJointDef
_ = (Int
184)
{-# LINE 976 "src/Box3D/Types.hsc" #-}
  alignment _ = 8
{-# LINE 977 "src/Box3D/Types.hsc" #-}
  peek p =
    WheelJointDef
      <$> (\hsc_ptr -> peekByteOff hsc_ptr 0) p
{-# LINE 980 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 112) p
{-# LINE 981 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 116) p
{-# LINE 982 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 120) p
{-# LINE 983 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 124) p
{-# LINE 984 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 128) p
{-# LINE 985 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 132) p
{-# LINE 986 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 136) p
{-# LINE 987 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 140) p
{-# LINE 988 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 144) p
{-# LINE 989 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 148) p
{-# LINE 990 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 152) p
{-# LINE 991 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 156) p
{-# LINE 992 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 160) p
{-# LINE 993 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 164) p
{-# LINE 994 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 168) p
{-# LINE 995 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 172) p
{-# LINE 996 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 176) p
{-# LINE 997 "src/Box3D/Types.hsc" #-}
  poke p x = do
    (\hsc_ptr -> pokeByteOff hsc_ptr 0) p (wheelJointDefBase x)
{-# LINE 999 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 112) p (wheelJointDefEnableSuspensionSpring x)
{-# LINE 1000 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 116) p (wheelJointDefSuspensionHertz x)
{-# LINE 1001 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 120) p (wheelJointDefSuspensionDampingRatio x)
{-# LINE 1002 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 124) p (wheelJointDefEnableSuspensionLimit x)
{-# LINE 1003 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 128) p (wheelJointDefLowerSuspensionLimit x)
{-# LINE 1004 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 132) p (wheelJointDefUpperSuspensionLimit x)
{-# LINE 1005 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 136) p (wheelJointDefEnableSpinMotor x)
{-# LINE 1006 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 140) p (wheelJointDefMaxSpinTorque x)
{-# LINE 1007 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 144) p (wheelJointDefSpinSpeed x)
{-# LINE 1008 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 148) p (wheelJointDefEnableSteering x)
{-# LINE 1009 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 152) p (wheelJointDefSteeringHertz x)
{-# LINE 1010 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 156) p (wheelJointDefSteeringDampingRatio x)
{-# LINE 1011 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 160) p (wheelJointDefTargetSteeringAngle x)
{-# LINE 1012 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 164) p (wheelJointDefMaxSteeringTorque x)
{-# LINE 1013 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 168) p (wheelJointDefEnableSteeringLimit x)
{-# LINE 1014 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 172) p (wheelJointDefLowerSteeringLimit x)
{-# LINE 1015 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 176) p (wheelJointDefUpperSteeringLimit x)
{-# LINE 1016 "src/Box3D/Types.hsc" #-}

-- | Filter joint definition. Initialise with 'defaultFilterJointDef'.
data FilterJointDef = FilterJointDef
  { FilterJointDef -> JointDef
filterJointDefBase :: JointDef
  }
  deriving (FilterJointDef -> FilterJointDef -> Bool
(FilterJointDef -> FilterJointDef -> Bool)
-> (FilterJointDef -> FilterJointDef -> Bool) -> Eq FilterJointDef
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: FilterJointDef -> FilterJointDef -> Bool
== :: FilterJointDef -> FilterJointDef -> Bool
$c/= :: FilterJointDef -> FilterJointDef -> Bool
/= :: FilterJointDef -> FilterJointDef -> Bool
Eq, Int -> FilterJointDef -> ShowS
[FilterJointDef] -> ShowS
FilterJointDef -> String
(Int -> FilterJointDef -> ShowS)
-> (FilterJointDef -> String)
-> ([FilterJointDef] -> ShowS)
-> Show FilterJointDef
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> FilterJointDef -> ShowS
showsPrec :: Int -> FilterJointDef -> ShowS
$cshow :: FilterJointDef -> String
show :: FilterJointDef -> String
$cshowList :: [FilterJointDef] -> ShowS
showList :: [FilterJointDef] -> ShowS
Show)

instance Storable FilterJointDef where
  sizeOf :: FilterJointDef -> Int
sizeOf FilterJointDef
_ = (Int
112)
{-# LINE 1025 "src/Box3D/Types.hsc" #-}
  alignment _ = 8
{-# LINE 1026 "src/Box3D/Types.hsc" #-}
  peek p =
    FilterJointDef
      <$> (\hsc_ptr -> peekByteOff hsc_ptr 0) p
{-# LINE 1029 "src/Box3D/Types.hsc" #-}
  poke p x = do
    (\hsc_ptr -> pokeByteOff hsc_ptr 0) p (filterJointDefBase x)
{-# LINE 1031 "src/Box3D/Types.hsc" #-}

-- Joint definition defaults ----------------------------------------------

foreign import ccall unsafe "hs_b3DefaultDistanceJointDef"
  c_b3DefaultDistanceJointDef :: Ptr DistanceJointDef -> IO ()

foreign import ccall unsafe "hs_b3DefaultMotorJointDef"
  c_b3DefaultMotorJointDef :: Ptr MotorJointDef -> IO ()

foreign import ccall unsafe "hs_b3DefaultParallelJointDef"
  c_b3DefaultParallelJointDef :: Ptr ParallelJointDef -> IO ()

foreign import ccall unsafe "hs_b3DefaultPrismaticJointDef"
  c_b3DefaultPrismaticJointDef :: Ptr PrismaticJointDef -> IO ()

foreign import ccall unsafe "hs_b3DefaultRevoluteJointDef"
  c_b3DefaultRevoluteJointDef :: Ptr RevoluteJointDef -> IO ()

foreign import ccall unsafe "hs_b3DefaultSphericalJointDef"
  c_b3DefaultSphericalJointDef :: Ptr SphericalJointDef -> IO ()

foreign import ccall unsafe "hs_b3DefaultWeldJointDef"
  c_b3DefaultWeldJointDef :: Ptr WeldJointDef -> IO ()

foreign import ccall unsafe "hs_b3DefaultWheelJointDef"
  c_b3DefaultWheelJointDef :: Ptr WheelJointDef -> IO ()

foreign import ccall unsafe "hs_b3DefaultFilterJointDef"
  c_b3DefaultFilterJointDef :: Ptr FilterJointDef -> IO ()

-- | A fully-initialised DistanceJointDef.
defaultDistanceJointDef :: IO DistanceJointDef
defaultDistanceJointDef :: IO DistanceJointDef
defaultDistanceJointDef = (Ptr DistanceJointDef -> IO ()) -> IO DistanceJointDef
forall a. Storable a => (Ptr a -> IO ()) -> IO a
allocaOut Ptr DistanceJointDef -> IO ()
c_b3DefaultDistanceJointDef

-- | A fully-initialised MotorJointDef.
defaultMotorJointDef :: IO MotorJointDef
defaultMotorJointDef :: IO MotorJointDef
defaultMotorJointDef = (Ptr MotorJointDef -> IO ()) -> IO MotorJointDef
forall a. Storable a => (Ptr a -> IO ()) -> IO a
allocaOut Ptr MotorJointDef -> IO ()
c_b3DefaultMotorJointDef

-- | A fully-initialised ParallelJointDef.
defaultParallelJointDef :: IO ParallelJointDef
defaultParallelJointDef :: IO ParallelJointDef
defaultParallelJointDef = (Ptr ParallelJointDef -> IO ()) -> IO ParallelJointDef
forall a. Storable a => (Ptr a -> IO ()) -> IO a
allocaOut Ptr ParallelJointDef -> IO ()
c_b3DefaultParallelJointDef

-- | A fully-initialised PrismaticJointDef.
defaultPrismaticJointDef :: IO PrismaticJointDef
defaultPrismaticJointDef :: IO PrismaticJointDef
defaultPrismaticJointDef = (Ptr PrismaticJointDef -> IO ()) -> IO PrismaticJointDef
forall a. Storable a => (Ptr a -> IO ()) -> IO a
allocaOut Ptr PrismaticJointDef -> IO ()
c_b3DefaultPrismaticJointDef

-- | A fully-initialised RevoluteJointDef.
defaultRevoluteJointDef :: IO RevoluteJointDef
defaultRevoluteJointDef :: IO RevoluteJointDef
defaultRevoluteJointDef = (Ptr RevoluteJointDef -> IO ()) -> IO RevoluteJointDef
forall a. Storable a => (Ptr a -> IO ()) -> IO a
allocaOut Ptr RevoluteJointDef -> IO ()
c_b3DefaultRevoluteJointDef

-- | A fully-initialised SphericalJointDef.
defaultSphericalJointDef :: IO SphericalJointDef
defaultSphericalJointDef :: IO SphericalJointDef
defaultSphericalJointDef = (Ptr SphericalJointDef -> IO ()) -> IO SphericalJointDef
forall a. Storable a => (Ptr a -> IO ()) -> IO a
allocaOut Ptr SphericalJointDef -> IO ()
c_b3DefaultSphericalJointDef

-- | A fully-initialised WeldJointDef.
defaultWeldJointDef :: IO WeldJointDef
defaultWeldJointDef :: IO WeldJointDef
defaultWeldJointDef = (Ptr WeldJointDef -> IO ()) -> IO WeldJointDef
forall a. Storable a => (Ptr a -> IO ()) -> IO a
allocaOut Ptr WeldJointDef -> IO ()
c_b3DefaultWeldJointDef

-- | A fully-initialised WheelJointDef.
defaultWheelJointDef :: IO WheelJointDef
defaultWheelJointDef :: IO WheelJointDef
defaultWheelJointDef = (Ptr WheelJointDef -> IO ()) -> IO WheelJointDef
forall a. Storable a => (Ptr a -> IO ()) -> IO a
allocaOut Ptr WheelJointDef -> IO ()
c_b3DefaultWheelJointDef

-- | A fully-initialised FilterJointDef.
defaultFilterJointDef :: IO FilterJointDef
defaultFilterJointDef :: IO FilterJointDef
defaultFilterJointDef = (Ptr FilterJointDef -> IO ()) -> IO FilterJointDef
forall a. Storable a => (Ptr a -> IO ()) -> IO a
allocaOut Ptr FilterJointDef -> IO ()
c_b3DefaultFilterJointDef

-- Queries and casts --------------------------------------------------------

foreign import ccall unsafe "hs_b3DefaultQueryFilter"
  c_b3DefaultQueryFilter :: Ptr QueryFilter -> IO ()

-- | Filter for world queries: which shape categories to accept. The optional
-- @id@ / @name@ pair tags the query in a recording; a 'nullPtr' name means
-- untagged.
data QueryFilter = QueryFilter
  { QueryFilter -> Word64
queryFilterCategoryBits :: Word64
  , QueryFilter -> Word64
queryFilterMaskBits     :: Word64
  , QueryFilter -> Word64
queryFilterId           :: Word64
  , QueryFilter -> CString
queryFilterName         :: CString
  }
  deriving (QueryFilter -> QueryFilter -> Bool
(QueryFilter -> QueryFilter -> Bool)
-> (QueryFilter -> QueryFilter -> Bool) -> Eq QueryFilter
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: QueryFilter -> QueryFilter -> Bool
== :: QueryFilter -> QueryFilter -> Bool
$c/= :: QueryFilter -> QueryFilter -> Bool
/= :: QueryFilter -> QueryFilter -> Bool
Eq, Int -> QueryFilter -> ShowS
[QueryFilter] -> ShowS
QueryFilter -> String
(Int -> QueryFilter -> ShowS)
-> (QueryFilter -> String)
-> ([QueryFilter] -> ShowS)
-> Show QueryFilter
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> QueryFilter -> ShowS
showsPrec :: Int -> QueryFilter -> ShowS
$cshow :: QueryFilter -> String
show :: QueryFilter -> String
$cshowList :: [QueryFilter] -> ShowS
showList :: [QueryFilter] -> ShowS
Show)

instance Storable QueryFilter where
  sizeOf :: QueryFilter -> Int
sizeOf QueryFilter
_ = (Int
32)
{-# LINE 1115 "src/Box3D/Types.hsc" #-}
  alignment _ = 8
{-# LINE 1116 "src/Box3D/Types.hsc" #-}
  peek p =
    QueryFilter
      <$> (\hsc_ptr -> peekByteOff hsc_ptr 0) p
{-# LINE 1119 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 8) p
{-# LINE 1120 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 16) p
{-# LINE 1121 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 24) p
{-# LINE 1122 "src/Box3D/Types.hsc" #-}
  poke p x = do
    (\hsc_ptr -> pokeByteOff hsc_ptr 0) p (queryFilterCategoryBits x)
{-# LINE 1124 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 8) p (queryFilterMaskBits x)
{-# LINE 1125 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 16) p (queryFilterId x)
{-# LINE 1126 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 24) p (queryFilterName x)
{-# LINE 1127 "src/Box3D/Types.hsc" #-}

-- | A fully-initialised query filter (accept everything, untagged).
defaultQueryFilter :: IO QueryFilter
defaultQueryFilter :: IO QueryFilter
defaultQueryFilter = (Ptr QueryFilter -> IO ()) -> IO QueryFilter
forall a. Storable a => (Ptr a -> IO ()) -> IO a
allocaOut Ptr QueryFilter -> IO ()
c_b3DefaultQueryFilter

-- | The mass, centroid and inertia tensor of a shape or body.
data MassData = MassData
  { MassData -> Float
massDataMass    :: Float
  , MassData -> Vec3
massDataCenter  :: Vec3
  , MassData -> Matrix3
massDataInertia :: Matrix3
  }
  deriving (MassData -> MassData -> Bool
(MassData -> MassData -> Bool)
-> (MassData -> MassData -> Bool) -> Eq MassData
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MassData -> MassData -> Bool
== :: MassData -> MassData -> Bool
$c/= :: MassData -> MassData -> Bool
/= :: MassData -> MassData -> Bool
Eq, Int -> MassData -> ShowS
[MassData] -> ShowS
MassData -> String
(Int -> MassData -> ShowS)
-> (MassData -> String) -> ([MassData] -> ShowS) -> Show MassData
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MassData -> ShowS
showsPrec :: Int -> MassData -> ShowS
$cshow :: MassData -> String
show :: MassData -> String
$cshowList :: [MassData] -> ShowS
showList :: [MassData] -> ShowS
Show)

instance Storable MassData where
  sizeOf :: MassData -> Int
sizeOf MassData
_ = (Int
52)
{-# LINE 1142 "src/Box3D/Types.hsc" #-}
  alignment _ = 4
{-# LINE 1143 "src/Box3D/Types.hsc" #-}
  peek p =
    MassData
      <$> (\hsc_ptr -> peekByteOff hsc_ptr 0) p
{-# LINE 1146 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 4) p
{-# LINE 1147 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 16) p
{-# LINE 1148 "src/Box3D/Types.hsc" #-}
  poke p x = do
    (\hsc_ptr -> pokeByteOff hsc_ptr 0) p (massDataMass x)
{-# LINE 1150 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 4) p (massDataCenter x)
{-# LINE 1151 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 16) p (massDataInertia x)
{-# LINE 1152 "src/Box3D/Types.hsc" #-}

-- | Low-level ray-cast input in the local frame of the target shape.
data RayCastInput = RayCastInput
  { RayCastInput -> Vec3
rayCastInputOrigin      :: Vec3
  , RayCastInput -> Vec3
rayCastInputTranslation :: Vec3
  , RayCastInput -> Float
rayCastInputMaxFraction :: Float
  }
  deriving (RayCastInput -> RayCastInput -> Bool
(RayCastInput -> RayCastInput -> Bool)
-> (RayCastInput -> RayCastInput -> Bool) -> Eq RayCastInput
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RayCastInput -> RayCastInput -> Bool
== :: RayCastInput -> RayCastInput -> Bool
$c/= :: RayCastInput -> RayCastInput -> Bool
/= :: RayCastInput -> RayCastInput -> Bool
Eq, Int -> RayCastInput -> ShowS
[RayCastInput] -> ShowS
RayCastInput -> String
(Int -> RayCastInput -> ShowS)
-> (RayCastInput -> String)
-> ([RayCastInput] -> ShowS)
-> Show RayCastInput
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> RayCastInput -> ShowS
showsPrec :: Int -> RayCastInput -> ShowS
$cshow :: RayCastInput -> String
show :: RayCastInput -> String
$cshowList :: [RayCastInput] -> ShowS
showList :: [RayCastInput] -> ShowS
Show)

instance Storable RayCastInput where
  sizeOf :: RayCastInput -> Int
sizeOf RayCastInput
_ = (Int
28)
{-# LINE 1163 "src/Box3D/Types.hsc" #-}
  alignment _ = 4
{-# LINE 1164 "src/Box3D/Types.hsc" #-}
  peek p =
    RayCastInput
      <$> (\hsc_ptr -> peekByteOff hsc_ptr 0) p
{-# LINE 1167 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 12) p
{-# LINE 1168 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 24) p
{-# LINE 1169 "src/Box3D/Types.hsc" #-}
  poke p x = do
    (\hsc_ptr -> pokeByteOff hsc_ptr 0) p (rayCastInputOrigin x)
{-# LINE 1171 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 12) p (rayCastInputTranslation x)
{-# LINE 1172 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 24) p (rayCastInputMaxFraction x)
{-# LINE 1173 "src/Box3D/Types.hsc" #-}

-- | Low-level ray or shape-cast output, in the frame of the input. A zero
-- fraction and normal signal initial overlap. The triangle\/child\/material
-- indices are -1 when not applicable.
data CastOutput = CastOutput
  { CastOutput -> Vec3
castOutputNormal        :: Vec3
  , CastOutput -> Vec3
castOutputPoint         :: Vec3
  , CastOutput -> Float
castOutputFraction      :: Float
  , CastOutput -> CInt
castOutputIterations    :: CInt
  , CastOutput -> CInt
castOutputTriangleIndex :: CInt
  , CastOutput -> CInt
castOutputChildIndex    :: CInt
  , CastOutput -> CInt
castOutputMaterialIndex :: CInt
  , CastOutput -> CBool
castOutputHit           :: CBool
  }
  deriving (CastOutput -> CastOutput -> Bool
(CastOutput -> CastOutput -> Bool)
-> (CastOutput -> CastOutput -> Bool) -> Eq CastOutput
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: CastOutput -> CastOutput -> Bool
== :: CastOutput -> CastOutput -> Bool
$c/= :: CastOutput -> CastOutput -> Bool
/= :: CastOutput -> CastOutput -> Bool
Eq, Int -> CastOutput -> ShowS
[CastOutput] -> ShowS
CastOutput -> String
(Int -> CastOutput -> ShowS)
-> (CastOutput -> String)
-> ([CastOutput] -> ShowS)
-> Show CastOutput
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> CastOutput -> ShowS
showsPrec :: Int -> CastOutput -> ShowS
$cshow :: CastOutput -> String
show :: CastOutput -> String
$cshowList :: [CastOutput] -> ShowS
showList :: [CastOutput] -> ShowS
Show)

instance Storable CastOutput where
  sizeOf :: CastOutput -> Int
sizeOf CastOutput
_ = (Int
48)
{-# LINE 1191 "src/Box3D/Types.hsc" #-}
  alignment _ = 4
{-# LINE 1192 "src/Box3D/Types.hsc" #-}
  peek p =
    CastOutput
      <$> (\hsc_ptr -> peekByteOff hsc_ptr 0) p
{-# LINE 1195 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 12) p
{-# LINE 1196 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 24) p
{-# LINE 1197 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 28) p
{-# LINE 1198 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 32) p
{-# LINE 1199 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 36) p
{-# LINE 1200 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 40) p
{-# LINE 1201 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 44) p
{-# LINE 1202 "src/Box3D/Types.hsc" #-}
  poke p x = do
    (\hsc_ptr -> pokeByteOff hsc_ptr 0) p (castOutputNormal x)
{-# LINE 1204 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 12) p (castOutputPoint x)
{-# LINE 1205 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 24) p (castOutputFraction x)
{-# LINE 1206 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 28) p (castOutputIterations x)
{-# LINE 1207 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 32) p (castOutputTriangleIndex x)
{-# LINE 1208 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 36) p (castOutputChildIndex x)
{-# LINE 1209 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 40) p (castOutputMaterialIndex x)
{-# LINE 1210 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 44) p (castOutputHit x)
{-# LINE 1211 "src/Box3D/Types.hsc" #-}

-- | World-space cast output. In single-precision builds (the default) this is
-- the same struct as 'CastOutput'.
type WorldCastOutput = CastOutput

-- | The closest hit of a world ray cast ('Box3D.World.castRayClosest').
data RayResult = RayResult
  { RayResult -> ShapeId
rayResultShapeId        :: ShapeId
  , RayResult -> Vec3
rayResultPoint          :: Pos
  , RayResult -> Vec3
rayResultNormal         :: Vec3
  , RayResult -> Word64
rayResultUserMaterialId :: Word64
  , RayResult -> Float
rayResultFraction       :: Float
  , RayResult -> CInt
rayResultTriangleIndex  :: CInt
  , RayResult -> CInt
rayResultChildIndex     :: CInt
  , RayResult -> CInt
rayResultNodeVisits     :: CInt
  , RayResult -> CInt
rayResultLeafVisits     :: CInt
  , RayResult -> CBool
rayResultHit            :: CBool
  }
  deriving (RayResult -> RayResult -> Bool
(RayResult -> RayResult -> Bool)
-> (RayResult -> RayResult -> Bool) -> Eq RayResult
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RayResult -> RayResult -> Bool
== :: RayResult -> RayResult -> Bool
$c/= :: RayResult -> RayResult -> Bool
/= :: RayResult -> RayResult -> Bool
Eq, Int -> RayResult -> ShowS
[RayResult] -> ShowS
RayResult -> String
(Int -> RayResult -> ShowS)
-> (RayResult -> String)
-> ([RayResult] -> ShowS)
-> Show RayResult
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> RayResult -> ShowS
showsPrec :: Int -> RayResult -> ShowS
$cshow :: RayResult -> String
show :: RayResult -> String
$cshowList :: [RayResult] -> ShowS
showList :: [RayResult] -> ShowS
Show)

instance Storable RayResult where
  sizeOf :: RayResult -> Int
sizeOf RayResult
_ = (Int
64)
{-# LINE 1233 "src/Box3D/Types.hsc" #-}
  alignment _ = 8
{-# LINE 1234 "src/Box3D/Types.hsc" #-}
  peek p =
    RayResult
      <$> (\hsc_ptr -> peekByteOff hsc_ptr 0) p
{-# LINE 1237 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 8) p
{-# LINE 1238 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 20) p
{-# LINE 1239 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 32) p
{-# LINE 1240 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 40) p
{-# LINE 1241 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 44) p
{-# LINE 1242 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 48) p
{-# LINE 1243 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 52) p
{-# LINE 1244 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 56) p
{-# LINE 1245 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 60) p
{-# LINE 1246 "src/Box3D/Types.hsc" #-}
  poke p x = do
    (\hsc_ptr -> pokeByteOff hsc_ptr 0) p (rayResultShapeId x)
{-# LINE 1248 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 8) p (rayResultPoint x)
{-# LINE 1249 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 20) p (rayResultNormal x)
{-# LINE 1250 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 32) p (rayResultUserMaterialId x)
{-# LINE 1251 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 40) p (rayResultFraction x)
{-# LINE 1252 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 44) p (rayResultTriangleIndex x)
{-# LINE 1253 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 48) p (rayResultChildIndex x)
{-# LINE 1254 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 52) p (rayResultNodeVisits x)
{-# LINE 1255 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 56) p (rayResultLeafVisits x)
{-# LINE 1256 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 60) p (rayResultHit x)
{-# LINE 1257 "src/Box3D/Types.hsc" #-}

-- | Broad-phase traversal counters for a query. Diagnostic.
data TreeStats = TreeStats
  { TreeStats -> CInt
treeStatsNodeVisits :: CInt
  , TreeStats -> CInt
treeStatsLeafVisits :: CInt
  }
  deriving (TreeStats -> TreeStats -> Bool
(TreeStats -> TreeStats -> Bool)
-> (TreeStats -> TreeStats -> Bool) -> Eq TreeStats
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TreeStats -> TreeStats -> Bool
== :: TreeStats -> TreeStats -> Bool
$c/= :: TreeStats -> TreeStats -> Bool
/= :: TreeStats -> TreeStats -> Bool
Eq, Int -> TreeStats -> ShowS
[TreeStats] -> ShowS
TreeStats -> String
(Int -> TreeStats -> ShowS)
-> (TreeStats -> String)
-> ([TreeStats] -> ShowS)
-> Show TreeStats
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TreeStats -> ShowS
showsPrec :: Int -> TreeStats -> ShowS
$cshow :: TreeStats -> String
show :: TreeStats -> String
$cshowList :: [TreeStats] -> ShowS
showList :: [TreeStats] -> ShowS
Show)

instance Storable TreeStats where
  sizeOf :: TreeStats -> Int
sizeOf TreeStats
_ = (Int
8)
{-# LINE 1267 "src/Box3D/Types.hsc" #-}
  alignment _ = 4
{-# LINE 1268 "src/Box3D/Types.hsc" #-}
  peek p =
    TreeStats
      <$> (\hsc_ptr -> peekByteOff hsc_ptr 0) p
{-# LINE 1271 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 4) p
{-# LINE 1272 "src/Box3D/Types.hsc" #-}
  poke p x = do
    (\hsc_ptr -> pokeByteOff hsc_ptr 0) p (treeStatsNodeVisits x)
{-# LINE 1274 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 4) p (treeStatsLeafVisits x)
{-# LINE 1275 "src/Box3D/Types.hsc" #-}

-- | The motion of a body between two configurations, for TOI computation.
data Sweep = Sweep
  { Sweep -> Vec3
sweepLocalCenter :: Vec3
  , Sweep -> Vec3
sweepC1          :: Vec3
  , Sweep -> Vec3
sweepC2          :: Vec3
  , Sweep -> Quat
sweepQ1          :: Quat
  , Sweep -> Quat
sweepQ2          :: Quat
  }
  deriving (Sweep -> Sweep -> Bool
(Sweep -> Sweep -> Bool) -> (Sweep -> Sweep -> Bool) -> Eq Sweep
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Sweep -> Sweep -> Bool
== :: Sweep -> Sweep -> Bool
$c/= :: Sweep -> Sweep -> Bool
/= :: Sweep -> Sweep -> Bool
Eq, Int -> Sweep -> ShowS
[Sweep] -> ShowS
Sweep -> String
(Int -> Sweep -> ShowS)
-> (Sweep -> String) -> ([Sweep] -> ShowS) -> Show Sweep
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Sweep -> ShowS
showsPrec :: Int -> Sweep -> ShowS
$cshow :: Sweep -> String
show :: Sweep -> String
$cshowList :: [Sweep] -> ShowS
showList :: [Sweep] -> ShowS
Show)

instance Storable Sweep where
  sizeOf :: Sweep -> Int
sizeOf Sweep
_ = (Int
68)
{-# LINE 1288 "src/Box3D/Types.hsc" #-}
  alignment _ = 4
{-# LINE 1289 "src/Box3D/Types.hsc" #-}
  peek p =
    Sweep
      <$> (\hsc_ptr -> peekByteOff hsc_ptr 0) p
{-# LINE 1292 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 12) p
{-# LINE 1293 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 24) p
{-# LINE 1294 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 36) p
{-# LINE 1295 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 52) p
{-# LINE 1296 "src/Box3D/Types.hsc" #-}
  poke p x = do
    (\hsc_ptr -> pokeByteOff hsc_ptr 0) p (sweepLocalCenter x)
{-# LINE 1298 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 12) p (sweepC1 x)
{-# LINE 1299 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 24) p (sweepC2 x)
{-# LINE 1300 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 36) p (sweepQ1 x)
{-# LINE 1301 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 52) p (sweepQ2 x)
{-# LINE 1302 "src/Box3D/Types.hsc" #-}

-- | One collision plane from 'Box3D.World.collideMover', relative to the
-- query origin.
data PlaneResult = PlaneResult
  { PlaneResult -> Plane
planeResultPlane :: Plane
  , PlaneResult -> Vec3
planeResultPoint :: Vec3
  }
  deriving (PlaneResult -> PlaneResult -> Bool
(PlaneResult -> PlaneResult -> Bool)
-> (PlaneResult -> PlaneResult -> Bool) -> Eq PlaneResult
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PlaneResult -> PlaneResult -> Bool
== :: PlaneResult -> PlaneResult -> Bool
$c/= :: PlaneResult -> PlaneResult -> Bool
/= :: PlaneResult -> PlaneResult -> Bool
Eq, Int -> PlaneResult -> ShowS
[PlaneResult] -> ShowS
PlaneResult -> String
(Int -> PlaneResult -> ShowS)
-> (PlaneResult -> String)
-> ([PlaneResult] -> ShowS)
-> Show PlaneResult
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> PlaneResult -> ShowS
showsPrec :: Int -> PlaneResult -> ShowS
$cshow :: PlaneResult -> String
show :: PlaneResult -> String
$cshowList :: [PlaneResult] -> ShowS
showList :: [PlaneResult] -> ShowS
Show)

instance Storable PlaneResult where
  sizeOf :: PlaneResult -> Int
sizeOf PlaneResult
_ = (Int
28)
{-# LINE 1313 "src/Box3D/Types.hsc" #-}
  alignment _ = 4
{-# LINE 1314 "src/Box3D/Types.hsc" #-}
  peek p =
    PlaneResult
      <$> (\hsc_ptr -> peekByteOff hsc_ptr 0) p
{-# LINE 1317 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 16) p
{-# LINE 1318 "src/Box3D/Types.hsc" #-}
  poke p x = do
    (\hsc_ptr -> pokeByteOff hsc_ptr 0) p (planeResultPlane x)
{-# LINE 1320 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 16) p (planeResultPoint x)
{-# LINE 1321 "src/Box3D/Types.hsc" #-}

-- | The size of the (opaque) @b3DynamicTree@ struct, for allocating one to
-- initialise with 'Box3D.DynamicTree.create'.
dynamicTreeByteCount :: Int
dynamicTreeByteCount :: Int
dynamicTreeByteCount = (Int
80)
{-# LINE 1326 "src/Box3D/Types.hsc" #-}

-- Events ------------------------------------------------------------------

-- | A body move event: the new transform of a body that moved this step.
-- Read after 'Box3D.World.step' and before the next step (see "Box3D.Events").
data BodyMoveEvent = BodyMoveEvent
  { BodyMoveEvent -> Ptr ()
bodyMoveEventUserData   :: Ptr ()
  , BodyMoveEvent -> Transform
bodyMoveEventTransform  :: Transform
  , BodyMoveEvent -> BodyId
bodyMoveEventBodyId     :: BodyId
  , BodyMoveEvent -> CBool
bodyMoveEventFellAsleep :: CBool
  }
  deriving (BodyMoveEvent -> BodyMoveEvent -> Bool
(BodyMoveEvent -> BodyMoveEvent -> Bool)
-> (BodyMoveEvent -> BodyMoveEvent -> Bool) -> Eq BodyMoveEvent
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: BodyMoveEvent -> BodyMoveEvent -> Bool
== :: BodyMoveEvent -> BodyMoveEvent -> Bool
$c/= :: BodyMoveEvent -> BodyMoveEvent -> Bool
/= :: BodyMoveEvent -> BodyMoveEvent -> Bool
Eq, Int -> BodyMoveEvent -> ShowS
[BodyMoveEvent] -> ShowS
BodyMoveEvent -> String
(Int -> BodyMoveEvent -> ShowS)
-> (BodyMoveEvent -> String)
-> ([BodyMoveEvent] -> ShowS)
-> Show BodyMoveEvent
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> BodyMoveEvent -> ShowS
showsPrec :: Int -> BodyMoveEvent -> ShowS
$cshow :: BodyMoveEvent -> String
show :: BodyMoveEvent -> String
$cshowList :: [BodyMoveEvent] -> ShowS
showList :: [BodyMoveEvent] -> ShowS
Show)

instance Storable BodyMoveEvent where
  sizeOf :: BodyMoveEvent -> Int
sizeOf BodyMoveEvent
_ = (Int
48)
{-# LINE 1341 "src/Box3D/Types.hsc" #-}
  alignment _ = 8
{-# LINE 1342 "src/Box3D/Types.hsc" #-}
  peek p =
    BodyMoveEvent
      <$> (\hsc_ptr -> peekByteOff hsc_ptr 0) p
{-# LINE 1345 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 8) p
{-# LINE 1346 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 36) p
{-# LINE 1347 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 44) p
{-# LINE 1348 "src/Box3D/Types.hsc" #-}
  poke p x = do
    (\hsc_ptr -> pokeByteOff hsc_ptr 0) p (bodyMoveEventUserData x)
{-# LINE 1350 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 8) p (bodyMoveEventTransform x)
{-# LINE 1351 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 36) p (bodyMoveEventBodyId x)
{-# LINE 1352 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 44) p (bodyMoveEventFellAsleep x)
{-# LINE 1353 "src/Box3D/Types.hsc" #-}

-- | Body events buffer: a C-owned array of 'BodyMoveEvent' valid until the
-- next 'Box3D.World.step'. Marshalled to a list by "Box3D.Events".
data BodyEvents = BodyEvents
  { BodyEvents -> Ptr BodyMoveEvent
bodyEventsMoveEvents :: Ptr BodyMoveEvent
  , BodyEvents -> CInt
bodyEventsMoveCount  :: CInt
  }
  deriving (BodyEvents -> BodyEvents -> Bool
(BodyEvents -> BodyEvents -> Bool)
-> (BodyEvents -> BodyEvents -> Bool) -> Eq BodyEvents
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: BodyEvents -> BodyEvents -> Bool
== :: BodyEvents -> BodyEvents -> Bool
$c/= :: BodyEvents -> BodyEvents -> Bool
/= :: BodyEvents -> BodyEvents -> Bool
Eq, Int -> BodyEvents -> ShowS
[BodyEvents] -> ShowS
BodyEvents -> String
(Int -> BodyEvents -> ShowS)
-> (BodyEvents -> String)
-> ([BodyEvents] -> ShowS)
-> Show BodyEvents
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> BodyEvents -> ShowS
showsPrec :: Int -> BodyEvents -> ShowS
$cshow :: BodyEvents -> String
show :: BodyEvents -> String
$cshowList :: [BodyEvents] -> ShowS
showList :: [BodyEvents] -> ShowS
Show)

instance Storable BodyEvents where
  sizeOf :: BodyEvents -> Int
sizeOf BodyEvents
_ = (Int
16)
{-# LINE 1364 "src/Box3D/Types.hsc" #-}
  alignment _ = 8
{-# LINE 1365 "src/Box3D/Types.hsc" #-}
  peek p =
    BodyEvents
      <$> (\hsc_ptr -> peekByteOff hsc_ptr 0) p
{-# LINE 1368 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 8) p
{-# LINE 1369 "src/Box3D/Types.hsc" #-}
  poke p x = do
    (\hsc_ptr -> pokeByteOff hsc_ptr 0) p (bodyEventsMoveEvents x)
{-# LINE 1371 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 8) p (bodyEventsMoveCount x)
{-# LINE 1372 "src/Box3D/Types.hsc" #-}

-- | A shape started overlapping a sensor shape.
data SensorBeginTouchEvent = SensorBeginTouchEvent
  { SensorBeginTouchEvent -> ShapeId
sensorBeginTouchEventSensorShapeId  :: ShapeId
  , SensorBeginTouchEvent -> ShapeId
sensorBeginTouchEventVisitorShapeId :: ShapeId
  }
  deriving (SensorBeginTouchEvent -> SensorBeginTouchEvent -> Bool
(SensorBeginTouchEvent -> SensorBeginTouchEvent -> Bool)
-> (SensorBeginTouchEvent -> SensorBeginTouchEvent -> Bool)
-> Eq SensorBeginTouchEvent
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SensorBeginTouchEvent -> SensorBeginTouchEvent -> Bool
== :: SensorBeginTouchEvent -> SensorBeginTouchEvent -> Bool
$c/= :: SensorBeginTouchEvent -> SensorBeginTouchEvent -> Bool
/= :: SensorBeginTouchEvent -> SensorBeginTouchEvent -> Bool
Eq, Int -> SensorBeginTouchEvent -> ShowS
[SensorBeginTouchEvent] -> ShowS
SensorBeginTouchEvent -> String
(Int -> SensorBeginTouchEvent -> ShowS)
-> (SensorBeginTouchEvent -> String)
-> ([SensorBeginTouchEvent] -> ShowS)
-> Show SensorBeginTouchEvent
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SensorBeginTouchEvent -> ShowS
showsPrec :: Int -> SensorBeginTouchEvent -> ShowS
$cshow :: SensorBeginTouchEvent -> String
show :: SensorBeginTouchEvent -> String
$cshowList :: [SensorBeginTouchEvent] -> ShowS
showList :: [SensorBeginTouchEvent] -> ShowS
Show)

instance Storable SensorBeginTouchEvent where
  sizeOf :: SensorBeginTouchEvent -> Int
sizeOf SensorBeginTouchEvent
_ = (Int
16)
{-# LINE 1382 "src/Box3D/Types.hsc" #-}
  alignment _ = 4
{-# LINE 1383 "src/Box3D/Types.hsc" #-}
  peek p =
    SensorBeginTouchEvent
      <$> (\hsc_ptr -> peekByteOff hsc_ptr 0) p
{-# LINE 1386 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 8) p
{-# LINE 1387 "src/Box3D/Types.hsc" #-}
  poke p x = do
    (\hsc_ptr -> pokeByteOff hsc_ptr 0) p (sensorBeginTouchEventSensorShapeId x)
{-# LINE 1389 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 8) p (sensorBeginTouchEventVisitorShapeId x)
{-# LINE 1390 "src/Box3D/Types.hsc" #-}

-- | A shape stopped overlapping a sensor shape. Either shape may already be
-- destroyed; check with @Box3D.Shape.isValid@.
data SensorEndTouchEvent = SensorEndTouchEvent
  { SensorEndTouchEvent -> ShapeId
sensorEndTouchEventSensorShapeId  :: ShapeId
  , SensorEndTouchEvent -> ShapeId
sensorEndTouchEventVisitorShapeId :: ShapeId
  }
  deriving (SensorEndTouchEvent -> SensorEndTouchEvent -> Bool
(SensorEndTouchEvent -> SensorEndTouchEvent -> Bool)
-> (SensorEndTouchEvent -> SensorEndTouchEvent -> Bool)
-> Eq SensorEndTouchEvent
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SensorEndTouchEvent -> SensorEndTouchEvent -> Bool
== :: SensorEndTouchEvent -> SensorEndTouchEvent -> Bool
$c/= :: SensorEndTouchEvent -> SensorEndTouchEvent -> Bool
/= :: SensorEndTouchEvent -> SensorEndTouchEvent -> Bool
Eq, Int -> SensorEndTouchEvent -> ShowS
[SensorEndTouchEvent] -> ShowS
SensorEndTouchEvent -> String
(Int -> SensorEndTouchEvent -> ShowS)
-> (SensorEndTouchEvent -> String)
-> ([SensorEndTouchEvent] -> ShowS)
-> Show SensorEndTouchEvent
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SensorEndTouchEvent -> ShowS
showsPrec :: Int -> SensorEndTouchEvent -> ShowS
$cshow :: SensorEndTouchEvent -> String
show :: SensorEndTouchEvent -> String
$cshowList :: [SensorEndTouchEvent] -> ShowS
showList :: [SensorEndTouchEvent] -> ShowS
Show)

instance Storable SensorEndTouchEvent where
  sizeOf :: SensorEndTouchEvent -> Int
sizeOf SensorEndTouchEvent
_ = (Int
16)
{-# LINE 1401 "src/Box3D/Types.hsc" #-}
  alignment _ = 4
{-# LINE 1402 "src/Box3D/Types.hsc" #-}
  peek p =
    SensorEndTouchEvent
      <$> (\hsc_ptr -> peekByteOff hsc_ptr 0) p
{-# LINE 1405 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 8) p
{-# LINE 1406 "src/Box3D/Types.hsc" #-}
  poke p x = do
    (\hsc_ptr -> pokeByteOff hsc_ptr 0) p (sensorEndTouchEventSensorShapeId x)
{-# LINE 1408 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 8) p (sensorEndTouchEventVisitorShapeId x)
{-# LINE 1409 "src/Box3D/Types.hsc" #-}

-- | Sensor events buffer: C-owned begin/end arrays valid until the next
-- 'Box3D.World.step'. Marshalled to lists by "Box3D.Events".
data SensorEvents = SensorEvents
  { SensorEvents -> Ptr SensorBeginTouchEvent
sensorEventsBeginEvents :: Ptr SensorBeginTouchEvent
  , SensorEvents -> Ptr SensorEndTouchEvent
sensorEventsEndEvents   :: Ptr SensorEndTouchEvent
  , SensorEvents -> CInt
sensorEventsBeginCount  :: CInt
  , SensorEvents -> CInt
sensorEventsEndCount    :: CInt
  }
  deriving (SensorEvents -> SensorEvents -> Bool
(SensorEvents -> SensorEvents -> Bool)
-> (SensorEvents -> SensorEvents -> Bool) -> Eq SensorEvents
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SensorEvents -> SensorEvents -> Bool
== :: SensorEvents -> SensorEvents -> Bool
$c/= :: SensorEvents -> SensorEvents -> Bool
/= :: SensorEvents -> SensorEvents -> Bool
Eq, Int -> SensorEvents -> ShowS
[SensorEvents] -> ShowS
SensorEvents -> String
(Int -> SensorEvents -> ShowS)
-> (SensorEvents -> String)
-> ([SensorEvents] -> ShowS)
-> Show SensorEvents
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SensorEvents -> ShowS
showsPrec :: Int -> SensorEvents -> ShowS
$cshow :: SensorEvents -> String
show :: SensorEvents -> String
$cshowList :: [SensorEvents] -> ShowS
showList :: [SensorEvents] -> ShowS
Show)

instance Storable SensorEvents where
  sizeOf :: SensorEvents -> Int
sizeOf SensorEvents
_ = (Int
24)
{-# LINE 1422 "src/Box3D/Types.hsc" #-}
  alignment _ = 8
{-# LINE 1423 "src/Box3D/Types.hsc" #-}
  peek p =
    SensorEvents
      <$> (\hsc_ptr -> peekByteOff hsc_ptr 0) p
{-# LINE 1426 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 8) p
{-# LINE 1427 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 16) p
{-# LINE 1428 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 20) p
{-# LINE 1429 "src/Box3D/Types.hsc" #-}
  poke p x = do
    (\hsc_ptr -> pokeByteOff hsc_ptr 0) p (sensorEventsBeginEvents x)
{-# LINE 1431 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 8) p (sensorEventsEndEvents x)
{-# LINE 1432 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 16) p (sensorEventsBeginCount x)
{-# LINE 1433 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 20) p (sensorEventsEndCount x)
{-# LINE 1434 "src/Box3D/Types.hsc" #-}

-- | Two shapes began touching.
data ContactBeginTouchEvent = ContactBeginTouchEvent
  { ContactBeginTouchEvent -> ShapeId
contactBeginTouchEventShapeIdA  :: ShapeId
  , ContactBeginTouchEvent -> ShapeId
contactBeginTouchEventShapeIdB  :: ShapeId
  , ContactBeginTouchEvent -> ContactId
contactBeginTouchEventContactId :: ContactId
  }
  deriving (ContactBeginTouchEvent -> ContactBeginTouchEvent -> Bool
(ContactBeginTouchEvent -> ContactBeginTouchEvent -> Bool)
-> (ContactBeginTouchEvent -> ContactBeginTouchEvent -> Bool)
-> Eq ContactBeginTouchEvent
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ContactBeginTouchEvent -> ContactBeginTouchEvent -> Bool
== :: ContactBeginTouchEvent -> ContactBeginTouchEvent -> Bool
$c/= :: ContactBeginTouchEvent -> ContactBeginTouchEvent -> Bool
/= :: ContactBeginTouchEvent -> ContactBeginTouchEvent -> Bool
Eq, Int -> ContactBeginTouchEvent -> ShowS
[ContactBeginTouchEvent] -> ShowS
ContactBeginTouchEvent -> String
(Int -> ContactBeginTouchEvent -> ShowS)
-> (ContactBeginTouchEvent -> String)
-> ([ContactBeginTouchEvent] -> ShowS)
-> Show ContactBeginTouchEvent
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ContactBeginTouchEvent -> ShowS
showsPrec :: Int -> ContactBeginTouchEvent -> ShowS
$cshow :: ContactBeginTouchEvent -> String
show :: ContactBeginTouchEvent -> String
$cshowList :: [ContactBeginTouchEvent] -> ShowS
showList :: [ContactBeginTouchEvent] -> ShowS
Show)

instance Storable ContactBeginTouchEvent where
  sizeOf :: ContactBeginTouchEvent -> Int
sizeOf ContactBeginTouchEvent
_ = (Int
28)
{-# LINE 1445 "src/Box3D/Types.hsc" #-}
  alignment _ = 4
{-# LINE 1446 "src/Box3D/Types.hsc" #-}
  peek p =
    ContactBeginTouchEvent
      <$> (\hsc_ptr -> peekByteOff hsc_ptr 0) p
{-# LINE 1449 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 8) p
{-# LINE 1450 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 16) p
{-# LINE 1451 "src/Box3D/Types.hsc" #-}
  poke p x = do
    (\hsc_ptr -> pokeByteOff hsc_ptr 0) p (contactBeginTouchEventShapeIdA x)
{-# LINE 1453 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 8) p (contactBeginTouchEventShapeIdB x)
{-# LINE 1454 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 16) p (contactBeginTouchEventContactId x)
{-# LINE 1455 "src/Box3D/Types.hsc" #-}

-- | Two shapes stopped touching. The shapes and the contact may already be
-- destroyed; check with the respective @isValid@.
data ContactEndTouchEvent = ContactEndTouchEvent
  { ContactEndTouchEvent -> ShapeId
contactEndTouchEventShapeIdA  :: ShapeId
  , ContactEndTouchEvent -> ShapeId
contactEndTouchEventShapeIdB  :: ShapeId
  , ContactEndTouchEvent -> ContactId
contactEndTouchEventContactId :: ContactId
  }
  deriving (ContactEndTouchEvent -> ContactEndTouchEvent -> Bool
(ContactEndTouchEvent -> ContactEndTouchEvent -> Bool)
-> (ContactEndTouchEvent -> ContactEndTouchEvent -> Bool)
-> Eq ContactEndTouchEvent
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ContactEndTouchEvent -> ContactEndTouchEvent -> Bool
== :: ContactEndTouchEvent -> ContactEndTouchEvent -> Bool
$c/= :: ContactEndTouchEvent -> ContactEndTouchEvent -> Bool
/= :: ContactEndTouchEvent -> ContactEndTouchEvent -> Bool
Eq, Int -> ContactEndTouchEvent -> ShowS
[ContactEndTouchEvent] -> ShowS
ContactEndTouchEvent -> String
(Int -> ContactEndTouchEvent -> ShowS)
-> (ContactEndTouchEvent -> String)
-> ([ContactEndTouchEvent] -> ShowS)
-> Show ContactEndTouchEvent
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ContactEndTouchEvent -> ShowS
showsPrec :: Int -> ContactEndTouchEvent -> ShowS
$cshow :: ContactEndTouchEvent -> String
show :: ContactEndTouchEvent -> String
$cshowList :: [ContactEndTouchEvent] -> ShowS
showList :: [ContactEndTouchEvent] -> ShowS
Show)

instance Storable ContactEndTouchEvent where
  sizeOf :: ContactEndTouchEvent -> Int
sizeOf ContactEndTouchEvent
_ = (Int
28)
{-# LINE 1467 "src/Box3D/Types.hsc" #-}
  alignment _ = 4
{-# LINE 1468 "src/Box3D/Types.hsc" #-}
  peek p =
    ContactEndTouchEvent
      <$> (\hsc_ptr -> peekByteOff hsc_ptr 0) p
{-# LINE 1471 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 8) p
{-# LINE 1472 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 16) p
{-# LINE 1473 "src/Box3D/Types.hsc" #-}
  poke p x = do
    (\hsc_ptr -> pokeByteOff hsc_ptr 0) p (contactEndTouchEventShapeIdA x)
{-# LINE 1475 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 8) p (contactEndTouchEventShapeIdB x)
{-# LINE 1476 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 16) p (contactEndTouchEventContactId x)
{-# LINE 1477 "src/Box3D/Types.hsc" #-}

-- | Two shapes collided faster than the hit speed threshold
-- (@worldDefHitEventThreshold@; hit events must be enabled per shape).
data ContactHitEvent = ContactHitEvent
  { ContactHitEvent -> ShapeId
contactHitEventShapeIdA        :: ShapeId
  , ContactHitEvent -> ShapeId
contactHitEventShapeIdB        :: ShapeId
  , ContactHitEvent -> ContactId
contactHitEventContactId       :: ContactId
  , ContactHitEvent -> Vec3
contactHitEventPoint           :: Pos
  , ContactHitEvent -> Vec3
contactHitEventNormal          :: Vec3
  , ContactHitEvent -> Float
contactHitEventApproachSpeed   :: Float
  , ContactHitEvent -> Word64
contactHitEventUserMaterialIdA :: Word64
  , ContactHitEvent -> Word64
contactHitEventUserMaterialIdB :: Word64
  }
  deriving (ContactHitEvent -> ContactHitEvent -> Bool
(ContactHitEvent -> ContactHitEvent -> Bool)
-> (ContactHitEvent -> ContactHitEvent -> Bool)
-> Eq ContactHitEvent
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ContactHitEvent -> ContactHitEvent -> Bool
== :: ContactHitEvent -> ContactHitEvent -> Bool
$c/= :: ContactHitEvent -> ContactHitEvent -> Bool
/= :: ContactHitEvent -> ContactHitEvent -> Bool
Eq, Int -> ContactHitEvent -> ShowS
[ContactHitEvent] -> ShowS
ContactHitEvent -> String
(Int -> ContactHitEvent -> ShowS)
-> (ContactHitEvent -> String)
-> ([ContactHitEvent] -> ShowS)
-> Show ContactHitEvent
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ContactHitEvent -> ShowS
showsPrec :: Int -> ContactHitEvent -> ShowS
$cshow :: ContactHitEvent -> String
show :: ContactHitEvent -> String
$cshowList :: [ContactHitEvent] -> ShowS
showList :: [ContactHitEvent] -> ShowS
Show)

instance Storable ContactHitEvent where
  sizeOf :: ContactHitEvent -> Int
sizeOf ContactHitEvent
_ = (Int
72)
{-# LINE 1494 "src/Box3D/Types.hsc" #-}
  alignment _ = 8
{-# LINE 1495 "src/Box3D/Types.hsc" #-}
  peek p =
    ContactHitEvent
      <$> (\hsc_ptr -> peekByteOff hsc_ptr 0) p
{-# LINE 1498 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 8) p
{-# LINE 1499 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 16) p
{-# LINE 1500 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 28) p
{-# LINE 1501 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 40) p
{-# LINE 1502 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 52) p
{-# LINE 1503 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 56) p
{-# LINE 1504 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 64) p
{-# LINE 1505 "src/Box3D/Types.hsc" #-}
  poke p x = do
    (\hsc_ptr -> pokeByteOff hsc_ptr 0) p (contactHitEventShapeIdA x)
{-# LINE 1507 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 8) p (contactHitEventShapeIdB x)
{-# LINE 1508 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 16) p (contactHitEventContactId x)
{-# LINE 1509 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 28) p (contactHitEventPoint x)
{-# LINE 1510 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 40) p (contactHitEventNormal x)
{-# LINE 1511 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 52) p (contactHitEventApproachSpeed x)
{-# LINE 1512 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 56) p (contactHitEventUserMaterialIdA x)
{-# LINE 1513 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 64) p (contactHitEventUserMaterialIdB x)
{-# LINE 1514 "src/Box3D/Types.hsc" #-}

-- | Contact events buffer: C-owned begin/end/hit arrays valid until the next
-- 'Box3D.World.step'. Marshalled to lists by "Box3D.Events".
data ContactEvents = ContactEvents
  { ContactEvents -> Ptr ContactBeginTouchEvent
contactEventsBeginEvents :: Ptr ContactBeginTouchEvent
  , ContactEvents -> Ptr ContactEndTouchEvent
contactEventsEndEvents   :: Ptr ContactEndTouchEvent
  , ContactEvents -> Ptr ContactHitEvent
contactEventsHitEvents   :: Ptr ContactHitEvent
  , ContactEvents -> CInt
contactEventsBeginCount  :: CInt
  , ContactEvents -> CInt
contactEventsEndCount    :: CInt
  , ContactEvents -> CInt
contactEventsHitCount    :: CInt
  }
  deriving (ContactEvents -> ContactEvents -> Bool
(ContactEvents -> ContactEvents -> Bool)
-> (ContactEvents -> ContactEvents -> Bool) -> Eq ContactEvents
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ContactEvents -> ContactEvents -> Bool
== :: ContactEvents -> ContactEvents -> Bool
$c/= :: ContactEvents -> ContactEvents -> Bool
/= :: ContactEvents -> ContactEvents -> Bool
Eq, Int -> ContactEvents -> ShowS
[ContactEvents] -> ShowS
ContactEvents -> String
(Int -> ContactEvents -> ShowS)
-> (ContactEvents -> String)
-> ([ContactEvents] -> ShowS)
-> Show ContactEvents
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ContactEvents -> ShowS
showsPrec :: Int -> ContactEvents -> ShowS
$cshow :: ContactEvents -> String
show :: ContactEvents -> String
$cshowList :: [ContactEvents] -> ShowS
showList :: [ContactEvents] -> ShowS
Show)

instance Storable ContactEvents where
  sizeOf :: ContactEvents -> Int
sizeOf ContactEvents
_ = (Int
40)
{-# LINE 1529 "src/Box3D/Types.hsc" #-}
  alignment _ = 8
{-# LINE 1530 "src/Box3D/Types.hsc" #-}
  peek p =
    ContactEvents
      <$> (\hsc_ptr -> peekByteOff hsc_ptr 0) p
{-# LINE 1533 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 8) p
{-# LINE 1534 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 16) p
{-# LINE 1535 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 24) p
{-# LINE 1536 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 28) p
{-# LINE 1537 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 32) p
{-# LINE 1538 "src/Box3D/Types.hsc" #-}
  poke p x = do
    (\hsc_ptr -> pokeByteOff hsc_ptr 0) p (contactEventsBeginEvents x)
{-# LINE 1540 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 8) p (contactEventsEndEvents x)
{-# LINE 1541 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 16) p (contactEventsHitEvents x)
{-# LINE 1542 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 24) p (contactEventsBeginCount x)
{-# LINE 1543 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 28) p (contactEventsEndCount x)
{-# LINE 1544 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 32) p (contactEventsHitCount x)
{-# LINE 1545 "src/Box3D/Types.hsc" #-}

-- | A joint exceeded its force/torque event threshold this step.
data JointEvent = JointEvent
  { JointEvent -> JointId
jointEventJointId  :: JointId
  , JointEvent -> Ptr ()
jointEventUserData :: Ptr ()
  }
  deriving (JointEvent -> JointEvent -> Bool
(JointEvent -> JointEvent -> Bool)
-> (JointEvent -> JointEvent -> Bool) -> Eq JointEvent
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: JointEvent -> JointEvent -> Bool
== :: JointEvent -> JointEvent -> Bool
$c/= :: JointEvent -> JointEvent -> Bool
/= :: JointEvent -> JointEvent -> Bool
Eq, Int -> JointEvent -> ShowS
[JointEvent] -> ShowS
JointEvent -> String
(Int -> JointEvent -> ShowS)
-> (JointEvent -> String)
-> ([JointEvent] -> ShowS)
-> Show JointEvent
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> JointEvent -> ShowS
showsPrec :: Int -> JointEvent -> ShowS
$cshow :: JointEvent -> String
show :: JointEvent -> String
$cshowList :: [JointEvent] -> ShowS
showList :: [JointEvent] -> ShowS
Show)

instance Storable JointEvent where
  sizeOf :: JointEvent -> Int
sizeOf JointEvent
_ = (Int
16)
{-# LINE 1555 "src/Box3D/Types.hsc" #-}
  alignment _ = 8
{-# LINE 1556 "src/Box3D/Types.hsc" #-}
  peek p =
    JointEvent
      <$> (\hsc_ptr -> peekByteOff hsc_ptr 0) p
{-# LINE 1559 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 8) p
{-# LINE 1560 "src/Box3D/Types.hsc" #-}
  poke p x = do
    (\hsc_ptr -> pokeByteOff hsc_ptr 0) p (jointEventJointId x)
{-# LINE 1562 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 8) p (jointEventUserData x)
{-# LINE 1563 "src/Box3D/Types.hsc" #-}

-- | Joint events buffer: a C-owned array of 'JointEvent' valid until the next
-- 'Box3D.World.step'. Marshalled to a list by "Box3D.Events".
data JointEvents = JointEvents
  { JointEvents -> Ptr JointEvent
jointEventsJointEvents :: Ptr JointEvent
  , JointEvents -> CInt
jointEventsCount       :: CInt
  }
  deriving (JointEvents -> JointEvents -> Bool
(JointEvents -> JointEvents -> Bool)
-> (JointEvents -> JointEvents -> Bool) -> Eq JointEvents
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: JointEvents -> JointEvents -> Bool
== :: JointEvents -> JointEvents -> Bool
$c/= :: JointEvents -> JointEvents -> Bool
/= :: JointEvents -> JointEvents -> Bool
Eq, Int -> JointEvents -> ShowS
[JointEvents] -> ShowS
JointEvents -> String
(Int -> JointEvents -> ShowS)
-> (JointEvents -> String)
-> ([JointEvents] -> ShowS)
-> Show JointEvents
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> JointEvents -> ShowS
showsPrec :: Int -> JointEvents -> ShowS
$cshow :: JointEvents -> String
show :: JointEvents -> String
$cshowList :: [JointEvents] -> ShowS
showList :: [JointEvents] -> ShowS
Show)

instance Storable JointEvents where
  sizeOf :: JointEvents -> Int
sizeOf JointEvents
_ = (Int
16)
{-# LINE 1574 "src/Box3D/Types.hsc" #-}
  alignment _ = 8
{-# LINE 1575 "src/Box3D/Types.hsc" #-}
  peek p =
    JointEvents
      <$> (\hsc_ptr -> peekByteOff hsc_ptr 0) p
{-# LINE 1578 "src/Box3D/Types.hsc" #-}
      <*> (\hsc_ptr -> peekByteOff hsc_ptr 8) p
{-# LINE 1579 "src/Box3D/Types.hsc" #-}
  poke p x = do
    (\hsc_ptr -> pokeByteOff hsc_ptr 0) p (jointEventsJointEvents x)
{-# LINE 1581 "src/Box3D/Types.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 8) p (jointEventsCount x)
{-# LINE 1582 "src/Box3D/Types.hsc" #-}