/* 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_DGPHYSICSWORLD_H__EC18C699_D48D_448F_A510_A865B2CC0789__INCLUDED_)
#define AFX_DGPHYSICSWORLD_H__EC18C699_D48D_448F_A510_A865B2CC0789__INCLUDED_


#include "dgBody.h"
#include "dgContact.h"
#include "dgCollision.h"
#include "dgCollisionScene.h"
#include "dgBodyMasterList.h"
#include "dgWorldDynamicUpdate.h"

//#include "dgBallConstraint.h"
//#include "dgHingeConstraint.h"
//#include "dgSlidingConstraint.h"
//#include "dgUniversalConstraint.h"
//#include "dgCorkscrewConstraint.h"
#include "dgBroadPhaseCollision.h"
//#include "dgUpVectorConstraint.h"
//#include "dgPointToCurveConstraint.h"


#define DG_REDUCE_CONTACT_TOLERANCE         dgFloat32 (1.0e-2f)
#define DG_PRUNE_CONTACT_TOLERANCE          dgFloat32 (1.0e-2f)
#define DG_RESTING_CONTACT_PENETRATION      dgFloat32 (1.0f / 256.0f)
#define DG_IMPULSIVE_CONTACT_PENETRATION    dgFloat32 (1.0f / 256.0f + DG_RESTING_CONTACT_PENETRATION)

#define DG_SLEEP_ENTRIES                    8
#define DG_MAX_DESTROYED_BODIES_BY_FORCE    8

//#define DG_SPANNING_MEMORY_POOL_SIZE  ((1<<16))

class dgCollisionPoint;
class dgUserConstraint;
class dgBallConstraint;
class dgHingeConstraint;
class dgSlidingConstraint;
class dgUniversalConstraint;
class dgCorkscrewConstraint;
class dgUpVectorConstraint;
class dgUserMeshCreation;
//class dgConnectorConstraint;
//class dgPointToCurveConstraint;


class dgBodyCollisionList: public dgTree<dgCollision *, dgUnsigned32> {
public:
	dgBodyCollisionList(dgMemoryAllocator *const allocator)
		: dgTree<dgCollision *, dgUnsigned32>(allocator) {

	}
};

class dgBodyMaterialList: public dgTree<dgContactMaterial, dgUnsigned32> {
public:
	dgBodyMaterialList(dgMemoryAllocator *const allocator)
		: dgTree<dgContactMaterial, dgUnsigned32>(allocator) {

	}
};

class dgCollisionParamProxy;

enum dgPerformanceCounters {



	m_worldTicks = 0,

	m_collisionTicks,
	m_broadPhaceTicks,
	m_narrowPhaseTicks,

	m_dynamicsTicks,
	m_dynamicsBuildSpanningTreeTicks,
	m_dynamicsSolveSpanningTreeTicks,

	m_forceCallback,
	m_counterSize,
};

class dgWorld;

typedef dgUnsigned32(dgApi *OnIslandUpdate)(const dgWorld *const world, void *island, dgInt32 bodyCount);
typedef void (dgApi *OnDestroyCollision)(const dgWorld *const world, dgCollision *shape);
typedef void (dgApi *OnBodyDestructionByExeciveForce)(const dgBody *const body, const dgContact *joint);

class dgSolverSleepTherfesholds {
public:
	dgFloat32 m_maxAccel;
	dgFloat32 m_maxAlpha;
	dgFloat32 m_maxVeloc;
	dgFloat32 m_maxOmega;
	dgInt32 m_steps;
};

DG_MSC_VECTOR_ALIGMENT
class dgWorld:
	public dgBodyMasterList,
	public dgBroadPhaseCollision,
	public dgBodyMaterialList,
	public dgBodyCollisionList,
	public dgActiveContacts,
	public dgCollidingPairCollector {
public:

	class dgDetroyBodyByForce {
	public:
		dgDetroyBodyByForce()
			: m_count(0) {
		}
		dgInt32 m_count;
		dgFloat32 m_force[DG_MAX_DESTROYED_BODIES_BY_FORCE];
		const dgBody *m_bodies[DG_MAX_DESTROYED_BODIES_BY_FORCE];
		const dgContact *m_joint[DG_MAX_DESTROYED_BODIES_BY_FORCE];
	};


	DG_CLASS_ALLOCATOR(allocator)

	dgWorld(dgMemoryAllocator *const allocator);
	~dgWorld();

//	void SetGlobalScale (dgFloat32 scale);
//	dgFloat32 GetGlobalScale () const;

	void SetSolverMode(dgInt32 mode);
	void SetFrictionMode(dgInt32 mode);
	void SetHardwareMode(dgInt32 mode);
	dgInt32 GetHardwareMode(char *description) const;

	void SetThreadsCount(dgInt32 count);
	dgInt32 GetThreadsCount() const;
	dgInt32 GetMaxThreadsCount() const;
//	dgInt32 GetThreadNumber() const;
	void EnableThreadOnSingleIsland(dgInt32 mode);
	dgInt32 GetThreadOnSingleIsland() const;

	void FlushCache();

	void *GetUserData() const;
	void SetUserData(void *const userData);

	void Update(dgFloat32 timestep);
	void UpdateCollision();
	dgInt32 Collide(dgCollision *const collisionA, const dgMatrix &matrixA, dgCollision *const collisionB, const dgMatrix &matrixB,
	                dgTriplex *const points, dgTriplex *const normals, dgFloat32 *const penetration, dgInt32 maxSize, dgInt32 threadIndex);

	dgInt32 CollideContinue(dgCollision *const collisionA, const dgMatrix &matrixA, const dgVector &velocA, const dgVector &omegaA,
	                        dgCollision *const collisionB, const dgMatrix &matrixB, const dgVector &velocB, const dgVector &omegaB,
	                        dgFloat32 &timeStep, dgTriplex *const points, dgTriplex *const normals, dgFloat32 *const penetration, dgInt32 maxSize, dgInt32 threadIndex);
	dgInt32 CollideContinueSimd(dgCollision *const collisionA, const dgMatrix &matrixA, const dgVector &velocA, const dgVector &omegaA,
	                            dgCollision *const collisionB, const dgMatrix &matrixB, const dgVector &velocB, const dgVector &omegaB,
	                            dgFloat32 &timeStep, dgTriplex *const points, dgTriplex *const normals, dgFloat32 *const penetration, dgInt32 maxSize, dgInt32 threadIndex);


	dgInt32 ClosestPoint(const dgTriplex &point, dgCollision *const collision, const dgMatrix &matrix, dgTriplex &contact, dgTriplex &normal, dgInt32 threadIndex) const;
	dgInt32 ClosestPoint(dgCollision *const collisionA, const dgMatrix &matrixA, dgCollision *const collisionB, const dgMatrix &matrixB,
	                     dgTriplex &contactA, dgTriplex &contactB, dgTriplex &normalAB, dgInt32 threadIndex) const;


	void SetFrictionThreshold(dgFloat32 acceletion);


	dgBody *GetIslandBody(const void *const island, dgInt32 index) const;


	void SetIslandUpdateCallback(OnIslandUpdate callback);
	void SetDestroyCollisionCallback(OnDestroyCollision shape);
	void SetLeavingWorldCallback(OnLeavingWorldAction callback);
	void SetBodyDestructionByExeciveForce(OnBodyDestructionByExeciveForce callback);
//	void ForEachBodyInAABB (const dgVector& q0, const dgVector& q1, OnLeavingWorldAction callback);

	dgBody *CreateBody(dgCollision *const collision, const dgMatrix &matrix);
	void DestroyBody(dgBody *const body);
	void DestroyAllBodies();

//	void AddToBreakQueue (const dgContact* const contactJoint, dgFloat32 masValue);
	void AddToBreakQueue(const dgContact *const contactJoint, dgBody *const body, dgFloat32 maxForce);

	// modify the velocity and angular velocity of a body in such a way
	// that the velocity of pointPosit is increase by pointDeltaVeloc
	// pointVeloc and pointPosit are in world space
	void AddBodyImpulse(dgBody *body, const dgVector &pointDeltaVeloc, const dgVector &pointPosit);

	void ApplyImpulseArray(dgBody *body, dgInt32 count, dgInt32 strideInBytes, const dgFloat32 *const impulseArray, const dgFloat32 *const pointArray);

	// apply the transform matrix to the body and recurse trough all bodies attached to this body with a
	// bilateral joint contact joint are ignored.
	void BodySetMatrix(dgBody *body, const dgMatrix &matrix);
//	void FreezeBody (dgBody *body);
//	void UnfreezeBody (dgBody *body);
//	dgInt32 GetActiveBodiesCount() const;

	dgInt32 GetBodiesCount() const;
	dgInt32 GetConstraintsCount() const;


	dgUnsigned32 GetBoxID() const;
	dgUnsigned32 GetConeID() const;
	dgUnsigned32 GetSphereID() const;
	dgUnsigned32 GetConvexID() const;
	dgUnsigned32 GetEllipseID() const;
	dgUnsigned32 GetCapsuleID() const;
	dgUnsigned32 GetCylinderID() const;
	dgUnsigned32 GetConvexHullID() const;
	dgUnsigned32 GetChamferCylinderID() const;
	dgUnsigned32 GetConvexHullModifierID() const;
	dgUnsigned32 GetPolygonSoupID() const;
	dgUnsigned32 GetSceneID() const;
	dgUnsigned32 GetCompoundCollisionID() const;

	dgCollision *CreateNull();
	dgCollision *CreateSphere(dgFloat32 radiusdg, dgInt32 shapeID, const dgMatrix &offsetMatrix = dgGetIdentityMatrix());
	dgCollision *CreateCone(dgFloat32 radius, dgFloat32 height, dgInt32 shapeID, const dgMatrix &offsetMatrix = dgGetIdentityMatrix());
	dgCollision *CreateCapsule(dgFloat32 radius, dgFloat32 height, dgInt32 shapeID, const dgMatrix &offsetMatrix = dgGetIdentityMatrix());
	dgCollision *CreateCylinder(dgFloat32 radius, dgFloat32 height, dgInt32 shapeID, const dgMatrix &offsetMatrix = dgGetIdentityMatrix());
	dgCollision *CreateBox(dgFloat32 dx, dgFloat32 dy, dgFloat32 dz, dgInt32 shapeID, const dgMatrix &offsetMatrix = dgGetIdentityMatrix());
	dgCollision *CreateEllipse(dgFloat32 rx, dgFloat32 ry, dgFloat32 rz, dgInt32 shapeID, const dgMatrix &offsetMatrix = dgGetIdentityMatrix());
	dgCollision *CreateConvexHull(dgInt32 count, const dgFloat32 *vertexArray, dgInt32 strideInBytes, dgFloat32 tolerance, dgInt32 shapeID, const dgMatrix &offsetMatrix = dgGetIdentityMatrix());
	dgCollision *CreateChamferCylinder(dgFloat32 radius, dgFloat32 height, dgInt32 shapeID, const dgMatrix &offsetMatrix = dgGetIdentityMatrix());
	dgCollision *CreateConvexModifier(dgCollision *convexCollision);
	dgCollision *CreateCollisionCompound(dgInt32 count, dgCollision *const array[]);
//	dgCollision* CreateCollisionCompoundBreakable (dgInt32 count, dgMeshEffect* const solidArray[], dgMeshEffect* const splitePlanes[],
//													  dgMatrix* const matrixArray, dgInt32* const idArray, dgFloat32* const mass, dgInt32 debriID,
//													  dgCollisionCompoundBreakableCallback callback, void* buildUsedData);

	dgCollision *CreateCollisionCompoundBreakable(dgInt32 count, dgMeshEffect *const solidArray[], const dgInt32 *const idArray,
	        const dgFloat32 *const densities, const dgInt32 *const internalFaceMaterial, dgInt32 debriID, dgFloat32 gap);


	dgCollision *CreateBVH();
	dgCollision *CreateStaticUserMesh(const dgVector &boxP0, const dgVector &boxP1, const dgUserMeshCreation &data);
	dgCollision *CreateBVHFieldCollision(dgInt32 width, dgInt32 height, dgInt32 contructionMode,
	                                     const dgUnsigned16 *const elevationMap, const dgInt8 *const atributeMap, dgFloat32 horizontalScale, dgFloat32 vertcalScale);

	dgCollision *CreateScene();

	void Serialize(const dgCollision *shape, dgSerialize deserialization, void *const userData) const;
	dgCollision *CreateFromSerialization(dgDeserialize deserialization, void *const userData);

	void RemoveFromCache(dgCollision *const collision);
	void ReleaseCollision(dgCollision *const collision);

	dgUpVectorConstraint *CreateUpVectorConstraint(const dgVector &pin, dgBody *body);

	dgBallConstraint *CreateBallConstraint(const dgVector &pivot, dgBody *const body0, dgBody *refBody = NULL);
	dgHingeConstraint *CreateHingeConstraint(const dgVector &pivot, const dgVector &pin, dgBody *const body0, dgBody *refBody = NULL);
	dgSlidingConstraint *CreateSlidingConstraint(const dgVector &pivot, const dgVector &pin, dgBody *const body0, dgBody *refBody = NULL);
	dgCorkscrewConstraint *CreateCorkscrewConstraint(const dgVector &pivot, const dgVector &pin, dgBody *const body0, dgBody *refBody = NULL);
	dgUniversalConstraint *CreateUniversalConstraint(const dgVector &pivot, const dgVector &pin0, const dgVector &pin1, dgBody *const body0, dgBody *body1 = NULL);


	void DestroyConstraint(dgConstraint *constraint);
	dgUnsigned32 CreateBodyGroupID();
	void RemoveAllGroupID();

	dgUnsigned32 GetDefualtBodyGroupID() const;
	dgContactMaterial *GetMaterial(dgUnsigned32 bodyGroupId0, dgUnsigned32 bodyGroupId1) const;

	dgContactMaterial *GetFirstMaterial() const;
	dgContactMaterial *GetNextMaterial(dgContactMaterial *material) const;

	OnGetPerformanceCountCallback GetPerformaceFuntion()const ;
	void SetPerfomanceCounter(OnGetPerformanceCountCallback callback);

//	dgUnsigned32 GetPerfomanceTicks (dgInt32 thread, dgUnsigned32 entry) const;
	dgUnsigned32 GetPerfomanceTicks(dgUnsigned32 entry) const;
	dgUnsigned32 GetThreadPerfomanceTicks(dgUnsigned32 threadIndex) const;

	void dgGetUserLock() const;
	void dgReleasedUserLock() const;
	void dgGetIndirectLock(dgInt32 *lockVar);
	void dgReleaseIndirectLock(dgInt32 *lockVar);


	dgBody *GetSentinelBody() const;
	dgMemoryAllocator *GetAllocator() const;

private:
	void CalculateContacts(dgCollidingPairCollector::dgPair *const pair, dgFloat32 timestep, dgInt32 threadIndex);
	void CalculateContactsSimd(dgCollidingPairCollector::dgPair *const pair, dgFloat32 timestep, dgInt32 threadIndex);

	void SortContacts(dgContactPoint *const contact, dgInt32 count) const;
	dgInt32 ReduceContacts(dgInt32 count, dgContactPoint *const contact, dgInt32 maxCount, dgFloat32 tol, dgInt32 arrayIsSorted = 0) const;
	dgInt32 PruneContacts(dgInt32 count, dgContactPoint *const contact, dgInt32 maxCount = (DG_CONSTRAINT_MAX_ROWS / 3)) const;

	dgInt32 CalculateHullToHullContacts(dgCollisionParamProxy &proxy) const;
	dgInt32 CalculateHullToHullContactsSimd(dgCollisionParamProxy &proxy) const;
	dgInt32 CalculateBoxToSphereContacts(dgCollisionParamProxy &proxy) const;
	dgInt32 CalculateSphereToSphereContacts(dgCollisionParamProxy &proxy) const;
	dgInt32 CalculateCapsuleToSphereContacts(dgCollisionParamProxy &proxy) const;
	dgInt32 CalculateCapsuleToCapsuleContacts(dgCollisionParamProxy &proxy) const;
	dgInt32 SphereSphereCollision(const dgVector &sph0, dgFloat32 radius0, const dgVector &sph1, dgFloat32 radius1, dgCollisionParamProxy &proxy) const;


	dgInt32 ValidateContactCache(dgBody *const convexBody, dgBody *const otherBody, dgContact *const contact) const;


	dgInt32 CalculatePolySoupToBoxContactsDescrete(dgBody *soup, dgBody *box, dgContactPoint *const contact, dgInt32 maxContacts) const;
	dgInt32 CalculatePolySoupToHullContactsDescrete(dgCollisionParamProxy &proxy) const;
	dgInt32 CalculatePolySoupToHullContactsDescreteSimd(dgCollisionParamProxy &proxy) const;

	dgInt32 CalculatePolySoupToSphereContactsDescrete(dgCollisionParamProxy &proxy) const;
	dgInt32 CalculatePolySoupToElipseContactsDescrete(dgCollisionParamProxy &proxy) const;
	dgInt32 CalculatePolySoupToSphereContactsContinue(dgCollisionParamProxy &proxy) const;
	dgInt32 CalculateConvexToNonConvexContactsContinue(dgCollisionParamProxy &proxy) const;
	dgInt32 CalculateConvexToNonConvexContactsContinueSimd(dgCollisionParamProxy &proxy) const;


//	dgInt32 CalculateConvexToConvexContinuesContacts (dgFloat32& timestep, dgBody* body1, dgBody* body2, dgContactPoint contactOut[]) const;
//	dgInt32 CalculateConvexToConvexContinuesContacts (dgCollisionParamProxy& proxy) const;
//	dgInt32 CalculateConvexToConvexContinuesContacts (dgCollisionParamProxy& proxy) const;
//	dgInt32 CalculateConvexToConvexContacts (dgFloat32& timestep, dgBody* conv1, dgBody* conv2, dgFloat32 penetrationPadding, dgContactPoint* const contact) const;
//	dgInt32 CalculateConvexToConvexContactsSimd (dgFloat32& timestep, dgBody* conv1, dgBody* conv2, dgFloat32 penetrationPadding, dgContactPoint* const contact) const;
	dgInt32 CalculateConvexToConvexContacts(dgCollisionParamProxy &proxy) const;
	dgInt32 CalculateConvexToConvexContactsSimd(dgCollisionParamProxy &proxy) const;

//	dgInt32 CalculateConvexToNonConvexContacts (dgFloat32& timestep, dgBody* conv, dgBody* nConv, dgContactPoint* const contact, dgInt32 maxContacts) const;
	dgInt32 CalculateConvexToNonConvexContacts(dgCollisionParamProxy &proxy) const;
	dgInt32 CalculateConvexToNonConvexContactsSimd(dgCollisionParamProxy &proxy) const;

	dgInt32 FilterPolygonEdgeContacts(dgInt32 count, dgContactPoint *const contact) const;

	void ProcessTriggers(dgCollidingPairCollector::dgPair *const pair, dgFloat32 timestep, dgInt32 threadIndex);
	void ProcessContacts(dgCollidingPairCollector::dgPair *const pair, dgFloat32 timestep, dgInt32 threadIndex);
	void ProcessCachedContacts(dgContact *const contact, const dgContactMaterial *const material, dgFloat32 timestep, dgInt32 threadIndex) const;

	void ConvexContacts(dgCollidingPairCollector::dgPair *const pair, dgCollisionParamProxy &proxy) const;
	void ConvexContactsSimd(dgCollidingPairCollector::dgPair *const pair, dgCollisionParamProxy &proxy) const;
	void CompoundContacts(dgCollidingPairCollector::dgPair *const pair, dgCollisionParamProxy &proxy) const;
	void CompoundContactsSimd(dgCollidingPairCollector::dgPair *const pair, dgCollisionParamProxy &proxy) const;

	void SceneContacts(dgCollidingPairCollector::dgPair *const pair, dgCollisionParamProxy &proxy) const;
	void SceneContacts(const dgCollisionScene::dgProxy &sceneProxy, dgCollidingPairCollector::dgPair *const pair, dgCollisionParamProxy &proxy) const;

	void SceneContactsSimd(dgCollidingPairCollector::dgPair *const pair, dgCollisionParamProxy &proxy) const;
	void SceneContactsSimd(const dgCollisionScene::dgProxy &sceneProxy, dgCollidingPairCollector::dgPair *const pair, dgCollisionParamProxy &proxy) const;

	dgInt32 ClosestPoint(dgCollisionParamProxy &proxy) const;
	dgInt32 ClosestCompoundPoint(dgBody *const compoundConvexA, dgBody *const collisionB, dgTriplex &contactA, dgTriplex &contactB, dgTriplex &normalAB, dgInt32 threadIndex) const;

	bool AreBodyConnectedByJoints(dgBody *const origin, dgBody *const target);

	void AddSentinelBody();


	static void InitConvexCollision();
	static dgUnsigned32 dgApi GetPerformanceCount();

	dgUnsigned32 m_dynamicsLru;
	dgUnsigned32 m_broadPhaseLru;
	dgUnsigned32 m_inUpdate;
	dgUnsigned32 m_solverMode;
	dgUnsigned32 m_frictionMode;
	dgUnsigned32 m_bodyGroupID;
	dgUnsigned32 m_defualtBodyGroupID;
	dgUnsigned32 m_bodiesUniqueID;
	dgUnsigned32 m_numberOfTheads;
	dgUnsigned32 m_maxTheads;


	dgFloat32 m_freezeAccel2;
	dgFloat32 m_freezeAlpha2;
	dgFloat32 m_freezeSpeed2;
	dgFloat32 m_freezeOmega2;
	dgFloat32 m_frictiomTheshold;

	dgSolverSleepTherfesholds m_sleepTable[DG_SLEEP_ENTRIES];

	dgInt32 m_genericLRUMark;
	dgInt32 m_islandMemorySizeInBytes;
	dgInt32 m_bodiesMemorySizeInBytes;
	dgInt32 m_jointsMemorySizeInBytes;
	dgInt32 m_pairMemoryBufferSizeInBytes;
	void *m_jointsMemory;
	void *m_bodiesMemory;
	void *m_islandMemory;
	void *m_pairMemoryBuffer;


	dgInt32 m_singleIslandMultithreading;
	dgInt32 m_contactBuffersSizeInBytes[DG_MAXIMUN_THREADS];
	dgInt32 m_jacobiansMemorySizeInBytes[DG_MAXIMUN_THREADS];
	dgInt32 m_internalForcesMemorySizeInBytes[DG_MAXIMUN_THREADS];
	void *m_jacobiansMemory[DG_MAXIMUN_THREADS];
	void *m_internalForcesMemory[DG_MAXIMUN_THREADS];
	void *m_contactBuffers[DG_MAXIMUN_THREADS];

	dgBody *m_sentionelBody;
	dgCollisionPoint *m_pointCollision;

	void *m_userData;
	dgMemoryAllocator *m_allocator;
	dgCpuClass m_cpu;
	OnIslandUpdate m_islandUpdate;
	OnDestroyCollision m_destroyCollision;
	OnLeavingWorldAction m_leavingWorldNotify;
	OnGetPerformanceCountCallback m_getPerformanceCount;
	OnBodyDestructionByExeciveForce m_destroyBodyByExeciveForce;

	dgDetroyBodyByForce m_destroyeddBodiesPool;
	dgUnsigned32 m_perfomanceCounters[m_counterSize];

	dgTree<void *, unsigned> m_perInstanceData;

	dgThreads m_threadsManager;
	dgWorldDynamicUpdate m_dynamicSolver;

	friend class dgBody;
	friend class dgActiveContacts;
	friend class dgBroadPhaseCell;
	friend class dgUserConstraint;
	friend class dgBodyMasterList;
	friend class dgJacobianMemory;
	friend class dgCollisionScene;
	friend class dgCollisionConvex;
	friend class dgCollisionCompound;
	friend class dgCollisionHeightField;
	friend class dgWorldDynamicUpdate;
	friend class dgParallelSolverSolve;
	friend class dgBroadPhaseCollision;
	friend class dgSolverWorlkerThreads;
	friend class dgCollidingPairCollector;
	friend class dgParallelSolverClear;
	friend class dgParallelSolverUpdateForce;
	friend class dgParallelSolverUpdateVeloc;
	friend class dgParallelSolverBodyInertia;
	friend class dgParallelSolverInitFeedbackUpdate;

	friend class dgBroadPhaseApplyExternalForce;
	friend class dgParallelSolverCalculateForces;
	friend class dgParallelSolverJointAcceleration;
	friend class dgParallelSolverBuildJacobianRows;
	friend class dgBroadPhaseCellPairsWorkerThread;
	friend class dgParallelSolverInitInternalForces;
	friend class dgParallelSolverBuildJacobianMatrix;

	friend class dgBroadPhaseMaterialCallbackWorkerThread;
	friend class dgBroadPhaseCalculateContactsWorkerThread;
} DG_GCC_VECTOR_ALIGMENT ;


inline void dgWorld::dgGetUserLock() const {
	if (m_numberOfTheads > 1) {
		m_threadsManager.dgGetLock();
	}
}

inline void dgWorld::dgReleasedUserLock() const {
	if (m_numberOfTheads > 1) {
		m_threadsManager.dgReleaseLock();
	}
}


inline void dgWorld::dgGetIndirectLock(dgInt32 *lockVar) {
	m_threadsManager.dgGetIndirectLock(lockVar);
}

inline void dgWorld::dgReleaseIndirectLock(dgInt32 *lockVar) {
	m_threadsManager.dgReleaseIndirectLock(lockVar);
}

inline dgMemoryAllocator *dgWorld::GetAllocator() const {
	return m_allocator;
}

inline void dgWorld::AddToBreakQueue(const dgContact *const contactJoint, dgBody *const body, dgFloat32 maxForce) {
//	if (body->GetCollision()->GetBreakImpulse() < maxForce) {
	if (m_destroyeddBodiesPool.m_count < DG_MAX_DESTROYED_BODIES_BY_FORCE) {
		if (body->m_isInDerstruionArrayLRU != body->m_dynamicsLru) {
			body->m_isInDerstruionArrayLRU = body->m_dynamicsLru;
			m_destroyeddBodiesPool.m_force[m_destroyeddBodiesPool.m_count] = maxForce;
			m_destroyeddBodiesPool.m_bodies[m_destroyeddBodiesPool.m_count] = body;
			m_destroyeddBodiesPool.m_joint[m_destroyeddBodiesPool.m_count] = contactJoint;
			m_destroyeddBodiesPool.m_count ++;
		} else {
			for (dgInt32 i = 0; i < m_destroyeddBodiesPool.m_count; i ++) {
				if (m_destroyeddBodiesPool.m_bodies[i] == body) {
					if (maxForce > m_destroyeddBodiesPool.m_force[i]) {
						m_destroyeddBodiesPool.m_force[i] = maxForce;
						m_destroyeddBodiesPool.m_joint[i] = contactJoint;
					}
				}
			}
		}
	}
//	}
}


//inline void dgWorld::AddToBreakQueue (const dgContact* const contactJoint, dgFloat32 maxImpulse)
//{
//	AddToBreakQueue (contactJoint, contactJoint->m_body0, maxForce);
//	AddToBreakQueue (contactJoint, contactJoint->m_body1, maxForce);
//}



#endif // !defined(AFX_DGPHYSICSWORLD_H__EC18C699_D48D_448F_A510_A865B2CC0789__INCLUDED_)