DestructibleActor.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_ACTOR_H
#define DESTRUCTIBLE_ACTOR_H

#include "foundation/Px.h"
#include "Actor.h"
#include "Renderable.h"
#include "ModuleDestructible.h"
#include "PxForceMode.h"

namespace physx
{
    class PxRigidDynamic;
};

#define DESTRUCTIBLE_ACTOR_TYPE_NAME "DestructibleActor"

namespace nvidia
{
namespace apex
{

PX_PUSH_PACK_DEFAULT

struct DestructibleParameters;
class RenderVolume;
class EmitterActor;
class DestructibleRenderable;
class DestructibleBehaviorGroupDesc;


struct DestructibleEmitterType
{
    enum Enum
    {
        Crumble,
        Dust,   // Note: this is a placeholder.  Its implementation has been removed in 1.2.0, and will be restored in later versions.
        Count
    };
};

struct DestructibleParameterizedType
{
    enum Enum
    {
        State,  // The full state of the actor (including params, chunk data, etc...)
        Params, // The parameters used to initialize the actor
    };
};

struct DestructibleHitChunk
{
    uint32_t chunkIndex;    
    uint32_t hitChunkFlags; 
};

struct DestructibleActorSyncFlags
{
    enum Enum
    {
        None                = 0,
        CopyDamageEvents    = (1 << 0),
        ReadDamageEvents    = (1 << 1),
        CopyFractureEvents  = (1 << 2),
        ReadFractureEvents  = (1 << 3),
        CopyChunkTransform  = (1 << 4),
        ReadChunkTransform  = (1 << 5),
        Last                = (1 << 6),
    };
};

struct DestructiblePhysXActorQueryFlags
{
    enum Enum
    {
        None = 0,

        // Actor states
        Static = (1 << 0),  
        Dynamic = (1 << 1), 
        Dormant = (1 << 2), 

        AllStates = Static | Dynamic | Dormant,

        // Other filters
        AllowRedundancy = (1 << 3),

        AllowActorsNotInScenes = (1 << 4)
    };
};

struct DestructibleActorSyncState
{
    uint32_t    damageEventFilterDepth;     
    uint32_t    fractureEventFilterDepth;   
};

struct DestructibleChunkSyncState
{
    bool        disableTransformBuffering;  
    bool        excludeSleepingChunks;      
    uint32_t    chunkTransformCopyDepth;    
};

struct DestructibleActorChunkFlags
{
    enum Enum
    {
        ChunkIsWorldSupported   =   (1<<0),
    };
};

class DestructibleActor : public Actor, public Renderable
#if PX_PHYSICS_VERSION_MAJOR == 3
    , public ActorSource
#endif
{
public:
    virtual const RenderMeshActor*  getRenderMeshActor(DestructibleActorMeshType::Enum type = DestructibleActorMeshType::Skinned) const = 0;

    virtual const DestructibleParameters& getDestructibleParameters() const = 0;

    virtual void                    setDestructibleParameters(const DestructibleParameters& destructibleParameters) = 0;

    virtual PxMat44                 getInitialGlobalPose() const = 0;

    virtual void                    setInitialGlobalPose(const PxMat44& pose) = 0;

    virtual PxVec3                  getScale() const = 0;

    virtual bool                    isInitiallyDynamic() const = 0;

    virtual void                    getChunkVisibilities(uint8_t* visibilityArray, uint32_t visibilityArraySize) const = 0;

    virtual uint32_t                getNumVisibleChunks() const = 0;

    virtual const uint16_t*         getVisibleChunks() const = 0;

    virtual bool                    acquireChunkEventBuffer(const nvidia::DestructibleChunkEvent*& buffer, uint32_t& bufferSize) = 0;

    virtual bool                    releaseChunkEventBuffer(bool clearBuffer = true) = 0;

    virtual bool                    acquirePhysXActorBuffer(physx::PxRigidDynamic**& buffer, uint32_t& bufferSize, uint32_t flags = DestructiblePhysXActorQueryFlags::AllStates) = 0;

    virtual bool                    releasePhysXActorBuffer() = 0;

    virtual physx::PxRigidDynamic*  getChunkPhysXActor(uint32_t chunkIndex) = 0;

    virtual uint32_t                getChunkPhysXShapes(physx::PxShape**& shapes, uint32_t chunkIndex) const = 0;

    virtual PxTransform             getChunkPose(uint32_t chunkIndex) const = 0;

    virtual PxTransform             getChunkTransform(uint32_t chunkIndex) const = 0;

    virtual PxVec3                  getChunkLinearVelocity(uint32_t chunkIndex) const = 0;

    virtual PxVec3                  getChunkAngularVelocity(uint32_t chunkIndex) const = 0;

    virtual const PxMat44           getChunkTM(uint32_t chunkIndex) const = 0;

    virtual int32_t                 getChunkBehaviorGroupIndex(uint32_t chunkIndex) const = 0;

    virtual uint32_t                getChunkActorFlags(uint32_t chunkIndex) const = 0;

    virtual void                    setGlobalPose(const PxMat44& pose) = 0;

    virtual bool                    getGlobalPose(PxMat44& pose) = 0;

    virtual void                    setLinearVelocity(const PxVec3& linearVelocity) = 0;

    virtual void                    setAngularVelocity(const PxVec3& angularVelocity) = 0;

    virtual void                    setDynamic(int32_t chunkIndex = ModuleDestructibleConst::INVALID_CHUNK_INDEX) = 0;

    virtual bool                    isDynamic(uint32_t chunkIndex) const = 0;

    virtual void                    enableHardSleeping() = 0;

    virtual void                    disableHardSleeping(bool wake = false)= 0;

    virtual bool                    isHardSleepingEnabled() const = 0;

    virtual bool                    setChunkPhysXActorAwakeState(uint32_t chunkIndex, bool awake) = 0;

    virtual bool                    addForce(uint32_t chunkIndex, const PxVec3& force, physx::PxForceMode::Enum mode, const PxVec3* position = NULL, bool wakeup = true) = 0;

    virtual void                    setSkinnedOverrideMaterial(uint32_t submeshIndex, const char* overrideMaterialName) = 0;

    virtual void                    setStaticOverrideMaterial(uint32_t submeshIndex, const char* overrideMaterialName) = 0;

    virtual void                    setRuntimeFractureOverridePattern(const char* overridePatternName) = 0;

    virtual void                    applyDamage(float damage, float momentum, const PxVec3& position, const PxVec3& direction, int32_t chunkIndex = ModuleDestructibleConst::INVALID_CHUNK_INDEX, void* damageUserData = NULL) = 0;

    virtual void                    applyRadiusDamage(float damage, float momentum, const PxVec3& position, float radius, bool falloff, void* damageUserData = NULL) = 0;

    virtual void                    takeImpact(const PxVec3& force, const PxVec3& position, uint16_t chunkIndex, PxActor const* damageImpactActor) = 0;

    virtual int32_t                 rayCast(float& time, PxVec3& normal, const PxVec3& worldRayOrig, const PxVec3& worldRayDir, DestructibleActorRaycastFlags::Enum flags, int32_t parentChunkIndex = ModuleDestructibleConst::INVALID_CHUNK_INDEX) const = 0;

    virtual int32_t                 obbSweep(float& time, PxVec3& normal, const PxVec3& worldBoxCenter, const PxVec3& worldBoxExtents, const PxMat33& worldBoxRot, const PxVec3& worldDisplacement, DestructibleActorRaycastFlags::Enum flags) const = 0;

    virtual void                    setCrumbleEmitterState(bool enable) = 0;

    virtual void                    setDustEmitterState(bool enable) = 0;

    virtual void                    setPreferredRenderVolume(RenderVolume* volume, DestructibleEmitterType::Enum type) = 0;


    virtual EmitterActor*           getApexEmitter(DestructibleEmitterType::Enum type) = 0;

    virtual bool                    recreateApexEmitter(DestructibleEmitterType::Enum type) = 0;

    virtual const ::NvParameterized::Interface* getNvParameterized(DestructibleParameterizedType::Enum type = DestructibleParameterizedType::State) const = 0;

    virtual void                    setNvParameterized(::NvParameterized::Interface*) = 0;

    virtual bool                    setSyncParams(uint32_t userActorID, uint32_t actorSyncFlags = 0, const DestructibleActorSyncState * actorSyncState = NULL, const DestructibleChunkSyncState * chunkSyncState = NULL) = 0;

    virtual bool                    setHitChunkTrackingParams(bool flushHistory, bool startTracking, uint32_t trackingDepth, bool trackAllChunks = true) = 0;

    virtual bool                    getHitChunkHistory(const DestructibleHitChunk *& hitChunkContainer, uint32_t & hitChunkCount) const = 0;

    virtual bool                    forceChunkHits(const DestructibleHitChunk * hitChunkContainer, uint32_t hitChunkCount, bool removeChunks = true, bool deferredEvent = false, PxVec3 damagePosition = PxVec3(0.0f), PxVec3 damageDirection = PxVec3(0.0f)) = 0;

    virtual bool                    getDamageColoringHistory(const DamageEventCoreData *& damageEventCoreDataContainer, uint32_t & damageEventCoreDataCount) const = 0;

    virtual bool                    forceDamageColoring(const DamageEventCoreData * damageEventCoreDataContainer, uint32_t damageEventCoreDataCount) = 0;

    virtual PxBounds3               getLocalBounds() const = 0;

    virtual PxBounds3               getOriginalBounds() const = 0;

    virtual bool                    isChunkSolitary(int32_t chunkIndex) const = 0;

    virtual PxBounds3               getChunkBounds(uint32_t chunkIndex) const = 0;

    virtual PxBounds3               getChunkLocalBounds(uint32_t chunkIndex) const = 0;

    virtual bool                    isChunkDestroyed(int32_t chunkIndex) const = 0;

    virtual uint32_t                getSupportDepthChunkIndices(uint32_t* const OutChunkIndices, uint32_t MaxOutIndices) const = 0;

    virtual uint32_t                getSupportDepth() const = 0;

    virtual void                    setDeleteFracturedChunks(bool inDeleteChunkMode) = 0;

    virtual DestructibleRenderable* acquireRenderableReference() = 0;

    virtual uint32_t                getCustomBehaviorGroupCount() const = 0;

    virtual bool                    getBehaviorGroup(nvidia::DestructibleBehaviorGroupDesc& behaviorGroupDesc, int32_t index = -1) const = 0;

protected:
    virtual                         ~DestructibleActor() {}
};

PX_POP_PACK

}
} // end namespace nvidia

#endif // DESTRUCTIBLE_ACTOR_H