DestructibleAsset.h

Go to the documentation of this file.

//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions
// are met:
//  * Redistributions of source code must retain the above copyright
//    notice, this list of conditions and the following disclaimer.
//  * Redistributions in binary form must reproduce the above copyright
//    notice, this list of conditions and the following disclaimer in the
//    documentation and/or other materials provided with the distribution.
//  * Neither the name of NVIDIA CORPORATION nor the names of its
//    contributors may be used to endorse or promote products derived
//    from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
// PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
// OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// Copyright (c) 2018 NVIDIA Corporation. All rights reserved.



#ifndef DESTRUCTIBLE_ASSET_H
#define DESTRUCTIBLE_ASSET_H

#define DESTRUCTIBLE_AUTHORING_TYPE_NAME "DestructibleAsset"

#include "foundation/Px.h"
#include "FractureToolsAPI.h"
// TODO: Remove this include when we remove the APEX_RUNTIME_FRACTURE define
#include "ModuleDestructible.h"

#if PX_PHYSICS_VERSION_MAJOR == 3
#include "PxFiltering.h"
#endif

namespace nvidia
{
namespace apex
{

struct IntPair;
class DestructibleActor;
class DestructiblePreview;

PX_PUSH_PACK_DEFAULT
#if !PX_PS4
    #pragma warning(push)
    #pragma warning(disable:4121)
#endif  //!PX_PS4

struct DestructibleDepthParametersFlag
{
    enum Enum
    {
        OVERRIDE_IMPACT_DAMAGE          = (1 << 0),

        OVERRIDE_IMPACT_DAMAGE_VALUE    = (1 << 1),

        IGNORE_POSE_UPDATES             = (1 << 2),

        IGNORE_RAYCAST_CALLBACKS        = (1 << 3),

        IGNORE_CONTACT_CALLBACKS        = (1 << 4),

        USER_FLAG_0                     = (1 << 24),
        USER_FLAG_1                     = (1 << 25),
        USER_FLAG_2                     = (1 << 26),
        USER_FLAG_3                     = (1 << 27)
    };
};


struct DestructibleDepthParameters
{
    PX_INLINE       DestructibleDepthParameters();

    PX_INLINE void  setToDefault();

    PX_INLINE void  setToMostExpensive();

    PX_INLINE bool  overrideImpactDamage() const;

    PX_INLINE bool  overrideImpactDamageValue() const;

    PX_INLINE bool  ignoresPoseUpdates() const;

    PX_INLINE bool  ignoresRaycastCallbacks() const;

    PX_INLINE bool  ignoresContactCallbacks() const;

    PX_INLINE bool  hasUserFlagSet(uint32_t flagIndex) const;

    uint32_t        flags;
};

// DestructibleDepthParameters inline functions

PX_INLINE DestructibleDepthParameters::DestructibleDepthParameters()
{
    setToDefault();
}

PX_INLINE void DestructibleDepthParameters::setToDefault()
{
    flags = 0;
}

PX_INLINE bool DestructibleDepthParameters::overrideImpactDamage() const
{
    return (flags & DestructibleDepthParametersFlag::OVERRIDE_IMPACT_DAMAGE) != 0;
}

PX_INLINE bool DestructibleDepthParameters::overrideImpactDamageValue() const
{
    return (flags & DestructibleDepthParametersFlag::OVERRIDE_IMPACT_DAMAGE_VALUE) != 0;
}

PX_INLINE bool DestructibleDepthParameters::ignoresPoseUpdates() const
{
    return (flags & DestructibleDepthParametersFlag::IGNORE_POSE_UPDATES) != 0;
}

PX_INLINE bool DestructibleDepthParameters::ignoresRaycastCallbacks() const
{
    return (flags & DestructibleDepthParametersFlag::IGNORE_RAYCAST_CALLBACKS) != 0;
}

PX_INLINE bool DestructibleDepthParameters::ignoresContactCallbacks() const
{
    return (flags & DestructibleDepthParametersFlag::IGNORE_CONTACT_CALLBACKS) != 0;
}

PX_INLINE bool DestructibleDepthParameters::hasUserFlagSet(uint32_t flagIndex) const
{
    switch (flagIndex)
    {
    case 0:
        return (flags & DestructibleDepthParametersFlag::USER_FLAG_0) != 0;
    case 1:
        return (flags & DestructibleDepthParametersFlag::USER_FLAG_1) != 0;
    case 2:
        return (flags & DestructibleDepthParametersFlag::USER_FLAG_2) != 0;
    case 3:
        return (flags & DestructibleDepthParametersFlag::USER_FLAG_3) != 0;
    default:
        return false;
    }
}

struct DestructibleRTFractureParameters
{
    bool sheetFracture;

    uint32_t depthLimit;

    bool destroyIfAtDepthLimit;

    float minConvexSize;

    float impulseScale;

    struct FractureGlass 
    {
        uint32_t numSectors;

        float sectorRand;

        float firstSegmentSize;

        float segmentScale;

        float segmentRand;
    }glass; 

    struct FractureAttachment 
    {
        bool posX;

        bool negX;

        bool posY;

        bool negY;

        bool posZ;

        bool negZ;
    }attachment; 

    PX_INLINE void  setToDefault();
};

PX_INLINE void DestructibleRTFractureParameters::setToDefault()
{
    sheetFracture = true;
    depthLimit = 2;
    destroyIfAtDepthLimit = false;
    minConvexSize = 0.02f;
    impulseScale = 1.0f;
    glass.numSectors = 10;
    glass.sectorRand = 0.3f;
    glass.firstSegmentSize = 0.06f;
    glass.segmentScale = 1.4f;
    glass.segmentRand = 0.3f;
    attachment.posX = false;
    attachment.negX = false;
    attachment.posY = false;
    attachment.negY = false;
    attachment.posZ = false;
    attachment.negZ = false;
}

struct DestructibleParametersFlag
{
    enum Enum
    {
        ACCUMULATE_DAMAGE = (1 << 0),

        DEBRIS_TIMEOUT =    (1 << 1),

        DEBRIS_MAX_SEPARATION = (1 << 2),

        CRUMBLE_SMALLEST_CHUNKS =   (1 << 3),

        ACCURATE_RAYCASTS = (1 << 4),

        USE_VALID_BOUNDS =  (1 << 5),

        CRUMBLE_VIA_RUNTIME_FRACTURE =  (1 << 6),
    };
};


struct DestructibleParameters
{
    PX_INLINE       DestructibleParameters();

    PX_INLINE void  setToDefault();

    float           damageCap;

    float           forceToDamage;

    float           impactVelocityThreshold;

    uint32_t        minimumFractureDepth;

    int32_t         impactDamageDefaultDepth;

    int32_t         debrisDepth;

    uint32_t        essentialDepth;

    float           debrisLifetimeMin;
    
    float           debrisLifetimeMax;

    float           debrisMaxSeparationMin;
    
    float           debrisMaxSeparationMax;

    float           debrisDestructionProbability;

    PxBounds3       validBounds;

    float           maxChunkSpeed;

    uint32_t        flags;

    float           fractureImpulseScale;

    uint16_t        damageDepthLimit;

    uint8_t         dynamicChunksDominanceGroup;

    bool            useDynamicChunksGroupsMask;

#if PX_PHYSICS_VERSION_MAJOR == 3

    physx::PxFilterData dynamicChunksFilterData;
#endif

    float           supportStrength;

    int8_t          legacyChunkBoundsTestSetting;

    int8_t          legacyDamageRadiusSpreadSetting;

    enum { kDepthParametersCountMax = 16 };

    uint32_t        depthParametersCount;

    DestructibleDepthParameters depthParameters[kDepthParametersCountMax];

    DestructibleRTFractureParameters rtFractureParameters;

    bool            alwaysDrawScatterMesh;
};

// DestructibleParameters inline functions

PX_INLINE DestructibleParameters::DestructibleParameters()
{
    setToDefault();
}

PX_INLINE void DestructibleParameters::setToDefault()
{
    damageCap = 0;
    forceToDamage = 0;
    impactVelocityThreshold = 0.0f;
    minimumFractureDepth = 0;
    impactDamageDefaultDepth = -1;
    debrisDepth = -1;
    essentialDepth = 0;
    debrisLifetimeMin = 1.0f;
    debrisLifetimeMax = 10.0f;
    debrisMaxSeparationMin = 1.0f;
    debrisMaxSeparationMax = 10.0f;
    debrisDestructionProbability = 0.0f;
    validBounds = PxBounds3(PxVec3(-10000.0f), PxVec3(10000.0f));
    maxChunkSpeed = 0.0f;
    fractureImpulseScale = 0.0f;
    damageDepthLimit = UINT16_MAX;
    useDynamicChunksGroupsMask = false;
#if PX_PHYSICS_VERSION_MAJOR == 3
    dynamicChunksFilterData.word0 = dynamicChunksFilterData.word1 = dynamicChunksFilterData.word2 = dynamicChunksFilterData.word3 = 0;
#endif
    supportStrength = -1.0;
    legacyChunkBoundsTestSetting = -1;
    legacyDamageRadiusSpreadSetting = -1;
    dynamicChunksDominanceGroup = 0xFF; // Out of range, so it won't be used.
    flags = DestructibleParametersFlag::ACCUMULATE_DAMAGE;
    depthParametersCount = 0;
    rtFractureParameters.setToDefault();
    alwaysDrawScatterMesh = false;
}

struct DestructibleInitParametersFlag
{
    enum Enum
    {
        ASSET_DEFINED_SUPPORT = (1 << 0),

        WORLD_SUPPORT = (1 << 1),

        FORM_EXTENDED_STRUCTURES =  (1 << 2)
    };
};

struct DestructibleInitParameters
{
    PX_INLINE       DestructibleInitParameters();

    PX_INLINE void  setToDefault();

    uint32_t        supportDepth;

    uint32_t        flags;
};


// DestructibleInitParameters inline functions

PX_INLINE DestructibleInitParameters::DestructibleInitParameters()
{
    setToDefault();
}

PX_INLINE void DestructibleInitParameters::setToDefault()
{
    supportDepth = 0;
    flags = 0;
}

struct DamageSpreadFunction
{
    PX_INLINE       DamageSpreadFunction()
    {
        setToDefault();
    }

    PX_INLINE void  setToDefault()
    {
        minimumRadius = 0.0f;
        radiusMultiplier = 1.0f;
        falloffExponent = 1.0f;
    }

    PX_INLINE bool  isValid() const
    {
        return
            minimumRadius >= 0.0f &&
            radiusMultiplier >= 0.0f &&
            falloffExponent >= 0.0f;
    }

    float minimumRadius;    
    float radiusMultiplier; 
    float falloffExponent;  
};

class DestructibleBehaviorGroupDesc : public ApexDesc
{
public:
    PX_INLINE       DestructibleBehaviorGroupDesc();

    PX_INLINE void  setToDefault();

    PX_INLINE bool  isValid() const;

    const char*     name; 
    float           damageThreshold; 
    float           damageToRadius; 
    DamageSpreadFunction    damageSpread; 
    DamageSpreadFunction    damageColorSpread; 
    PxVec4          damageColorChange; 
    float           materialStrength; 
    float           density; 
    float           fadeOut; 
    float           maxDepenetrationVelocity; 
    uint64_t        userData; 
};

// DestructibleChunkDesc inline functions

PX_INLINE DestructibleBehaviorGroupDesc::DestructibleBehaviorGroupDesc()
{
    setToDefault();
}

PX_INLINE void DestructibleBehaviorGroupDesc::setToDefault()
{
    ApexDesc::setToDefault();

    // TC_TODO: suitable default values?
    name = NULL;
    damageThreshold = 1.0f;
    damageToRadius = 0.1f;
    damageSpread.setToDefault();
    damageColorSpread.setToDefault();
    damageColorChange.setZero();
    materialStrength = 0.0f;
    density = 0;
    fadeOut = 1;
    maxDepenetrationVelocity = PX_MAX_F32;
    userData = (uint64_t)0;
}

PX_INLINE bool DestructibleBehaviorGroupDesc::isValid() const
{
    // TC_TODO: this good enough?
    if (damageThreshold < 0 ||
        damageToRadius < 0 ||
        !damageSpread.isValid() ||
        !damageColorSpread.isValid() ||
        materialStrength < 0 ||
        density < 0 ||
        fadeOut < 0 ||
        !(maxDepenetrationVelocity > 0.f))
    {
        return false;
    }

    return ApexDesc::isValid();
}
class DestructibleChunkDesc : public ApexDesc
{
public:
    PX_INLINE               DestructibleChunkDesc();

    PX_INLINE void          setToDefault();

    PX_INLINE bool          isValid() const;

    bool                    isSupportChunk;

    bool                    doNotFracture;

    bool                    doNotDamage;

    bool                    doNotCrumble;

#if APEX_RUNTIME_FRACTURE

    bool                    runtimeFracture;
#endif

    bool                    useInstancedRendering;

    PxVec3                  instancePositionOffset;

    PxVec2                  instanceUVOffset;

    uint16_t                meshIndex;

    int32_t                 parentIndex;

    PxVec3                  surfaceNormal;

    int8_t                  behaviorGroupIndex;

    uint32_t                scatterMeshCount;

    const uint8_t*          scatterMeshIndices;

    const PxMat44*          scatterMeshTransforms;
};

// DestructibleChunkDesc inline functions

PX_INLINE DestructibleChunkDesc::DestructibleChunkDesc()
{
    setToDefault();
}

PX_INLINE void DestructibleChunkDesc::setToDefault()
{
    ApexDesc::setToDefault();
    isSupportChunk = false;
    doNotFracture = false;
    doNotDamage = false;
    doNotCrumble = false;
#if APEX_RUNTIME_FRACTURE
    runtimeFracture = false;
#endif
    useInstancedRendering = false;
    instancePositionOffset = PxVec3(0.0f);
    instanceUVOffset = PxVec2(0.0f);
    meshIndex = 0xFFFF;
    parentIndex = -1;
    surfaceNormal = PxVec3(0.0f);
    behaviorGroupIndex = -1;
    scatterMeshCount = 0;
    scatterMeshIndices = NULL;
    scatterMeshTransforms = NULL;
}

PX_INLINE bool DestructibleChunkDesc::isValid() const
{
    if (meshIndex == 0xFFFF)
    {
        return false;
    }

    return ApexDesc::isValid();
}


class DestructibleGeometryDesc : public ApexDesc
{
public:
    PX_INLINE       DestructibleGeometryDesc();

    PX_INLINE void  setToDefault();

    PX_INLINE bool  isValid() const;

    const nvidia::ExplicitHierarchicalMesh::ConvexHull**    convexHulls;

    uint32_t                                                convexHullCount;

    const CollisionVolumeDesc*                              collisionVolumeDesc;
};

// DestructibleGeometryDesc inline functions

PX_INLINE DestructibleGeometryDesc::DestructibleGeometryDesc()
{
    setToDefault();
}

PX_INLINE void DestructibleGeometryDesc::setToDefault()
{
    ApexDesc::setToDefault();
    convexHulls = NULL;
    convexHullCount = 0;
    collisionVolumeDesc = NULL;
}

PX_INLINE bool DestructibleGeometryDesc::isValid() const
{
    if (convexHullCount == 0 && collisionVolumeDesc == NULL)
    {
        return false;
    }

    if (convexHullCount > 0 && convexHulls == NULL)
    {
        return false;
    }

    return ApexDesc::isValid();
}


class DestructibleAssetCookingDesc : public ApexDesc
{
public:
    PX_INLINE       DestructibleAssetCookingDesc();

    PX_INLINE void  setToDefault();

    PX_INLINE bool  isValid() const;

    DestructibleChunkDesc*          chunkDescs;

    uint32_t                        chunkDescCount;

    DestructibleBehaviorGroupDesc   defaultBehaviorGroupDesc;

    DestructibleBehaviorGroupDesc*  behaviorGroupDescs;

    uint32_t                        behaviorGroupDescCount;

    int8_t                          RTFractureBehaviorGroup;

    DestructibleGeometryDesc*       geometryDescs;

    uint32_t                        geometryDescCount;

    nvidia::IntPair*                supportGraphEdges;

    uint32_t                        supportGraphEdgeCount;
};

// DestructibleAssetCookingDesc inline functions

PX_INLINE DestructibleAssetCookingDesc::DestructibleAssetCookingDesc()
{
    setToDefault();
}

PX_INLINE void DestructibleAssetCookingDesc::setToDefault()
{
    ApexDesc::setToDefault();
    chunkDescs = NULL;
    chunkDescCount = 0;
    geometryDescs = NULL;
    geometryDescCount = 0;
    behaviorGroupDescs = 0;
    behaviorGroupDescCount = 0;
    supportGraphEdges = 0;
    supportGraphEdgeCount = 0;
}

PX_INLINE bool DestructibleAssetCookingDesc::isValid() const
{
    if (chunkDescCount == 0 || chunkDescs == NULL)
    {
        return false;
    }

    for (uint32_t i = 0; i < chunkDescCount; ++i )
    {
        if (!chunkDescs[i].isValid())
        {
            return false;
        }
    }

    if (chunkDescCount >= 65535)
    {
        return false;
    }

    if (geometryDescCount == 0 || geometryDescs == NULL)
    {
        return false;
    }

    for (uint32_t i = 0; i < geometryDescCount; ++i )
    {
        if (!geometryDescs[i].isValid())
        {
            return false;
        }
    }

    if (behaviorGroupDescCount > 127)
    {
        return false;
    }

    for (uint32_t i = 0; i < behaviorGroupDescCount; ++i )
    {
        if (!behaviorGroupDescs[i].isValid())
        {
            return false;
        }
    }

    return ApexDesc::isValid();
}


struct DestructibleAssetStats
{
    uint32_t            totalBytes; 
    uint32_t            chunkCount; 
    uint32_t            chunkBytes; 
    uint32_t            chunkHullDataBytes; 
    uint32_t            collisionCookedHullDataBytes; 
    uint32_t            collisionMeshCount; 
    uint32_t            maxHullVertexCount; 
    uint32_t            maxHullFaceCount; 
    uint32_t            chunkWithMaxEdgeCount; 
    uint32_t            runtimeCookedConvexCount; 
    RenderMeshAssetStats    renderMeshAssetStats; 
};

class DestructibleAssetAuthoring : public AssetAuthoring
{
public:

    virtual ExplicitHierarchicalMesh&   getExplicitHierarchicalMesh() = 0;

    virtual ExplicitHierarchicalMesh&   getCoreExplicitHierarchicalMesh() = 0;

    virtual FractureTools::CutoutSet&   getCutoutSet() = 0;

    virtual uint32_t                    partitionMeshByIslands
    (
        nvidia::ExplicitRenderTriangle* mesh,
        uint32_t meshTriangleCount,
        uint32_t* meshPartition,
        uint32_t meshPartitionMaxCount,
        float padding = 0.0001f
    ) = 0;

    virtual bool                        setRootMesh
    (
        const ExplicitRenderTriangle* meshTriangles,
        uint32_t meshTriangleCount,
        const ExplicitSubmeshData* submeshData,
        uint32_t submeshCount,
        uint32_t* meshPartition = NULL,
        uint32_t meshPartitionCount = 0,
        int32_t* parentIndices = NULL,
        uint32_t parentIndexCount = 0
    ) = 0;

    virtual bool                        importRenderMeshAssetToRootMesh(const nvidia::RenderMeshAsset& renderMeshAsset, uint32_t maxRootDepth = UINT32_MAX) = 0;

    virtual bool                        importDestructibleAssetToRootMesh(const nvidia::DestructibleAsset& destructibleAsset, uint32_t maxRootDepth = UINT32_MAX) = 0;

    virtual bool                        setCoreMesh
    (
        const ExplicitRenderTriangle* mesh,
        uint32_t meshTriangleCount,
        const ExplicitSubmeshData* submeshData,
        uint32_t submeshCount,
        uint32_t* meshPartition = NULL,
        uint32_t meshPartitionCount = 0
    ) = 0;

    virtual bool                        buildExplicitHierarchicalMesh
    (
        ExplicitHierarchicalMesh& hMesh,
        const ExplicitRenderTriangle* meshTriangles,
        uint32_t meshTriangleCount,
        const ExplicitSubmeshData* submeshData,
        uint32_t submeshCount,
        uint32_t* meshPartition = NULL,
        uint32_t meshPartitionCount = 0,
        int32_t* parentIndices = NULL,
        uint32_t parentIndexCount = 0
    ) = 0;

    virtual bool                            createHierarchicallySplitMesh
    (
        const FractureTools::MeshProcessingParameters& meshProcessingParams,
        const FractureTools::FractureSliceDesc& desc,
        const CollisionDesc& collisionDesc,
        bool exportCoreMesh,
        int32_t coreMeshImprintSubmeshIndex,
        uint32_t randomSeed,
        IProgressListener& progressListener,
        volatile bool* cancel = NULL
    ) = 0;

    virtual bool                            createChippedMesh
    (
        const FractureTools::MeshProcessingParameters& meshProcessingParams,
        const FractureTools::FractureCutoutDesc& desc,
        const FractureTools::CutoutSet& cutoutSet,
        const FractureTools::FractureSliceDesc& sliceDesc,
        const FractureTools::FractureVoronoiDesc& voronoiDesc,
        const CollisionDesc& collisionDesc,
        uint32_t randomSeed,
        IProgressListener& progressListener,
        volatile bool* cancel = NULL
    ) = 0;

    virtual void                            buildCutoutSet
    (
        const uint8_t* pixelBuffer,
        uint32_t bufferWidth,
        uint32_t bufferHeight,
        float snapThreshold,
        bool periodic
    ) = 0;

    virtual bool                            calculateCutoutUVMapping
    (
        PxMat33& mapping,
        const nvidia::ExplicitRenderTriangle& triangle
    ) = 0;

    virtual bool                            calculateCutoutUVMapping
    (
        PxMat33& mapping,
        const PxVec3& targetDirection
    ) = 0;

    virtual bool                            createVoronoiSplitMesh
    (
        const FractureTools::MeshProcessingParameters& meshProcessingParams,
        const FractureTools::FractureVoronoiDesc& desc,
        const CollisionDesc& collisionDesc,
        bool exportCoreMesh,
        int32_t coreMeshImprintSubmeshIndex,
        uint32_t randomSeed,
        IProgressListener& progressListener,
        volatile bool* cancel = NULL
    ) = 0;

    virtual uint32_t                        createVoronoiSitesInsideMesh
    (
        PxVec3* siteBuffer,
        uint32_t* siteChunkIndices,
        uint32_t siteCount,
        uint32_t* randomSeed,
        uint32_t* microgridSize,
        BSPOpenMode::Enum meshMode,
        IProgressListener& progressListener,
        uint32_t chunkIndex = 0xFFFFFFFF
    ) = 0;

    virtual uint32_t                    createScatterMeshSites
    (
        uint8_t*                        meshIndices,
        PxMat44*                        relativeTransforms,
        uint32_t*                       chunkMeshStarts,
        uint32_t                        scatterMeshInstancesBufferSize,
        uint32_t                        targetChunkCount,
        const uint16_t*                 targetChunkIndices,
        uint32_t*                       randomSeed,
        uint32_t                        scatterMeshAssetCount,
        nvidia::RenderMeshAsset**           scatterMeshAssets,
        const uint32_t*                 minCount,
        const uint32_t*                 maxCount,
        const float*                    minScales,
        const float*                    maxScales,
        const float*                    maxAngles
    ) = 0;

    virtual void                            visualizeVoronoiCells
    (
        nvidia::RenderDebugInterface& debugRender,
        const PxVec3* sites,
        uint32_t siteCount,
        const uint32_t* cellColors,
        uint32_t cellColorCount,
        const PxBounds3& bounds,
        uint32_t cellIndex = 0xFFFFFFFF
    ) = 0;

    virtual bool                            hierarchicallySplitChunk
    (
        uint32_t chunkIndex,
        const FractureTools::MeshProcessingParameters& meshProcessingParams,
        const FractureTools::FractureSliceDesc& desc,
        const CollisionDesc& collisionDesc,
        uint32_t* randomSeed,
        IProgressListener& progressListener,
        volatile bool* cancel = NULL
    ) = 0;

    virtual bool                            voronoiSplitChunk
    (
        uint32_t chunkIndex,
        const FractureTools::MeshProcessingParameters& meshProcessingParams,
        const FractureTools::FractureVoronoiDesc& desc,
        const CollisionDesc& collisionDesc,
        uint32_t* randomSeed,
        IProgressListener& progressListener,
        volatile bool* cancel = NULL
    ) = 0;

    virtual void                            setBSPTolerances
    (
        float linearTolerance,
        float angularTolerance,
        float baseTolerance,
        float clipTolerance,
        float cleaningTolerance
    ) = 0;

    virtual void    setBSPBuildParameters
    (
        float logAreaSigmaThreshold,
        uint32_t testSetSize,
        float splitWeight,
        float imbalanceWeight
    ) = 0;


    virtual ExplicitHierarchicalMesh::ConvexHull*   createExplicitHierarchicalMeshConvexHull() = 0;

    virtual uint32_t                        buildSliceMesh(const ExplicitRenderTriangle*& mesh, const FractureTools::NoiseParameters& noiseParameters, const PxPlane& slicePlane, uint32_t randomSeed) = 0;

    virtual void                            serializeFractureToolState(PxFileBuf& stream, nvidia::ExplicitHierarchicalMesh::Embedding& embedding) const = 0;
    
    virtual void                            deserializeFractureToolState(PxFileBuf& stream, nvidia::ExplicitHierarchicalMesh::Embedding& embedding) = 0;

    virtual void                            setChunkOverlapsCacheDepth(int32_t depth = -1) = 0;

    virtual const RenderMeshAsset*          getRenderMeshAsset() const = 0;

    virtual bool                            setRenderMeshAsset(RenderMeshAsset*) = 0;

    virtual bool                            setScatterMeshAssets(RenderMeshAsset** scatterMeshAssetArray, uint32_t scatterMeshAssetArraySize) = 0;

    virtual uint32_t                        getScatterMeshAssetCount() const = 0;

    virtual RenderMeshAsset* const *        getScatterMeshAssets() const = 0;

    virtual uint32_t                        getInstancedChunkMeshCount() const = 0;

    virtual void                            setDestructibleParameters(const DestructibleParameters&) = 0;

    virtual DestructibleParameters          getDestructibleParameters() const = 0;

    virtual void                            setDestructibleInitParameters(const DestructibleInitParameters&) = 0;

    virtual DestructibleInitParameters      getDestructibleInitParameters() const = 0;

    virtual void                            setCrumbleEmitterName(const char*) = 0;

    virtual void                            setDustEmitterName(const char*) = 0;

    virtual void                            setFracturePatternName(const char*) = 0;

    virtual void                            setNeighborPadding(float neighborPadding) = 0;

    virtual float                           getNeighborPadding() const = 0;

    virtual void                            cookChunks( const DestructibleAssetCookingDesc& cookingDesc, bool cacheOverlaps = true,
                                                        uint32_t* chunkIndexMapUser2Apex = NULL, uint32_t* chunkIndexMapApex2User = NULL, uint32_t chunkIndexMapCount = 0) = 0;

    virtual float                           getFractureImpulseScale() const = 0;

    virtual float                           getImpactVelocityThreshold() const = 0;

    virtual uint32_t                        getChunkCount() const = 0;

    virtual uint32_t                        getDepthCount() const = 0;

    virtual uint32_t                        getChunkChildCount(uint32_t chunkIndex) const = 0;

    virtual int32_t                         getChunkChild(uint32_t chunkIndex, uint32_t childIndex) const = 0;

    virtual PxVec3                          getChunkPositionOffset(uint32_t chunkIndex) const = 0;

    virtual PxVec2                          getChunkUVOffset(uint32_t chunkIndex) const = 0;

    virtual uint32_t                        getPartIndex(uint32_t chunkIndex) const = 0;

    virtual void                            trimCollisionGeometry(const uint32_t* partIndices, uint32_t partIndexCount, float maxTrimFraction = 0.2f) = 0;

    virtual void                            getStats(DestructibleAssetStats& stats) const = 0;

    virtual void                            cacheChunkOverlapsUpToDepth(int32_t depth = -1) = 0;

    virtual void                            clearChunkOverlaps(int32_t depth = -1, bool keepCachedFlag = false) = 0;

    virtual void                            addChunkOverlaps(IntPair* supportGraphEdges, uint32_t numSupportGraphEdges) = 0;

    virtual void                            removeChunkOverlaps(IntPair* supportGraphEdges, uint32_t numSupportGraphEdges, bool keepCachedFlagIfEmpty) = 0;

    virtual uint32_t                        getCachedOverlapCountAtDepth(uint32_t depth) = 0;

    virtual const IntPair*                  getCachedOverlapsAtDepth(uint32_t depth) = 0;

    virtual void                            applyTransformation(const PxMat44& transformation, float scale) = 0;

    virtual void                            applyTransformation(const PxMat44& transformation) = 0;

    virtual bool                            setPlatformMaxDepth(PlatformTag platform, uint32_t maxDepth) = 0;

    virtual bool                            removePlatformMaxDepth(PlatformTag platform) = 0;

    virtual uint32_t                        getActorTransformCount() const = 0;

    virtual const PxMat44*                  getActorTransforms() const = 0;

    virtual void                            appendActorTransforms(const PxMat44* transforms, uint32_t transformCount) = 0;

    virtual void                            clearActorTransforms() = 0;
};

class DestructibleAsset : public Asset
{
public:
    enum ChunkFlags
    {
        ChunkEnvironmentallySupported =     (1 << 0),
        ChunkAndDescendentsDoNotFracture =  (1 << 1),
        ChunkDoesNotFracture =              (1 << 2),
        ChunkDoesNotCrumble =               (1 << 3),
#if APEX_RUNTIME_FRACTURE
        ChunkRuntimeFracture =              (1 << 4),
#endif
        ChunkIsInstanced =                  (1 << 16)
    };

    virtual void                            releaseDestructibleActor(DestructibleActor& actor) = 0;


    virtual DestructibleActor*              createDestructibleActorFromDeserializedState(::NvParameterized::Interface* actorParams, Scene& apexScene) = 0;

    virtual DestructibleParameters          getDestructibleParameters() const = 0;

    virtual DestructibleInitParameters      getDestructibleInitParameters() const = 0;

    virtual const char*                     getCrumbleEmitterName() const = 0;

    virtual const char*                     getDustEmitterName() const = 0;

    virtual uint32_t                        getChunkCount() const = 0;

    virtual uint32_t                        getDepthCount() const = 0;

    virtual const RenderMeshAsset*          getRenderMeshAsset() const = 0;

    virtual bool                            setRenderMeshAsset(RenderMeshAsset*) = 0;

    virtual uint32_t                        getScatterMeshAssetCount() const = 0;

    virtual RenderMeshAsset* const *        getScatterMeshAssets() const = 0;

    virtual uint32_t                        getInstancedChunkMeshCount() const = 0;

    virtual void                            getStats(DestructibleAssetStats& stats) const = 0;

    virtual void                            cacheChunkOverlapsUpToDepth(int32_t depth = -1) = 0;

    virtual void                            clearChunkOverlaps(int32_t depth = -1, bool keepCachedFlag = false) = 0;

    virtual void                            addChunkOverlaps(IntPair* supportGraphEdges, uint32_t numSupportGraphEdges) = 0;

    virtual void                            removeChunkOverlaps(IntPair* supportGraphEdges, uint32_t numSupportGraphEdges, bool keepCachedFlagIfEmpty) = 0;

    virtual uint32_t                        getCachedOverlapCountAtDepth(uint32_t depth) const = 0;

    virtual const IntPair*                  getCachedOverlapsAtDepth(uint32_t depth) const = 0;

    virtual PxVec3                          getChunkPositionOffset(uint32_t chunkIndex) const = 0;

    virtual PxVec2                          getChunkUVOffset(uint32_t chunkIndex) const = 0;

    virtual uint32_t                        getChunkFlags(uint32_t chunkIndex) const = 0;

    virtual uint16_t                        getChunkDepth(uint32_t chunkIndex) const = 0;

    virtual int32_t                         getChunkParentIndex(uint32_t chunkIndex) const = 0;

    virtual PxBounds3                       getChunkActorLocalBounds(uint32_t chunkIndex) const = 0;

    virtual uint32_t                        getPartIndex(uint32_t chunkIndex) const = 0;

    virtual uint32_t                        getPartConvexHullCount(const uint32_t partIndex) const = 0;

    virtual NvParameterized::Interface**    getPartConvexHullArray(const uint32_t partIndex) const = 0;

    virtual uint32_t                        getActorTransformCount() const = 0;

    virtual const PxMat44*                  getActorTransforms() const = 0;

    virtual void                            applyTransformation(const PxMat44& transformation, float scale) = 0;

    virtual void                            applyTransformation(const PxMat44& transformation) = 0;

    virtual bool                            rebuildCollisionGeometry(uint32_t partIndex, const DestructibleGeometryDesc& geometryDesc) = 0;

protected:
    virtual                                 ~DestructibleAsset() {}
};


#if !PX_PS4
    #pragma warning(pop)
#endif  //!PX_PS4

PX_POP_PACK

}
} // end namespace nvidia

#endif // DESTRUCTIBLE_ASSET_H