ModuleDestructible.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 MODULE_DESTRUCTIBLE_H
#define MODULE_DESTRUCTIBLE_H

#include "foundation/Px.h"
#include "foundation/PxBounds3.h"
#include "Module.h"

#ifndef APEX_RUNTIME_FRACTURE
#define APEX_RUNTIME_FRACTURE 1
#else
#undef APEX_RUNTIME_FRACTURE
#define APEX_RUNTIME_FRACTURE 0
#endif

#if PX_ANDROID
#undef APEX_RUNTIME_FRACTURE
#define APEX_RUNTIME_FRACTURE 0
#endif

namespace physx
{
class PxRigidActor;
class PxRigidDynamic;
class PxScene;
}

namespace nvidia
{
namespace apex
{

PX_PUSH_PACK_DEFAULT

class DestructibleAsset;
class DestructibleAssetAuthoring;
class DestructibleActor;
class DestructibleActorJoint;
class DestructibleChunkDesc;
class DestructibleActorDesc;
class DestructibleActorJointDesc;

struct ApexChunkFlag
{
    enum Enum
    {
        DYNAMIC                         =   1 << 0,

        EXTERNALLY_SUPPORTED            =   1 << 1,

        WORLD_SUPPORTED                 =   1 << 2,

        FRACTURED                       =   1 << 3,

        DESTROYED_FIFO_FULL             =   1 << 4,

        DESTROYED_TIMED_OUT             =   1 << 5,

        DESTROYED_EXCEEDED_MAX_DISTANCE =   1 << 6,

        DESTROYED_CRUMBLED              =   1 << 7,

        DESTROYED_LEFT_VALID_BOUNDS     =   1 << 8,

        DESTROYED_LEFT_USER_BOUNDS      =   1 << 9,

        DESTROYED_ENTERED_USER_BOUNDS   =   1 << 10
    };
};

struct ChunkData
{
    uint32_t            index;

    uint32_t            depth;

    PxBounds3           worldBounds;

    float               damage;

    uint32_t            flags;
};

struct DamageEventReportData
{
    DestructibleActor*  destructible;

    PxVec3              hitDirection;

    PxBounds3           worldBounds;

    uint32_t            totalNumberOfFractureEvents;

    uint16_t            minDepth;
    
    uint16_t            maxDepth;

    const ChunkData*    fractureEventList;

    uint32_t            fractureEventListSize;

    physx::PxActor const*   impactDamageActor;


    PxVec3              hitPosition;

    void*               appliedDamageUserData;
};


struct DestructibleChunkEvent
{
    enum EventMask
    {
        VisibilityChanged   =   (1 << 0),
        ChunkVisible    =       (1 << 1)
    };

    uint16_t    chunkIndex; 
    uint16_t    event; 
};


struct ChunkStateEventData
{
    DestructibleActor*          destructible;

    const DestructibleChunkEvent* stateEventList;

    uint32_t                    stateEventListSize;
};


class UserChunkReport
{
public:
    virtual void    onDamageNotify(const DamageEventReportData& damageEvent) = 0;

    virtual void    onStateChangeNotify(const ChunkStateEventData& visibilityEvent) = 0;

    virtual bool    releaseOnNoChunksVisible(const DestructibleActor* destructible) { PX_UNUSED(destructible);  return false; }

    virtual void    onDestructibleWake(DestructibleActor** destructibles, uint32_t count) = 0;

    virtual void    onDestructibleSleep(DestructibleActor** destructibles, uint32_t count) = 0;

protected:
    virtual         ~UserChunkReport() {}
};


struct ChunkParticleReportData
{
    const PxVec3* positions;

    uint32_t positionCount;

    const PxVec3* velocities;

    uint32_t velocityCount;
};

class UserChunkParticleReport
{
public:
    virtual void    onParticleEmission(const ChunkParticleReportData& particleData) = 0;

protected:
    virtual         ~UserChunkParticleReport() {}
};


class UserDestructiblePhysXActorReport
{
public:
    virtual void    onPhysXActorCreate(const physx::PxActor& actor) = 0;

    virtual void    onPhysXActorRelease(const physx::PxActor& actor) = 0;
protected:
    virtual     ~UserDestructiblePhysXActorReport() {}
};


struct ModuleDestructibleConst
{
    enum Enum
    {
        INVALID_CHUNK_INDEX = -1
    };
};

struct DestructibleActorMeshType
{
    enum Enum
    {
        Skinned,
        Static,
        Count
    };
};

struct DamageEventCoreData
{
    int32_t chunkIndexInAsset;  
    PxVec3  position;           
    float   damage;             
    float   radius;             
};

struct ImpactDamageEventData : public DamageEventCoreData
{
    nvidia::DestructibleActor*  destructible;       
    PxVec3                      direction;          
    physx::PxActor const*       impactDamageActor;  
};

class UserImpactDamageReport
{
public:
    virtual void    onImpactDamageNotify(const ImpactDamageEventData* buffer, uint32_t bufferSize) = 0;
};

template<typename DestructibleSyncHeader>
class UserDestructibleSyncHandler
{
public:
    virtual void    onWriteBegin(DestructibleSyncHeader *& bufferStart, uint32_t bufferSize) = 0;
    
    virtual void    onWriteDone(uint32_t headerCount) = 0;
    
    virtual void    onPreProcessReadBegin(DestructibleSyncHeader *& bufferStart, uint32_t & bufferSize, bool & continuePointerSwizzling) = 0;
    
    virtual void    onPreProcessReadDone(uint32_t headerCount) = 0;
    
    virtual void    onReadBegin(const DestructibleSyncHeader *& bufferStart) = 0;
    
    virtual void    onReadDone(const char * debugMessage) = 0;
protected:
    virtual ~UserDestructibleSyncHandler() {}
};

/*** Sync-able Damage Data ***/

struct DamageEventUnit;
struct DamageEventHeader
{
    uint32_t                    userActorID;            
    uint32_t                    damageEventCount;       
    DamageEventUnit *           damageEventBufferStart; 
    DamageEventHeader *         next;                   
};

struct DamageEventUnit
{
    uint32_t    chunkIndex;         
    uint32_t    damageEventFlags;   
    float       damage;             
    float       momentum;           
    float       radius;             
    PxVec3      position;           
    PxVec3      direction;          
};

/*** Sync-able Fracture Data ***/

struct FractureEventUnit;

struct FractureEventHeader
{
    uint32_t                    userActorID;                
    uint32_t                    fractureEventCount;         
    FractureEventUnit *         fractureEventBufferStart;   
    FractureEventHeader *       next;                       
};

struct FractureEventUnit
{
    uint32_t    chunkIndex;         
    uint32_t    fractureEventFlags; 
    PxVec3      position;           
    PxVec3      direction;          
    PxVec3      impulse;            
};

/*** Sync-able Transform Data ***/

struct ChunkTransformUnit;

struct ChunkTransformHeader
{
    uint32_t                    userActorID;                
    uint32_t                    chunkTransformCount;        
    ChunkTransformUnit *        chunkTransformBufferStart;  
    ChunkTransformHeader *      next;                       
};

struct ChunkTransformUnit
{
    uint32_t    chunkIndex;         
    PxVec3      chunkPosition;      
    PxQuat      chunkOrientation;   
};


struct DestructibleActorRaycastFlags
{
    enum Enum
    {
        NoChunks =      (0),
        StaticChunks =  (1 << 0),
        DynamicChunks = (1 << 1),

        AllChunks =                 StaticChunks | DynamicChunks,

        SegmentIntersect =  (1 << 2),   

        ForceAccurateRaycastsOn =   (1 << 3),
        ForceAccurateRaycastsOff =  (1 << 4),
    };
};


struct DestructibleCallbackSchedule
{
    enum Enum
    {
        Disabled =      (0),
        BeforeTick,     
        FetchResults,   

        Count
    };
};


class ModuleDestructible : public Module
{
public:
    virtual DestructibleActorJoint*         createDestructibleActorJoint(const DestructibleActorJointDesc& desc, Scene& scene) = 0;

    virtual bool                            isDestructibleActorJointActive(const DestructibleActorJoint* candidateJoint, Scene& apexScene) const = 0;

    virtual void                            setMaxDynamicChunkIslandCount(uint32_t maxCount) = 0;

    virtual void                            setMaxChunkCount(uint32_t maxCount) = 0;

    virtual void                            setSortByBenefit(bool sortByBenefit) = 0;

    virtual void                            setValidBoundsPadding(float pad) = 0;

    virtual void                            setMaxChunkDepthOffset(uint32_t maxChunkDepthOffset) = 0;

    virtual void                            setMaxChunkSeparationLOD(float separationLOD) = 0;


    virtual void                            setChunkReport(UserChunkReport* chunkReport) = 0;

    virtual void                            setImpactDamageReportCallback(UserImpactDamageReport* impactDamageReport) = 0;

    virtual void                            setChunkReportBitMask(uint32_t chunkReportBitMask) = 0;

    virtual void                            setDestructiblePhysXActorReport(UserDestructiblePhysXActorReport* destructiblePhysXActorReport) = 0;

    virtual void                            setChunkReportMaxFractureEventDepth(uint32_t chunkReportMaxFractureEventDepth) = 0;

    virtual void                            scheduleChunkStateEventCallback(DestructibleCallbackSchedule::Enum chunkStateEventCallbackSchedule) = 0;

    virtual void                            setChunkCrumbleReport(UserChunkParticleReport* chunkCrumbleReport) = 0;

    virtual void                            setChunkDustReport(UserChunkParticleReport* chunkDustReport) = 0;

    virtual void                            setWorldSupportPhysXScene(Scene& apexScene, PxScene* physxScene) = 0;

    virtual bool                            owns(const PxRigidActor* actor) const = 0;

#if APEX_RUNTIME_FRACTURE

    virtual bool                            isRuntimeFractureShape(const PxShape& shape) const = 0;
#endif

    virtual DestructibleActor*              getDestructibleAndChunk(const PxShape* shape, int32_t* chunkIndex = NULL) const = 0;

    virtual void                            applyRadiusDamage(Scene& scene, float damage, float momentum,
            const PxVec3& position, float radius, bool falloff) = 0;

    virtual void                            setMaxActorCreatesPerFrame(uint32_t maxActorsPerFrame) = 0;

    virtual void                            setMaxFracturesProcessedPerFrame(uint32_t maxFracturesProcessedPerFrame) = 0;

    virtual bool                            setSyncParams(UserDestructibleSyncHandler<DamageEventHeader> * userDamageEventHandler, UserDestructibleSyncHandler<FractureEventHeader> * userFractureEventHandler, UserDestructibleSyncHandler<ChunkTransformHeader> * userChunkMotionHandler) = 0;

    virtual void                            setUseLegacyChunkBoundsTesting(bool useLegacyChunkBoundsTesting) = 0;

    virtual void                            setUseLegacyDamageRadiusSpread(bool useLegacyDamageRadiusSpread) = 0;

    virtual bool                            setMassScaling(float massScale, float scaledMassExponent, Scene& apexScene) = 0;

    virtual void                            invalidateBounds(const PxBounds3* bounds, uint32_t boundsCount, Scene& apexScene) = 0;

    virtual void                            setDamageApplicationRaycastFlags(nvidia::DestructibleActorRaycastFlags::Enum flags, Scene& apexScene) = 0;

    virtual bool                            setChunkCollisionHullCookingScale(const PxVec3& scale) = 0;

    virtual PxVec3                          getChunkCollisionHullCookingScale() const = 0;

    virtual class FractureToolsAPI*         getFractureTools() const = 0;

protected:
    virtual                                 ~ModuleDestructible() {}
};


#if !defined(_USRDLL)

void instantiateModuleDestructible();
#endif

PX_POP_PACK

}
} // end namespace nvidia

#endif // MODULE_DESTRUCTIBLE_H