00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012 #ifndef MODULE_DESTRUCTIBLE_H
00013 #define MODULE_DESTRUCTIBLE_H
00014
00015 #include "foundation/Px.h"
00016 #include "foundation/PxBounds3.h"
00017 #include "Module.h"
00018
00019 #ifndef APEX_RUNTIME_FRACTURE
00020 #define APEX_RUNTIME_FRACTURE 1
00021 #else
00022 #undef APEX_RUNTIME_FRACTURE
00023 #define APEX_RUNTIME_FRACTURE 0
00024 #endif
00025
00026 #if PX_ANDROID
00027 #undef APEX_RUNTIME_FRACTURE
00028 #define APEX_RUNTIME_FRACTURE 0
00029 #endif
00030
00031 namespace physx
00032 {
00033 class PxRigidActor;
00034 class PxRigidDynamic;
00035 class PxScene;
00036 }
00037
00038 namespace nvidia
00039 {
00040 namespace apex
00041 {
00042
00043 PX_PUSH_PACK_DEFAULT
00044
00045 class DestructibleAsset;
00046 class DestructibleAssetAuthoring;
00047 class DestructibleActor;
00048 class DestructibleActorJoint;
00049 class DestructibleChunkDesc;
00050 class DestructibleActorDesc;
00051 class DestructibleActorJointDesc;
00052
00056 struct ApexChunkFlag
00057 {
00061 enum Enum
00062 {
00064 DYNAMIC = 1 << 0,
00065
00067 EXTERNALLY_SUPPORTED = 1 << 1,
00068
00070 WORLD_SUPPORTED = 1 << 2,
00071
00073 FRACTURED = 1 << 3,
00074
00076 DESTROYED_FIFO_FULL = 1 << 4,
00077
00079 DESTROYED_TIMED_OUT = 1 << 5,
00080
00082 DESTROYED_EXCEEDED_MAX_DISTANCE = 1 << 6,
00083
00085 DESTROYED_CRUMBLED = 1 << 7,
00086
00088 DESTROYED_LEFT_VALID_BOUNDS = 1 << 8,
00089
00091 DESTROYED_LEFT_USER_BOUNDS = 1 << 9,
00092
00094 DESTROYED_ENTERED_USER_BOUNDS = 1 << 10
00095 };
00096 };
00097
00101 struct ChunkData
00102 {
00104 uint32_t index;
00105
00107 uint32_t depth;
00108
00112 PxBounds3 worldBounds;
00113
00117 float damage;
00118
00123 uint32_t flags;
00124 };
00125
00129 struct DamageEventReportData
00130 {
00134 DestructibleActor* destructible;
00135
00139 PxVec3 hitDirection;
00140
00145 PxBounds3 worldBounds;
00146
00151 uint32_t totalNumberOfFractureEvents;
00152
00157 uint16_t minDepth;
00158
00163 uint16_t maxDepth;
00164
00173 const ChunkData* fractureEventList;
00174
00180 uint32_t fractureEventListSize;
00181
00185 physx::PxActor const* impactDamageActor;
00186
00187
00191 PxVec3 hitPosition;
00192
00196 void* appliedDamageUserData;
00197 };
00198
00199
00205 struct DestructibleChunkEvent
00206 {
00210 enum EventMask
00211 {
00212 VisibilityChanged = (1 << 0),
00213 ChunkVisible = (1 << 1)
00214 };
00215
00216 uint16_t chunkIndex;
00217 uint16_t event;
00218 };
00219
00220
00224 struct ChunkStateEventData
00225 {
00229 DestructibleActor* destructible;
00230
00234 const DestructibleChunkEvent* stateEventList;
00235
00239 uint32_t stateEventListSize;
00240 };
00241
00242
00246 class UserChunkReport
00247 {
00248 public:
00255 virtual void onDamageNotify(const DamageEventReportData& damageEvent) = 0;
00256
00267 virtual void onStateChangeNotify(const ChunkStateEventData& visibilityEvent) = 0;
00268
00279 virtual bool releaseOnNoChunksVisible(const DestructibleActor* destructible) { PX_UNUSED(destructible); return false; }
00280
00284 virtual void onDestructibleWake(DestructibleActor** destructibles, uint32_t count) = 0;
00285
00289 virtual void onDestructibleSleep(DestructibleActor** destructibles, uint32_t count) = 0;
00290
00291 protected:
00292 virtual ~UserChunkReport() {}
00293 };
00294
00295
00299 struct ChunkParticleReportData
00300 {
00302 const PxVec3* positions;
00303
00305 uint32_t positionCount;
00306
00315 const PxVec3* velocities;
00316
00318 uint32_t velocityCount;
00319 };
00320
00325 class UserChunkParticleReport
00326 {
00327 public:
00337 virtual void onParticleEmission(const ChunkParticleReportData& particleData) = 0;
00338
00339 protected:
00340 virtual ~UserChunkParticleReport() {}
00341 };
00342
00343
00348 class UserDestructiblePhysXActorReport
00349 {
00350 public:
00352 virtual void onPhysXActorCreate(const physx::PxActor& actor) = 0;
00353
00355 virtual void onPhysXActorRelease(const physx::PxActor& actor) = 0;
00356 protected:
00357 virtual ~UserDestructiblePhysXActorReport() {}
00358 };
00359
00360
00364 struct ModuleDestructibleConst
00365 {
00369 enum Enum
00370 {
00375 INVALID_CHUNK_INDEX = -1
00376 };
00377 };
00378
00382 struct DestructibleActorMeshType
00383 {
00387 enum Enum
00388 {
00389 Skinned,
00390 Static,
00391 Count
00392 };
00393 };
00394
00398 struct DamageEventCoreData
00399 {
00400 int32_t chunkIndexInAsset;
00401 PxVec3 position;
00402 float damage;
00403 float radius;
00404 };
00405
00409 struct ImpactDamageEventData : public DamageEventCoreData
00410 {
00411 nvidia::DestructibleActor* destructible;
00412 PxVec3 direction;
00413 physx::PxActor const* impactDamageActor;
00414 };
00415
00419 class UserImpactDamageReport
00420 {
00421 public:
00428 virtual void onImpactDamageNotify(const ImpactDamageEventData* buffer, uint32_t bufferSize) = 0;
00429 };
00430
00434 template<typename DestructibleSyncHeader>
00435 class UserDestructibleSyncHandler
00436 {
00437 public:
00441 virtual void onWriteBegin(DestructibleSyncHeader *& bufferStart, uint32_t bufferSize) = 0;
00442
00446 virtual void onWriteDone(uint32_t headerCount) = 0;
00447
00451 virtual void onPreProcessReadBegin(DestructibleSyncHeader *& bufferStart, uint32_t & bufferSize, bool & continuePointerSwizzling) = 0;
00452
00456 virtual void onPreProcessReadDone(uint32_t headerCount) = 0;
00457
00461 virtual void onReadBegin(const DestructibleSyncHeader *& bufferStart) = 0;
00462
00466 virtual void onReadDone(const char * debugMessage) = 0;
00467 protected:
00468 virtual ~UserDestructibleSyncHandler() {}
00469 };
00470
00471
00472
00473 struct DamageEventUnit;
00477 struct DamageEventHeader
00478 {
00479 uint32_t userActorID;
00480 uint32_t damageEventCount;
00481 DamageEventUnit * damageEventBufferStart;
00482 DamageEventHeader * next;
00483 };
00484
00488 struct DamageEventUnit
00489 {
00490 uint32_t chunkIndex;
00491 uint32_t damageEventFlags;
00492 float damage;
00493 float momentum;
00494 float radius;
00495 PxVec3 position;
00496 PxVec3 direction;
00497 };
00498
00499
00500
00501 struct FractureEventUnit;
00502
00506 struct FractureEventHeader
00507 {
00508 uint32_t userActorID;
00509 uint32_t fractureEventCount;
00510 FractureEventUnit * fractureEventBufferStart;
00511 FractureEventHeader * next;
00512 };
00513
00517 struct FractureEventUnit
00518 {
00519 uint32_t chunkIndex;
00520 uint32_t fractureEventFlags;
00521 PxVec3 position;
00522 PxVec3 direction;
00523 PxVec3 impulse;
00524 };
00525
00526
00527
00528 struct ChunkTransformUnit;
00529
00533 struct ChunkTransformHeader
00534 {
00535 uint32_t userActorID;
00536 uint32_t chunkTransformCount;
00537 ChunkTransformUnit * chunkTransformBufferStart;
00538 ChunkTransformHeader * next;
00539 };
00540
00544 struct ChunkTransformUnit
00545 {
00546 uint32_t chunkIndex;
00547 PxVec3 chunkPosition;
00548 PxQuat chunkOrientation;
00549 };
00550
00551
00555 struct DestructibleActorRaycastFlags
00556 {
00560 enum Enum
00561 {
00562 NoChunks = (0),
00563 StaticChunks = (1 << 0),
00564 DynamicChunks = (1 << 1),
00565
00566 AllChunks = StaticChunks | DynamicChunks,
00567
00568 SegmentIntersect = (1 << 2),
00569
00570 ForceAccurateRaycastsOn = (1 << 3),
00571 ForceAccurateRaycastsOff = (1 << 4),
00572 };
00573 };
00574
00575
00579 struct DestructibleCallbackSchedule
00580 {
00584 enum Enum
00585 {
00586 Disabled = (0),
00587 BeforeTick,
00588 FetchResults,
00589
00590 Count
00591 };
00592 };
00593
00594
00598 class ModuleDestructible : public Module
00599 {
00600 public:
00610 virtual DestructibleActorJoint* createDestructibleActorJoint(const DestructibleActorJointDesc& desc, Scene& scene) = 0;
00611
00617 virtual bool isDestructibleActorJointActive(const DestructibleActorJoint* candidateJoint, Scene& apexScene) const = 0;
00618
00628 virtual void setMaxDynamicChunkIslandCount(uint32_t maxCount) = 0;
00629
00636 virtual void setMaxChunkCount(uint32_t maxCount) = 0;
00637
00642 virtual void setSortByBenefit(bool sortByBenefit) = 0;
00643
00647 virtual void setValidBoundsPadding(float pad) = 0;
00648
00655 virtual void setMaxChunkDepthOffset(uint32_t maxChunkDepthOffset) = 0;
00656
00662 virtual void setMaxChunkSeparationLOD(float separationLOD) = 0;
00663
00664
00670 virtual void setChunkReport(UserChunkReport* chunkReport) = 0;
00671
00676 virtual void setImpactDamageReportCallback(UserImpactDamageReport* impactDamageReport) = 0;
00677
00682 virtual void setChunkReportBitMask(uint32_t chunkReportBitMask) = 0;
00683
00688 virtual void setDestructiblePhysXActorReport(UserDestructiblePhysXActorReport* destructiblePhysXActorReport) = 0;
00689
00695 virtual void setChunkReportMaxFractureEventDepth(uint32_t chunkReportMaxFractureEventDepth) = 0;
00696
00703 virtual void scheduleChunkStateEventCallback(DestructibleCallbackSchedule::Enum chunkStateEventCallbackSchedule) = 0;
00704
00709 virtual void setChunkCrumbleReport(UserChunkParticleReport* chunkCrumbleReport) = 0;
00710
00717 virtual void setChunkDustReport(UserChunkParticleReport* chunkDustReport) = 0;
00718
00724 virtual void setWorldSupportPhysXScene(Scene& apexScene, PxScene* physxScene) = 0;
00725
00730 virtual bool owns(const PxRigidActor* actor) const = 0;
00731
00732 #if APEX_RUNTIME_FRACTURE
00733
00737 virtual bool isRuntimeFractureShape(const PxShape& shape) const = 0;
00738 #endif
00739
00746 virtual DestructibleActor* getDestructibleAndChunk(const PxShape* shape, int32_t* chunkIndex = NULL) const = 0;
00747
00758 virtual void applyRadiusDamage(Scene& scene, float damage, float momentum,
00759 const PxVec3& position, float radius, bool falloff) = 0;
00760
00765 virtual void setMaxActorCreatesPerFrame(uint32_t maxActorsPerFrame) = 0;
00766
00771 virtual void setMaxFracturesProcessedPerFrame(uint32_t maxFracturesProcessedPerFrame) = 0;
00772
00776 virtual bool setSyncParams(UserDestructibleSyncHandler<DamageEventHeader> * userDamageEventHandler, UserDestructibleSyncHandler<FractureEventHeader> * userFractureEventHandler, UserDestructibleSyncHandler<ChunkTransformHeader> * userChunkMotionHandler) = 0;
00777
00788 virtual void setUseLegacyChunkBoundsTesting(bool useLegacyChunkBoundsTesting) = 0;
00789
00801 virtual void setUseLegacyDamageRadiusSpread(bool useLegacyDamageRadiusSpread) = 0;
00802
00819 virtual bool setMassScaling(float massScale, float scaledMassExponent, Scene& apexScene) = 0;
00820
00827 virtual void invalidateBounds(const PxBounds3* bounds, uint32_t boundsCount, Scene& apexScene) = 0;
00828
00839 virtual void setDamageApplicationRaycastFlags(nvidia::DestructibleActorRaycastFlags::Enum flags, Scene& apexScene) = 0;
00840
00850 virtual bool setChunkCollisionHullCookingScale(const PxVec3& scale) = 0;
00851
00855 virtual PxVec3 getChunkCollisionHullCookingScale() const = 0;
00856
00860 virtual class FractureToolsAPI* getFractureTools() const = 0;
00861
00862 protected:
00863 virtual ~ModuleDestructible() {}
00864 };
00865
00866
00867 #if !defined(_USRDLL)
00868
00872 void instantiateModuleDestructible();
00873 #endif
00874
00875 PX_POP_PACK
00876
00877 }
00878 }
00879
00880 #endif // MODULE_DESTRUCTIBLE_H