dgContact.h

/* Copyright (c) <2003-2011> <Julio Jerez, Newton Game Dynamics>
*
* This software is provided 'as-is', without any express or implied
* warranty. In no event will the authors be held liable for any damages
* arising from the use of this software.
*
* Permission is granted to anyone to use this software for any purpose,
* including commercial applications, and to alter it and redistribute it
* freely, subject to the following restrictions:
*
* 1. The origin of this software must not be misrepresented; you must not
* claim that you wrote the original software. If you use this software
* in a product, an acknowledgment in the product documentation would be
* appreciated but is not required.
*
* 2. Altered source versions must be plainly marked as such, and must not be
* misrepresented as being the original software.
*
* 3. This notice may not be removed or altered from any source distribution.
*/

#if !defined(AFX_DGCONTACT_H__BDE5B2AC_5834_46FD_A994_65D855788F69__INCLUDED_)
#define AFX_DGCONTACT_H__BDE5B2AC_5834_46FD_A994_65D855788F69__INCLUDED_


#include "dgConstraint.h"


class dgBody;
class dgWorld;
class dgContact;
class dgCollision;
class dgContactPoint;
class dgContactMaterial;
class dgPolygonMeshDesc;


#define DG_MAX_CONTATCS         128
#define DG_CACHE_PAIR_BUFFER    256

typedef int(dgApi *OnAABBOverlap)(const NewtonMaterial *const material, const NewtonBody *const body0, const NewtonBody *const body1, int32 threadIndex);
typedef void(dgApi *OnContactCallback)(const NewtonJoint *const contact, dFloat timestep, int32 threadIndex);

class dgActiveContacts: public dgList<dgContact *> {
public:
    dgActiveContacts(dgMemoryAllocator *const allocator)
        : dgList<dgContact*>(allocator) {
    }
};

class dgCollidingPairCollector {
public:
    struct dgPair {
        dgBody *m_body0;
        dgBody *m_body1;
        dgContact *m_contact;
        const dgContactMaterial *m_material;
        dgContactPoint *m_contactBuffer;
        dgInt16 m_contactCount;
        dgInt16 m_isTrigger;
    };

    struct dgThreadPairCache {
        dgInt32 m_count;
        dgPair m_chacheBuffer[DG_CACHE_PAIR_BUFFER];
    };
    dgThreadPairCache *m_chacheBuffers[DG_MAXIMUN_THREADS];


    dgCollidingPairCollector();
    ~dgCollidingPairCollector();

    void Init();
    void SetCaches(dgThreadPairCache *const chaches);
    void FlushChache(dgThreadPairCache *const chache);
    void AddPair(dgBody *const body0, dgBody *const body1, dgInt32 threadIndex);


    dgPair *m_pairs;
    dgInt32 m_count;
    dgInt32 m_maxSize;
    dgBody *m_sentinel;
};



DG_MSC_VECTOR_ALIGMENT
class dgContactPoint {
public:
    dgVector m_point;
    dgVector m_normal;
    dgBody *m_body0;
    dgBody *m_body1;
    dgCollision *m_collision0;
    dgCollision *m_collision1;
    dgInt64 m_userId;
    dgFloat32 m_penetration;
    dgInt32 m_isEdgeContact;
} DG_GCC_VECTOR_ALIGMENT;

DG_MSC_VECTOR_ALIGMENT
class dgCollisionParamProxy {
public:
    dgBody *m_floatingBody;
    dgBody *m_referenceBody;
    dgCollision *m_floatingCollision;
    dgCollision *m_referenceCollision;
    dgMatrix m_floatingMatrix;
    dgMatrix m_referenceMatrix;
    dgFloat32 m_timestep;
    dgFloat32 m_penetrationPadding;
    dgInt32 m_continueCollision;
    dgInt32 m_unconditionalCast;
    dgInt32 m_threadIndex;
    dgInt32 m_maxContacts;
    dgContactPoint *m_contacts;

    // used but Mink solver
    const dgMatrix *m_localMatrixInv;
    const dgPolygonMeshDesc *m_polyMeshData;

    dgUnsigned32 m_isTriggerVolume : 1;
    dgUnsigned32 m_inTriggerVolume : 1;


    dgCollisionParamProxy(dgInt32 threadIndex) {
        m_threadIndex = threadIndex;
        m_polyMeshData = NULL;
        m_localMatrixInv = NULL;
//      m_projectContinueCollisionContacts = 1;
    }

} DG_GCC_VECTOR_ALIGMENT;



DG_MSC_VECTOR_ALIGMENT
class dgContactMaterial: public dgContactPoint {
public:

    enum {
        m_collisionEnable__ = 1 << 0,
        m_friction0Enable__ = 1 << 1,
        m_friction1Enable__ = 1 << 2,
        m_override0Accel__ = 1 << 3,
        m_override1Accel__ = 1 << 4,
        m_overrideNormalAccel__ = 1 << 5,
        m_collisionContinueCollisionEnable__ = 1 << 6,
    };

    dgContactMaterial();
    void *GetUserData() const;
    void SetUserData(void *const userData);
    void SetCollisionCallback(OnAABBOverlap abbOvelap, OnContactCallback callback);
    void SetCompoundCollisionCallback(OnAABBOverlap abbOvelap);

    dgVector m_dir0;
    dgVector m_dir1;
    dgFloat32 m_normal_Force;
    dgFloat32 m_dir0_Force;
    dgFloat32 m_dir1_Force;
    dgFloat32 m_softness;
    dgFloat32 m_restitution;
    dgFloat32 m_staticFriction0;
    dgFloat32 m_staticFriction1;
    dgFloat32 m_dynamicFriction0;
    dgFloat32 m_dynamicFriction1;
    dgFloat32 m_penetrationPadding;
    dgInt32 m_flags;
//  union {
//      dgInt32 m_flags;
//      struct {
//          dgUnsigned32 m_collisionEnable                 : 1;
//          dgUnsigned32 m_friction0Enable                 : 1;
//          dgUnsigned32 m_friction1Enable                 : 1;
//          dgUnsigned32 m_override0Accel                  : 1;
//          dgUnsigned32 m_override1Accel                  : 1;
//          dgUnsigned32 m_overrideNormalAccel             : 1;
//          dgUnsigned32 m_collisionContinueCollisionEnable : 1;
//      };
//  };

private:
    void *m_userData;
    OnAABBOverlap m_aabbOverlap;
    OnContactCallback m_contactPoint;
    OnAABBOverlap m_compoundAABBOverlap;

    friend class dgWorld;
    friend class dgCollisionCompound;
    friend class dgBroadPhaseCollision;
    friend class dgSolverWorlkerThreads;
    friend class dgCollidingPairCollector;
    friend class dgBroadPhaseMaterialCallbackWorkerThread;

} DG_GCC_VECTOR_ALIGMENT;



DG_MSC_VECTOR_ALIGMENT
class dgContact:
    public dgConstraint,
    public dgList<dgContactMaterial> {

    dgContact(dgWorld *world);
    virtual ~dgContact();

    DG_CLASS_ALLOCATOR(allocator)

    virtual void GetInfo(dgConstraintInfo *const info) const;
    virtual dgUnsigned32 JacobianDerivative(dgContraintDescritor &params);
    virtual void JointAccelerations(const dgJointAccelerationDecriptor &params);
    virtual void JointAccelerationsSimd(const dgJointAccelerationDecriptor &params);
    virtual void JointVelocityCorrection(const dgJointAccelerationDecriptor &params);

    virtual void SetDestructorCallback(OnConstraintDestroy destructor);

    void JacobianContactDerivative(dgContraintDescritor &params, dgContactMaterial &contact, dgInt32 normalIndex, dgInt32 &frictionIndex);
    void CalculatePointDerivative(dgInt32 index, dgContraintDescritor &desc, const dgVector &dir, const dgPointParam &param) const;


    dgVector m_prevPosit0;
    dgVector m_prevPosit1;
    dgQuaternion m_prevRotation0;
    dgQuaternion m_prevRotation1;

    dgWorld *m_world;
    dgActiveContacts::dgListNode *m_contactNode;
    const dgContactMaterial *m_myCacheMaterial;
    dgInt32 m_broadphaseLru;

    friend class dgWorld;
    friend class dgActiveContacts;
    friend class dgTireCollision;
    friend class dgBroadPhaseCollision;
    friend class dgSolverWorlkerThreads;
    friend class dgCollidingPairCollector;
} DG_GCC_VECTOR_ALIGMENT;

inline void dgContactMaterial::SetCollisionCallback(OnAABBOverlap aabbOverlap, OnContactCallback contact) {
    m_aabbOverlap = aabbOverlap;
    m_contactPoint = contact;
}

inline void dgContactMaterial::SetCompoundCollisionCallback(OnAABBOverlap aabbOverlap) {
    m_compoundAABBOverlap = aabbOverlap;
}

inline void *dgContactMaterial::GetUserData() const {
    return m_userData;
}

inline void dgContactMaterial::SetUserData(void *const userData) {
    m_userData = userData;
}



inline void dgContact::SetDestructorCallback(OnConstraintDestroy destructor) {
}

#endif