{-# CFILES cbits/bullet.c #-}  -- for Hugs (?)
module Physics.Bullet (
    PlQuaternion, PlVector3, PlRayCastResult, PlMatrix,
    PlPhysicsSdkHandle, PlDynamicsWorldHandle, PlRigidBodyHandle, PlUserDataHandle, PlCollisionShapeHandle, PlMeshInterfaceHandle,
    plNewBulletSdk, plDeletePhysicsSdk,
--	plCreateSapBroadphase, plDestroyBroadphase,
--	plCreateProxy, plDestroyProxy, plSetBoundingBox,
--	plCreateCollisionWorld,
    plCreateDynamicsWorld, plDeleteDynamicsWorld, plStepSimulation, plAddRigidBody, plRemoveRigidBody,
    plCreateRigidBody, plDeleteRigidBody,
    plNewSphereShape, plNewBoxShape, plNewCapsuleShape, plNewConeShape, plNewCylinderShape, plNewCompoundShape,

    plAddChildShape, plDeleteShape, plNewConvexHullShape, plAddVertex, plNewMeshInterface,
	plAddTriangle, plNewStaticTriangleMeshShape,plNewGimpactTriangleMeshShape,plNewConvexTriangleMeshShape,
    plSetScaling, plGetOpenGLMatrix, plGetPosition, plGetOrientation, plSetPosition, plSetOrientation, plSetEuler
--	plRayCast

) where

import Foreign
import Foreign.C.Types
import Foreign.Marshal.Array
{-
typedef float 	plVector3[3];
typedef float 	plQuaternion[4];
typedef float 	plVehicleTuning[5];

typedef struct plRayCastResult {
	plRigidBodyHandle		m_body;  
	plCollisionShapeHandle	m_shape; 		
	plVector3				m_positionWorld; 		
	plVector3				m_normalWorld;
} plRayCastResult;
-}
--plRayCastResult
--type PlRayCastResult = Ptr ()
data PlRayCastResult_ = PlRayCastResult_ PlRigidBodyHandle PlCollisionShapeHandle PlVector3 PlVector3
type PlRayCastResult = Ptr PlRayCastResult_

type PlQuaternion = Ptr CFloat

type PlVector3 = Ptr CFloat

type PlMatrix = Ptr CFloat

type PlVehicleTuning = Ptr CFloat

-----------------------------------------
data PlPhysicsSdk = PlPhysicsSdk
type PlPhysicsSdkHandle = Ptr PlPhysicsSdk

data PlDynamicsWorld = PlDynamicsWorld
type PlDynamicsWorldHandle = Ptr PlDynamicsWorld

data PlRigidBody = PlRigidBody
type PlRigidBodyHandle = Ptr PlRigidBody

type PlUserDataHandle = Ptr ()

data PlCollisionShape = PlCollisionShape
type PlCollisionShapeHandle = Ptr PlCollisionShape

data PlMeshInterface = PlMeshInterface
type PlMeshInterfaceHandle = Ptr PlMeshInterface

foreign import ccall unsafe "plNewBulletSdk"                plNewBulletSdk                  :: IO PlPhysicsSdkHandle
foreign import ccall unsafe "plDeletePhysicsSdk"		    plDeletePhysicsSdk              :: PlPhysicsSdkHandle -> IO ()
--foreign import ccall "plCreateSapBroadphase"              plCreateSapBroadphase           :: Ptr a -> Ptr a -> IO (Ptr a)
--foreign import ccall "plDestroyBroadphase"                plDestroyBroadphase             :: Ptr a -> IO()
--foreign import ccall "plCreateProxy"                      plCreateProxy                   :: Ptr a -> Ptr a -> CCFloat -> CCFloat -> CCFloat -> CCFloat -> CCFloat -> CCFloat -> IO( Ptr a )
--foreign import ccall "plDestroyProxy"                     plDestroyProxy                  :: Ptr a -> Ptr a -> IO()
--foreign import ccall "plSetBoundingBox"                   plSetBoundingBox                :: Ptr a -> CCFloat -> CCFloat -> CCFloat -> CCFloat -> CCFloat -> CCFloat -> IO()
--foreign import ccall "plCreateCollisionWorld"             plCreateCollisionWorld          :: Ptr a -> IO( Ptr a )
foreign import ccall unsafe "plCreateDynamicsWorld"         plCreateDynamicsWorld           :: PlPhysicsSdkHandle -> IO PlDynamicsWorldHandle
foreign import ccall unsafe "plDeleteDynamicsWorld"         plDeleteDynamicsWorld           :: PlDynamicsWorldHandle -> IO ()
foreign import ccall unsafe "plStepSimulation"              plStepSimulation                :: PlDynamicsWorldHandle -> CFloat -> IO ()
foreign import ccall unsafe "plAddRigidBody"                plAddRigidBody                  :: PlDynamicsWorldHandle -> PlRigidBodyHandle -> IO ()
foreign import ccall unsafe "plRemoveRigidBody"             plRemoveRigidBody               :: PlDynamicsWorldHandle -> PlRigidBodyHandle -> IO ()
foreign import ccall unsafe "plCreateRigidBody"             plCreateRigidBody               :: PlUserDataHandle -> CFloat -> PlCollisionShapeHandle -> IO PlRigidBodyHandle
foreign import ccall unsafe "plDeleteRigidBody"             plDeleteRigidBody               :: PlRigidBodyHandle -> IO ()
foreign import ccall unsafe "plNewSphereShape"              plNewSphereShape                :: CFloat -> IO PlCollisionShapeHandle
foreign import ccall unsafe "plNewBoxShape"                 plNewBoxShape                   :: CFloat -> CFloat -> CFloat -> IO PlCollisionShapeHandle
foreign import ccall unsafe "plNewCapsuleShape"             plNewCapsuleShape               :: CFloat -> CFloat -> IO PlCollisionShapeHandle
foreign import ccall unsafe "plNewConeShape"                plNewConeShape                  :: CFloat -> CFloat -> IO PlCollisionShapeHandle
foreign import ccall unsafe "plNewCylinderShape"            plNewCylinderShape              :: CFloat -> CFloat -> IO PlCollisionShapeHandle
foreign import ccall unsafe "plNewCompoundShape"            plNewCompoundShape              :: IO PlCollisionShapeHandle
foreign import ccall unsafe "plAddChildShape"               plAddChildShape_                :: PlCollisionShapeHandle -> PlCollisionShapeHandle -> PlVector3 -> PlQuaternion -> IO ()
foreign import ccall unsafe "plDeleteShape"                 plDeleteShape                   :: PlCollisionShapeHandle -> IO ()
foreign import ccall unsafe "plNewConvexHullShape"          plNewConvexHullShape            :: Ptr CFloat -> Int -> Int -> IO PlCollisionShapeHandle

foreign import ccall unsafe "plAddVertex"                   plAddVertex                     :: PlCollisionShapeHandle -> CFloat -> CFloat -> CFloat -> IO ()

foreign import ccall unsafe "plNewMeshInterface"            plNewMeshInterface              :: IO PlMeshInterfaceHandle
foreign import ccall unsafe "plAddTriangle"                 plAddTriangle_                  :: PlMeshInterfaceHandle -> PlVector3 -> PlVector3 -> PlVector3 -> Int -> IO ()
foreign import ccall unsafe "plNewStaticTriangleMeshShape"  plNewStaticTriangleMeshShape    :: PlMeshInterfaceHandle -> IO PlCollisionShapeHandle
foreign import ccall unsafe "plNewGimpactTriangleMeshShape" plNewGimpactTriangleMeshShape   :: PlMeshInterfaceHandle -> IO PlCollisionShapeHandle
foreign import ccall unsafe "plNewConvexTriangleMeshShape"  plNewConvexTriangleMeshShape    :: PlMeshInterfaceHandle -> IO PlCollisionShapeHandle

foreign import ccall unsafe "plSetScaling"                  plSetScaling_                   :: PlCollisionShapeHandle -> PlVector3 -> IO ()
foreign import ccall unsafe "plGetOpenGLMatrix"             plGetOpenGLMatrix_              :: PlRigidBodyHandle -> PlMatrix -> IO ()
foreign import ccall unsafe "plGetPosition"                 plGetPosition_                  :: PlRigidBodyHandle -> PlVector3 -> IO ()
foreign import ccall unsafe "plGetOrientation"              plGetOrientation_               :: PlRigidBodyHandle -> PlQuaternion -> IO ()
foreign import ccall unsafe "plSetPosition"                 plSetPosition_                  :: PlRigidBodyHandle -> PlVector3 -> IO ()
foreign import ccall unsafe "plSetOrientation"              plSetOrientation_               :: PlRigidBodyHandle -> PlQuaternion -> IO ()
foreign import ccall unsafe "plSetEuler"                    plSetEuler                      :: CFloat -> CFloat -> CFloat -> PlQuaternion -> IO ()
foreign import ccall unsafe "plRayCast"                     plRayCast                       :: PlDynamicsWorldHandle -> PlVector3 -> PlVector3 -> PlRayCastResult -> IO Int

-- TODO : new functions
{-
plCreateRaycastVehicle :: PlVehicleTuning -> PlRigidBodyHandle -> IO PlRaycastVehicleHandle
plAddVehicle :: PlDynamicsWorldHandle -> PlRaycastVehicleHandle -> IO ()
plSetCoordinateSystem :: PlRaycastVehicleHandle -> Int -> Int -> Int -> IO ()
plAddWheel :: PlCFloat3 -> PlCFloat3 -> PlCFloat3 -> CFloat -> CFloat -> PlCFloat5 -> Bool -> IO (wheelinfo ????)


	btRaycastVehicle::btVehicleTuning	m_tuning;
	btVehicleRaycaster*	m_vehicleRayCaster;
	btRaycastVehicle*	m_vehicle;
	btCollisionShape*	m_wheelShape;

	btWheelInfo&	addWheel( const btVector3& connectionPointCS0, const btVector3& wheelDirectionCS0,const btVector3& wheelAxleCS,btScalar suspensionRestLength,btScalar wheelRadius,const btVehicleTuning& tuning, bool isFrontWheel);

	class btVehicleTuning
		{
			public:

			btVehicleTuning()
				:m_suspensionStiffness(btScalar(5.88)),
				m_suspensionCompression(btScalar(0.83)),
				m_suspensionDamping(btScalar(0.88)),
				m_maxSuspensionTravelCm(btScalar(500.)),
				m_frictionSlip(btScalar(10.5))
			{
			}
			btScalar	m_suspensionStiffness;
			btScalar	m_suspensionCompression;
			btScalar	m_suspensionDamping;
			btScalar	m_maxSuspensionTravelCm;
			btScalar	m_frictionSlip;

		};
-}

-- more nice wrappers
plGetOpenGLMatrix body =
    allocaArray 16 f
  where
    f p = do
        plGetOpenGLMatrix_ body p
        e0 <- peekElemOff p 0
        e1 <- peekElemOff p 1
        e2 <- peekElemOff p 2
        e3 <- peekElemOff p 3
        e4 <- peekElemOff p 4
        e5 <- peekElemOff p 5
        e6 <- peekElemOff p 6
        e7 <- peekElemOff p 7
        e8 <- peekElemOff p 8
        e9 <- peekElemOff p 9
        eA <- peekElemOff p 10
        eB <- peekElemOff p 11
        eC <- peekElemOff p 12
        eD <- peekElemOff p 13
        eE <- peekElemOff p 14
        eF <- peekElemOff p 15
        return (e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,eA,eB,eC,eD,eE,eF)
        --mapM (peekElemOff m) [0..15]

packCFloat3 p (x,y,z) = do
    pokeElemOff p 0  x 
    pokeElemOff p 1  y
    pokeElemOff p 2  z

unpackCFloat3 p = do
    x <- peekElemOff p 0
    y <- peekElemOff p 1
    z <- peekElemOff p 2
    return (x,y,z)

packCFloat4 p (x,y,z,w) = do
    pokeElemOff p 0 x 
    pokeElemOff p 1 y
    pokeElemOff p 2 z
    pokeElemOff p 3 w

unpackCFloat4 p = do
    x <- peekElemOff p 0
    y <- peekElemOff p 1
    z <- peekElemOff p 2
    w <- peekElemOff p 3
    return (x,y,z,w)

packCFloat5 p (x,y,z,w,q) = do
    pokeElemOff p 0 x 
    pokeElemOff p 1 y
    pokeElemOff p 2 z
    pokeElemOff p 3 w
    pokeElemOff p 4 q

unpackCFloat5 p = do
    x <- peekElemOff p 0
    y <- peekElemOff p 1
    z <- peekElemOff p 2
    w <- peekElemOff p 3
    q <- peekElemOff p 4
    return (x,y,z,w,q)

plGetPosition body =
    allocaArray 3 f
  where
    f p = do
        plGetPosition_ body p
        unpackCFloat3 p

plSetPosition b pos =
    allocaArray 3 f
  where
    f p = do
        packCFloat3 p pos
        plSetPosition_ b p

plGetOrientation body =
    allocaArray 4 f
  where
    f p = do
        plGetOrientation_ body p
        unpackCFloat4 p

plSetOrientation b o =
    allocaArray 4 f
  where
    f p = do
        packCFloat4 p o
        plSetOrientation_ b p

plAddChildShape compShape chShape chPos chOrig =
    allocaArray 7 f
  where
    f p = do
        packCFloat3 p chPos
        packCFloat4 (advancePtr p 3) chOrig
        plAddChildShape_ compShape chShape p (advancePtr p 3)

plAddTriangle meshInterface v0 v1 v2 rmDup =
    allocaArray 9 f
  where
    f p = do
        packCFloat3 p v0
        packCFloat3 (advancePtr p 3) v1
        packCFloat3 (advancePtr p 6) v2
        plAddTriangle_ meshInterface p (advancePtr p 3) (advancePtr p 6) $ if rmDup then 1 else 0

plSetScaling shape v =
    allocaArray 3 f
  where
    f p = do
        packCFloat3 p v
        plSetScaling_ shape p