mirror of https://github.com/zeldaret/botw.git
547 lines
20 KiB
C++
547 lines
20 KiB
C++
#pragma once
|
|
|
|
#include <Havok/Common/Base/DebugUtil/MultiThreadCheck/hkMultiThreadCheck.h>
|
|
#include <Havok/Common/Base/Types/Physics/hkStepInfo.h>
|
|
#include <Havok/Common/Base/hkBase.h>
|
|
#include <Havok/Physics/ConstraintSolver/Solve/hkpSolverInfo.h>
|
|
#include <Havok/Physics2012/Dynamics/World/hkpWorldCinfo.h>
|
|
|
|
class hkCriticalSection;
|
|
class hkJobQueue;
|
|
class hkSemaphoreBusyWait;
|
|
class hkThreadPool;
|
|
class hkWorldMemoryAvailableWatchDog;
|
|
class hkdWorld;
|
|
class hknpWorld;
|
|
class hkpAction;
|
|
class hkpActionListener;
|
|
class hkpBodyOperation;
|
|
class hkpBroadPhase;
|
|
class hkpBroadPhaseBorder;
|
|
class hkpBroadPhaseBorderListener;
|
|
class hkpCdBodyPairCollector;
|
|
class hkpCdPointCollector;
|
|
class hkpCollisionDispatcher;
|
|
class hkpCollisionFilter;
|
|
class hkpConstraintData;
|
|
class hkpConstraintInstance;
|
|
class hkpConstraintListener;
|
|
class hkpContactImpulseLimitBreachedListener;
|
|
class hkpContactListener;
|
|
class hkpDebugInfoOnPendingOperationQueues;
|
|
class hkpEntity;
|
|
class hkpEntityEntityBroadPhaseListener;
|
|
class hkpEntityListener;
|
|
class hkpIslandActivationListener;
|
|
class hkpIslandPostCollideListener;
|
|
class hkpIslandPostIntegrateListener;
|
|
struct hkpLinearCastInput;
|
|
class hkpMtThreadStructure;
|
|
class hkpMultithreadConfig;
|
|
class hkpPhantom;
|
|
class hkpPhantomBroadPhaseListener;
|
|
class hkpPhantomListener;
|
|
class hkpPhysicsSystem;
|
|
struct hkpProcessCollisionInput;
|
|
class hkpRigidBody;
|
|
class hkpSimulation;
|
|
class hkpSimulationIsland;
|
|
class hkpTypedBroadPhaseDispatcher;
|
|
struct hkpViolatedConstraintArray;
|
|
class hkpWorldDeletionListener;
|
|
class hkpWorldExtension;
|
|
struct hkpWorldGetClosestPointsCommand;
|
|
struct hkpWorldLinearCastCommand;
|
|
class hkpWorldMaintenanceMgr;
|
|
class hkpWorldOperationQueue;
|
|
class hkpWorldPostCollideListener;
|
|
class hkpWorldPostIntegrateListener;
|
|
class hkpWorldPostSimulationListener;
|
|
struct hkpWorldRayCastCommand;
|
|
struct hkpWorldRayCastOutput;
|
|
|
|
namespace hkWorldOperation {
|
|
struct BaseOperation;
|
|
class UserCallback;
|
|
} // namespace hkWorldOperation
|
|
|
|
enum hkpUpdateCollisionFilterOnWorldMode {
|
|
HK_UPDATE_FILTER_ON_WORLD_FULL_CHECK,
|
|
HK_UPDATE_FILTER_ON_WORLD_DISABLE_ENTITY_ENTITY_COLLISIONS_ONLY,
|
|
};
|
|
|
|
enum hkpUpdateCollisionFilterOnEntityMode {
|
|
HK_UPDATE_FILTER_ON_ENTITY_FULL_CHECK,
|
|
HK_UPDATE_FILTER_ON_ENTITY_DISABLE_ENTITY_ENTITY_COLLISIONS_ONLY,
|
|
};
|
|
|
|
enum hkpEntityActivation {
|
|
HK_ENTITY_ACTIVATION_DO_NOT_ACTIVATE,
|
|
HK_ENTITY_ACTIVATION_DO_ACTIVATE,
|
|
};
|
|
|
|
enum hkpUpdateCollectionFilterMode {
|
|
HK_UPDATE_COLLECTION_FILTER_IGNORE_SHAPE_COLLECTIONS,
|
|
HK_UPDATE_COLLECTION_FILTER_PROCESS_SHAPE_COLLECTIONS,
|
|
};
|
|
|
|
enum hkpStepResult {
|
|
HK_STEP_RESULT_SUCCESS,
|
|
HK_STEP_RESULT_MEMORY_FAILURE_BEFORE_INTEGRATION,
|
|
HK_STEP_RESULT_MEMORY_FAILURE_DURING_COLLIDE,
|
|
HK_STEP_RESULT_MEMORY_FAILURE_DURING_TOI_SOLVE,
|
|
};
|
|
|
|
struct hkpWorldDynamicsStepInfo {
|
|
HK_DECLARE_CLASS_ALLOCATOR(hkpWorldDynamicsStepInfo)
|
|
|
|
hkStepInfo m_stepInfo;
|
|
hkpSolverInfo m_solverInfo;
|
|
};
|
|
|
|
class hkpWorld : public hkReferencedObject {
|
|
public:
|
|
HK_DECLARE_CLASS_ALLOCATOR(hkpWorld)
|
|
HK_DECLARE_REFLECTION()
|
|
|
|
enum ReintegrationRecollideMode {
|
|
RR_MODE_REINTEGRATE = 1 << 0,
|
|
RR_MODE_RECOLLIDE_BROADPHASE = 1 << 1,
|
|
RR_MODE_RECOLLIDE_NARROWPHASE = 1 << 2,
|
|
RR_MODE_ALL = (1 << 3) - 1,
|
|
};
|
|
|
|
hkpWorld(const hkpWorldCinfo& info, unsigned int sdkversion = 20140200u);
|
|
explicit hkpWorld(hkFinishLoadedObjectFlag flag);
|
|
~hkpWorld() override;
|
|
|
|
void getCinfo(hkpWorldCinfo& info) const;
|
|
|
|
void setGravity(const hkVector4& gravity);
|
|
inline const hkVector4& getGravity() const;
|
|
|
|
hkTime getCurrentTime() const;
|
|
hkTime getCurrentPsiTime() const;
|
|
|
|
// region Entity
|
|
|
|
hkpEntity*
|
|
addEntity(hkpEntity* entity,
|
|
hkpEntityActivation initialActivationState = HK_ENTITY_ACTIVATION_DO_ACTIVATE);
|
|
|
|
hkBool removeEntity(hkpEntity* entity);
|
|
|
|
void
|
|
addEntityBatch(hkpEntity* const* entityBatch, int numEntities,
|
|
hkpEntityActivation initialActivationState = HK_ENTITY_ACTIVATION_DO_ACTIVATE);
|
|
|
|
void removeEntityBatch(hkpEntity* const* entityBatch, int numEntities);
|
|
|
|
// endregion
|
|
|
|
// region Constraint
|
|
|
|
hkpConstraintInstance* addConstraint(hkpConstraintInstance* constraint);
|
|
hkBool removeConstraint(hkpConstraintInstance* constraint);
|
|
hkpConstraintInstance* createAndAddConstraintInstance(hkpRigidBody* bodyA, hkpRigidBody* bodyB,
|
|
hkpConstraintData* constraintData);
|
|
|
|
// endregion
|
|
|
|
// region Action
|
|
|
|
hkpAction* addAction(hkpAction* action);
|
|
void removeAction(hkpAction* action);
|
|
void removeActionImmediately(hkpAction* action);
|
|
|
|
// endregion
|
|
|
|
// region Phantom
|
|
|
|
inline const hkArray<hkpPhantom*>& getPhantoms() const;
|
|
hkpPhantom* addPhantom(hkpPhantom* phantom);
|
|
void addPhantomBatch(hkpPhantom* const* phantomBatch, int numPhantoms);
|
|
void removePhantom(hkpPhantom* phantom);
|
|
void removePhantomBatch(hkpPhantom* const* phantomBatch, int numPhantoms);
|
|
void activateRegion(const hkAabb& aabb);
|
|
|
|
// endregion
|
|
|
|
// region System
|
|
|
|
void addPhysicsSystem(const hkpPhysicsSystem* sys);
|
|
void removePhysicsSystem(const hkpPhysicsSystem* sys);
|
|
|
|
// endregion
|
|
|
|
// region Fixed rigid body
|
|
|
|
inline hkpRigidBody* getFixedRigidBody();
|
|
inline const hkpRigidBody* getFixedRigidBody() const;
|
|
|
|
// endregion
|
|
|
|
// region Collision filter
|
|
|
|
void updateCollisionFilterOnEntity(hkpEntity* entity,
|
|
hkpUpdateCollisionFilterOnEntityMode updateMode,
|
|
hkpUpdateCollectionFilterMode updateShapeCollectionFilter);
|
|
|
|
void reenableCollisionBetweenEntityPair(hkpEntity* entityA, hkpEntity* entityB);
|
|
|
|
void updateCollisionFilterOnPhantom(hkpPhantom* phantom,
|
|
hkpUpdateCollectionFilterMode updateShapeCollectionFilter);
|
|
|
|
void updateCollisionFilterOnWorld(hkpUpdateCollisionFilterOnWorldMode updateMode,
|
|
hkpUpdateCollectionFilterMode updateShapeCollectionFilter);
|
|
|
|
void reintegrateAndRecollideEntities(hkpEntity** entityBatch, int numEntities,
|
|
ReintegrationRecollideMode mode = RR_MODE_ALL);
|
|
|
|
// endregion
|
|
|
|
// region Simulation
|
|
|
|
void findInitialContactPoints(hkpEntity** entities, int numEntities);
|
|
void findInitialContactPointsOfAllEntities();
|
|
void calcRequiredSolverBufferSize(hkWorldMemoryAvailableWatchDog::MemUsageInfo& infoOut);
|
|
void checkDeterminism();
|
|
void checkDeterminismOfIslandBroadPhase(const hkpSimulationIsland* island);
|
|
hkWorldMemoryAvailableWatchDog* getMemoryWatchDog() const;
|
|
void setMemoryWatchDog(hkWorldMemoryAvailableWatchDog* watchDog);
|
|
|
|
// endregion
|
|
|
|
// region Multithreading
|
|
|
|
enum MtAccessChecking { MT_ACCESS_CHECKING_ENABLED = 0, MT_ACCESS_CHECKING_DISABLED };
|
|
|
|
void lock();
|
|
void lockReadOnly();
|
|
void unlock();
|
|
void unlockReadOnly();
|
|
bool checkUnmarked();
|
|
void lockIslandForConstraintUpdate(hkpSimulationIsland* island);
|
|
void lockForIslandSplit(hkpSimulationIsland* island);
|
|
void unlockIslandForConstraintUpdate(hkpSimulationIsland* island);
|
|
void unlockForIslandSplit(hkpSimulationIsland* island);
|
|
void setMultithreadedAccessChecking(MtAccessChecking accessCheckState);
|
|
MtAccessChecking getMultithreadedAccessChecking() const;
|
|
void markForRead() const;
|
|
void markForWrite();
|
|
void unmarkForRead() const;
|
|
void unmarkForWrite();
|
|
|
|
// endregion
|
|
|
|
// region Event handling
|
|
|
|
void addActionListener(hkpActionListener* worldListener);
|
|
void removeActionListener(hkpActionListener* worldListener);
|
|
|
|
void addConstraintListener(hkpConstraintListener* worldListener);
|
|
void removeConstraintListener(hkpConstraintListener* worldListener);
|
|
|
|
void addEntityListener(hkpEntityListener* worldListener);
|
|
void removeEntityListener(hkpEntityListener* worldListener);
|
|
|
|
void addPhantomListener(hkpPhantomListener* worldListener);
|
|
void removePhantomListener(hkpPhantomListener* worldListener);
|
|
|
|
void addIslandActivationListener(hkpIslandActivationListener* worldListener);
|
|
void removeIslandActivationListener(hkpIslandActivationListener* worldListener);
|
|
|
|
void addWorldPostCollideListener(hkpWorldPostCollideListener* worldListener);
|
|
void removeWorldPostCollideListener(hkpWorldPostCollideListener* worldListener);
|
|
|
|
void addWorldPostSimulationListener(hkpWorldPostSimulationListener* worldListener);
|
|
void removeWorldPostSimulationListener(hkpWorldPostSimulationListener* worldListener);
|
|
|
|
void addWorldPostIntegrateListener(hkpWorldPostIntegrateListener* worldListener);
|
|
void removeWorldPostIntegrateListener(hkpWorldPostIntegrateListener* worldListener);
|
|
|
|
void addIslandPostCollideListener(hkpIslandPostCollideListener* islandListener);
|
|
void removeIslandPostCollideListener(hkpIslandPostCollideListener* islandListener);
|
|
|
|
void addIslandPostIntegrateListener(hkpIslandPostIntegrateListener* islandListener);
|
|
void removeIslandPostIntegrateListener(hkpIslandPostIntegrateListener* islandListener);
|
|
|
|
void addContactListener(hkpContactListener* worldListener);
|
|
void removeContactListener(hkpContactListener* worldListener);
|
|
|
|
const hkArray<hkpContactListener*>& getContactListeners() const;
|
|
|
|
void addWorldDeletionListener(hkpWorldDeletionListener* worldListener);
|
|
void removeWorldDeletionListener(hkpWorldDeletionListener* worldListener);
|
|
|
|
void addContactImpulseLimitBreachedListener(hkpContactImpulseLimitBreachedListener* listener);
|
|
void
|
|
removeContactImpulseLimitBreachedListener(hkpContactImpulseLimitBreachedListener* listener);
|
|
|
|
void addWorldExtension(hkpWorldExtension* extension);
|
|
void removeWorldExtension(hkpWorldExtension* extension);
|
|
hkpWorldExtension* findWorldExtension(int id) const;
|
|
|
|
// endregion
|
|
|
|
// region Collision detection
|
|
|
|
inline hkpBroadPhase* getBroadPhase();
|
|
inline const hkpBroadPhase* getBroadPhase() const;
|
|
|
|
hkpBroadPhaseBorder* getBroadPhaseBorder() const;
|
|
void setBroadPhaseBorder(hkpBroadPhaseBorder* bpb);
|
|
|
|
inline const hkpProcessCollisionInput* getCollisionInput() const;
|
|
inline hkpProcessCollisionInput* getCollisionInputRw();
|
|
inline hkpSolverInfo* getSolverInfo();
|
|
inline hkpCollisionDispatcher* getCollisionDispatcher() const;
|
|
|
|
inline const hkpCollisionFilter* getCollisionFilter() const;
|
|
void setCollisionFilter(hkpCollisionFilter* filter,
|
|
hkBool runUpdateCollisionFilterOnWorld = true,
|
|
hkpUpdateCollisionFilterOnWorldMode checkBroadPhaseMode =
|
|
HK_UPDATE_FILTER_ON_WORLD_FULL_CHECK,
|
|
hkpUpdateCollectionFilterMode updateShapeCollectionFilter =
|
|
HK_UPDATE_COLLECTION_FILTER_PROCESS_SHAPE_COLLECTIONS);
|
|
|
|
void castRay(const hkpWorldRayCastInput& input, hkpWorldRayCastOutput& output) const;
|
|
void castRay(const hkpWorldRayCastInput& input, hkpRayHitCollector& collector) const;
|
|
void castRayMt(hkpWorldRayCastCommand* commandArray, int numCommands, hkJobQueue* jobQueue,
|
|
hkThreadPool* threadPool, hkSemaphoreBusyWait* semaphore,
|
|
int numCommandsPerJob = 32) const;
|
|
|
|
void linearCast(const hkpCollidable* collA, const hkpLinearCastInput& input,
|
|
hkpCdPointCollector& castCollector,
|
|
hkpCdPointCollector* startCollector = nullptr) const;
|
|
|
|
void linearCastMt(hkpWorldLinearCastCommand* commandArray, int numCommands,
|
|
hkJobQueue* jobQueue, hkThreadPool* threadPool,
|
|
hkSemaphoreBusyWait* semaphore, int numCommandsPerJob = 32) const;
|
|
|
|
void getClosestPoints(const hkpCollidable* collA, const hkpCollisionInput& input,
|
|
hkpCdPointCollector& collector) const;
|
|
|
|
void getClosestPointsMt(hkpWorldGetClosestPointsCommand* commandArray, int numCommands,
|
|
hkJobQueue* jobQueue, hkThreadPool* threadPool,
|
|
hkSemaphoreBusyWait* semaphore, int numCommandsPerJob = 32) const;
|
|
|
|
void getPenetrations(const hkpCollidable* collA, const hkpCollisionInput& input,
|
|
hkpCdBodyPairCollector& collector) const;
|
|
|
|
enum CachedAabbUpdate {
|
|
SHIFT_BROADPHASE_UPDATE_ENTITY_AABBS,
|
|
SHIFT_BROADPHASE_IGNORE_ENTITY_AABBS
|
|
};
|
|
void shiftBroadPhase(const hkVector4& shiftDistance, hkVector4& effectiveShiftDistanceOut,
|
|
CachedAabbUpdate updateAabbs);
|
|
|
|
// endregion
|
|
|
|
// region Simulation island
|
|
|
|
inline const hkArray<hkpSimulationIsland*>& getActiveSimulationIslands() const;
|
|
inline const hkArray<hkpSimulationIsland*>& getInactiveSimulationIslands() const;
|
|
inline const hkpSimulationIsland* getFixedIsland() const;
|
|
|
|
// endregion
|
|
|
|
// region Stepping
|
|
|
|
hkpStepResult stepDeltaTime(hkReal physicsDeltaTime);
|
|
|
|
hkpStepResult integrate(hkReal physicsDeltaTime);
|
|
hkpStepResult collide();
|
|
hkpStepResult advanceTime();
|
|
|
|
void setFrameTimeMarker(hkReal frameDeltaTime);
|
|
bool isSimulationAtMarker() const;
|
|
bool isSimulationAtPsi() const;
|
|
|
|
static void registerWithJobQueue(hkJobQueue* jobQueue);
|
|
hkpStepResult stepMultithreaded(hkJobQueue* jobQueue, hkThreadPool* threadPool,
|
|
hkReal physicsDeltaTime);
|
|
hkpStepResult initMtStep(hkJobQueue* jobQueue, hkReal physicsDeltaTime);
|
|
hkpStepResult finishMtStep(hkJobQueue* jobQueue = nullptr, hkThreadPool* threadPool = nullptr);
|
|
|
|
// endregion
|
|
|
|
// region Multithreading config
|
|
|
|
void getMultithreadConfig(hkpMultithreadConfig& config);
|
|
void setMultithreadConfig(const hkpMultithreadConfig& config, hkJobQueue* queue);
|
|
hkMultiThreadCheck& getMultiThreadCheck() const { return m_multiThreadCheck; }
|
|
void checkAccessGetActiveSimulationIslands() const;
|
|
|
|
// endregion
|
|
|
|
// region Serialisation
|
|
|
|
hkpPhysicsSystem* getWorldAsOneSystem() const;
|
|
void getWorldAsSystems(hkArray<hkpPhysicsSystem*>& systemsOut) const;
|
|
|
|
// endregion
|
|
|
|
void removeAll();
|
|
void attachActionToEntity(hkpAction* action, hkpEntity* entity);
|
|
void detachActionFromEntity(hkpAction* action, hkpEntity* entity);
|
|
|
|
// region Locking
|
|
|
|
HK_FORCE_INLINE void lockCriticalOperations();
|
|
HK_FORCE_INLINE void unlockCriticalOperations();
|
|
HK_FORCE_INLINE int areCriticalOperationsLocked() const;
|
|
HK_FORCE_INLINE int areCriticalOperationsLockedUnchecked() const;
|
|
|
|
HK_FORCE_INLINE void unlockCriticalOperationsForPhantoms();
|
|
HK_FORCE_INLINE void lockCriticalOperationsForPhantoms();
|
|
HK_FORCE_INLINE int areCriticalOperationsLockedForPhantoms() const;
|
|
|
|
HK_FORCE_INLINE void blockExecutingPendingOperations(hkBool block);
|
|
HK_FORCE_INLINE void unlockAndAttemptToExecutePendingOperations();
|
|
|
|
HK_FORCE_INLINE void attemptToExecutePendingOperations(bool executeBodyOperations = true);
|
|
|
|
void queueOperation(const hkWorldOperation::BaseOperation& operation);
|
|
|
|
hkWorldOperation::UserCallback* queueCallback(hkWorldOperation::UserCallback* callback,
|
|
hkUlong userData = 0);
|
|
|
|
void addBodyOperation(hkpRigidBody* breakingBody, hkpBodyOperation* operation, int priority,
|
|
/*hkpBodyOperation::ExecutionState*/ int hint);
|
|
|
|
void checkConstraintsViolated();
|
|
|
|
private:
|
|
void internal_executePendingOperations();
|
|
void internal_executePendingBodyOperations();
|
|
|
|
public:
|
|
HK_FORCE_INLINE void allowCriticalOperations(hkBool allow);
|
|
|
|
// endregion
|
|
|
|
hkpSimulation* m_simulation;
|
|
hkVector4 m_gravity;
|
|
hkpSimulationIsland* m_fixedIsland;
|
|
hkpRigidBody* m_fixedRigidBody;
|
|
|
|
hkArray<hkpSimulationIsland*> m_activeSimulationIslands;
|
|
hkArray<hkpSimulationIsland*> m_inactiveSimulationIslands;
|
|
hkArray<hkpSimulationIsland*> m_dirtySimulationIslands;
|
|
|
|
hkpWorldMaintenanceMgr* m_maintenanceMgr;
|
|
hkRefPtr<hkWorldMemoryAvailableWatchDog> m_memoryWatchDog;
|
|
|
|
hkBool m_assertOnRunningOutOfSolverMemory;
|
|
|
|
hkEnum<hkpWorldCinfo::BroadPhaseType, hkInt8> m_broadPhaseType;
|
|
hkpBroadPhase* m_broadPhase;
|
|
|
|
hkpTypedBroadPhaseDispatcher* m_broadPhaseDispatcher;
|
|
hkpPhantomBroadPhaseListener* m_phantomBroadPhaseListener;
|
|
hkpEntityEntityBroadPhaseListener* m_entityEntityBroadPhaseListener;
|
|
hkpBroadPhaseBorderListener* m_broadPhaseBorderListener;
|
|
|
|
hkpMtThreadStructure* m_multithreadedSimulationJobData;
|
|
hkpProcessCollisionInput* m_collisionInput;
|
|
hkpCollisionFilter* m_collisionFilter;
|
|
hkpCollisionDispatcher* m_collisionDispatcher;
|
|
hkpConvexListFilter* m_convexListFilter;
|
|
|
|
hkpWorldOperationQueue* m_pendingOperations;
|
|
int m_pendingOperationsCount;
|
|
int m_pendingBodyOperationsCount;
|
|
int m_criticalOperationsLockCount;
|
|
int m_criticalOperationsLockCountForPhantoms;
|
|
hkBool m_blockExecutingPendingOperations;
|
|
hkBool m_criticalOperationsAllowed;
|
|
hkpDebugInfoOnPendingOperationQueues* m_pendingOperationQueues;
|
|
int m_pendingOperationQueueCount;
|
|
|
|
mutable hkMultiThreadCheck m_multiThreadCheck;
|
|
|
|
hkBool m_processActionsInSingleThread;
|
|
hkBool m_allowIntegrationOfIslandsWithoutConstraintsInASeparateJob;
|
|
|
|
hkUint32 m_minDesiredIslandSize;
|
|
|
|
hkCriticalSection* m_modifyConstraintCriticalSection;
|
|
int m_isLocked;
|
|
hkCriticalSection* m_islandDirtyListCriticalSection;
|
|
hkCriticalSection* m_propertyMasterLock;
|
|
|
|
hkBool m_wantSimulationIslands;
|
|
|
|
hkReal m_snapCollisionToConvexEdgeThreshold;
|
|
hkReal m_snapCollisionToConcaveEdgeThreshold;
|
|
hkBool m_enableToiWeldRejection;
|
|
|
|
hkBool m_wantDeactivation;
|
|
hkBool m_shouldActivateOnRigidBodyTransformChange;
|
|
hkReal m_deactivationReferenceDistance;
|
|
|
|
hkReal m_toiCollisionResponseRotateNormal;
|
|
|
|
int m_maxSectorsPerMidphaseCollideTask;
|
|
int m_maxSectorsPerNarrowphaseCollideTask;
|
|
hkBool m_processToisMultithreaded;
|
|
int m_maxEntriesPerToiMidphaseCollideTask;
|
|
int m_maxEntriesPerToiNarrowphaseCollideTask;
|
|
int m_maxNumToiCollisionPairsSinglethreaded;
|
|
hkEnum<hkpWorldCinfo::SimulationType, hkInt32> m_simulationType;
|
|
hkReal m_numToisTillAllowedPenetrationSimplifiedToi;
|
|
hkReal m_numToisTillAllowedPenetrationToi;
|
|
hkReal m_numToisTillAllowedPenetrationToiHigher;
|
|
hkReal m_numToisTillAllowedPenetrationToiForced;
|
|
|
|
hkUint32 m_lastEntityUid;
|
|
hkUint32 m_lastIslandUid;
|
|
hkUint32 m_lastConstraintUid;
|
|
|
|
friend class hkHalfstepSimulation;
|
|
friend class hkpContinuousSimulation;
|
|
friend class hkpMultiThreadedSimulation;
|
|
friend class hkpSimpleConstraintContactMgr;
|
|
friend class hkpSimulation;
|
|
friend class hkpWorldCallbackUtil;
|
|
friend class hkpWorldOperationUtil;
|
|
|
|
hkArray<hkpPhantom*> m_phantoms;
|
|
|
|
hkArray<hkpActionListener*> m_actionListeners;
|
|
hkArray<hkpEntityListener*> m_entityListeners;
|
|
hkArray<hkpPhantomListener*> m_phantomListeners;
|
|
hkArray<hkpConstraintListener*> m_constraintListeners;
|
|
hkArray<hkpWorldDeletionListener*> m_worldDeletionListeners;
|
|
hkArray<hkpIslandActivationListener*> m_islandActivationListeners;
|
|
hkArray<hkpWorldPostSimulationListener*> m_worldPostSimulationListeners;
|
|
hkArray<hkpWorldPostIntegrateListener*> m_worldPostIntegrateListeners;
|
|
hkArray<hkpWorldPostCollideListener*> m_worldPostCollideListeners;
|
|
hkArray<hkpIslandPostIntegrateListener*> m_islandPostIntegrateListeners;
|
|
hkArray<hkpIslandPostCollideListener*> m_islandPostCollideListeners;
|
|
hkArray<hkpContactListener*> m_contactListeners;
|
|
hkArray<hkpContactImpulseLimitBreachedListener*> m_contactImpulseLimitBreachedListeners;
|
|
hkArray<hkpWorldExtension*> m_worldExtensions;
|
|
hkpViolatedConstraintArray* m_violatedConstraintArray;
|
|
|
|
hkpBroadPhaseBorder* m_broadPhaseBorder;
|
|
|
|
hkdWorld* m_destructionWorld;
|
|
hknpWorld* m_npWorld;
|
|
|
|
hkpWorldDynamicsStepInfo m_dynamicsStepInfo;
|
|
|
|
hkVector4 m_broadPhaseExtents[2];
|
|
int m_broadPhaseNumMarkers;
|
|
int m_sizeOfToiEventQueue;
|
|
hkInt32 m_broadPhaseQuerySize;
|
|
hkInt32 m_broadPhaseUpdateSize;
|
|
hkEnum<hkpWorldCinfo::ContactPointGeneration, hkInt8> m_contactPointGeneration;
|
|
hkBool m_useCompoundSpuElf;
|
|
};
|
|
|
|
inline hkpSolverInfo* hkpWorld::getSolverInfo() {
|
|
return &m_dynamicsStepInfo.m_solverInfo;
|
|
}
|