DestructibleAsset.h
00001 /* 00002 * Copyright (c) 2008-2017, NVIDIA CORPORATION. All rights reserved. 00003 * 00004 * NVIDIA CORPORATION and its licensors retain all intellectual property 00005 * and proprietary rights in and to this software, related documentation 00006 * and any modifications thereto. Any use, reproduction, disclosure or 00007 * distribution of this software and related documentation without an express 00008 * license agreement from NVIDIA CORPORATION is strictly prohibited. 00009 */ 00010 00011 00012 #ifndef DESTRUCTIBLE_ASSET_H 00013 #define DESTRUCTIBLE_ASSET_H 00014 00015 #define DESTRUCTIBLE_AUTHORING_TYPE_NAME "DestructibleAsset" 00016 00017 #include "foundation/Px.h" 00018 #include "FractureToolsAPI.h" 00019 // TODO: Remove this include when we remove the APEX_RUNTIME_FRACTURE define 00020 #include "ModuleDestructible.h" 00021 00022 #if PX_PHYSICS_VERSION_MAJOR == 3 00023 #include "PxFiltering.h" 00024 #endif 00025 00026 namespace nvidia 00027 { 00028 namespace apex 00029 { 00030 00031 struct IntPair; 00032 class DestructibleActor; 00033 class DestructiblePreview; 00034 00035 PX_PUSH_PACK_DEFAULT 00036 #if !PX_PS4 00037 #pragma warning(push) 00038 #pragma warning(disable:4121) 00039 #endif //!PX_PS4 00040 00044 struct DestructibleDepthParametersFlag 00045 { 00049 enum Enum 00050 { 00056 OVERRIDE_IMPACT_DAMAGE = (1 << 0), 00057 00061 OVERRIDE_IMPACT_DAMAGE_VALUE = (1 << 1), 00062 00066 IGNORE_POSE_UPDATES = (1 << 2), 00067 00071 IGNORE_RAYCAST_CALLBACKS = (1 << 3), 00072 00076 IGNORE_CONTACT_CALLBACKS = (1 << 4), 00077 00081 USER_FLAG_0 = (1 << 24), 00082 USER_FLAG_1 = (1 << 25), 00083 USER_FLAG_2 = (1 << 26), 00084 USER_FLAG_3 = (1 << 27) 00085 }; 00086 }; 00087 00088 00092 struct DestructibleDepthParameters 00093 { 00097 PX_INLINE DestructibleDepthParameters(); 00098 00102 PX_INLINE void setToDefault(); 00103 00107 PX_INLINE void setToMostExpensive(); 00108 00112 PX_INLINE bool overrideImpactDamage() const; 00113 00117 PX_INLINE bool overrideImpactDamageValue() const; 00118 00122 PX_INLINE bool ignoresPoseUpdates() const; 00123 00127 PX_INLINE bool ignoresRaycastCallbacks() const; 00128 00132 PX_INLINE bool ignoresContactCallbacks() const; 00133 00137 PX_INLINE bool hasUserFlagSet(uint32_t flagIndex) const; 00138 00142 uint32_t flags; 00143 }; 00144 00145 // DestructibleDepthParameters inline functions 00146 00147 PX_INLINE DestructibleDepthParameters::DestructibleDepthParameters() 00148 { 00149 setToDefault(); 00150 } 00151 00152 PX_INLINE void DestructibleDepthParameters::setToDefault() 00153 { 00154 flags = 0; 00155 } 00156 00157 PX_INLINE bool DestructibleDepthParameters::overrideImpactDamage() const 00158 { 00159 return (flags & DestructibleDepthParametersFlag::OVERRIDE_IMPACT_DAMAGE) != 0; 00160 } 00161 00162 PX_INLINE bool DestructibleDepthParameters::overrideImpactDamageValue() const 00163 { 00164 return (flags & DestructibleDepthParametersFlag::OVERRIDE_IMPACT_DAMAGE_VALUE) != 0; 00165 } 00166 00167 PX_INLINE bool DestructibleDepthParameters::ignoresPoseUpdates() const 00168 { 00169 return (flags & DestructibleDepthParametersFlag::IGNORE_POSE_UPDATES) != 0; 00170 } 00171 00172 PX_INLINE bool DestructibleDepthParameters::ignoresRaycastCallbacks() const 00173 { 00174 return (flags & DestructibleDepthParametersFlag::IGNORE_RAYCAST_CALLBACKS) != 0; 00175 } 00176 00177 PX_INLINE bool DestructibleDepthParameters::ignoresContactCallbacks() const 00178 { 00179 return (flags & DestructibleDepthParametersFlag::IGNORE_CONTACT_CALLBACKS) != 0; 00180 } 00181 00182 PX_INLINE bool DestructibleDepthParameters::hasUserFlagSet(uint32_t flagIndex) const 00183 { 00184 switch (flagIndex) 00185 { 00186 case 0: 00187 return (flags & DestructibleDepthParametersFlag::USER_FLAG_0) != 0; 00188 case 1: 00189 return (flags & DestructibleDepthParametersFlag::USER_FLAG_1) != 0; 00190 case 2: 00191 return (flags & DestructibleDepthParametersFlag::USER_FLAG_2) != 0; 00192 case 3: 00193 return (flags & DestructibleDepthParametersFlag::USER_FLAG_3) != 0; 00194 default: 00195 return false; 00196 } 00197 } 00198 00202 struct DestructibleRTFractureParameters 00203 { 00208 bool sheetFracture; 00209 00214 uint32_t depthLimit; 00215 00220 bool destroyIfAtDepthLimit; 00221 00225 float minConvexSize; 00226 00230 float impulseScale; 00231 00235 struct FractureGlass 00236 { 00240 uint32_t numSectors; 00241 00245 float sectorRand; 00246 00250 float firstSegmentSize; 00251 00255 float segmentScale; 00256 00260 float segmentRand; 00261 }glass; 00262 00266 struct FractureAttachment 00267 { 00271 bool posX; 00272 00276 bool negX; 00277 00281 bool posY; 00282 00286 bool negY; 00287 00291 bool posZ; 00292 00296 bool negZ; 00297 }attachment; 00298 00302 PX_INLINE void setToDefault(); 00303 }; 00304 00305 PX_INLINE void DestructibleRTFractureParameters::setToDefault() 00306 { 00307 sheetFracture = true; 00308 depthLimit = 2; 00309 destroyIfAtDepthLimit = false; 00310 minConvexSize = 0.02f; 00311 impulseScale = 1.0f; 00312 glass.numSectors = 10; 00313 glass.sectorRand = 0.3f; 00314 glass.firstSegmentSize = 0.06f; 00315 glass.segmentScale = 1.4f; 00316 glass.segmentRand = 0.3f; 00317 attachment.posX = false; 00318 attachment.negX = false; 00319 attachment.posY = false; 00320 attachment.negY = false; 00321 attachment.posZ = false; 00322 attachment.negZ = false; 00323 } 00324 00328 struct DestructibleParametersFlag 00329 { 00333 enum Enum 00334 { 00340 ACCUMULATE_DAMAGE = (1 << 0), 00341 00347 DEBRIS_TIMEOUT = (1 << 1), 00348 00355 DEBRIS_MAX_SEPARATION = (1 << 2), 00356 00364 CRUMBLE_SMALLEST_CHUNKS = (1 << 3), 00365 00372 ACCURATE_RAYCASTS = (1 << 4), 00373 00379 USE_VALID_BOUNDS = (1 << 5), 00380 00386 CRUMBLE_VIA_RUNTIME_FRACTURE = (1 << 6), 00387 }; 00388 }; 00389 00390 00394 struct DestructibleParameters 00395 { 00399 PX_INLINE DestructibleParameters(); 00400 00404 PX_INLINE void setToDefault(); 00405 00411 float damageCap; 00412 00419 float forceToDamage; 00420 00427 float impactVelocityThreshold; 00428 00432 uint32_t minimumFractureDepth; 00433 00439 int32_t impactDamageDefaultDepth; 00440 00447 int32_t debrisDepth; 00448 00455 uint32_t essentialDepth; 00456 00465 float debrisLifetimeMin; 00466 00468 float debrisLifetimeMax; 00469 00478 float debrisMaxSeparationMin; 00479 00481 float debrisMaxSeparationMax; 00482 00488 float debrisDestructionProbability; 00489 00495 PxBounds3 validBounds; 00496 00501 float maxChunkSpeed; 00502 00506 uint32_t flags; 00507 00512 float fractureImpulseScale; 00513 00518 uint16_t damageDepthLimit; 00519 00523 uint8_t dynamicChunksDominanceGroup; 00524 00529 bool useDynamicChunksGroupsMask; 00530 00531 #if PX_PHYSICS_VERSION_MAJOR == 3 00532 00535 physx::PxFilterData dynamicChunksFilterData; 00536 #endif 00537 00541 float supportStrength; 00542 00548 int8_t legacyChunkBoundsTestSetting; 00549 00555 int8_t legacyDamageRadiusSpreadSetting; 00556 00560 enum { kDepthParametersCountMax = 16 }; 00561 00566 uint32_t depthParametersCount; 00567 00574 DestructibleDepthParameters depthParameters[kDepthParametersCountMax]; 00575 00579 DestructibleRTFractureParameters rtFractureParameters; 00580 00585 bool alwaysDrawScatterMesh; 00586 }; 00587 00588 // DestructibleParameters inline functions 00589 00590 PX_INLINE DestructibleParameters::DestructibleParameters() 00591 { 00592 setToDefault(); 00593 } 00594 00595 PX_INLINE void DestructibleParameters::setToDefault() 00596 { 00597 damageCap = 0; 00598 forceToDamage = 0; 00599 impactVelocityThreshold = 0.0f; 00600 minimumFractureDepth = 0; 00601 impactDamageDefaultDepth = -1; 00602 debrisDepth = -1; 00603 essentialDepth = 0; 00604 debrisLifetimeMin = 1.0f; 00605 debrisLifetimeMax = 10.0f; 00606 debrisMaxSeparationMin = 1.0f; 00607 debrisMaxSeparationMax = 10.0f; 00608 debrisDestructionProbability = 0.0f; 00609 validBounds = PxBounds3(PxVec3(-10000.0f), PxVec3(10000.0f)); 00610 maxChunkSpeed = 0.0f; 00611 fractureImpulseScale = 0.0f; 00612 damageDepthLimit = UINT16_MAX; 00613 useDynamicChunksGroupsMask = false; 00614 #if PX_PHYSICS_VERSION_MAJOR == 3 00615 dynamicChunksFilterData.word0 = dynamicChunksFilterData.word1 = dynamicChunksFilterData.word2 = dynamicChunksFilterData.word3 = 0; 00616 #endif 00617 supportStrength = -1.0; 00618 legacyChunkBoundsTestSetting = -1; 00619 legacyDamageRadiusSpreadSetting = -1; 00620 dynamicChunksDominanceGroup = 0xFF; // Out of range, so it won't be used. 00621 flags = DestructibleParametersFlag::ACCUMULATE_DAMAGE; 00622 depthParametersCount = 0; 00623 rtFractureParameters.setToDefault(); 00624 alwaysDrawScatterMesh = false; 00625 } 00626 00630 struct DestructibleInitParametersFlag 00631 { 00635 enum Enum 00636 { 00643 ASSET_DEFINED_SUPPORT = (1 << 0), 00644 00651 WORLD_SUPPORT = (1 << 1), 00652 00657 FORM_EXTENDED_STRUCTURES = (1 << 2) 00658 }; 00659 }; 00660 00664 struct DestructibleInitParameters 00665 { 00669 PX_INLINE DestructibleInitParameters(); 00670 00674 PX_INLINE void setToDefault(); 00675 00680 uint32_t supportDepth; 00681 00685 uint32_t flags; 00686 }; 00687 00688 00689 // DestructibleInitParameters inline functions 00690 00691 PX_INLINE DestructibleInitParameters::DestructibleInitParameters() 00692 { 00693 setToDefault(); 00694 } 00695 00696 PX_INLINE void DestructibleInitParameters::setToDefault() 00697 { 00698 supportDepth = 0; 00699 flags = 0; 00700 } 00701 00705 struct DamageSpreadFunction 00706 { 00707 PX_INLINE DamageSpreadFunction() 00708 { 00709 setToDefault(); 00710 } 00711 00715 PX_INLINE void setToDefault() 00716 { 00717 minimumRadius = 0.0f; 00718 radiusMultiplier = 1.0f; 00719 falloffExponent = 1.0f; 00720 } 00721 00725 PX_INLINE bool isValid() const 00726 { 00727 return 00728 minimumRadius >= 0.0f && 00729 radiusMultiplier >= 0.0f && 00730 falloffExponent >= 0.0f; 00731 } 00732 00733 float minimumRadius; 00734 float radiusMultiplier; 00735 float falloffExponent; 00736 }; 00737 00743 class DestructibleBehaviorGroupDesc : public ApexDesc 00744 { 00745 public: 00749 PX_INLINE DestructibleBehaviorGroupDesc(); 00750 00754 PX_INLINE void setToDefault(); 00755 00759 PX_INLINE bool isValid() const; 00760 00765 const char* name; 00766 float damageThreshold; 00767 float damageToRadius; 00768 DamageSpreadFunction damageSpread; 00769 DamageSpreadFunction damageColorSpread; 00770 PxVec4 damageColorChange; 00771 float materialStrength; 00772 float density; 00773 float fadeOut; 00774 float maxDepenetrationVelocity; 00775 uint64_t userData; 00776 }; 00777 00778 // DestructibleChunkDesc inline functions 00779 00780 PX_INLINE DestructibleBehaviorGroupDesc::DestructibleBehaviorGroupDesc() 00781 { 00782 setToDefault(); 00783 } 00784 00785 PX_INLINE void DestructibleBehaviorGroupDesc::setToDefault() 00786 { 00787 ApexDesc::setToDefault(); 00788 00789 // TC_TODO: suitable default values? 00790 name = NULL; 00791 damageThreshold = 1.0f; 00792 damageToRadius = 0.1f; 00793 damageSpread.setToDefault(); 00794 damageColorSpread.setToDefault(); 00795 damageColorChange.setZero(); 00796 materialStrength = 0.0f; 00797 density = 0; 00798 fadeOut = 1; 00799 maxDepenetrationVelocity = PX_MAX_F32; 00800 userData = (uint64_t)0; 00801 } 00802 00803 PX_INLINE bool DestructibleBehaviorGroupDesc::isValid() const 00804 { 00805 // TC_TODO: this good enough? 00806 if (damageThreshold < 0 || 00807 damageToRadius < 0 || 00808 !damageSpread.isValid() || 00809 !damageColorSpread.isValid() || 00810 materialStrength < 0 || 00811 density < 0 || 00812 fadeOut < 0 || 00813 !(maxDepenetrationVelocity > 0.f)) 00814 { 00815 return false; 00816 } 00817 00818 return ApexDesc::isValid(); 00819 } 00825 class DestructibleChunkDesc : public ApexDesc 00826 { 00827 public: 00831 PX_INLINE DestructibleChunkDesc(); 00832 00836 PX_INLINE void setToDefault(); 00837 00841 PX_INLINE bool isValid() const; 00842 00847 bool isSupportChunk; 00848 00852 bool doNotFracture; 00853 00857 bool doNotDamage; 00858 00868 bool doNotCrumble; 00869 00870 #if APEX_RUNTIME_FRACTURE 00871 00875 bool runtimeFracture; 00876 #endif 00877 00885 bool useInstancedRendering; 00886 00892 PxVec3 instancePositionOffset; 00893 00899 PxVec2 instanceUVOffset; 00900 00907 uint16_t meshIndex; 00908 00913 int32_t parentIndex; 00914 00918 PxVec3 surfaceNormal; 00919 00923 int8_t behaviorGroupIndex; 00924 00929 uint32_t scatterMeshCount; 00930 00936 const uint8_t* scatterMeshIndices; 00937 00944 const PxMat44* scatterMeshTransforms; 00945 }; 00946 00947 // DestructibleChunkDesc inline functions 00948 00949 PX_INLINE DestructibleChunkDesc::DestructibleChunkDesc() 00950 { 00951 setToDefault(); 00952 } 00953 00954 PX_INLINE void DestructibleChunkDesc::setToDefault() 00955 { 00956 ApexDesc::setToDefault(); 00957 isSupportChunk = false; 00958 doNotFracture = false; 00959 doNotDamage = false; 00960 doNotCrumble = false; 00961 #if APEX_RUNTIME_FRACTURE 00962 runtimeFracture = false; 00963 #endif 00964 useInstancedRendering = false; 00965 instancePositionOffset = PxVec3(0.0f); 00966 instanceUVOffset = PxVec2(0.0f); 00967 meshIndex = 0xFFFF; 00968 parentIndex = -1; 00969 surfaceNormal = PxVec3(0.0f); 00970 behaviorGroupIndex = -1; 00971 scatterMeshCount = 0; 00972 scatterMeshIndices = NULL; 00973 scatterMeshTransforms = NULL; 00974 } 00975 00976 PX_INLINE bool DestructibleChunkDesc::isValid() const 00977 { 00978 if (meshIndex == 0xFFFF) 00979 { 00980 return false; 00981 } 00982 00983 return ApexDesc::isValid(); 00984 } 00985 00986 00992 class DestructibleGeometryDesc : public ApexDesc 00993 { 00994 public: 00998 PX_INLINE DestructibleGeometryDesc(); 00999 01003 PX_INLINE void setToDefault(); 01004 01008 PX_INLINE bool isValid() const; 01009 01014 const nvidia::ExplicitHierarchicalMesh::ConvexHull** convexHulls; 01015 01021 uint32_t convexHullCount; 01022 01027 const CollisionVolumeDesc* collisionVolumeDesc; 01028 }; 01029 01030 // DestructibleGeometryDesc inline functions 01031 01032 PX_INLINE DestructibleGeometryDesc::DestructibleGeometryDesc() 01033 { 01034 setToDefault(); 01035 } 01036 01037 PX_INLINE void DestructibleGeometryDesc::setToDefault() 01038 { 01039 ApexDesc::setToDefault(); 01040 convexHulls = NULL; 01041 convexHullCount = 0; 01042 collisionVolumeDesc = NULL; 01043 } 01044 01045 PX_INLINE bool DestructibleGeometryDesc::isValid() const 01046 { 01047 if (convexHullCount == 0 && collisionVolumeDesc == NULL) 01048 { 01049 return false; 01050 } 01051 01052 if (convexHullCount > 0 && convexHulls == NULL) 01053 { 01054 return false; 01055 } 01056 01057 return ApexDesc::isValid(); 01058 } 01059 01060 01066 class DestructibleAssetCookingDesc : public ApexDesc 01067 { 01068 public: 01072 PX_INLINE DestructibleAssetCookingDesc(); 01073 01077 PX_INLINE void setToDefault(); 01078 01082 PX_INLINE bool isValid() const; 01083 01087 DestructibleChunkDesc* chunkDescs; 01088 01092 uint32_t chunkDescCount; 01093 01097 DestructibleBehaviorGroupDesc defaultBehaviorGroupDesc; 01098 01102 DestructibleBehaviorGroupDesc* behaviorGroupDescs; 01103 01107 uint32_t behaviorGroupDescCount; 01108 01112 int8_t RTFractureBehaviorGroup; 01113 01117 DestructibleGeometryDesc* geometryDescs; 01118 01122 uint32_t geometryDescCount; 01123 01129 nvidia::IntPair* supportGraphEdges; 01130 01134 uint32_t supportGraphEdgeCount; 01135 }; 01136 01137 // DestructibleAssetCookingDesc inline functions 01138 01139 PX_INLINE DestructibleAssetCookingDesc::DestructibleAssetCookingDesc() 01140 { 01141 setToDefault(); 01142 } 01143 01144 PX_INLINE void DestructibleAssetCookingDesc::setToDefault() 01145 { 01146 ApexDesc::setToDefault(); 01147 chunkDescs = NULL; 01148 chunkDescCount = 0; 01149 geometryDescs = NULL; 01150 geometryDescCount = 0; 01151 behaviorGroupDescs = 0; 01152 behaviorGroupDescCount = 0; 01153 supportGraphEdges = 0; 01154 supportGraphEdgeCount = 0; 01155 } 01156 01157 PX_INLINE bool DestructibleAssetCookingDesc::isValid() const 01158 { 01159 if (chunkDescCount == 0 || chunkDescs == NULL) 01160 { 01161 return false; 01162 } 01163 01164 for (uint32_t i = 0; i < chunkDescCount; ++i ) 01165 { 01166 if (!chunkDescs[i].isValid()) 01167 { 01168 return false; 01169 } 01170 } 01171 01172 if (chunkDescCount >= 65535) 01173 { 01174 return false; 01175 } 01176 01177 if (geometryDescCount == 0 || geometryDescs == NULL) 01178 { 01179 return false; 01180 } 01181 01182 for (uint32_t i = 0; i < geometryDescCount; ++i ) 01183 { 01184 if (!geometryDescs[i].isValid()) 01185 { 01186 return false; 01187 } 01188 } 01189 01190 if (behaviorGroupDescCount > 127) 01191 { 01192 return false; 01193 } 01194 01195 for (uint32_t i = 0; i < behaviorGroupDescCount; ++i ) 01196 { 01197 if (!behaviorGroupDescs[i].isValid()) 01198 { 01199 return false; 01200 } 01201 } 01202 01203 return ApexDesc::isValid(); 01204 } 01205 01206 01210 struct DestructibleAssetStats 01211 { 01212 uint32_t totalBytes; 01213 uint32_t chunkCount; 01214 uint32_t chunkBytes; 01215 uint32_t chunkHullDataBytes; 01216 uint32_t collisionCookedHullDataBytes; 01217 uint32_t collisionMeshCount; 01218 uint32_t maxHullVertexCount; 01219 uint32_t maxHullFaceCount; 01220 uint32_t chunkWithMaxEdgeCount; 01221 uint32_t runtimeCookedConvexCount; 01222 RenderMeshAssetStats renderMeshAssetStats; 01223 }; 01224 01228 class DestructibleAssetAuthoring : public AssetAuthoring 01229 { 01230 public: 01231 01241 virtual ExplicitHierarchicalMesh& getExplicitHierarchicalMesh() = 0; 01242 01248 virtual ExplicitHierarchicalMesh& getCoreExplicitHierarchicalMesh() = 0; 01249 01255 virtual FractureTools::CutoutSet& getCutoutSet() = 0; 01256 01268 virtual uint32_t partitionMeshByIslands 01269 ( 01270 nvidia::ExplicitRenderTriangle* mesh, 01271 uint32_t meshTriangleCount, 01272 uint32_t* meshPartition, 01273 uint32_t meshPartitionMaxCount, 01274 float padding = 0.0001f 01275 ) = 0; 01276 01298 virtual bool setRootMesh 01299 ( 01300 const ExplicitRenderTriangle* meshTriangles, 01301 uint32_t meshTriangleCount, 01302 const ExplicitSubmeshData* submeshData, 01303 uint32_t submeshCount, 01304 uint32_t* meshPartition = NULL, 01305 uint32_t meshPartitionCount = 0, 01306 int32_t* parentIndices = NULL, 01307 uint32_t parentIndexCount = 0 01308 ) = 0; 01309 01317 virtual bool importRenderMeshAssetToRootMesh(const nvidia::RenderMeshAsset& renderMeshAsset, uint32_t maxRootDepth = UINT32_MAX) = 0; 01318 01327 virtual bool importDestructibleAssetToRootMesh(const nvidia::DestructibleAsset& destructibleAsset, uint32_t maxRootDepth = UINT32_MAX) = 0; 01328 01341 virtual bool setCoreMesh 01342 ( 01343 const ExplicitRenderTriangle* mesh, 01344 uint32_t meshTriangleCount, 01345 const ExplicitSubmeshData* submeshData, 01346 uint32_t submeshCount, 01347 uint32_t* meshPartition = NULL, 01348 uint32_t meshPartitionCount = 0 01349 ) = 0; 01350 01375 virtual bool buildExplicitHierarchicalMesh 01376 ( 01377 ExplicitHierarchicalMesh& hMesh, 01378 const ExplicitRenderTriangle* meshTriangles, 01379 uint32_t meshTriangleCount, 01380 const ExplicitSubmeshData* submeshData, 01381 uint32_t submeshCount, 01382 uint32_t* meshPartition = NULL, 01383 uint32_t meshPartitionCount = 0, 01384 int32_t* parentIndices = NULL, 01385 uint32_t parentIndexCount = 0 01386 ) = 0; 01387 01403 virtual bool createHierarchicallySplitMesh 01404 ( 01405 const FractureTools::MeshProcessingParameters& meshProcessingParams, 01406 const FractureTools::FractureSliceDesc& desc, 01407 const CollisionDesc& collisionDesc, 01408 bool exportCoreMesh, 01409 int32_t coreMeshImprintSubmeshIndex, 01410 uint32_t randomSeed, 01411 IProgressListener& progressListener, 01412 volatile bool* cancel = NULL 01413 ) = 0; 01414 01431 virtual bool createChippedMesh 01432 ( 01433 const FractureTools::MeshProcessingParameters& meshProcessingParams, 01434 const FractureTools::FractureCutoutDesc& desc, 01435 const FractureTools::CutoutSet& cutoutSet, 01436 const FractureTools::FractureSliceDesc& sliceDesc, 01437 const FractureTools::FractureVoronoiDesc& voronoiDesc, 01438 const CollisionDesc& collisionDesc, 01439 uint32_t randomSeed, 01440 IProgressListener& progressListener, 01441 volatile bool* cancel = NULL 01442 ) = 0; 01443 01453 virtual void buildCutoutSet 01454 ( 01455 const uint8_t* pixelBuffer, 01456 uint32_t bufferWidth, 01457 uint32_t bufferHeight, 01458 float snapThreshold, 01459 bool periodic 01460 ) = 0; 01461 01470 virtual bool calculateCutoutUVMapping 01471 ( 01472 PxMat33& mapping, 01473 const nvidia::ExplicitRenderTriangle& triangle 01474 ) = 0; 01475 01487 virtual bool calculateCutoutUVMapping 01488 ( 01489 PxMat33& mapping, 01490 const PxVec3& targetDirection 01491 ) = 0; 01492 01508 virtual bool createVoronoiSplitMesh 01509 ( 01510 const FractureTools::MeshProcessingParameters& meshProcessingParams, 01511 const FractureTools::FractureVoronoiDesc& desc, 01512 const CollisionDesc& collisionDesc, 01513 bool exportCoreMesh, 01514 int32_t coreMeshImprintSubmeshIndex, 01515 uint32_t randomSeed, 01516 IProgressListener& progressListener, 01517 volatile bool* cancel = NULL 01518 ) = 0; 01519 01539 virtual uint32_t createVoronoiSitesInsideMesh 01540 ( 01541 PxVec3* siteBuffer, 01542 uint32_t* siteChunkIndices, 01543 uint32_t siteCount, 01544 uint32_t* randomSeed, 01545 uint32_t* microgridSize, 01546 BSPOpenMode::Enum meshMode, 01547 IProgressListener& progressListener, 01548 uint32_t chunkIndex = 0xFFFFFFFF 01549 ) = 0; 01550 01573 virtual uint32_t createScatterMeshSites 01574 ( 01575 uint8_t* meshIndices, 01576 PxMat44* relativeTransforms, 01577 uint32_t* chunkMeshStarts, 01578 uint32_t scatterMeshInstancesBufferSize, 01579 uint32_t targetChunkCount, 01580 const uint16_t* targetChunkIndices, 01581 uint32_t* randomSeed, 01582 uint32_t scatterMeshAssetCount, 01583 nvidia::RenderMeshAsset** scatterMeshAssets, 01584 const uint32_t* minCount, 01585 const uint32_t* maxCount, 01586 const float* minScales, 01587 const float* maxScales, 01588 const float* maxAngles 01589 ) = 0; 01590 01604 virtual void visualizeVoronoiCells 01605 ( 01606 nvidia::RenderDebugInterface& debugRender, 01607 const PxVec3* sites, 01608 uint32_t siteCount, 01609 const uint32_t* cellColors, 01610 uint32_t cellColorCount, 01611 const PxBounds3& bounds, 01612 uint32_t cellIndex = 0xFFFFFFFF 01613 ) = 0; 01614 01629 virtual bool hierarchicallySplitChunk 01630 ( 01631 uint32_t chunkIndex, 01632 const FractureTools::MeshProcessingParameters& meshProcessingParams, 01633 const FractureTools::FractureSliceDesc& desc, 01634 const CollisionDesc& collisionDesc, 01635 uint32_t* randomSeed, 01636 IProgressListener& progressListener, 01637 volatile bool* cancel = NULL 01638 ) = 0; 01639 01654 virtual bool voronoiSplitChunk 01655 ( 01656 uint32_t chunkIndex, 01657 const FractureTools::MeshProcessingParameters& meshProcessingParams, 01658 const FractureTools::FractureVoronoiDesc& desc, 01659 const CollisionDesc& collisionDesc, 01660 uint32_t* randomSeed, 01661 IProgressListener& progressListener, 01662 volatile bool* cancel = NULL 01663 ) = 0; 01664 01674 virtual void setBSPTolerances 01675 ( 01676 float linearTolerance, 01677 float angularTolerance, 01678 float baseTolerance, 01679 float clipTolerance, 01680 float cleaningTolerance 01681 ) = 0; 01682 01701 virtual void setBSPBuildParameters 01702 ( 01703 float logAreaSigmaThreshold, 01704 uint32_t testSetSize, 01705 float splitWeight, 01706 float imbalanceWeight 01707 ) = 0; 01708 01709 01718 virtual ExplicitHierarchicalMesh::ConvexHull* createExplicitHierarchicalMeshConvexHull() = 0; 01719 01726 virtual uint32_t buildSliceMesh(const ExplicitRenderTriangle*& mesh, const FractureTools::NoiseParameters& noiseParameters, const PxPlane& slicePlane, uint32_t randomSeed) = 0; 01727 01732 virtual void serializeFractureToolState(PxFileBuf& stream, nvidia::ExplicitHierarchicalMesh::Embedding& embedding) const = 0; 01733 01738 virtual void deserializeFractureToolState(PxFileBuf& stream, nvidia::ExplicitHierarchicalMesh::Embedding& embedding) = 0; 01739 01743 virtual void setChunkOverlapsCacheDepth(int32_t depth = -1) = 0; 01744 01748 virtual const RenderMeshAsset* getRenderMeshAsset() const = 0; 01749 01757 virtual bool setRenderMeshAsset(RenderMeshAsset*) = 0; 01758 01766 virtual bool setScatterMeshAssets(RenderMeshAsset** scatterMeshAssetArray, uint32_t scatterMeshAssetArraySize) = 0; 01767 01769 virtual uint32_t getScatterMeshAssetCount() const = 0; 01770 01772 virtual RenderMeshAsset* const * getScatterMeshAssets() const = 0; 01773 01777 virtual uint32_t getInstancedChunkMeshCount() const = 0; 01778 01782 virtual void setDestructibleParameters(const DestructibleParameters&) = 0; 01783 01788 virtual DestructibleParameters getDestructibleParameters() const = 0; 01789 01793 virtual void setDestructibleInitParameters(const DestructibleInitParameters&) = 0; 01794 01798 virtual DestructibleInitParameters getDestructibleInitParameters() const = 0; 01799 01803 virtual void setCrumbleEmitterName(const char*) = 0; 01804 01808 virtual void setDustEmitterName(const char*) = 0; 01809 01813 virtual void setFracturePatternName(const char*) = 0; 01814 01821 virtual void setNeighborPadding(float neighborPadding) = 0; 01822 01826 virtual float getNeighborPadding() const = 0; 01827 01842 virtual void cookChunks( const DestructibleAssetCookingDesc& cookingDesc, bool cacheOverlaps = true, 01843 uint32_t* chunkIndexMapUser2Apex = NULL, uint32_t* chunkIndexMapApex2User = NULL, uint32_t chunkIndexMapCount = 0) = 0; 01844 01849 virtual float getFractureImpulseScale() const = 0; 01850 01856 virtual float getImpactVelocityThreshold() const = 0; 01857 01861 virtual uint32_t getChunkCount() const = 0; 01862 01866 virtual uint32_t getDepthCount() const = 0; 01867 01872 virtual uint32_t getChunkChildCount(uint32_t chunkIndex) const = 0; 01873 01879 virtual int32_t getChunkChild(uint32_t chunkIndex, uint32_t childIndex) const = 0; 01880 01885 virtual PxVec3 getChunkPositionOffset(uint32_t chunkIndex) const = 0; 01886 01891 virtual PxVec2 getChunkUVOffset(uint32_t chunkIndex) const = 0; 01892 01896 virtual uint32_t getPartIndex(uint32_t chunkIndex) const = 0; 01897 01904 virtual void trimCollisionGeometry(const uint32_t* partIndices, uint32_t partIndexCount, float maxTrimFraction = 0.2f) = 0; 01905 01909 virtual void getStats(DestructibleAssetStats& stats) const = 0; 01910 01917 virtual void cacheChunkOverlapsUpToDepth(int32_t depth = -1) = 0; 01918 01925 virtual void clearChunkOverlaps(int32_t depth = -1, bool keepCachedFlag = false) = 0; 01926 01931 virtual void addChunkOverlaps(IntPair* supportGraphEdges, uint32_t numSupportGraphEdges) = 0; 01932 01941 virtual void removeChunkOverlaps(IntPair* supportGraphEdges, uint32_t numSupportGraphEdges, bool keepCachedFlagIfEmpty) = 0; 01942 01948 virtual uint32_t getCachedOverlapCountAtDepth(uint32_t depth) = 0; 01949 01956 virtual const IntPair* getCachedOverlapsAtDepth(uint32_t depth) = 0; 01957 01967 virtual void applyTransformation(const PxMat44& transformation, float scale) = 0; 01968 01977 virtual void applyTransformation(const PxMat44& transformation) = 0; 01978 01984 virtual bool setPlatformMaxDepth(PlatformTag platform, uint32_t maxDepth) = 0; 01985 01991 virtual bool removePlatformMaxDepth(PlatformTag platform) = 0; 01992 01996 virtual uint32_t getActorTransformCount() const = 0; 01997 02002 virtual const PxMat44* getActorTransforms() const = 0; 02003 02010 virtual void appendActorTransforms(const PxMat44* transforms, uint32_t transformCount) = 0; 02011 02015 virtual void clearActorTransforms() = 0; 02016 }; 02017 02021 class DestructibleAsset : public Asset 02022 { 02023 public: 02027 enum ChunkFlags 02028 { 02029 ChunkEnvironmentallySupported = (1 << 0), 02030 ChunkAndDescendentsDoNotFracture = (1 << 1), 02031 ChunkDoesNotFracture = (1 << 2), 02032 ChunkDoesNotCrumble = (1 << 3), 02033 #if APEX_RUNTIME_FRACTURE 02034 ChunkRuntimeFracture = (1 << 4), 02035 #endif 02036 ChunkIsInstanced = (1 << 16) 02037 }; 02038 02047 virtual void releaseDestructibleActor(DestructibleActor& actor) = 0; 02048 02049 02058 virtual DestructibleActor* createDestructibleActorFromDeserializedState(::NvParameterized::Interface* actorParams, Scene& apexScene) = 0; 02059 02064 virtual DestructibleParameters getDestructibleParameters() const = 0; 02065 02069 virtual DestructibleInitParameters getDestructibleInitParameters() const = 0; 02070 02075 virtual const char* getCrumbleEmitterName() const = 0; 02076 02081 virtual const char* getDustEmitterName() const = 0; 02082 02086 virtual uint32_t getChunkCount() const = 0; 02087 02091 virtual uint32_t getDepthCount() const = 0; 02092 02096 virtual const RenderMeshAsset* getRenderMeshAsset() const = 0; 02097 02104 virtual bool setRenderMeshAsset(RenderMeshAsset*) = 0; 02105 02107 virtual uint32_t getScatterMeshAssetCount() const = 0; 02108 02110 virtual RenderMeshAsset* const * getScatterMeshAssets() const = 0; 02111 02115 virtual uint32_t getInstancedChunkMeshCount() const = 0; 02116 02120 virtual void getStats(DestructibleAssetStats& stats) const = 0; 02121 02128 virtual void cacheChunkOverlapsUpToDepth(int32_t depth = -1) = 0; 02129 02137 virtual void clearChunkOverlaps(int32_t depth = -1, bool keepCachedFlag = false) = 0; 02138 02146 virtual void addChunkOverlaps(IntPair* supportGraphEdges, uint32_t numSupportGraphEdges) = 0; 02147 02156 virtual void removeChunkOverlaps(IntPair* supportGraphEdges, uint32_t numSupportGraphEdges, bool keepCachedFlagIfEmpty) = 0; 02157 02162 virtual uint32_t getCachedOverlapCountAtDepth(uint32_t depth) const = 0; 02163 02170 virtual const IntPair* getCachedOverlapsAtDepth(uint32_t depth) const = 0; 02171 02176 virtual PxVec3 getChunkPositionOffset(uint32_t chunkIndex) const = 0; 02177 02182 virtual PxVec2 getChunkUVOffset(uint32_t chunkIndex) const = 0; 02183 02187 virtual uint32_t getChunkFlags(uint32_t chunkIndex) const = 0; 02188 02192 virtual uint16_t getChunkDepth(uint32_t chunkIndex) const = 0; 02193 02198 virtual int32_t getChunkParentIndex(uint32_t chunkIndex) const = 0; 02199 02203 virtual PxBounds3 getChunkActorLocalBounds(uint32_t chunkIndex) const = 0; 02204 02208 virtual uint32_t getPartIndex(uint32_t chunkIndex) const = 0; 02209 02213 virtual uint32_t getPartConvexHullCount(const uint32_t partIndex) const = 0; 02214 02218 virtual NvParameterized::Interface** getPartConvexHullArray(const uint32_t partIndex) const = 0; 02219 02223 virtual uint32_t getActorTransformCount() const = 0; 02224 02229 virtual const PxMat44* getActorTransforms() const = 0; 02230 02240 virtual void applyTransformation(const PxMat44& transformation, float scale) = 0; 02241 02250 virtual void applyTransformation(const PxMat44& transformation) = 0; 02251 02256 virtual bool rebuildCollisionGeometry(uint32_t partIndex, const DestructibleGeometryDesc& geometryDesc) = 0; 02257 02258 protected: 02260 virtual ~DestructibleAsset() {} 02261 }; 02262 02263 02264 #if !PX_PS4 02265 #pragma warning(pop) 02266 #endif //!PX_PS4 02267 02268 PX_POP_PACK 02269 02270 } 02271 } // end namespace nvidia 02272 02273 #endif // DESTRUCTIBLE_ASSET_H
Generated on Fri Dec 15 2017 13:58:35 Copyright © 2012-2017 NVIDIA Corporation, 2701 San Tomas Expressway, Santa Clara, CA 95050 U.S.A. All rights reserved.
