module Physics.Bullet.Raw.BulletDynamics.Dynamics (
module Physics.Bullet.Raw.BulletDynamics.Dynamics
) where
import Control.Monad
import Foreign.Marshal.Alloc
import Foreign.ForeignPtr
import Foreign.Ptr
import Physics.Bullet.Raw.C2HS
import Physics.Bullet.Raw.Types
import Physics.Bullet.Raw.Class
btActionInterface_getFixedBody :: ( ) => IO (BtRigidBody)
btActionInterface_getFixedBody =
btActionInterface_getFixedBody'_ >>= \res ->
mkBtRigidBody res >>= \res' ->
return (res')
btActionInterface_updateAction :: ( BtActionInterfaceClass bc , BtCollisionWorldClass p0 ) => bc -> p0 -> Float -> IO ()
btActionInterface_updateAction a1 a2 a3 =
withBt a1 $ \a1' ->
withBt a2 $ \a2' ->
let {a3' = realToFrac a3} in
btActionInterface_updateAction'_ a1' a2' a3' >>= \res ->
return ()
btActionInterface_debugDraw :: ( BtActionInterfaceClass bc , BtIDebugDrawClass p0 ) => bc -> p0 -> IO ()
btActionInterface_debugDraw a1 a2 =
withBt a1 $ \a1' ->
withBt a2 $ \a2' ->
btActionInterface_debugDraw'_ a1' a2' >>= \res ->
return ()
btDiscreteDynamicsWorld :: ( BtDispatcherClass p0 , BtBroadphaseInterfaceClass p1 , BtConstraintSolverClass p2 , BtCollisionConfigurationClass p3 ) => p0 -> p1 -> p2 -> p3 -> IO (BtDiscreteDynamicsWorld)
btDiscreteDynamicsWorld a1 a2 a3 a4 =
withBt a1 $ \a1' ->
withBt a2 $ \a2' ->
withBt a3 $ \a3' ->
withBt a4 $ \a4' ->
btDiscreteDynamicsWorld'_ a1' a2' a3' a4' >>= \res ->
mkBtDiscreteDynamicsWorld res >>= \res' ->
return (res')
btDiscreteDynamicsWorld_free :: ( BtDiscreteDynamicsWorldClass bc ) => bc -> IO ()
btDiscreteDynamicsWorld_free a1 =
withBt a1 $ \a1' ->
btDiscreteDynamicsWorld_free'_ a1' >>= \res ->
return ()
btDiscreteDynamicsWorld_setGravity :: ( BtDiscreteDynamicsWorldClass bc ) => bc -> Vec3 -> IO (Vec3)
btDiscreteDynamicsWorld_setGravity a1 a2 =
withBt a1 $ \a1' ->
withVec3 a2 $ \a2' ->
btDiscreteDynamicsWorld_setGravity'_ a1' a2' >>= \res ->
peekVec3 a2'>>= \a2'' ->
return (a2'')
btDiscreteDynamicsWorld_setGravity' :: ( BtDiscreteDynamicsWorldClass bc ) => bc -> IO (Vec3)
btDiscreteDynamicsWorld_setGravity' a1 =
withBt a1 $ \a1' ->
allocaVec3 $ \a2' ->
btDiscreteDynamicsWorld_setGravity''_ a1' a2' >>= \res ->
peekVec3 a2'>>= \a2'' ->
return (a2'')
btDiscreteDynamicsWorld_addAction :: ( BtDiscreteDynamicsWorldClass bc , BtActionInterfaceClass p0 ) => bc -> p0 -> IO ()
btDiscreteDynamicsWorld_addAction a1 a2 =
withBt a1 $ \a1' ->
withBt a2 $ \a2' ->
btDiscreteDynamicsWorld_addAction'_ a1' a2' >>= \res ->
return ()
btDiscreteDynamicsWorld_applyGravity :: ( BtDiscreteDynamicsWorldClass bc ) => bc -> IO ()
btDiscreteDynamicsWorld_applyGravity a1 =
withBt a1 $ \a1' ->
btDiscreteDynamicsWorld_applyGravity'_ a1' >>= \res ->
return ()
btDiscreteDynamicsWorld_serialize :: ( BtDiscreteDynamicsWorldClass bc , BtSerializerClass p0 ) => bc -> p0 -> IO ()
btDiscreteDynamicsWorld_serialize a1 a2 =
withBt a1 $ \a1' ->
withBt a2 $ \a2' ->
btDiscreteDynamicsWorld_serialize'_ a1' a2' >>= \res ->
return ()
btDiscreteDynamicsWorld_getCollisionWorld :: ( BtDiscreteDynamicsWorldClass bc ) => bc -> IO (BtCollisionWorld)
btDiscreteDynamicsWorld_getCollisionWorld a1 =
withBt a1 $ \a1' ->
btDiscreteDynamicsWorld_getCollisionWorld'_ a1' >>= \res ->
mkBtCollisionWorld res >>= \res' ->
return (res')
btDiscreteDynamicsWorld_addRigidBody :: ( BtDiscreteDynamicsWorldClass bc , BtRigidBodyClass p0 ) => bc -> p0 -> IO ()
btDiscreteDynamicsWorld_addRigidBody a1 a2 =
withBt a1 $ \a1' ->
withBt a2 $ \a2' ->
btDiscreteDynamicsWorld_addRigidBody'_ a1' a2' >>= \res ->
return ()
btDiscreteDynamicsWorld_addRigidBody0 :: ( BtDiscreteDynamicsWorldClass bc , BtRigidBodyClass p0 ) => bc -> p0 -> IO ()
btDiscreteDynamicsWorld_addRigidBody0 a1 a2 =
withBt a1 $ \a1' ->
withBt a2 $ \a2' ->
btDiscreteDynamicsWorld_addRigidBody0'_ a1' a2' >>= \res ->
return ()
btDiscreteDynamicsWorld_addRigidBody1 :: ( BtDiscreteDynamicsWorldClass bc , BtRigidBodyClass p0 ) => bc -> p0 -> Int -> Int -> IO ()
btDiscreteDynamicsWorld_addRigidBody1 a1 a2 a3 a4 =
withBt a1 $ \a1' ->
withBt a2 $ \a2' ->
let {a3' = fromIntegral a3} in
let {a4' = fromIntegral a4} in
btDiscreteDynamicsWorld_addRigidBody1'_ a1' a2' a3' a4' >>= \res ->
return ()
btDiscreteDynamicsWorld_clearForces :: ( BtDiscreteDynamicsWorldClass bc ) => bc -> IO ()
btDiscreteDynamicsWorld_clearForces a1 =
withBt a1 $ \a1' ->
btDiscreteDynamicsWorld_clearForces'_ a1' >>= \res ->
return ()
btDiscreteDynamicsWorld_removeVehicle :: ( BtDiscreteDynamicsWorldClass bc , BtActionInterfaceClass p0 ) => bc -> p0 -> IO ()
btDiscreteDynamicsWorld_removeVehicle a1 a2 =
withBt a1 $ \a1' ->
withBt a2 $ \a2' ->
btDiscreteDynamicsWorld_removeVehicle'_ a1' a2' >>= \res ->
return ()
btDiscreteDynamicsWorld_serializeRigidBodies :: ( BtDiscreteDynamicsWorldClass bc , BtSerializerClass p0 ) => bc -> p0 -> IO ()
btDiscreteDynamicsWorld_serializeRigidBodies a1 a2 =
withBt a1 $ \a1' ->
withBt a2 $ \a2' ->
btDiscreteDynamicsWorld_serializeRigidBodies'_ a1' a2' >>= \res ->
return ()
btDiscreteDynamicsWorld_internalSingleStepSimulation :: ( BtDiscreteDynamicsWorldClass bc ) => bc -> Float -> IO ()
btDiscreteDynamicsWorld_internalSingleStepSimulation a1 a2 =
withBt a1 $ \a1' ->
let {a2' = realToFrac a2} in
btDiscreteDynamicsWorld_internalSingleStepSimulation'_ a1' a2' >>= \res ->
return ()
btDiscreteDynamicsWorld_getSynchronizeAllMotionStates :: ( BtDiscreteDynamicsWorldClass bc ) => bc -> IO (Bool)
btDiscreteDynamicsWorld_getSynchronizeAllMotionStates a1 =
withBt a1 $ \a1' ->
btDiscreteDynamicsWorld_getSynchronizeAllMotionStates'_ a1' >>= \res ->
let {res' = toBool res} in
return (res')
btDiscreteDynamicsWorld_setNumTasks :: ( BtDiscreteDynamicsWorldClass bc ) => bc -> Int -> IO ()
btDiscreteDynamicsWorld_setNumTasks a1 a2 =
withBt a1 $ \a1' ->
let {a2' = fromIntegral a2} in
btDiscreteDynamicsWorld_setNumTasks'_ a1' a2' >>= \res ->
return ()
btDiscreteDynamicsWorld_setSynchronizeAllMotionStates :: ( BtDiscreteDynamicsWorldClass bc ) => bc -> Bool -> IO ()
btDiscreteDynamicsWorld_setSynchronizeAllMotionStates a1 a2 =
withBt a1 $ \a1' ->
let {a2' = fromBool a2} in
btDiscreteDynamicsWorld_setSynchronizeAllMotionStates'_ a1' a2' >>= \res ->
return ()
btDiscreteDynamicsWorld_predictUnconstraintMotion :: ( BtDiscreteDynamicsWorldClass bc ) => bc -> Float -> IO ()
btDiscreteDynamicsWorld_predictUnconstraintMotion a1 a2 =
withBt a1 $ \a1' ->
let {a2' = realToFrac a2} in
btDiscreteDynamicsWorld_predictUnconstraintMotion'_ a1' a2' >>= \res ->
return ()
btDiscreteDynamicsWorld_removeConstraint :: ( BtDiscreteDynamicsWorldClass bc , BtTypedConstraintClass p0 ) => bc -> p0 -> IO ()
btDiscreteDynamicsWorld_removeConstraint a1 a2 =
withBt a1 $ \a1' ->
withBt a2 $ \a2' ->
btDiscreteDynamicsWorld_removeConstraint'_ a1' a2' >>= \res ->
return ()
btDiscreteDynamicsWorld_getNumConstraints :: ( BtDiscreteDynamicsWorldClass bc ) => bc -> IO (Int)
btDiscreteDynamicsWorld_getNumConstraints a1 =
withBt a1 $ \a1' ->
btDiscreteDynamicsWorld_getNumConstraints'_ a1' >>= \res ->
let {res' = fromIntegral res} in
return (res')
btDiscreteDynamicsWorld_addCollisionObject :: ( BtDiscreteDynamicsWorldClass bc , BtCollisionObjectClass p0 ) => bc -> p0 -> Int -> Int -> IO ()
btDiscreteDynamicsWorld_addCollisionObject a1 a2 a3 a4 =
withBt a1 $ \a1' ->
withBt a2 $ \a2' ->
let {a3' = fromIntegral a3} in
let {a4' = fromIntegral a4} in
btDiscreteDynamicsWorld_addCollisionObject'_ a1' a2' a3' a4' >>= \res ->
return ()
btDiscreteDynamicsWorld_removeRigidBody :: ( BtDiscreteDynamicsWorldClass bc , BtRigidBodyClass p0 ) => bc -> p0 -> IO ()
btDiscreteDynamicsWorld_removeRigidBody a1 a2 =
withBt a1 $ \a1' ->
withBt a2 $ \a2' ->
btDiscreteDynamicsWorld_removeRigidBody'_ a1' a2' >>= \res ->
return ()
btDiscreteDynamicsWorld_integrateTransforms :: ( BtDiscreteDynamicsWorldClass bc ) => bc -> Float -> IO ()
btDiscreteDynamicsWorld_integrateTransforms a1 a2 =
withBt a1 $ \a1' ->
let {a2' = realToFrac a2} in
btDiscreteDynamicsWorld_integrateTransforms'_ a1' a2' >>= \res ->
return ()
btDiscreteDynamicsWorld_debugDrawConstraint :: ( BtDiscreteDynamicsWorldClass bc , BtTypedConstraintClass p0 ) => bc -> p0 -> IO ()
btDiscreteDynamicsWorld_debugDrawConstraint a1 a2 =
withBt a1 $ \a1' ->
withBt a2 $ \a2' ->
btDiscreteDynamicsWorld_debugDrawConstraint'_ a1' a2' >>= \res ->
return ()
btDiscreteDynamicsWorld_debugDrawWorld :: ( BtDiscreteDynamicsWorldClass bc ) => bc -> IO ()
btDiscreteDynamicsWorld_debugDrawWorld a1 =
withBt a1 $ \a1' ->
btDiscreteDynamicsWorld_debugDrawWorld'_ a1' >>= \res ->
return ()
btDiscreteDynamicsWorld_calculateSimulationIslands :: ( BtDiscreteDynamicsWorldClass bc ) => bc -> IO ()
btDiscreteDynamicsWorld_calculateSimulationIslands a1 =
withBt a1 $ \a1' ->
btDiscreteDynamicsWorld_calculateSimulationIslands'_ a1' >>= \res ->
return ()
btDiscreteDynamicsWorld_addConstraint :: ( BtDiscreteDynamicsWorldClass bc , BtTypedConstraintClass p0 ) => bc -> p0 -> Bool -> IO ()
btDiscreteDynamicsWorld_addConstraint a1 a2 a3 =
withBt a1 $ \a1' ->
withBt a2 $ \a2' ->
let {a3' = fromBool a3} in
btDiscreteDynamicsWorld_addConstraint'_ a1' a2' a3' >>= \res ->
return ()
btDiscreteDynamicsWorld_startProfiling :: ( BtDiscreteDynamicsWorldClass bc ) => bc -> Float -> IO ()
btDiscreteDynamicsWorld_startProfiling a1 a2 =
withBt a1 $ \a1' ->
let {a2' = realToFrac a2} in
btDiscreteDynamicsWorld_startProfiling'_ a1' a2' >>= \res ->
return ()
btDiscreteDynamicsWorld_updateActivationState :: ( BtDiscreteDynamicsWorldClass bc ) => bc -> Float -> IO ()
btDiscreteDynamicsWorld_updateActivationState a1 a2 =
withBt a1 $ \a1' ->
let {a2' = realToFrac a2} in
btDiscreteDynamicsWorld_updateActivationState'_ a1' a2' >>= \res ->
return ()
btDiscreteDynamicsWorld_getGravity :: ( BtDiscreteDynamicsWorldClass bc ) => bc -> IO (Vec3)
btDiscreteDynamicsWorld_getGravity a1 =
withBt a1 $ \a1' ->
allocaVec3 $ \a2' ->
btDiscreteDynamicsWorld_getGravity'_ a1' a2' >>= \res ->
peekVec3 a2'>>= \a2'' ->
return (a2'')
btDiscreteDynamicsWorld_removeAction :: ( BtDiscreteDynamicsWorldClass bc , BtActionInterfaceClass p0 ) => bc -> p0 -> IO ()
btDiscreteDynamicsWorld_removeAction a1 a2 =
withBt a1 $ \a1' ->
withBt a2 $ \a2' ->
btDiscreteDynamicsWorld_removeAction'_ a1' a2' >>= \res ->
return ()
btDiscreteDynamicsWorld_removeCharacter :: ( BtDiscreteDynamicsWorldClass bc , BtActionInterfaceClass p0 ) => bc -> p0 -> IO ()
btDiscreteDynamicsWorld_removeCharacter a1 a2 =
withBt a1 $ \a1' ->
withBt a2 $ \a2' ->
btDiscreteDynamicsWorld_removeCharacter'_ a1' a2' >>= \res ->
return ()
btDiscreteDynamicsWorld_saveKinematicState :: ( BtDiscreteDynamicsWorldClass bc ) => bc -> Float -> IO ()
btDiscreteDynamicsWorld_saveKinematicState a1 a2 =
withBt a1 $ \a1' ->
let {a2' = realToFrac a2} in
btDiscreteDynamicsWorld_saveKinematicState'_ a1' a2' >>= \res ->
return ()
btDiscreteDynamicsWorld_getConstraint :: ( BtDiscreteDynamicsWorldClass bc ) => bc -> Int -> IO (BtTypedConstraint)
btDiscreteDynamicsWorld_getConstraint a1 a2 =
withBt a1 $ \a1' ->
let {a2' = fromIntegral a2} in
btDiscreteDynamicsWorld_getConstraint'_ a1' a2' >>= \res ->
mkBtTypedConstraint res >>= \res' ->
return (res')
btDiscreteDynamicsWorld_getConstraint0 :: ( BtDiscreteDynamicsWorldClass bc ) => bc -> Int -> IO (BtTypedConstraint)
btDiscreteDynamicsWorld_getConstraint0 a1 a2 =
withBt a1 $ \a1' ->
let {a2' = fromIntegral a2} in
btDiscreteDynamicsWorld_getConstraint0'_ a1' a2' >>= \res ->
mkBtTypedConstraint res >>= \res' ->
return (res')
btDiscreteDynamicsWorld_getConstraint1 :: ( BtDiscreteDynamicsWorldClass bc ) => bc -> Int -> IO (BtTypedConstraint)
btDiscreteDynamicsWorld_getConstraint1 a1 a2 =
withBt a1 $ \a1' ->
let {a2' = fromIntegral a2} in
btDiscreteDynamicsWorld_getConstraint1'_ a1' a2' >>= \res ->
mkBtTypedConstraint res >>= \res' ->
return (res')
btDiscreteDynamicsWorld_getConstraintSolver :: ( BtDiscreteDynamicsWorldClass bc ) => bc -> IO (BtConstraintSolver)
btDiscreteDynamicsWorld_getConstraintSolver a1 =
withBt a1 $ \a1' ->
btDiscreteDynamicsWorld_getConstraintSolver'_ a1' >>= \res ->
mkBtConstraintSolver res >>= \res' ->
return (res')
btDiscreteDynamicsWorld_addCharacter :: ( BtDiscreteDynamicsWorldClass bc , BtActionInterfaceClass p0 ) => bc -> p0 -> IO ()
btDiscreteDynamicsWorld_addCharacter a1 a2 =
withBt a1 $ \a1' ->
withBt a2 $ \a2' ->
btDiscreteDynamicsWorld_addCharacter'_ a1' a2' >>= \res ->
return ()
btDiscreteDynamicsWorld_solveConstraints :: ( BtDiscreteDynamicsWorldClass bc , BtContactSolverInfoClass p0 ) => bc -> p0 -> IO ()
btDiscreteDynamicsWorld_solveConstraints a1 a2 =
withBt a1 $ \a1' ->
withBt a2 $ \a2' ->
btDiscreteDynamicsWorld_solveConstraints'_ a1' a2' >>= \res ->
return ()
btDiscreteDynamicsWorld_updateActions :: ( BtDiscreteDynamicsWorldClass bc ) => bc -> Float -> IO ()
btDiscreteDynamicsWorld_updateActions a1 a2 =
withBt a1 $ \a1' ->
let {a2' = realToFrac a2} in
btDiscreteDynamicsWorld_updateActions'_ a1' a2' >>= \res ->
return ()
btDiscreteDynamicsWorld_updateVehicles :: ( BtDiscreteDynamicsWorldClass bc ) => bc -> Float -> IO ()
btDiscreteDynamicsWorld_updateVehicles a1 a2 =
withBt a1 $ \a1' ->
let {a2' = realToFrac a2} in
btDiscreteDynamicsWorld_updateVehicles'_ a1' a2' >>= \res ->
return ()
btDiscreteDynamicsWorld_synchronizeSingleMotionState :: ( BtDiscreteDynamicsWorldClass bc , BtRigidBodyClass p0 ) => bc -> p0 -> IO ()
btDiscreteDynamicsWorld_synchronizeSingleMotionState a1 a2 =
withBt a1 $ \a1' ->
withBt a2 $ \a2' ->
btDiscreteDynamicsWorld_synchronizeSingleMotionState'_ a1' a2' >>= \res ->
return ()
btDiscreteDynamicsWorld_addVehicle :: ( BtDiscreteDynamicsWorldClass bc , BtActionInterfaceClass p0 ) => bc -> p0 -> IO ()
btDiscreteDynamicsWorld_addVehicle a1 a2 =
withBt a1 $ \a1' ->
withBt a2 $ \a2' ->
btDiscreteDynamicsWorld_addVehicle'_ a1' a2' >>= \res ->
return ()
btDiscreteDynamicsWorld_synchronizeMotionStates :: ( BtDiscreteDynamicsWorldClass bc ) => bc -> IO ()
btDiscreteDynamicsWorld_synchronizeMotionStates a1 =
withBt a1 $ \a1' ->
btDiscreteDynamicsWorld_synchronizeMotionStates'_ a1' >>= \res ->
return ()
btDiscreteDynamicsWorld_stepSimulation :: ( BtDiscreteDynamicsWorldClass bc ) => bc -> Float -> Int -> Float -> IO (Int)
btDiscreteDynamicsWorld_stepSimulation a1 a2 a3 a4 =
withBt a1 $ \a1' ->
let {a2' = realToFrac a2} in
let {a3' = fromIntegral a3} in
let {a4' = realToFrac a4} in
btDiscreteDynamicsWorld_stepSimulation'_ a1' a2' a3' a4' >>= \res ->
let {res' = fromIntegral res} in
return (res')
btDiscreteDynamicsWorld_removeCollisionObject :: ( BtDiscreteDynamicsWorldClass bc , BtCollisionObjectClass p0 ) => bc -> p0 -> IO ()
btDiscreteDynamicsWorld_removeCollisionObject a1 a2 =
withBt a1 $ \a1' ->
withBt a2 $ \a2' ->
btDiscreteDynamicsWorld_removeCollisionObject'_ a1' a2' >>= \res ->
return ()
btDiscreteDynamicsWorld_setConstraintSolver :: ( BtDiscreteDynamicsWorldClass bc , BtConstraintSolverClass p0 ) => bc -> p0 -> IO ()
btDiscreteDynamicsWorld_setConstraintSolver a1 a2 =
withBt a1 $ \a1' ->
withBt a2 $ \a2' ->
btDiscreteDynamicsWorld_setConstraintSolver'_ a1' a2' >>= \res ->
return ()
btDiscreteDynamicsWorld_m_constraintSolver_set :: ( BtDiscreteDynamicsWorldClass bc , BtConstraintSolverClass a ) => bc -> a -> IO ()
btDiscreteDynamicsWorld_m_constraintSolver_set a1 a2 =
withBt a1 $ \a1' ->
withBt a2 $ \a2' ->
btDiscreteDynamicsWorld_m_constraintSolver_set'_ a1' a2' >>= \res ->
return ()
btDiscreteDynamicsWorld_m_constraintSolver_get :: ( BtDiscreteDynamicsWorldClass bc ) => bc -> IO (BtConstraintSolver)
btDiscreteDynamicsWorld_m_constraintSolver_get a1 =
withBt a1 $ \a1' ->
btDiscreteDynamicsWorld_m_constraintSolver_get'_ a1' >>= \res ->
mkBtConstraintSolver res >>= \res' ->
return (res')
btDiscreteDynamicsWorld_m_constraints_set :: ( BtDiscreteDynamicsWorldClass bc , BtAlignedObjectArray_btTypedConstraint_ptr_Class a ) => bc -> a -> IO ()
btDiscreteDynamicsWorld_m_constraints_set a1 a2 =
withBt a1 $ \a1' ->
withBt a2 $ \a2' ->
btDiscreteDynamicsWorld_m_constraints_set'_ a1' a2' >>= \res ->
return ()
btDiscreteDynamicsWorld_m_constraints_get :: ( BtDiscreteDynamicsWorldClass bc ) => bc -> IO (BtAlignedObjectArray_btTypedConstraint_ptr_)
btDiscreteDynamicsWorld_m_constraints_get a1 =
withBt a1 $ \a1' ->
btDiscreteDynamicsWorld_m_constraints_get'_ a1' >>= \res ->
mkBtAlignedObjectArray_btTypedConstraint_ptr_ res >>= \res' ->
return (res')
btDiscreteDynamicsWorld_m_nonStaticRigidBodies_set :: ( BtDiscreteDynamicsWorldClass bc , BtAlignedObjectArray_btRigidBody_ptr_Class a ) => bc -> a -> IO ()
btDiscreteDynamicsWorld_m_nonStaticRigidBodies_set a1 a2 =
withBt a1 $ \a1' ->
withBt a2 $ \a2' ->
btDiscreteDynamicsWorld_m_nonStaticRigidBodies_set'_ a1' a2' >>= \res ->
return ()
btDiscreteDynamicsWorld_m_nonStaticRigidBodies_get :: ( BtDiscreteDynamicsWorldClass bc ) => bc -> IO (BtAlignedObjectArray_btRigidBody_ptr_)
btDiscreteDynamicsWorld_m_nonStaticRigidBodies_get a1 =
withBt a1 $ \a1' ->
btDiscreteDynamicsWorld_m_nonStaticRigidBodies_get'_ a1' >>= \res ->
mkBtAlignedObjectArray_btRigidBody_ptr_ res >>= \res' ->
return (res')
btDiscreteDynamicsWorld_m_gravity_set :: ( BtDiscreteDynamicsWorldClass bc ) => bc -> Vec3 -> IO ()
btDiscreteDynamicsWorld_m_gravity_set a1 a2 =
withBt a1 $ \a1' ->
withVec3 a2 $ \a2' ->
btDiscreteDynamicsWorld_m_gravity_set'_ a1' a2' >>= \res ->
return ()
btDiscreteDynamicsWorld_m_gravity_get :: ( BtDiscreteDynamicsWorldClass bc ) => bc -> IO (Vec3)
btDiscreteDynamicsWorld_m_gravity_get a1 =
withBt a1 $ \a1' ->
allocaVec3 $ \a2' ->
btDiscreteDynamicsWorld_m_gravity_get'_ a1' a2' >>= \res ->
peekVec3 a2'>>= \a2'' ->
return (a2'')
btDiscreteDynamicsWorld_m_localTime_set :: ( BtDiscreteDynamicsWorldClass bc ) => bc -> Float -> IO ()
btDiscreteDynamicsWorld_m_localTime_set a1 a2 =
withBt a1 $ \a1' ->
let {a2' = realToFrac a2} in
btDiscreteDynamicsWorld_m_localTime_set'_ a1' a2' >>= \res ->
return ()
btDiscreteDynamicsWorld_m_localTime_get :: ( BtDiscreteDynamicsWorldClass bc ) => bc -> IO (Float)
btDiscreteDynamicsWorld_m_localTime_get a1 =
withBt a1 $ \a1' ->
btDiscreteDynamicsWorld_m_localTime_get'_ a1' >>= \res ->
let {res' = realToFrac res} in
return (res')
btDiscreteDynamicsWorld_m_ownsIslandManager_set :: ( BtDiscreteDynamicsWorldClass bc ) => bc -> Bool -> IO ()
btDiscreteDynamicsWorld_m_ownsIslandManager_set a1 a2 =
withBt a1 $ \a1' ->
let {a2' = fromBool a2} in
btDiscreteDynamicsWorld_m_ownsIslandManager_set'_ a1' a2' >>= \res ->
return ()
btDiscreteDynamicsWorld_m_ownsIslandManager_get :: ( BtDiscreteDynamicsWorldClass bc ) => bc -> IO (Bool)
btDiscreteDynamicsWorld_m_ownsIslandManager_get a1 =
withBt a1 $ \a1' ->
btDiscreteDynamicsWorld_m_ownsIslandManager_get'_ a1' >>= \res ->
let {res' = toBool res} in
return (res')
btDiscreteDynamicsWorld_m_ownsConstraintSolver_set :: ( BtDiscreteDynamicsWorldClass bc ) => bc -> Bool -> IO ()
btDiscreteDynamicsWorld_m_ownsConstraintSolver_set a1 a2 =
withBt a1 $ \a1' ->
let {a2' = fromBool a2} in
btDiscreteDynamicsWorld_m_ownsConstraintSolver_set'_ a1' a2' >>= \res ->
return ()
btDiscreteDynamicsWorld_m_ownsConstraintSolver_get :: ( BtDiscreteDynamicsWorldClass bc ) => bc -> IO (Bool)
btDiscreteDynamicsWorld_m_ownsConstraintSolver_get a1 =
withBt a1 $ \a1' ->
btDiscreteDynamicsWorld_m_ownsConstraintSolver_get'_ a1' >>= \res ->
let {res' = toBool res} in
return (res')
btDiscreteDynamicsWorld_m_synchronizeAllMotionStates_set :: ( BtDiscreteDynamicsWorldClass bc ) => bc -> Bool -> IO ()
btDiscreteDynamicsWorld_m_synchronizeAllMotionStates_set a1 a2 =
withBt a1 $ \a1' ->
let {a2' = fromBool a2} in
btDiscreteDynamicsWorld_m_synchronizeAllMotionStates_set'_ a1' a2' >>= \res ->
return ()
btDiscreteDynamicsWorld_m_synchronizeAllMotionStates_get :: ( BtDiscreteDynamicsWorldClass bc ) => bc -> IO (Bool)
btDiscreteDynamicsWorld_m_synchronizeAllMotionStates_get a1 =
withBt a1 $ \a1' ->
btDiscreteDynamicsWorld_m_synchronizeAllMotionStates_get'_ a1' >>= \res ->
let {res' = toBool res} in
return (res')
btDiscreteDynamicsWorld_m_actions_set :: ( BtDiscreteDynamicsWorldClass bc , BtAlignedObjectArray_btActionInterface_ptr_Class a ) => bc -> a -> IO ()
btDiscreteDynamicsWorld_m_actions_set a1 a2 =
withBt a1 $ \a1' ->
withBt a2 $ \a2' ->
btDiscreteDynamicsWorld_m_actions_set'_ a1' a2' >>= \res ->
return ()
btDiscreteDynamicsWorld_m_actions_get :: ( BtDiscreteDynamicsWorldClass bc ) => bc -> IO (BtAlignedObjectArray_btActionInterface_ptr_)
btDiscreteDynamicsWorld_m_actions_get a1 =
withBt a1 $ \a1' ->
btDiscreteDynamicsWorld_m_actions_get'_ a1' >>= \res ->
mkBtAlignedObjectArray_btActionInterface_ptr_ res >>= \res' ->
return (res')
btDiscreteDynamicsWorld_m_profileTimings_set :: ( BtDiscreteDynamicsWorldClass bc ) => bc -> Int -> IO ()
btDiscreteDynamicsWorld_m_profileTimings_set a1 a2 =
withBt a1 $ \a1' ->
let {a2' = fromIntegral a2} in
btDiscreteDynamicsWorld_m_profileTimings_set'_ a1' a2' >>= \res ->
return ()
btDiscreteDynamicsWorld_m_profileTimings_get :: ( BtDiscreteDynamicsWorldClass bc ) => bc -> IO (Int)
btDiscreteDynamicsWorld_m_profileTimings_get a1 =
withBt a1 $ \a1' ->
btDiscreteDynamicsWorld_m_profileTimings_get'_ a1' >>= \res ->
let {res' = fromIntegral res} in
return (res')
btDynamicsWorld_setGravity :: ( BtDynamicsWorldClass bc ) => bc -> Vec3 -> IO (Vec3)
btDynamicsWorld_setGravity a1 a2 =
withBt a1 $ \a1' ->
withVec3 a2 $ \a2' ->
btDynamicsWorld_setGravity'_ a1' a2' >>= \res ->
peekVec3 a2'>>= \a2'' ->
return (a2'')
btDynamicsWorld_setGravity' :: ( BtDynamicsWorldClass bc ) => bc -> IO (Vec3)
btDynamicsWorld_setGravity' a1 =
withBt a1 $ \a1' ->
allocaVec3 $ \a2' ->
btDynamicsWorld_setGravity''_ a1' a2' >>= \res ->
peekVec3 a2'>>= \a2'' ->
return (a2'')
btDynamicsWorld_addAction :: ( BtDynamicsWorldClass bc , BtActionInterfaceClass p0 ) => bc -> p0 -> IO ()
btDynamicsWorld_addAction a1 a2 =
withBt a1 $ \a1' ->
withBt a2 $ \a2' ->
btDynamicsWorld_addAction'_ a1' a2' >>= \res ->
return ()
btDynamicsWorld_getSolverInfo :: ( BtDynamicsWorldClass bc ) => bc -> IO (BtContactSolverInfo)
btDynamicsWorld_getSolverInfo a1 =
withBt a1 $ \a1' ->
btDynamicsWorld_getSolverInfo'_ a1' >>= \res ->
mkBtContactSolverInfo res >>= \res' ->
return (res')
btDynamicsWorld_addRigidBody :: ( BtDynamicsWorldClass bc , BtRigidBodyClass p0 ) => bc -> p0 -> IO ()
btDynamicsWorld_addRigidBody a1 a2 =
withBt a1 $ \a1' ->
withBt a2 $ \a2' ->
btDynamicsWorld_addRigidBody'_ a1' a2' >>= \res ->
return ()
btDynamicsWorld_addRigidBody0 :: ( BtDynamicsWorldClass bc , BtRigidBodyClass p0 ) => bc -> p0 -> IO ()
btDynamicsWorld_addRigidBody0 a1 a2 =
withBt a1 $ \a1' ->
withBt a2 $ \a2' ->
btDynamicsWorld_addRigidBody0'_ a1' a2' >>= \res ->
return ()
btDynamicsWorld_addRigidBody1 :: ( BtDynamicsWorldClass bc , BtRigidBodyClass p0 ) => bc -> p0 -> Int -> Int -> IO ()
btDynamicsWorld_addRigidBody1 a1 a2 a3 a4 =
withBt a1 $ \a1' ->
withBt a2 $ \a2' ->
let {a3' = fromIntegral a3} in
let {a4' = fromIntegral a4} in
btDynamicsWorld_addRigidBody1'_ a1' a2' a3' a4' >>= \res ->
return ()
btDynamicsWorld_clearForces :: ( BtDynamicsWorldClass bc ) => bc -> IO ()
btDynamicsWorld_clearForces a1 =
withBt a1 $ \a1' ->
btDynamicsWorld_clearForces'_ a1' >>= \res ->
return ()
btDynamicsWorld_removeVehicle :: ( BtDynamicsWorldClass bc , BtActionInterfaceClass p0 ) => bc -> p0 -> IO ()
btDynamicsWorld_removeVehicle a1 a2 =
withBt a1 $ \a1' ->
withBt a2 $ \a2' ->
btDynamicsWorld_removeVehicle'_ a1' a2' >>= \res ->
return ()
btDynamicsWorld_removeConstraint :: ( BtDynamicsWorldClass bc , BtTypedConstraintClass p0 ) => bc -> p0 -> IO ()
btDynamicsWorld_removeConstraint a1 a2 =
withBt a1 $ \a1' ->
withBt a2 $ \a2' ->
btDynamicsWorld_removeConstraint'_ a1' a2' >>= \res ->
return ()
btDynamicsWorld_getNumConstraints :: ( BtDynamicsWorldClass bc ) => bc -> IO (Int)
btDynamicsWorld_getNumConstraints a1 =
withBt a1 $ \a1' ->
btDynamicsWorld_getNumConstraints'_ a1' >>= \res ->
let {res' = fromIntegral res} in
return (res')
btDynamicsWorld_removeRigidBody :: ( BtDynamicsWorldClass bc , BtRigidBodyClass p0 ) => bc -> p0 -> IO ()
btDynamicsWorld_removeRigidBody a1 a2 =
withBt a1 $ \a1' ->
withBt a2 $ \a2' ->
btDynamicsWorld_removeRigidBody'_ a1' a2' >>= \res ->
return ()
btDynamicsWorld_synchronizeMotionStates :: ( BtDynamicsWorldClass bc ) => bc -> IO ()
btDynamicsWorld_synchronizeMotionStates a1 =
withBt a1 $ \a1' ->
btDynamicsWorld_synchronizeMotionStates'_ a1' >>= \res ->
return ()
btDynamicsWorld_addConstraint :: ( BtDynamicsWorldClass bc , BtTypedConstraintClass p0 ) => bc -> p0 -> Bool -> IO ()
btDynamicsWorld_addConstraint a1 a2 a3 =
withBt a1 $ \a1' ->
withBt a2 $ \a2' ->
let {a3' = fromBool a3} in
btDynamicsWorld_addConstraint'_ a1' a2' a3' >>= \res ->
return ()
btDynamicsWorld_getGravity :: ( BtDynamicsWorldClass bc ) => bc -> IO (Vec3)
btDynamicsWorld_getGravity a1 =
withBt a1 $ \a1' ->
allocaVec3 $ \a2' ->
btDynamicsWorld_getGravity'_ a1' a2' >>= \res ->
peekVec3 a2'>>= \a2'' ->
return (a2'')
btDynamicsWorld_debugDrawWorld :: ( BtDynamicsWorldClass bc ) => bc -> IO ()
btDynamicsWorld_debugDrawWorld a1 =
withBt a1 $ \a1' ->
btDynamicsWorld_debugDrawWorld'_ a1' >>= \res ->
return ()
btDynamicsWorld_removeAction :: ( BtDynamicsWorldClass bc , BtActionInterfaceClass p0 ) => bc -> p0 -> IO ()
btDynamicsWorld_removeAction a1 a2 =
withBt a1 $ \a1' ->
withBt a2 $ \a2' ->
btDynamicsWorld_removeAction'_ a1' a2' >>= \res ->
return ()
btDynamicsWorld_setWorldUserInfo :: ( BtDynamicsWorldClass bc ) => bc -> VoidPtr -> IO ()
btDynamicsWorld_setWorldUserInfo a1 a2 =
withBt a1 $ \a1' ->
withVoidPtr a2 $ \a2' ->
btDynamicsWorld_setWorldUserInfo'_ a1' a2' >>= \res ->
return ()
btDynamicsWorld_removeCharacter :: ( BtDynamicsWorldClass bc , BtActionInterfaceClass p0 ) => bc -> p0 -> IO ()
btDynamicsWorld_removeCharacter a1 a2 =
withBt a1 $ \a1' ->
withBt a2 $ \a2' ->
btDynamicsWorld_removeCharacter'_ a1' a2' >>= \res ->
return ()
btDynamicsWorld_getConstraint :: ( BtDynamicsWorldClass bc ) => bc -> Int -> IO (BtTypedConstraint)
btDynamicsWorld_getConstraint a1 a2 =
withBt a1 $ \a1' ->
let {a2' = fromIntegral a2} in
btDynamicsWorld_getConstraint'_ a1' a2' >>= \res ->
mkBtTypedConstraint res >>= \res' ->
return (res')
btDynamicsWorld_getConstraint0 :: ( BtDynamicsWorldClass bc ) => bc -> Int -> IO (BtTypedConstraint)
btDynamicsWorld_getConstraint0 a1 a2 =
withBt a1 $ \a1' ->
let {a2' = fromIntegral a2} in
btDynamicsWorld_getConstraint0'_ a1' a2' >>= \res ->
mkBtTypedConstraint res >>= \res' ->
return (res')
btDynamicsWorld_getConstraint1 :: ( BtDynamicsWorldClass bc ) => bc -> Int -> IO (BtTypedConstraint)
btDynamicsWorld_getConstraint1 a1 a2 =
withBt a1 $ \a1' ->
let {a2' = fromIntegral a2} in
btDynamicsWorld_getConstraint1'_ a1' a2' >>= \res ->
mkBtTypedConstraint res >>= \res' ->
return (res')
btDynamicsWorld_getConstraintSolver :: ( BtDynamicsWorldClass bc ) => bc -> IO (BtConstraintSolver)
btDynamicsWorld_getConstraintSolver a1 =
withBt a1 $ \a1' ->
btDynamicsWorld_getConstraintSolver'_ a1' >>= \res ->
mkBtConstraintSolver res >>= \res' ->
return (res')
btDynamicsWorld_stepSimulation :: ( BtDynamicsWorldClass bc ) => bc -> Float -> Int -> Float -> IO (Int)
btDynamicsWorld_stepSimulation a1 a2 a3 a4 =
withBt a1 $ \a1' ->
let {a2' = realToFrac a2} in
let {a3' = fromIntegral a3} in
let {a4' = realToFrac a4} in
btDynamicsWorld_stepSimulation'_ a1' a2' a3' a4' >>= \res ->
let {res' = fromIntegral res} in
return (res')
btDynamicsWorld_addCharacter :: ( BtDynamicsWorldClass bc , BtActionInterfaceClass p0 ) => bc -> p0 -> IO ()
btDynamicsWorld_addCharacter a1 a2 =
withBt a1 $ \a1' ->
withBt a2 $ \a2' ->
btDynamicsWorld_addCharacter'_ a1' a2' >>= \res ->
return ()
btDynamicsWorld_addVehicle :: ( BtDynamicsWorldClass bc , BtActionInterfaceClass p0 ) => bc -> p0 -> IO ()
btDynamicsWorld_addVehicle a1 a2 =
withBt a1 $ \a1' ->
withBt a2 $ \a2' ->
btDynamicsWorld_addVehicle'_ a1' a2' >>= \res ->
return ()
btDynamicsWorld_getWorldUserInfo :: ( BtDynamicsWorldClass bc ) => bc -> IO (VoidPtr)
btDynamicsWorld_getWorldUserInfo a1 =
withBt a1 $ \a1' ->
btDynamicsWorld_getWorldUserInfo'_ a1' >>= \res ->
mkVoidPtr res >>= \res' ->
return (res')
btDynamicsWorld_setConstraintSolver :: ( BtDynamicsWorldClass bc , BtConstraintSolverClass p0 ) => bc -> p0 -> IO ()
btDynamicsWorld_setConstraintSolver a1 a2 =
withBt a1 $ \a1' ->
withBt a2 $ \a2' ->
btDynamicsWorld_setConstraintSolver'_ a1' a2' >>= \res ->
return ()
btDynamicsWorld_m_worldUserInfo_set :: ( BtDynamicsWorldClass bc ) => bc -> VoidPtr -> IO ()
btDynamicsWorld_m_worldUserInfo_set a1 a2 =
withBt a1 $ \a1' ->
withVoidPtr a2 $ \a2' ->
btDynamicsWorld_m_worldUserInfo_set'_ a1' a2' >>= \res ->
return ()
btDynamicsWorld_m_worldUserInfo_get :: ( BtDynamicsWorldClass bc ) => bc -> IO (VoidPtr)
btDynamicsWorld_m_worldUserInfo_get a1 =
withBt a1 $ \a1' ->
btDynamicsWorld_m_worldUserInfo_get'_ a1' >>= \res ->
mkVoidPtr res >>= \res' ->
return (res')
btDynamicsWorld_m_solverInfo_set :: ( BtDynamicsWorldClass bc , BtContactSolverInfoClass a ) => bc -> a -> IO ()
btDynamicsWorld_m_solverInfo_set a1 a2 =
withBt a1 $ \a1' ->
withBt a2 $ \a2' ->
btDynamicsWorld_m_solverInfo_set'_ a1' a2' >>= \res ->
return ()
btDynamicsWorld_m_solverInfo_get :: ( BtDynamicsWorldClass bc ) => bc -> IO (BtContactSolverInfo)
btDynamicsWorld_m_solverInfo_get a1 =
withBt a1 $ \a1' ->
btDynamicsWorld_m_solverInfo_get'_ a1' >>= \res ->
mkBtContactSolverInfo res >>= \res' ->
return (res')
btRigidBody0 :: ( BtRigidBody_btRigidBodyConstructionInfoClass p0 ) => p0 -> IO (BtRigidBody)
btRigidBody0 a1 =
withBt a1 $ \a1' ->
btRigidBody0'_ a1' >>= \res ->
mkBtRigidBody res >>= \res' ->
return (res')
btRigidBody1 :: ( BtMotionStateClass p1 , BtCollisionShapeClass p2 ) => Float -> p1 -> p2 -> Vec3 -> IO (BtRigidBody)
btRigidBody1 a1 a2 a3 a4 =
let {a1' = realToFrac a1} in
withBt a2 $ \a2' ->
withBt a3 $ \a3' ->
withVec3 a4 $ \a4' ->
btRigidBody1'_ a1' a2' a3' a4' >>= \res ->
mkBtRigidBody res >>= \res' ->
return (res')
btRigidBody_free :: ( BtRigidBodyClass bc ) => bc -> IO ()
btRigidBody_free a1 =
withBt a1 $ \a1' ->
btRigidBody_free'_ a1' >>= \res ->
return ()
btRigidBody_setGravity :: ( BtRigidBodyClass bc ) => bc -> Vec3 -> IO (Vec3)
btRigidBody_setGravity a1 a2 =
withBt a1 $ \a1' ->
withVec3 a2 $ \a2' ->
btRigidBody_setGravity'_ a1' a2' >>= \res ->
peekVec3 a2'>>= \a2'' ->
return (a2'')
btRigidBody_setGravity' :: ( BtRigidBodyClass bc ) => bc -> IO (Vec3)
btRigidBody_setGravity' a1 =
withBt a1 $ \a1' ->
allocaVec3 $ \a2' ->
btRigidBody_setGravity''_ a1' a2' >>= \res ->
peekVec3 a2'>>= \a2'' ->
return (a2'')
btRigidBody_updateDeactivation :: ( BtRigidBodyClass bc ) => bc -> Float -> IO ()
btRigidBody_updateDeactivation a1 a2 =
withBt a1 $ \a1' ->
let {a2' = realToFrac a2} in
btRigidBody_updateDeactivation'_ a1' a2' >>= \res ->
return ()
btRigidBody_setAngularFactor :: ( BtRigidBodyClass bc ) => bc -> Vec3 -> IO (Vec3)
btRigidBody_setAngularFactor a1 a2 =
withBt a1 $ \a1' ->
withVec3 a2 $ \a2' ->
btRigidBody_setAngularFactor'_ a1' a2' >>= \res ->
peekVec3 a2'>>= \a2'' ->
return (a2'')
btRigidBody_setAngularFactor' :: ( BtRigidBodyClass bc ) => bc -> IO (Vec3)
btRigidBody_setAngularFactor' a1 =
withBt a1 $ \a1' ->
allocaVec3 $ \a2' ->
btRigidBody_setAngularFactor''_ a1' a2' >>= \res ->
peekVec3 a2'>>= \a2'' ->
return (a2'')
btRigidBody_setAngularFactor0 :: ( BtRigidBodyClass bc ) => bc -> Vec3 -> IO (Vec3)
btRigidBody_setAngularFactor0 a1 a2 =
withBt a1 $ \a1' ->
withVec3 a2 $ \a2' ->
btRigidBody_setAngularFactor0'_ a1' a2' >>= \res ->
peekVec3 a2'>>= \a2'' ->
return (a2'')
btRigidBody_setAngularFactor0' :: ( BtRigidBodyClass bc ) => bc -> IO (Vec3)
btRigidBody_setAngularFactor0' a1 =
withBt a1 $ \a1' ->
allocaVec3 $ \a2' ->
btRigidBody_setAngularFactor0''_ a1' a2' >>= \res ->
peekVec3 a2'>>= \a2'' ->
return (a2'')
btRigidBody_setAngularFactor1 :: ( BtRigidBodyClass bc ) => bc -> Float -> IO ()
btRigidBody_setAngularFactor1 a1 a2 =
withBt a1 $ \a1' ->
let {a2' = realToFrac a2} in
btRigidBody_setAngularFactor1'_ a1' a2' >>= \res ->
return ()
btRigidBody_internalWritebackVelocity :: ( BtRigidBodyClass bc ) => bc -> IO ()
btRigidBody_internalWritebackVelocity a1 =
withBt a1 $ \a1' ->
btRigidBody_internalWritebackVelocity'_ a1' >>= \res ->
return ()
btRigidBody_internalWritebackVelocity0 :: ( BtRigidBodyClass bc ) => bc -> IO ()
btRigidBody_internalWritebackVelocity0 a1 =
withBt a1 $ \a1' ->
btRigidBody_internalWritebackVelocity0'_ a1' >>= \res ->
return ()
btRigidBody_internalWritebackVelocity1 :: ( BtRigidBodyClass bc ) => bc -> Float -> IO ()
btRigidBody_internalWritebackVelocity1 a1 a2 =
withBt a1 $ \a1' ->
let {a2' = realToFrac a2} in
btRigidBody_internalWritebackVelocity1'_ a1' a2' >>= \res ->
return ()
btRigidBody_getPushVelocity :: ( BtRigidBodyClass bc ) => bc -> IO (Vec3)
btRigidBody_getPushVelocity a1 =
withBt a1 $ \a1' ->
allocaVec3 $ \a2' ->
btRigidBody_getPushVelocity'_ a1' a2' >>= \res ->
peekVec3 a2'>>= \a2'' ->
return (a2'')
btRigidBody_internalGetDeltaAngularVelocity :: ( BtRigidBodyClass bc ) => bc -> IO (Vec3)
btRigidBody_internalGetDeltaAngularVelocity a1 =
withBt a1 $ \a1' ->
allocaVec3 $ \a2' ->
btRigidBody_internalGetDeltaAngularVelocity'_ a1' a2' >>= \res ->
peekVec3 a2'>>= \a2'' ->
return (a2'')
btRigidBody_applyGravity :: ( BtRigidBodyClass bc ) => bc -> IO ()
btRigidBody_applyGravity a1 =
withBt a1 $ \a1' ->
btRigidBody_applyGravity'_ a1' >>= \res ->
return ()
btRigidBody_serialize :: ( BtRigidBodyClass bc , BtSerializerClass p1 ) => bc -> VoidPtr -> p1 -> IO (String)
btRigidBody_serialize a1 a2 a3 =
withBt a1 $ \a1' ->
withVoidPtr a2 $ \a2' ->
withBt a3 $ \a3' ->
btRigidBody_serialize'_ a1' a2' a3' >>= \res ->
peekCString res >>= \res' ->
return (res')
btRigidBody_getOrientation :: ( BtRigidBodyClass bc ) => bc -> IO (UnitQuaternion)
btRigidBody_getOrientation a1 =
withBt a1 $ \a1' ->
allocaUnitQuaternion $ \a2' ->
btRigidBody_getOrientation'_ a1' a2' >>= \res ->
peekUnitQuaternion a2'>>= \a2'' ->
return (a2'')
btRigidBody_applyCentralForce :: ( BtRigidBodyClass bc ) => bc -> Vec3 -> IO (Vec3)
btRigidBody_applyCentralForce a1 a2 =
withBt a1 $ \a1' ->
withVec3 a2 $ \a2' ->
btRigidBody_applyCentralForce'_ a1' a2' >>= \res ->
peekVec3 a2'>>= \a2'' ->
return (a2'')
btRigidBody_applyCentralForce' :: ( BtRigidBodyClass bc ) => bc -> IO (Vec3)
btRigidBody_applyCentralForce' a1 =
withBt a1 $ \a1' ->
allocaVec3 $ \a2' ->
btRigidBody_applyCentralForce''_ a1' a2' >>= \res ->
peekVec3 a2'>>= \a2'' ->
return (a2'')
btRigidBody_setMotionState :: ( BtRigidBodyClass bc , BtMotionStateClass p0 ) => bc -> p0 -> IO ()
btRigidBody_setMotionState a1 a2 =
withBt a1 $ \a1' ->
withBt a2 $ \a2' ->
btRigidBody_setMotionState'_ a1' a2' >>= \res ->
return ()
btRigidBody_clearForces :: ( BtRigidBodyClass bc ) => bc -> IO ()
btRigidBody_clearForces a1 =
withBt a1 $ \a1' ->
btRigidBody_clearForces'_ a1' >>= \res ->
return ()
btRigidBody_getMotionState :: ( BtRigidBodyClass bc ) => bc -> IO (BtMotionState)
btRigidBody_getMotionState a1 =
withBt a1 $ \a1' ->
btRigidBody_getMotionState'_ a1' >>= \res ->
mkBtMotionState res >>= \res' ->
return (res')
btRigidBody_getMotionState0 :: ( BtRigidBodyClass bc ) => bc -> IO (BtMotionState)
btRigidBody_getMotionState0 a1 =
withBt a1 $ \a1' ->
btRigidBody_getMotionState0'_ a1' >>= \res ->
mkBtMotionState res >>= \res' ->
return (res')
btRigidBody_getMotionState1 :: ( BtRigidBodyClass bc ) => bc -> IO (BtMotionState)
btRigidBody_getMotionState1 a1 =
withBt a1 $ \a1' ->
btRigidBody_getMotionState1'_ a1' >>= \res ->
mkBtMotionState res >>= \res' ->
return (res')
btRigidBody_setDamping :: ( BtRigidBodyClass bc ) => bc -> Float -> Float -> IO ()
btRigidBody_setDamping a1 a2 a3 =
withBt a1 $ \a1' ->
let {a2' = realToFrac a2} in
let {a3' = realToFrac a3} in
btRigidBody_setDamping'_ a1' a2' a3' >>= \res ->
return ()
btRigidBody_applyImpulse :: ( BtRigidBodyClass bc ) => bc -> Vec3 -> Vec3 -> IO (Vec3, Vec3)
btRigidBody_applyImpulse a1 a2 a3 =
withBt a1 $ \a1' ->
withVec3 a2 $ \a2' ->
withVec3 a3 $ \a3' ->
btRigidBody_applyImpulse'_ a1' a2' a3' >>= \res ->
peekVec3 a2'>>= \a2'' ->
peekVec3 a3'>>= \a3'' ->
return (a2'', a3'')
btRigidBody_applyImpulse' :: ( BtRigidBodyClass bc ) => bc -> IO (Vec3, Vec3)
btRigidBody_applyImpulse' a1 =
withBt a1 $ \a1' ->
allocaVec3 $ \a2' ->
allocaVec3 $ \a3' ->
btRigidBody_applyImpulse''_ a1' a2' a3' >>= \res ->
peekVec3 a2'>>= \a2'' ->
peekVec3 a3'>>= \a3'' ->
return (a2'', a3'')
btRigidBody_applyTorque :: ( BtRigidBodyClass bc ) => bc -> Vec3 -> IO (Vec3)
btRigidBody_applyTorque a1 a2 =
withBt a1 $ \a1' ->
withVec3 a2 $ \a2' ->
btRigidBody_applyTorque'_ a1' a2' >>= \res ->
peekVec3 a2'>>= \a2'' ->
return (a2'')
btRigidBody_applyTorque' :: ( BtRigidBodyClass bc ) => bc -> IO (Vec3)
btRigidBody_applyTorque' a1 =
withBt a1 $ \a1' ->
allocaVec3 $ \a2' ->
btRigidBody_applyTorque''_ a1' a2' >>= \res ->
peekVec3 a2'>>= \a2'' ->
return (a2'')
btRigidBody_internalApplyPushImpulse :: ( BtRigidBodyClass bc ) => bc -> Vec3 -> Vec3 -> Float -> IO (Vec3, Vec3)
btRigidBody_internalApplyPushImpulse a1 a2 a3 a4 =
withBt a1 $ \a1' ->
withVec3 a2 $ \a2' ->
withVec3 a3 $ \a3' ->
let {a4' = realToFrac a4} in
btRigidBody_internalApplyPushImpulse'_ a1' a2' a3' a4' >>= \res ->
peekVec3 a2'>>= \a2'' ->
peekVec3 a3'>>= \a3'' ->
return (a2'', a3'')
btRigidBody_internalApplyPushImpulse' :: ( BtRigidBodyClass bc ) => bc -> Float -> IO (Vec3, Vec3)
btRigidBody_internalApplyPushImpulse' a1 a4 =
withBt a1 $ \a1' ->
allocaVec3 $ \a2' ->
allocaVec3 $ \a3' ->
let {a4' = realToFrac a4} in
btRigidBody_internalApplyPushImpulse''_ a1' a2' a3' a4' >>= \res ->
peekVec3 a2'>>= \a2'' ->
peekVec3 a3'>>= \a3'' ->
return (a2'', a3'')
btRigidBody_wantsSleeping :: ( BtRigidBodyClass bc ) => bc -> IO (Bool)
btRigidBody_wantsSleeping a1 =
withBt a1 $ \a1' ->
btRigidBody_wantsSleeping'_ a1' >>= \res ->
let {res' = toBool res} in
return (res')
btRigidBody_setNewBroadphaseProxy :: ( BtRigidBodyClass bc , BtBroadphaseProxyClass p0 ) => bc -> p0 -> IO ()
btRigidBody_setNewBroadphaseProxy a1 a2 =
withBt a1 $ \a1' ->
withBt a2 $ \a2' ->
btRigidBody_setNewBroadphaseProxy'_ a1' a2' >>= \res ->
return ()
btRigidBody_getVelocityInLocalPoint :: ( BtRigidBodyClass bc ) => bc -> Vec3 -> IO (Vec3, Vec3)
btRigidBody_getVelocityInLocalPoint a1 a2 =
withBt a1 $ \a1' ->
withVec3 a2 $ \a2' ->
allocaVec3 $ \a3' ->
btRigidBody_getVelocityInLocalPoint'_ a1' a2' a3' >>= \res ->
peekVec3 a2'>>= \a2'' ->
peekVec3 a3'>>= \a3'' ->
return (a2'', a3'')
btRigidBody_getVelocityInLocalPoint' :: ( BtRigidBodyClass bc ) => bc -> IO (Vec3, Vec3)
btRigidBody_getVelocityInLocalPoint' a1 =
withBt a1 $ \a1' ->
allocaVec3 $ \a2' ->
allocaVec3 $ \a3' ->
btRigidBody_getVelocityInLocalPoint''_ a1' a2' a3' >>= \res ->
peekVec3 a2'>>= \a2'' ->
peekVec3 a3'>>= \a3'' ->
return (a2'', a3'')
btRigidBody_calculateSerializeBufferSize :: ( BtRigidBodyClass bc ) => bc -> IO (Int)
btRigidBody_calculateSerializeBufferSize a1 =
withBt a1 $ \a1' ->
btRigidBody_calculateSerializeBufferSize'_ a1' >>= \res ->
let {res' = fromIntegral res} in
return (res')
btRigidBody_setAngularVelocity :: ( BtRigidBodyClass bc ) => bc -> Vec3 -> IO (Vec3)
btRigidBody_setAngularVelocity a1 a2 =
withBt a1 $ \a1' ->
withVec3 a2 $ \a2' ->
btRigidBody_setAngularVelocity'_ a1' a2' >>= \res ->
peekVec3 a2'>>= \a2'' ->
return (a2'')
btRigidBody_setAngularVelocity' :: ( BtRigidBodyClass bc ) => bc -> IO (Vec3)
btRigidBody_setAngularVelocity' a1 =
withBt a1 $ \a1' ->
allocaVec3 $ \a2' ->
btRigidBody_setAngularVelocity''_ a1' a2' >>= \res ->
peekVec3 a2'>>= \a2'' ->
return (a2'')
btRigidBody_getLinearFactor :: ( BtRigidBodyClass bc ) => bc -> IO (Vec3)
btRigidBody_getLinearFactor a1 =
withBt a1 $ \a1' ->
allocaVec3 $ \a2' ->
btRigidBody_getLinearFactor'_ a1' a2' >>= \res ->
peekVec3 a2'>>= \a2'' ->
return (a2'')
btRigidBody_predictIntegratedTransform :: ( BtRigidBodyClass bc ) => bc -> Float -> Transform -> IO (Transform)
btRigidBody_predictIntegratedTransform a1 a2 a3 =
withBt a1 $ \a1' ->
let {a2' = realToFrac a2} in
withTransform a3 $ \a3' ->
btRigidBody_predictIntegratedTransform'_ a1' a2' a3' >>= \res ->
peekTransform a3'>>= \a3'' ->
return (a3'')
btRigidBody_predictIntegratedTransform' :: ( BtRigidBodyClass bc ) => bc -> Float -> IO (Transform)
btRigidBody_predictIntegratedTransform' a1 a2 =
withBt a1 $ \a1' ->
let {a2' = realToFrac a2} in
allocaTransform $ \a3' ->
btRigidBody_predictIntegratedTransform''_ a1' a2' a3' >>= \res ->
peekTransform a3'>>= \a3'' ->
return (a3'')
btRigidBody_internalGetAngularFactor :: ( BtRigidBodyClass bc ) => bc -> IO (Vec3)
btRigidBody_internalGetAngularFactor a1 =
withBt a1 $ \a1' ->
allocaVec3 $ \a2' ->
btRigidBody_internalGetAngularFactor'_ a1' a2' >>= \res ->
peekVec3 a2'>>= \a2'' ->
return (a2'')
btRigidBody_getAngularSleepingThreshold :: ( BtRigidBodyClass bc ) => bc -> IO (Float)
btRigidBody_getAngularSleepingThreshold a1 =
withBt a1 $ \a1' ->
btRigidBody_getAngularSleepingThreshold'_ a1' >>= \res ->
let {res' = realToFrac res} in
return (res')
btRigidBody_applyDamping :: ( BtRigidBodyClass bc ) => bc -> Float -> IO ()
btRigidBody_applyDamping a1 a2 =
withBt a1 $ \a1' ->
let {a2' = realToFrac a2} in
btRigidBody_applyDamping'_ a1' a2' >>= \res ->
return ()
btRigidBody_saveKinematicState :: ( BtRigidBodyClass bc ) => bc -> Float -> IO ()
btRigidBody_saveKinematicState a1 a2 =
withBt a1 $ \a1' ->
let {a2' = realToFrac a2} in
btRigidBody_saveKinematicState'_ a1' a2' >>= \res ->
return ()
btRigidBody_setSleepingThresholds :: ( BtRigidBodyClass bc ) => bc -> Float -> Float -> IO ()
btRigidBody_setSleepingThresholds a1 a2 a3 =
withBt a1 $ \a1' ->
let {a2' = realToFrac a2} in
let {a3' = realToFrac a3} in
btRigidBody_setSleepingThresholds'_ a1' a2' a3' >>= \res ->
return ()
btRigidBody_getAngularVelocity :: ( BtRigidBodyClass bc ) => bc -> IO (Vec3)
btRigidBody_getAngularVelocity a1 =
withBt a1 $ \a1' ->
allocaVec3 $ \a2' ->
btRigidBody_getAngularVelocity'_ a1' a2' >>= \res ->
peekVec3 a2'>>= \a2'' ->
return (a2'')
btRigidBody_getLinearSleepingThreshold :: ( BtRigidBodyClass bc ) => bc -> IO (Float)
btRigidBody_getLinearSleepingThreshold a1 =
withBt a1 $ \a1' ->
btRigidBody_getLinearSleepingThreshold'_ a1' >>= \res ->
let {res' = realToFrac res} in
return (res')
btRigidBody_internalGetInvMass :: ( BtRigidBodyClass bc ) => bc -> IO (Vec3)
btRigidBody_internalGetInvMass a1 =
withBt a1 $ \a1' ->
allocaVec3 $ \a2' ->
btRigidBody_internalGetInvMass'_ a1' a2' >>= \res ->
peekVec3 a2'>>= \a2'' ->
return (a2'')
btRigidBody_applyTorqueImpulse :: ( BtRigidBodyClass bc ) => bc -> Vec3 -> IO (Vec3)
btRigidBody_applyTorqueImpulse a1 a2 =
withBt a1 $ \a1' ->
withVec3 a2 $ \a2' ->
btRigidBody_applyTorqueImpulse'_ a1' a2' >>= \res ->
peekVec3 a2'>>= \a2'' ->
return (a2'')
btRigidBody_applyTorqueImpulse' :: ( BtRigidBodyClass bc ) => bc -> IO (Vec3)
btRigidBody_applyTorqueImpulse' a1 =
withBt a1 $ \a1' ->
allocaVec3 $ \a2' ->
btRigidBody_applyTorqueImpulse''_ a1' a2' >>= \res ->
peekVec3 a2'>>= \a2'' ->
return (a2'')
btRigidBody_internalGetPushVelocity :: ( BtRigidBodyClass bc ) => bc -> IO (Vec3)
btRigidBody_internalGetPushVelocity a1 =
withBt a1 $ \a1' ->
allocaVec3 $ \a2' ->
btRigidBody_internalGetPushVelocity'_ a1' a2' >>= \res ->
peekVec3 a2'>>= \a2'' ->
return (a2'')
btRigidBody_setLinearFactor :: ( BtRigidBodyClass bc ) => bc -> Vec3 -> IO (Vec3)
btRigidBody_setLinearFactor a1 a2 =
withBt a1 $ \a1' ->
withVec3 a2 $ \a2' ->
btRigidBody_setLinearFactor'_ a1' a2' >>= \res ->
peekVec3 a2'>>= \a2'' ->
return (a2'')
btRigidBody_setLinearFactor' :: ( BtRigidBodyClass bc ) => bc -> IO (Vec3)
btRigidBody_setLinearFactor' a1 =
withBt a1 $ \a1' ->
allocaVec3 $ \a2' ->
btRigidBody_setLinearFactor''_ a1' a2' >>= \res ->
peekVec3 a2'>>= \a2'' ->
return (a2'')
btRigidBody_serializeSingleObject :: ( BtRigidBodyClass bc , BtSerializerClass p0 ) => bc -> p0 -> IO ()
btRigidBody_serializeSingleObject a1 a2 =
withBt a1 $ \a1' ->
withBt a2 $ \a2' ->
btRigidBody_serializeSingleObject'_ a1' a2' >>= \res ->
return ()
btRigidBody_getInvMass :: ( BtRigidBodyClass bc ) => bc -> IO (Float)
btRigidBody_getInvMass a1 =
withBt a1 $ \a1' ->
btRigidBody_getInvMass'_ a1' >>= \res ->
let {res' = realToFrac res} in
return (res')
btRigidBody_getTotalForce :: ( BtRigidBodyClass bc ) => bc -> IO (Vec3)
btRigidBody_getTotalForce a1 =
withBt a1 $ \a1' ->
allocaVec3 $ \a2' ->
btRigidBody_getTotalForce'_ a1' a2' >>= \res ->
peekVec3 a2'>>= \a2'' ->
return (a2'')
btRigidBody_getCenterOfMassPosition :: ( BtRigidBodyClass bc ) => bc -> IO (Vec3)
btRigidBody_getCenterOfMassPosition a1 =
withBt a1 $ \a1' ->
allocaVec3 $ \a2' ->
btRigidBody_getCenterOfMassPosition'_ a1' a2' >>= \res ->
peekVec3 a2'>>= \a2'' ->
return (a2'')
btRigidBody_getAabb :: ( BtRigidBodyClass bc ) => bc -> Vec3 -> Vec3 -> IO (Vec3, Vec3)
btRigidBody_getAabb a1 a2 a3 =
withBt a1 $ \a1' ->
withVec3 a2 $ \a2' ->
withVec3 a3 $ \a3' ->
btRigidBody_getAabb'_ a1' a2' a3' >>= \res ->
peekVec3 a2'>>= \a2'' ->
peekVec3 a3'>>= \a3'' ->
return (a2'', a3'')
btRigidBody_getAabb' :: ( BtRigidBodyClass bc ) => bc -> IO (Vec3, Vec3)
btRigidBody_getAabb' a1 =
withBt a1 $ \a1' ->
allocaVec3 $ \a2' ->
allocaVec3 $ \a3' ->
btRigidBody_getAabb''_ a1' a2' a3' >>= \res ->
peekVec3 a2'>>= \a2'' ->
peekVec3 a3'>>= \a3'' ->
return (a2'', a3'')
btRigidBody_getBroadphaseProxy :: ( BtRigidBodyClass bc ) => bc -> IO (BtBroadphaseProxy)
btRigidBody_getBroadphaseProxy a1 =
withBt a1 $ \a1' ->
btRigidBody_getBroadphaseProxy'_ a1' >>= \res ->
mkBtBroadphaseProxy res >>= \res' ->
return (res')
btRigidBody_getBroadphaseProxy0 :: ( BtRigidBodyClass bc ) => bc -> IO (BtBroadphaseProxy)
btRigidBody_getBroadphaseProxy0 a1 =
withBt a1 $ \a1' ->
btRigidBody_getBroadphaseProxy0'_ a1' >>= \res ->
mkBtBroadphaseProxy res >>= \res' ->
return (res')
btRigidBody_getBroadphaseProxy1 :: ( BtRigidBodyClass bc ) => bc -> IO (BtBroadphaseProxy)
btRigidBody_getBroadphaseProxy1 a1 =
withBt a1 $ \a1' ->
btRigidBody_getBroadphaseProxy1'_ a1' >>= \res ->
mkBtBroadphaseProxy res >>= \res' ->
return (res')
btRigidBody_getCollisionShape :: ( BtRigidBodyClass bc ) => bc -> IO (BtCollisionShape)
btRigidBody_getCollisionShape a1 =
withBt a1 $ \a1' ->
btRigidBody_getCollisionShape'_ a1' >>= \res ->
mkBtCollisionShape res >>= \res' ->
return (res')
btRigidBody_getCollisionShape0 :: ( BtRigidBodyClass bc ) => bc -> IO (BtCollisionShape)
btRigidBody_getCollisionShape0 a1 =
withBt a1 $ \a1' ->
btRigidBody_getCollisionShape0'_ a1' >>= \res ->
mkBtCollisionShape res >>= \res' ->
return (res')
btRigidBody_getCollisionShape1 :: ( BtRigidBodyClass bc ) => bc -> IO (BtCollisionShape)
btRigidBody_getCollisionShape1 a1 =
withBt a1 $ \a1' ->
btRigidBody_getCollisionShape1'_ a1' >>= \res ->
mkBtCollisionShape res >>= \res' ->
return (res')
btRigidBody_upcast :: ( BtCollisionObjectClass p0 ) => p0 -> IO (BtRigidBody)
btRigidBody_upcast a1 =
withBt a1 $ \a1' ->
btRigidBody_upcast'_ a1' >>= \res ->
mkBtRigidBody res >>= \res' ->
return (res')
btRigidBody_upcast0 :: ( BtCollisionObjectClass p0 ) => p0 -> IO (BtRigidBody)
btRigidBody_upcast0 a1 =
withBt a1 $ \a1' ->
btRigidBody_upcast0'_ a1' >>= \res ->
mkBtRigidBody res >>= \res' ->
return (res')
btRigidBody_upcast1 :: ( BtCollisionObjectClass p0 ) => p0 -> IO (BtRigidBody)
btRigidBody_upcast1 a1 =
withBt a1 $ \a1' ->
btRigidBody_upcast1'_ a1' >>= \res ->
mkBtRigidBody res >>= \res' ->
return (res')
btRigidBody_checkCollideWithOverride :: ( BtRigidBodyClass bc , BtCollisionObjectClass p0 ) => bc -> p0 -> IO (Bool)
btRigidBody_checkCollideWithOverride a1 a2 =
withBt a1 $ \a1' ->
withBt a2 $ \a2' ->
btRigidBody_checkCollideWithOverride'_ a1' a2' >>= \res ->
let {res' = toBool res} in
return (res')
btRigidBody_translate :: ( BtRigidBodyClass bc ) => bc -> Vec3 -> IO (Vec3)
btRigidBody_translate a1 a2 =
withBt a1 $ \a1' ->
withVec3 a2 $ \a2' ->
btRigidBody_translate'_ a1' a2' >>= \res ->
peekVec3 a2'>>= \a2'' ->
return (a2'')
btRigidBody_translate' :: ( BtRigidBodyClass bc ) => bc -> IO (Vec3)
btRigidBody_translate' a1 =
withBt a1 $ \a1' ->
allocaVec3 $ \a2' ->
btRigidBody_translate''_ a1' a2' >>= \res ->
peekVec3 a2'>>= \a2'' ->
return (a2'')
btRigidBody_updateInertiaTensor :: ( BtRigidBodyClass bc ) => bc -> IO ()
btRigidBody_updateInertiaTensor a1 =
withBt a1 $ \a1' ->
btRigidBody_updateInertiaTensor'_ a1' >>= \res ->
return ()
btRigidBody_applyForce :: ( BtRigidBodyClass bc ) => bc -> Vec3 -> Vec3 -> IO (Vec3, Vec3)
btRigidBody_applyForce a1 a2 a3 =
withBt a1 $ \a1' ->
withVec3 a2 $ \a2' ->
withVec3 a3 $ \a3' ->
btRigidBody_applyForce'_ a1' a2' a3' >>= \res ->
peekVec3 a2'>>= \a2'' ->
peekVec3 a3'>>= \a3'' ->
return (a2'', a3'')
btRigidBody_applyForce' :: ( BtRigidBodyClass bc ) => bc -> IO (Vec3, Vec3)
btRigidBody_applyForce' a1 =
withBt a1 $ \a1' ->
allocaVec3 $ \a2' ->
allocaVec3 $ \a3' ->
btRigidBody_applyForce''_ a1' a2' a3' >>= \res ->
peekVec3 a2'>>= \a2'' ->
peekVec3 a3'>>= \a3'' ->
return (a2'', a3'')
btRigidBody_internalGetAngularVelocity :: ( BtRigidBodyClass bc ) => bc -> Vec3 -> IO (Vec3)
btRigidBody_internalGetAngularVelocity a1 a2 =
withBt a1 $ \a1' ->
withVec3 a2 $ \a2' ->
btRigidBody_internalGetAngularVelocity'_ a1' a2' >>= \res ->
peekVec3 a2'>>= \a2'' ->
return (a2'')
btRigidBody_internalGetAngularVelocity' :: ( BtRigidBodyClass bc ) => bc -> IO (Vec3)
btRigidBody_internalGetAngularVelocity' a1 =
withBt a1 $ \a1' ->
allocaVec3 $ \a2' ->
btRigidBody_internalGetAngularVelocity''_ a1' a2' >>= \res ->
peekVec3 a2'>>= \a2'' ->
return (a2'')
btRigidBody_setupRigidBody :: ( BtRigidBodyClass bc , BtRigidBody_btRigidBodyConstructionInfoClass p0 ) => bc -> p0 -> IO ()
btRigidBody_setupRigidBody a1 a2 =
withBt a1 $ \a1' ->
withBt a2 $ \a2' ->
btRigidBody_setupRigidBody'_ a1' a2' >>= \res ->
return ()
btRigidBody_applyCentralImpulse :: ( BtRigidBodyClass bc ) => bc -> Vec3 -> IO (Vec3)
btRigidBody_applyCentralImpulse a1 a2 =
withBt a1 $ \a1' ->
withVec3 a2 $ \a2' ->
btRigidBody_applyCentralImpulse'_ a1' a2' >>= \res ->
peekVec3 a2'>>= \a2'' ->
return (a2'')
btRigidBody_applyCentralImpulse' :: ( BtRigidBodyClass bc ) => bc -> IO (Vec3)
btRigidBody_applyCentralImpulse' a1 =
withBt a1 $ \a1' ->
allocaVec3 $ \a2' ->
btRigidBody_applyCentralImpulse''_ a1' a2' >>= \res ->
peekVec3 a2'>>= \a2'' ->
return (a2'')
btRigidBody_getTurnVelocity :: ( BtRigidBodyClass bc ) => bc -> IO (Vec3)
btRigidBody_getTurnVelocity a1 =
withBt a1 $ \a1' ->
allocaVec3 $ \a2' ->
btRigidBody_getTurnVelocity'_ a1' a2' >>= \res ->
peekVec3 a2'>>= \a2'' ->
return (a2'')
btRigidBody_getDeltaLinearVelocity :: ( BtRigidBodyClass bc ) => bc -> IO (Vec3)
btRigidBody_getDeltaLinearVelocity a1 =
withBt a1 $ \a1' ->
allocaVec3 $ \a2' ->
btRigidBody_getDeltaLinearVelocity'_ a1' a2' >>= \res ->
peekVec3 a2'>>= \a2'' ->
return (a2'')
btRigidBody_integrateVelocities :: ( BtRigidBodyClass bc ) => bc -> Float -> IO ()
btRigidBody_integrateVelocities a1 a2 =
withBt a1 $ \a1' ->
let {a2' = realToFrac a2} in
btRigidBody_integrateVelocities'_ a1' a2' >>= \res ->
return ()
btRigidBody_getGravity :: ( BtRigidBodyClass bc ) => bc -> IO (Vec3)
btRigidBody_getGravity a1 =
withBt a1 $ \a1' ->
allocaVec3 $ \a2' ->
btRigidBody_getGravity'_ a1' a2' >>= \res ->
peekVec3 a2'>>= \a2'' ->
return (a2'')
btRigidBody_setMassProps :: ( BtRigidBodyClass bc ) => bc -> Float -> Vec3 -> IO (Vec3)
btRigidBody_setMassProps a1 a2 a3 =
withBt a1 $ \a1' ->
let {a2' = realToFrac a2} in
withVec3 a3 $ \a3' ->
btRigidBody_setMassProps'_ a1' a2' a3' >>= \res ->
peekVec3 a3'>>= \a3'' ->
return (a3'')
btRigidBody_setMassProps' :: ( BtRigidBodyClass bc ) => bc -> Float -> IO (Vec3)
btRigidBody_setMassProps' a1 a2 =
withBt a1 $ \a1' ->
let {a2' = realToFrac a2} in
allocaVec3 $ \a3' ->
btRigidBody_setMassProps''_ a1' a2' a3' >>= \res ->
peekVec3 a3'>>= \a3'' ->
return (a3'')
btRigidBody_setCenterOfMassTransform :: ( BtRigidBodyClass bc ) => bc -> Transform -> IO (Transform)
btRigidBody_setCenterOfMassTransform a1 a2 =
withBt a1 $ \a1' ->
withTransform a2 $ \a2' ->
btRigidBody_setCenterOfMassTransform'_ a1' a2' >>= \res ->
peekTransform a2'>>= \a2'' ->
return (a2'')
btRigidBody_setCenterOfMassTransform' :: ( BtRigidBodyClass bc ) => bc -> IO (Transform)
btRigidBody_setCenterOfMassTransform' a1 =
withBt a1 $ \a1' ->
allocaTransform $ \a2' ->
btRigidBody_setCenterOfMassTransform''_ a1' a2' >>= \res ->
peekTransform a2'>>= \a2'' ->
return (a2'')
btRigidBody_setFlags :: ( BtRigidBodyClass bc ) => bc -> Int -> IO ()
btRigidBody_setFlags a1 a2 =
withBt a1 $ \a1' ->
let {a2' = fromIntegral a2} in
btRigidBody_setFlags'_ a1' a2' >>= \res ->
return ()
btRigidBody_addConstraintRef :: ( BtRigidBodyClass bc , BtTypedConstraintClass p0 ) => bc -> p0 -> IO ()
btRigidBody_addConstraintRef a1 a2 =
withBt a1 $ \a1' ->
withBt a2 $ \a2' ->
btRigidBody_addConstraintRef'_ a1' a2' >>= \res ->
return ()
btRigidBody_setLinearVelocity :: ( BtRigidBodyClass bc ) => bc -> Vec3 -> IO (Vec3)
btRigidBody_setLinearVelocity a1 a2 =
withBt a1 $ \a1' ->
withVec3 a2 $ \a2' ->
btRigidBody_setLinearVelocity'_ a1' a2' >>= \res ->
peekVec3 a2'>>= \a2'' ->
return (a2'')
btRigidBody_setLinearVelocity' :: ( BtRigidBodyClass bc ) => bc -> IO (Vec3)
btRigidBody_setLinearVelocity' a1 =
withBt a1 $ \a1' ->
allocaVec3 $ \a2' ->
btRigidBody_setLinearVelocity''_ a1' a2' >>= \res ->
peekVec3 a2'>>= \a2'' ->
return (a2'')
btRigidBody_isInWorld :: ( BtRigidBodyClass bc ) => bc -> IO (Bool)
btRigidBody_isInWorld a1 =
withBt a1 $ \a1' ->
btRigidBody_isInWorld'_ a1' >>= \res ->
let {res' = toBool res} in
return (res')
btRigidBody_getTotalTorque :: ( BtRigidBodyClass bc ) => bc -> IO (Vec3)
btRigidBody_getTotalTorque a1 =
withBt a1 $ \a1' ->
allocaVec3 $ \a2' ->
btRigidBody_getTotalTorque'_ a1' a2' >>= \res ->
peekVec3 a2'>>= \a2'' ->
return (a2'')
btRigidBody_getNumConstraintRefs :: ( BtRigidBodyClass bc ) => bc -> IO (Int)
btRigidBody_getNumConstraintRefs a1 =
withBt a1 $ \a1' ->
btRigidBody_getNumConstraintRefs'_ a1' >>= \res ->
let {res' = fromIntegral res} in
return (res')
btRigidBody_computeAngularImpulseDenominator :: ( BtRigidBodyClass bc ) => bc -> Vec3 -> IO (Float, Vec3)
btRigidBody_computeAngularImpulseDenominator a1 a2 =
withBt a1 $ \a1' ->
withVec3 a2 $ \a2' ->
btRigidBody_computeAngularImpulseDenominator'_ a1' a2' >>= \res ->
peekVec3 a2'>>= \a2'' ->
let {res' = realToFrac res} in
return (res', a2'')
btRigidBody_computeAngularImpulseDenominator' :: ( BtRigidBodyClass bc ) => bc -> IO (Float, Vec3)
btRigidBody_computeAngularImpulseDenominator' a1 =
withBt a1 $ \a1' ->
allocaVec3 $ \a2' ->
btRigidBody_computeAngularImpulseDenominator''_ a1' a2' >>= \res ->
peekVec3 a2'>>= \a2'' ->
let {res' = realToFrac res} in
return (res', a2'')
btRigidBody_getInvInertiaTensorWorld :: ( BtRigidBodyClass bc ) => bc -> IO (Mat3)
btRigidBody_getInvInertiaTensorWorld a1 =
withBt a1 $ \a1' ->
allocaMat3 $ \a2' ->
btRigidBody_getInvInertiaTensorWorld'_ a1' a2' >>= \res ->
peekMat3 a2'>>= \a2'' ->
return (a2'')
btRigidBody_getDeltaAngularVelocity :: ( BtRigidBodyClass bc ) => bc -> IO (Vec3)
btRigidBody_getDeltaAngularVelocity a1 =
withBt a1 $ \a1' ->
allocaVec3 $ \a2' ->
btRigidBody_getDeltaAngularVelocity'_ a1' a2' >>= \res ->
peekVec3 a2'>>= \a2'' ->
return (a2'')
btRigidBody_internalGetDeltaLinearVelocity :: ( BtRigidBodyClass bc ) => bc -> IO (Vec3)
btRigidBody_internalGetDeltaLinearVelocity a1 =
withBt a1 $ \a1' ->
allocaVec3 $ \a2' ->
btRigidBody_internalGetDeltaLinearVelocity'_ a1' a2' >>= \res ->
peekVec3 a2'>>= \a2'' ->
return (a2'')
btRigidBody_computeImpulseDenominator :: ( BtRigidBodyClass bc ) => bc -> Vec3 -> Vec3 -> IO (Float, Vec3, Vec3)
btRigidBody_computeImpulseDenominator a1 a2 a3 =
withBt a1 $ \a1' ->
withVec3 a2 $ \a2' ->
withVec3 a3 $ \a3' ->
btRigidBody_computeImpulseDenominator'_ a1' a2' a3' >>= \res ->
peekVec3 a2'>>= \a2'' ->
peekVec3 a3'>>= \a3'' ->
let {res' = realToFrac res} in
return (res', a2'', a3'')
btRigidBody_computeImpulseDenominator' :: ( BtRigidBodyClass bc ) => bc -> IO (Float, Vec3, Vec3)
btRigidBody_computeImpulseDenominator' a1 =
withBt a1 $ \a1' ->
allocaVec3 $ \a2' ->
allocaVec3 $ \a3' ->
btRigidBody_computeImpulseDenominator''_ a1' a2' a3' >>= \res ->
peekVec3 a2'>>= \a2'' ->
peekVec3 a3'>>= \a3'' ->
let {res' = realToFrac res} in
return (res', a2'', a3'')
btRigidBody_getConstraintRef :: ( BtRigidBodyClass bc ) => bc -> Int -> IO (BtTypedConstraint)
btRigidBody_getConstraintRef a1 a2 =
withBt a1 $ \a1' ->
let {a2' = fromIntegral a2} in
btRigidBody_getConstraintRef'_ a1' a2' >>= \res ->
mkBtTypedConstraint res >>= \res' ->
return (res')
btRigidBody_getAngularDamping :: ( BtRigidBodyClass bc ) => bc -> IO (Float)
btRigidBody_getAngularDamping a1 =
withBt a1 $ \a1' ->
btRigidBody_getAngularDamping'_ a1' >>= \res ->
let {res' = realToFrac res} in
return (res')
btRigidBody_internalGetTurnVelocity :: ( BtRigidBodyClass bc ) => bc -> IO (Vec3)
btRigidBody_internalGetTurnVelocity a1 =
withBt a1 $ \a1' ->
allocaVec3 $ \a2' ->
btRigidBody_internalGetTurnVelocity'_ a1' a2' >>= \res ->
peekVec3 a2'>>= \a2'' ->
return (a2'')
btRigidBody_proceedToTransform :: ( BtRigidBodyClass bc ) => bc -> Transform -> IO (Transform)
btRigidBody_proceedToTransform a1 a2 =
withBt a1 $ \a1' ->
withTransform a2 $ \a2' ->
btRigidBody_proceedToTransform'_ a1' a2' >>= \res ->
peekTransform a2'>>= \a2'' ->
return (a2'')
btRigidBody_proceedToTransform' :: ( BtRigidBodyClass bc ) => bc -> IO (Transform)
btRigidBody_proceedToTransform' a1 =
withBt a1 $ \a1' ->
allocaTransform $ \a2' ->
btRigidBody_proceedToTransform''_ a1' a2' >>= \res ->
peekTransform a2'>>= \a2'' ->
return (a2'')
btRigidBody_setInvInertiaDiagLocal :: ( BtRigidBodyClass bc ) => bc -> Vec3 -> IO (Vec3)
btRigidBody_setInvInertiaDiagLocal a1 a2 =
withBt a1 $ \a1' ->
withVec3 a2 $ \a2' ->
btRigidBody_setInvInertiaDiagLocal'_ a1' a2' >>= \res ->
peekVec3 a2'>>= \a2'' ->
return (a2'')
btRigidBody_setInvInertiaDiagLocal' :: ( BtRigidBodyClass bc ) => bc -> IO (Vec3)
btRigidBody_setInvInertiaDiagLocal' a1 =
withBt a1 $ \a1' ->
allocaVec3 $ \a2' ->
btRigidBody_setInvInertiaDiagLocal''_ a1' a2' >>= \res ->
peekVec3 a2'>>= \a2'' ->
return (a2'')
btRigidBody_getInvInertiaDiagLocal :: ( BtRigidBodyClass bc ) => bc -> IO (Vec3)
btRigidBody_getInvInertiaDiagLocal a1 =
withBt a1 $ \a1' ->
allocaVec3 $ \a2' ->
btRigidBody_getInvInertiaDiagLocal'_ a1' a2' >>= \res ->
peekVec3 a2'>>= \a2'' ->
return (a2'')
btRigidBody_getCenterOfMassTransform :: ( BtRigidBodyClass bc ) => bc -> IO (Transform)
btRigidBody_getCenterOfMassTransform a1 =
withBt a1 $ \a1' ->
allocaTransform $ \a2' ->
btRigidBody_getCenterOfMassTransform'_ a1' a2' >>= \res ->
peekTransform a2'>>= \a2'' ->
return (a2'')
btRigidBody_removeConstraintRef :: ( BtRigidBodyClass bc , BtTypedConstraintClass p0 ) => bc -> p0 -> IO ()
btRigidBody_removeConstraintRef a1 a2 =
withBt a1 $ \a1' ->
withBt a2 $ \a2' ->
btRigidBody_removeConstraintRef'_ a1' a2' >>= \res ->
return ()
btRigidBody_getAngularFactor :: ( BtRigidBodyClass bc ) => bc -> IO (Vec3)
btRigidBody_getAngularFactor a1 =
withBt a1 $ \a1' ->
allocaVec3 $ \a2' ->
btRigidBody_getAngularFactor'_ a1' a2' >>= \res ->
peekVec3 a2'>>= \a2'' ->
return (a2'')
btRigidBody_getLinearVelocity :: ( BtRigidBodyClass bc ) => bc -> IO (Vec3)
btRigidBody_getLinearVelocity a1 =
withBt a1 $ \a1' ->
allocaVec3 $ \a2' ->
btRigidBody_getLinearVelocity'_ a1' a2' >>= \res ->
peekVec3 a2'>>= \a2'' ->
return (a2'')
btRigidBody_getFlags :: ( BtRigidBodyClass bc ) => bc -> IO (Int)
btRigidBody_getFlags a1 =
withBt a1 $ \a1' ->
btRigidBody_getFlags'_ a1' >>= \res ->
let {res' = fromIntegral res} in
return (res')
btRigidBody_internalGetVelocityInLocalPointObsolete :: ( BtRigidBodyClass bc ) => bc -> Vec3 -> Vec3 -> IO (Vec3, Vec3)
btRigidBody_internalGetVelocityInLocalPointObsolete a1 a2 a3 =
withBt a1 $ \a1' ->
withVec3 a2 $ \a2' ->
withVec3 a3 $ \a3' ->
btRigidBody_internalGetVelocityInLocalPointObsolete'_ a1' a2' a3' >>= \res ->
peekVec3 a2'>>= \a2'' ->
peekVec3 a3'>>= \a3'' ->
return (a2'', a3'')
btRigidBody_internalGetVelocityInLocalPointObsolete' :: ( BtRigidBodyClass bc ) => bc -> IO (Vec3, Vec3)
btRigidBody_internalGetVelocityInLocalPointObsolete' a1 =
withBt a1 $ \a1' ->
allocaVec3 $ \a2' ->
allocaVec3 $ \a3' ->
btRigidBody_internalGetVelocityInLocalPointObsolete''_ a1' a2' a3' >>= \res ->
peekVec3 a2'>>= \a2'' ->
peekVec3 a3'>>= \a3'' ->
return (a2'', a3'')
btRigidBody_getLinearDamping :: ( BtRigidBodyClass bc ) => bc -> IO (Float)
btRigidBody_getLinearDamping a1 =
withBt a1 $ \a1' ->
btRigidBody_getLinearDamping'_ a1' >>= \res ->
let {res' = realToFrac res} in
return (res')
btRigidBody_m_additionalAngularDampingFactor_set :: ( BtRigidBodyClass bc ) => bc -> Float -> IO ()
btRigidBody_m_additionalAngularDampingFactor_set a1 a2 =
withBt a1 $ \a1' ->
let {a2' = realToFrac a2} in
btRigidBody_m_additionalAngularDampingFactor_set'_ a1' a2' >>= \res ->
return ()
btRigidBody_m_additionalAngularDampingFactor_get :: ( BtRigidBodyClass bc ) => bc -> IO (Float)
btRigidBody_m_additionalAngularDampingFactor_get a1 =
withBt a1 $ \a1' ->
btRigidBody_m_additionalAngularDampingFactor_get'_ a1' >>= \res ->
let {res' = realToFrac res} in
return (res')
btRigidBody_m_additionalAngularDampingThresholdSqr_set :: ( BtRigidBodyClass bc ) => bc -> Float -> IO ()
btRigidBody_m_additionalAngularDampingThresholdSqr_set a1 a2 =
withBt a1 $ \a1' ->
let {a2' = realToFrac a2} in
btRigidBody_m_additionalAngularDampingThresholdSqr_set'_ a1' a2' >>= \res ->
return ()
btRigidBody_m_additionalAngularDampingThresholdSqr_get :: ( BtRigidBodyClass bc ) => bc -> IO (Float)
btRigidBody_m_additionalAngularDampingThresholdSqr_get a1 =
withBt a1 $ \a1' ->
btRigidBody_m_additionalAngularDampingThresholdSqr_get'_ a1' >>= \res ->
let {res' = realToFrac res} in
return (res')
btRigidBody_m_additionalDamping_set :: ( BtRigidBodyClass bc ) => bc -> Bool -> IO ()
btRigidBody_m_additionalDamping_set a1 a2 =
withBt a1 $ \a1' ->
let {a2' = fromBool a2} in
btRigidBody_m_additionalDamping_set'_ a1' a2' >>= \res ->
return ()
btRigidBody_m_additionalDamping_get :: ( BtRigidBodyClass bc ) => bc -> IO (Bool)
btRigidBody_m_additionalDamping_get a1 =
withBt a1 $ \a1' ->
btRigidBody_m_additionalDamping_get'_ a1' >>= \res ->
let {res' = toBool res} in
return (res')
btRigidBody_m_additionalDampingFactor_set :: ( BtRigidBodyClass bc ) => bc -> Float -> IO ()
btRigidBody_m_additionalDampingFactor_set a1 a2 =
withBt a1 $ \a1' ->
let {a2' = realToFrac a2} in
btRigidBody_m_additionalDampingFactor_set'_ a1' a2' >>= \res ->
return ()
btRigidBody_m_additionalDampingFactor_get :: ( BtRigidBodyClass bc ) => bc -> IO (Float)
btRigidBody_m_additionalDampingFactor_get a1 =
withBt a1 $ \a1' ->
btRigidBody_m_additionalDampingFactor_get'_ a1' >>= \res ->
let {res' = realToFrac res} in
return (res')
btRigidBody_m_additionalLinearDampingThresholdSqr_set :: ( BtRigidBodyClass bc ) => bc -> Float -> IO ()
btRigidBody_m_additionalLinearDampingThresholdSqr_set a1 a2 =
withBt a1 $ \a1' ->
let {a2' = realToFrac a2} in
btRigidBody_m_additionalLinearDampingThresholdSqr_set'_ a1' a2' >>= \res ->
return ()
btRigidBody_m_additionalLinearDampingThresholdSqr_get :: ( BtRigidBodyClass bc ) => bc -> IO (Float)
btRigidBody_m_additionalLinearDampingThresholdSqr_get a1 =
withBt a1 $ \a1' ->
btRigidBody_m_additionalLinearDampingThresholdSqr_get'_ a1' >>= \res ->
let {res' = realToFrac res} in
return (res')
btRigidBody_m_angularDamping_set :: ( BtRigidBodyClass bc ) => bc -> Float -> IO ()
btRigidBody_m_angularDamping_set a1 a2 =
withBt a1 $ \a1' ->
let {a2' = realToFrac a2} in
btRigidBody_m_angularDamping_set'_ a1' a2' >>= \res ->
return ()
btRigidBody_m_angularDamping_get :: ( BtRigidBodyClass bc ) => bc -> IO (Float)
btRigidBody_m_angularDamping_get a1 =
withBt a1 $ \a1' ->
btRigidBody_m_angularDamping_get'_ a1' >>= \res ->
let {res' = realToFrac res} in
return (res')
btRigidBody_m_angularFactor_set :: ( BtRigidBodyClass bc ) => bc -> Vec3 -> IO ()
btRigidBody_m_angularFactor_set a1 a2 =
withBt a1 $ \a1' ->
withVec3 a2 $ \a2' ->
btRigidBody_m_angularFactor_set'_ a1' a2' >>= \res ->
return ()
btRigidBody_m_angularFactor_get :: ( BtRigidBodyClass bc ) => bc -> IO (Vec3)
btRigidBody_m_angularFactor_get a1 =
withBt a1 $ \a1' ->
allocaVec3 $ \a2' ->
btRigidBody_m_angularFactor_get'_ a1' a2' >>= \res ->
peekVec3 a2'>>= \a2'' ->
return (a2'')
btRigidBody_m_angularSleepingThreshold_set :: ( BtRigidBodyClass bc ) => bc -> Float -> IO ()
btRigidBody_m_angularSleepingThreshold_set a1 a2 =
withBt a1 $ \a1' ->
let {a2' = realToFrac a2} in
btRigidBody_m_angularSleepingThreshold_set'_ a1' a2' >>= \res ->
return ()
btRigidBody_m_angularSleepingThreshold_get :: ( BtRigidBodyClass bc ) => bc -> IO (Float)
btRigidBody_m_angularSleepingThreshold_get a1 =
withBt a1 $ \a1' ->
btRigidBody_m_angularSleepingThreshold_get'_ a1' >>= \res ->
let {res' = realToFrac res} in
return (res')
btRigidBody_m_angularVelocity_set :: ( BtRigidBodyClass bc ) => bc -> Vec3 -> IO ()
btRigidBody_m_angularVelocity_set a1 a2 =
withBt a1 $ \a1' ->
withVec3 a2 $ \a2' ->
btRigidBody_m_angularVelocity_set'_ a1' a2' >>= \res ->
return ()
btRigidBody_m_angularVelocity_get :: ( BtRigidBodyClass bc ) => bc -> IO (Vec3)
btRigidBody_m_angularVelocity_get a1 =
withBt a1 $ \a1' ->
allocaVec3 $ \a2' ->
btRigidBody_m_angularVelocity_get'_ a1' a2' >>= \res ->
peekVec3 a2'>>= \a2'' ->
return (a2'')
btRigidBody_m_constraintRefs_set :: ( BtRigidBodyClass bc , BtAlignedObjectArray_btTypedConstraint_ptr_Class a ) => bc -> a -> IO ()
btRigidBody_m_constraintRefs_set a1 a2 =
withBt a1 $ \a1' ->
withBt a2 $ \a2' ->
btRigidBody_m_constraintRefs_set'_ a1' a2' >>= \res ->
return ()
btRigidBody_m_constraintRefs_get :: ( BtRigidBodyClass bc ) => bc -> IO (BtAlignedObjectArray_btTypedConstraint_ptr_)
btRigidBody_m_constraintRefs_get a1 =
withBt a1 $ \a1' ->
btRigidBody_m_constraintRefs_get'_ a1' >>= \res ->
mkBtAlignedObjectArray_btTypedConstraint_ptr_ res >>= \res' ->
return (res')
btRigidBody_m_contactSolverType_set :: ( BtRigidBodyClass bc ) => bc -> Int -> IO ()
btRigidBody_m_contactSolverType_set a1 a2 =
withBt a1 $ \a1' ->
let {a2' = fromIntegral a2} in
btRigidBody_m_contactSolverType_set'_ a1' a2' >>= \res ->
return ()
btRigidBody_m_contactSolverType_get :: ( BtRigidBodyClass bc ) => bc -> IO (Int)
btRigidBody_m_contactSolverType_get a1 =
withBt a1 $ \a1' ->
btRigidBody_m_contactSolverType_get'_ a1' >>= \res ->
let {res' = fromIntegral res} in
return (res')
btRigidBody_m_debugBodyId_set :: ( BtRigidBodyClass bc ) => bc -> Int -> IO ()
btRigidBody_m_debugBodyId_set a1 a2 =
withBt a1 $ \a1' ->
let {a2' = fromIntegral a2} in
btRigidBody_m_debugBodyId_set'_ a1' a2' >>= \res ->
return ()
btRigidBody_m_debugBodyId_get :: ( BtRigidBodyClass bc ) => bc -> IO (Int)
btRigidBody_m_debugBodyId_get a1 =
withBt a1 $ \a1' ->
btRigidBody_m_debugBodyId_get'_ a1' >>= \res ->
let {res' = fromIntegral res} in
return (res')
btRigidBody_m_deltaAngularVelocity_set :: ( BtRigidBodyClass bc ) => bc -> Vec3 -> IO ()
btRigidBody_m_deltaAngularVelocity_set a1 a2 =
withBt a1 $ \a1' ->
withVec3 a2 $ \a2' ->
btRigidBody_m_deltaAngularVelocity_set'_ a1' a2' >>= \res ->
return ()
btRigidBody_m_deltaAngularVelocity_get :: ( BtRigidBodyClass bc ) => bc -> IO (Vec3)
btRigidBody_m_deltaAngularVelocity_get a1 =
withBt a1 $ \a1' ->
allocaVec3 $ \a2' ->
btRigidBody_m_deltaAngularVelocity_get'_ a1' a2' >>= \res ->
peekVec3 a2'>>= \a2'' ->
return (a2'')
btRigidBody_m_deltaLinearVelocity_set :: ( BtRigidBodyClass bc ) => bc -> Vec3 -> IO ()
btRigidBody_m_deltaLinearVelocity_set a1 a2 =
withBt a1 $ \a1' ->
withVec3 a2 $ \a2' ->
btRigidBody_m_deltaLinearVelocity_set'_ a1' a2' >>= \res ->
return ()
btRigidBody_m_deltaLinearVelocity_get :: ( BtRigidBodyClass bc ) => bc -> IO (Vec3)
btRigidBody_m_deltaLinearVelocity_get a1 =
withBt a1 $ \a1' ->
allocaVec3 $ \a2' ->
btRigidBody_m_deltaLinearVelocity_get'_ a1' a2' >>= \res ->
peekVec3 a2'>>= \a2'' ->
return (a2'')
btRigidBody_m_frictionSolverType_set :: ( BtRigidBodyClass bc ) => bc -> Int -> IO ()
btRigidBody_m_frictionSolverType_set a1 a2 =
withBt a1 $ \a1' ->
let {a2' = fromIntegral a2} in
btRigidBody_m_frictionSolverType_set'_ a1' a2' >>= \res ->
return ()
btRigidBody_m_frictionSolverType_get :: ( BtRigidBodyClass bc ) => bc -> IO (Int)
btRigidBody_m_frictionSolverType_get a1 =
withBt a1 $ \a1' ->
btRigidBody_m_frictionSolverType_get'_ a1' >>= \res ->
let {res' = fromIntegral res} in
return (res')
btRigidBody_m_gravity_set :: ( BtRigidBodyClass bc ) => bc -> Vec3 -> IO ()
btRigidBody_m_gravity_set a1 a2 =
withBt a1 $ \a1' ->
withVec3 a2 $ \a2' ->
btRigidBody_m_gravity_set'_ a1' a2' >>= \res ->
return ()
btRigidBody_m_gravity_get :: ( BtRigidBodyClass bc ) => bc -> IO (Vec3)
btRigidBody_m_gravity_get a1 =
withBt a1 $ \a1' ->
allocaVec3 $ \a2' ->
btRigidBody_m_gravity_get'_ a1' a2' >>= \res ->
peekVec3 a2'>>= \a2'' ->
return (a2'')
btRigidBody_m_gravity_acceleration_set :: ( BtRigidBodyClass bc ) => bc -> Vec3 -> IO ()
btRigidBody_m_gravity_acceleration_set a1 a2 =
withBt a1 $ \a1' ->
withVec3 a2 $ \a2' ->
btRigidBody_m_gravity_acceleration_set'_ a1' a2' >>= \res ->
return ()
btRigidBody_m_gravity_acceleration_get :: ( BtRigidBodyClass bc ) => bc -> IO (Vec3)
btRigidBody_m_gravity_acceleration_get a1 =
withBt a1 $ \a1' ->
allocaVec3 $ \a2' ->
btRigidBody_m_gravity_acceleration_get'_ a1' a2' >>= \res ->
peekVec3 a2'>>= \a2'' ->
return (a2'')
btRigidBody_m_invInertiaLocal_set :: ( BtRigidBodyClass bc ) => bc -> Vec3 -> IO ()
btRigidBody_m_invInertiaLocal_set a1 a2 =
withBt a1 $ \a1' ->
withVec3 a2 $ \a2' ->
btRigidBody_m_invInertiaLocal_set'_ a1' a2' >>= \res ->
return ()
btRigidBody_m_invInertiaLocal_get :: ( BtRigidBodyClass bc ) => bc -> IO (Vec3)
btRigidBody_m_invInertiaLocal_get a1 =
withBt a1 $ \a1' ->
allocaVec3 $ \a2' ->
btRigidBody_m_invInertiaLocal_get'_ a1' a2' >>= \res ->
peekVec3 a2'>>= \a2'' ->
return (a2'')
btRigidBody_m_invInertiaTensorWorld_set :: ( BtRigidBodyClass bc ) => bc -> Mat3 -> IO ()
btRigidBody_m_invInertiaTensorWorld_set a1 a2 =
withBt a1 $ \a1' ->
withMat3 a2 $ \a2' ->
btRigidBody_m_invInertiaTensorWorld_set'_ a1' a2' >>= \res ->
return ()
btRigidBody_m_invInertiaTensorWorld_get :: ( BtRigidBodyClass bc ) => bc -> IO (Mat3)
btRigidBody_m_invInertiaTensorWorld_get a1 =
withBt a1 $ \a1' ->
allocaMat3 $ \a2' ->
btRigidBody_m_invInertiaTensorWorld_get'_ a1' a2' >>= \res ->
peekMat3 a2'>>= \a2'' ->
return (a2'')
btRigidBody_m_invMass_set :: ( BtRigidBodyClass bc ) => bc -> Vec3 -> IO ()
btRigidBody_m_invMass_set a1 a2 =
withBt a1 $ \a1' ->
withVec3 a2 $ \a2' ->
btRigidBody_m_invMass_set'_ a1' a2' >>= \res ->
return ()
btRigidBody_m_invMass_get :: ( BtRigidBodyClass bc ) => bc -> IO (Vec3)
btRigidBody_m_invMass_get a1 =
withBt a1 $ \a1' ->
allocaVec3 $ \a2' ->
btRigidBody_m_invMass_get'_ a1' a2' >>= \res ->
peekVec3 a2'>>= \a2'' ->
return (a2'')
btRigidBody_m_inverseMass_set :: ( BtRigidBodyClass bc ) => bc -> Float -> IO ()
btRigidBody_m_inverseMass_set a1 a2 =
withBt a1 $ \a1' ->
let {a2' = realToFrac a2} in
btRigidBody_m_inverseMass_set'_ a1' a2' >>= \res ->
return ()
btRigidBody_m_inverseMass_get :: ( BtRigidBodyClass bc ) => bc -> IO (Float)
btRigidBody_m_inverseMass_get a1 =
withBt a1 $ \a1' ->
btRigidBody_m_inverseMass_get'_ a1' >>= \res ->
let {res' = realToFrac res} in
return (res')
btRigidBody_m_linearDamping_set :: ( BtRigidBodyClass bc ) => bc -> Float -> IO ()
btRigidBody_m_linearDamping_set a1 a2 =
withBt a1 $ \a1' ->
let {a2' = realToFrac a2} in
btRigidBody_m_linearDamping_set'_ a1' a2' >>= \res ->
return ()
btRigidBody_m_linearDamping_get :: ( BtRigidBodyClass bc ) => bc -> IO (Float)
btRigidBody_m_linearDamping_get a1 =
withBt a1 $ \a1' ->
btRigidBody_m_linearDamping_get'_ a1' >>= \res ->
let {res' = realToFrac res} in
return (res')
btRigidBody_m_linearFactor_set :: ( BtRigidBodyClass bc ) => bc -> Vec3 -> IO ()
btRigidBody_m_linearFactor_set a1 a2 =
withBt a1 $ \a1' ->
withVec3 a2 $ \a2' ->
btRigidBody_m_linearFactor_set'_ a1' a2' >>= \res ->
return ()
btRigidBody_m_linearFactor_get :: ( BtRigidBodyClass bc ) => bc -> IO (Vec3)
btRigidBody_m_linearFactor_get a1 =
withBt a1 $ \a1' ->
allocaVec3 $ \a2' ->
btRigidBody_m_linearFactor_get'_ a1' a2' >>= \res ->
peekVec3 a2'>>= \a2'' ->
return (a2'')
btRigidBody_m_linearSleepingThreshold_set :: ( BtRigidBodyClass bc ) => bc -> Float -> IO ()
btRigidBody_m_linearSleepingThreshold_set a1 a2 =
withBt a1 $ \a1' ->
let {a2' = realToFrac a2} in
btRigidBody_m_linearSleepingThreshold_set'_ a1' a2' >>= \res ->
return ()
btRigidBody_m_linearSleepingThreshold_get :: ( BtRigidBodyClass bc ) => bc -> IO (Float)
btRigidBody_m_linearSleepingThreshold_get a1 =
withBt a1 $ \a1' ->
btRigidBody_m_linearSleepingThreshold_get'_ a1' >>= \res ->
let {res' = realToFrac res} in
return (res')
btRigidBody_m_linearVelocity_set :: ( BtRigidBodyClass bc ) => bc -> Vec3 -> IO ()
btRigidBody_m_linearVelocity_set a1 a2 =
withBt a1 $ \a1' ->
withVec3 a2 $ \a2' ->
btRigidBody_m_linearVelocity_set'_ a1' a2' >>= \res ->
return ()
btRigidBody_m_linearVelocity_get :: ( BtRigidBodyClass bc ) => bc -> IO (Vec3)
btRigidBody_m_linearVelocity_get a1 =
withBt a1 $ \a1' ->
allocaVec3 $ \a2' ->
btRigidBody_m_linearVelocity_get'_ a1' a2' >>= \res ->
peekVec3 a2'>>= \a2'' ->
return (a2'')
btRigidBody_m_optionalMotionState_set :: ( BtRigidBodyClass bc , BtMotionStateClass a ) => bc -> a -> IO ()
btRigidBody_m_optionalMotionState_set a1 a2 =
withBt a1 $ \a1' ->
withBt a2 $ \a2' ->
btRigidBody_m_optionalMotionState_set'_ a1' a2' >>= \res ->
return ()
btRigidBody_m_optionalMotionState_get :: ( BtRigidBodyClass bc ) => bc -> IO (BtMotionState)
btRigidBody_m_optionalMotionState_get a1 =
withBt a1 $ \a1' ->
btRigidBody_m_optionalMotionState_get'_ a1' >>= \res ->
mkBtMotionState res >>= \res' ->
return (res')
btRigidBody_m_pushVelocity_set :: ( BtRigidBodyClass bc ) => bc -> Vec3 -> IO ()
btRigidBody_m_pushVelocity_set a1 a2 =
withBt a1 $ \a1' ->
withVec3 a2 $ \a2' ->
btRigidBody_m_pushVelocity_set'_ a1' a2' >>= \res ->
return ()
btRigidBody_m_pushVelocity_get :: ( BtRigidBodyClass bc ) => bc -> IO (Vec3)
btRigidBody_m_pushVelocity_get a1 =
withBt a1 $ \a1' ->
allocaVec3 $ \a2' ->
btRigidBody_m_pushVelocity_get'_ a1' a2' >>= \res ->
peekVec3 a2'>>= \a2'' ->
return (a2'')
btRigidBody_m_rigidbodyFlags_set :: ( BtRigidBodyClass bc ) => bc -> Int -> IO ()
btRigidBody_m_rigidbodyFlags_set a1 a2 =
withBt a1 $ \a1' ->
let {a2' = fromIntegral a2} in
btRigidBody_m_rigidbodyFlags_set'_ a1' a2' >>= \res ->
return ()
btRigidBody_m_rigidbodyFlags_get :: ( BtRigidBodyClass bc ) => bc -> IO (Int)
btRigidBody_m_rigidbodyFlags_get a1 =
withBt a1 $ \a1' ->
btRigidBody_m_rigidbodyFlags_get'_ a1' >>= \res ->
let {res' = fromIntegral res} in
return (res')
btRigidBody_m_totalForce_set :: ( BtRigidBodyClass bc ) => bc -> Vec3 -> IO ()
btRigidBody_m_totalForce_set a1 a2 =
withBt a1 $ \a1' ->
withVec3 a2 $ \a2' ->
btRigidBody_m_totalForce_set'_ a1' a2' >>= \res ->
return ()
btRigidBody_m_totalForce_get :: ( BtRigidBodyClass bc ) => bc -> IO (Vec3)
btRigidBody_m_totalForce_get a1 =
withBt a1 $ \a1' ->
allocaVec3 $ \a2' ->
btRigidBody_m_totalForce_get'_ a1' a2' >>= \res ->
peekVec3 a2'>>= \a2'' ->
return (a2'')
btRigidBody_m_totalTorque_set :: ( BtRigidBodyClass bc ) => bc -> Vec3 -> IO ()
btRigidBody_m_totalTorque_set a1 a2 =
withBt a1 $ \a1' ->
withVec3 a2 $ \a2' ->
btRigidBody_m_totalTorque_set'_ a1' a2' >>= \res ->
return ()
btRigidBody_m_totalTorque_get :: ( BtRigidBodyClass bc ) => bc -> IO (Vec3)
btRigidBody_m_totalTorque_get a1 =
withBt a1 $ \a1' ->
allocaVec3 $ \a2' ->
btRigidBody_m_totalTorque_get'_ a1' a2' >>= \res ->
peekVec3 a2'>>= \a2'' ->
return (a2'')
btRigidBody_m_turnVelocity_set :: ( BtRigidBodyClass bc ) => bc -> Vec3 -> IO ()
btRigidBody_m_turnVelocity_set a1 a2 =
withBt a1 $ \a1' ->
withVec3 a2 $ \a2' ->
btRigidBody_m_turnVelocity_set'_ a1' a2' >>= \res ->
return ()
btRigidBody_m_turnVelocity_get :: ( BtRigidBodyClass bc ) => bc -> IO (Vec3)
btRigidBody_m_turnVelocity_get a1 =
withBt a1 $ \a1' ->
allocaVec3 $ \a2' ->
btRigidBody_m_turnVelocity_get'_ a1' a2' >>= \res ->
peekVec3 a2'>>= \a2'' ->
return (a2'')
btRigidBody_btRigidBodyConstructionInfo :: ( BtMotionStateClass p1 , BtCollisionShapeClass p2 ) => Float -> p1 -> p2 -> Vec3 -> IO (BtRigidBody_btRigidBodyConstructionInfo)
btRigidBody_btRigidBodyConstructionInfo a1 a2 a3 a4 =
let {a1' = realToFrac a1} in
withBt a2 $ \a2' ->
withBt a3 $ \a3' ->
withVec3 a4 $ \a4' ->
btRigidBody_btRigidBodyConstructionInfo'_ a1' a2' a3' a4' >>= \res ->
mkBtRigidBody_btRigidBodyConstructionInfo res >>= \res' ->
return (res')
btRigidBody_btRigidBodyConstructionInfo_free :: ( BtRigidBody_btRigidBodyConstructionInfoClass bc ) => bc -> IO ()
btRigidBody_btRigidBodyConstructionInfo_free a1 =
withBt a1 $ \a1' ->
btRigidBody_btRigidBodyConstructionInfo_free'_ a1' >>= \res ->
return ()
btRigidBody_btRigidBodyConstructionInfo_m_additionalAngularDampingFactor_set :: ( BtRigidBody_btRigidBodyConstructionInfoClass bc ) => bc -> Float -> IO ()
btRigidBody_btRigidBodyConstructionInfo_m_additionalAngularDampingFactor_set a1 a2 =
withBt a1 $ \a1' ->
let {a2' = realToFrac a2} in
btRigidBody_btRigidBodyConstructionInfo_m_additionalAngularDampingFactor_set'_ a1' a2' >>= \res ->
return ()
btRigidBody_btRigidBodyConstructionInfo_m_additionalAngularDampingFactor_get :: ( BtRigidBody_btRigidBodyConstructionInfoClass bc ) => bc -> IO (Float)
btRigidBody_btRigidBodyConstructionInfo_m_additionalAngularDampingFactor_get a1 =
withBt a1 $ \a1' ->
btRigidBody_btRigidBodyConstructionInfo_m_additionalAngularDampingFactor_get'_ a1' >>= \res ->
let {res' = realToFrac res} in
return (res')
btRigidBody_btRigidBodyConstructionInfo_m_additionalAngularDampingThresholdSqr_set :: ( BtRigidBody_btRigidBodyConstructionInfoClass bc ) => bc -> Float -> IO ()
btRigidBody_btRigidBodyConstructionInfo_m_additionalAngularDampingThresholdSqr_set a1 a2 =
withBt a1 $ \a1' ->
let {a2' = realToFrac a2} in
btRigidBody_btRigidBodyConstructionInfo_m_additionalAngularDampingThresholdSqr_set'_ a1' a2' >>= \res ->
return ()
btRigidBody_btRigidBodyConstructionInfo_m_additionalAngularDampingThresholdSqr_get :: ( BtRigidBody_btRigidBodyConstructionInfoClass bc ) => bc -> IO (Float)
btRigidBody_btRigidBodyConstructionInfo_m_additionalAngularDampingThresholdSqr_get a1 =
withBt a1 $ \a1' ->
btRigidBody_btRigidBodyConstructionInfo_m_additionalAngularDampingThresholdSqr_get'_ a1' >>= \res ->
let {res' = realToFrac res} in
return (res')
btRigidBody_btRigidBodyConstructionInfo_m_additionalDamping_set :: ( BtRigidBody_btRigidBodyConstructionInfoClass bc ) => bc -> Bool -> IO ()
btRigidBody_btRigidBodyConstructionInfo_m_additionalDamping_set a1 a2 =
withBt a1 $ \a1' ->
let {a2' = fromBool a2} in
btRigidBody_btRigidBodyConstructionInfo_m_additionalDamping_set'_ a1' a2' >>= \res ->
return ()
btRigidBody_btRigidBodyConstructionInfo_m_additionalDamping_get :: ( BtRigidBody_btRigidBodyConstructionInfoClass bc ) => bc -> IO (Bool)
btRigidBody_btRigidBodyConstructionInfo_m_additionalDamping_get a1 =
withBt a1 $ \a1' ->
btRigidBody_btRigidBodyConstructionInfo_m_additionalDamping_get'_ a1' >>= \res ->
let {res' = toBool res} in
return (res')
btRigidBody_btRigidBodyConstructionInfo_m_additionalDampingFactor_set :: ( BtRigidBody_btRigidBodyConstructionInfoClass bc ) => bc -> Float -> IO ()
btRigidBody_btRigidBodyConstructionInfo_m_additionalDampingFactor_set a1 a2 =
withBt a1 $ \a1' ->
let {a2' = realToFrac a2} in
btRigidBody_btRigidBodyConstructionInfo_m_additionalDampingFactor_set'_ a1' a2' >>= \res ->
return ()
btRigidBody_btRigidBodyConstructionInfo_m_additionalDampingFactor_get :: ( BtRigidBody_btRigidBodyConstructionInfoClass bc ) => bc -> IO (Float)
btRigidBody_btRigidBodyConstructionInfo_m_additionalDampingFactor_get a1 =
withBt a1 $ \a1' ->
btRigidBody_btRigidBodyConstructionInfo_m_additionalDampingFactor_get'_ a1' >>= \res ->
let {res' = realToFrac res} in
return (res')
btRigidBody_btRigidBodyConstructionInfo_m_additionalLinearDampingThresholdSqr_set :: ( BtRigidBody_btRigidBodyConstructionInfoClass bc ) => bc -> Float -> IO ()
btRigidBody_btRigidBodyConstructionInfo_m_additionalLinearDampingThresholdSqr_set a1 a2 =
withBt a1 $ \a1' ->
let {a2' = realToFrac a2} in
btRigidBody_btRigidBodyConstructionInfo_m_additionalLinearDampingThresholdSqr_set'_ a1' a2' >>= \res ->
return ()
btRigidBody_btRigidBodyConstructionInfo_m_additionalLinearDampingThresholdSqr_get :: ( BtRigidBody_btRigidBodyConstructionInfoClass bc ) => bc -> IO (Float)
btRigidBody_btRigidBodyConstructionInfo_m_additionalLinearDampingThresholdSqr_get a1 =
withBt a1 $ \a1' ->
btRigidBody_btRigidBodyConstructionInfo_m_additionalLinearDampingThresholdSqr_get'_ a1' >>= \res ->
let {res' = realToFrac res} in
return (res')
btRigidBody_btRigidBodyConstructionInfo_m_angularDamping_set :: ( BtRigidBody_btRigidBodyConstructionInfoClass bc ) => bc -> Float -> IO ()
btRigidBody_btRigidBodyConstructionInfo_m_angularDamping_set a1 a2 =
withBt a1 $ \a1' ->
let {a2' = realToFrac a2} in
btRigidBody_btRigidBodyConstructionInfo_m_angularDamping_set'_ a1' a2' >>= \res ->
return ()
btRigidBody_btRigidBodyConstructionInfo_m_angularDamping_get :: ( BtRigidBody_btRigidBodyConstructionInfoClass bc ) => bc -> IO (Float)
btRigidBody_btRigidBodyConstructionInfo_m_angularDamping_get a1 =
withBt a1 $ \a1' ->
btRigidBody_btRigidBodyConstructionInfo_m_angularDamping_get'_ a1' >>= \res ->
let {res' = realToFrac res} in
return (res')
btRigidBody_btRigidBodyConstructionInfo_m_angularSleepingThreshold_set :: ( BtRigidBody_btRigidBodyConstructionInfoClass bc ) => bc -> Float -> IO ()
btRigidBody_btRigidBodyConstructionInfo_m_angularSleepingThreshold_set a1 a2 =
withBt a1 $ \a1' ->
let {a2' = realToFrac a2} in
btRigidBody_btRigidBodyConstructionInfo_m_angularSleepingThreshold_set'_ a1' a2' >>= \res ->
return ()
btRigidBody_btRigidBodyConstructionInfo_m_angularSleepingThreshold_get :: ( BtRigidBody_btRigidBodyConstructionInfoClass bc ) => bc -> IO (Float)
btRigidBody_btRigidBodyConstructionInfo_m_angularSleepingThreshold_get a1 =
withBt a1 $ \a1' ->
btRigidBody_btRigidBodyConstructionInfo_m_angularSleepingThreshold_get'_ a1' >>= \res ->
let {res' = realToFrac res} in
return (res')
btRigidBody_btRigidBodyConstructionInfo_m_collisionShape_set :: ( BtRigidBody_btRigidBodyConstructionInfoClass bc , BtCollisionShapeClass a ) => bc -> a -> IO ()
btRigidBody_btRigidBodyConstructionInfo_m_collisionShape_set a1 a2 =
withBt a1 $ \a1' ->
withBt a2 $ \a2' ->
btRigidBody_btRigidBodyConstructionInfo_m_collisionShape_set'_ a1' a2' >>= \res ->
return ()
btRigidBody_btRigidBodyConstructionInfo_m_collisionShape_get :: ( BtRigidBody_btRigidBodyConstructionInfoClass bc ) => bc -> IO (BtCollisionShape)
btRigidBody_btRigidBodyConstructionInfo_m_collisionShape_get a1 =
withBt a1 $ \a1' ->
btRigidBody_btRigidBodyConstructionInfo_m_collisionShape_get'_ a1' >>= \res ->
mkBtCollisionShape res >>= \res' ->
return (res')
btRigidBody_btRigidBodyConstructionInfo_m_friction_set :: ( BtRigidBody_btRigidBodyConstructionInfoClass bc ) => bc -> Float -> IO ()
btRigidBody_btRigidBodyConstructionInfo_m_friction_set a1 a2 =
withBt a1 $ \a1' ->
let {a2' = realToFrac a2} in
btRigidBody_btRigidBodyConstructionInfo_m_friction_set'_ a1' a2' >>= \res ->
return ()
btRigidBody_btRigidBodyConstructionInfo_m_friction_get :: ( BtRigidBody_btRigidBodyConstructionInfoClass bc ) => bc -> IO (Float)
btRigidBody_btRigidBodyConstructionInfo_m_friction_get a1 =
withBt a1 $ \a1' ->
btRigidBody_btRigidBodyConstructionInfo_m_friction_get'_ a1' >>= \res ->
let {res' = realToFrac res} in
return (res')
btRigidBody_btRigidBodyConstructionInfo_m_linearDamping_set :: ( BtRigidBody_btRigidBodyConstructionInfoClass bc ) => bc -> Float -> IO ()
btRigidBody_btRigidBodyConstructionInfo_m_linearDamping_set a1 a2 =
withBt a1 $ \a1' ->
let {a2' = realToFrac a2} in
btRigidBody_btRigidBodyConstructionInfo_m_linearDamping_set'_ a1' a2' >>= \res ->
return ()
btRigidBody_btRigidBodyConstructionInfo_m_linearDamping_get :: ( BtRigidBody_btRigidBodyConstructionInfoClass bc ) => bc -> IO (Float)
btRigidBody_btRigidBodyConstructionInfo_m_linearDamping_get a1 =
withBt a1 $ \a1' ->
btRigidBody_btRigidBodyConstructionInfo_m_linearDamping_get'_ a1' >>= \res ->
let {res' = realToFrac res} in
return (res')
btRigidBody_btRigidBodyConstructionInfo_m_linearSleepingThreshold_set :: ( BtRigidBody_btRigidBodyConstructionInfoClass bc ) => bc -> Float -> IO ()
btRigidBody_btRigidBodyConstructionInfo_m_linearSleepingThreshold_set a1 a2 =
withBt a1 $ \a1' ->
let {a2' = realToFrac a2} in
btRigidBody_btRigidBodyConstructionInfo_m_linearSleepingThreshold_set'_ a1' a2' >>= \res ->
return ()
btRigidBody_btRigidBodyConstructionInfo_m_linearSleepingThreshold_get :: ( BtRigidBody_btRigidBodyConstructionInfoClass bc ) => bc -> IO (Float)
btRigidBody_btRigidBodyConstructionInfo_m_linearSleepingThreshold_get a1 =
withBt a1 $ \a1' ->
btRigidBody_btRigidBodyConstructionInfo_m_linearSleepingThreshold_get'_ a1' >>= \res ->
let {res' = realToFrac res} in
return (res')
btRigidBody_btRigidBodyConstructionInfo_m_localInertia_set :: ( BtRigidBody_btRigidBodyConstructionInfoClass bc ) => bc -> Vec3 -> IO ()
btRigidBody_btRigidBodyConstructionInfo_m_localInertia_set a1 a2 =
withBt a1 $ \a1' ->
withVec3 a2 $ \a2' ->
btRigidBody_btRigidBodyConstructionInfo_m_localInertia_set'_ a1' a2' >>= \res ->
return ()
btRigidBody_btRigidBodyConstructionInfo_m_localInertia_get :: ( BtRigidBody_btRigidBodyConstructionInfoClass bc ) => bc -> IO (Vec3)
btRigidBody_btRigidBodyConstructionInfo_m_localInertia_get a1 =
withBt a1 $ \a1' ->
allocaVec3 $ \a2' ->
btRigidBody_btRigidBodyConstructionInfo_m_localInertia_get'_ a1' a2' >>= \res ->
peekVec3 a2'>>= \a2'' ->
return (a2'')
btRigidBody_btRigidBodyConstructionInfo_m_mass_set :: ( BtRigidBody_btRigidBodyConstructionInfoClass bc ) => bc -> Float -> IO ()
btRigidBody_btRigidBodyConstructionInfo_m_mass_set a1 a2 =
withBt a1 $ \a1' ->
let {a2' = realToFrac a2} in
btRigidBody_btRigidBodyConstructionInfo_m_mass_set'_ a1' a2' >>= \res ->
return ()
btRigidBody_btRigidBodyConstructionInfo_m_mass_get :: ( BtRigidBody_btRigidBodyConstructionInfoClass bc ) => bc -> IO (Float)
btRigidBody_btRigidBodyConstructionInfo_m_mass_get a1 =
withBt a1 $ \a1' ->
btRigidBody_btRigidBodyConstructionInfo_m_mass_get'_ a1' >>= \res ->
let {res' = realToFrac res} in
return (res')
btRigidBody_btRigidBodyConstructionInfo_m_motionState_set :: ( BtRigidBody_btRigidBodyConstructionInfoClass bc , BtMotionStateClass a ) => bc -> a -> IO ()
btRigidBody_btRigidBodyConstructionInfo_m_motionState_set a1 a2 =
withBt a1 $ \a1' ->
withBt a2 $ \a2' ->
btRigidBody_btRigidBodyConstructionInfo_m_motionState_set'_ a1' a2' >>= \res ->
return ()
btRigidBody_btRigidBodyConstructionInfo_m_motionState_get :: ( BtRigidBody_btRigidBodyConstructionInfoClass bc ) => bc -> IO (BtMotionState)
btRigidBody_btRigidBodyConstructionInfo_m_motionState_get a1 =
withBt a1 $ \a1' ->
btRigidBody_btRigidBodyConstructionInfo_m_motionState_get'_ a1' >>= \res ->
mkBtMotionState res >>= \res' ->
return (res')
btRigidBody_btRigidBodyConstructionInfo_m_restitution_set :: ( BtRigidBody_btRigidBodyConstructionInfoClass bc ) => bc -> Float -> IO ()
btRigidBody_btRigidBodyConstructionInfo_m_restitution_set a1 a2 =
withBt a1 $ \a1' ->
let {a2' = realToFrac a2} in
btRigidBody_btRigidBodyConstructionInfo_m_restitution_set'_ a1' a2' >>= \res ->
return ()
btRigidBody_btRigidBodyConstructionInfo_m_restitution_get :: ( BtRigidBody_btRigidBodyConstructionInfoClass bc ) => bc -> IO (Float)
btRigidBody_btRigidBodyConstructionInfo_m_restitution_get a1 =
withBt a1 $ \a1' ->
btRigidBody_btRigidBodyConstructionInfo_m_restitution_get'_ a1' >>= \res ->
let {res' = realToFrac res} in
return (res')
btRigidBody_btRigidBodyConstructionInfo_m_startWorldTransform_set :: ( BtRigidBody_btRigidBodyConstructionInfoClass bc ) => bc -> Transform -> IO ()
btRigidBody_btRigidBodyConstructionInfo_m_startWorldTransform_set a1 a2 =
withBt a1 $ \a1' ->
withTransform a2 $ \a2' ->
btRigidBody_btRigidBodyConstructionInfo_m_startWorldTransform_set'_ a1' a2' >>= \res ->
return ()
btRigidBody_btRigidBodyConstructionInfo_m_startWorldTransform_get :: ( BtRigidBody_btRigidBodyConstructionInfoClass bc ) => bc -> IO (Transform)
btRigidBody_btRigidBodyConstructionInfo_m_startWorldTransform_get a1 =
withBt a1 $ \a1' ->
allocaTransform $ \a2' ->
btRigidBody_btRigidBodyConstructionInfo_m_startWorldTransform_get'_ a1' a2' >>= \res ->
peekTransform a2'>>= \a2'' ->
return (a2'')
btRigidBodyDoubleData :: IO (BtRigidBodyDoubleData)
btRigidBodyDoubleData =
btRigidBodyDoubleData'_ >>= \res ->
mkBtRigidBodyDoubleData res >>= \res' ->
return (res')
btRigidBodyDoubleData_free :: ( BtRigidBodyDoubleDataClass bc ) => bc -> IO ()
btRigidBodyDoubleData_free a1 =
withBt a1 $ \a1' ->
btRigidBodyDoubleData_free'_ a1' >>= \res ->
return ()
btRigidBodyDoubleData_m_collisionObjectData_set :: ( BtRigidBodyDoubleDataClass bc , BtCollisionObjectDoubleDataClass a ) => bc -> a -> IO ()
btRigidBodyDoubleData_m_collisionObjectData_set a1 a2 =
withBt a1 $ \a1' ->
withBt a2 $ \a2' ->
btRigidBodyDoubleData_m_collisionObjectData_set'_ a1' a2' >>= \res ->
return ()
btRigidBodyDoubleData_m_collisionObjectData_get :: ( BtRigidBodyDoubleDataClass bc ) => bc -> IO (BtCollisionObjectDoubleData)
btRigidBodyDoubleData_m_collisionObjectData_get a1 =
withBt a1 $ \a1' ->
btRigidBodyDoubleData_m_collisionObjectData_get'_ a1' >>= \res ->
mkBtCollisionObjectDoubleData res >>= \res' ->
return (res')
btRigidBodyDoubleData_m_invInertiaTensorWorld_set :: ( BtRigidBodyDoubleDataClass bc , BtMatrix3x3DoubleDataClass a ) => bc -> a -> IO ()
btRigidBodyDoubleData_m_invInertiaTensorWorld_set a1 a2 =
withBt a1 $ \a1' ->
withBt a2 $ \a2' ->
btRigidBodyDoubleData_m_invInertiaTensorWorld_set'_ a1' a2' >>= \res ->
return ()
btRigidBodyDoubleData_m_invInertiaTensorWorld_get :: ( BtRigidBodyDoubleDataClass bc ) => bc -> IO (BtMatrix3x3DoubleData)
btRigidBodyDoubleData_m_invInertiaTensorWorld_get a1 =
withBt a1 $ \a1' ->
btRigidBodyDoubleData_m_invInertiaTensorWorld_get'_ a1' >>= \res ->
mkBtMatrix3x3DoubleData res >>= \res' ->
return (res')
btRigidBodyDoubleData_m_linearVelocity_set :: ( BtRigidBodyDoubleDataClass bc , BtVector3DoubleDataClass a ) => bc -> a -> IO ()
btRigidBodyDoubleData_m_linearVelocity_set a1 a2 =
withBt a1 $ \a1' ->
withBt a2 $ \a2' ->
btRigidBodyDoubleData_m_linearVelocity_set'_ a1' a2' >>= \res ->
return ()
btRigidBodyDoubleData_m_linearVelocity_get :: ( BtRigidBodyDoubleDataClass bc ) => bc -> IO (BtVector3DoubleData)
btRigidBodyDoubleData_m_linearVelocity_get a1 =
withBt a1 $ \a1' ->
btRigidBodyDoubleData_m_linearVelocity_get'_ a1' >>= \res ->
mkBtVector3DoubleData res >>= \res' ->
return (res')
btRigidBodyDoubleData_m_angularVelocity_set :: ( BtRigidBodyDoubleDataClass bc , BtVector3DoubleDataClass a ) => bc -> a -> IO ()
btRigidBodyDoubleData_m_angularVelocity_set a1 a2 =
withBt a1 $ \a1' ->
withBt a2 $ \a2' ->
btRigidBodyDoubleData_m_angularVelocity_set'_ a1' a2' >>= \res ->
return ()
btRigidBodyDoubleData_m_angularVelocity_get :: ( BtRigidBodyDoubleDataClass bc ) => bc -> IO (BtVector3DoubleData)
btRigidBodyDoubleData_m_angularVelocity_get a1 =
withBt a1 $ \a1' ->
btRigidBodyDoubleData_m_angularVelocity_get'_ a1' >>= \res ->
mkBtVector3DoubleData res >>= \res' ->
return (res')
btRigidBodyDoubleData_m_angularFactor_set :: ( BtRigidBodyDoubleDataClass bc , BtVector3DoubleDataClass a ) => bc -> a -> IO ()
btRigidBodyDoubleData_m_angularFactor_set a1 a2 =
withBt a1 $ \a1' ->
withBt a2 $ \a2' ->
btRigidBodyDoubleData_m_angularFactor_set'_ a1' a2' >>= \res ->
return ()
btRigidBodyDoubleData_m_angularFactor_get :: ( BtRigidBodyDoubleDataClass bc ) => bc -> IO (BtVector3DoubleData)
btRigidBodyDoubleData_m_angularFactor_get a1 =
withBt a1 $ \a1' ->
btRigidBodyDoubleData_m_angularFactor_get'_ a1' >>= \res ->
mkBtVector3DoubleData res >>= \res' ->
return (res')
btRigidBodyDoubleData_m_linearFactor_set :: ( BtRigidBodyDoubleDataClass bc , BtVector3DoubleDataClass a ) => bc -> a -> IO ()
btRigidBodyDoubleData_m_linearFactor_set a1 a2 =
withBt a1 $ \a1' ->
withBt a2 $ \a2' ->
btRigidBodyDoubleData_m_linearFactor_set'_ a1' a2' >>= \res ->
return ()
btRigidBodyDoubleData_m_linearFactor_get :: ( BtRigidBodyDoubleDataClass bc ) => bc -> IO (BtVector3DoubleData)
btRigidBodyDoubleData_m_linearFactor_get a1 =
withBt a1 $ \a1' ->
btRigidBodyDoubleData_m_linearFactor_get'_ a1' >>= \res ->
mkBtVector3DoubleData res >>= \res' ->
return (res')
btRigidBodyDoubleData_m_gravity_set :: ( BtRigidBodyDoubleDataClass bc , BtVector3DoubleDataClass a ) => bc -> a -> IO ()
btRigidBodyDoubleData_m_gravity_set a1 a2 =
withBt a1 $ \a1' ->
withBt a2 $ \a2' ->
btRigidBodyDoubleData_m_gravity_set'_ a1' a2' >>= \res ->
return ()
btRigidBodyDoubleData_m_gravity_get :: ( BtRigidBodyDoubleDataClass bc ) => bc -> IO (BtVector3DoubleData)
btRigidBodyDoubleData_m_gravity_get a1 =
withBt a1 $ \a1' ->
btRigidBodyDoubleData_m_gravity_get'_ a1' >>= \res ->
mkBtVector3DoubleData res >>= \res' ->
return (res')
btRigidBodyDoubleData_m_gravity_acceleration_set :: ( BtRigidBodyDoubleDataClass bc , BtVector3DoubleDataClass a ) => bc -> a -> IO ()
btRigidBodyDoubleData_m_gravity_acceleration_set a1 a2 =
withBt a1 $ \a1' ->
withBt a2 $ \a2' ->
btRigidBodyDoubleData_m_gravity_acceleration_set'_ a1' a2' >>= \res ->
return ()
btRigidBodyDoubleData_m_gravity_acceleration_get :: ( BtRigidBodyDoubleDataClass bc ) => bc -> IO (BtVector3DoubleData)
btRigidBodyDoubleData_m_gravity_acceleration_get a1 =
withBt a1 $ \a1' ->
btRigidBodyDoubleData_m_gravity_acceleration_get'_ a1' >>= \res ->
mkBtVector3DoubleData res >>= \res' ->
return (res')
btRigidBodyDoubleData_m_invInertiaLocal_set :: ( BtRigidBodyDoubleDataClass bc , BtVector3DoubleDataClass a ) => bc -> a -> IO ()
btRigidBodyDoubleData_m_invInertiaLocal_set a1 a2 =
withBt a1 $ \a1' ->
withBt a2 $ \a2' ->
btRigidBodyDoubleData_m_invInertiaLocal_set'_ a1' a2' >>= \res ->
return ()
btRigidBodyDoubleData_m_invInertiaLocal_get :: ( BtRigidBodyDoubleDataClass bc ) => bc -> IO (BtVector3DoubleData)
btRigidBodyDoubleData_m_invInertiaLocal_get a1 =
withBt a1 $ \a1' ->
btRigidBodyDoubleData_m_invInertiaLocal_get'_ a1' >>= \res ->
mkBtVector3DoubleData res >>= \res' ->
return (res')
btRigidBodyDoubleData_m_totalForce_set :: ( BtRigidBodyDoubleDataClass bc , BtVector3DoubleDataClass a ) => bc -> a -> IO ()
btRigidBodyDoubleData_m_totalForce_set a1 a2 =
withBt a1 $ \a1' ->
withBt a2 $ \a2' ->
btRigidBodyDoubleData_m_totalForce_set'_ a1' a2' >>= \res ->
return ()
btRigidBodyDoubleData_m_totalForce_get :: ( BtRigidBodyDoubleDataClass bc ) => bc -> IO (BtVector3DoubleData)
btRigidBodyDoubleData_m_totalForce_get a1 =
withBt a1 $ \a1' ->
btRigidBodyDoubleData_m_totalForce_get'_ a1' >>= \res ->
mkBtVector3DoubleData res >>= \res' ->
return (res')
btRigidBodyDoubleData_m_totalTorque_set :: ( BtRigidBodyDoubleDataClass bc , BtVector3DoubleDataClass a ) => bc -> a -> IO ()
btRigidBodyDoubleData_m_totalTorque_set a1 a2 =
withBt a1 $ \a1' ->
withBt a2 $ \a2' ->
btRigidBodyDoubleData_m_totalTorque_set'_ a1' a2' >>= \res ->
return ()
btRigidBodyDoubleData_m_totalTorque_get :: ( BtRigidBodyDoubleDataClass bc ) => bc -> IO (BtVector3DoubleData)
btRigidBodyDoubleData_m_totalTorque_get a1 =
withBt a1 $ \a1' ->
btRigidBodyDoubleData_m_totalTorque_get'_ a1' >>= \res ->
mkBtVector3DoubleData res >>= \res' ->
return (res')
btRigidBodyDoubleData_m_inverseMass_set :: ( BtRigidBodyDoubleDataClass bc ) => bc -> Double -> IO ()
btRigidBodyDoubleData_m_inverseMass_set a1 a2 =
withBt a1 $ \a1' ->
let {a2' = realToFrac a2} in
btRigidBodyDoubleData_m_inverseMass_set'_ a1' a2' >>= \res ->
return ()
btRigidBodyDoubleData_m_inverseMass_get :: ( BtRigidBodyDoubleDataClass bc ) => bc -> IO (Double)
btRigidBodyDoubleData_m_inverseMass_get a1 =
withBt a1 $ \a1' ->
btRigidBodyDoubleData_m_inverseMass_get'_ a1' >>= \res ->
let {res' = realToFrac res} in
return (res')
btRigidBodyDoubleData_m_linearDamping_set :: ( BtRigidBodyDoubleDataClass bc ) => bc -> Double -> IO ()
btRigidBodyDoubleData_m_linearDamping_set a1 a2 =
withBt a1 $ \a1' ->
let {a2' = realToFrac a2} in
btRigidBodyDoubleData_m_linearDamping_set'_ a1' a2' >>= \res ->
return ()
btRigidBodyDoubleData_m_linearDamping_get :: ( BtRigidBodyDoubleDataClass bc ) => bc -> IO (Double)
btRigidBodyDoubleData_m_linearDamping_get a1 =
withBt a1 $ \a1' ->
btRigidBodyDoubleData_m_linearDamping_get'_ a1' >>= \res ->
let {res' = realToFrac res} in
return (res')
btRigidBodyDoubleData_m_angularDamping_set :: ( BtRigidBodyDoubleDataClass bc ) => bc -> Double -> IO ()
btRigidBodyDoubleData_m_angularDamping_set a1 a2 =
withBt a1 $ \a1' ->
let {a2' = realToFrac a2} in
btRigidBodyDoubleData_m_angularDamping_set'_ a1' a2' >>= \res ->
return ()
btRigidBodyDoubleData_m_angularDamping_get :: ( BtRigidBodyDoubleDataClass bc ) => bc -> IO (Double)
btRigidBodyDoubleData_m_angularDamping_get a1 =
withBt a1 $ \a1' ->
btRigidBodyDoubleData_m_angularDamping_get'_ a1' >>= \res ->
let {res' = realToFrac res} in
return (res')
btRigidBodyDoubleData_m_additionalDampingFactor_set :: ( BtRigidBodyDoubleDataClass bc ) => bc -> Double -> IO ()
btRigidBodyDoubleData_m_additionalDampingFactor_set a1 a2 =
withBt a1 $ \a1' ->
let {a2' = realToFrac a2} in
btRigidBodyDoubleData_m_additionalDampingFactor_set'_ a1' a2' >>= \res ->
return ()
btRigidBodyDoubleData_m_additionalDampingFactor_get :: ( BtRigidBodyDoubleDataClass bc ) => bc -> IO (Double)
btRigidBodyDoubleData_m_additionalDampingFactor_get a1 =
withBt a1 $ \a1' ->
btRigidBodyDoubleData_m_additionalDampingFactor_get'_ a1' >>= \res ->
let {res' = realToFrac res} in
return (res')
btRigidBodyDoubleData_m_additionalLinearDampingThresholdSqr_set :: ( BtRigidBodyDoubleDataClass bc ) => bc -> Double -> IO ()
btRigidBodyDoubleData_m_additionalLinearDampingThresholdSqr_set a1 a2 =
withBt a1 $ \a1' ->
let {a2' = realToFrac a2} in
btRigidBodyDoubleData_m_additionalLinearDampingThresholdSqr_set'_ a1' a2' >>= \res ->
return ()
btRigidBodyDoubleData_m_additionalLinearDampingThresholdSqr_get :: ( BtRigidBodyDoubleDataClass bc ) => bc -> IO (Double)
btRigidBodyDoubleData_m_additionalLinearDampingThresholdSqr_get a1 =
withBt a1 $ \a1' ->
btRigidBodyDoubleData_m_additionalLinearDampingThresholdSqr_get'_ a1' >>= \res ->
let {res' = realToFrac res} in
return (res')
btRigidBodyDoubleData_m_additionalAngularDampingThresholdSqr_set :: ( BtRigidBodyDoubleDataClass bc ) => bc -> Double -> IO ()
btRigidBodyDoubleData_m_additionalAngularDampingThresholdSqr_set a1 a2 =
withBt a1 $ \a1' ->
let {a2' = realToFrac a2} in
btRigidBodyDoubleData_m_additionalAngularDampingThresholdSqr_set'_ a1' a2' >>= \res ->
return ()
btRigidBodyDoubleData_m_additionalAngularDampingThresholdSqr_get :: ( BtRigidBodyDoubleDataClass bc ) => bc -> IO (Double)
btRigidBodyDoubleData_m_additionalAngularDampingThresholdSqr_get a1 =
withBt a1 $ \a1' ->
btRigidBodyDoubleData_m_additionalAngularDampingThresholdSqr_get'_ a1' >>= \res ->
let {res' = realToFrac res} in
return (res')
btRigidBodyDoubleData_m_additionalAngularDampingFactor_set :: ( BtRigidBodyDoubleDataClass bc ) => bc -> Double -> IO ()
btRigidBodyDoubleData_m_additionalAngularDampingFactor_set a1 a2 =
withBt a1 $ \a1' ->
let {a2' = realToFrac a2} in
btRigidBodyDoubleData_m_additionalAngularDampingFactor_set'_ a1' a2' >>= \res ->
return ()
btRigidBodyDoubleData_m_additionalAngularDampingFactor_get :: ( BtRigidBodyDoubleDataClass bc ) => bc -> IO (Double)
btRigidBodyDoubleData_m_additionalAngularDampingFactor_get a1 =
withBt a1 $ \a1' ->
btRigidBodyDoubleData_m_additionalAngularDampingFactor_get'_ a1' >>= \res ->
let {res' = realToFrac res} in
return (res')
btRigidBodyDoubleData_m_linearSleepingThreshold_set :: ( BtRigidBodyDoubleDataClass bc ) => bc -> Double -> IO ()
btRigidBodyDoubleData_m_linearSleepingThreshold_set a1 a2 =
withBt a1 $ \a1' ->
let {a2' = realToFrac a2} in
btRigidBodyDoubleData_m_linearSleepingThreshold_set'_ a1' a2' >>= \res ->
return ()
btRigidBodyDoubleData_m_linearSleepingThreshold_get :: ( BtRigidBodyDoubleDataClass bc ) => bc -> IO (Double)
btRigidBodyDoubleData_m_linearSleepingThreshold_get a1 =
withBt a1 $ \a1' ->
btRigidBodyDoubleData_m_linearSleepingThreshold_get'_ a1' >>= \res ->
let {res' = realToFrac res} in
return (res')
btRigidBodyDoubleData_m_angularSleepingThreshold_set :: ( BtRigidBodyDoubleDataClass bc ) => bc -> Double -> IO ()
btRigidBodyDoubleData_m_angularSleepingThreshold_set a1 a2 =
withBt a1 $ \a1' ->
let {a2' = realToFrac a2} in
btRigidBodyDoubleData_m_angularSleepingThreshold_set'_ a1' a2' >>= \res ->
return ()
btRigidBodyDoubleData_m_angularSleepingThreshold_get :: ( BtRigidBodyDoubleDataClass bc ) => bc -> IO (Double)
btRigidBodyDoubleData_m_angularSleepingThreshold_get a1 =
withBt a1 $ \a1' ->
btRigidBodyDoubleData_m_angularSleepingThreshold_get'_ a1' >>= \res ->
let {res' = realToFrac res} in
return (res')
btRigidBodyDoubleData_m_additionalDamping_set :: ( BtRigidBodyDoubleDataClass bc ) => bc -> Int -> IO ()
btRigidBodyDoubleData_m_additionalDamping_set a1 a2 =
withBt a1 $ \a1' ->
let {a2' = fromIntegral a2} in
btRigidBodyDoubleData_m_additionalDamping_set'_ a1' a2' >>= \res ->
return ()
btRigidBodyDoubleData_m_additionalDamping_get :: ( BtRigidBodyDoubleDataClass bc ) => bc -> IO (Int)
btRigidBodyDoubleData_m_additionalDamping_get a1 =
withBt a1 $ \a1' ->
btRigidBodyDoubleData_m_additionalDamping_get'_ a1' >>= \res ->
let {res' = fromIntegral res} in
return (res')
btRigidBodyFloatData :: IO (BtRigidBodyFloatData)
btRigidBodyFloatData =
btRigidBodyFloatData'_ >>= \res ->
mkBtRigidBodyFloatData res >>= \res' ->
return (res')
btRigidBodyFloatData_free :: ( BtRigidBodyFloatDataClass bc ) => bc -> IO ()
btRigidBodyFloatData_free a1 =
withBt a1 $ \a1' ->
btRigidBodyFloatData_free'_ a1' >>= \res ->
return ()
btRigidBodyFloatData_m_additionalAngularDampingFactor_set :: ( BtRigidBodyFloatDataClass bc ) => bc -> Float -> IO ()
btRigidBodyFloatData_m_additionalAngularDampingFactor_set a1 a2 =
withBt a1 $ \a1' ->
let {a2' = realToFrac a2} in
btRigidBodyFloatData_m_additionalAngularDampingFactor_set'_ a1' a2' >>= \res ->
return ()
btRigidBodyFloatData_m_additionalAngularDampingFactor_get :: ( BtRigidBodyFloatDataClass bc ) => bc -> IO (Float)
btRigidBodyFloatData_m_additionalAngularDampingFactor_get a1 =
withBt a1 $ \a1' ->
btRigidBodyFloatData_m_additionalAngularDampingFactor_get'_ a1' >>= \res ->
let {res' = realToFrac res} in
return (res')
btRigidBodyFloatData_m_additionalAngularDampingThresholdSqr_set :: ( BtRigidBodyFloatDataClass bc ) => bc -> Float -> IO ()
btRigidBodyFloatData_m_additionalAngularDampingThresholdSqr_set a1 a2 =
withBt a1 $ \a1' ->
let {a2' = realToFrac a2} in
btRigidBodyFloatData_m_additionalAngularDampingThresholdSqr_set'_ a1' a2' >>= \res ->
return ()
btRigidBodyFloatData_m_additionalAngularDampingThresholdSqr_get :: ( BtRigidBodyFloatDataClass bc ) => bc -> IO (Float)
btRigidBodyFloatData_m_additionalAngularDampingThresholdSqr_get a1 =
withBt a1 $ \a1' ->
btRigidBodyFloatData_m_additionalAngularDampingThresholdSqr_get'_ a1' >>= \res ->
let {res' = realToFrac res} in
return (res')
btRigidBodyFloatData_m_additionalDamping_set :: ( BtRigidBodyFloatDataClass bc ) => bc -> Int -> IO ()
btRigidBodyFloatData_m_additionalDamping_set a1 a2 =
withBt a1 $ \a1' ->
let {a2' = fromIntegral a2} in
btRigidBodyFloatData_m_additionalDamping_set'_ a1' a2' >>= \res ->
return ()
btRigidBodyFloatData_m_additionalDamping_get :: ( BtRigidBodyFloatDataClass bc ) => bc -> IO (Int)
btRigidBodyFloatData_m_additionalDamping_get a1 =
withBt a1 $ \a1' ->
btRigidBodyFloatData_m_additionalDamping_get'_ a1' >>= \res ->
let {res' = fromIntegral res} in
return (res')
btRigidBodyFloatData_m_additionalDampingFactor_set :: ( BtRigidBodyFloatDataClass bc ) => bc -> Float -> IO ()
btRigidBodyFloatData_m_additionalDampingFactor_set a1 a2 =
withBt a1 $ \a1' ->
let {a2' = realToFrac a2} in
btRigidBodyFloatData_m_additionalDampingFactor_set'_ a1' a2' >>= \res ->
return ()
btRigidBodyFloatData_m_additionalDampingFactor_get :: ( BtRigidBodyFloatDataClass bc ) => bc -> IO (Float)
btRigidBodyFloatData_m_additionalDampingFactor_get a1 =
withBt a1 $ \a1' ->
btRigidBodyFloatData_m_additionalDampingFactor_get'_ a1' >>= \res ->
let {res' = realToFrac res} in
return (res')
btRigidBodyFloatData_m_additionalLinearDampingThresholdSqr_set :: ( BtRigidBodyFloatDataClass bc ) => bc -> Float -> IO ()
btRigidBodyFloatData_m_additionalLinearDampingThresholdSqr_set a1 a2 =
withBt a1 $ \a1' ->
let {a2' = realToFrac a2} in
btRigidBodyFloatData_m_additionalLinearDampingThresholdSqr_set'_ a1' a2' >>= \res ->
return ()
btRigidBodyFloatData_m_additionalLinearDampingThresholdSqr_get :: ( BtRigidBodyFloatDataClass bc ) => bc -> IO (Float)
btRigidBodyFloatData_m_additionalLinearDampingThresholdSqr_get a1 =
withBt a1 $ \a1' ->
btRigidBodyFloatData_m_additionalLinearDampingThresholdSqr_get'_ a1' >>= \res ->
let {res' = realToFrac res} in
return (res')
btRigidBodyFloatData_m_angularDamping_set :: ( BtRigidBodyFloatDataClass bc ) => bc -> Float -> IO ()
btRigidBodyFloatData_m_angularDamping_set a1 a2 =
withBt a1 $ \a1' ->
let {a2' = realToFrac a2} in
btRigidBodyFloatData_m_angularDamping_set'_ a1' a2' >>= \res ->
return ()
btRigidBodyFloatData_m_angularDamping_get :: ( BtRigidBodyFloatDataClass bc ) => bc -> IO (Float)
btRigidBodyFloatData_m_angularDamping_get a1 =
withBt a1 $ \a1' ->
btRigidBodyFloatData_m_angularDamping_get'_ a1' >>= \res ->
let {res' = realToFrac res} in
return (res')
btRigidBodyFloatData_m_angularFactor_set :: ( BtRigidBodyFloatDataClass bc , BtVector3FloatDataClass a ) => bc -> a -> IO ()
btRigidBodyFloatData_m_angularFactor_set a1 a2 =
withBt a1 $ \a1' ->
withBt a2 $ \a2' ->
btRigidBodyFloatData_m_angularFactor_set'_ a1' a2' >>= \res ->
return ()
btRigidBodyFloatData_m_angularFactor_get :: ( BtRigidBodyFloatDataClass bc ) => bc -> IO (BtVector3FloatData)
btRigidBodyFloatData_m_angularFactor_get a1 =
withBt a1 $ \a1' ->
btRigidBodyFloatData_m_angularFactor_get'_ a1' >>= \res ->
mkBtVector3FloatData res >>= \res' ->
return (res')
btRigidBodyFloatData_m_angularSleepingThreshold_set :: ( BtRigidBodyFloatDataClass bc ) => bc -> Float -> IO ()
btRigidBodyFloatData_m_angularSleepingThreshold_set a1 a2 =
withBt a1 $ \a1' ->
let {a2' = realToFrac a2} in
btRigidBodyFloatData_m_angularSleepingThreshold_set'_ a1' a2' >>= \res ->
return ()
btRigidBodyFloatData_m_angularSleepingThreshold_get :: ( BtRigidBodyFloatDataClass bc ) => bc -> IO (Float)
btRigidBodyFloatData_m_angularSleepingThreshold_get a1 =
withBt a1 $ \a1' ->
btRigidBodyFloatData_m_angularSleepingThreshold_get'_ a1' >>= \res ->
let {res' = realToFrac res} in
return (res')
btRigidBodyFloatData_m_angularVelocity_set :: ( BtRigidBodyFloatDataClass bc , BtVector3FloatDataClass a ) => bc -> a -> IO ()
btRigidBodyFloatData_m_angularVelocity_set a1 a2 =
withBt a1 $ \a1' ->
withBt a2 $ \a2' ->
btRigidBodyFloatData_m_angularVelocity_set'_ a1' a2' >>= \res ->
return ()
btRigidBodyFloatData_m_angularVelocity_get :: ( BtRigidBodyFloatDataClass bc ) => bc -> IO (BtVector3FloatData)
btRigidBodyFloatData_m_angularVelocity_get a1 =
withBt a1 $ \a1' ->
btRigidBodyFloatData_m_angularVelocity_get'_ a1' >>= \res ->
mkBtVector3FloatData res >>= \res' ->
return (res')
btRigidBodyFloatData_m_collisionObjectData_set :: ( BtRigidBodyFloatDataClass bc , BtCollisionObjectFloatDataClass a ) => bc -> a -> IO ()
btRigidBodyFloatData_m_collisionObjectData_set a1 a2 =
withBt a1 $ \a1' ->
withBt a2 $ \a2' ->
btRigidBodyFloatData_m_collisionObjectData_set'_ a1' a2' >>= \res ->
return ()
btRigidBodyFloatData_m_collisionObjectData_get :: ( BtRigidBodyFloatDataClass bc ) => bc -> IO (BtCollisionObjectFloatData)
btRigidBodyFloatData_m_collisionObjectData_get a1 =
withBt a1 $ \a1' ->
btRigidBodyFloatData_m_collisionObjectData_get'_ a1' >>= \res ->
mkBtCollisionObjectFloatData res >>= \res' ->
return (res')
btRigidBodyFloatData_m_gravity_set :: ( BtRigidBodyFloatDataClass bc , BtVector3FloatDataClass a ) => bc -> a -> IO ()
btRigidBodyFloatData_m_gravity_set a1 a2 =
withBt a1 $ \a1' ->
withBt a2 $ \a2' ->
btRigidBodyFloatData_m_gravity_set'_ a1' a2' >>= \res ->
return ()
btRigidBodyFloatData_m_gravity_get :: ( BtRigidBodyFloatDataClass bc ) => bc -> IO (BtVector3FloatData)
btRigidBodyFloatData_m_gravity_get a1 =
withBt a1 $ \a1' ->
btRigidBodyFloatData_m_gravity_get'_ a1' >>= \res ->
mkBtVector3FloatData res >>= \res' ->
return (res')
btRigidBodyFloatData_m_gravity_acceleration_set :: ( BtRigidBodyFloatDataClass bc , BtVector3FloatDataClass a ) => bc -> a -> IO ()
btRigidBodyFloatData_m_gravity_acceleration_set a1 a2 =
withBt a1 $ \a1' ->
withBt a2 $ \a2' ->
btRigidBodyFloatData_m_gravity_acceleration_set'_ a1' a2' >>= \res ->
return ()
btRigidBodyFloatData_m_gravity_acceleration_get :: ( BtRigidBodyFloatDataClass bc ) => bc -> IO (BtVector3FloatData)
btRigidBodyFloatData_m_gravity_acceleration_get a1 =
withBt a1 $ \a1' ->
btRigidBodyFloatData_m_gravity_acceleration_get'_ a1' >>= \res ->
mkBtVector3FloatData res >>= \res' ->
return (res')
btRigidBodyFloatData_m_invInertiaLocal_set :: ( BtRigidBodyFloatDataClass bc , BtVector3FloatDataClass a ) => bc -> a -> IO ()
btRigidBodyFloatData_m_invInertiaLocal_set a1 a2 =
withBt a1 $ \a1' ->
withBt a2 $ \a2' ->
btRigidBodyFloatData_m_invInertiaLocal_set'_ a1' a2' >>= \res ->
return ()
btRigidBodyFloatData_m_invInertiaLocal_get :: ( BtRigidBodyFloatDataClass bc ) => bc -> IO (BtVector3FloatData)
btRigidBodyFloatData_m_invInertiaLocal_get a1 =
withBt a1 $ \a1' ->
btRigidBodyFloatData_m_invInertiaLocal_get'_ a1' >>= \res ->
mkBtVector3FloatData res >>= \res' ->
return (res')
btRigidBodyFloatData_m_invInertiaTensorWorld_set :: ( BtRigidBodyFloatDataClass bc , BtMatrix3x3FloatDataClass a ) => bc -> a -> IO ()
btRigidBodyFloatData_m_invInertiaTensorWorld_set a1 a2 =
withBt a1 $ \a1' ->
withBt a2 $ \a2' ->
btRigidBodyFloatData_m_invInertiaTensorWorld_set'_ a1' a2' >>= \res ->
return ()
btRigidBodyFloatData_m_invInertiaTensorWorld_get :: ( BtRigidBodyFloatDataClass bc ) => bc -> IO (BtMatrix3x3FloatData)
btRigidBodyFloatData_m_invInertiaTensorWorld_get a1 =
withBt a1 $ \a1' ->
btRigidBodyFloatData_m_invInertiaTensorWorld_get'_ a1' >>= \res ->
mkBtMatrix3x3FloatData res >>= \res' ->
return (res')
btRigidBodyFloatData_m_inverseMass_set :: ( BtRigidBodyFloatDataClass bc ) => bc -> Float -> IO ()
btRigidBodyFloatData_m_inverseMass_set a1 a2 =
withBt a1 $ \a1' ->
let {a2' = realToFrac a2} in
btRigidBodyFloatData_m_inverseMass_set'_ a1' a2' >>= \res ->
return ()
btRigidBodyFloatData_m_inverseMass_get :: ( BtRigidBodyFloatDataClass bc ) => bc -> IO (Float)
btRigidBodyFloatData_m_inverseMass_get a1 =
withBt a1 $ \a1' ->
btRigidBodyFloatData_m_inverseMass_get'_ a1' >>= \res ->
let {res' = realToFrac res} in
return (res')
btRigidBodyFloatData_m_linearDamping_set :: ( BtRigidBodyFloatDataClass bc ) => bc -> Float -> IO ()
btRigidBodyFloatData_m_linearDamping_set a1 a2 =
withBt a1 $ \a1' ->
let {a2' = realToFrac a2} in
btRigidBodyFloatData_m_linearDamping_set'_ a1' a2' >>= \res ->
return ()
btRigidBodyFloatData_m_linearDamping_get :: ( BtRigidBodyFloatDataClass bc ) => bc -> IO (Float)
btRigidBodyFloatData_m_linearDamping_get a1 =
withBt a1 $ \a1' ->
btRigidBodyFloatData_m_linearDamping_get'_ a1' >>= \res ->
let {res' = realToFrac res} in
return (res')
btRigidBodyFloatData_m_linearFactor_set :: ( BtRigidBodyFloatDataClass bc , BtVector3FloatDataClass a ) => bc -> a -> IO ()
btRigidBodyFloatData_m_linearFactor_set a1 a2 =
withBt a1 $ \a1' ->
withBt a2 $ \a2' ->
btRigidBodyFloatData_m_linearFactor_set'_ a1' a2' >>= \res ->
return ()
btRigidBodyFloatData_m_linearFactor_get :: ( BtRigidBodyFloatDataClass bc ) => bc -> IO (BtVector3FloatData)
btRigidBodyFloatData_m_linearFactor_get a1 =
withBt a1 $ \a1' ->
btRigidBodyFloatData_m_linearFactor_get'_ a1' >>= \res ->
mkBtVector3FloatData res >>= \res' ->
return (res')
btRigidBodyFloatData_m_linearSleepingThreshold_set :: ( BtRigidBodyFloatDataClass bc ) => bc -> Float -> IO ()
btRigidBodyFloatData_m_linearSleepingThreshold_set a1 a2 =
withBt a1 $ \a1' ->
let {a2' = realToFrac a2} in
btRigidBodyFloatData_m_linearSleepingThreshold_set'_ a1' a2' >>= \res ->
return ()
btRigidBodyFloatData_m_linearSleepingThreshold_get :: ( BtRigidBodyFloatDataClass bc ) => bc -> IO (Float)
btRigidBodyFloatData_m_linearSleepingThreshold_get a1 =
withBt a1 $ \a1' ->
btRigidBodyFloatData_m_linearSleepingThreshold_get'_ a1' >>= \res ->
let {res' = realToFrac res} in
return (res')
btRigidBodyFloatData_m_linearVelocity_set :: ( BtRigidBodyFloatDataClass bc , BtVector3FloatDataClass a ) => bc -> a -> IO ()
btRigidBodyFloatData_m_linearVelocity_set a1 a2 =
withBt a1 $ \a1' ->
withBt a2 $ \a2' ->
btRigidBodyFloatData_m_linearVelocity_set'_ a1' a2' >>= \res ->
return ()
btRigidBodyFloatData_m_linearVelocity_get :: ( BtRigidBodyFloatDataClass bc ) => bc -> IO (BtVector3FloatData)
btRigidBodyFloatData_m_linearVelocity_get a1 =
withBt a1 $ \a1' ->
btRigidBodyFloatData_m_linearVelocity_get'_ a1' >>= \res ->
mkBtVector3FloatData res >>= \res' ->
return (res')
btRigidBodyFloatData_m_totalForce_set :: ( BtRigidBodyFloatDataClass bc , BtVector3FloatDataClass a ) => bc -> a -> IO ()
btRigidBodyFloatData_m_totalForce_set a1 a2 =
withBt a1 $ \a1' ->
withBt a2 $ \a2' ->
btRigidBodyFloatData_m_totalForce_set'_ a1' a2' >>= \res ->
return ()
btRigidBodyFloatData_m_totalForce_get :: ( BtRigidBodyFloatDataClass bc ) => bc -> IO (BtVector3FloatData)
btRigidBodyFloatData_m_totalForce_get a1 =
withBt a1 $ \a1' ->
btRigidBodyFloatData_m_totalForce_get'_ a1' >>= \res ->
mkBtVector3FloatData res >>= \res' ->
return (res')
btRigidBodyFloatData_m_totalTorque_set :: ( BtRigidBodyFloatDataClass bc , BtVector3FloatDataClass a ) => bc -> a -> IO ()
btRigidBodyFloatData_m_totalTorque_set a1 a2 =
withBt a1 $ \a1' ->
withBt a2 $ \a2' ->
btRigidBodyFloatData_m_totalTorque_set'_ a1' a2' >>= \res ->
return ()
btRigidBodyFloatData_m_totalTorque_get :: ( BtRigidBodyFloatDataClass bc ) => bc -> IO (BtVector3FloatData)
btRigidBodyFloatData_m_totalTorque_get a1 =
withBt a1 $ \a1' ->
btRigidBodyFloatData_m_totalTorque_get'_ a1' >>= \res ->
mkBtVector3FloatData res >>= \res' ->
return (res')
btSimpleDynamicsWorld :: ( BtDispatcherClass p0 , BtBroadphaseInterfaceClass p1 , BtConstraintSolverClass p2 , BtCollisionConfigurationClass p3 ) => p0 -> p1 -> p2 -> p3 -> IO (BtSimpleDynamicsWorld)
btSimpleDynamicsWorld a1 a2 a3 a4 =
withBt a1 $ \a1' ->
withBt a2 $ \a2' ->
withBt a3 $ \a3' ->
withBt a4 $ \a4' ->
btSimpleDynamicsWorld'_ a1' a2' a3' a4' >>= \res ->
mkBtSimpleDynamicsWorld res >>= \res' ->
return (res')
btSimpleDynamicsWorld_free :: ( BtSimpleDynamicsWorldClass bc ) => bc -> IO ()
btSimpleDynamicsWorld_free a1 =
withBt a1 $ \a1' ->
btSimpleDynamicsWorld_free'_ a1' >>= \res ->
return ()
btSimpleDynamicsWorld_predictUnconstraintMotion :: ( BtSimpleDynamicsWorldClass bc ) => bc -> Float -> IO ()
btSimpleDynamicsWorld_predictUnconstraintMotion a1 a2 =
withBt a1 $ \a1' ->
let {a2' = realToFrac a2} in
btSimpleDynamicsWorld_predictUnconstraintMotion'_ a1' a2' >>= \res ->
return ()
btSimpleDynamicsWorld_setGravity :: ( BtSimpleDynamicsWorldClass bc ) => bc -> Vec3 -> IO (Vec3)
btSimpleDynamicsWorld_setGravity a1 a2 =
withBt a1 $ \a1' ->
withVec3 a2 $ \a2' ->
btSimpleDynamicsWorld_setGravity'_ a1' a2' >>= \res ->
peekVec3 a2'>>= \a2'' ->
return (a2'')
btSimpleDynamicsWorld_setGravity' :: ( BtSimpleDynamicsWorldClass bc ) => bc -> IO (Vec3)
btSimpleDynamicsWorld_setGravity' a1 =
withBt a1 $ \a1' ->
allocaVec3 $ \a2' ->
btSimpleDynamicsWorld_setGravity''_ a1' a2' >>= \res ->
peekVec3 a2'>>= \a2'' ->
return (a2'')
btSimpleDynamicsWorld_addAction :: ( BtSimpleDynamicsWorldClass bc , BtActionInterfaceClass p0 ) => bc -> p0 -> IO ()
btSimpleDynamicsWorld_addAction a1 a2 =
withBt a1 $ \a1' ->
withBt a2 $ \a2' ->
btSimpleDynamicsWorld_addAction'_ a1' a2' >>= \res ->
return ()
btSimpleDynamicsWorld_synchronizeMotionStates :: ( BtSimpleDynamicsWorldClass bc ) => bc -> IO ()
btSimpleDynamicsWorld_synchronizeMotionStates a1 =
withBt a1 $ \a1' ->
btSimpleDynamicsWorld_synchronizeMotionStates'_ a1' >>= \res ->
return ()
btSimpleDynamicsWorld_setConstraintSolver :: ( BtSimpleDynamicsWorldClass bc , BtConstraintSolverClass p0 ) => bc -> p0 -> IO ()
btSimpleDynamicsWorld_setConstraintSolver a1 a2 =
withBt a1 $ \a1' ->
withBt a2 $ \a2' ->
btSimpleDynamicsWorld_setConstraintSolver'_ a1' a2' >>= \res ->
return ()
btSimpleDynamicsWorld_stepSimulation :: ( BtSimpleDynamicsWorldClass bc ) => bc -> Float -> Int -> Float -> IO (Int)
btSimpleDynamicsWorld_stepSimulation a1 a2 a3 a4 =
withBt a1 $ \a1' ->
let {a2' = realToFrac a2} in
let {a3' = fromIntegral a3} in
let {a4' = realToFrac a4} in
btSimpleDynamicsWorld_stepSimulation'_ a1' a2' a3' a4' >>= \res ->
let {res' = fromIntegral res} in
return (res')
btSimpleDynamicsWorld_getConstraintSolver :: ( BtSimpleDynamicsWorldClass bc ) => bc -> IO (BtConstraintSolver)
btSimpleDynamicsWorld_getConstraintSolver a1 =
withBt a1 $ \a1' ->
btSimpleDynamicsWorld_getConstraintSolver'_ a1' >>= \res ->
mkBtConstraintSolver res >>= \res' ->
return (res')
btSimpleDynamicsWorld_removeRigidBody :: ( BtSimpleDynamicsWorldClass bc , BtRigidBodyClass p0 ) => bc -> p0 -> IO ()
btSimpleDynamicsWorld_removeRigidBody a1 a2 =
withBt a1 $ \a1' ->
withBt a2 $ \a2' ->
btSimpleDynamicsWorld_removeRigidBody'_ a1' a2' >>= \res ->
return ()
btSimpleDynamicsWorld_addRigidBody :: ( BtSimpleDynamicsWorldClass bc , BtRigidBodyClass p0 ) => bc -> p0 -> IO ()
btSimpleDynamicsWorld_addRigidBody a1 a2 =
withBt a1 $ \a1' ->
withBt a2 $ \a2' ->
btSimpleDynamicsWorld_addRigidBody'_ a1' a2' >>= \res ->
return ()
btSimpleDynamicsWorld_addRigidBody0 :: ( BtSimpleDynamicsWorldClass bc , BtRigidBodyClass p0 ) => bc -> p0 -> IO ()
btSimpleDynamicsWorld_addRigidBody0 a1 a2 =
withBt a1 $ \a1' ->
withBt a2 $ \a2' ->
btSimpleDynamicsWorld_addRigidBody0'_ a1' a2' >>= \res ->
return ()
btSimpleDynamicsWorld_addRigidBody1 :: ( BtSimpleDynamicsWorldClass bc , BtRigidBodyClass p0 ) => bc -> p0 -> Int -> Int -> IO ()
btSimpleDynamicsWorld_addRigidBody1 a1 a2 a3 a4 =
withBt a1 $ \a1' ->
withBt a2 $ \a2' ->
let {a3' = fromIntegral a3} in
let {a4' = fromIntegral a4} in
btSimpleDynamicsWorld_addRigidBody1'_ a1' a2' a3' a4' >>= \res ->
return ()
btSimpleDynamicsWorld_getGravity :: ( BtSimpleDynamicsWorldClass bc ) => bc -> IO (Vec3)
btSimpleDynamicsWorld_getGravity a1 =
withBt a1 $ \a1' ->
allocaVec3 $ \a2' ->
btSimpleDynamicsWorld_getGravity'_ a1' a2' >>= \res ->
peekVec3 a2'>>= \a2'' ->
return (a2'')
btSimpleDynamicsWorld_integrateTransforms :: ( BtSimpleDynamicsWorldClass bc ) => bc -> Float -> IO ()
btSimpleDynamicsWorld_integrateTransforms a1 a2 =
withBt a1 $ \a1' ->
let {a2' = realToFrac a2} in
btSimpleDynamicsWorld_integrateTransforms'_ a1' a2' >>= \res ->
return ()
btSimpleDynamicsWorld_removeCollisionObject :: ( BtSimpleDynamicsWorldClass bc , BtCollisionObjectClass p0 ) => bc -> p0 -> IO ()
btSimpleDynamicsWorld_removeCollisionObject a1 a2 =
withBt a1 $ \a1' ->
withBt a2 $ \a2' ->
btSimpleDynamicsWorld_removeCollisionObject'_ a1' a2' >>= \res ->
return ()
btSimpleDynamicsWorld_clearForces :: ( BtSimpleDynamicsWorldClass bc ) => bc -> IO ()
btSimpleDynamicsWorld_clearForces a1 =
withBt a1 $ \a1' ->
btSimpleDynamicsWorld_clearForces'_ a1' >>= \res ->
return ()
btSimpleDynamicsWorld_removeAction :: ( BtSimpleDynamicsWorldClass bc , BtActionInterfaceClass p0 ) => bc -> p0 -> IO ()
btSimpleDynamicsWorld_removeAction a1 a2 =
withBt a1 $ \a1' ->
withBt a2 $ \a2' ->
btSimpleDynamicsWorld_removeAction'_ a1' a2' >>= \res ->
return ()
btSimpleDynamicsWorld_updateAabbs :: ( BtSimpleDynamicsWorldClass bc ) => bc -> IO ()
btSimpleDynamicsWorld_updateAabbs a1 =
withBt a1 $ \a1' ->
btSimpleDynamicsWorld_updateAabbs'_ a1' >>= \res ->
return ()
btSimpleDynamicsWorld_debugDrawWorld :: ( BtSimpleDynamicsWorldClass bc ) => bc -> IO ()
btSimpleDynamicsWorld_debugDrawWorld a1 =
withBt a1 $ \a1' ->
btSimpleDynamicsWorld_debugDrawWorld'_ a1' >>= \res ->
return ()
btSimpleDynamicsWorld_m_constraintSolver_set :: ( BtSimpleDynamicsWorldClass bc , BtConstraintSolverClass a ) => bc -> a -> IO ()
btSimpleDynamicsWorld_m_constraintSolver_set a1 a2 =
withBt a1 $ \a1' ->
withBt a2 $ \a2' ->
btSimpleDynamicsWorld_m_constraintSolver_set'_ a1' a2' >>= \res ->
return ()
btSimpleDynamicsWorld_m_constraintSolver_get :: ( BtSimpleDynamicsWorldClass bc ) => bc -> IO (BtConstraintSolver)
btSimpleDynamicsWorld_m_constraintSolver_get a1 =
withBt a1 $ \a1' ->
btSimpleDynamicsWorld_m_constraintSolver_get'_ a1' >>= \res ->
mkBtConstraintSolver res >>= \res' ->
return (res')
btSimpleDynamicsWorld_m_ownsConstraintSolver_set :: ( BtSimpleDynamicsWorldClass bc ) => bc -> Bool -> IO ()
btSimpleDynamicsWorld_m_ownsConstraintSolver_set a1 a2 =
withBt a1 $ \a1' ->
let {a2' = fromBool a2} in
btSimpleDynamicsWorld_m_ownsConstraintSolver_set'_ a1' a2' >>= \res ->
return ()
btSimpleDynamicsWorld_m_ownsConstraintSolver_get :: ( BtSimpleDynamicsWorldClass bc ) => bc -> IO (Bool)
btSimpleDynamicsWorld_m_ownsConstraintSolver_get a1 =
withBt a1 $ \a1' ->
btSimpleDynamicsWorld_m_ownsConstraintSolver_get'_ a1' >>= \res ->
let {res' = toBool res} in
return (res')
btSimpleDynamicsWorld_m_gravity_set :: ( BtSimpleDynamicsWorldClass bc ) => bc -> Vec3 -> IO ()
btSimpleDynamicsWorld_m_gravity_set a1 a2 =
withBt a1 $ \a1' ->
withVec3 a2 $ \a2' ->
btSimpleDynamicsWorld_m_gravity_set'_ a1' a2' >>= \res ->
return ()
btSimpleDynamicsWorld_m_gravity_get :: ( BtSimpleDynamicsWorldClass bc ) => bc -> IO (Vec3)
btSimpleDynamicsWorld_m_gravity_get a1 =
withBt a1 $ \a1' ->
allocaVec3 $ \a2' ->
btSimpleDynamicsWorld_m_gravity_get'_ a1' a2' >>= \res ->
peekVec3 a2'>>= \a2'' ->
return (a2'')
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btActionInterface_getFixedBody"
btActionInterface_getFixedBody'_ :: (IO (Ptr ()))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btActionInterface_updateAction"
btActionInterface_updateAction'_ :: ((Ptr ()) -> ((Ptr ()) -> (CFloat -> (IO ()))))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btActionInterface_debugDraw"
btActionInterface_debugDraw'_ :: ((Ptr ()) -> ((Ptr ()) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btDiscreteDynamicsWorld_new"
btDiscreteDynamicsWorld'_ :: ((Ptr ()) -> ((Ptr ()) -> ((Ptr ()) -> ((Ptr ()) -> (IO (Ptr ()))))))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btDiscreteDynamicsWorld_free"
btDiscreteDynamicsWorld_free'_ :: ((Ptr ()) -> (IO ()))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btDiscreteDynamicsWorld_setGravity"
btDiscreteDynamicsWorld_setGravity'_ :: ((Ptr ()) -> ((Ptr CFloat) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btDiscreteDynamicsWorld_setGravity"
btDiscreteDynamicsWorld_setGravity''_ :: ((Ptr ()) -> ((Ptr CFloat) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btDiscreteDynamicsWorld_addAction"
btDiscreteDynamicsWorld_addAction'_ :: ((Ptr ()) -> ((Ptr ()) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btDiscreteDynamicsWorld_applyGravity"
btDiscreteDynamicsWorld_applyGravity'_ :: ((Ptr ()) -> (IO ()))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btDiscreteDynamicsWorld_serialize"
btDiscreteDynamicsWorld_serialize'_ :: ((Ptr ()) -> ((Ptr ()) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btDiscreteDynamicsWorld_getCollisionWorld"
btDiscreteDynamicsWorld_getCollisionWorld'_ :: ((Ptr ()) -> (IO (Ptr ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btDiscreteDynamicsWorld_addRigidBody0"
btDiscreteDynamicsWorld_addRigidBody'_ :: ((Ptr ()) -> ((Ptr ()) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btDiscreteDynamicsWorld_addRigidBody0"
btDiscreteDynamicsWorld_addRigidBody0'_ :: ((Ptr ()) -> ((Ptr ()) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btDiscreteDynamicsWorld_addRigidBody1"
btDiscreteDynamicsWorld_addRigidBody1'_ :: ((Ptr ()) -> ((Ptr ()) -> (CShort -> (CShort -> (IO ())))))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btDiscreteDynamicsWorld_clearForces"
btDiscreteDynamicsWorld_clearForces'_ :: ((Ptr ()) -> (IO ()))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btDiscreteDynamicsWorld_removeVehicle"
btDiscreteDynamicsWorld_removeVehicle'_ :: ((Ptr ()) -> ((Ptr ()) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btDiscreteDynamicsWorld_serializeRigidBodies"
btDiscreteDynamicsWorld_serializeRigidBodies'_ :: ((Ptr ()) -> ((Ptr ()) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btDiscreteDynamicsWorld_internalSingleStepSimulation"
btDiscreteDynamicsWorld_internalSingleStepSimulation'_ :: ((Ptr ()) -> (CFloat -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btDiscreteDynamicsWorld_getSynchronizeAllMotionStates"
btDiscreteDynamicsWorld_getSynchronizeAllMotionStates'_ :: ((Ptr ()) -> (IO CInt))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btDiscreteDynamicsWorld_setNumTasks"
btDiscreteDynamicsWorld_setNumTasks'_ :: ((Ptr ()) -> (CInt -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btDiscreteDynamicsWorld_setSynchronizeAllMotionStates"
btDiscreteDynamicsWorld_setSynchronizeAllMotionStates'_ :: ((Ptr ()) -> (CInt -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btDiscreteDynamicsWorld_predictUnconstraintMotion"
btDiscreteDynamicsWorld_predictUnconstraintMotion'_ :: ((Ptr ()) -> (CFloat -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btDiscreteDynamicsWorld_removeConstraint"
btDiscreteDynamicsWorld_removeConstraint'_ :: ((Ptr ()) -> ((Ptr ()) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btDiscreteDynamicsWorld_getNumConstraints"
btDiscreteDynamicsWorld_getNumConstraints'_ :: ((Ptr ()) -> (IO CInt))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btDiscreteDynamicsWorld_addCollisionObject"
btDiscreteDynamicsWorld_addCollisionObject'_ :: ((Ptr ()) -> ((Ptr ()) -> (CShort -> (CShort -> (IO ())))))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btDiscreteDynamicsWorld_removeRigidBody"
btDiscreteDynamicsWorld_removeRigidBody'_ :: ((Ptr ()) -> ((Ptr ()) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btDiscreteDynamicsWorld_integrateTransforms"
btDiscreteDynamicsWorld_integrateTransforms'_ :: ((Ptr ()) -> (CFloat -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btDiscreteDynamicsWorld_debugDrawConstraint"
btDiscreteDynamicsWorld_debugDrawConstraint'_ :: ((Ptr ()) -> ((Ptr ()) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btDiscreteDynamicsWorld_debugDrawWorld"
btDiscreteDynamicsWorld_debugDrawWorld'_ :: ((Ptr ()) -> (IO ()))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btDiscreteDynamicsWorld_calculateSimulationIslands"
btDiscreteDynamicsWorld_calculateSimulationIslands'_ :: ((Ptr ()) -> (IO ()))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btDiscreteDynamicsWorld_addConstraint"
btDiscreteDynamicsWorld_addConstraint'_ :: ((Ptr ()) -> ((Ptr ()) -> (CInt -> (IO ()))))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btDiscreteDynamicsWorld_startProfiling"
btDiscreteDynamicsWorld_startProfiling'_ :: ((Ptr ()) -> (CFloat -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btDiscreteDynamicsWorld_updateActivationState"
btDiscreteDynamicsWorld_updateActivationState'_ :: ((Ptr ()) -> (CFloat -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btDiscreteDynamicsWorld_getGravity"
btDiscreteDynamicsWorld_getGravity'_ :: ((Ptr ()) -> ((Ptr CFloat) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btDiscreteDynamicsWorld_removeAction"
btDiscreteDynamicsWorld_removeAction'_ :: ((Ptr ()) -> ((Ptr ()) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btDiscreteDynamicsWorld_removeCharacter"
btDiscreteDynamicsWorld_removeCharacter'_ :: ((Ptr ()) -> ((Ptr ()) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btDiscreteDynamicsWorld_saveKinematicState"
btDiscreteDynamicsWorld_saveKinematicState'_ :: ((Ptr ()) -> (CFloat -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btDiscreteDynamicsWorld_getConstraint0"
btDiscreteDynamicsWorld_getConstraint'_ :: ((Ptr ()) -> (CInt -> (IO (Ptr ()))))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btDiscreteDynamicsWorld_getConstraint0"
btDiscreteDynamicsWorld_getConstraint0'_ :: ((Ptr ()) -> (CInt -> (IO (Ptr ()))))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btDiscreteDynamicsWorld_getConstraint1"
btDiscreteDynamicsWorld_getConstraint1'_ :: ((Ptr ()) -> (CInt -> (IO (Ptr ()))))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btDiscreteDynamicsWorld_getConstraintSolver"
btDiscreteDynamicsWorld_getConstraintSolver'_ :: ((Ptr ()) -> (IO (Ptr ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btDiscreteDynamicsWorld_addCharacter"
btDiscreteDynamicsWorld_addCharacter'_ :: ((Ptr ()) -> ((Ptr ()) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btDiscreteDynamicsWorld_solveConstraints"
btDiscreteDynamicsWorld_solveConstraints'_ :: ((Ptr ()) -> ((Ptr ()) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btDiscreteDynamicsWorld_updateActions"
btDiscreteDynamicsWorld_updateActions'_ :: ((Ptr ()) -> (CFloat -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btDiscreteDynamicsWorld_updateVehicles"
btDiscreteDynamicsWorld_updateVehicles'_ :: ((Ptr ()) -> (CFloat -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btDiscreteDynamicsWorld_synchronizeSingleMotionState"
btDiscreteDynamicsWorld_synchronizeSingleMotionState'_ :: ((Ptr ()) -> ((Ptr ()) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btDiscreteDynamicsWorld_addVehicle"
btDiscreteDynamicsWorld_addVehicle'_ :: ((Ptr ()) -> ((Ptr ()) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btDiscreteDynamicsWorld_synchronizeMotionStates"
btDiscreteDynamicsWorld_synchronizeMotionStates'_ :: ((Ptr ()) -> (IO ()))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btDiscreteDynamicsWorld_stepSimulation"
btDiscreteDynamicsWorld_stepSimulation'_ :: ((Ptr ()) -> (CFloat -> (CInt -> (CFloat -> (IO CInt)))))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btDiscreteDynamicsWorld_removeCollisionObject"
btDiscreteDynamicsWorld_removeCollisionObject'_ :: ((Ptr ()) -> ((Ptr ()) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btDiscreteDynamicsWorld_setConstraintSolver"
btDiscreteDynamicsWorld_setConstraintSolver'_ :: ((Ptr ()) -> ((Ptr ()) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btDiscreteDynamicsWorld_m_constraintSolver_set"
btDiscreteDynamicsWorld_m_constraintSolver_set'_ :: ((Ptr ()) -> ((Ptr ()) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btDiscreteDynamicsWorld_m_constraintSolver_get"
btDiscreteDynamicsWorld_m_constraintSolver_get'_ :: ((Ptr ()) -> (IO (Ptr ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btDiscreteDynamicsWorld_m_constraints_set"
btDiscreteDynamicsWorld_m_constraints_set'_ :: ((Ptr ()) -> ((Ptr ()) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btDiscreteDynamicsWorld_m_constraints_get"
btDiscreteDynamicsWorld_m_constraints_get'_ :: ((Ptr ()) -> (IO (Ptr ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btDiscreteDynamicsWorld_m_nonStaticRigidBodies_set"
btDiscreteDynamicsWorld_m_nonStaticRigidBodies_set'_ :: ((Ptr ()) -> ((Ptr ()) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btDiscreteDynamicsWorld_m_nonStaticRigidBodies_get"
btDiscreteDynamicsWorld_m_nonStaticRigidBodies_get'_ :: ((Ptr ()) -> (IO (Ptr ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btDiscreteDynamicsWorld_m_gravity_set"
btDiscreteDynamicsWorld_m_gravity_set'_ :: ((Ptr ()) -> ((Ptr CFloat) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btDiscreteDynamicsWorld_m_gravity_get"
btDiscreteDynamicsWorld_m_gravity_get'_ :: ((Ptr ()) -> ((Ptr CFloat) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btDiscreteDynamicsWorld_m_localTime_set"
btDiscreteDynamicsWorld_m_localTime_set'_ :: ((Ptr ()) -> (CFloat -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btDiscreteDynamicsWorld_m_localTime_get"
btDiscreteDynamicsWorld_m_localTime_get'_ :: ((Ptr ()) -> (IO CFloat))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btDiscreteDynamicsWorld_m_ownsIslandManager_set"
btDiscreteDynamicsWorld_m_ownsIslandManager_set'_ :: ((Ptr ()) -> (CInt -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btDiscreteDynamicsWorld_m_ownsIslandManager_get"
btDiscreteDynamicsWorld_m_ownsIslandManager_get'_ :: ((Ptr ()) -> (IO CInt))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btDiscreteDynamicsWorld_m_ownsConstraintSolver_set"
btDiscreteDynamicsWorld_m_ownsConstraintSolver_set'_ :: ((Ptr ()) -> (CInt -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btDiscreteDynamicsWorld_m_ownsConstraintSolver_get"
btDiscreteDynamicsWorld_m_ownsConstraintSolver_get'_ :: ((Ptr ()) -> (IO CInt))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btDiscreteDynamicsWorld_m_synchronizeAllMotionStates_set"
btDiscreteDynamicsWorld_m_synchronizeAllMotionStates_set'_ :: ((Ptr ()) -> (CInt -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btDiscreteDynamicsWorld_m_synchronizeAllMotionStates_get"
btDiscreteDynamicsWorld_m_synchronizeAllMotionStates_get'_ :: ((Ptr ()) -> (IO CInt))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btDiscreteDynamicsWorld_m_actions_set"
btDiscreteDynamicsWorld_m_actions_set'_ :: ((Ptr ()) -> ((Ptr ()) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btDiscreteDynamicsWorld_m_actions_get"
btDiscreteDynamicsWorld_m_actions_get'_ :: ((Ptr ()) -> (IO (Ptr ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btDiscreteDynamicsWorld_m_profileTimings_set"
btDiscreteDynamicsWorld_m_profileTimings_set'_ :: ((Ptr ()) -> (CInt -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btDiscreteDynamicsWorld_m_profileTimings_get"
btDiscreteDynamicsWorld_m_profileTimings_get'_ :: ((Ptr ()) -> (IO CInt))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btDynamicsWorld_setGravity"
btDynamicsWorld_setGravity'_ :: ((Ptr ()) -> ((Ptr CFloat) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btDynamicsWorld_setGravity"
btDynamicsWorld_setGravity''_ :: ((Ptr ()) -> ((Ptr CFloat) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btDynamicsWorld_addAction"
btDynamicsWorld_addAction'_ :: ((Ptr ()) -> ((Ptr ()) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btDynamicsWorld_getSolverInfo"
btDynamicsWorld_getSolverInfo'_ :: ((Ptr ()) -> (IO (Ptr ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btDynamicsWorld_addRigidBody0"
btDynamicsWorld_addRigidBody'_ :: ((Ptr ()) -> ((Ptr ()) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btDynamicsWorld_addRigidBody0"
btDynamicsWorld_addRigidBody0'_ :: ((Ptr ()) -> ((Ptr ()) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btDynamicsWorld_addRigidBody1"
btDynamicsWorld_addRigidBody1'_ :: ((Ptr ()) -> ((Ptr ()) -> (CShort -> (CShort -> (IO ())))))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btDynamicsWorld_clearForces"
btDynamicsWorld_clearForces'_ :: ((Ptr ()) -> (IO ()))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btDynamicsWorld_removeVehicle"
btDynamicsWorld_removeVehicle'_ :: ((Ptr ()) -> ((Ptr ()) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btDynamicsWorld_removeConstraint"
btDynamicsWorld_removeConstraint'_ :: ((Ptr ()) -> ((Ptr ()) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btDynamicsWorld_getNumConstraints"
btDynamicsWorld_getNumConstraints'_ :: ((Ptr ()) -> (IO CInt))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btDynamicsWorld_removeRigidBody"
btDynamicsWorld_removeRigidBody'_ :: ((Ptr ()) -> ((Ptr ()) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btDynamicsWorld_synchronizeMotionStates"
btDynamicsWorld_synchronizeMotionStates'_ :: ((Ptr ()) -> (IO ()))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btDynamicsWorld_addConstraint"
btDynamicsWorld_addConstraint'_ :: ((Ptr ()) -> ((Ptr ()) -> (CInt -> (IO ()))))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btDynamicsWorld_getGravity"
btDynamicsWorld_getGravity'_ :: ((Ptr ()) -> ((Ptr CFloat) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btDynamicsWorld_debugDrawWorld"
btDynamicsWorld_debugDrawWorld'_ :: ((Ptr ()) -> (IO ()))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btDynamicsWorld_removeAction"
btDynamicsWorld_removeAction'_ :: ((Ptr ()) -> ((Ptr ()) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btDynamicsWorld_setWorldUserInfo"
btDynamicsWorld_setWorldUserInfo'_ :: ((Ptr ()) -> ((Ptr ()) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btDynamicsWorld_removeCharacter"
btDynamicsWorld_removeCharacter'_ :: ((Ptr ()) -> ((Ptr ()) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btDynamicsWorld_getConstraint0"
btDynamicsWorld_getConstraint'_ :: ((Ptr ()) -> (CInt -> (IO (Ptr ()))))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btDynamicsWorld_getConstraint0"
btDynamicsWorld_getConstraint0'_ :: ((Ptr ()) -> (CInt -> (IO (Ptr ()))))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btDynamicsWorld_getConstraint1"
btDynamicsWorld_getConstraint1'_ :: ((Ptr ()) -> (CInt -> (IO (Ptr ()))))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btDynamicsWorld_getConstraintSolver"
btDynamicsWorld_getConstraintSolver'_ :: ((Ptr ()) -> (IO (Ptr ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btDynamicsWorld_stepSimulation"
btDynamicsWorld_stepSimulation'_ :: ((Ptr ()) -> (CFloat -> (CInt -> (CFloat -> (IO CInt)))))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btDynamicsWorld_addCharacter"
btDynamicsWorld_addCharacter'_ :: ((Ptr ()) -> ((Ptr ()) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btDynamicsWorld_addVehicle"
btDynamicsWorld_addVehicle'_ :: ((Ptr ()) -> ((Ptr ()) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btDynamicsWorld_getWorldUserInfo"
btDynamicsWorld_getWorldUserInfo'_ :: ((Ptr ()) -> (IO (Ptr ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btDynamicsWorld_setConstraintSolver"
btDynamicsWorld_setConstraintSolver'_ :: ((Ptr ()) -> ((Ptr ()) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btDynamicsWorld_m_worldUserInfo_set"
btDynamicsWorld_m_worldUserInfo_set'_ :: ((Ptr ()) -> ((Ptr ()) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btDynamicsWorld_m_worldUserInfo_get"
btDynamicsWorld_m_worldUserInfo_get'_ :: ((Ptr ()) -> (IO (Ptr ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btDynamicsWorld_m_solverInfo_set"
btDynamicsWorld_m_solverInfo_set'_ :: ((Ptr ()) -> ((Ptr ()) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btDynamicsWorld_m_solverInfo_get"
btDynamicsWorld_m_solverInfo_get'_ :: ((Ptr ()) -> (IO (Ptr ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_new0"
btRigidBody0'_ :: ((Ptr ()) -> (IO (Ptr ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_new1"
btRigidBody1'_ :: (CFloat -> ((Ptr ()) -> ((Ptr ()) -> ((Ptr CFloat) -> (IO (Ptr ()))))))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_free"
btRigidBody_free'_ :: ((Ptr ()) -> (IO ()))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_setGravity"
btRigidBody_setGravity'_ :: ((Ptr ()) -> ((Ptr CFloat) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_setGravity"
btRigidBody_setGravity''_ :: ((Ptr ()) -> ((Ptr CFloat) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_updateDeactivation"
btRigidBody_updateDeactivation'_ :: ((Ptr ()) -> (CFloat -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_setAngularFactor0"
btRigidBody_setAngularFactor'_ :: ((Ptr ()) -> ((Ptr CFloat) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_setAngularFactor0"
btRigidBody_setAngularFactor''_ :: ((Ptr ()) -> ((Ptr CFloat) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_setAngularFactor0"
btRigidBody_setAngularFactor0'_ :: ((Ptr ()) -> ((Ptr CFloat) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_setAngularFactor0"
btRigidBody_setAngularFactor0''_ :: ((Ptr ()) -> ((Ptr CFloat) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_setAngularFactor1"
btRigidBody_setAngularFactor1'_ :: ((Ptr ()) -> (CFloat -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_internalWritebackVelocity0"
btRigidBody_internalWritebackVelocity'_ :: ((Ptr ()) -> (IO ()))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_internalWritebackVelocity0"
btRigidBody_internalWritebackVelocity0'_ :: ((Ptr ()) -> (IO ()))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_internalWritebackVelocity1"
btRigidBody_internalWritebackVelocity1'_ :: ((Ptr ()) -> (CFloat -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_getPushVelocity"
btRigidBody_getPushVelocity'_ :: ((Ptr ()) -> ((Ptr CFloat) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_internalGetDeltaAngularVelocity"
btRigidBody_internalGetDeltaAngularVelocity'_ :: ((Ptr ()) -> ((Ptr CFloat) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_applyGravity"
btRigidBody_applyGravity'_ :: ((Ptr ()) -> (IO ()))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_serialize"
btRigidBody_serialize'_ :: ((Ptr ()) -> ((Ptr ()) -> ((Ptr ()) -> (IO (Ptr CChar)))))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_getOrientation"
btRigidBody_getOrientation'_ :: ((Ptr ()) -> ((Ptr CFloat) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_applyCentralForce"
btRigidBody_applyCentralForce'_ :: ((Ptr ()) -> ((Ptr CFloat) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_applyCentralForce"
btRigidBody_applyCentralForce''_ :: ((Ptr ()) -> ((Ptr CFloat) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_setMotionState"
btRigidBody_setMotionState'_ :: ((Ptr ()) -> ((Ptr ()) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_clearForces"
btRigidBody_clearForces'_ :: ((Ptr ()) -> (IO ()))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_getMotionState0"
btRigidBody_getMotionState'_ :: ((Ptr ()) -> (IO (Ptr ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_getMotionState0"
btRigidBody_getMotionState0'_ :: ((Ptr ()) -> (IO (Ptr ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_getMotionState1"
btRigidBody_getMotionState1'_ :: ((Ptr ()) -> (IO (Ptr ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_setDamping"
btRigidBody_setDamping'_ :: ((Ptr ()) -> (CFloat -> (CFloat -> (IO ()))))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_applyImpulse"
btRigidBody_applyImpulse'_ :: ((Ptr ()) -> ((Ptr CFloat) -> ((Ptr CFloat) -> (IO ()))))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_applyImpulse"
btRigidBody_applyImpulse''_ :: ((Ptr ()) -> ((Ptr CFloat) -> ((Ptr CFloat) -> (IO ()))))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_applyTorque"
btRigidBody_applyTorque'_ :: ((Ptr ()) -> ((Ptr CFloat) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_applyTorque"
btRigidBody_applyTorque''_ :: ((Ptr ()) -> ((Ptr CFloat) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_internalApplyPushImpulse"
btRigidBody_internalApplyPushImpulse'_ :: ((Ptr ()) -> ((Ptr CFloat) -> ((Ptr CFloat) -> (CFloat -> (IO ())))))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_internalApplyPushImpulse"
btRigidBody_internalApplyPushImpulse''_ :: ((Ptr ()) -> ((Ptr CFloat) -> ((Ptr CFloat) -> (CFloat -> (IO ())))))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_wantsSleeping"
btRigidBody_wantsSleeping'_ :: ((Ptr ()) -> (IO CInt))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_setNewBroadphaseProxy"
btRigidBody_setNewBroadphaseProxy'_ :: ((Ptr ()) -> ((Ptr ()) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_getVelocityInLocalPoint"
btRigidBody_getVelocityInLocalPoint'_ :: ((Ptr ()) -> ((Ptr CFloat) -> ((Ptr CFloat) -> (IO ()))))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_getVelocityInLocalPoint"
btRigidBody_getVelocityInLocalPoint''_ :: ((Ptr ()) -> ((Ptr CFloat) -> ((Ptr CFloat) -> (IO ()))))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_calculateSerializeBufferSize"
btRigidBody_calculateSerializeBufferSize'_ :: ((Ptr ()) -> (IO CInt))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_setAngularVelocity"
btRigidBody_setAngularVelocity'_ :: ((Ptr ()) -> ((Ptr CFloat) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_setAngularVelocity"
btRigidBody_setAngularVelocity''_ :: ((Ptr ()) -> ((Ptr CFloat) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_getLinearFactor"
btRigidBody_getLinearFactor'_ :: ((Ptr ()) -> ((Ptr CFloat) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_predictIntegratedTransform"
btRigidBody_predictIntegratedTransform'_ :: ((Ptr ()) -> (CFloat -> ((Ptr CFloat) -> (IO ()))))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_predictIntegratedTransform"
btRigidBody_predictIntegratedTransform''_ :: ((Ptr ()) -> (CFloat -> ((Ptr CFloat) -> (IO ()))))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_internalGetAngularFactor"
btRigidBody_internalGetAngularFactor'_ :: ((Ptr ()) -> ((Ptr CFloat) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_getAngularSleepingThreshold"
btRigidBody_getAngularSleepingThreshold'_ :: ((Ptr ()) -> (IO CFloat))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_applyDamping"
btRigidBody_applyDamping'_ :: ((Ptr ()) -> (CFloat -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_saveKinematicState"
btRigidBody_saveKinematicState'_ :: ((Ptr ()) -> (CFloat -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_setSleepingThresholds"
btRigidBody_setSleepingThresholds'_ :: ((Ptr ()) -> (CFloat -> (CFloat -> (IO ()))))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_getAngularVelocity"
btRigidBody_getAngularVelocity'_ :: ((Ptr ()) -> ((Ptr CFloat) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_getLinearSleepingThreshold"
btRigidBody_getLinearSleepingThreshold'_ :: ((Ptr ()) -> (IO CFloat))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_internalGetInvMass"
btRigidBody_internalGetInvMass'_ :: ((Ptr ()) -> ((Ptr CFloat) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_applyTorqueImpulse"
btRigidBody_applyTorqueImpulse'_ :: ((Ptr ()) -> ((Ptr CFloat) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_applyTorqueImpulse"
btRigidBody_applyTorqueImpulse''_ :: ((Ptr ()) -> ((Ptr CFloat) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_internalGetPushVelocity"
btRigidBody_internalGetPushVelocity'_ :: ((Ptr ()) -> ((Ptr CFloat) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_setLinearFactor"
btRigidBody_setLinearFactor'_ :: ((Ptr ()) -> ((Ptr CFloat) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_setLinearFactor"
btRigidBody_setLinearFactor''_ :: ((Ptr ()) -> ((Ptr CFloat) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_serializeSingleObject"
btRigidBody_serializeSingleObject'_ :: ((Ptr ()) -> ((Ptr ()) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_getInvMass"
btRigidBody_getInvMass'_ :: ((Ptr ()) -> (IO CFloat))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_getTotalForce"
btRigidBody_getTotalForce'_ :: ((Ptr ()) -> ((Ptr CFloat) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_getCenterOfMassPosition"
btRigidBody_getCenterOfMassPosition'_ :: ((Ptr ()) -> ((Ptr CFloat) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_getAabb"
btRigidBody_getAabb'_ :: ((Ptr ()) -> ((Ptr CFloat) -> ((Ptr CFloat) -> (IO ()))))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_getAabb"
btRigidBody_getAabb''_ :: ((Ptr ()) -> ((Ptr CFloat) -> ((Ptr CFloat) -> (IO ()))))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_getBroadphaseProxy0"
btRigidBody_getBroadphaseProxy'_ :: ((Ptr ()) -> (IO (Ptr ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_getBroadphaseProxy0"
btRigidBody_getBroadphaseProxy0'_ :: ((Ptr ()) -> (IO (Ptr ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_getBroadphaseProxy1"
btRigidBody_getBroadphaseProxy1'_ :: ((Ptr ()) -> (IO (Ptr ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_getCollisionShape0"
btRigidBody_getCollisionShape'_ :: ((Ptr ()) -> (IO (Ptr ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_getCollisionShape0"
btRigidBody_getCollisionShape0'_ :: ((Ptr ()) -> (IO (Ptr ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_getCollisionShape1"
btRigidBody_getCollisionShape1'_ :: ((Ptr ()) -> (IO (Ptr ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_upcast0"
btRigidBody_upcast'_ :: ((Ptr ()) -> (IO (Ptr ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_upcast0"
btRigidBody_upcast0'_ :: ((Ptr ()) -> (IO (Ptr ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_upcast1"
btRigidBody_upcast1'_ :: ((Ptr ()) -> (IO (Ptr ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_checkCollideWithOverride"
btRigidBody_checkCollideWithOverride'_ :: ((Ptr ()) -> ((Ptr ()) -> (IO CInt)))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_translate"
btRigidBody_translate'_ :: ((Ptr ()) -> ((Ptr CFloat) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_translate"
btRigidBody_translate''_ :: ((Ptr ()) -> ((Ptr CFloat) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_updateInertiaTensor"
btRigidBody_updateInertiaTensor'_ :: ((Ptr ()) -> (IO ()))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_applyForce"
btRigidBody_applyForce'_ :: ((Ptr ()) -> ((Ptr CFloat) -> ((Ptr CFloat) -> (IO ()))))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_applyForce"
btRigidBody_applyForce''_ :: ((Ptr ()) -> ((Ptr CFloat) -> ((Ptr CFloat) -> (IO ()))))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_internalGetAngularVelocity"
btRigidBody_internalGetAngularVelocity'_ :: ((Ptr ()) -> ((Ptr CFloat) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_internalGetAngularVelocity"
btRigidBody_internalGetAngularVelocity''_ :: ((Ptr ()) -> ((Ptr CFloat) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_setupRigidBody"
btRigidBody_setupRigidBody'_ :: ((Ptr ()) -> ((Ptr ()) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_applyCentralImpulse"
btRigidBody_applyCentralImpulse'_ :: ((Ptr ()) -> ((Ptr CFloat) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_applyCentralImpulse"
btRigidBody_applyCentralImpulse''_ :: ((Ptr ()) -> ((Ptr CFloat) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_getTurnVelocity"
btRigidBody_getTurnVelocity'_ :: ((Ptr ()) -> ((Ptr CFloat) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_getDeltaLinearVelocity"
btRigidBody_getDeltaLinearVelocity'_ :: ((Ptr ()) -> ((Ptr CFloat) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_integrateVelocities"
btRigidBody_integrateVelocities'_ :: ((Ptr ()) -> (CFloat -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_getGravity"
btRigidBody_getGravity'_ :: ((Ptr ()) -> ((Ptr CFloat) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_setMassProps"
btRigidBody_setMassProps'_ :: ((Ptr ()) -> (CFloat -> ((Ptr CFloat) -> (IO ()))))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_setMassProps"
btRigidBody_setMassProps''_ :: ((Ptr ()) -> (CFloat -> ((Ptr CFloat) -> (IO ()))))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_setCenterOfMassTransform"
btRigidBody_setCenterOfMassTransform'_ :: ((Ptr ()) -> ((Ptr CFloat) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_setCenterOfMassTransform"
btRigidBody_setCenterOfMassTransform''_ :: ((Ptr ()) -> ((Ptr CFloat) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_setFlags"
btRigidBody_setFlags'_ :: ((Ptr ()) -> (CInt -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_addConstraintRef"
btRigidBody_addConstraintRef'_ :: ((Ptr ()) -> ((Ptr ()) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_setLinearVelocity"
btRigidBody_setLinearVelocity'_ :: ((Ptr ()) -> ((Ptr CFloat) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_setLinearVelocity"
btRigidBody_setLinearVelocity''_ :: ((Ptr ()) -> ((Ptr CFloat) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_isInWorld"
btRigidBody_isInWorld'_ :: ((Ptr ()) -> (IO CInt))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_getTotalTorque"
btRigidBody_getTotalTorque'_ :: ((Ptr ()) -> ((Ptr CFloat) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_getNumConstraintRefs"
btRigidBody_getNumConstraintRefs'_ :: ((Ptr ()) -> (IO CInt))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_computeAngularImpulseDenominator"
btRigidBody_computeAngularImpulseDenominator'_ :: ((Ptr ()) -> ((Ptr CFloat) -> (IO CFloat)))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_computeAngularImpulseDenominator"
btRigidBody_computeAngularImpulseDenominator''_ :: ((Ptr ()) -> ((Ptr CFloat) -> (IO CFloat)))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_getInvInertiaTensorWorld"
btRigidBody_getInvInertiaTensorWorld'_ :: ((Ptr ()) -> ((Ptr CFloat) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_getDeltaAngularVelocity"
btRigidBody_getDeltaAngularVelocity'_ :: ((Ptr ()) -> ((Ptr CFloat) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_internalGetDeltaLinearVelocity"
btRigidBody_internalGetDeltaLinearVelocity'_ :: ((Ptr ()) -> ((Ptr CFloat) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_computeImpulseDenominator"
btRigidBody_computeImpulseDenominator'_ :: ((Ptr ()) -> ((Ptr CFloat) -> ((Ptr CFloat) -> (IO CFloat))))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_computeImpulseDenominator"
btRigidBody_computeImpulseDenominator''_ :: ((Ptr ()) -> ((Ptr CFloat) -> ((Ptr CFloat) -> (IO CFloat))))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_getConstraintRef"
btRigidBody_getConstraintRef'_ :: ((Ptr ()) -> (CInt -> (IO (Ptr ()))))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_getAngularDamping"
btRigidBody_getAngularDamping'_ :: ((Ptr ()) -> (IO CFloat))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_internalGetTurnVelocity"
btRigidBody_internalGetTurnVelocity'_ :: ((Ptr ()) -> ((Ptr CFloat) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_proceedToTransform"
btRigidBody_proceedToTransform'_ :: ((Ptr ()) -> ((Ptr CFloat) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_proceedToTransform"
btRigidBody_proceedToTransform''_ :: ((Ptr ()) -> ((Ptr CFloat) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_setInvInertiaDiagLocal"
btRigidBody_setInvInertiaDiagLocal'_ :: ((Ptr ()) -> ((Ptr CFloat) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_setInvInertiaDiagLocal"
btRigidBody_setInvInertiaDiagLocal''_ :: ((Ptr ()) -> ((Ptr CFloat) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_getInvInertiaDiagLocal"
btRigidBody_getInvInertiaDiagLocal'_ :: ((Ptr ()) -> ((Ptr CFloat) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_getCenterOfMassTransform"
btRigidBody_getCenterOfMassTransform'_ :: ((Ptr ()) -> ((Ptr CFloat) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_removeConstraintRef"
btRigidBody_removeConstraintRef'_ :: ((Ptr ()) -> ((Ptr ()) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_getAngularFactor"
btRigidBody_getAngularFactor'_ :: ((Ptr ()) -> ((Ptr CFloat) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_getLinearVelocity"
btRigidBody_getLinearVelocity'_ :: ((Ptr ()) -> ((Ptr CFloat) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_getFlags"
btRigidBody_getFlags'_ :: ((Ptr ()) -> (IO CInt))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_internalGetVelocityInLocalPointObsolete"
btRigidBody_internalGetVelocityInLocalPointObsolete'_ :: ((Ptr ()) -> ((Ptr CFloat) -> ((Ptr CFloat) -> (IO ()))))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_internalGetVelocityInLocalPointObsolete"
btRigidBody_internalGetVelocityInLocalPointObsolete''_ :: ((Ptr ()) -> ((Ptr CFloat) -> ((Ptr CFloat) -> (IO ()))))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_getLinearDamping"
btRigidBody_getLinearDamping'_ :: ((Ptr ()) -> (IO CFloat))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_m_additionalAngularDampingFactor_set"
btRigidBody_m_additionalAngularDampingFactor_set'_ :: ((Ptr ()) -> (CFloat -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_m_additionalAngularDampingFactor_get"
btRigidBody_m_additionalAngularDampingFactor_get'_ :: ((Ptr ()) -> (IO CFloat))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_m_additionalAngularDampingThresholdSqr_set"
btRigidBody_m_additionalAngularDampingThresholdSqr_set'_ :: ((Ptr ()) -> (CFloat -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_m_additionalAngularDampingThresholdSqr_get"
btRigidBody_m_additionalAngularDampingThresholdSqr_get'_ :: ((Ptr ()) -> (IO CFloat))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_m_additionalDamping_set"
btRigidBody_m_additionalDamping_set'_ :: ((Ptr ()) -> (CInt -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_m_additionalDamping_get"
btRigidBody_m_additionalDamping_get'_ :: ((Ptr ()) -> (IO CInt))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_m_additionalDampingFactor_set"
btRigidBody_m_additionalDampingFactor_set'_ :: ((Ptr ()) -> (CFloat -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_m_additionalDampingFactor_get"
btRigidBody_m_additionalDampingFactor_get'_ :: ((Ptr ()) -> (IO CFloat))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_m_additionalLinearDampingThresholdSqr_set"
btRigidBody_m_additionalLinearDampingThresholdSqr_set'_ :: ((Ptr ()) -> (CFloat -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_m_additionalLinearDampingThresholdSqr_get"
btRigidBody_m_additionalLinearDampingThresholdSqr_get'_ :: ((Ptr ()) -> (IO CFloat))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_m_angularDamping_set"
btRigidBody_m_angularDamping_set'_ :: ((Ptr ()) -> (CFloat -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_m_angularDamping_get"
btRigidBody_m_angularDamping_get'_ :: ((Ptr ()) -> (IO CFloat))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_m_angularFactor_set"
btRigidBody_m_angularFactor_set'_ :: ((Ptr ()) -> ((Ptr CFloat) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_m_angularFactor_get"
btRigidBody_m_angularFactor_get'_ :: ((Ptr ()) -> ((Ptr CFloat) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_m_angularSleepingThreshold_set"
btRigidBody_m_angularSleepingThreshold_set'_ :: ((Ptr ()) -> (CFloat -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_m_angularSleepingThreshold_get"
btRigidBody_m_angularSleepingThreshold_get'_ :: ((Ptr ()) -> (IO CFloat))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_m_angularVelocity_set"
btRigidBody_m_angularVelocity_set'_ :: ((Ptr ()) -> ((Ptr CFloat) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_m_angularVelocity_get"
btRigidBody_m_angularVelocity_get'_ :: ((Ptr ()) -> ((Ptr CFloat) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_m_constraintRefs_set"
btRigidBody_m_constraintRefs_set'_ :: ((Ptr ()) -> ((Ptr ()) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_m_constraintRefs_get"
btRigidBody_m_constraintRefs_get'_ :: ((Ptr ()) -> (IO (Ptr ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_m_contactSolverType_set"
btRigidBody_m_contactSolverType_set'_ :: ((Ptr ()) -> (CInt -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_m_contactSolverType_get"
btRigidBody_m_contactSolverType_get'_ :: ((Ptr ()) -> (IO CInt))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_m_debugBodyId_set"
btRigidBody_m_debugBodyId_set'_ :: ((Ptr ()) -> (CInt -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_m_debugBodyId_get"
btRigidBody_m_debugBodyId_get'_ :: ((Ptr ()) -> (IO CInt))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_m_deltaAngularVelocity_set"
btRigidBody_m_deltaAngularVelocity_set'_ :: ((Ptr ()) -> ((Ptr CFloat) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_m_deltaAngularVelocity_get"
btRigidBody_m_deltaAngularVelocity_get'_ :: ((Ptr ()) -> ((Ptr CFloat) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_m_deltaLinearVelocity_set"
btRigidBody_m_deltaLinearVelocity_set'_ :: ((Ptr ()) -> ((Ptr CFloat) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_m_deltaLinearVelocity_get"
btRigidBody_m_deltaLinearVelocity_get'_ :: ((Ptr ()) -> ((Ptr CFloat) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_m_frictionSolverType_set"
btRigidBody_m_frictionSolverType_set'_ :: ((Ptr ()) -> (CInt -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_m_frictionSolverType_get"
btRigidBody_m_frictionSolverType_get'_ :: ((Ptr ()) -> (IO CInt))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_m_gravity_set"
btRigidBody_m_gravity_set'_ :: ((Ptr ()) -> ((Ptr CFloat) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_m_gravity_get"
btRigidBody_m_gravity_get'_ :: ((Ptr ()) -> ((Ptr CFloat) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_m_gravity_acceleration_set"
btRigidBody_m_gravity_acceleration_set'_ :: ((Ptr ()) -> ((Ptr CFloat) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_m_gravity_acceleration_get"
btRigidBody_m_gravity_acceleration_get'_ :: ((Ptr ()) -> ((Ptr CFloat) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_m_invInertiaLocal_set"
btRigidBody_m_invInertiaLocal_set'_ :: ((Ptr ()) -> ((Ptr CFloat) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_m_invInertiaLocal_get"
btRigidBody_m_invInertiaLocal_get'_ :: ((Ptr ()) -> ((Ptr CFloat) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_m_invInertiaTensorWorld_set"
btRigidBody_m_invInertiaTensorWorld_set'_ :: ((Ptr ()) -> ((Ptr CFloat) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_m_invInertiaTensorWorld_get"
btRigidBody_m_invInertiaTensorWorld_get'_ :: ((Ptr ()) -> ((Ptr CFloat) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_m_invMass_set"
btRigidBody_m_invMass_set'_ :: ((Ptr ()) -> ((Ptr CFloat) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_m_invMass_get"
btRigidBody_m_invMass_get'_ :: ((Ptr ()) -> ((Ptr CFloat) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_m_inverseMass_set"
btRigidBody_m_inverseMass_set'_ :: ((Ptr ()) -> (CFloat -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_m_inverseMass_get"
btRigidBody_m_inverseMass_get'_ :: ((Ptr ()) -> (IO CFloat))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_m_linearDamping_set"
btRigidBody_m_linearDamping_set'_ :: ((Ptr ()) -> (CFloat -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_m_linearDamping_get"
btRigidBody_m_linearDamping_get'_ :: ((Ptr ()) -> (IO CFloat))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_m_linearFactor_set"
btRigidBody_m_linearFactor_set'_ :: ((Ptr ()) -> ((Ptr CFloat) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_m_linearFactor_get"
btRigidBody_m_linearFactor_get'_ :: ((Ptr ()) -> ((Ptr CFloat) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_m_linearSleepingThreshold_set"
btRigidBody_m_linearSleepingThreshold_set'_ :: ((Ptr ()) -> (CFloat -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_m_linearSleepingThreshold_get"
btRigidBody_m_linearSleepingThreshold_get'_ :: ((Ptr ()) -> (IO CFloat))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_m_linearVelocity_set"
btRigidBody_m_linearVelocity_set'_ :: ((Ptr ()) -> ((Ptr CFloat) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_m_linearVelocity_get"
btRigidBody_m_linearVelocity_get'_ :: ((Ptr ()) -> ((Ptr CFloat) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_m_optionalMotionState_set"
btRigidBody_m_optionalMotionState_set'_ :: ((Ptr ()) -> ((Ptr ()) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_m_optionalMotionState_get"
btRigidBody_m_optionalMotionState_get'_ :: ((Ptr ()) -> (IO (Ptr ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_m_pushVelocity_set"
btRigidBody_m_pushVelocity_set'_ :: ((Ptr ()) -> ((Ptr CFloat) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_m_pushVelocity_get"
btRigidBody_m_pushVelocity_get'_ :: ((Ptr ()) -> ((Ptr CFloat) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_m_rigidbodyFlags_set"
btRigidBody_m_rigidbodyFlags_set'_ :: ((Ptr ()) -> (CInt -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_m_rigidbodyFlags_get"
btRigidBody_m_rigidbodyFlags_get'_ :: ((Ptr ()) -> (IO CInt))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_m_totalForce_set"
btRigidBody_m_totalForce_set'_ :: ((Ptr ()) -> ((Ptr CFloat) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_m_totalForce_get"
btRigidBody_m_totalForce_get'_ :: ((Ptr ()) -> ((Ptr CFloat) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_m_totalTorque_set"
btRigidBody_m_totalTorque_set'_ :: ((Ptr ()) -> ((Ptr CFloat) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_m_totalTorque_get"
btRigidBody_m_totalTorque_get'_ :: ((Ptr ()) -> ((Ptr CFloat) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_m_turnVelocity_set"
btRigidBody_m_turnVelocity_set'_ :: ((Ptr ()) -> ((Ptr CFloat) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_m_turnVelocity_get"
btRigidBody_m_turnVelocity_get'_ :: ((Ptr ()) -> ((Ptr CFloat) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_btRigidBodyConstructionInfo_new"
btRigidBody_btRigidBodyConstructionInfo'_ :: (CFloat -> ((Ptr ()) -> ((Ptr ()) -> ((Ptr CFloat) -> (IO (Ptr ()))))))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_btRigidBodyConstructionInfo_free"
btRigidBody_btRigidBodyConstructionInfo_free'_ :: ((Ptr ()) -> (IO ()))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_btRigidBodyConstructionInfo_m_additionalAngularDampingFactor_set"
btRigidBody_btRigidBodyConstructionInfo_m_additionalAngularDampingFactor_set'_ :: ((Ptr ()) -> (CFloat -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_btRigidBodyConstructionInfo_m_additionalAngularDampingFactor_get"
btRigidBody_btRigidBodyConstructionInfo_m_additionalAngularDampingFactor_get'_ :: ((Ptr ()) -> (IO CFloat))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_btRigidBodyConstructionInfo_m_additionalAngularDampingThresholdSqr_set"
btRigidBody_btRigidBodyConstructionInfo_m_additionalAngularDampingThresholdSqr_set'_ :: ((Ptr ()) -> (CFloat -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_btRigidBodyConstructionInfo_m_additionalAngularDampingThresholdSqr_get"
btRigidBody_btRigidBodyConstructionInfo_m_additionalAngularDampingThresholdSqr_get'_ :: ((Ptr ()) -> (IO CFloat))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_btRigidBodyConstructionInfo_m_additionalDamping_set"
btRigidBody_btRigidBodyConstructionInfo_m_additionalDamping_set'_ :: ((Ptr ()) -> (CInt -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_btRigidBodyConstructionInfo_m_additionalDamping_get"
btRigidBody_btRigidBodyConstructionInfo_m_additionalDamping_get'_ :: ((Ptr ()) -> (IO CInt))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_btRigidBodyConstructionInfo_m_additionalDampingFactor_set"
btRigidBody_btRigidBodyConstructionInfo_m_additionalDampingFactor_set'_ :: ((Ptr ()) -> (CFloat -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_btRigidBodyConstructionInfo_m_additionalDampingFactor_get"
btRigidBody_btRigidBodyConstructionInfo_m_additionalDampingFactor_get'_ :: ((Ptr ()) -> (IO CFloat))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_btRigidBodyConstructionInfo_m_additionalLinearDampingThresholdSqr_set"
btRigidBody_btRigidBodyConstructionInfo_m_additionalLinearDampingThresholdSqr_set'_ :: ((Ptr ()) -> (CFloat -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_btRigidBodyConstructionInfo_m_additionalLinearDampingThresholdSqr_get"
btRigidBody_btRigidBodyConstructionInfo_m_additionalLinearDampingThresholdSqr_get'_ :: ((Ptr ()) -> (IO CFloat))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_btRigidBodyConstructionInfo_m_angularDamping_set"
btRigidBody_btRigidBodyConstructionInfo_m_angularDamping_set'_ :: ((Ptr ()) -> (CFloat -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_btRigidBodyConstructionInfo_m_angularDamping_get"
btRigidBody_btRigidBodyConstructionInfo_m_angularDamping_get'_ :: ((Ptr ()) -> (IO CFloat))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_btRigidBodyConstructionInfo_m_angularSleepingThreshold_set"
btRigidBody_btRigidBodyConstructionInfo_m_angularSleepingThreshold_set'_ :: ((Ptr ()) -> (CFloat -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_btRigidBodyConstructionInfo_m_angularSleepingThreshold_get"
btRigidBody_btRigidBodyConstructionInfo_m_angularSleepingThreshold_get'_ :: ((Ptr ()) -> (IO CFloat))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_btRigidBodyConstructionInfo_m_collisionShape_set"
btRigidBody_btRigidBodyConstructionInfo_m_collisionShape_set'_ :: ((Ptr ()) -> ((Ptr ()) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_btRigidBodyConstructionInfo_m_collisionShape_get"
btRigidBody_btRigidBodyConstructionInfo_m_collisionShape_get'_ :: ((Ptr ()) -> (IO (Ptr ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_btRigidBodyConstructionInfo_m_friction_set"
btRigidBody_btRigidBodyConstructionInfo_m_friction_set'_ :: ((Ptr ()) -> (CFloat -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_btRigidBodyConstructionInfo_m_friction_get"
btRigidBody_btRigidBodyConstructionInfo_m_friction_get'_ :: ((Ptr ()) -> (IO CFloat))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_btRigidBodyConstructionInfo_m_linearDamping_set"
btRigidBody_btRigidBodyConstructionInfo_m_linearDamping_set'_ :: ((Ptr ()) -> (CFloat -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_btRigidBodyConstructionInfo_m_linearDamping_get"
btRigidBody_btRigidBodyConstructionInfo_m_linearDamping_get'_ :: ((Ptr ()) -> (IO CFloat))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_btRigidBodyConstructionInfo_m_linearSleepingThreshold_set"
btRigidBody_btRigidBodyConstructionInfo_m_linearSleepingThreshold_set'_ :: ((Ptr ()) -> (CFloat -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_btRigidBodyConstructionInfo_m_linearSleepingThreshold_get"
btRigidBody_btRigidBodyConstructionInfo_m_linearSleepingThreshold_get'_ :: ((Ptr ()) -> (IO CFloat))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_btRigidBodyConstructionInfo_m_localInertia_set"
btRigidBody_btRigidBodyConstructionInfo_m_localInertia_set'_ :: ((Ptr ()) -> ((Ptr CFloat) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_btRigidBodyConstructionInfo_m_localInertia_get"
btRigidBody_btRigidBodyConstructionInfo_m_localInertia_get'_ :: ((Ptr ()) -> ((Ptr CFloat) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_btRigidBodyConstructionInfo_m_mass_set"
btRigidBody_btRigidBodyConstructionInfo_m_mass_set'_ :: ((Ptr ()) -> (CFloat -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_btRigidBodyConstructionInfo_m_mass_get"
btRigidBody_btRigidBodyConstructionInfo_m_mass_get'_ :: ((Ptr ()) -> (IO CFloat))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_btRigidBodyConstructionInfo_m_motionState_set"
btRigidBody_btRigidBodyConstructionInfo_m_motionState_set'_ :: ((Ptr ()) -> ((Ptr ()) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_btRigidBodyConstructionInfo_m_motionState_get"
btRigidBody_btRigidBodyConstructionInfo_m_motionState_get'_ :: ((Ptr ()) -> (IO (Ptr ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_btRigidBodyConstructionInfo_m_restitution_set"
btRigidBody_btRigidBodyConstructionInfo_m_restitution_set'_ :: ((Ptr ()) -> (CFloat -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_btRigidBodyConstructionInfo_m_restitution_get"
btRigidBody_btRigidBodyConstructionInfo_m_restitution_get'_ :: ((Ptr ()) -> (IO CFloat))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_btRigidBodyConstructionInfo_m_startWorldTransform_set"
btRigidBody_btRigidBodyConstructionInfo_m_startWorldTransform_set'_ :: ((Ptr ()) -> ((Ptr CFloat) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBody_btRigidBodyConstructionInfo_m_startWorldTransform_get"
btRigidBody_btRigidBodyConstructionInfo_m_startWorldTransform_get'_ :: ((Ptr ()) -> ((Ptr CFloat) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBodyDoubleData_new"
btRigidBodyDoubleData'_ :: (IO (Ptr ()))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBodyDoubleData_free"
btRigidBodyDoubleData_free'_ :: ((Ptr ()) -> (IO ()))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBodyDoubleData_m_collisionObjectData_set"
btRigidBodyDoubleData_m_collisionObjectData_set'_ :: ((Ptr ()) -> ((Ptr ()) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBodyDoubleData_m_collisionObjectData_get"
btRigidBodyDoubleData_m_collisionObjectData_get'_ :: ((Ptr ()) -> (IO (Ptr ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBodyDoubleData_m_invInertiaTensorWorld_set"
btRigidBodyDoubleData_m_invInertiaTensorWorld_set'_ :: ((Ptr ()) -> ((Ptr ()) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBodyDoubleData_m_invInertiaTensorWorld_get"
btRigidBodyDoubleData_m_invInertiaTensorWorld_get'_ :: ((Ptr ()) -> (IO (Ptr ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBodyDoubleData_m_linearVelocity_set"
btRigidBodyDoubleData_m_linearVelocity_set'_ :: ((Ptr ()) -> ((Ptr ()) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBodyDoubleData_m_linearVelocity_get"
btRigidBodyDoubleData_m_linearVelocity_get'_ :: ((Ptr ()) -> (IO (Ptr ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBodyDoubleData_m_angularVelocity_set"
btRigidBodyDoubleData_m_angularVelocity_set'_ :: ((Ptr ()) -> ((Ptr ()) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBodyDoubleData_m_angularVelocity_get"
btRigidBodyDoubleData_m_angularVelocity_get'_ :: ((Ptr ()) -> (IO (Ptr ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBodyDoubleData_m_angularFactor_set"
btRigidBodyDoubleData_m_angularFactor_set'_ :: ((Ptr ()) -> ((Ptr ()) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBodyDoubleData_m_angularFactor_get"
btRigidBodyDoubleData_m_angularFactor_get'_ :: ((Ptr ()) -> (IO (Ptr ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBodyDoubleData_m_linearFactor_set"
btRigidBodyDoubleData_m_linearFactor_set'_ :: ((Ptr ()) -> ((Ptr ()) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBodyDoubleData_m_linearFactor_get"
btRigidBodyDoubleData_m_linearFactor_get'_ :: ((Ptr ()) -> (IO (Ptr ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBodyDoubleData_m_gravity_set"
btRigidBodyDoubleData_m_gravity_set'_ :: ((Ptr ()) -> ((Ptr ()) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBodyDoubleData_m_gravity_get"
btRigidBodyDoubleData_m_gravity_get'_ :: ((Ptr ()) -> (IO (Ptr ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBodyDoubleData_m_gravity_acceleration_set"
btRigidBodyDoubleData_m_gravity_acceleration_set'_ :: ((Ptr ()) -> ((Ptr ()) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBodyDoubleData_m_gravity_acceleration_get"
btRigidBodyDoubleData_m_gravity_acceleration_get'_ :: ((Ptr ()) -> (IO (Ptr ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBodyDoubleData_m_invInertiaLocal_set"
btRigidBodyDoubleData_m_invInertiaLocal_set'_ :: ((Ptr ()) -> ((Ptr ()) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBodyDoubleData_m_invInertiaLocal_get"
btRigidBodyDoubleData_m_invInertiaLocal_get'_ :: ((Ptr ()) -> (IO (Ptr ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBodyDoubleData_m_totalForce_set"
btRigidBodyDoubleData_m_totalForce_set'_ :: ((Ptr ()) -> ((Ptr ()) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBodyDoubleData_m_totalForce_get"
btRigidBodyDoubleData_m_totalForce_get'_ :: ((Ptr ()) -> (IO (Ptr ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBodyDoubleData_m_totalTorque_set"
btRigidBodyDoubleData_m_totalTorque_set'_ :: ((Ptr ()) -> ((Ptr ()) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBodyDoubleData_m_totalTorque_get"
btRigidBodyDoubleData_m_totalTorque_get'_ :: ((Ptr ()) -> (IO (Ptr ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBodyDoubleData_m_inverseMass_set"
btRigidBodyDoubleData_m_inverseMass_set'_ :: ((Ptr ()) -> (CDouble -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBodyDoubleData_m_inverseMass_get"
btRigidBodyDoubleData_m_inverseMass_get'_ :: ((Ptr ()) -> (IO CDouble))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBodyDoubleData_m_linearDamping_set"
btRigidBodyDoubleData_m_linearDamping_set'_ :: ((Ptr ()) -> (CDouble -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBodyDoubleData_m_linearDamping_get"
btRigidBodyDoubleData_m_linearDamping_get'_ :: ((Ptr ()) -> (IO CDouble))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBodyDoubleData_m_angularDamping_set"
btRigidBodyDoubleData_m_angularDamping_set'_ :: ((Ptr ()) -> (CDouble -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBodyDoubleData_m_angularDamping_get"
btRigidBodyDoubleData_m_angularDamping_get'_ :: ((Ptr ()) -> (IO CDouble))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBodyDoubleData_m_additionalDampingFactor_set"
btRigidBodyDoubleData_m_additionalDampingFactor_set'_ :: ((Ptr ()) -> (CDouble -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBodyDoubleData_m_additionalDampingFactor_get"
btRigidBodyDoubleData_m_additionalDampingFactor_get'_ :: ((Ptr ()) -> (IO CDouble))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBodyDoubleData_m_additionalLinearDampingThresholdSqr_set"
btRigidBodyDoubleData_m_additionalLinearDampingThresholdSqr_set'_ :: ((Ptr ()) -> (CDouble -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBodyDoubleData_m_additionalLinearDampingThresholdSqr_get"
btRigidBodyDoubleData_m_additionalLinearDampingThresholdSqr_get'_ :: ((Ptr ()) -> (IO CDouble))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBodyDoubleData_m_additionalAngularDampingThresholdSqr_set"
btRigidBodyDoubleData_m_additionalAngularDampingThresholdSqr_set'_ :: ((Ptr ()) -> (CDouble -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBodyDoubleData_m_additionalAngularDampingThresholdSqr_get"
btRigidBodyDoubleData_m_additionalAngularDampingThresholdSqr_get'_ :: ((Ptr ()) -> (IO CDouble))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBodyDoubleData_m_additionalAngularDampingFactor_set"
btRigidBodyDoubleData_m_additionalAngularDampingFactor_set'_ :: ((Ptr ()) -> (CDouble -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBodyDoubleData_m_additionalAngularDampingFactor_get"
btRigidBodyDoubleData_m_additionalAngularDampingFactor_get'_ :: ((Ptr ()) -> (IO CDouble))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBodyDoubleData_m_linearSleepingThreshold_set"
btRigidBodyDoubleData_m_linearSleepingThreshold_set'_ :: ((Ptr ()) -> (CDouble -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBodyDoubleData_m_linearSleepingThreshold_get"
btRigidBodyDoubleData_m_linearSleepingThreshold_get'_ :: ((Ptr ()) -> (IO CDouble))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBodyDoubleData_m_angularSleepingThreshold_set"
btRigidBodyDoubleData_m_angularSleepingThreshold_set'_ :: ((Ptr ()) -> (CDouble -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBodyDoubleData_m_angularSleepingThreshold_get"
btRigidBodyDoubleData_m_angularSleepingThreshold_get'_ :: ((Ptr ()) -> (IO CDouble))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBodyDoubleData_m_additionalDamping_set"
btRigidBodyDoubleData_m_additionalDamping_set'_ :: ((Ptr ()) -> (CInt -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBodyDoubleData_m_additionalDamping_get"
btRigidBodyDoubleData_m_additionalDamping_get'_ :: ((Ptr ()) -> (IO CInt))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBodyFloatData_new"
btRigidBodyFloatData'_ :: (IO (Ptr ()))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBodyFloatData_free"
btRigidBodyFloatData_free'_ :: ((Ptr ()) -> (IO ()))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBodyFloatData_m_additionalAngularDampingFactor_set"
btRigidBodyFloatData_m_additionalAngularDampingFactor_set'_ :: ((Ptr ()) -> (CFloat -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBodyFloatData_m_additionalAngularDampingFactor_get"
btRigidBodyFloatData_m_additionalAngularDampingFactor_get'_ :: ((Ptr ()) -> (IO CFloat))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBodyFloatData_m_additionalAngularDampingThresholdSqr_set"
btRigidBodyFloatData_m_additionalAngularDampingThresholdSqr_set'_ :: ((Ptr ()) -> (CFloat -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBodyFloatData_m_additionalAngularDampingThresholdSqr_get"
btRigidBodyFloatData_m_additionalAngularDampingThresholdSqr_get'_ :: ((Ptr ()) -> (IO CFloat))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBodyFloatData_m_additionalDamping_set"
btRigidBodyFloatData_m_additionalDamping_set'_ :: ((Ptr ()) -> (CInt -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBodyFloatData_m_additionalDamping_get"
btRigidBodyFloatData_m_additionalDamping_get'_ :: ((Ptr ()) -> (IO CInt))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBodyFloatData_m_additionalDampingFactor_set"
btRigidBodyFloatData_m_additionalDampingFactor_set'_ :: ((Ptr ()) -> (CFloat -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBodyFloatData_m_additionalDampingFactor_get"
btRigidBodyFloatData_m_additionalDampingFactor_get'_ :: ((Ptr ()) -> (IO CFloat))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBodyFloatData_m_additionalLinearDampingThresholdSqr_set"
btRigidBodyFloatData_m_additionalLinearDampingThresholdSqr_set'_ :: ((Ptr ()) -> (CFloat -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBodyFloatData_m_additionalLinearDampingThresholdSqr_get"
btRigidBodyFloatData_m_additionalLinearDampingThresholdSqr_get'_ :: ((Ptr ()) -> (IO CFloat))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBodyFloatData_m_angularDamping_set"
btRigidBodyFloatData_m_angularDamping_set'_ :: ((Ptr ()) -> (CFloat -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBodyFloatData_m_angularDamping_get"
btRigidBodyFloatData_m_angularDamping_get'_ :: ((Ptr ()) -> (IO CFloat))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBodyFloatData_m_angularFactor_set"
btRigidBodyFloatData_m_angularFactor_set'_ :: ((Ptr ()) -> ((Ptr ()) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBodyFloatData_m_angularFactor_get"
btRigidBodyFloatData_m_angularFactor_get'_ :: ((Ptr ()) -> (IO (Ptr ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBodyFloatData_m_angularSleepingThreshold_set"
btRigidBodyFloatData_m_angularSleepingThreshold_set'_ :: ((Ptr ()) -> (CFloat -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBodyFloatData_m_angularSleepingThreshold_get"
btRigidBodyFloatData_m_angularSleepingThreshold_get'_ :: ((Ptr ()) -> (IO CFloat))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBodyFloatData_m_angularVelocity_set"
btRigidBodyFloatData_m_angularVelocity_set'_ :: ((Ptr ()) -> ((Ptr ()) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBodyFloatData_m_angularVelocity_get"
btRigidBodyFloatData_m_angularVelocity_get'_ :: ((Ptr ()) -> (IO (Ptr ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBodyFloatData_m_collisionObjectData_set"
btRigidBodyFloatData_m_collisionObjectData_set'_ :: ((Ptr ()) -> ((Ptr ()) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBodyFloatData_m_collisionObjectData_get"
btRigidBodyFloatData_m_collisionObjectData_get'_ :: ((Ptr ()) -> (IO (Ptr ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBodyFloatData_m_gravity_set"
btRigidBodyFloatData_m_gravity_set'_ :: ((Ptr ()) -> ((Ptr ()) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBodyFloatData_m_gravity_get"
btRigidBodyFloatData_m_gravity_get'_ :: ((Ptr ()) -> (IO (Ptr ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBodyFloatData_m_gravity_acceleration_set"
btRigidBodyFloatData_m_gravity_acceleration_set'_ :: ((Ptr ()) -> ((Ptr ()) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBodyFloatData_m_gravity_acceleration_get"
btRigidBodyFloatData_m_gravity_acceleration_get'_ :: ((Ptr ()) -> (IO (Ptr ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBodyFloatData_m_invInertiaLocal_set"
btRigidBodyFloatData_m_invInertiaLocal_set'_ :: ((Ptr ()) -> ((Ptr ()) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBodyFloatData_m_invInertiaLocal_get"
btRigidBodyFloatData_m_invInertiaLocal_get'_ :: ((Ptr ()) -> (IO (Ptr ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBodyFloatData_m_invInertiaTensorWorld_set"
btRigidBodyFloatData_m_invInertiaTensorWorld_set'_ :: ((Ptr ()) -> ((Ptr ()) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBodyFloatData_m_invInertiaTensorWorld_get"
btRigidBodyFloatData_m_invInertiaTensorWorld_get'_ :: ((Ptr ()) -> (IO (Ptr ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBodyFloatData_m_inverseMass_set"
btRigidBodyFloatData_m_inverseMass_set'_ :: ((Ptr ()) -> (CFloat -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBodyFloatData_m_inverseMass_get"
btRigidBodyFloatData_m_inverseMass_get'_ :: ((Ptr ()) -> (IO CFloat))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBodyFloatData_m_linearDamping_set"
btRigidBodyFloatData_m_linearDamping_set'_ :: ((Ptr ()) -> (CFloat -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBodyFloatData_m_linearDamping_get"
btRigidBodyFloatData_m_linearDamping_get'_ :: ((Ptr ()) -> (IO CFloat))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBodyFloatData_m_linearFactor_set"
btRigidBodyFloatData_m_linearFactor_set'_ :: ((Ptr ()) -> ((Ptr ()) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBodyFloatData_m_linearFactor_get"
btRigidBodyFloatData_m_linearFactor_get'_ :: ((Ptr ()) -> (IO (Ptr ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBodyFloatData_m_linearSleepingThreshold_set"
btRigidBodyFloatData_m_linearSleepingThreshold_set'_ :: ((Ptr ()) -> (CFloat -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBodyFloatData_m_linearSleepingThreshold_get"
btRigidBodyFloatData_m_linearSleepingThreshold_get'_ :: ((Ptr ()) -> (IO CFloat))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBodyFloatData_m_linearVelocity_set"
btRigidBodyFloatData_m_linearVelocity_set'_ :: ((Ptr ()) -> ((Ptr ()) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBodyFloatData_m_linearVelocity_get"
btRigidBodyFloatData_m_linearVelocity_get'_ :: ((Ptr ()) -> (IO (Ptr ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBodyFloatData_m_totalForce_set"
btRigidBodyFloatData_m_totalForce_set'_ :: ((Ptr ()) -> ((Ptr ()) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBodyFloatData_m_totalForce_get"
btRigidBodyFloatData_m_totalForce_get'_ :: ((Ptr ()) -> (IO (Ptr ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBodyFloatData_m_totalTorque_set"
btRigidBodyFloatData_m_totalTorque_set'_ :: ((Ptr ()) -> ((Ptr ()) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btRigidBodyFloatData_m_totalTorque_get"
btRigidBodyFloatData_m_totalTorque_get'_ :: ((Ptr ()) -> (IO (Ptr ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btSimpleDynamicsWorld_new"
btSimpleDynamicsWorld'_ :: ((Ptr ()) -> ((Ptr ()) -> ((Ptr ()) -> ((Ptr ()) -> (IO (Ptr ()))))))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btSimpleDynamicsWorld_free"
btSimpleDynamicsWorld_free'_ :: ((Ptr ()) -> (IO ()))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btSimpleDynamicsWorld_predictUnconstraintMotion"
btSimpleDynamicsWorld_predictUnconstraintMotion'_ :: ((Ptr ()) -> (CFloat -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btSimpleDynamicsWorld_setGravity"
btSimpleDynamicsWorld_setGravity'_ :: ((Ptr ()) -> ((Ptr CFloat) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btSimpleDynamicsWorld_setGravity"
btSimpleDynamicsWorld_setGravity''_ :: ((Ptr ()) -> ((Ptr CFloat) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btSimpleDynamicsWorld_addAction"
btSimpleDynamicsWorld_addAction'_ :: ((Ptr ()) -> ((Ptr ()) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btSimpleDynamicsWorld_synchronizeMotionStates"
btSimpleDynamicsWorld_synchronizeMotionStates'_ :: ((Ptr ()) -> (IO ()))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btSimpleDynamicsWorld_setConstraintSolver"
btSimpleDynamicsWorld_setConstraintSolver'_ :: ((Ptr ()) -> ((Ptr ()) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btSimpleDynamicsWorld_stepSimulation"
btSimpleDynamicsWorld_stepSimulation'_ :: ((Ptr ()) -> (CFloat -> (CInt -> (CFloat -> (IO CInt)))))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btSimpleDynamicsWorld_getConstraintSolver"
btSimpleDynamicsWorld_getConstraintSolver'_ :: ((Ptr ()) -> (IO (Ptr ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btSimpleDynamicsWorld_removeRigidBody"
btSimpleDynamicsWorld_removeRigidBody'_ :: ((Ptr ()) -> ((Ptr ()) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btSimpleDynamicsWorld_addRigidBody0"
btSimpleDynamicsWorld_addRigidBody'_ :: ((Ptr ()) -> ((Ptr ()) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btSimpleDynamicsWorld_addRigidBody0"
btSimpleDynamicsWorld_addRigidBody0'_ :: ((Ptr ()) -> ((Ptr ()) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btSimpleDynamicsWorld_addRigidBody1"
btSimpleDynamicsWorld_addRigidBody1'_ :: ((Ptr ()) -> ((Ptr ()) -> (CShort -> (CShort -> (IO ())))))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btSimpleDynamicsWorld_getGravity"
btSimpleDynamicsWorld_getGravity'_ :: ((Ptr ()) -> ((Ptr CFloat) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btSimpleDynamicsWorld_integrateTransforms"
btSimpleDynamicsWorld_integrateTransforms'_ :: ((Ptr ()) -> (CFloat -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btSimpleDynamicsWorld_removeCollisionObject"
btSimpleDynamicsWorld_removeCollisionObject'_ :: ((Ptr ()) -> ((Ptr ()) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btSimpleDynamicsWorld_clearForces"
btSimpleDynamicsWorld_clearForces'_ :: ((Ptr ()) -> (IO ()))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btSimpleDynamicsWorld_removeAction"
btSimpleDynamicsWorld_removeAction'_ :: ((Ptr ()) -> ((Ptr ()) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btSimpleDynamicsWorld_updateAabbs"
btSimpleDynamicsWorld_updateAabbs'_ :: ((Ptr ()) -> (IO ()))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btSimpleDynamicsWorld_debugDrawWorld"
btSimpleDynamicsWorld_debugDrawWorld'_ :: ((Ptr ()) -> (IO ()))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btSimpleDynamicsWorld_m_constraintSolver_set"
btSimpleDynamicsWorld_m_constraintSolver_set'_ :: ((Ptr ()) -> ((Ptr ()) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btSimpleDynamicsWorld_m_constraintSolver_get"
btSimpleDynamicsWorld_m_constraintSolver_get'_ :: ((Ptr ()) -> (IO (Ptr ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btSimpleDynamicsWorld_m_ownsConstraintSolver_set"
btSimpleDynamicsWorld_m_ownsConstraintSolver_set'_ :: ((Ptr ()) -> (CInt -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btSimpleDynamicsWorld_m_ownsConstraintSolver_get"
btSimpleDynamicsWorld_m_ownsConstraintSolver_get'_ :: ((Ptr ()) -> (IO CInt))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btSimpleDynamicsWorld_m_gravity_set"
btSimpleDynamicsWorld_m_gravity_set'_ :: ((Ptr ()) -> ((Ptr CFloat) -> (IO ())))
foreign import ccall safe "Physics/Bullet/Raw/BulletDynamics/Dynamics.chs.h btSimpleDynamicsWorld_m_gravity_get"
btSimpleDynamicsWorld_m_gravity_get'_ :: ((Ptr ()) -> ((Ptr CFloat) -> (IO ())))