Initial commit

engines/hpl1/engine/libraries/newton/physics/dgContact.h

@@ -0,0 +1,262 @@
+/* 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