APEX Destruction Release Notes

APEX Destruction 1.3.4

New Features

• DestructibleActor::acquirePhysXActorBuffer uses a new flag in DestructiblePhysXActorQueryFlags. ‘AllowActorsNotInScenes’ (default cleared) will return actors that have not yet been added to a PhysX scene.
• DestructiblePhysXActorQueryFlags::All has changed to DestructiblePhysXActorQueryFlags::AllStates, since other (non-state) values are now in the enum.

Removed

Optimizations

Fixes

Miscellaneous API changes

• DestructibleActor::acquirePhysXActorBuffer has a new function signature. The ‘eliminateRedundantActors’ bool is removed, and the flag ‘AllowRedundancy’ added to DestructiblePhysXActorQueryFlags. These have opposite meanings, and their default values are accordingly opposite.

Known Issues

APEX Destruction 1.3.3

New Features

• Destructible assets authored with imported multiple-mesh fbx files now clip their collision hulls to prevent initial penetration when chunks are created.
• New NxPhysX3DescTemplate interface to replace the undefined PhysX3DescTemplate used in public functions NxApexActorSource::setPhysX3Template and ::getPhysX3Template. To use, create an instance using NxApexActorSource::createPhysX3DescTemplate(), and use NxPhysX3DescTemplate::release() when done.

Removed

• Deprecated functions createTwoWayRb, addTwoWayRb, and releaseTwoWayRb have been removed.

Optimizations

Fixes

• Fixed a bug where destructibles fractured when touching kinematics, even if impact damage was disabled.
• Fixed a bug which may have led to errors when disabling detailed overlap tests with performDetailedOverlapTestForExtendedStructures.

Miscellaneous API changes

Known Issues

• Known issue with improper reference counting when using setSkinnedOverrideMaterial, which could lead to APEX trying to release a resource that hasn’t been requested. Use setResource on the material to manually increment its reference count as a workaround.
• Destructible scatter meshes may create render resources outside of updateRenderResources. If you use scatter meshes your callback must be thread safe.
• Potential threading issue when using instanced rendering with destructibles. A destructible could be rendered twice as a result.

APEX Destruction 1.3.2

New Features

• NxDestructibleParameters now has two new fields: legacyChunkBoundsTestSetting and legacyDamageRadiusSpreadSetting. These control whether or not the legacy settings are used per-actor, with per-asset defaults since it is a part of NxDestructibleParameters. These correspond to the NxModuleDestructible functions setUseLegacyChunkBoundsTesting and setUseLegacyDamageRadiusSpread. The per-actor values may override the module values. If the per-actor values are negative (their defaults are -1), then the module values are used. If a per-actor value is 0, then the corresponding setting is “false” (legacy setting is not used). Otherwise, the legacy setting is used.
• NxUserChunkReport has a new virtual callback function onStateChangeNotify that needs to be added to any user implementations. It gets called when chunk visibility changes occur, if the user has enabled it via NxModuleDestructible::scheduleChunkStateEventCallback.
• Destructible authoring API has new functionality that allows it to import full destruction hierarchies. One does this by passing in an array of chunk parent indices to NxFractureTools::buildExplicitHierarchicalMesh or NxDestructibleAssetAuthoring::setRootMesh. PhysXLab uses this when importing a multi-mesh FBX file. If the chunk hierarchy will reflect the parent/child relationship given by the FBX scene graph.
• NxUserChunkReport has a new virtual callback function releaseOnNoChunksVisible. When the last chunk of an NxDestructibleActor disappears, this callback is called. If the user returns true, APEX will release the destructible actor. If the user chooses to release the actor themselves, they must wait until after fetchResults() completes.
• Voronoi fracture distributes its N sites across all pieces of a multi-mesh.
• Added new FractureVoronoi type to RT fracturing.
• Added maxDepentrationVelocity to behavior groups.
• Fracture event callback runs before PhysX simulate step, so the application has a chance to modify PhysX state before simulation.
• Enabled alpha channel for scatter meshes.
• Added user-defined deletion bounding boxes for destructible chunks. See NxApexScene::addBoundingBox and the deleteChunksLeavingUserDefinedBB and deleteChunksEnteringUserDefinedBB parameters of destructible actors.
• Added customizable velocityIterationCount parameter to destructible actors.
• Better conversion of legacy damage spread parameters to the new behavior. See NxDestructibleParameters::legacyChunkBoundsTestSetting and NxDestructibleParameters::legacyDamageRadiusSpreadSetting.
• User-defined support graphs:
  • NxDestructibleAssetCookingDesc::supportGraphEdges
  • NxDestructibleAssetCookingDesc::supportGraphEdgeCount
  • NxDestructibleAssetAuthoring::cacheChunkOverlapsUpToDepth
  • NxDestructibleAssetAuthoring::clearChunkOverlaps
  • NxDestructibleAssetAuthoring::addChunkOverlaps
  • NxDestructibleAssetAuthoring::removeChunkOverlaps
  • NxDestructibleAssetAuthoring::getCachedOverlapCountAtDepth
  • NxDestructibleAssetAuthoring::getCachedOverlapsAtDepth.

Removed

• Support for GPU rigid bodies has been removed.
• Functions createTwoWayRb, addTwoWayRb, and releaseTwoWayRb have been deprecated.
• Removed ‘enabled’ parameter from NxDestructibleAssetAuthoring::setChunkOverlapsCacheDepth(bool enabled, physx::PxI32 depth = -1), it is now a function parameter of cookChunks

Optimizations

• By default, NxDestructibleActor::applyDamage() will only raycast against static chunks. To match the behavior of previous releases, pass NxDestructibleActorRaycastFlags::AllChunks to NxModuleDestructible::setDamageApplicationRaycastFlags(). You can also have it raycast against no chunks.
• Multiple optimizations to destructible actor creation.
• Faster applyDamage.
• Disabled internal benefit calculations when not using the sort by benefit feature.
• Improved damage event report performance.
• Improved support graph rebuild/update performance.
• Store only a single cooking scale in the destructible module cached data, and use PhysX 3.x’s scaling feature instead. Reduces size of data needed for an application when using destructibles at multiple scales. Note that using a scale of (1,1,1) may still give better PhysX performance.
• Improved render update processing which was previously running on some actors that were sleeping.
• Added ability to disable detailed overlap testing for creation of extended structures. See performDetailedOverlapTestForExtendedStructures destructible actor parameter.

Fixes

• No more render resource allocation in fetchResults when instanced chunks are used.
• Chunks with shapes that had their simulation flags reset (eSIMULATION_SHAPE) could get their inertia tensors re-calulated incorrectly, leading to bizarre physical behavior.
• Render resource creation for scatter meshes is now happening in updateRenderResources of the DestructibleRenderable, not at Asset creation anymore.
• Fixed case in extended structures where some shapes on broken off islands did not get the correct shape template (including userData).
• Fixed crash in NxDestructibleAsset::releaseAndReturnNxParameterizedInterface when it is called on an asset with existing actors.
• Fixed bug that caused the last chunks’ graphics to remain when they were destroyed due to a debris setting.
• Fixed behavior when “keepVisibleBonesPacked” is false.
• Fixed NxDestructibleActorJoint not working correctly when jointed to a PxActor.
• When using RT fracture, the renderable bounds now take the RT-fracture chunks into account.
• Fixed various small issues with destructible graphics updates.
• Correctly set applied damage user data in damage event reports.
• Fixed a possible crash when a destructible asset name is NULL.
• Added scene locks to protect potentially unsafe asynchronous sweeps.
• Fixed possible nuisance assertions on destructible actor release and when creating kinematic non-static destructibles.
• Fixed damage event assertion.
• APEX was intercepting onTrigger callbacks from PhysX and not passing them along to the application.
• Apply impact forces to newly created actors in the scene.
• Fixed a memory leak on PS4.
• Fixed improperly inflated convexes when skinWidth is 0, causing bad collision geometry.
• Fixed issue where destructible bounds kept growing.
• Fixed other miscellaneous crash issues.

Miscellaneous API changes

• Moved rebuildCollisionGeometry from NxDestructibleAssetAuthoring to NxDestructibleAsset.
• Renamed “getInstancedChunkCount” to more accurate name “getInstancedChunkMeshCount”
• API cleanup:
  • ExplicitHierarchicalMesh.h renamed to NxExplicitHierarchicalMesh.h
  • FractureTools.h renamed to NxFractureToolsStructs.h
  • Added NxFractureTools.h to expose helper functions that so far were only accessible through NxDestructibleAssetAuthoring
  • Access NxFractureTools through NxModuleDestructible::getFractureTools()
  • Renamed classes and structs in NxExplicitHierarchicalMesh and NxFractureToolsStructs.h to have an Nx prefix
    • IDisplacementMapVolume -> NxDisplacementMapVolume
    • IExplicitHierarchicalMesh -> NxExplicitHierarchicalMesh
    • IEmbedding -> NxEmbedding
    • IConvexHull -> NxConvexHull
    • MeshProcessingParameters -> NxMeshProcessingParameters
    • NoiseParameters -> NxNoiseParameters
    • SliceParameters -> NxSliceParameters
    • FractureSliceDesc -> NxFractureSliceDesc
    • CutoutParameters -> NxCutoutParameters
    • FractureCutoutDesc -> NxFractureCutoutDesc
    • FractureVoronoiDesc -> NxFractureVoronoiDesc
  • Removed “m” prefix of public members of NxMeshProcessingParameters
    • mIslandGeneration -> islandGeneration
    • mRemoveTJunctions -> removeTJunctions
    • mMicrogridSize -> microgridSize
    • mVerbosity -> verbosity

Known Issues

• Known issue with improper reference counting when using setSkinnedOverrideMaterial, which could lead to APEX trying to release a resource that hasn’t been requested. Use setResource on the material to manually increment its reference count as a workaround.
• Destructible scatter meshes may create render resources outside of updateRenderResources. If you use scatter meshes your callback must be thread safe.
• Potential threading issue when using instanced rendering with destructibles. A destructible could be rendered twice as a result.

APEX Destruction 1.3.1

New Features

• Fracturing now handles open meshes. No API change.
• Performance improvement in fetchResults: Only update poses of awake actors.
• Added doNotCreateRenderable parameter to destructible actors. Optimization if the APEX rendering API is being bypassed.
• Added access to scatter meshes from NxDestructibleAsset.
• NxRenderMeshActor::setMaxInstanceCount: Change the max instance count in the case that the instance buffer was changed.
• Improvement to acquirePhysXActorBuffer: Before, if “eliminateRedundantActors” was true, this function could return multiple copies of a PhysX actor per NxDestructibleActor. In 1.3.1, it will only return one PhysX actor per NxDestructibleActor, at most. Also, this query has been made more efficient.

Fixes

• Fixed crash when two or more structures are joined at DestructibleActor creation.
• Fix for assertion in destructible stress solver sample.
• Fixed destructible module cached data in release builds.
• Properly take into account the bias field on weights in destructible benefit calculation.
• Fixed a bad pointer dereference crash.
• Fixed real-time fracturing thread-safety issues.
• Fixed real-time fracturing override of the PxSimulationEventCallback.
• Fixed applyTransformation to also transform scatter meshes.
• Fixed NxDestructibleActorJoint not working correctly when jointed to the world (one actor NULL).
• Fixed potential crash when PhysX 3.x shape creation fails.
• Fixed bad destructible actor deletion/creation accounting, which could potentially have led to bad reference counts on destructibles.
• Fixed crash: APEX could access deleted actors if actor creation rate or fractureBufferProcessRates are exceeded.
• Fixed an unsafe destructible scene release when using GRB.
• Fixed incorrect rendering when a destructible actor is removed from a structure.
• Fixed an issue where the number of dynamic chunks, reported in the DynamicDestructibleChunkIslandCount stat, could exceed the limit set by calling setMaxDynamicChunkIslandCount.
• In some cases when using instanced mesh rendering, creating a destructible actor could lead to a releaseRenderResources callback. That no longer happens.
• FractureTool now handles multi-fbx import
• FractureTool -x option now works correctly

Known Issues

• Known issue with improper reference counting when using setSkinnedOverrideMaterial, which could lead to APEX trying to release a resource that hasn’t been requested. Use setResource on the material to manually increment its reference count as a workaround.
• Destructible scatter meshes may create render resources outside of updateRenderResources. If you use scatter meshes your callback must be thread safe.
• Potential threading issue when using instanced rendering with destructibles. A destructible could be rendered twice as a result.

APEX Destruction 1.3

New Features

• Behavior groups
  • Some common parameters, such as damage threshold, damage spread, density, etc., are now contained in “Behavior Groups.” Every chunk references a behavior group by index, allowing the user to customize behaviors for different chunks.
• Render proxies for destructibles. The rendering of destructibles is managed by a new object that is independent of the destructible actor. By default you will not see a change, but you may detach this object from the destructible, meaning that the render data will not get deleted when the destructible is deleted. You may delete the renderable when you’re done with it. This is useful for multi-threaded renderers which may have the render data queued up even after the destructible is deleted in the main thread.
• New damage detection (can be reverted to legacy behavior):
  • Exact chunk collision volumes used for hit testing (point and radius damage). This gives better consistency when applying damage to destructibles at different LODs.
• New damage spread
  • damageToRadius is no longer used for point and radius damage. Instead, behavior groups contain a DamageSpreadFunction struct, which contains a minimumRadius, radiusMultiplier, and falloffExponent. It works as follows. When damage is applied, it comes with a radius. That radius is zero for a point damage. In any case, we multiply that damage radius by radiusMultiplier, and then add minimumRadius. This value becomes what we call “maximumRadius.” Then, when applying the damage, every chunk up to minumumRadius takes the full damage, and chunks past the maximumRadius take zero damage. How the damage falls off between the minimumRadius and maximumRadius is determined by falloffExponent. Basically, a linear function which goes from 1.0 down to 0.0 between min to max is raised to the power falloffExponent, and the result at a given chunk’s radius is multiplied by the damage, to get the applied damage.
  • damageToRadius is still used for impact damage, but it is no longer scaled by the size of the destructible. To recover the old behavior, multiply the damageToRadius by the approximate radius of the destructible
• Damage vertex coloring
  • The behavior groups now contain a DamageSpreadFunction for damage coloring, as well as a damageColorChange parameter (Vec4). If damageColorChange != (0,0,0,0), a per-actor color channel is created for the destructible. The initial (asset-supplied) color channel is used to initialize it, or all zeros if none exists. Then, using a similar radial behavior to that used for damage spread (above), the color channel is modified by the damageColorChange vector. This allows for some nice effects using multiple-texture shaders. One difference in the radial function: the falloff is calculated between 0 and max radius, instead of min radius and max radius.
• Ability to specify collision volume properties per chunk depth in PhysXLab
• Damage depth limit: You can specify how many hierarchy depths deep fracturing may occur, relative to the chunk that takes the damage.
• More robust fracturing in PhysXLab. BSPs are stored and fractured at a normalized scale, with the output mesh scaled back to the appropriate world coordinates. The result is that many inexplicable errors (BSPs which looked perfect were generating holes and extra triangles) are now gone.
• Better chunk deletion probability behavior. Debris chunks may be deleted with a user-supplied probability. Now the probability distribution is scaled by the damage taken by each chunk, and normalized. The result is that more chunks disappear near the damage point.
• Limited real-time fracturing. Chunks with no child chunks can be real-time fractured now. This means that a fracture pattern is applied to the chunk at a position specified at runtime. This may be applied recursively. In 1.3, only a glass fracture pattern is available.
• A physical stress solver is available when using PhysX 3.3. Stresses are updated as a destructible structure is fractured, and when they exceed a user-specified limit, fracturing will occur at the highest stress points automatically.
• Scatter meshes
  • Ability to author instanced meshes, randomly scattered about the surface of fractured chunks, rotated and scaled with respect to the surface normal within a range specified by the user. Authoring with preview available in PhysXLab.
• Graphical noise on chunk faces with Voronoi fracturing.
• Faster queries (rayCast and obbSweep) for static chunks, if static-only query flags are selected.
• Exposed several functions to get per-chunk state.

Known Issues

• Known issue with improper reference counting when using setSkinnedOverrideMaterial, which could lead to APEX trying to release a resource that hasn’t been requested. Use setResource on the material to manually increment its reference count as a workaround.

APEX Destruction 1.2.4

Fixes

• Fixed contacts not getting detected between PhysX bodies and destructibles when using GRB.

APEX Destruction 1.2.3

New Features

• Added actor synchronization filtering by damage event depth and fracture event depth.
• Added NxDestructibleActor::setDeleteFracturedChunks() to tell a destructible actor to delete its fractured chunks instead of simulating them.
• Added NxUserDestructibleSyncHandler::onPreProcessReadBegin() and NxUserDestructibleSyncHandler::onPreProcessReadDone() callbacks.
• Edited NxUserDestructibleSyncHandler::onReadBegin() callback.
• Removed NxUserDestructibleSyncHandler::onSwizzleDone() callback.
• Added NxDestructibleActorSyncState struct.
• Edited NxDestructibleActor::setSyncParams() method.
• Edited NxDestructibleActor::setHitChunkTrackingParams() method.
• Added new NxDestructibleAssetStats: maxHullVertexCount, maxHullFaceCount, chunkWithMaxEdgeCount.
• NxDestructibleAsset::createDestructibleActor() renamed to NxDestructibleAsset::createDestructibleActorFromDeserializedState().
• NxDestructibleActor::getPartTM() renamed to NxDestructibleActor::getChunkTM().
• IExplicitHierarchicalMesh::IConvexHull::reduceHull function removes vertices from a convex hull until the given limits are reached (after cooking).
• Added both the destructible actor pointer and the chunk index to the NxApexPhysX3Interface::setContactReportFlags() callback when PhysX 3.x shapes are created.

APEX Destruction 1.2.2

New Features

• Option to include use of stress solver in destructibles. The stress solver attempts to detect and break off chunks deemed to be overly-strained.
• Introduced a new parameter struct “StrutureSettings” in the destructible actor. Parameters that make up “StructureSettings” affect all actors’ settings structure-wide.
  • New parameters “useStressSolver”, “stressSolverTimeDelay” and “stressSolverMassThreshold” introduced for the stress solver.

Authoring Improvements

• Option to remove all T-junctions from a fractured mesh. This allows post-processing such as deformation to be applied (for example in a DCC tool).
• Ability to control the interior materials used when fracturing selected chunks.
• Ability to add noise to the perimeter faces of cutout chunks.

Bug Fixes

• ApexHelloWorld sample destruction scene on PS3 crash was fixed

APEX Destruction 1.2.1

New Features

• Enabled GRB support with PhysX 3.2.1.
• Support multiple interior materials.
• Added hard sleeping option, which turns chunk islands kinematic when they sleep. They may be turned dynamic again if enough damage is applied.
• New sleepVelocityFrameDecayConstant parameter replaces sleepVelocitySmoothingFactor.

Removed

• Removed surface trace functionality (was used for old dust system).

Authoring Improvements

• Edge face noise in cutout.

Known Issues

• Known crash in ApexHelloWorld sample destruction scene on PS3 with heavy destruction load.

APEX Destruction 1.2

New Features

• FractureTool FractureTool is a new command-line utility for fracturing and exporting meshes. It provides a subset of the fracturing features exposed by PhysXLab, and serves as a convenient way of batch processing meshes and testing new features.
• NxDestructibleActor
  • Serialization support for actor state provided via the actor’s NxParameterized interface
  • Deserialization support for actor state provided via NxParameterized constructor argument
• Added setGlobalPose/getGlobalPose to NxDestructibleActor (sets the pose of static chunks only).
• Added impactDamageDefaultDepth to NxDestructibleParameters. Chunks up to this depth will take impact damage, unless an override flag is set (see below).
• TAKE_IMPACT_DAMAGE flag has been changed to OVERRIDE_IMPACT_DAMAGE/OVERRIDE_IMPACT_DAMAGE_VALUE. At the given depth, the OVERRIDE_IMPACT_DAMAGE flag tells APEX to use OVERRIDE_IMPACT_DAMAGE_VALUE (true or false) instead of the behavior it would get from impactDamageDefaultDepth (see above).
• New dust and crumble callbacks, using NxUserChunkParticleReport.
• Visibility event buffer for NxDestructibleActors using acquireChunkEventBuffer / releaseChunkEventBuffer.
• Option for second bone buffer for frame-delayed chunk transforms, using keepPreviousFrameBoneBuffer.

Improvements

• LOD performance improvements.
• Better instancing of cutout chunks, allows for UV offset instancing so that texture maps don’t need to tile with the chunk instance tiling. This requires a renderer which uses the new NxRenderInstanceSemantic::UV_OFFSET semantic for the ApexRenderMesh instance buffer.

Authoring Improvements

• Voronoi fracturing mode using NxDestructibleAssetAuthoring::createVoronoiSitesInsideMesh and ::createVoronoiSplitMesh.
• Voronoi cell visualization utility using NxDestructibleAssetAuthoring::visualizeVoronoiCells.
• Several performance optimizations.
• Ability to fracture a single chunk using NxDestructibleAssetAuthoring::hierarchicallySplitChunk.
• Ability to re-calculate a collision hull for a chunk using different settings, or a custom-made hull, and trim the hulls against neighbors to eliminate initial overlap: NxDestructibleAssetAuthoring::rebuildCollisionGeometry and NxDestructibleAssetAuthoring::trimCollisionGeometry.
• Ability to control interior UV mapping direction and offset in slice and cutout mode. See FractureTools::FractureMaterialDesc.
• Utility to deliver a render mesh which displays a typical noisy slice surface for the current settings, using NxDestructibleAssetAuthoring::buildSliceMesh.

Removed

• Deprecated damageToPercentDeformation and deformationPercentLimit in NxDestructibleParameters.

Known Issues

• Known crash in ApexHelloWorld sample destruction scene on PS3 with heavy destruction load.

Bug Fixes

• Better fracture behavior (fewer errors such as missing or extra polygons).

Misc.

• chunkCount()/depthCount() renamed to getChunkCount()/getDepthCount(), for consistency with the rest of the API.
• Destructibe actors that contain GRBs do not send debug visualization data to PhysX Visual Debugger.

APEX Destruction 1.1

New Features

• GPU Rigid Bodies The NxModuleDestructibe has settings to enable GPU Rigid Bodies for destruction. If your hardware supports this feature, large numbers of chunks (in the 1000’s) can be simulated in a fraction of the time taken by a CPU. GRB Rigid Body support requires NVIDIA driver 270.81 or later, PhysX 2.8.4 RC6 or later and a CUDA capable GPU.
• Chunk instancing (When authored to instance) correponding chunks between different destructible actors will be rendered using an instance buffer. This is advantageous if there are many destructible actors which reference the same asset.
• Chunk tiling (When authored to tile) matching chunks created from cutout fracturing will be instanced within the same actor, as well as other destructible actors which reference the same asset. This can drastically reduce the memory size of the asset.
• NxDestructibleActor:

• LOD setting sets the maximum chunk depth which can be fractured, implementing forcePhysicalLOD interface
• getChunkLinearVelocity and getChunkAngularVelocity API in the actor
• Per-actor materials in the actor descriptor
• Can specify a separate render mesh for static chunks which gets drawn in a single draw call, using the renderStaticChunksSeparately field in the actor descriptor
• can set a separate set of static materials used by the static mesh if renderStaticChunksSeparately is set
• minimumFractureDepth added to destructible parameters, to limit the size of the pieces that can be broken free

• NxDestructibleActor:

• Implements applyTransformation interface to geometrically transform an asset

• Fracture event callback now consolidates chunk information to reduce the number of fracture events reported
• NxActor (chunk island) FIFO can now be sorted by “benefit” (takes into account screen size and age of the chunk), so that less-beneficial chunks are removed first.
• NxShape count limit can be set in addition to NxActor count

Improvements

• Chunk creation can be amortized over many frames
• Fracture processing can be amortized over many frames
• Conforms to new LOD system
• Removed the per-chunk thread locks, for better performance and resource usage
• SimpleDestruction has multiple sample scenes, loaded using the keys 1-7

Bug Fixes

• Damage reports are no longer issued when a destructible is set free using setDynamic()
• Several crash bugs fixed

Authoring Improvements

• Ability to have multiple collision hulls per chunk.
• Can cancel the fracture operation
• “Trim face hulls” option in cutout fracturing
• Ability to use multiple UV channels and color channels from FBX meshes
• cookChunks does not use the internal ExplicitHierarchicalMesh any longer, only information passed in from the descriptor

Removed

Known Issues

• Sensitivity of instancing. Instanced cutout fracturing is very sensitive to the scale of the cutout map. It must tile perfectly in order to instance all chunks across a mesh. Similiarly, if there is backface noise in cutout fracturing, the grid size must be a multiple of the number of fracture map tiles. If not, the chunk meshes won’t be exactly duplicated from tile to tile, so they will not instance.
• UV instancing not supported. Therefore the texture maps on the asset must tile with the fracture map if instancing is used. Othterwise there will be a graphical pop when fracturing first occurs on a cutout face.
• Chunk island separation bug. When a chunk does not physically touch any of its neighbors, it forms a chunk support island. When supportDepth is set to that chunk’s depth, and fracturing occurs, that chunk will always break free from the rest of the destructible, and the rest of the destructible breaks free as well. This is very common when there is noise in the slicing surface, and so chunk collision hull trimming is performed in order to prevent hull overlaps.

APEX Destruction 1.0 Beta

New Features

• Ability for objects to pass through destructibles when damage is taken. This uses the new materialStrength parameter.
• Chunk neighbor padding value is exposed, allowing the user to tune how near chunk collision volumes need to be for chunks to be considered neighbors for support calculations.
• Tiling feature for SimpleDestruction (-tile command line argument), allows destructibles to be tiled in the scene. This allows you to see how they form extended structures.

Improvements

• Destructible structures can now contain up to 4 billion chunks (increased from 64k chunks).
• Dynamic chunk islands can contain chunks from more than one destructible, so there is no artificial fracturing at destructible boundaries.
• More robust impact damage.
• Better behavior when LOD budget limit is reached.
• New flags for NxDestructibleActor::rayCast and DestuctibleActor::obbSweep, which allow you to override the ACCURATE_RAYCASTS setting in the asset.

Authoring Improvements

• Better chunk mesh island generation
• Improved cutout fracturing. More robust, no more triangles inside non-convex and better normal/tangent generation on edges of chunks.
• Threshold angle for normal smoothing on cutout fracturing.
• Better spacing calculation of grid used for noisy surface fracturing.
• Better fractured mesh cleaning. Can reduce fractured mesh size significantly (on the order of 50% in some cases).
• Option for periodic backface noise, so that tiled chippable destructibles have no discontinuities between them.
• Option to choose if a core mesh is exported with a destructible or not.
• Option to “transfer” texture map from core mesh to neighboring chunks or not.
• Slicing parameters may be set at each depth in the fracture hierarchy.
• Multiple-part meshes may be fractured. These will become the first stage of fracturing.
• Core meshes may also be made from multiple-part meshes.

Removed

• Replaced NxDestructibleActorDesc and NxDestructiblePreviewDesc with parameterized objects.

Known Issues

• Cutout-fractured tiles (closely packed collision bounds) jitter when fractured.
• Errors in destructible structure calculations - when chunk neighbors initially form an island, the whole destructible may be dislodged when any part of the structure it is in gets damaged.
• Chunk mesh island generation can sometimes produce spurious triangles.
• Open meshes can produce spurious triangles when fractured. Small openings are usually OK.
• Destruction API is not fully buffered.
• PhysXLab can easily runs out of memory on a 32-bit OS, with complex fracturing.
• Support structures don’t perform stress calculations, leading to configurations “hanging by a thread”
• When testing collision of chunks with the static geometry in the PhysX scene (for support determination), only the AABB of the chunk is used.