522 lines
22 KiB
C++
522 lines
22 KiB
C++
/* 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_)
|